eqc-models 0.10.1__py3-none-any.whl → 0.11.0__py3-none-any.whl

{eqc_models-0.10.1.data → eqc_models-0.11.0.data}/platlib/eqc_models/__init__.py

@@ -8,8 +8,9 @@ from .base import QuadraticModel, PolynomialModel
 from .solvers import (Dirac1CloudSolver, Dirac3CloudSolver, Dirac3DirectSolver)
 from .allocation import AllocationModel, AllocationModelX, ResourceRuleEnum
 from .assignment import QAPModel
+from .combinatorics import SetCoverModel, SetPartitionModel
 
 __all__ = ["QuadraticModel", "PolynomialModel", "Dirac1CloudSolver", 
            "Dirac3CloudSolver", "AllocationModel", "AllocationModelX",
            "Dirac3DirectSolver", "ResourceRuleEnum",
-           "QAPModel"]
+           "QAPModel", "SetPartitionModel", "SetCoverModel"]

eqc_models-0.11.0.data/platlib/eqc_models/assignment/setpartition.py

@@ -0,0 +1,4 @@
+from ..combinatorics import SetPartitionModel
+import warnings
+
+warnings.warn("import of SetPartitionModel through assignment is deprecated", DeprecationWarning)

{eqc_models-0.10.1.data → eqc_models-0.11.0.data}/platlib/eqc_models/base/__init__.py

@@ -65,8 +65,10 @@ from .quadratic import (ConstrainedQuadraticModel, QuadraticModel)
 from .polynomial import (PolynomialModel, ConstrainedPolynomialModel)
 from .base import (ModelSolver, EqcModel)
 from .operators import (QUBO, Polynomial)
+from .results import SolutionResults
 
 __all__ = ["ConstraintsMixIn", "ConstraintModel", "ConstrainedQuadraticModel", 
            "QuadraticModel", "PolynomialModel", "ConstrainedPolynomialModel",
            "InequalitiesMixin", "InequalityConstraintModel",
-           "EqcModel", "ModelSolver", "QUBO", "Polynomial"]
+           "EqcModel", "ModelSolver", "QUBO", "Polynomial",
+           "SolutionResults"]

{eqc_models-0.10.1.data → eqc_models-0.11.0.data}/platlib/eqc_models/base/base.py

@@ -42,12 +42,50 @@ class EqcModel:
     _H = None
     _machine_slacks = 0
     
-    def decode(self, solution : np.ndarray) -> np.ndarray:
-        """ Manipulate the solution to match the variable count """
+    def decode(self, solution : np.ndarray, from_encoding : str=None) -> np.ndarray:
+        """ 
+        Manipulate the solution to match the variable count. Optionally,
+        a log-encoded solution vector can be translated into a vector
+        with integral values.
+
+        Parameters
+        -----------
+
+        solution : np.ndarray
+            1d solution vector 
+
+        from_encoding : str
+            string indicating if the vector is an encoding of particular type. The
+            text 'qubo' is the only option that does anything for now.
+
+        >>> model = EqcModel()
+        >>> ub = np.array([1, 2, 5])
+        >>> model.upper_bound = ub
+        >>> model.machine_slacks = 1
+        >>> solution = np.array([1, 1, 1, 1, 0, 1, 0]) # this solution has a 3, which violates the upper bound, but decode doesn't care
+        >>> model.decode(solution, "qubo")
+        array([1, 3, 5])
+
+        """
         
+        solution = np.array(solution)
         # ignore any slacks that may have been added during encoding
-        solution = solution[:-self.machine_slacks]
-        
+        if self.machine_slacks > 0:
+            solution = solution[:-self.machine_slacks]
+        if from_encoding == "qubo":
+            ub = self.upper_bound
+            en = solution.shape[0]
+            assert en > 0
+            n = ub.shape[0]
+            linear_operator = np.zeros((n,en))
+            j = 0
+            for i in range(self.n):
+                m = int(np.floor(np.log2(ub[i]))+1)
+                bits = 2**np.arange(m)
+                assert j+m <= linear_operator.shape[1]+2, f"Invalid slice for i={i} {j}:{j+m}"
+                linear_operator[i,j:j+m] = bits
+                j += m
+            solution = (linear_operator@solution).astype(np.int64)
         return solution
 
     @property
@@ -64,6 +102,8 @@ class EqcModel:
         value = np.array(value)
         if (value != value.astype(np.int64)).any():
             raise ValueError("Upper bound values must be integer")
+        if (value==0).any():
+            raise ValueError("Zero values are not allowed as an upper_bound.")
         self._upper_bound = value.astype(np.int64)
 
     @property