python-sat 1.9.dev5__tar.gz → 1.9.dev7__tar.gz

{python_sat-1.9.dev5/python_sat.egg-info → python_sat-1.9.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev5
+Version: 1.9.dev7
 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.dev5 → python_sat-1.9.dev7}/examples/rc2.py

@@ -409,6 +409,9 @@ class RC2(object):
             :type clause: iterable(int)
             :type weight: int
 
+            :return: selector literal for a soft clause and ``None`` for a hard one
+            :rtype: int or None
+
             .. code-block:: python
 
                 >>> from pysat.examples.rc2 import RC2
@@ -449,6 +452,8 @@ class RC2(object):
                         '{0} does not support native cardinality constraints. Make sure you use the right type of formula.'.format(self.solver)
 
                 self.oracle.add_atmost(cl, clause[1], weights=clause[2] if len(clause) == 3 else [])
+
+            return None
         else:
             # soft clauses should be augmented with a selector
             selv = cl[0]  # for a unit clause, no selector is needed
@@ -472,6 +477,8 @@ class RC2(object):
             self.sall.append(selv)
             self.sels_set.add(selv)
 
+            return selv
+
     def delete(self):
         """
             Explicit destructor of the internal SAT oracle and all the

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/formula/pf_parse.cc

@@ -47,10 +47,14 @@ PyObject *parse_cnf_impl(PyObject *txt_obj, PyObject *comment_lead)
 			continue;
 
 		if (comment_mask[(unsigned char)beg[0]]) {
-			if (!line_starts(beg, lend, "p cnf ")) {
-				if (!append_comment(comments, beg, lend))
-					goto fail;
+			if (line_has_kind(beg, lend, "cnf"))
+				continue;
+			if (line_has_p(beg, lend)) {
+				PyErr_SetString(PyExc_ValueError, "invalid CNF preamble");
+				goto fail;
 			}
+			if (!append_comment(comments, beg, lend))
+				goto fail;
 			continue;
 		}
 
@@ -143,13 +147,17 @@ PyObject *parse_wcnf_impl(PyObject *txt_obj, PyObject *comment_lead)
 			continue;
 
 		if (comment_mask[(unsigned char)beg[0]]) {
-			if (!line_starts(beg, lend, "p wcnf ")) {
-				if (!append_comment(comments, beg, lend))
+			if (line_has_kind(beg, lend, "wcnf")) {
+				if (!parse_weight_preamble(beg, lend,
+						"invalid WCNF preamble", &topw))
 					goto fail;
 			}
+			else if (line_has_p(beg, lend)) {
+				PyErr_SetString(PyExc_ValueError, "invalid WCNF preamble");
+				goto fail;
+			}
 			else {
-				if (!parse_weight_preamble(beg, lend, "wcnf",
-						"invalid WCNF preamble", &topw))
+				if (!append_comment(comments, beg, lend))
 					goto fail;
 			}
 			continue;
@@ -249,10 +257,15 @@ PyObject *parse_cnfplus_impl(PyObject *txt_obj, PyObject *comment_lead)
 			continue;
 
 		if (comment_mask[(unsigned char)beg[0]]) {
-			if (!line_starts(beg, lend, "p cnf+")) {
-				if (!append_comment(comments, beg, lend))
-					goto fail;
+			if (line_has_kind(beg, lend, "cnf", "cnf+"))
+				continue;
+			if (line_has_p(beg, lend)) {
+				PyErr_SetString(PyExc_ValueError, "invalid CNF/CNF+ preamble");
+				goto fail;
 			}
+
+			if (!append_comment(comments, beg, lend))
+				goto fail;
 			continue;
 		}
 
@@ -366,13 +379,18 @@ PyObject *parse_wcnfplus_impl(PyObject *txt_obj, PyObject *comment_lead)
 			continue;
 
 		if (comment_mask[(unsigned char)beg[0]]) {
-			if (!line_starts(beg, lend, "p wcnf+")) {
-				if (!append_comment(comments, beg, lend))
+			if (line_has_kind(beg, lend, "wcnf", "wcnf+")) {
+				if (!parse_weight_preamble(beg, lend,
+						"invalid WCNF/WCNF+ preamble", &topw))
 					goto fail;
 			}
+			else if (line_has_p(beg, lend)) {
+				PyErr_SetString(PyExc_ValueError,
+						"invalid WCNF/WCNF+ preamble");
+				goto fail;
+			}
 			else {
-				if (!parse_weight_preamble(beg, lend, "wcnf+",
-						"invalid WCNF+ preamble", &topw))
+				if (!append_comment(comments, beg, lend))
 					goto fail;
 			}
 			continue;

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/formula/pf_scan.hh

@@ -83,6 +83,32 @@ static inline bool read_span(const char * &p, const char *end,
 	return true;
 }
 
+// check whether a line starts with the exact DIMACS preamble marker
+//=============================================================================
+static inline bool line_has_p(const char *beg, const char *end)
+{
+	const char *p = beg;
+	const char *tbeg, *tend;
+
+	return read_span(p, end, tbeg, tend) && span_eq(tbeg, tend, "p");
+}
+
+// check whether a line has an exact DIMACS preamble kind token
+//=============================================================================
+static inline bool line_has_kind(const char *beg, const char *end,
+		const char *kind1, const char *kind2 = NULL)
+{
+	const char *p = beg;
+	const char *tbeg, *tend;
+
+	if (!read_span(p, end, tbeg, tend) || !span_eq(tbeg, tend, "p") ||
+			!read_span(p, end, tbeg, tend))
+		return false;
+
+	return span_eq(tbeg, tend, kind1) ||
+		(kind2 != NULL && span_eq(tbeg, tend, kind2));
+}
+
 // check whether a span has the syntax of a signed integer
 //=============================================================================
 static inline bool span_is_integer_like(const char *beg, const char *end)

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/formula/pf_weight.cc

@@ -13,13 +13,14 @@
 // parse only the weighted preamble fields relevant to the native parser
 //=============================================================================
 bool parse_weight_preamble(const char *beg, const char *end,
-		const char *kind, const char *errmsg, PyObject **topw)
+		const char *errmsg, PyObject **topw)
 {
 	const char *p = beg;
 	const char *tbeg, *tend;
 
 	if (!read_span(p, end, tbeg, tend) || !span_eq(tbeg, tend, "p") ||
-			!read_span(p, end, tbeg, tend) || !span_eq(tbeg, tend, kind) ||
+			!read_span(p, end, tbeg, tend) ||
+			!(span_eq(tbeg, tend, "wcnf") || span_eq(tbeg, tend, "wcnf+")) ||
 			!read_span(p, end, tbeg, tend) ||
 			!read_span(p, end, tbeg, tend)) {
 		PyErr_SetString(PyExc_ValueError, errmsg);

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/formula/pyformula.hh

@@ -76,7 +76,7 @@ typedef struct {
 	vector<long long> wght;
 } plus_body;
 
-bool parse_weight_preamble(const char *beg, const char *end, const char *kind,
+bool parse_weight_preamble(const char *beg, const char *end,
 		const char *errmsg, PyObject **topw);
 
 bool parse_clause_body(const char *p, const char *end,

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/pysat/__init__.py

@@ -10,7 +10,7 @@
 
 # current version
 #==============================================================================
-VERSION = (1, 9, 'dev', 5)
+VERSION = (1, 9, 'dev', 7)
 
 
 # PEP440 Format

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/pysat/engines.py

@@ -564,8 +564,11 @@ class Propagator(object):
                 def provide_reason(self, lit: int) -> List[int]:
                     pass      # explain why a given literal was propagated
 
+                def has_clause(self) -> bool:
+                    return False  # optional: report whether an external clause exists
+
                 def add_clause(self) -> List[int]:
-                    return [] # add an(y) external clause to the solver
+                    return [] # if has_clause() is used, may also be the empty clause
     """
 
     def __init__(self):
@@ -687,10 +690,9 @@ class Propagator(object):
 
     def add_clause(self) -> List[int]:
         """
-            The method is called by the solver to add an external clause if
-            there is any. The clause can be arbitrary but if it is
-            root-satisfied or tautological, the solver will ignore it without
-            learning it.
+            The method is called by the solver to obtain an external clause.
+            The clause can be arbitrary but if it is root-satisfied or
+            tautological, the solver will ignore it without learning it.
 
             Root-falsified literals are eagerly removed from the clause.
             Falsified clauses trigger conflict analysis, propagating clauses
@@ -700,6 +702,19 @@ class Propagator(object):
             An empty clause (or root falsified clause, see above) makes the
             formula unsatisfiable and stops the search immediately.
 
+            .. note::
+
+                The exact meaning of returning ``[]`` depends on whether the
+                propagator defines method ``has_clause()``.
+
+                - If ``has_clause()`` is defined, the solver first queries it.
+                  Whenever it returns ``True``, the follow-up call of
+                  :meth:`add_clause` is expected to return the clause itself,
+                  and ``[]`` denotes the actual empty clause.
+                - Otherwise, if ``has_clause()`` is undefined, returning
+                  ``[]`` from :meth:`add_clause` is interpreted as saying that
+                  there is no clause to add.
+
             :rtype: iterable(int)
         """
 
@@ -1283,14 +1298,25 @@ class BooleanEngine(Propagator):
 
         return [lit] + self.origin[lit].justify(lit)
 
+    def has_clause(self):
+        """
+            Check whether the engine currently has an external clause to add.
+            When queried separately by the solver, this lets
+            :meth:`add_clause` return ``[]`` as an actual empty clause.
+        """
+
+        return self.falsified is not None
+
     def add_clause(self):
         """
-            Extract a new clause to add to the solver if one exists; return an
-            empty clause ``[]`` otherwise.
+            Extract the external clause previously announced by
+            :meth:`has_clause`.
         """
 
-        if self.falsified is None:
-            return []
+        # # old behaviour checking if we have a clause to add;
+        # # commenting this out because we have has_clause() now
+        # if self.falsified is None:
+        #     return []
 
         to_add = self.falsified.explain_failure()
 

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/pysat/formula.py

@@ -4129,6 +4129,7 @@ class WCNF(object):
         # normalize it, i.e. transform into a set of clauses
         # with a positive weight
         if negs:
+            self.nv = max(self.nv, max(map(lambda cl: max(map(abs, cl[0])), negs)))
             self.normalize_negatives(negs)
 
         # if topw was unspecified and assigned to +infinity,
@@ -5380,6 +5381,7 @@ class WCNFPlus(WCNF, object):
         # normalize it, i.e. transform into a set of clauses
         # with a positive weight
         if negs:
+            self.nv = max(self.nv, max(map(lambda cl: max(map(abs, cl[0])), negs)))
             self.normalize_negatives(negs)
 
         # if topw was unspecified and assigned to +infinity,

{python_sat-1.9.dev5 → python_sat-1.9.dev7/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev5
+Version: 1.9.dev7
 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.dev5 → python_sat-1.9.dev7}/python_sat.egg-info/SOURCES.txt

@@ -102,12 +102,14 @@ tests/test_atmostk.py
 tests/test_boolengine.py
 tests/test_clausification.py
 tests/test_cnf.py
+tests/test_empty_extclause.py
 tests/test_encode_pb_conditional.py
 tests/test_equals1.py
 tests/test_formula_parsing.py
 tests/test_formula_unique.py
 tests/test_idpool.py
 tests/test_integer.py
+tests/test_oom.py
 tests/test_process.py
 tests/test_propagate.py
 tests/test_unique_model.py

{python_sat-1.9.dev5 → python_sat-1.9.dev7}/solvers/patches/minisatep.patch

@@ -623,7 +623,7 @@ diff -Naur solvers/minisatep/core/Solver.cc solvers/mep/core/Solver.cc
 -    for (int i = 0; i < nVars(); i++) {
 -        if (value(i) != Minisat::l_Undef) {
 -            res.push_back(Minisat::LitToint(Minisat::mkLit(i, value(i) == Minisat::l_False)));
-+    std::vector<int> res; res.reserve(nVars() - 1);
++    std::vector<int> res; res.reserve(nVars() > 0 ? nVars() - 1 : 0); 
 +    for (int i = 1; i < nVars(); i++) {
 +        if (value(i) != mep_l_Undef) {
 +            res.push_back(i * (value(i) == mep_l_False ? -1 : 1));