Introduce cube data structure

* README, configure.ac, spot/Makefile.am,
spot/twacube/Makefile.am, spot/twacube/cube.cc,
spot/twacube/cube.hh, tests/Makefile.am,
tests/core/.gitignore, tests/core/cube.cc,
tests/core/cube.test: here.

spot/twacube/cube.cc

@@ -0,0 +1,167 @@
+// -*- coding: utf-8 -*-
+// Copyright (C) 2015, 2016 Laboratoire de Recherche et Developpement de
+// l'Epita (LRDE).
+//
+// This file is part of Spot, a model checking library.
+//
+// Spot is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 3 of the License, or
+// (at your option) any later version.
+//
+// Spot is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+// or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+// License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include <sstream>
+#include <iostream>
+#include <spot/twacube/cube.hh>
+#include <assert.h>
+
+namespace spot
+{
+  cubeset::cubeset(int aps)
+  {
+    size_ = aps;
+    nb_bits_ = sizeof(unsigned int) * CHAR_BIT;
+    uint_size_ = 1;
+    while ((aps = aps -  nb_bits_)>0)
+      ++uint_size_;
+  }
+
+  cubeset::~cubeset()
+  { }
+
+  cube cubeset::alloc() const
+  {
+    auto* res = new unsigned int[2*uint_size_];
+    for (unsigned int i = 0; i < 2*uint_size_; ++i)
+      res[i] = 0;
+    return res;
+  }
+
+  void cubeset::set_true_var(cube c, unsigned int x) const
+  {
+    *(c+x/nb_bits_) |= 1 << (x%nb_bits_);
+    *(c+uint_size_+x/nb_bits_) &= ~(1 << (x%nb_bits_));
+  }
+
+  void cubeset::set_false_var(cube c, unsigned int x) const
+  {
+    *(c+uint_size_+x/nb_bits_) |= 1 << (x%nb_bits_);
+    *(c+x/nb_bits_) &= ~(1 << (x%nb_bits_));
+  }
+
+  bool cubeset::is_true_var(cube c, unsigned int x) const
+  {
+    unsigned int i = x/nb_bits_;
+    bool true_var = (*(c+i) >> x) & 1;
+    bool false_var = (*(c+i+uint_size_) >> x) & 1;
+    return true_var && !false_var;
+  }
+
+  bool cubeset::is_false_var(cube c, unsigned int x) const
+  {
+    unsigned int i = x/nb_bits_;
+    bool true_var = (*(c+i) >> x) & 1;
+    bool false_var = (*(c+i+uint_size_) >> x) & 1;
+    return !true_var && false_var;
+  }
+
+  bool cubeset::intersect(const cube lhs, const cube rhs) const
+  {
+    unsigned int true_elt;
+    unsigned int false_elt;
+    bool incompatible = false;
+    for (unsigned int i = 0; i < uint_size_ && !incompatible; ++i)
+      {
+	true_elt = *(lhs+i) | *(rhs+i);
+	false_elt = *(lhs+i+uint_size_) | *(rhs+i+uint_size_);
+	incompatible |=  (true_elt & false_elt);
+      }
+    return !incompatible;
+  }
+
+  cube cubeset::intersection(const cube lhs, const cube rhs) const
+  {
+    auto* res = new unsigned int[2*uint_size_];
+    for (unsigned int i = 0; i < uint_size_; ++i)
+      {
+	res[i] = *(lhs+i) | *(rhs+i);
+	res[i+uint_size_] = *(lhs+i+uint_size_) | *(rhs+i+uint_size_);
+      }
+    return res;
+  }
+
+  bool cubeset::is_valid(const cube lhs) const
+  {
+    bool incompatible = false;
+    for (unsigned int i = 0; i < uint_size_ && !incompatible; ++i)
+      incompatible |= *(lhs+i) & *(lhs+i+uint_size_);
+    return !incompatible;
+  }
+
+  size_t cubeset::size() const
+  {
+    return size_;
+  }
+
+  void cubeset::release(cube c) const
+  {
+    delete[] c;
+  }
+
+  void cubeset::display(const cube c) const
+  {
+    for (unsigned int i = 0; i < 2*uint_size_; ++i)
+      {
+	if (i == uint_size_)
+	  std::cout << '\n';
+
+	for (unsigned x = 0; x < nb_bits_; ++x)
+	  std::cout << ((*(c+i) >> x) & 1);
+      }
+    std::cout << '\n';
+  }
+
+  std::string cubeset::dump(cube c, const std::vector<std::string>& aps) const
+  {
+    std::ostringstream oss;
+    bool all_free = true;
+    unsigned int cpt = 0;
+    for (unsigned int i = 0; i < uint_size_; ++i)
+      {
+	for (unsigned x = 0; x < nb_bits_ && cpt != size_; ++x)
+	  {
+	    bool true_var = (*(c+i) >> x) & 1;
+	    bool false_var = (*(c+i+uint_size_) >> x) & 1;
+	    if (true_var)
+	      {
+		oss << aps[cpt]
+		    << (cpt != (size_ - 1) ? "&": "");
+		all_free = false;
+	      }
+	    else if (false_var)
+	      {
+		oss << '!' << aps[cpt]
+		    << (cpt != (size_ - 1) ? "&": "");
+		all_free = false;
+	      }
+	    ++cpt;
+	  }
+      }
+    if (all_free)
+      oss << '1';
+
+    std::string res = oss.str();
+    if (res.back() == '&')
+      res.pop_back();
+    if (res.front() == '&')
+      res =  res.substr(1);
+    return res;
+  }
+}