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/base/polynomial.py

@@ -117,12 +117,15 @@ class PolynomialModel(PolynomialMixin, EqcModel):
 
     @property
     def qubo(self) -> QUBO:
+        polynomial = self.polynomial
+        coefficients = polynomial.coefficients
+        indices = polynomial.indices
         try:
-            if np.all([len(self.polynomial.indices[i]) == 2 for i in range(len(self.polynomial.indices))]):
+            if np.all([len(indices[i]) == 2 for i in range(len(indices))]):
                 bin_n = 0
                 bits = []
-                C, J = self._quadratic_polynomial_to_qubo_coefficients(self.polynomial.coefficients,
-                                                                       self.polynomial.indices, self.n)
+                C, J = self._quadratic_polynomial_to_qubo_coefficients(coefficients,
+                                                                       indices, self.n)
                 # upper_bound is an array of the maximum values each variable can take
                 upper_bound = self.upper_bound
                 if np.sum(upper_bound) != upper_bound.shape[0]:
@@ -158,6 +161,7 @@ class PolynomialModel(PolynomialMixin, EqcModel):
                 raise OperatorNotAvailableError("QUBO operator not available")
         except OperatorNotAvailableError as e:
             print(e)
+            raise
 
     def _quadratic_polynomial_to_qubo_coefficients(self, coefficients, indices, num_variables):
         """

eqc_models-0.11.0.data/platlib/eqc_models/base/results.py

@@ -0,0 +1,94 @@
+import dataclasses
+import warnings
+import numpy as np
+
+@dataclasses.dataclass
+class SolutionResults:
+    """
+    The class is meant to provide a uniform interface to results, no matter
+    the method of running the job.
+
+    """
+
+    solutions : np.ndarray
+    energies : np.ndarray
+    counts : np.array
+    objectives : np.ndarray
+    run_time : np.ndarray
+    preprocessing_time : np.ndarray
+    postprocessing_time : np.ndarray
+    penalties : np.ndarray = None
+    device : str = None
+    time_units : str = "ns"
+
+    @property
+    def device_time(self):
+        pre = self.preprocessing_time
+        runtime = np.sum(self.run_time)
+        post = np.sum(self.postprocessing_time)
+        return pre + runtime + post
+
+    @property
+    def total_samples(self):
+        return np.sum(self.counts)
+
+    @property
+    def best_energy(self):
+        return np.min(self.energies)
+
+    @classmethod
+    def determine_device_type(cls, device_config):
+        """ 
+        Use the device config object from a cloud response
+        to get the device info. It will have a device and job type
+        identifiers in it.
+
+        """
+        devices = [k for k in device_config.keys()]
+        # only one device type is supported at a time
+        return devices[0]
+
+    @classmethod
+    def from_cloud_response(cls, model, response, solver):
+        """ Fill in the details from the cloud """
+
+        solutions = np.array(response["results"]["solutions"])
+        energies = np.array(response["results"]["energies"])
+        if hasattr(model, "evaluateObjective"):
+            objectives = np.zeros((solutions.shape[0],), dtype=np.float32)
+            for i in range(solutions.shape[0]):
+                try:
+                    objective = model.evaluateObjective(solutions[i])
+                except NotImplementedError:
+                    warnings.warn(f"Cannot set objective value in results for {model.__class__}")
+                    objectives = None
+                    break
+                objectives[i] = objective
+        else:
+            objectives = None
+        if hasattr(model, "evaluatePenalties"):
+            penalties = np.zeros((solutions.shape[0],), dtype=np.float32)
+            for i in range(solutions.shape[0]):
+                penalties[i] = model.evaluatePenalty(solution[i]) + model.offset
+        else:
+            penalties = None
+        counts = np.array(response["results"]["counts"])
+# interrogate to determine the device type
+        try:
+            device_type = cls.determine_device_type(response["job_info"]["job_submission"]["device_config"])
+        except KeyError:
+            print(response.keys())
+            raise
+        job_id = response["job_info"]["job_id"]
+        metrics = solver.client.get_job_metrics(job_id=job_id)
+        metrics = metrics["job_metrics"]
+        time_ns = metrics["time_ns"]
+        device = time_ns["device"][device_type]
+        runtime = device["samples"]["runtime"]
+        post = device["samples"]["postprocessing_time"]
+        pre = device["samples"]["preprocessing_time"]
+        results = SolutionResults(solutions, energies, counts, objectives, 
+                                  runtime, pre, post, penalties=penalties,
+                                  device=device_type, time_units="ns")
+
+        return results

eqc_models-0.11.0.data/platlib/eqc_models/combinatorics/__init__.py

@@ -0,0 +1,6 @@
+# (C) Quantum Computing Inc., 2024.
+
+from .setcover import SetCoverModel
+from .setpartition import SetPartitionModel
+
+__all__ = ["SetCoverModel", "SetPartitionModel"]

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

@@ -41,41 +41,57 @@ class SetCoverModel(ConstrainedQuadraticModel):
     >>> X = [set(['A', 'B']), set(['B', 'C']), set(['C'])]
     >>> weights = [2, 2, 1]
     >>> model = SetCoverModel(X, weights)
-    >>> model.penalty_multiplier = 2
+    >>> model.penalty_multiplier = 8
+    >>> lhs, rhs = model.constraints
+    >>> lhs
+    array([[ 1,  0,  0,  0,  0],
+           [ 1,  1,  0, -1,  0],
+           [ 0,  1,  1,  0, -1]])
     >>> from eqc_models.solvers import Dirac3IntegerCloudSolver
     >>> solver = Dirac3IntegerCloudSolver()
     >>> response = solver.solve(model, relaxation_schedule=1, num_samples=5) #doctest: +ELLIPSIS
     20...
     >>> solutions = response["results"]["solutions"]
     >>> solutions[0]
-    [1, 0, 1, 0, 0, 0]
-    >>> model.decode(solutions[0])
-    [{'B', 'A'}, {'C'}]
+    [1, 0, 1, 0, 0]
+    >>> selections = model.decode(solutions[0])
+    >>> assert {'B', 'A'} in selections
+    >>> assert {'C'} in selections
+    >>> assert len(selections) == 2
 
     """
 
     def __init__(self, subsets, weights):
         # ensure that X is ordered
-        self.X = X = list(subsets)
-        self.S = S = set()
+        self.S = S = list(subsets)
+        self.universal_set = U = set()
 
         for x in subsets:
-            S = S.union(x)
+            U.update(x)
         # elements is sorted to maintain consistent output
-        elements = [a for a in S]
+        elements = [a for a in U]
         elements.sort()
         # constraints 
         A = []
         b = []
-        variables = [f'x_{i}' for i in range(len(X))]
+        variables = [f'x_{i}' for i in range(len(S))]
         pos = 0
+        num_slacks = 0
+        slack_ub = []
         for a in elements:
-            variables.append(f"s_{pos}")
-            constraint = [1 if a in X[i] else 0 for i in range(len(X))]
-            slacks = [0 for i in range(len(S))]
-            slacks[pos] = -1
+            num_sets = sum([1 if a in S[i] else 0 for i in range(len(S))])
+            assert num_sets >= 1, "Invalid subsets, check the universal set"
+            if num_sets > 1:
+                num_slacks += 1
+            slack_ub.append(num_sets-1)
+        for i, a in enumerate(elements):
+            constraint = [1 if a in S[j] else 0 for j in range(len(S))]
+            slacks = [0 for i in range(num_slacks)]
+            if slack_ub[i] > 0:
+                variables.append(f"s_{pos}")
+                slacks[pos] = -1
+                pos += 1
             A.append(constraint + slacks)
-            pos += 1
             b.append(1)
         n = len(variables)
         J = np.zeros((n, n))
@@ -84,11 +100,12 @@ class SetCoverModel(ConstrainedQuadraticModel):
         # call the superclass constructor with the objective and constraints
         super(SetCoverModel, self).__init__(h, J, np.array(A), np.array(b))
         # set upper bound on the variables to be 1 for x_i and the length of X minus 1 for the slacks
-        self.upper_bound = np.array([1 for i in range(len(weights))] + [len(X)-1 for i in range(n-len(weights))])
+        slack_ub = [val for val in slack_ub if val > 0]
+        self.upper_bound = np.array([1 for i in range(len(weights))] + slack_ub)
 
     def decode(self, solution) -> List:
         xbar = []
-        for i in range(len(self.X)):
+        for i in range(len(self.S)):
             if solution[i] > 0.5:
-                xbar.append(self.X[i])
+                xbar.append(self.S[i])
         return xbar

{eqc_models-0.10.1.data/platlib/eqc_models/assignment → eqc_models-0.11.0.data/platlib/eqc_models/combinatorics}/setpartition.py

@@ -86,6 +86,8 @@ class SetPartitionModel(ConstrainedPolynomialModel):
         b = np.ones((A.shape[0],))
         n = A.shape[1]
 
+        self.upper_bound = np.ones((n,), np.int32)
+
         # Define the linear objective function based on subset weights
         self.linear_objective = np.array(weights).reshape((n, 1))
         self.quad_objective = np.zeros((n, n)) #np.zeros_like(J)

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

@@ -1,20 +1,24 @@
 # (C) Quantum Computing Inc., 2024.
+from typing import Tuple
 import numpy as np
 import networkx as nx
 from .base import NodeModel
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
 
-
-class MaxKCutModel(NodeModel):
+class MaxKCutModel(ConstrainedQuadraticModel):
+    _objective = None
 
     def __init__(self, G : nx.Graph, k : int):
-        super(MaxKCutModel, self).__init__(G)
+        self.G = G
         self.k = k
-        self.lhs = None
-        self.rhs = None
-        self._objective = None
-        self._J = None
-        self._C = None
-
+        A, b = self._build_constraints()
+        c, J = self.costFunction()
+        ConstrainedQuadraticModel.__init__(self, c, J, A, b)
+        if k < 3:
+            raise ValueError("k must be greater than 2")
+        n = len(G.nodes) * k
+        self.upper_bound = np.ones((n,))
+        
     def decode(self, solution: np.ndarray) -> np.ndarray:
         """ Override the default decoding to use a the max cut metric to determine a solution """
 
@@ -22,7 +26,8 @@ class MaxKCutModel(NodeModel):
         # rather than the same cutoff per node, use the max value per partition
         decoded_solution = np.zeros_like(solution, dtype=np.int32)
         k = self.k
-        for i, u in enumerate(self.variables):
+        G = self.G
+        for i, u in enumerate(G.nodes):
             idx = slice(k*i, k*(i+1))
             spins = solution[idx]
             mx = np.max(spins)
@@ -35,9 +40,9 @@ class MaxKCutModel(NodeModel):
     def partition(self, solution):
         """ Return a dictionary with the partition number of each node """
         k = self.k
-        n = len(self.variables)
+        G = self.G
         partition_num = {}
-        for i, u in enumerate(self.variables):
+        for i, u in enumerate(G.nodes):
             for j in range(k):
                 if solution[i*k+j] == 1:
                     partition_num[u] = j+1
@@ -50,10 +55,10 @@ class MaxKCutModel(NodeModel):
                 cut_size += 1
         return cut_size
 
-    def _build_objective(self):
+    def costFunction(self) -> Tuple:
         
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
         # construct the quadratic portion of the objective
@@ -70,12 +75,12 @@ class MaxKCutModel(NodeModel):
                 idx1 = ibase + incr1
                 idx2 = jbase + incr2
                 objective[idx1, idx2] += -1
-        self._objective = (np.zeros((n, 1)), objective)
+        return (np.zeros((n, 1)), objective)
 
     def _build_constraints(self):
 
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
 
@@ -86,78 +91,31 @@ class MaxKCutModel(NodeModel):
             i = node_map.index(u)
             ibase = i * self.k
             A[i, ibase:ibase+self.k] = 1
-        self.lhs = A
-        self.rhs = b
-
-    def build(self, multiplier=None):
-        """ Create the constraints and objective and Hamiltonian """
-
-        # there are k * m variables in this problem where m is the number of nodes in the graph
-        node_map = self.variables
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        self.upper_bound = np.ones((n,))
-        
-        self._build_objective()
-        if multiplier is None:
-            multiplier = np.max(np.abs(self._objective[1]))
-        self._build_constraints()
-
-        self._C, self._J = self.buildH(multiplier)
-        self.sum_constraint = m
-
-    def buildH(self, multiplier):
-        """ Combine the objective and penalties using the multiplier """
-
-        objC, objJ = self.objective
-        lhs, rhs = self.constraints
-        Pq = lhs.T@lhs
-        Pl = -2 * rhs.T@lhs
-        offset = rhs.T@rhs
-        n = self.n
-        J = np.zeros((n, n), np.float32)
-        C = np.zeros([n, 1], np.float32)
-        C += objC
-        J[:,:] += objJ
-        C += multiplier * Pl.reshape((n, 1))
-        J[:,:] += multiplier * Pq
-        return C, J
+        return A, b
 
     @property
     def constraints(self):
         """ Return LHS, RHS in numpy matrix format """
-        if self.rhs is None:
-            self.build()
+
         return self.lhs, self.rhs
 
     @property
     def objective(self):
         """ Return the quadratic objective as NxN+1 matrix """
 
-        if self._objective is None:
-            self.build()
         return self._objective
 
-    @property
-    def H(self):
-        """ Return the Hamiltonian as parts C, J """
-
-        if self._C is None:
-            self.build()
-        return self._C, self._J
-    
 class WeightedMaxKCutModel(MaxKCutModel):
 
     def __init__(self, G: nx.Graph, k: int, weight_label : str = "weight"):
-        super().__init__(G, k)
+        super(WeightedMaxCutModel).__init__(G, k)
 
         self.weight_label = weight_label
     
     def _build_objective(self):
         
-        node_map = self.variables
         G = self.G
+        node_map = list(G.nodes)
         m = len(G.nodes)
         n = self.k * m
         # construct the quadratic portion of the objective
@@ -174,7 +132,7 @@ class WeightedMaxKCutModel(MaxKCutModel):
                 idx1 = ibase + incr1
                 idx2 = jbase + incr2
                 objective[idx1, idx2] += G[u][v][self.weight_label]
-        self._objective = (np.zeros((n, 1)), objective)
+        return (np.zeros((n, 1)), objective)
 
     def getCutSize(self, partition):
         cut_size = 0

eqc_models-0.11.0.data/platlib/eqc_models/sequence/scheduling.py

@@ -0,0 +1,29 @@
+import numpy as np
+from eqc_models.base.quadratic import ConstrainedQuadraticModel
+from eqc_models.base.constraints import InequalitiesMixin
+
+class CrewSchedulingModel(ConstrainedQuadraticModel):
+    """
+    Crew scheduling model
+
+    Parameters
+    ------------
+
+    crews : List
+    tasks : List
+
+    >>> crews = [{"name": "Maintenance Crew 1", "skills": ["A", "F"]}, 
+    ...          {"name": "Baggage Crew 1", "skills": ["B"]},
+    ...          {"name": "Maintenance Crew 2", "skills": ["A", "F"]}]
+    >>> tasks = [{"name": "Refuel", "skill_need": "F"},
+    ...          {"name": "Baggage", "skill_need": "B"}]
+
+    """
+
+    def __init__(self, crews, tasks):
+        self.crews = crews
+        self.tasks = tasks
+
+    def decode(self, solution) -> np.ndarray:
+        """ Translate the solution into a list of tasks for each crew """
+

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

@@ -68,10 +68,19 @@ class QciClientMixin:
             client = QciClient(url=self.url, api_token=self.api_token)
         return client
 
+    def getMetrics(self, job_id : str) -> Dict:
+        """
+        Returns a dictionary containing the job metrics.
+
+        """
+        client = self.client
+        metrics = client.get_job_metrics(job_id=job_id)
+        return metrics
+
 class Dirac1Mixin:
     sampler_type = "dirac-1"
     requires_operator = "qubo"
-    max_upper_bound = 1
+    max_upper_bound = 205 # log encoding beyond this level has inherent issues
     job_params_names = ["num_samples", "alpha", "atol"]
 
 class QuboSolverMixin:
@@ -141,7 +150,7 @@ class Dirac3Mixin:
         poly_indices = polynomial.indices
         data = []
         # must find these attributes of the polynomial before uploading
-        max_degree = 0
+        max_degree = 2
         min_degree = len(poly_indices[-1])
         num_variables = 0
         for i in range(len(poly_coeffs)):

{eqc_models-0.10.1.dist-info → eqc_models-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: eqc-models
-Version: 0.10.1
+Version: 0.11.0
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com
@@ -22,6 +22,7 @@ Provides-Extra: dev
 Requires-Dist: pytest<8,>=7.1.0; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: sphinx_rtd_theme<2,>=1.3.0; extra == "dev"
+Dynamic: license-file
 
 # EQC Models
 

eqc_models-0.11.0.dist-info/RECORD

@@ -0,0 +1,61 @@
+eqc_models-0.11.0.data/platlib/compile_extensions.py,sha256=ivFZ87WFzBITU7IwK_72C41MDNMortJIF8tKevm2aW4,1946
+eqc_models-0.11.0.data/platlib/eqc_models/__init__.py,sha256=WPUijJz2-4UZU-ZTqBofDc-Yaah24geHdmF16SkwIj4,683
+eqc_models-0.11.0.data/platlib/eqc_models/decoding.py,sha256=G3JgbIFzvZ3DIKW0kZ1JeTMIZmrc8hy9kzdbX2Xv5Og,637
+eqc_models-0.11.0.data/platlib/eqc_models/algorithms/__init__.py,sha256=lzQoMMSs2QTqp5suEYNvcQaSEN16d0LwIsZ1mRstumU,135
+eqc_models-0.11.0.data/platlib/eqc_models/algorithms/base.py,sha256=qfQQTwuVyewn7Qpg1_SVoD_7TsdA8vdwSKGqOeZSmNI,204
+eqc_models-0.11.0.data/platlib/eqc_models/algorithms/penaltymultiplier.py,sha256=SndGxCZDS3JTaxFOPJpTBumFdIKcB0dKwSHwfl_BI6o,7845
+eqc_models-0.11.0.data/platlib/eqc_models/allocation/__init__.py,sha256=op_udrapTlWrakTuQId3M0ggo-Y1w4nGJLPcYKOQ-8I,239
+eqc_models-0.11.0.data/platlib/eqc_models/allocation/allocation.py,sha256=PAQn4M75Zegeoy0i6r3hycWs4TKeRglHk05TvwZOoLk,15506
+eqc_models-0.11.0.data/platlib/eqc_models/allocation/portbase.py,sha256=BTnYYduHydPbrE2yQr_Sgv3XJACH_GpIJstuMrfGqCU,3269
+eqc_models-0.11.0.data/platlib/eqc_models/allocation/portmomentum.py,sha256=oMod63rNDC-01dLZjmhUb24SN3_GVgfc6CItgQL_obI,3756
+eqc_models-0.11.0.data/platlib/eqc_models/assignment/__init__.py,sha256=CX_QYl8P1meajV8gcVs6hm07VhoLVe8uu436t7-1XQo,86
+eqc_models-0.11.0.data/platlib/eqc_models/assignment/qap.py,sha256=WMiQQmTORsgi2w7kbmMA1xo-93dESLECWqYTF-zkmTs,2963
+eqc_models-0.11.0.data/platlib/eqc_models/assignment/setpartition.py,sha256=5SQxF_ZlQk4ubWf5_3TgL83k01hAakUP-5AydlD-BvE,161
+eqc_models-0.11.0.data/platlib/eqc_models/base/__init__.py,sha256=wKBppDk1lBiDvGOFnNpzu4lh7n4dQiyd_x3lNQJumTw,2952
+eqc_models-0.11.0.data/platlib/eqc_models/base/base.py,sha256=tL6z0MW4ffMKWlozZ0CH4soTiKxSlMXqyVDctaA110U,6405
+eqc_models-0.11.0.data/platlib/eqc_models/base/constraints.py,sha256=KMPyCdt_8GMWLnVEdpzw1T1WqXm2f7Lh629ClUH7XDY,8271
+eqc_models-0.11.0.data/platlib/eqc_models/base/operators.py,sha256=9nCeN6fRP-_YBfs-Gm57D-O_376qcOQiqGDuVlSlf00,7392
+eqc_models-0.11.0.data/platlib/eqc_models/base/polyeval.c,sha256=xyZgxdE5DbBJP3Q8ol7t5651V7bjVZNKH24HAeADeNk,438431
+eqc_models-0.11.0.data/platlib/eqc_models/base/polyeval.cpython-310-darwin.so,sha256=gS8RuuiASVDgHRiexrTgQiydL-CtTAMUts7jPOAPpJ4,108672
+eqc_models-0.11.0.data/platlib/eqc_models/base/polyeval.pyx,sha256=76Bf99Jt1_rLh5byrZxAjavE2F4_yCysirViqOBFIXw,2547
+eqc_models-0.11.0.data/platlib/eqc_models/base/polynomial.py,sha256=FQA26ihFlwfHz9k9XP3qDM0hl5Ko4rtUxiXloj3ail4,13056
+eqc_models-0.11.0.data/platlib/eqc_models/base/quadratic.py,sha256=BHZKniUvSq30pZgzguVasdO39BCEYue_wi5AIklPGS8,8062
+eqc_models-0.11.0.data/platlib/eqc_models/base/results.py,sha256=SPTDdlA2BOQjoaNvp7UGB1v5Veys8AGjQ3VDC1NpEQY,3301
+eqc_models-0.11.0.data/platlib/eqc_models/combinatorics/__init__.py,sha256=BhzcVxwpWu2b4jIe0bmPzD5VmSyzwp0oW2q9iYx2IUs,167
+eqc_models-0.11.0.data/platlib/eqc_models/combinatorics/setcover.py,sha256=T5hXoE9Ecw3mTHPLmifBwTzpF_4MhoCUgo2rkSOWt5s,3396
+eqc_models-0.11.0.data/platlib/eqc_models/combinatorics/setpartition.py,sha256=ZD69kgEYSU3KWnx0b4MVCP8XSxbA_VCXOW22_Yssl_M,6254
+eqc_models-0.11.0.data/platlib/eqc_models/graph/__init__.py,sha256=zlPE_c92wsuzz_wQLs0nxYi7tHCYxrPs-yOa9BhQAIo,162
+eqc_models-0.11.0.data/platlib/eqc_models/graph/base.py,sha256=j48OwhorZ5jTlTysTmMiXCeiAdj6jylBREk3NxCpFLI,2072
+eqc_models-0.11.0.data/platlib/eqc_models/graph/hypergraph.py,sha256=ABvutT0NOdIEpUF4TjUzboE4Y_J5iUZyj6-AzKr4R28,13268
+eqc_models-0.11.0.data/platlib/eqc_models/graph/maxcut.py,sha256=o8xVsAwTa9jcpmsIoCQ5z7HSstVdraT8TENomdT519o,4132
+eqc_models-0.11.0.data/platlib/eqc_models/graph/maxkcut.py,sha256=rEDBjto2MbuPh4c0RwTOZoVffKgcriqHNOZAIuBlclQ,4654
+eqc_models-0.11.0.data/platlib/eqc_models/graph/partition.py,sha256=HMpRRipLp14x8pHucY-g6fU7v0PGoy1pf_KpzbanfD0,5800
+eqc_models-0.11.0.data/platlib/eqc_models/ml/__init__.py,sha256=CLfraacr0FrD5ynxlNB6cyNy0lpbavcQT45TvkDrNvY,369
+eqc_models-0.11.0.data/platlib/eqc_models/ml/classifierbase.py,sha256=1yXufiUGpaiBjI2evMiwfYn-Zr-SnWwCnvtREqprtJw,2184
+eqc_models-0.11.0.data/platlib/eqc_models/ml/classifierqboost.py,sha256=5Dcpd0DjpMmlUULyZFKKWm4UuZpeMaknWKViiIjwc0U,18978
+eqc_models-0.11.0.data/platlib/eqc_models/ml/classifierqsvm.py,sha256=b6TdwlghR84UoQpfUThwMwNF_wmkABbCqOn6T1uY2dA,6636
+eqc_models-0.11.0.data/platlib/eqc_models/ml/clustering.py,sha256=yhh6jlgwZiQVn9h2pnYBlzVTCocK7rzsEurSQxCn5FQ,9486
+eqc_models-0.11.0.data/platlib/eqc_models/ml/clusteringbase.py,sha256=AvQbt6jeocBAGCuAmXHKyr3wLWqYUtBDq9PbsEOSlSc,2632
+eqc_models-0.11.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian.pyx,sha256=3PMmEJ_xfmmWXGfire0t-WASnmKj6-CblufgQ2NTARo,2111
+eqc_models-0.11.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.c,sha256=ZoKgm_uGjTewhk4W6s-x8QoFuZO0KVkxILIFh6JKsoI,1851
+eqc_models-0.11.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.h,sha256=aOImMG5pziUnZxGpDXyWjLrvcY7ZdsczwwSQ2ay4T88,272
+eqc_models-0.11.0.data/platlib/eqc_models/ml/decomposition.py,sha256=Nsnq0GmINpbGOszndgCHXqKdECNpiNiampBrHPU_Gjg,8943
+eqc_models-0.11.0.data/platlib/eqc_models/ml/forecast.py,sha256=fFcBxQK9ZryfEuyvlr9HXicHoZRzLFybimYYttzhI9E,7403
+eqc_models-0.11.0.data/platlib/eqc_models/ml/forecastbase.py,sha256=s-6nUMvtYqG07r7MmmkFVj8_QqgeGkD-HVoEEDTE2bk,3654
+eqc_models-0.11.0.data/platlib/eqc_models/ml/regressor.py,sha256=LA1woXCnefG0wfoOxilX1kszgCUmfNcbQgs_WZ4Ai0o,5683
+eqc_models-0.11.0.data/platlib/eqc_models/ml/regressorbase.py,sha256=H5E8-8pUji1oH5JRdS37LJQoHuKt2JU8eXCZp-ZaEM4,2109
+eqc_models-0.11.0.data/platlib/eqc_models/ml/reservoir.py,sha256=cPRvpCaWLYTBkui35jCssHcOPQgSQZallrG6Ac9djVI,2827
+eqc_models-0.11.0.data/platlib/eqc_models/sequence/__init__.py,sha256=VXlYufO3GYFsM00oii9Cite2WsQEF8XTwRcjLPH_Zlg,92
+eqc_models-0.11.0.data/platlib/eqc_models/sequence/scheduling.py,sha256=9gSD-L_n18NrE8K6CYTaIYRJ1JYI1ILhdEsk6xtsa68,841
+eqc_models-0.11.0.data/platlib/eqc_models/sequence/tsp.py,sha256=YM641FTyK5NkgRGxHrU1QmMkEU0gf77nEmIElTqa6Qw,7680
+eqc_models-0.11.0.data/platlib/eqc_models/solvers/__init__.py,sha256=hTjJI4F0FNDgQlK_oRHJxLIkg6of3I1-nEqU_3RL4Gk,542
+eqc_models-0.11.0.data/platlib/eqc_models/solvers/qciclient.py,sha256=uZrtK03oA9ozTGD--hUicmu8zoHYkuIaJ924tOtGwzU,27269
+eqc_models-0.11.0.data/platlib/eqc_models/utilities/__init__.py,sha256=SI2U7JKmPWSiq-F1WcSyfd7l9V6nbOZv_p8quMAZaT0,340
+eqc_models-0.11.0.data/platlib/eqc_models/utilities/fileio.py,sha256=alWPTfjGFx6Iio9HZAAWtYcLmZsBBifg6S6_YbFMQhk,1088
+eqc_models-0.11.0.data/platlib/eqc_models/utilities/polynomial.py,sha256=blXfu7Ehz9lT4nEmIinRzJOL27_qUHSbQ57zxmwDJCA,4735
+eqc_models-0.11.0.data/platlib/eqc_models/utilities/qplib.py,sha256=Do-MjmCFdI5HyDOAjfoz4_5lugySLMBlMAWDLUWx2OA,15796
+eqc_models-0.11.0.dist-info/licenses/LICENSE.txt,sha256=8eh0oqsNNVR1Jk-13gkqRRSo2axtUU5kp2KzH4f9u3U,11354
+eqc_models-0.11.0.dist-info/METADATA,sha256=6Ixla2-iQUpemI_tFaSn1vAeSR5c60n0XJX0kiFbk3I,7129
+eqc_models-0.11.0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+eqc_models-0.11.0.dist-info/top_level.txt,sha256=9ZfFeKNEvkRlKWoUnfcZ9TzmTdgdsuPEnTPy11Hqf4Q,30
+eqc_models-0.11.0.dist-info/RECORD,,

{eqc_models-0.10.1.dist-info → eqc_models-0.11.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any