python-sat 1.9.dev2__tar.gz → 1.9.dev4__tar.gz

{python_sat-1.9.dev2/python_sat.egg-info → python_sat-1.9.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev2
+Version: 1.9.dev4
 Summary: A Python library for prototyping with SAT oracles
 Home-page: https://github.com/pysathq/pysat
 Author: Alexey Ignatiev, Joao Marques-Silva, Antonio Morgado

{python_sat-1.9.dev2 → python_sat-1.9.dev4}/README.rst

@@ -66,6 +66,7 @@ Minisat-based solvers only *core* versions are integrated):
 -  CaDiCaL (`rel-1.0.3 <https://github.com/arminbiere/cadical>`__)
 -  CaDiCaL (`rel-1.5.3 <https://github.com/arminbiere/cadical>`__)
 -  CaDiCaL (`rel-1.9.5 <https://github.com/arminbiere/cadical>`__)
+-  CaDiCaL (`rel-3.0.0 <https://github.com/arminbiere/cadical>`__)
 -  Glucose (`3.0 <http://www.labri.fr/perso/lsimon/glucose/>`__)
 -  Glucose (`4.1 <http://www.labri.fr/perso/lsimon/glucose/>`__)
 -  Glucose (`4.2.1 <http://www.labri.fr/perso/lsimon/glucose/>`__)
@@ -78,6 +79,7 @@ Minisat-based solvers only *core* versions are integrated):
 -  Minicard (`1.2 <https://github.com/liffiton/minicard>`__)
 -  Minisat (`2.2 release <http://minisat.se/MiniSat.html>`__)
 -  Minisat (`GitHub version <https://github.com/niklasso/minisat>`__)
+-  Minisat (`with IPASIR-UP support <https://github.com/hchenqide/minisat>`__)
 
 In order to make SAT-based prototyping easier, PySAT integrates a variety of
 cardinality encodings. All of them are implemented from scratch in C++. The

{python_sat-1.9.dev2 → python_sat-1.9.dev4}/cardenc/pycard.cc

@@ -11,6 +11,7 @@
 #include <setjmp.h>
 #include <signal.h>
 #include <stdio.h>
+#include <stdint.h>
 #include <Python.h>
 
 #include "card.hh"
@@ -18,6 +19,10 @@
 
 using namespace std;
 
+#ifndef PYCARD_ENABLE_PYINT_CACHE
+#define PYCARD_ENABLE_PYINT_CACHE 1
+#endif
+
 // docstrings
 //=============================================================================
 static char   module_docstring[] = "This module provides an interface for "
@@ -37,6 +42,78 @@ static char itot_del_docstring[] = "Delete an iterative totalizer object";
 static PyObject *CardError;
 static jmp_buf env;
 
+// forward declaration (implemented in Python2/Python3 branches below)
+extern "C" {
+	static PyObject *pyint_from_cint(int i);
+}
+
+#define PYINT_CACHE_SIZE (1u << 8)
+
+typedef struct {
+	int key;
+	PyObject *obj;  // cache-owned reference
+	unsigned char used;
+} PyIntCacheEntry;
+
+typedef struct {
+	PyIntCacheEntry slots[PYINT_CACHE_SIZE];
+	uint16_t used_idx[PYINT_CACHE_SIZE];
+	size_t used_count;
+} PyIntCache;
+
+static inline uint32_t pyint_cache_hash(int v)
+{
+	return ((uint32_t)v * 2654435761u) & (PYINT_CACHE_SIZE - 1u);
+}
+
+static PyObject *pyint_cache_get_or_make(PyIntCache *cache, int v)
+{
+#if PYCARD_ENABLE_PYINT_CACHE
+	uint32_t idx = pyint_cache_hash(v);
+	PyIntCacheEntry *e = &cache->slots[idx];
+	if (e->used && e->key == v) {
+		Py_INCREF(e->obj);  // caller gets one ref
+		return e->obj;
+	}
+
+	PyObject *obj = pyint_from_cint(v);
+	if (obj == NULL)
+		return NULL;
+
+	if (e->used)
+		Py_DECREF(e->obj);
+	else
+		cache->used_idx[cache->used_count++] = (uint16_t)idx;
+
+	e->used = 1;
+	e->key = v;
+	e->obj = obj;      // cache keeps one ref
+
+	Py_INCREF(obj);    // caller gets one ref
+	return obj;
+#else
+	(void)cache;
+	return pyint_from_cint(v);
+#endif
+}
+
+static void pyint_cache_clear(PyIntCache *cache)
+{
+#if PYCARD_ENABLE_PYINT_CACHE
+	for (size_t i = 0; i < cache->used_count; ++i) {
+		PyIntCacheEntry *e = &cache->slots[cache->used_idx[i]];
+		if (e->used) {
+			Py_DECREF(e->obj);
+			e->obj = NULL;
+			e->used = 0;
+		}
+	}
+	cache->used_count = 0;
+#else
+	(void)cache;
+#endif
+}
+
 // function declaration for functions available in module
 //=============================================================================
 extern "C" {
@@ -195,6 +272,40 @@ PyMODINIT_FUNC initpycard(void)
 //=============================================================================
 static bool pyiter_to_vector(PyObject *obj, vector<int>& vect)
 {
+	// Fast path for sequences (list/tuple and sequence-like objects).
+	// This avoids iterator protocol overhead and allows up-front reservation.
+	PyObject *seq = PySequence_Fast(obj, NULL);
+	if (seq != NULL) {
+		Py_ssize_t n = PySequence_Fast_GET_SIZE(seq);
+		if (n > 0)
+			vect.reserve(vect.size() + (size_t)n);
+
+		PyObject **items = PySequence_Fast_ITEMS(seq);
+		for (Py_ssize_t i = 0; i < n; ++i) {
+			PyObject *l_obj = items[i];
+			if (!pyint_check(l_obj)) {
+				Py_DECREF(seq);
+				PyErr_SetString(PyExc_TypeError, "integer expected");
+				return false;
+			}
+
+			int l = pyint_to_cint(l_obj);
+			if (l == 0) {
+				Py_DECREF(seq);
+				PyErr_SetString(PyExc_ValueError, "non-zero integer expected");
+				return false;
+			}
+
+			vect.push_back(l);
+		}
+
+		Py_DECREF(seq);
+		return true;
+	}
+
+	// If this failed because object is not a sequence, continue with iterator path.
+	PyErr_Clear();
+
 	PyObject *i_obj = PyObject_GetIter(obj);
 
 	if (i_obj == NULL) {
@@ -203,6 +314,19 @@ static bool pyiter_to_vector(PyObject *obj, vector<int>& vect)
 		return false;
 	}
 
+	PyObject *hint_obj = PyObject_CallMethod(i_obj, "__length_hint__", NULL);
+	if (hint_obj != NULL) {
+		if (pyint_check(hint_obj)) {
+			int hint = pyint_to_cint(hint_obj);
+			if (hint > 0)
+				vect.reserve(vect.size() + (size_t)hint);
+		}
+		Py_DECREF(hint_obj);
+	}
+	else {
+		PyErr_Clear();
+	}
+
 	PyObject *l_obj;
 	while ((l_obj = PyIter_Next(i_obj)) != NULL) {
 		if (!pyint_check(l_obj)) {
@@ -224,10 +348,72 @@ static bool pyiter_to_vector(PyObject *obj, vector<int>& vect)
 		vect.push_back(l);
 	}
 
+	if (PyErr_Occurred()) {
+		Py_DECREF(i_obj);
+		return false;
+	}
+
 	Py_DECREF(i_obj);
 	return true;
 }
 
+// Auxiliary function for translating ClauseSet to Python list of lists
+//=============================================================================
+static PyObject *clauseset_to_pylist(ClauseSet& dest, PyIntCache *cache)
+{
+	Py_ssize_t ncls = (Py_ssize_t)dest.size();
+	PyObject *dest_obj = PyList_New(ncls);
+	if (dest_obj == NULL)
+		return NULL;
+
+	for (Py_ssize_t i = 0; i < ncls; ++i) {
+		const vector<int> &cl = dest[(size_t)i];
+		Py_ssize_t nlit = (Py_ssize_t)cl.size();
+		PyObject *cl_obj = PyList_New(nlit);
+		if (cl_obj == NULL) {
+			Py_DECREF(dest_obj);
+			return NULL;
+		}
+
+		for (Py_ssize_t j = 0; j < nlit; ++j) {
+			PyObject *lit_obj = pyint_cache_get_or_make(cache, cl[(size_t)j]);
+			if (lit_obj == NULL) {
+				Py_DECREF(cl_obj);
+				Py_DECREF(dest_obj);
+				return NULL;
+			}
+
+			PyList_SET_ITEM(cl_obj, j, lit_obj);
+		}
+
+		PyList_SET_ITEM(dest_obj, i, cl_obj);
+	}
+
+	return dest_obj;
+}
+
+// Auxiliary function for translating vector<int> to Python list
+//=============================================================================
+static PyObject *vector_to_pylist(const vector<int>& vals)
+{
+	Py_ssize_t n = (Py_ssize_t)vals.size();
+	PyObject *lst = PyList_New(n);
+	if (lst == NULL)
+		return NULL;
+
+	for (Py_ssize_t i = 0; i < n; ++i) {
+		PyObject *v_obj = pyint_from_cint(vals[(size_t)i]);
+		if (v_obj == NULL) {
+			Py_DECREF(lst);
+			return NULL;
+		}
+
+		PyList_SET_ITEM(lst, i, v_obj);
+	}
+
+	return lst;
+}
+
 //
 //=============================================================================
 static PyObject *py_encode_atmost(PyObject *self, PyObject *args)
@@ -263,22 +449,28 @@ static PyObject *py_encode_atmost(PyObject *self, PyObject *args)
 	if (main_thread)
 		PyOS_setsig(SIGINT, sig_save);
 
-	// creating the resulting clause set
-	PyObject *dest_obj = PyList_New(dest.size());
-	for (size_t i = 0; i < dest.size(); ++i) {
-		PyObject *cl_obj = PyList_New(dest[i].size());
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
 
-		for (size_t j = 0; j < dest[i].size(); ++j) {
-			PyObject *lit_obj = pyint_from_cint(dest[i][j]);
-			PyList_SetItem(cl_obj, j, lit_obj);
+	if (dest.size()) {
+		PyObject *ret = PyTuple_New(2);
+		if (ret == NULL) {
+			Py_DECREF(dest_obj);
+			return NULL;
 		}
 
-		PyList_SetItem(dest_obj, i, cl_obj);
-	}
+		PyObject *top_obj = pyint_from_cint(top);
+		if (top_obj == NULL) {
+			Py_DECREF(dest_obj);
+			Py_DECREF(ret);
+			return NULL;
+		}
 
-	if (dest.size()) {
-		PyObject *ret = Py_BuildValue("On", dest_obj, (Py_ssize_t)top);
-		Py_DECREF(dest_obj);
+		PyTuple_SET_ITEM(ret, 0, dest_obj);
+		PyTuple_SET_ITEM(ret, 1, top_obj);
 		return ret;
 	}
 	else {
@@ -322,30 +514,34 @@ static PyObject *py_encode_atleast(PyObject *self, PyObject *args)
 	if (main_thread)
 		PyOS_setsig(SIGINT, sig_save);
 
-	// creating the resulting clause set
-	PyObject *dest_obj = PyList_New(dest.size());
-	for (size_t i = 0; i < dest.size(); ++i) {
-		PyObject *cl_obj = PyList_New(dest[i].size());
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
 
-		for (size_t j = 0; j < dest[i].size(); ++j) {
-			PyObject *lit_obj = pyint_from_cint(dest[i][j]);
-			PyList_SetItem(cl_obj, j, lit_obj);
+	if (dest.size()) {
+		PyObject *ret = PyTuple_New(2);
+		if (ret == NULL) {
+			Py_DECREF(dest_obj);
+			return NULL;
 		}
 
-		PyList_SetItem(dest_obj, i, cl_obj);
-	}
+		PyObject *top_obj = pyint_from_cint(top);
+		if (top_obj == NULL) {
+			Py_DECREF(dest_obj);
+			Py_DECREF(ret);
+			return NULL;
+		}
 
-	if (dest.size()) {
-		PyObject *ret = Py_BuildValue("On", dest_obj, (Py_ssize_t)top);
-		Py_DECREF(dest_obj);
+		PyTuple_SET_ITEM(ret, 0, dest_obj);
+		PyTuple_SET_ITEM(ret, 1, top_obj);
 		return ret;
-
 	}
 	else {
 		Py_DECREF(dest_obj);
 		Py_RETURN_NONE;
 	}
-
 }
 
 //
@@ -381,31 +577,43 @@ static PyObject *py_itot_new(PyObject *self, PyObject *args)
 	if (main_thread)
 		PyOS_setsig(SIGINT, sig_save);
 
-	// creating the resulting clause set
-	PyObject *dest_obj = PyList_New(dest.size());
-	for (size_t i = 0; i < dest.size(); ++i) {
-		PyObject *cl_obj = PyList_New(dest[i].size());
-
-		for (size_t j = 0; j < dest[i].size(); ++j) {
-			PyObject *lit_obj = pyint_from_cint(dest[i][j]);
-			PyList_SetItem(cl_obj, j, lit_obj);
-		}
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
 
-		PyList_SetItem(dest_obj, i, cl_obj);
+	PyObject *ubs_obj = vector_to_pylist(tree->vars);
+	if (ubs_obj == NULL) {
+		Py_DECREF(dest_obj);
+		return NULL;
 	}
-
-	// creating the upper-bounds (right-hand side)
-	PyObject *ubs_obj = PyList_New(tree->vars.size());
-	for (size_t i = 0; i < tree->vars.size(); ++i) {
-		PyObject *ub_obj = pyint_from_cint(tree->vars[i]);
-		PyList_SetItem(ubs_obj, i, ub_obj);
+	PyObject *tree_obj = void_to_pyobj((void *)tree);
+	if (tree_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		return NULL;
+	}
+	PyObject *top_obj = pyint_from_cint(top);
+	if (top_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(tree_obj);
+		return NULL;
 	}
 
-	PyObject *ret = Py_BuildValue("OOOn", void_to_pyobj((void *)tree),
-				dest_obj, ubs_obj, (Py_ssize_t)top);
-
-	Py_DECREF(dest_obj);
-	Py_DECREF( ubs_obj);
+	PyObject *ret = PyTuple_New(4);
+	if (ret == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(tree_obj);
+		Py_DECREF(top_obj);
+		return NULL;
+	}
+	PyTuple_SET_ITEM(ret, 0, tree_obj);
+	PyTuple_SET_ITEM(ret, 1, dest_obj);
+	PyTuple_SET_ITEM(ret, 2, ubs_obj);
+	PyTuple_SET_ITEM(ret, 3, top_obj);
 	return ret;
 }
 
@@ -441,30 +649,34 @@ static PyObject *py_itot_inc(PyObject *self, PyObject *args)
 	if (main_thread)
 		PyOS_setsig(SIGINT, sig_save);
 
-	// creating the resulting clause set
-	PyObject *dest_obj = PyList_New(dest.size());
-	for (size_t i = 0; i < dest.size(); ++i) {
-		PyObject *cl_obj = PyList_New(dest[i].size());
-
-		for (size_t j = 0; j < dest[i].size(); ++j) {
-			PyObject *lit_obj = pyint_from_cint(dest[i][j]);
-			PyList_SetItem(cl_obj, j, lit_obj);
-		}
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
 
-		PyList_SetItem(dest_obj, i, cl_obj);
+	PyObject *ubs_obj = vector_to_pylist(tree->vars);
+	if (ubs_obj == NULL) {
+		Py_DECREF(dest_obj);
+		return NULL;
 	}
-
-	// creating the upper-bounds (right-hand side)
-	PyObject *ubs_obj = PyList_New(tree->vars.size());
-	for (size_t i = 0; i < tree->vars.size(); ++i) {
-		PyObject *ub_obj = pyint_from_cint(tree->vars[i]);
-		PyList_SetItem(ubs_obj, i, ub_obj);
+	PyObject *top_obj = pyint_from_cint(top);
+	if (top_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		return NULL;
 	}
 
-	PyObject *ret = Py_BuildValue("OOn", dest_obj, ubs_obj, (Py_ssize_t)top);
-
-	Py_DECREF(dest_obj);
-	Py_DECREF( ubs_obj);
+	PyObject *ret = PyTuple_New(3);
+	if (ret == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(top_obj);
+		return NULL;
+	}
+	PyTuple_SET_ITEM(ret, 0, dest_obj);
+	PyTuple_SET_ITEM(ret, 1, ubs_obj);
+	PyTuple_SET_ITEM(ret, 2, top_obj);
 	return ret;
 }
 
@@ -506,31 +718,43 @@ static PyObject *py_itot_ext(PyObject *self, PyObject *args)
 	if (main_thread)
 		PyOS_setsig(SIGINT, sig_save);
 
-	// creating the resulting clause set
-	PyObject *dest_obj = PyList_New(dest.size());
-	for (size_t i = 0; i < dest.size(); ++i) {
-		PyObject *cl_obj = PyList_New(dest[i].size());
-
-		for (size_t j = 0; j < dest[i].size(); ++j) {
-			PyObject *lit_obj = pyint_from_cint(dest[i][j]);
-			PyList_SetItem(cl_obj, j, lit_obj);
-		}
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
 
-		PyList_SetItem(dest_obj, i, cl_obj);
+	PyObject *ubs_obj = vector_to_pylist(tree->vars);
+	if (ubs_obj == NULL) {
+		Py_DECREF(dest_obj);
+		return NULL;
 	}
-
-	// creating the upper-bounds (right-hand side)
-	PyObject *ubs_obj = PyList_New(tree->vars.size());
-	for (size_t i = 0; i < tree->vars.size(); ++i) {
-		PyObject *ub_obj = pyint_from_cint(tree->vars[i]);
-		PyList_SetItem(ubs_obj, i, ub_obj);
+	PyObject *tree_obj = void_to_pyobj((void *)tree);
+	if (tree_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		return NULL;
+	}
+	PyObject *top_obj = pyint_from_cint(top);
+	if (top_obj == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(tree_obj);
+		return NULL;
 	}
 
-	PyObject *ret = Py_BuildValue("OOOn", void_to_pyobj((void *)tree),
-				dest_obj, ubs_obj, (Py_ssize_t)top);
-
-	Py_DECREF(dest_obj);
-	Py_DECREF( ubs_obj);
+	PyObject *ret = PyTuple_New(4);
+	if (ret == NULL) {
+		Py_DECREF(dest_obj);
+		Py_DECREF(ubs_obj);
+		Py_DECREF(tree_obj);
+		Py_DECREF(top_obj);
+		return NULL;
+	}
+	PyTuple_SET_ITEM(ret, 0, tree_obj);
+	PyTuple_SET_ITEM(ret, 1, dest_obj);
+	PyTuple_SET_ITEM(ret, 2, ubs_obj);
+	PyTuple_SET_ITEM(ret, 3, top_obj);
 	return ret;
 }
 
@@ -569,39 +793,52 @@ static PyObject *py_itot_mrg(PyObject *self, PyObject *args)
 	if (main_thread)
 		PyOS_setsig(SIGINT, sig_save);
 
-	// creating the resulting clause set
-	PyObject *dest_obj = PyList_New(dest.size());
-	for (size_t i = 0; i < dest.size(); ++i) {
-		PyObject *cl_obj = PyList_New(dest[i].size());
-
-		for (size_t j = 0; j < dest[i].size(); ++j) {
-			PyObject *lit_obj = pyint_from_cint(dest[i][j]);
-			PyList_SetItem(cl_obj, j, lit_obj);
-		}
-
-		PyList_SetItem(dest_obj, i, cl_obj);
-	}
+	PyIntCache cache = {};
+	PyObject *dest_obj = clauseset_to_pylist(dest, &cache);
+	pyint_cache_clear(&cache);
+	if (dest_obj == NULL)
+		return NULL;
 
-	// creating the upper-bounds (right-hand side)
-	PyObject *ubs_obj = PyList_New(tree1->vars.size());
-	for (size_t i = 0; i < tree1->vars.size(); ++i) {
-		PyObject *ub_obj = pyint_from_cint(tree1->vars[i]);
-		PyList_SetItem(ubs_obj, i, ub_obj);
+	PyObject *ubs_obj = vector_to_pylist(tree1->vars);
+	if (ubs_obj == NULL) {
+		Py_DECREF(dest_obj);
+		return NULL;
 	}
 
 	if (dest.size()) {
-		PyObject *ret = Py_BuildValue("OOOn", void_to_pyobj((void *)tree1),
-				dest_obj, ubs_obj, (Py_ssize_t)top);
-		Py_DECREF(dest_obj);
-		Py_DECREF( ubs_obj);
+		PyObject *tree_obj = void_to_pyobj((void *)tree1);
+		if (tree_obj == NULL) {
+			Py_DECREF(dest_obj);
+			Py_DECREF(ubs_obj);
+			return NULL;
+		}
+		PyObject *top_obj = pyint_from_cint(top);
+		if (top_obj == NULL) {
+			Py_DECREF(dest_obj);
+			Py_DECREF(ubs_obj);
+			Py_DECREF(tree_obj);
+			return NULL;
+		}
+
+		PyObject *ret = PyTuple_New(4);
+		if (ret == NULL) {
+			Py_DECREF(dest_obj);
+			Py_DECREF(ubs_obj);
+			Py_DECREF(tree_obj);
+			Py_DECREF(top_obj);
+			return NULL;
+		}
+		PyTuple_SET_ITEM(ret, 0, tree_obj);
+		PyTuple_SET_ITEM(ret, 1, dest_obj);
+		PyTuple_SET_ITEM(ret, 2, ubs_obj);
+		PyTuple_SET_ITEM(ret, 3, top_obj);
 		return ret;
 	}
 	else {
 		Py_DECREF(dest_obj);
-		Py_DECREF( ubs_obj);
+		Py_DECREF(ubs_obj);
 		Py_RETURN_NONE;
 	}
-
 }
 
 //