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

{python_sat-1.9.dev3 → python_sat-1.9.dev5}/MANIFEST.in

@@ -6,3 +6,4 @@ recursive-include cardenc *.hh
 include solvers/prepare.py
 recursive-include solvers *.patch
 recursive-include solvers *.zip *.tar.gz
+recursive-include formula *.hh

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-sat
-Version: 1.9.dev3
+Version: 1.9.dev5
 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.dev3 → python_sat-1.9.dev5}/README.rst

@@ -79,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.dev3 → python_sat-1.9.dev5}/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

python_sat-1.9.dev5/formula/pf_plus.hh

@@ -0,0 +1,36 @@
+/*
+ * pf_plus.hh
+ *
+ *  Created on: May 19, 2025
+ *      Author: Alexey Ignatiev
+ *      E-mail: alexey.ignatiev@monash.edu
+ */
+
+#ifndef __PF_PLUS_HH__
+#define __PF_PLUS_HH__
+
+#include "pyformula.hh"
+
+// reset the temporary state used for CNF+/WCNF+ bodies
+//=============================================================================
+static inline void init_plus_body(plus_body &body)
+{
+	body.weighted = false;
+	body.clause   = false;
+	body.rhs      = 0;
+	body.sumw     = 0;
+	body.lits.clear();
+	body.wght.clear();
+}
+
+// normalize a >= constraint into an equivalent <= form
+//=============================================================================
+static inline void normalize_ge(plus_body &body)
+{
+	for (size_t i = 0; i < body.lits.size(); ++i)
+		body.lits[i] = -body.lits[i];
+
+	body.rhs = body.sumw - body.rhs;
+}
+
+#endif

python_sat-1.9.dev5/formula/pf_py.hh

@@ -0,0 +1,185 @@
+/*
+ * pf_py.hh
+ *
+ *  Created on: May 19, 2025
+ *      Author: Alexey Ignatiev
+ *      E-mail: alexey.ignatiev@monash.edu
+ */
+
+#ifndef __PF_PY_HH__
+#define __PF_PY_HH__
+
+#include "pyformula.hh"
+#include "pf_scan.hh"
+
+// tiny integer cache for repeated literals/weights
+//=============================================================================
+// hash an integer for the tiny object cache
+static inline uint32_t pyint_cache_hash(long long v)
+{
+	return ((uint32_t)v * 2654435761u) & (PYINT_CACHE_SIZE - 1u);
+}
+
+// fetch a cached Python integer or create it on demand
+//=============================================================================
+static inline PyObject *pyint_cache_get_or_make(int_cache *cache, long long v)
+{
+	uint32_t idx = pyint_cache_hash(v);
+	int_cache_ent *e = &cache->slots[idx];
+	if (e->used && e->key == v) {
+		Py_INCREF(e->obj);
+		return e->obj;
+	}
+
+	PyObject *obj = PyLong_FromLongLong(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;
+
+	Py_INCREF(obj);
+	return obj;
+}
+
+// release all Python integers stored in the cache
+//=============================================================================
+static inline void pyint_cache_clear(int_cache *cache)
+{
+	for (size_t i = 0; i < cache->used_count; ++i) {
+		int_cache_ent *e = &cache->slots[cache->used_idx[i]];
+		if (e->used) {
+			Py_DECREF(e->obj);
+			e->obj = NULL;
+			e->used = 0;
+		}
+	}
+
+	cache->used_count = 0;
+}
+
+// generic helpers
+//=============================================================================
+// build a fast lookup table for comment lead characters
+static inline void init_comment_mask(PyObject *comment_lead, bool mask[256])
+{
+	memset(mask, 0, sizeof(bool) * 256);
+	mask[(unsigned char)'p'] = true;
+
+	if (comment_lead == NULL)
+		return;
+
+	PyObject *iter = PyObject_GetIter(comment_lead);
+	if (iter == NULL) {
+		PyErr_Clear();
+		return;
+	}
+
+	PyObject *item;
+	while ((item = PyIter_Next(iter)) != NULL) {
+		if (PyUnicode_Check(item)) {
+			Py_ssize_t size = 0;
+			const char *s = PyUnicode_AsUTF8AndSize(item, &size);
+			if (s && size > 0)
+				mask[(unsigned char)s[0]] = true;
+		}
+#if PY_MAJOR_VERSION < 3
+		else if (PyString_Check(item)) {
+			char *s = NULL;
+			Py_ssize_t size = 0;
+			if (PyString_AsStringAndSize(item, &s, &size) == 0 && s && size > 0)
+				mask[(unsigned char)s[0]] = true;
+		}
+#endif
+		Py_DECREF(item);
+	}
+
+	Py_DECREF(iter);
+	PyErr_Clear();
+}
+
+// expose a Python string/bytes object as a contiguous text buffer
+//=============================================================================
+static inline bool get_text_view(PyObject *obj, const char **ptr,
+		Py_ssize_t *len)
+{
+	if (PyUnicode_Check(obj)) {
+		*ptr = PyUnicode_AsUTF8AndSize(obj, len);
+		return *ptr != NULL;
+	}
+	else if (PyBytes_Check(obj)) {
+		return PyBytes_AsStringAndSize(obj, (char **)ptr, len) == 0;
+	}
+#if PY_MAJOR_VERSION < 3
+	else if (PyString_Check(obj)) {
+		return PyString_AsStringAndSize(obj, (char **)ptr, len) == 0;
+	}
+#endif
+
+	PyErr_SetString(PyExc_TypeError, "string or bytes expected");
+	return false;
+}
+
+// create a Python string from a line span
+//=============================================================================
+static inline PyObject *mk_line(const char *beg, const char *end)
+{
+	return PyUnicode_FromStringAndSize(beg, end - beg);
+}
+
+// append a raw comment line to the comments list
+//=============================================================================
+static inline bool append_comment(PyObject *comments, const char *beg,
+		const char *end)
+{
+	PyObject *line = mk_line(beg, end);
+	if (line == NULL)
+		return false;
+
+	int ok = PyList_Append(comments, line);
+	Py_DECREF(line);
+	return ok >= 0;
+}
+
+// update the current maximum variable identifier
+//=============================================================================
+static inline void update_nv(long long lit, long long &nv)
+{
+	long long a = lit < 0 ? -lit : lit;
+	if (a > nv)
+		nv = a;
+}
+
+// convert a vector of integers into a Python list
+//=============================================================================
+static inline PyObject *mk_llist(const vector<long long> &vals,
+		int_cache *cache, long long *nv)
+{
+	PyObject *lst = PyList_New((Py_ssize_t)vals.size());
+	if (lst == NULL)
+		return NULL;
+
+	for (Py_ssize_t i = 0; i < (Py_ssize_t)vals.size(); ++i) {
+		long long v = vals[(size_t)i];
+		if (nv)
+			update_nv(v, *nv);
+
+		PyObject *obj = pyint_cache_get_or_make(cache, v);
+		if (obj == NULL) {
+			Py_DECREF(lst);
+			return NULL;
+		}
+
+		PyList_SET_ITEM(lst, i, obj);
+	}
+
+	return lst;
+}
+
+#endif

python_sat-1.9.dev5/formula/pf_scan.hh

@@ -0,0 +1,181 @@
+/*
+ * pf_scan.hh
+ *
+ *  Created on: May 19, 2025
+ *      Author: Alexey Ignatiev
+ *      E-mail: alexey.ignatiev@monash.edu
+ */
+
+#ifndef __PF_SCAN_HH__
+#define __PF_SCAN_HH__
+
+#include "pyformula.hh"
+
+// low-level cursor helpers
+//=============================================================================
+// skip inline whitespace while advancing the cursor
+static inline void skip_ws(const char * &p, const char *end)
+{
+	while (p < end && ((*p >= 9 && *p <= 13) || *p == 32))
+		++p;
+}
+
+// check whether a bounded span matches a C string exactly
+//=============================================================================
+static inline bool span_eq(const char *beg, const char *end, const char *s)
+{
+	size_t n = strlen(s);
+	return (Py_ssize_t)n == end - beg && memcmp(beg, s, n) == 0;
+}
+
+// check whether a line starts with a fixed prefix
+//=============================================================================
+static inline bool line_starts(const char *beg, const char *end,
+		const char *prefix)
+{
+	size_t n = strlen(prefix);
+	return (Py_ssize_t)n <= end - beg && memcmp(beg, prefix, n) == 0;
+}
+
+// test whether a trimmed line is empty
+//=============================================================================
+static inline bool line_empty(const char *beg, const char *end)
+{
+	return end <= beg;
+}
+
+// split the input into trimmed logical lines
+//=============================================================================
+static inline bool next_line(const char * &p, const char *end,
+		const char * &beg, const char * &lend)
+{
+	if (p >= end)
+		return false;
+
+	beg = p;
+	while (p < end && *p != '\n')
+		++p;
+
+	lend = p;
+	if (p < end)
+		++p;
+
+	while (lend > beg && isspace((unsigned char)lend[-1]))
+		--lend;
+
+	return true;
+}
+
+// read the next whitespace-delimited token span
+//=============================================================================
+static inline bool read_span(const char * &p, const char *end,
+		const char * &beg, const char * &tend)
+{
+	skip_ws(p, end);
+	if (p >= end)
+		return false;
+
+	beg = p;
+	while (p < end && !isspace((unsigned char)*p))
+		++p;
+
+	tend = p;
+	return true;
+}
+
+// check whether a span has the syntax of a signed integer
+//=============================================================================
+static inline bool span_is_integer_like(const char *beg, const char *end)
+{
+	if (beg >= end)
+		return false;
+
+	if (*beg == '+' || *beg == '-')
+		++beg;
+	if (beg >= end)
+		return false;
+
+	for (; beg < end; ++beg) {
+		if (*beg < '0' || *beg > '9')
+			return false;
+	}
+
+	return true;
+}
+
+// parse a bounded signed integer without copying
+//=============================================================================
+static inline bool parse_ll_span(const char *beg, const char *end,
+		long long &out)
+{
+	if (beg >= end)
+		return false;
+
+	bool neg = false;
+	if (*beg == '+' || *beg == '-') {
+		neg = (*beg == '-');
+		++beg;
+	}
+	if (beg >= end)
+		return false;
+
+	unsigned long long lim = neg ? (unsigned long long)LLONG_MAX + 1ULL
+					     : (unsigned long long)LLONG_MAX;
+	unsigned long long val = 0;
+
+	for (; beg < end; ++beg) {
+		unsigned char ch = (unsigned char)*beg;
+		if (ch < '0' || ch > '9')
+			return false;
+
+		unsigned long long dig = (unsigned long long)(ch - '0');
+		if (val > (lim - dig) / 10ULL)
+			return false;
+
+		val = val * 10ULL + dig;
+	}
+
+	if (neg) {
+		if (val == (unsigned long long)LLONG_MAX + 1ULL)
+			out = LLONG_MIN;
+		else
+			out = -(long long)val;
+	}
+	else {
+		out = (long long)val;
+	}
+
+	return true;
+}
+
+// parse the next integer directly from the cursor
+//=============================================================================
+static inline bool read_int(const char *&p, const char *end, long long &out)
+{
+	skip_ws(p, end);
+	if (p >= end) {
+		PyErr_SetString(PyExc_ValueError,
+				"unexpected end of input while parsing integer");
+		return false;
+	}
+
+	const char *beg = p;
+	if (*p == '+' || *p == '-')
+		++p;
+	if (p >= end || *p < '0' || *p > '9') {
+		PyErr_SetString(PyExc_ValueError, "invalid integer token");
+		return false;
+	}
+
+	while (p < end && *p >= '0' && *p <= '9')
+		++p;
+
+	if (!parse_ll_span(beg, p, out)) {
+		PyErr_SetString(PyExc_ValueError, "invalid integer token");
+		return false;
+	}
+
+	return true;
+}
+
+#endif

python_sat-1.9.dev5/formula/pf_weight.hh

@@ -0,0 +1,93 @@
+/*
+ * pf_weight.hh
+ *
+ *  Created on: May 19, 2025
+ *      Author: Alexey Ignatiev
+ *      E-mail: alexey.ignatiev@monash.edu
+ */
+
+#ifndef __PF_WEIGHT_HH__
+#define __PF_WEIGHT_HH__
+
+#include "pyformula.hh"
+#include "pf_scan.hh"
+
+// weights and preambles
+//=============================================================================
+// parse a clause or top weight as h, int, or decimal.Decimal
+static inline PyObject *parse_wght_span(const char *beg, const char *end)
+{
+	if (span_eq(beg, end, "h")) {
+		Py_RETURN_NONE;
+	}
+
+	if (span_is_integer_like(beg, end)) {
+		long long val;
+		if (!parse_ll_span(beg, end, val)) {
+			PyErr_SetString(PyExc_ValueError, "invalid integer weight");
+			return NULL;
+		}
+
+		return PyLong_FromLongLong(val);
+	}
+
+	PyObject *text = PyUnicode_FromStringAndSize(beg, end - beg);
+	if (text == NULL)
+		return NULL;
+
+	PyObject *d = PyObject_CallFunctionObjArgs(dec_cls, text, NULL);
+	Py_DECREF(text);
+	if (d == NULL)
+		return NULL;
+
+	PyObject *inf = PyObject_CallMethod(d, (char *)"is_infinite", NULL);
+	if (inf == NULL) {
+		Py_DECREF(d);
+		return NULL;
+	}
+
+	int is_inf = PyObject_IsTrue(inf);
+	Py_DECREF(inf);
+	if (is_inf < 0) {
+		Py_DECREF(d);
+		return NULL;
+	}
+	if (is_inf)
+		return d;
+
+	PyObject *ival = PyObject_CallMethod(d, (char *)"to_integral_value", NULL);
+	if (ival == NULL) {
+		Py_DECREF(d);
+		return NULL;
+	}
+
+	int is_eq = PyObject_RichCompareBool(d, ival, Py_EQ);
+	Py_DECREF(ival);
+	if (is_eq < 0) {
+		Py_DECREF(d);
+		return NULL;
+	}
+
+	if (is_eq) {
+		PyObject *res = PyNumber_Long(d);
+		Py_DECREF(d);
+		return res;
+	}
+
+	return d;
+}
+
+// parse a weighted literal of the form w*l
+//=============================================================================
+static inline bool parse_wlit_span(const char *beg, const char *end,
+		long long &w, long long &l)
+{
+	const char *star = (const char *)memchr(beg, '*', (size_t)(end - beg));
+	if (star == NULL)
+		return false;
+
+	return parse_ll_span(beg, star, w) &&
+		parse_ll_span(star + 1, end, l) && l != 0;
+}
+
+#endif

python_sat-1.9.dev5/formula/pyformula.hh

@@ -0,0 +1,99 @@
+/*
+ * pyformula.hh
+ *
+ *  Created on: May 19, 2025
+ *      Author: Alexey Ignatiev
+ *      E-mail: alexey.ignatiev@monash.edu
+ */
+
+#ifndef __PYFORMULA_HH__
+#define __PYFORMULA_HH__
+
+#define PY_SSIZE_T_CLEAN
+
+#include <Python.h>
+#include <ctype.h>
+#include <limits.h>
+#include <stdint.h>
+#include <string.h>
+#include <vector>
+
+using namespace std;
+
+// parser overview
+//=============================================================================
+// The code below follows one cursor-based parsing style throughout.
+// The aim is to replicate the former PySAT's parsers for all *CNF? formats.
+//
+// Generic path:
+//   next_line()      -> split the input into trimmed lines
+//   read_span()      -> scan the next token on a line
+//   parse_ll_span()  -> parse a bounded integer token/span
+//   read_int()       -> parse the next integer directly from a cursor
+//
+// Formula-specific path:
+//   CNF      : parse_clause_body() -> mk_llist()
+//   WCNF     : read weight with parse_wght_span(), parse clause body,
+//              classify with append_weighted_clause()
+//   CNF+     : parse_plus_body() -> clause or AtMost/PB constraint
+//   WCNF+    : parse weight with parse_wght_span(), then parse_plus_body(),
+//              then route either to append_weighted_clause() or mk_atm()
+//
+// Weight parsing:
+//   parse_wght_span() parses clause/top weights as hard-marker 'h', integer,
+//   or decimal.Decimal; parse_wlit_span() parses weighted PB literals w*l.
+//
+// Public wrappers are py_parse_*(); parse_*_impl() contain the actual parser
+// implementations used by those wrappers.
+//
+// Note that preambles are only recognized enough to distinguish the format
+// and, for weighted formats, extract the optional top weight.
+
+#define PYINT_CACHE_SIZE (1u << 10)
+
+extern PyObject *formula_err;
+extern PyObject *dec_cls;
+extern PyObject *dec_inf;
+
+typedef struct {
+	long long key;
+	PyObject *obj;
+	unsigned char used;
+} int_cache_ent;
+
+typedef struct {
+	int_cache_ent slots[PYINT_CACHE_SIZE];
+	uint16_t   used_idx[PYINT_CACHE_SIZE];
+	size_t used_count;
+} int_cache;
+
+typedef struct {
+	bool weighted;
+	bool clause;
+	long long rhs;
+	long long sumw;
+	vector<long long> lits;
+	vector<long long> wght;
+} plus_body;
+
+bool parse_weight_preamble(const char *beg, const char *end, const char *kind,
+		const char *errmsg, PyObject **topw);
+
+bool parse_clause_body(const char *p, const char *end,
+		vector<long long> &lits);
+
+bool parse_plus_body(const char *first_beg, const char *first_end,
+		const char *p, const char *end, plus_body &body);
+
+PyObject *mk_atm(const plus_body &body, int_cache *cache, long long &nv);
+
+bool append_weighted_clause(PyObject *hard, PyObject *soft, PyObject *wght,
+		PyObject *negs, PyObject *topw, PyObject *zero, PyObject *cl,
+		PyObject *wt);
+
+PyObject *parse_cnf_impl     (PyObject *txt_obj, PyObject *comment_lead);
+PyObject *parse_wcnf_impl    (PyObject *txt_obj, PyObject *comment_lead);
+PyObject *parse_cnfplus_impl (PyObject *txt_obj, PyObject *comment_lead);
+PyObject *parse_wcnfplus_impl(PyObject *txt_obj, PyObject *comment_lead);
+
+#endif

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

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

{python_sat-1.9.dev3 → python_sat-1.9.dev5}/pysat/solvers.py

@@ -184,9 +184,9 @@
     settings. For that reason, :class:`Cadical300`'s BVA is disabled by
     default whenever it is created without a synchronized
     :class:`.pysat.formula.IDPool`. Users who want BVA can either enable it
-    manually with :meth:`.configure` or attach a shared pool with
-    :meth:`.attach_vpool` and keep it synchronized explicitly with
-    :meth:`.sync_vpool`.
+    manually with :meth:`.Solver.configure` or attach a shared pool with
+    :meth:`.Solver.attach_vpool` and keep it synchronized explicitly with
+    :meth:`.Solver.sync_vpool`.
 
     ==============
     Module details

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

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

@@ -37,8 +37,13 @@ examples/rc2.py
 examples/usage.py
 formula/pf_parse.cc
 formula/pf_plus.cc
+formula/pf_plus.hh
+formula/pf_py.hh
+formula/pf_scan.hh
 formula/pf_weight.cc
+formula/pf_weight.hh
 formula/pyformula.cc
+formula/pyformula.hh
 pysat/__init__.py
 pysat/_fileio.py
 pysat/_utils.py