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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev5
+Version: 1.9.dev6
 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.dev6}/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.dev6}/pysat/__init__.py

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

{python_sat-1.9.dev5 → python_sat-1.9.dev6}/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.dev6/python_sat.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev5
+Version: 1.9.dev6
 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.dev6}/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.dev6}/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));