def proccess_sat_file(filename, sat, solver):
start_time = time.time()
result = "{} || solver {} ".format(filename, solver)
formula = CNF(from_file="./InstanciasSAT/" + filename)
clauses = formula.clauses[:]
nv = formula.nv
original_time = time.time()
original_solution = solve_clauses(clauses, solver)
result += "|| original: {} || Tiempo: {:.10f} segundos ".format(original_solution, time.time() - original_time)
clauses, nv = sat_to_3_sat(clauses, nv)
if sat > 3:
x_sat = 3
while x_sat < sat:
clauses, nv = reduce_to_x_sat(clauses, nv)
x_sat += 1
x_sat_time = time.time()
x_sat_solution = solve_clauses(clauses, solver)
result += "|| {}-SAT: {} || Tiempo: {:.10f} segundos ".format(sat, x_sat_solution, time.time() - x_sat_time)
formula.clauses = clauses
formula.nv = nv
formula.to_file("./X-SAT/" + filename)
result += "|| Tiempo total: {:.10f} segundos".format(time.time() - start_time)
print(result)
def _encode(cls, lits, weights=None, bound=1, top_id=None, vpool=None,
encoding=EncType.best, comparator='<'):
"""
This is the method that wraps the encoder of PyPBLib. Although the
method can be invoked directly, a user is expected to call one of
the following methods instead: :meth:`atmost`, :meth:`atleast`, or
:meth:`equals`.
The list of literals can contain either integers or pairs ``(l,
w)``, where ``l`` is an integer literal and ``w`` is an integer
weight. The latter can be done only if no ``weights`` are
specified separately.
:param lits: a list of literals in the sum.
:param weights: a list of weights
:param bound: the value of bound :math:`k`.
:param top_id: top variable identifier used so far.
:param vpool: variable pool for counting the number of variables.
:param encoding: identifier of the encoding to use.
:param comparator: identifier of the comparison operator
:type lits: iterable(int)
:type weights: iterable(int)
:type bound: int
:type top_id: integer or None
:type vpool: :class:`.IDPool`
:type encoding: integer
:type comparator: str
:rtype: :class:`pysat.formula.CNF`
"""
assert pblib_present, 'Package \'pypblib\' is unavailable. Check your installation.'
if encoding < 0 or encoding > 5:
raise(NoSuchEncodingError(encoding))
assert lits, 'No literals are provided.'
assert not top_id or not vpool, \
'Use either a top id or a pool of variables but not both.'
# preparing weighted literals
if weights:
assert len(lits) == len(weights), 'Same number of literals and weights is expected.'
wlits = [pblib.WeightedLit(l, w) for l, w in zip(lits, weights)]
else:
if all(map(lambda lw: (type(lw) in (list, tuple)) and len(lw) == 2, lits)):
# literals are already weighted
wlits = [pblib.WeightedLit(*wl) for wl in lits]
lits = zip(*lits)[0] # unweighted literals for getting top_id
elif all(map(lambda l: type(l) is int, lits)):
# no weights are provided => all weights are units
wlits = [pblib.WeightedLit(l, 1) for l in lits]
else:
assert 0, 'Incorrect literals given.'
# obtaining the top id from the variable pool
if vpool:
top_id = vpool.top
if not top_id:
top_id = max(map(lambda x: abs(x), lits))
# pseudo-Boolean constraint and variable manager
constr = pblib.PBConstraint(wlits, EncType._to_pbcmp[comparator], bound)
varmgr = pblib.AuxVarManager(top_id + 1)
# encoder configuration
config = pblib.PBConfig()
config.set_PB_Encoder(EncType._to_pbenc[encoding])
# encoding
result = pblib.VectorClauseDatabase(config)
pb2cnf = pblib.Pb2cnf(config)
pb2cnf.encode(constr, result, varmgr)
# extracting clauses
ret = CNF(from_clauses=result.get_clauses())
ret.nv = max(ret.nv, top_id) # needed if no auxiliary variable is used
# updating vpool if necessary
if vpool:
if vpool._occupied and vpool.top <= vpool._occupied[0][0] <= ret.nv:
cls._update_vids(ret, vpool, lits)
else:
vpool.top = ret.nv - 1
vpool._next()
return ret
