eqc-models 0.10.0__py3-none-any.whl → 0.10.3__py3-none-any.whl

eqc_models-0.10.0.data/platlib/eqc_models/graphs.py

@@ -1,28 +0,0 @@
-from typing import List
-import networkx as nx
-from .quadraticmodel import QuadraticModel
-
-class GraphModel(QuadraticModel):
-
-    def __init__(self, G : nx.Graph):
-        self.G = G
-
-class TwoPartitionModel(GraphModel):
-    """ Create a model where the variables are node-based """
-
-    @property
-    def variables(self) -> List[str]:
-        """ Provide a variable name to index lookup, order enforced by sorting the list before returning """
-        names = [node.name for node in self.G.nodes]
-        names.sort()
-        return names
-    
-class EdgeModel(GraphModel):
-    """ Create a model where the variables are edge-based """
-
-    @property
-    def variables(self) -> List[str]:
-        """ Provide a variable name to index lookup, order enforced by sorting the list before returning """
-        names = [f"({u},{v})" for u, v in self.G.edges]
-        names.sort()
-        return names

eqc_models-0.10.0.data/platlib/eqc_models/maxcut.py

@@ -1,113 +0,0 @@
-import networkx as nx
-import numpy as np
-from .graphs import TwoPartitionModel
-
-class MaxCutModel(TwoPartitionModel):
-
-    def build(self):
-        variables = self.variables
-        n = len(variables)
-        self.domains = np.ones((n,))
-        
-        J = np.zeros((n+1, n+1), dtype=np.float32)
-        h = np.zeros((n+1,1), dtype=np.float32)
-        for u, v in G.edges:
-            J[u, v] += 1
-            J[v, u] += 1
-            J[u, u] = 1
-            J[v, v] = 1
-            h[u] -= 1
-            h[v] -= 1
-        J *= 1/t**2
-        h *= 1/t
-        H = np.hstack([h, J])
-        return H
-
-    @property
-    def J(self) -> np.ndarray:
-        if getattr(self, "_J", None) is None:
-            self.build()
-        return self._J
-
-    @property
-    def C(self) -> np.ndarray:
-        if getattr(self, "C", None) is None:
-            self.build()
-        return self._C
-    
-def get_graph(n, d):
-    """ Produce a repeatable graph with parameters n and d """
-
-    seed = n * d
-    return nx.random_graphs.random_regular_graph(d, n, seed)
-
-def get_partition_graph(G, solution):
-    """
-    Build the partitioned graph, counting cut size 
-
-    :parameters: G : nx.DiGraph, solution : np.ndarray
-    :returns: nx.DiGraph, int
-    
-    """
-
-    cut_size = 0
-    Gprime = nx.DiGraph()
-    Gprime.add_nodes_from(G.nodes)
-    for i, j in G.edges:
-        if solution[i] != solution[j]:
-            cut_size+=1
-        else:
-            Gprime.add_edge(i, j)
-    return Gprime, cut_size
-
-def determine_solution(G, solution):
-    """
-    Use a simple bisection method to determine the binary solution. Uses
-    the cut size as the metric.
-
-    Returns the partitioned graph and solution.
-
-    :parameters: G : nx.DiGraph, solution : np.ndarray
-    :returns: nx.DiGraph, np.ndarray
-
-    """
-
-    solution = np.array(solution)
-    lower = np.min(solution)
-    upper = np.max(solution)
-    best_cut_size = 0
-    best_graph = G
-    best_solution = None
-    while upper > lower + 0.0001:
-        middle = (lower + upper) / 2
-        test_solution = (solution>=middle).astype(np.int32)
-        Gprime, cut_size = get_partition_graph(G, test_solution)
-        if cut_size > best_cut_size:
-            best_cut_size = cut_size
-            lower = middle
-            best_solution = test_solution
-            best_graph = Gprime
-        else:
-            upper = middle
-    return best_graph, best_solution
-
-def get_maxcut_H(G, t):
-    """ 
-    Return a Hamiltonian representing the Maximum Cut Problem. Scale the problem using `t`.
-    Automatically adds a slack qudit.
-    
-    """
-    n = len(G.nodes)
-    J = np.zeros((n+1, n+1), dtype=np.float32)
-    h = np.zeros((n+1,1), dtype=np.float32)
-    for u, v in G.edges:
-        J[u, v] += 1
-        J[v, u] += 1
-        J[u, u] = 1
-        J[v, v] = 1
-        h[u] -= 1
-        h[v] -= 1
-    J *= 1/t**2
-    h *= 1/t
-    H = np.hstack([h, J])
-    return H

eqc_models-0.10.0.data/platlib/eqc_models/maxkcut.py

@@ -1,185 +0,0 @@
-import numpy as np
-import networkx as nx
-from .quadraticmodel import QuadraticModel
-
-
-class MaxKCut(QuadraticModel):
-
-    def __init__(self, G : nx.Graph, k : int):
-        self.G = G
-        self.node_map = list(G.nodes)
-        self.k = k
-        self.partitions = []
-        self._lhs = None
-        self._rhs = None
-        self._objective = None
-        self._J = None
-        self._C = None
-
-    def decode(self, solution: np.ndarray) -> np.ndarray:
-        """ Override the default decoding to use a the max cut metric to determine a solution """
-
-        # only one partition per node can be selected
-        # 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.node_map):
-            idx = slice(k*i, k*(i+1))
-            spins = solution[idx]
-            mx = np.max(spins)
-            for j in range(k):
-                if spins[j] == mx:
-                    decoded_solution[k*i+j] = 1
-                    break
-        return decoded_solution
-    
-    def partition(self, solution):
-        """ Return a dictionary with the partition number of each node """
-        k = self.k
-        n = len(self.node_map)
-        partition_num = {}
-        for i, u in enumerate(self.node_map):
-            for j in range(k):
-                if solution[i*k+j] == 1:
-                    partition_num[u] = j+1
-        return partition_num
-    
-    def getCutSize(self, partition):
-        cut_size = 0
-        for u, v in self.G.edges:
-            if partition[u]!=partition[v]:
-                cut_size += 1
-        return cut_size
-
-    def _build_objective(self):
-        
-        node_map = self.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        # construct the quadratic portion of the objective
-        # the linear portion is 0
-        objective = np.zeros((n, n), dtype=np.float32)
-        # increment the joint variable terms indicating the nodes are in different sets
-        pairs = [(i, j) for i in range(self.k) for j in range(self.k) if i!=j]
-        for u, v in G.edges:
-            i = node_map.index(u)
-            j = node_map.index(v)
-            ibase = i * self.k
-            jbase = j * self.k
-            for incr1, incr2 in pairs:
-                idx1 = ibase + incr1
-                idx2 = jbase + incr2
-                objective[idx1, idx2] += -1
-        self._objective = (np.zeros((n, 1)), objective)
-
-    def _build_constraints(self):
-
-        node_map = self.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-
-        # build the constraints
-        A = np.zeros((m, n))
-        b = np.ones((m,))
-        for u in G.nodes:
-            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.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        self.domains = 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
-
-    @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 WeightedMaxKCut(MaxKCut):
-
-    def __init__(self, G: nx.Graph, k: int, weight_label : str = "weight"):
-        super().__init__(G, k)
-
-        self.weight_label = weight_label
-    
-    def _build_objective(self):
-        
-        node_map = self.node_map
-        G = self.G
-        m = len(G.nodes)
-        n = self.k * m
-        # construct the quadratic portion of the objective
-        # the linear portion is 0
-        objective = np.zeros((n, n), dtype=np.float32)
-        # increment the joint variable terms indicating the nodes are in different sets
-        pairs = [(i, j) for i in range(self.k) for j in range(self.k) if i!=j]
-        for u, v in G.edges:
-            i = node_map.index(u)
-            j = node_map.index(v)
-            ibase = i * self.k
-            jbase = j * self.k
-            for incr1, incr2 in pairs:
-                idx1 = ibase + incr1
-                idx2 = jbase + incr2
-                objective[idx1, idx2] += G[u][v][self.weight_label]
-        self._objective = (np.zeros((n, 1)), objective)
-
-    def getCutSize(self, partition):
-        cut_size = 0
-        for u, v in self.G.edges:
-            if partition[u]!=partition[v]:
-                cut_size += self.G[u][v][self.weight_label]
-        return cut_size

eqc_models-0.10.0.data/platlib/eqc_models/quadraticmodel.py

@@ -1,131 +0,0 @@
-from typing import Tuple
-import numpy as np
-from .base import EqcModel
-
-class QuadraticMixIn:
-    C = None
-    J = None
-
-    def encode(self, levels:int=200, norm_value:float=None, dtype=np.float32) -> np.ndarray:
-        """ 
-        Encode Hamiltonian into the domain of the device 
-
-        The encoding method can be tuned using levels or norm_value. The parameter 
-        levels and the member self.domains are used to generate a vector t such that
-        $$
-        x = ts
-        $$
-        thus,
-        $$
-        h^Tx + x^TJx = h^T(ts) + (ts)^TJ(ts) = (th)^Ts + s^T(t\\cross tJ)s
-        $$
-        
-        """
-
-        n = max(self.domains.shape)
-        J = self.J
-        C = self.C
-        if norm_value is None:
-            max_level = levels - 1
-            multipliers = (self.domains) / max_level
-            J = np.array(np.outer(multipliers, multipliers) * J)
-            # h = np.multiply(h[:,0], multipliers)
-            C *= multipliers
-            C = C.reshape((n, 1))
-        else:
-            # normalize the operator
-            max_val_J = np.max(np.abs(J))
-            max_val_C = np.max(np.abs(C))
-            if max_val_J > max_val_C:
-                max_val = max_val_J
-            else:
-                max_val = max_val_C
-            C /= max_val
-            C *= norm_value
-            J /= max_val
-            J *= norm_value
-        # make J symmetric
-        J += J.T
-        J /= 2
-        # return operator in hJ format
-        H = np.hstack([C, J]).astype(dtype)
-
-        if self.machine_slacks > 0:
-            machine_slacks = self.machine_slacks
-            n = H.shape[0]
-            Hslack = np.zeros((n+machine_slacks, n+machine_slacks+1), dtype=dtype)
-            Hslack[:n, :n+1] = H
-            H = Hslack
-    
-        return np.array(H)
-        
-    @property
-    def sparse(self) -> Tuple[np.ndarray, np.ndarray]:
-        """ Put the linear and quadratic terms in a sparse format 
-        
-        :returns: coefficients : List, indices : List
-        """
-        C, J = self.H
-        n = self.n
-        indices = []
-        coefficients = []
-        # build a key (ordered tuple of indices) of length 2 for each element
-        for i in range(n):
-            if C[i,0] != 0:
-                key = (0, i+1)
-                indices.append(key)
-                coefficients.append(C[i,0])
-        # make J upper triangular
-        J = np.triu(J) + np.tril(J, -1).T
-        for i in range(n):
-            for j in range(i, n):
-                val = J[i, j]
-                if val != 0:
-                    key = (i+1, j+1)
-                    indices.append(key)
-                    coefficients.append(val)
-        return np.array(coefficients, dtype=np.float32), np.array(indices, dtype=np.int32)
-    
-    def evaluate(self, solution: np.ndarray, decode:bool=False, levels:int=200) -> float:
-        """ 
-        Evaluate the solution using the original operator. The decode
-        and levels parameters control the decoding of the solution. Without
-        specifying decode, the evaluation of the operator is done with the
-        solution provided.
-         
-        """
-        H = self.H
-        h, J = H[:, 0], H[:, 1:]
-        if decode:
-            sol = self.decode(solution)
-        else:
-            sol = solution
-        return np.squeeze(sol.T@J@sol + h.T@sol)
-
-class QuadraticModel(QuadraticMixIn, EqcModel):
-    """ Provides a quadratic operator and device sum constraint support """
-
-    def __init__(self, C : np.ndarray, J : np.ndarray, sum_constraint : float):
-        self._C = C
-        self._J = J
-        self._sum_constraint = sum_constraint
-    
-    @property
-    def H(self):
-        return self._C, self._J
-    
-    def check_constraint(self, solution: np.array) -> bool:
-        """ Evaluate the solution against the original sum constraint """
-        return np.sum(solution) == self.sum_constraint
-    
-    @property
-    def sum_constraint(self) -> int:
-        """ Integer value which all qudits must sum to.
-        The value must be less than or equal to  n * base for
-        the model to make sense. """
-
-        return self._sum_constraint
-
-    @sum_constraint.setter
-    def sum_constraint(self, value : int):
-        self._sum_constraint = value

eqc_models-0.10.0.data/platlib/eqc_models/solvers/eqcdirect.py

@@ -1,160 +0,0 @@
-# (C) Quantum Computing Inc., 2024.
-from typing import Dict
-import logging
-import numpy as np
-from eqc_direct.client import EqcClient
-from eqc_models.base.base import ModelSolver, EqcModel
-
-log = logging.getLogger(name=__name__)
-
-
-class EqcDirectMixin:
-    """
-    This class provides an instance method and property that
-    manage the direct connection to a QCi device.
-
-    """
-
-    ip_addr = None
-    port = None
-
-    def connect(self, ip_addr: str, port: str) -> str:
-        """
-        Explicitly set device address; if environment is
-        configured with the connection, this call is not required.
-
-        Parameters
-        ------------
-
-        ip_addr: The IP address of the device.
-
-        port: The port number of the device.
-
-        Parameters
-        ------------
-        The status.
-
-        """
-        self.ip_addr = ip_addr
-        self.port = port
-        client = self.client
-        return client.system_status()["status_desc"]
-
-    @property
-    def client(self):
-        params = {}
-        if self.ip_addr is not None:
-            params["ip_address"] = self.ip_addr
-        if self.port is not None:
-            params["port"] = self.port
-        return EqcClient(**params)
-
-
-class EqcDirectSolver(ModelSolver, EqcDirectMixin):
-    """
-    This class provides an instance method for direct submission
-    of jobs to QCi devices.
-
-    """
-
-    def solve(
-        self,
-        model: EqcModel,
-        relaxation_schedule: int = 2,
-        precision: float = 1.0,
-    ) -> Dict:
-        """Parameters
-        -------------
-        model: An EqcModel instance.
-
-        relaxation_schedule: A predefined schedule indicator which
-        sets parameters on the device to control the sampling through
-        photon measurement; default is 2.
-
-        precision: A value which, when not None, indicates
-        the numerical precision desired in the solution: 1 for
-        integer, 0.1 for tenths place, 0.01 for hundreths and None for
-        raw; default is 1.0.
-
-        Returns
-        ---------
-        Json response from the solver.
-
-        """
-        poly_coefficients, poly_indices = model.sparse
-        # print(poly_indices)
-        if model.machine_slacks > 0:
-            # add a single 0 coefficient entry as the next-highest index
-            highest_idx = int(np.max(poly_indices))
-            # print("POLY HIGHEST", highest_idx)
-            for i in range(model.machine_slacks):
-                addtl_index = [0 for i in range(len(poly_indices[0]))]
-                addtl_index[-1] = highest_idx + i + 1
-                poly_indices = poly_indices.tolist() + [addtl_index]
-                poly_coefficients = poly_coefficients.tolist() + [0]
-        # print(poly_indices)
-        scval = model.sum_constraint
-
-        client = self.client
-        lock_id, start_ts, end_ts = client.wait_for_lock()
-        log.debug(
-            "Got device lock id %s. Wait time %f",
-            lock_id,
-            end_ts - start_ts,
-        )
-        resp = None
-        try:
-            log.debug(
-                "Calling device with parameters relaxation_schedule %d sum_constraint %s lock_id %s solution_precision %f",
-                relaxation_schedule,
-                scval,
-                lock_id,
-                precision,
-            )
-            resp = client.process_job(
-                poly_coefficients=poly_coefficients,
-                poly_indices=poly_indices,
-                relaxation_schedule=relaxation_schedule,
-                sum_constraint=scval,
-                lock_id=lock_id,
-                solution_precision=precision,
-            )
-            log.debug("Received response with status %s", resp["err_desc"])
-            log.debug(
-                "Runtime %f resulting in energy %f",
-                resp["runtime"],
-                resp["energy"],
-            )
-            log.debug(
-                "Distillation runtime %s resulting in energy %f",
-                resp["distilled_runtime"],
-                resp["distilled_energy"],
-            )
-        finally:
-            client.release_lock(lock_id=lock_id)
-        if resp is not None:
-            solution = resp["solution"]
-            energy = resp["energy"]
-            runtime = resp["runtime"]
-            dirac3_sol = np.array(solution)
-            log.debug(
-                "Energy %f Runtime %f Solution Size %i Solution Sum %f",
-                energy,
-                runtime,
-                len(dirac3_sol),
-                sum(dirac3_sol),
-            )
-        else:
-            raise RuntimeError("FAILED TO GET RESPONSE")
-        return resp
-
-
-class Dirac3DirectSolver(EqcDirectSolver):
-
-    """
-    Naming this for when when other devices are available and have
-    different requirements. For instance, Dirac-3 requires the
-    summation constraint parameter, but others might not. The same
-    could be true for relaxation schedule.
-
-    """

eqc_models-0.10.0.dist-info/RECORD

@@ -1,65 +0,0 @@
-eqc_models-0.10.0.data/platlib/compile_extensions.py,sha256=ivFZ87WFzBITU7IwK_72C41MDNMortJIF8tKevm2aW4,1946
-eqc_models-0.10.0.data/platlib/eqc_models/__init__.py,sha256=njh-tvfgnAIVBGw9FXFv6XQOAgwrnBG23dU9dipa1Jg,585
-eqc_models-0.10.0.data/platlib/eqc_models/base.py,sha256=YWS9kjmh-ZEZqpByDaik4fLjeGbwKLLlqbVMsHto6Bs,3524
-eqc_models-0.10.0.data/platlib/eqc_models/communitydetection.py,sha256=-zqESm8MFDdaw_a39Kg6Wuu5Tvman3JOeUH4bbPXB48,891
-eqc_models-0.10.0.data/platlib/eqc_models/decoding.py,sha256=G3JgbIFzvZ3DIKW0kZ1JeTMIZmrc8hy9kzdbX2Xv5Og,637
-eqc_models-0.10.0.data/platlib/eqc_models/eqcdirectsolver.py,sha256=zoR8VHD9OFEBxKO9GW8sPLtuqVfWMubg4SDFCQKr3fc,2444
-eqc_models-0.10.0.data/platlib/eqc_models/graphs.py,sha256=8gWGwPKhAFoddYFRiJ770CNHrbudy_UVqgsv2BrHVDA,895
-eqc_models-0.10.0.data/platlib/eqc_models/maxcut.py,sha256=ohD08acRcmDhnxRI5MN1wvY6k81xUs8PRpsAzO5kQXI,2899
-eqc_models-0.10.0.data/platlib/eqc_models/maxkcut.py,sha256=fzittwUftQljSqe9yBS042-SXeyj2AmLTDuW8yc0JFw,5812
-eqc_models-0.10.0.data/platlib/eqc_models/quadraticmodel.py,sha256=vhWMNmKxzxaV6kdb9TTI-SqJMUEvKMLHfAOD6BVYBwc,4242
-eqc_models-0.10.0.data/platlib/eqc_models/algorithms/__init__.py,sha256=lzQoMMSs2QTqp5suEYNvcQaSEN16d0LwIsZ1mRstumU,135
-eqc_models-0.10.0.data/platlib/eqc_models/algorithms/base.py,sha256=qfQQTwuVyewn7Qpg1_SVoD_7TsdA8vdwSKGqOeZSmNI,204
-eqc_models-0.10.0.data/platlib/eqc_models/algorithms/penaltymultiplier.py,sha256=gV48irx3q9yvMsCRqv2fa8DGQEOUkgVNGbZdNzI-3Tc,7057
-eqc_models-0.10.0.data/platlib/eqc_models/allocation/__init__.py,sha256=op_udrapTlWrakTuQId3M0ggo-Y1w4nGJLPcYKOQ-8I,239
-eqc_models-0.10.0.data/platlib/eqc_models/allocation/allocation.py,sha256=PAQn4M75Zegeoy0i6r3hycWs4TKeRglHk05TvwZOoLk,15506
-eqc_models-0.10.0.data/platlib/eqc_models/allocation/portbase.py,sha256=BTnYYduHydPbrE2yQr_Sgv3XJACH_GpIJstuMrfGqCU,3269
-eqc_models-0.10.0.data/platlib/eqc_models/allocation/portmomentum.py,sha256=oMod63rNDC-01dLZjmhUb24SN3_GVgfc6CItgQL_obI,3756
-eqc_models-0.10.0.data/platlib/eqc_models/assignment/__init__.py,sha256=CX_QYl8P1meajV8gcVs6hm07VhoLVe8uu436t7-1XQo,86
-eqc_models-0.10.0.data/platlib/eqc_models/assignment/qap.py,sha256=WMiQQmTORsgi2w7kbmMA1xo-93dESLECWqYTF-zkmTs,2963
-eqc_models-0.10.0.data/platlib/eqc_models/assignment/setpartition.py,sha256=-DJjPgsSMslEjfo3iDdXbKHQ9Lfc3cHlNc-9DtkJnW0,6202
-eqc_models-0.10.0.data/platlib/eqc_models/base/__init__.py,sha256=RwZguuucmsuOSVqfPLBqj-wzinBOzcgO-2ifFU-DCqg,2885
-eqc_models-0.10.0.data/platlib/eqc_models/base/base.py,sha256=kpnOb1dw0aaQyassIYKNlS6rIH1fNvZMI-NKPosAEMk,4856
-eqc_models-0.10.0.data/platlib/eqc_models/base/constraints.py,sha256=KMPyCdt_8GMWLnVEdpzw1T1WqXm2f7Lh629ClUH7XDY,8271
-eqc_models-0.10.0.data/platlib/eqc_models/base/operators.py,sha256=9nCeN6fRP-_YBfs-Gm57D-O_376qcOQiqGDuVlSlf00,7392
-eqc_models-0.10.0.data/platlib/eqc_models/base/polyeval.c,sha256=4Rbo0snmzpBfk3EL1u5NLsYt_vni5wk_4p9XwsszFkg,445633
-eqc_models-0.10.0.data/platlib/eqc_models/base/polyeval.cpython-310-darwin.so,sha256=p9WsRiRpK18WJUHT4-x3s2VPr92_-DF5TLLPOuvwl_o,101024
-eqc_models-0.10.0.data/platlib/eqc_models/base/polyeval.pyx,sha256=76Bf99Jt1_rLh5byrZxAjavE2F4_yCysirViqOBFIXw,2547
-eqc_models-0.10.0.data/platlib/eqc_models/base/polynomial.py,sha256=dlWqL-PgSzV1UX-1S-MDwEL4sp3vs3h0vdRkv4JYfLo,12981
-eqc_models-0.10.0.data/platlib/eqc_models/base/quadratic.py,sha256=BHZKniUvSq30pZgzguVasdO39BCEYue_wi5AIklPGS8,8062
-eqc_models-0.10.0.data/platlib/eqc_models/combinatorics/setcover.py,sha256=v42_pB2gPF2YkVllCqqjw58t97y5AAddfWITIsESZI8,2730
-eqc_models-0.10.0.data/platlib/eqc_models/graph/__init__.py,sha256=Cpo4jb630U57J0lS_iZddE_W3v9N4ijUb7xZRIYuguo,95
-eqc_models-0.10.0.data/platlib/eqc_models/graph/base.py,sha256=j48OwhorZ5jTlTysTmMiXCeiAdj6jylBREk3NxCpFLI,2072
-eqc_models-0.10.0.data/platlib/eqc_models/graph/hypergraph.py,sha256=ABvutT0NOdIEpUF4TjUzboE4Y_J5iUZyj6-AzKr4R28,13268
-eqc_models-0.10.0.data/platlib/eqc_models/graph/maxcut.py,sha256=o8xVsAwTa9jcpmsIoCQ5z7HSstVdraT8TENomdT519o,4132
-eqc_models-0.10.0.data/platlib/eqc_models/graph/maxkcut.py,sha256=OFZwmC3wWpIJWVHOb9wkUeka0g0bOHrwf-mx0VZvt58,5807
-eqc_models-0.10.0.data/platlib/eqc_models/graph/partition.py,sha256=HMpRRipLp14x8pHucY-g6fU7v0PGoy1pf_KpzbanfD0,5800
-eqc_models-0.10.0.data/platlib/eqc_models/ml/__init__.py,sha256=CLfraacr0FrD5ynxlNB6cyNy0lpbavcQT45TvkDrNvY,369
-eqc_models-0.10.0.data/platlib/eqc_models/ml/classifierbase.py,sha256=1yXufiUGpaiBjI2evMiwfYn-Zr-SnWwCnvtREqprtJw,2184
-eqc_models-0.10.0.data/platlib/eqc_models/ml/classifierqboost.py,sha256=5Dcpd0DjpMmlUULyZFKKWm4UuZpeMaknWKViiIjwc0U,18978
-eqc_models-0.10.0.data/platlib/eqc_models/ml/classifierqsvm.py,sha256=b6TdwlghR84UoQpfUThwMwNF_wmkABbCqOn6T1uY2dA,6636
-eqc_models-0.10.0.data/platlib/eqc_models/ml/clustering.py,sha256=yhh6jlgwZiQVn9h2pnYBlzVTCocK7rzsEurSQxCn5FQ,9486
-eqc_models-0.10.0.data/platlib/eqc_models/ml/clusteringbase.py,sha256=AvQbt6jeocBAGCuAmXHKyr3wLWqYUtBDq9PbsEOSlSc,2632
-eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian.pyx,sha256=3PMmEJ_xfmmWXGfire0t-WASnmKj6-CblufgQ2NTARo,2111
-eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.c,sha256=ZoKgm_uGjTewhk4W6s-x8QoFuZO0KVkxILIFh6JKsoI,1851
-eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.h,sha256=aOImMG5pziUnZxGpDXyWjLrvcY7ZdsczwwSQ2ay4T88,272
-eqc_models-0.10.0.data/platlib/eqc_models/ml/decomposition.py,sha256=Nsnq0GmINpbGOszndgCHXqKdECNpiNiampBrHPU_Gjg,8943
-eqc_models-0.10.0.data/platlib/eqc_models/ml/forecast.py,sha256=fFcBxQK9ZryfEuyvlr9HXicHoZRzLFybimYYttzhI9E,7403
-eqc_models-0.10.0.data/platlib/eqc_models/ml/forecastbase.py,sha256=s-6nUMvtYqG07r7MmmkFVj8_QqgeGkD-HVoEEDTE2bk,3654
-eqc_models-0.10.0.data/platlib/eqc_models/ml/regressor.py,sha256=LA1woXCnefG0wfoOxilX1kszgCUmfNcbQgs_WZ4Ai0o,5683
-eqc_models-0.10.0.data/platlib/eqc_models/ml/regressorbase.py,sha256=H5E8-8pUji1oH5JRdS37LJQoHuKt2JU8eXCZp-ZaEM4,2109
-eqc_models-0.10.0.data/platlib/eqc_models/ml/reservoir.py,sha256=cPRvpCaWLYTBkui35jCssHcOPQgSQZallrG6Ac9djVI,2827
-eqc_models-0.10.0.data/platlib/eqc_models/sequence/__init__.py,sha256=VXlYufO3GYFsM00oii9Cite2WsQEF8XTwRcjLPH_Zlg,92
-eqc_models-0.10.0.data/platlib/eqc_models/sequence/tsp.py,sha256=YM641FTyK5NkgRGxHrU1QmMkEU0gf77nEmIElTqa6Qw,7680
-eqc_models-0.10.0.data/platlib/eqc_models/solvers/__init__.py,sha256=hTjJI4F0FNDgQlK_oRHJxLIkg6of3I1-nEqU_3RL4Gk,542
-eqc_models-0.10.0.data/platlib/eqc_models/solvers/eqcdirect.py,sha256=RzcRz3e3a0nJaR_qZ1td3NRKHT1NKPei_QNYExN3ooI,4898
-eqc_models-0.10.0.data/platlib/eqc_models/solvers/qciclient.py,sha256=Vnfqa1N6JSzigb-mbqXj6g0r-1wOkeYzmEmctId1VCo,26975
-eqc_models-0.10.0.data/platlib/eqc_models/utilities/__init__.py,sha256=SI2U7JKmPWSiq-F1WcSyfd7l9V6nbOZv_p8quMAZaT0,340
-eqc_models-0.10.0.data/platlib/eqc_models/utilities/fileio.py,sha256=alWPTfjGFx6Iio9HZAAWtYcLmZsBBifg6S6_YbFMQhk,1088
-eqc_models-0.10.0.data/platlib/eqc_models/utilities/polynomial.py,sha256=blXfu7Ehz9lT4nEmIinRzJOL27_qUHSbQ57zxmwDJCA,4735
-eqc_models-0.10.0.data/platlib/eqc_models/utilities/qplib.py,sha256=Do-MjmCFdI5HyDOAjfoz4_5lugySLMBlMAWDLUWx2OA,15796
-eqc_models-0.10.0.dist-info/LICENSE.txt,sha256=8eh0oqsNNVR1Jk-13gkqRRSo2axtUU5kp2KzH4f9u3U,11354
-eqc_models-0.10.0.dist-info/METADATA,sha256=vFFt3ENmDo-0sFt3-9V_ffKaZm2y9COhcC0N_AVbUvM,7107
-eqc_models-0.10.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-eqc_models-0.10.0.dist-info/top_level.txt,sha256=9ZfFeKNEvkRlKWoUnfcZ9TzmTdgdsuPEnTPy11Hqf4Q,30
-eqc_models-0.10.0.dist-info/RECORD,,