Extending automatic teststuite

cpmpy/expressions/core.py

@@ -72,7 +72,7 @@
 import numpy as np
 
 
-from .utils import is_num, is_any_list, flatlist, argval, get_bounds, is_boolexpr, is_true_cst, is_false_cst
+from .utils import is_num, is_any_list, flatlist, argval, get_bounds, is_boolexpr, is_true_cst, is_false_cst, argvals
 from ..exceptions import IncompleteFunctionError, TypeError
 
 
@@ -144,6 +144,7 @@ def is_bool(self):
     def value(self):
         return None # default
 
+
     def get_bounds(self):
         if self.is_bool():
             return 0, 1 #default for boolean expressions
@@ -400,7 +401,8 @@ def __repr__(self):
     # return the value of the expression
     # optional, default: None
     def value(self):
-        arg_vals = [argval(a) for a in self.args]
+        arg_vals = argvals(self.args)
+
         if any(a is None for a in arg_vals): return None
         if   self.name == "==": return arg_vals[0] == arg_vals[1]
         elif self.name == "!=": return arg_vals[0] != arg_vals[1]
@@ -526,11 +528,12 @@ def wrap_bracket(arg):
         return "{}({})".format(self.name, self.args)
 
     def value(self):
+
         if self.name == "wsum":
             # wsum: arg0 is list of constants, no .value() use as is
-            arg_vals = [self.args[0], [argval(arg) for arg in self.args[1]]]
+            arg_vals = [self.args[0], argvals(self.args[1])]
         else:
-            arg_vals = [argval(arg) for arg in self.args]
+            arg_vals = argvals(self.args)
 
 
         if any(a is None for a in arg_vals): return None
@@ -546,7 +549,8 @@ def value(self):
             try:
                 return arg_vals[0] // arg_vals[1]
             except ZeroDivisionError:
-                raise IncompleteFunctionError(f"Division by zero during value computation for expression {self}")
+                raise IncompleteFunctionError(f"Division by zero during value computation for expression {self}"
+                                              + "\n Use argval(expr) to get the value of expr with relational semantics.")
 
         # boolean
         elif self.name == "and": return all(arg_vals)

cpmpy/expressions/globalconstraints.py

@@ -120,7 +120,7 @@ def my_circuit_decomp(self):
 from ..exceptions import CPMpyException, IncompleteFunctionError, TypeError
 from .core import Expression, Operator, Comparison
 from .variables import boolvar, intvar, cpm_array, _NumVarImpl, _IntVarImpl
-from .utils import flatlist, all_pairs, argval, is_num, eval_comparison, is_any_list, is_boolexpr, get_bounds
+from .utils import flatlist, all_pairs, argval, is_num, eval_comparison, is_any_list, is_boolexpr, get_bounds, argvals
 from .globalfunctions import * # XXX make this file backwards compatible
 
 
@@ -178,7 +178,7 @@ def decompose(self):
         return [var1 != var2 for var1, var2 in all_pairs(self.args)], []
 
     def value(self):
-        return len(set(a.value() for a in self.args)) == len(self.args)
+        return len(set(argvals(self.args))) == len(self.args)
 
 
 class AllDifferentExcept0(GlobalConstraint):
@@ -193,10 +193,9 @@ def decompose(self):
         return [(var1 == var2).implies(var1 == 0) for var1, var2 in all_pairs(self.args)], []
 
     def value(self):
-        vals = [a.value() for a in self.args if a.value() != 0]
+        vals = [argval(a) for a in self.args if argval(a) != 0]
         return len(set(vals)) == len(vals)
 
-
 def allequal(args):
     warnings.warn("Deprecated, use AllEqual(v1,v2,...,vn) instead, will be removed in stable version", DeprecationWarning)
     return AllEqual(*args) # unfold list as individual arguments
@@ -215,8 +214,7 @@ def decompose(self):
         return [var1 == var2 for var1, var2 in zip(self.args[:-1], self.args[1:])], []
 
     def value(self):
-        return len(set(a.value() for a in self.args)) == 1
-
+        return len(set(argvals(self.args))) == 1
 
 def circuit(args):
     warnings.warn("Deprecated, use Circuit(v1,v2,...,vn) instead, will be removed in stable version", DeprecationWarning)
@@ -259,7 +257,8 @@ def value(self):
         pathlen = 0
         idx = 0
         visited = set()
-        arr = [argval(a) for a in self.args]
+        arr = argvals(self.args)
+
         while idx not in visited:
             if idx is None:
                 return False
@@ -294,9 +293,13 @@ def decompose(self):
         return [all(rev[x] == i for i, x in enumerate(fwd))], []
 
     def value(self):
-        fwd = [argval(a) for a in self.args[0]]
-        rev = [argval(a) for a in self.args[1]]
-        return all(rev[x] == i for i, x in enumerate(fwd))
+        fwd = argvals(self.args[0])
+        rev = argvals(self.args[1])
+        # args are fine, now evaluate actual inverse cons
+        try:
+            return all(rev[x] == i for i, x in enumerate(fwd))
+        except IndexError: # partiality of Element constraint
+            return False
 
 
 class Table(GlobalConstraint):
@@ -315,10 +318,11 @@ def decompose(self):
 
     def value(self):
         arr, tab = self.args
-        arrval = [argval(a) for a in arr]
+        arrval = argvals(arr)
         return arrval in tab
 
 
+
 # syntax of the form 'if b then x == 9 else x == 0' is not supported (no override possible)
 # same semantic as CPLEX IfThenElse constraint
 # https://www.ibm.com/docs/en/icos/12.9.0?topic=methods-ifthenelse-method
@@ -379,7 +383,7 @@ def decompose(self):
 
 
     def value(self):
-        return argval(self.args[0]) in argval(self.args[1])
+        return argval(self.args[0]) in argvals(self.args[1])
 
     def __repr__(self):
         return "{} in {}".format(self.args[0], self.args[1])
@@ -409,7 +413,7 @@ def decompose(self):
         return decomp, []
 
     def value(self):
-        return sum(argval(a) for a in self.args) % 2 == 1
+        return sum(argvals(self.args)) % 2 == 1
 
     def __repr__(self):
         if len(self.args) == 2:
@@ -478,14 +482,14 @@ def decompose(self):
         return cons, []
 
     def value(self):
-        argvals = [np.array([argval(a) for a in arg]) if is_any_list(arg)
+        arg_vals = [np.array(argvals(arg)) if is_any_list(arg)
                    else argval(arg) for arg in self.args]
 
-        if any(a is None for a in argvals):
+        if any(a is None for a in arg_vals):
             return None
 
         # start, dur, end are np arrays
-        start, dur, end, demand, capacity = argvals
+        start, dur, end, demand, capacity = arg_vals
         # start and end seperated by duration
         if not (start + dur == end).all():
             return False

cpmpy/expressions/globalfunctions.py

@@ -257,7 +257,8 @@ def value(self):
         if idxval is not None:
             if idxval >= 0 and idxval < len(arr):
                 return argval(arr[idxval])
-            raise IncompleteFunctionError(f"Index {idxval} out of range for array of length {len(arr)} while calculating value for expression {self}")
+            raise IncompleteFunctionError(f"Index {idxval} out of range for array of length {len(arr)} while calculating value for expression {self}"
+                                          + "\n Use argval(expr) to get the value of expr with relational semantics.")
         return None # default
 
     def decompose_comparison(self, cpm_op, cpm_rhs):

cpmpy/expressions/utils.py

@@ -121,11 +121,19 @@ def argval(a):
 
         We check with hasattr instead of isinstance to avoid circular dependency
     """
-    try:
-        return a.value() if hasattr(a, "value") else a
-    except IncompleteFunctionError as e:
-        if a.is_bool(): return False
-        raise e
+    if hasattr(a, "value"):
+        try:
+            return a.value()
+        except IncompleteFunctionError as e:
+            if a.is_bool():
+                return False
+            else:
+                raise e
+    return a
+
+
+def argvals(arr):
+    return [argval(a) for a in arr]
 
 
 def eval_comparison(str_op, lhs, rhs):

cpmpy/solvers/choco.py

@@ -29,7 +29,7 @@
 from ..expressions.globalconstraints import DirectConstraint
 from ..expressions.variables import _NumVarImpl, _IntVarImpl, _BoolVarImpl, NegBoolView, intvar
 from ..expressions.globalconstraints import GlobalConstraint
-from ..expressions.utils import is_num, is_int, is_boolexpr, is_any_list, get_bounds
+from ..expressions.utils import is_num, is_int, is_boolexpr, is_any_list, get_bounds, argval, argvals
 from ..transformations.decompose_global import decompose_in_tree
 from ..transformations.get_variables import get_variables
 from ..transformations.flatten_model import flatten_constraint, flatten_objective
@@ -208,9 +208,9 @@ def solveAll(self, display=None, time_limit=None, solution_limit=None, call_from
                         cpm_var._value = value
                 # print the desired display
                 if isinstance(display, Expression):
-                    print(display.value())
+                    print(argval(display))
                 elif isinstance(display, list):
-                    print([v.value() for v in display])
+                    print(argvals(display))
                 else:
                     display()  # callback
 
@@ -349,6 +349,7 @@ def __add__(self, cpm_expr):
         """
         # add new user vars to the set
         get_variables(cpm_expr, collect=self.user_vars)
+        # ensure all vars are known to solver
 
         # transform and post the constraints
         for con in self.transform(cpm_expr):

cpmpy/solvers/exact.py

@@ -37,7 +37,7 @@
 from ..transformations.normalize import toplevel_list
 from ..expressions.globalconstraints import DirectConstraint
 from ..exceptions import NotSupportedError
-from ..expressions.utils import flatlist
+from ..expressions.utils import flatlist, argvals
 
 import numpy as np
 import numbers
@@ -263,9 +263,9 @@ def solveAll(self, display=None, time_limit=None, solution_limit=None, call_from
                 if display is not None:
                     self._fillObjAndVars()
                     if isinstance(display, Expression):
-                        print(display.value())
+                        print(argval(display))
                     elif isinstance(display, list):
-                        print([v.value() for v in display])
+                        print(argvals(display))
                     else:
                         display()  # callback
             elif my_status == 2: # found inconsistency

cpmpy/solvers/gurobi.py

@@ -28,6 +28,7 @@
 
 from .solver_interface import SolverInterface, SolverStatus, ExitStatus
 from ..expressions.core import *
+from ..expressions.utils import argvals
 from ..expressions.variables import _BoolVarImpl, NegBoolView, _IntVarImpl, _NumVarImpl, intvar
 from ..expressions.globalconstraints import DirectConstraint
 from ..transformations.comparison import only_numexpr_equality
@@ -461,9 +462,9 @@ def solveAll(self, display=None, time_limit=None, solution_limit=None, call_from
 
             if display is not None:
                 if isinstance(display, Expression):
-                    print(display.value())
+                    print(argval(display))
                 elif isinstance(display, list):
-                    print([v.value() for v in display])
+                    print(argvals(display))
                 else:
                     display()  # callback
 

cpmpy/solvers/minizinc.py

@@ -36,7 +36,7 @@
 from ..expressions.core import Expression, Comparison, Operator, BoolVal
 from ..expressions.variables import _NumVarImpl, _IntVarImpl, _BoolVarImpl, NegBoolView, intvar
 from ..expressions.globalconstraints import DirectConstraint
-from ..expressions.utils import is_num, is_any_list, eval_comparison
+from ..expressions.utils import is_num, is_any_list, eval_comparison, argvals, argval
 from ..transformations.decompose_global import decompose_in_tree
 from ..transformations.get_variables import get_variables
 from ..exceptions import MinizincPathException, NotSupportedError
@@ -323,9 +323,9 @@ async def _solveAll(self, display=None, time_limit=None, solution_limit=None, **
 
                 # and the actual displaying
                 if isinstance(display, Expression):
-                    print(display.value())
+                    print(argval(display))
                 elif isinstance(display, list):
-                    print([v.value() for v in display])
+                    print(argvals(display))
                 else:
                     display() # callback
 

cpmpy/solvers/ortools.py

@@ -32,7 +32,7 @@
 from ..expressions.globalconstraints import DirectConstraint
 from ..expressions.variables import _NumVarImpl, _IntVarImpl, _BoolVarImpl, NegBoolView, boolvar
 from ..expressions.globalconstraints import GlobalConstraint
-from ..expressions.utils import is_num, is_any_list, eval_comparison, flatlist
+from ..expressions.utils import is_num, is_any_list, eval_comparison, flatlist, argval, argvals
 from ..transformations.decompose_global import decompose_in_tree
 from ..transformations.get_variables import get_variables
 from ..transformations.flatten_model import flatten_constraint, flatten_objective
@@ -689,10 +689,10 @@ def on_solution_callback(self):
                         cpm_var._value = self.Value(self._varmap[cpm_var])
 
                 if isinstance(self._display, Expression):
-                    print(self._display.value())
+                    print(argval(self._display))
                 elif isinstance(self._display, list):
                     # explicit list of expressions to display
-                    print([v.value() for v in self._display])
+                    print(argvals(self._display))
                 else: # callable
                     self._display()
 

cpmpy/solvers/pysat.py

@@ -38,7 +38,7 @@
 from ..transformations.decompose_global import decompose_in_tree
 from ..transformations.get_variables import get_variables
 from ..transformations.flatten_model import flatten_constraint
-from ..transformations.normalize import toplevel_list
+from ..transformations.normalize import toplevel_list, simplify_boolean
 from ..transformations.reification import only_implies, only_bv_reifies
 
 
@@ -233,6 +233,7 @@ def transform(self, cpm_expr):
         """
         cpm_cons = toplevel_list(cpm_expr)
         cpm_cons = decompose_in_tree(cpm_cons)
+        cpm_cons = simplify_boolean(cpm_cons)
         cpm_cons = flatten_constraint(cpm_cons)
         cpm_cons = only_bv_reifies(cpm_cons)
         cpm_cons = only_implies(cpm_cons)

cpmpy/solvers/pysdd.py

@@ -26,7 +26,7 @@
 from ..expressions.core import Expression, Comparison, Operator, BoolVal
 from ..expressions.variables import _BoolVarImpl, NegBoolView, boolvar
 from ..expressions.globalconstraints import DirectConstraint
-from ..expressions.utils import is_any_list, is_bool
+from ..expressions.utils import is_any_list, is_bool, argval, argvals
 from ..transformations.decompose_global import decompose_in_tree
 from ..transformations.get_variables import get_variables
 from ..transformations.normalize import toplevel_list, simplify_boolean
@@ -121,7 +121,8 @@ def solve(self, time_limit=None, assumptions=None):
                 if lit in sol:
                     cpm_var._value = bool(sol[lit])
                 else:
-                    raise ValueError(f"Var {cpm_var} is unknown to the PySDD solver, this is unexpected - please report on github...")
+                    cpm_var._value = cpm_var.get_bounds()[0] # dummy value - TODO: ensure Pysdd assigns an actual value
+                    # cpm_var._value = None  # not specified...
 
         return has_sol
 
@@ -177,9 +178,9 @@ def solveAll(self, display=None, time_limit=None, solution_limit=None, call_from
 
                 # display is not None:
                 if isinstance(display, Expression):
-                    print(display.value())
+                    print(argval(display))
                 elif isinstance(display, list):
-                    print([v.value() for v in display])
+                    print(argvals(display))
                 else:
                     display()  # callback
             return solution_count

cpmpy/transformations/normalize.py

@@ -132,15 +132,15 @@ def simplify_boolean(lst_of_expr, num_context=False):
                     if name == "==" or name == "<=":
                         newlist.append(recurse_negation(lhs))
                     if name == "<":
-                        newlist.append(BoolVal(False))
+                        newlist.append(0 if num_context else BoolVal(False))
                     if name == ">=":
-                        newlist.append(BoolVal(True))
+                        newlist.append(1 if num_context else BoolVal(True))
                 elif 0 < rhs < 1:
                     # a floating point value
                     if name == "==":
-                        newlist.append(BoolVal(False))
+                        newlist.append(0 if num_context else BoolVal(False))
                     if name == "!=":
-                        newlist.append(BoolVal(True))
+                        newlist.append(1 if num_context else BoolVal(True))
                     if name == "<" or name == "<=":
                         newlist.append(recurse_negation(lhs))
                     if name == ">" or name == ">=":
@@ -151,9 +151,9 @@ def simplify_boolean(lst_of_expr, num_context=False):
                     if name == "!=" or name == "<":
                         newlist.append(recurse_negation(lhs))
                     if name == ">":
-                        newlist.append(BoolVal(False))
+                        newlist.append(0 if num_context else BoolVal(False))
                     if name == "<=":
-                        newlist.append(BoolVal(True))
+                        newlist.append(1 if num_context else BoolVal(True))
                 elif rhs > 1:
                     newlist.append(BoolVal(name in  {"!=", "<", "<="})) # all other operators evaluate to False
             else: