python-sat 1.9.dev2__cp39-cp39-win_amd64.whl → 1.9.dev4__cp39-cp39-win_amd64.whl

pysat/__init__.py

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

pysat/_fileio.py

@@ -74,6 +74,21 @@ except ImportError:  # zstandard is introduced in Python 3.14
     zstd_present = False
 
 
+#
+#==============================================================================
+def read_all_text(fp):
+    """
+        Read the entire contents of a file-like object and normalize the
+        result to text.
+    """
+
+    data = fp.read()
+
+    if isinstance(data, bytes):
+        return data.decode('utf-8')
+
+    return data
+
 
 #
 #==============================================================================

pysat/examples/rc2.py

@@ -131,6 +131,7 @@
 #
 #==============================================================================
 from __future__ import print_function
+import bisect
 import collections
 import getopt
 import itertools
@@ -810,8 +811,8 @@ class RC2(object):
             handled by calling :func:`process_am1`.
         """
 
-        # literal connections
-        conns = collections.defaultdict(lambda: set([]))
+        # literal connections and selectors conflicting on their own
+        conns = collections.defaultdict(list)
         confl = []
 
         # prepare connections
@@ -819,26 +820,29 @@ class RC2(object):
             st, props = self.oracle.propagate(assumptions=[l1], phase_saving=2)
             if st:
                 for l2 in props:
-                    if -l2 in self.sels_set:
-                        conns[l1].add(-l2)
-                        conns[-l2].add(l1)
+                    l2 = -l2
+                    if l2 in self.sels_set:
+                        conns[l1].append(l2)
+                        conns[l2].append(l1)
             else:
                 # propagating this literal results in a conflict
                 confl.append(l1)
 
-        if confl:  # filtering out unnecessary connections
-            ccopy = {}
-            confl = set(confl)
+        # sort (in-place) and deduplicate adjacency lists
+        for l in list(conns):
+            neigh = conns[l]
+            if neigh:
+                neigh.sort()
 
-            for l in conns:
-                if l not in confl:
-                    cc = conns[l].difference(confl)
-                    if cc:
-                        ccopy[l] = cc
+                j = 1
+                for i in range(1, len(neigh)):
+                    if neigh[i] != neigh[j - 1]:
+                        neigh[j] = neigh[i]
+                        j += 1
 
-            conns = ccopy
-            confl = list(confl)
+                del neigh[j:]
 
+        if confl:
             # processing unit size cores
             for l in confl:
                 self.core, self.minw = [l], self.wght[l]
@@ -849,24 +853,47 @@ class RC2(object):
                 print('c unit cores found: {0}; cost: {1}'.format(len(confl),
                     self.cost))
 
+        # the following graph manipulation requires
+        # fast membership checks for confl; making it a set
+        confl = set(confl)
+
+        # current degrees in the remaining graph;
+        # literals disconnected after removing conflicts are ignored
+        degree, lits = {}, set()
+        for l in conns:
+            if l not in confl:
+                d = sum(1 for l2 in conns[l] if l2 not in confl)
+                if d:
+                    degree[l] = d
+                    lits.add(l)
+
+        # detect AM1s on the original formula with conflicting selectors
+        # filtered out, similarly to the previous implementation
         nof_am1 = 0
         len_am1 = []
-        lits = set(conns.keys())
+
         while lits:
-            am1 = [min(lits, key=lambda l: len(conns[l]))]
+            am1 = [min(lits, key=lambda l: degree[l])]
 
-            for l in sorted(conns[am1[0]], key=lambda l: len(conns[l])):
+            for l in sorted(conns[am1[0]], key=lambda l: degree.get(l, 0)):
                 if l in lits:
                     for l_added in am1[1:]:
-                        if l_added not in conns[l]:
+                        # adjacency lists are sorted, so we use
+                        # binary search for clique membership tests
+                        i = bisect.bisect_left(conns[l], l_added)
+                        if i == len(conns[l]) or conns[l][i] != l_added:
                             break
                     else:
                         am1.append(l)
 
-            # updating remaining lits and connections
-            lits.difference_update(set(am1))
-            for l in conns:
-                conns[l] = conns[l].difference(set(am1))
+            # updating remaining literals and their degrees
+            am1_set = set(am1)
+            lits.difference_update(am1_set)
+
+            for l in am1:
+                for l2 in conns.get(l, []):
+                    if l2 in lits:
+                        degree[l2] -= 1
 
             if len(am1) > 1:
                 # treat the new atmost1 relation

pysat/formula.py

@@ -271,7 +271,7 @@ import decimal
 from enum import Enum
 import itertools
 import os
-from pysat._fileio import FileObject
+from pysat._fileio import FileObject, read_all_text
 import sys
 
 # checking whether or not py-aiger-cnf is available and working as expected
@@ -281,6 +281,13 @@ try:
 except ImportError:
     aiger_present = False
 
+# checking whether or not native formula parser is available
+pyformula_present = True
+try:
+    import pyformula
+except ImportError:
+    pyformula_present = False
+
 try:  # for Python2
     from cStringIO import StringIO
 except ImportError:  # for Python3
@@ -3286,6 +3293,11 @@ class CNF(Formula, object):
                 ...     cnf2 = CNF(from_fp=fp)
         """
 
+        if pyformula_present:
+            self.nv, self.clauses, self.comments = pyformula.parse_cnf(
+                    read_all_text(file_pointer), comment_lead)
+            return
+
         self.nv = 0
         self.clauses = []
         self.comments = []
@@ -3331,7 +3343,10 @@ class CNF(Formula, object):
                 3
         """
 
-        self.from_fp(StringIO(string), comment_lead)
+        if pyformula_present:
+            self.nv, self.clauses, self.comments = pyformula.parse_cnf(string, comment_lead)
+        else:
+            self.from_fp(StringIO(string), comment_lead)
 
     def from_clauses(self, clauses, by_ref=False):
         """
@@ -4044,6 +4059,18 @@ class WCNF(object):
                 ...     cnf2 = WCNF(from_fp=fp)
         """
 
+        if pyformula_present:
+            self.nv, self.hard, self.soft, self.wght, self.topw, self.comments, negs = \
+                    pyformula.parse_wcnf(read_all_text(file_pointer), comment_lead)
+
+            if negs:
+                self.normalize_negatives(negs)
+
+            if type(self.topw) == decimal.Decimal and self.topw.is_infinite():
+                self.topw = 1 + sum(self.wght)
+
+            return
+
         def parse_wght(string):
             if string == 'h':
                 return None
@@ -4171,7 +4198,17 @@ class WCNF(object):
                 3
         """
 
-        self.from_fp(StringIO(string), comment_lead)
+        if pyformula_present:
+            self.nv, self.hard, self.soft, self.wght, self.topw, self.comments, negs = \
+                    pyformula.parse_wcnf(string, comment_lead)
+
+            if negs:
+                self.normalize_negatives(negs)
+
+            if type(self.topw) == decimal.Decimal and self.topw.is_infinite():
+                self.topw = 1 + sum(self.wght)
+        else:
+            self.from_fp(StringIO(string), comment_lead)
 
     def copy(self):
         """
@@ -4668,6 +4705,16 @@ class CNFPlus(CNF, object):
         s = self.to_dimacs().replace('\n', '\\n')
         return f'CNFPlus(from_string=\'{s}\')'
 
+    def from_string(self, string, comment_lead=['c']):
+        """
+            Read a CNF+ formula from a string.
+        """
+
+        if pyformula_present:
+            self.nv, self.clauses, self.atmosts, self.comments = pyformula.parse_cnfplus(string, comment_lead)
+        else:
+            self.from_fp(StringIO(string), comment_lead)
+
     def from_fp(self, file_pointer, comment_lead=['c']):
         """
             Read a CNF+ formula from a file pointer. A file pointer should be
@@ -4693,6 +4740,11 @@ class CNFPlus(CNF, object):
                 ...     cnf2 = CNFPlus(from_fp=fp)
         """
 
+        if pyformula_present:
+            self.nv, self.clauses, self.atmosts, self.comments = pyformula.parse_cnfplus(
+                    read_all_text(file_pointer), comment_lead)
+            return
+
         self.nv = 0
         self.clauses = []
         self.atmosts = []
@@ -5196,6 +5248,23 @@ class WCNFPlus(WCNF, object):
         s = self.to_dimacs().replace('\n', '\\n')
         return f'WCNFPlus(from_string=\'{s}\')'
 
+    def from_string(self, string, comment_lead=['c']):
+        """
+            Read a WCNF+ formula from a string.
+        """
+
+        if pyformula_present:
+            self.nv, self.hard, self.soft, self.wght, self.atms, self.topw, self.comments, negs = \
+                    pyformula.parse_wcnfplus(string, comment_lead)
+
+            if negs:
+                self.normalize_negatives(negs)
+
+            if type(self.topw) == decimal.Decimal and self.topw.is_infinite():
+                self.topw = 1 + sum(self.wght)
+        else:
+            self.from_fp(StringIO(string), comment_lead)
+
     def from_fp(self, file_pointer, comment_lead=['c']):
         """
             Read a WCNF+ formula from a file pointer. A file pointer should be
@@ -5221,6 +5290,18 @@ class WCNFPlus(WCNF, object):
                 ...     cnf2 = WCNFPlus(from_fp=fp)
         """
 
+        if pyformula_present:
+            self.nv, self.hard, self.soft, self.wght, self.atms, self.topw, self.comments, negs = \
+                    pyformula.parse_wcnfplus(read_all_text(file_pointer), comment_lead)
+
+            if negs:
+                self.normalize_negatives(negs)
+
+            if type(self.topw) == decimal.Decimal and self.topw.is_infinite():
+                self.topw = 1 + sum(self.wght)
+
+            return
+
         def parse_wght(string):
             if string == 'h':
                 return None