cadical 0.9.0

data/ext/cadical/cadical/src/util.cpp

@@ -0,0 +1,129 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+/*------------------------------------------------------------------------*/
+
+bool parse_int_str (const char *val_str, int &val) {
+  if (!strcmp (val_str, "true"))
+    val = 1;
+  else if (!strcmp (val_str, "false"))
+    val = 0;
+  else {
+    const char *p = val_str;
+    int sign;
+
+    if (*p == '-')
+      sign = -1, p++;
+    else
+      sign = 1;
+
+    int ch;
+    if (!isdigit ((ch = *p++)))
+      return false;
+
+    const int64_t bound = -(int64_t) INT_MIN;
+    int64_t mantissa = ch - '0';
+
+    while (isdigit (ch = *p++)) {
+      if (bound / 10 < mantissa)
+        mantissa = bound;
+      else
+        mantissa *= 10;
+      const int digit = ch - '0';
+      if (bound - digit < mantissa)
+        mantissa = bound;
+      else
+        mantissa += digit;
+    }
+
+    int exponent = 0;
+    if (ch == 'e') {
+      while (isdigit ((ch = *p++)))
+        exponent = exponent ? 10 : ch - '0';
+      if (ch)
+        return false;
+    } else if (ch)
+      return false;
+
+    assert (exponent <= 10);
+    int64_t val64 = mantissa;
+    for (int i = 0; i < exponent; i++)
+      val64 *= 10;
+
+    if (sign < 0) {
+      val64 = -val64;
+      if (val64 < INT_MIN)
+        val64 = INT_MIN;
+    } else {
+      if (val64 > INT_MAX)
+        val64 = INT_MAX;
+    }
+
+    assert (INT_MIN <= val64);
+    assert (val64 <= INT_MAX);
+
+    val = val64;
+  }
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool has_suffix (const char *str, const char *suffix) {
+  size_t k = strlen (str), l = strlen (suffix);
+  return k > l && !strcmp (str + k - l, suffix);
+}
+
+bool has_prefix (const char *str, const char *prefix) {
+  for (const char *p = str, *q = prefix; *q; q++, p++)
+    if (*q != *p)
+      return false;
+  return true;
+}
+
+/*------------------------------------------------------------------------*/
+
+bool is_color_option (const char *arg) {
+  return !strcmp (arg, "--color") || !strcmp (arg, "--colors") ||
+         !strcmp (arg, "--colour") || !strcmp (arg, "--colours") ||
+         !strcmp (arg, "--color=1") || !strcmp (arg, "--colors=1") ||
+         !strcmp (arg, "--colour=1") || !strcmp (arg, "--colours=1") ||
+         !strcmp (arg, "--color=true") || !strcmp (arg, "--colors=true") ||
+         !strcmp (arg, "--colour=true") || !strcmp (arg, "--colours=true");
+}
+
+bool is_no_color_option (const char *arg) {
+  return !strcmp (arg, "--no-color") || !strcmp (arg, "--no-colors") ||
+         !strcmp (arg, "--no-colour") || !strcmp (arg, "--no-colours") ||
+         !strcmp (arg, "--color=0") || !strcmp (arg, "--colors=0") ||
+         !strcmp (arg, "--colour=0") || !strcmp (arg, "--colours=0") ||
+         !strcmp (arg, "--color=false") ||
+         !strcmp (arg, "--colors=false") ||
+         !strcmp (arg, "--colour=false") ||
+         !strcmp (arg, "--colours=false");
+}
+
+/*------------------------------------------------------------------------*/
+
+static uint64_t primes[] = {
+    1111111111111111111lu, 2222222222222222249lu, 3333333333333333347lu,
+    4444444444444444537lu, 5555555555555555621lu, 6666666666666666677lu,
+    7777777777777777793lu, 8888888888888888923lu, 9999999999999999961lu,
+};
+
+uint64_t hash_string (const char *str) {
+  const unsigned size = sizeof primes / sizeof *primes;
+  uint64_t res = 0;
+  unsigned char ch;
+  unsigned i = 0;
+  for (const char *p = str; (ch = *p); p++) {
+    res += ch;
+    res *= primes[i++];
+    if (i == size)
+      i = 0;
+  }
+  return res;
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/util.hpp

@@ -0,0 +1,181 @@
+#ifndef _util_hpp_INCLUDED
+#define _util_hpp_INCLUDED
+
+#include <cassert>
+#include <cstdint>
+#include <vector>
+
+namespace CaDiCaL {
+
+using namespace std;
+
+// Common simple utility functions independent from 'Internal'.
+
+/*------------------------------------------------------------------------*/
+
+inline double relative (double a, double b) { return b ? a / b : 0; }
+inline double percent (double a, double b) { return relative (100 * a, b); }
+inline int sign (int lit) { return (lit > 0) - (lit < 0); }
+inline unsigned bign (int lit) { return 1 + (lit < 0); }
+
+/*------------------------------------------------------------------------*/
+
+bool has_suffix (const char *str, const char *suffix);
+bool has_prefix (const char *str, const char *prefix);
+
+/*------------------------------------------------------------------------*/
+
+// Parse integer string in the form of
+//
+//   true
+//   false
+//   [-]<mantissa>[e<exponent>]
+//
+// and in the latter case '<val>' has to be within [-INT_MAX,INT_MAX].
+//
+// The function returns true if parsing is successful and then also sets
+// the second argument to the parsed value.
+
+bool parse_int_str (const char *str, int &);
+
+/*------------------------------------------------------------------------*/
+
+inline bool is_power_of_two (unsigned n) { return n && !(n & (n - 1)); }
+
+inline bool contained (int64_t c, int64_t l, int64_t u) {
+  return l <= c && c <= u;
+}
+
+inline bool aligned (size_t n, size_t alignment) {
+  assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  return !(n & mask);
+}
+
+inline size_t align (size_t n, size_t alignment) {
+  size_t res = n;
+  assert (is_power_of_two (alignment));
+  const size_t mask = alignment - 1;
+  if (res & mask)
+    res = (res | mask) + 1;
+  assert (aligned (res, alignment));
+  return res;
+}
+
+/*------------------------------------------------------------------------*/
+
+inline bool parity (unsigned a) {
+  assert (sizeof a == 4);
+  unsigned tmp = a;
+  tmp ^= (tmp >> 16);
+  tmp ^= (tmp >> 8);
+  tmp ^= (tmp >> 4);
+  tmp ^= (tmp >> 2);
+  tmp ^= (tmp >> 1);
+  return tmp & 1;
+}
+
+/*------------------------------------------------------------------------*/
+
+// The standard 'Effective STL' way (though not guaranteed) to clear a
+// vector and reduce its capacity to zero, thus deallocating all its
+// internal memory.  This is quite important for keeping the actual
+// allocated size of watched and occurrence lists small particularly during
+// bounded variable elimination where many clauses are added and removed.
+
+template <class T> void erase_vector (std::vector<T> &v) {
+  if (v.capacity ()) {
+    std::vector<T> ().swap (v);
+  }
+  assert (!v.capacity ()); // not guaranteed though
+}
+
+// The standard 'Effective STL' way (though not guaranteed) to shrink the
+// capacity of a vector to its size thus kind of releasing all the internal
+// excess memory not needed at the moment any more.
+
+template <class T> void shrink_vector (std::vector<T> &v) {
+  if (v.capacity () > v.size ()) {
+    std::vector<T> (v).swap (v);
+  }
+  assert (v.capacity () == v.size ()); // not guaranteed though
+}
+
+template <class T>
+static void enlarge_init (vector<T> &v, size_t N, const T &i) {
+  if (v.size () < N)
+    v.resize (N, i);
+}
+
+template <class T> static void enlarge_only (vector<T> &v, size_t N) {
+  if (v.size () < N)
+    v.resize (N, T ());
+}
+
+template <class T> static void enlarge_zero (vector<T> &v, size_t N) {
+  enlarge_init (v, N, (const T &) 0);
+}
+
+// double the capacity until it fits. This is different from reserve
+// that will allocate exactly the size requested, meaning that the
+// amortized complexity is lost.
+template <class T> static void reserve_at_least (vector<T> &v, size_t N) {
+  if (N < v.capacity ())
+    return;
+  size_t new_size = v.size ();
+  if (!new_size)
+    new_size = N;
+  while (new_size < N)
+    new_size *= 2;
+  v.reserve (new_size);
+}
+
+// Clean-up class for bad_alloc error safety.
+
+template <typename T> struct DeferDeleteArray {
+  T *data;
+  DeferDeleteArray (T *t) : data (t) {}
+  ~DeferDeleteArray () { delete[] data; }
+  void release () { data = nullptr; }
+  void free () {
+    delete[] data;
+    data = nullptr;
+  }
+};
+
+template <typename T> struct DeferDeletePtr {
+  T *data;
+  DeferDeletePtr (T *t) : data (t) {}
+  ~DeferDeletePtr () { delete data; }
+  void release () { data = nullptr; }
+  void free () {
+    delete data;
+    data = nullptr;
+  }
+};
+
+/*------------------------------------------------------------------------*/
+
+template <class T> inline void clear_n (T *base, size_t n) {
+  memset (base, 0, sizeof (T) * n);
+}
+
+/*------------------------------------------------------------------------*/
+
+// These are options both to 'cadical' and 'mobical'.  After wasting some
+// on not remembering the spelling (British vs American), nor singular vs
+// plural and then wanted to use '--color=false', and '--colours=0' too, I
+// just factored this out into these two utility functions.
+
+bool is_color_option (const char *arg);    // --color, --colour, ...
+bool is_no_color_option (const char *arg); // --no-color, --no-colour, ...
+
+/*------------------------------------------------------------------------*/
+
+uint64_t hash_string (const char *str);
+
+/*------------------------------------------------------------------------*/
+
+} // namespace CaDiCaL
+
+#endif

data/ext/cadical/cadical/src/var.cpp

@@ -0,0 +1,39 @@
+#include "internal.hpp"
+
+namespace CaDiCaL {
+
+void Internal::reset_subsume_bits () {
+  LOG ("marking all variables as not subsume");
+  for (auto idx : vars)
+    flags (idx).subsume = false;
+}
+
+void Internal::check_var_stats () {
+#ifndef NDEBUG
+  int64_t fixed = 0, eliminated = 0, substituted = 0, pure = 0, unused = 0;
+  for (auto idx : vars) {
+    Flags &f = flags (idx);
+    if (f.active ())
+      continue;
+    if (f.fixed ())
+      fixed++;
+    if (f.eliminated ())
+      eliminated++;
+    if (f.substituted ())
+      substituted++;
+    if (f.unused ())
+      unused++;
+    if (f.pure ())
+      pure++;
+  }
+  assert (stats.now.fixed == fixed);
+  assert (stats.now.eliminated == eliminated);
+  assert (stats.now.substituted == substituted);
+  assert (stats.now.pure == pure);
+  int64_t inactive = unused + fixed + eliminated + substituted + pure;
+  assert (stats.inactive == inactive);
+  assert (max_var == stats.active + stats.inactive);
+#endif
+}
+
+} // namespace CaDiCaL

data/ext/cadical/cadical/src/var.hpp

@@ -0,0 +1,22 @@
+#ifndef _var_hpp_INCLUDED
+#define _var_hpp_INCLUDED
+
+namespace CaDiCaL {
+
+struct Clause;
+
+// This structure captures data associated with an assigned variable.
+
+struct Var {
+
+  // Note that none of these members is valid unless the variable is
+  // assigned.  During unassigning a variable we do not reset it.
+
+  int level;      // decision level
+  int trail;      // trail height at assignment
+  Clause *reason; // implication graph edge during search
+};
+
+} // namespace CaDiCaL
+
+#endif