eqc-models 0.11.1__py3-none-any.whl → 0.13.0__py3-none-any.whl

{eqc_models-0.11.1.data → eqc_models-0.13.0.data}/platlib/eqc_models/base/base.py

@@ -41,6 +41,7 @@ class EqcModel:
     _upper_bound = None
     _H = None
     _machine_slacks = 0
+    _is_discrete = None
     
     def decode(self, solution : np.ndarray, from_encoding : str=None) -> np.ndarray:
         """ 
@@ -117,6 +118,16 @@ class EqcModel:
         warn("The domains property is deprecated in favor of naming it upper_bound", DeprecationWarning)
         self._upper_bound = value
 
+    @property
+    def is_discrete(self) -> List:
+        """ An array of boolean values indicating if variable should be restricted to a discrete domain """
+
+        return self._is_discrete
+
+    @is_discrete.setter
+    def is_discrete(self, value : List):
+        self._is_discrete = value
+
     @property
     def n(self) -> int:
         """ Return the number of variables """

eqc_models-0.13.0.data/platlib/eqc_models/base/binaries.py

@@ -0,0 +1,33 @@
+
+def make_binary_penalty(var_idx, slack_idx, max_degree=2, penalty_multiplier=None):
+    """ 
+    Make a penalty expression enforcing binary values 
+
+    The expression is formed from the conditions
+
+    $$
+    x + w = 1
+    $$
+
+    $$
+    xw = 0
+    $$
+
+    $$
+    w^2 + 2xw + x^2 - 2w - 2x + 1 + xw = 0
+    $$
+
+    $$
+    3xw + w^2 + x^2 - 2w - 2x + 1 = 0
+    $$
+
+    """
+
+    indices = [(0, var_idx), (0, slack_idx), (var_idx, slack_idx), (var_idx, var_idx), (slack_idx, slack_idx)]
+    coefficients = [-2, -2, 3, 1, 1]
+    offset = 1
+    if penalty_multiplier is not None:
+        coefficients = [penalty_multiplier * c for c in coefficients]
+        offset *- penalty_multiplier
+    return coefficients, indices, offset
+

{eqc_models-0.11.1.data → eqc_models-0.13.0.data}/platlib/eqc_models/base/constraints.py

@@ -82,6 +82,45 @@ class ConstraintsMixIn:
     def constraints(self, value: Tuple[np.ndarray, np.ndarray]):
         self.lhs, self.rhs = value
 
+    @staticmethod
+    def _stackLHS(*args):
+        """
+
+        >>> m1 = np.array([1, 1, 1])
+        >>> m2 = np.array([[2.0, 2.0]])
+        >>> m3 = np.array([[0, 3, 3, 1], [1, 0, 1, 0]])
+        >>> ConstraintsMixIn._stackLHS(m1, m2, m3)
+        array([[1., 1., 1., 0.],
+               [2., 2., 0., 0.],
+               [0., 3., 3., 1.],
+               [1., 0., 1., 0.]])
+
+        """
+        n = 0
+        m = 0
+        dtype = np.int32
+        def update_dtype(matrix):
+            type_rank = ["int8", "int16", "int32", "int64", "float8", "float16", "float32", "float64"]
+            try:
+                idx = type_rank.index(str(matrix.dtype))
+            except ValueError:
+                raise TypeError(f"matrix type {matrix.dtype} not supported")
+        new_args = []
+        for mat in args:
+            if len(mat.shape) == 1:
+                mat = mat.reshape((1, mat.size))
+            if mat.shape[1] > n:
+                n = mat.shape[1]
+            m += mat.shape[0]
+            dtype = update_dtype(mat)
+            new_args.append(mat)
+        new_lhs = np.zeros((m, n), dtype=dtype)
+        idx = 0
+        for mat in new_args:
+            new_lhs[idx:idx+mat.shape[0],:mat.shape[1]] = mat
+            idx += mat.shape[0]
+        return new_lhs
+
     @property
     def offset(self) -> float:
         """ Calculate the offset due to the conversion of constraints to penalties """