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

eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.c

@@ -0,0 +1,68 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <omp.h>
+#include "cvqboost_hamiltonian_c_func.h"
+
+void get_hamiltonian_c(
+    float **J,
+    float *C,
+    float **h_vals,
+    float *y,        
+    float lambda_coef,    
+    int n_records,
+    int n_classifiers
+) {
+    float tmp_i, tmp_j;
+
+    //    omp_set_num_threads(8);
+
+    /*
+    #pragma omp parallel
+    {
+        #pragma omp single
+        printf("Number of threads: %d\n", omp_get_num_threads());
+    }
+    */
+    
+    double start = omp_get_wtime();
+    // Compute J matrix
+    //#pragma omp parallel for collapse(2) //schedule(static,10)
+    for (int i = 0; i < n_classifiers; i++) {
+        for (int j = 0; j < n_classifiers; j++) {
+            J[i][j] = 0.0f;
+
+            // Parallelized innermost loop
+            #pragma omp parallel for reduction(+:J[i][j]) schedule(dynamic, 10000)
+            for (int k = 0; k < n_records; k++) {
+                tmp_i = h_vals[i][k];
+                tmp_j = h_vals[j][k];
+                J[i][j] += tmp_i * tmp_j;
+            }
+        }
+    }
+    double end = omp_get_wtime();
+    printf("Time J loop: %f seconds\n", end - start);
+    
+    // Compute C vector
+    start = omp_get_wtime();    
+    //#pragma omp parallel for schedule(static,10) 
+    for (int i = 0; i < n_classifiers; i++) {
+        C[i] = 0.0f;
+
+        // Parallelized innermost loop
+        #pragma omp parallel for reduction(+:C[i]) schedule(dynamic, 10000)
+        for (int m = 0; m < n_records; m++) {
+            tmp_i = -2.0f * y[m] * h_vals[i][m];
+            C[i] += tmp_i;
+        }
+    }
+    end = omp_get_wtime();
+    printf("Time C loop: %f seconds\n", end - start);
+
+    // Add lambda_coef to the diagonal of J
+    //#pragma omp parallel for schedule(static)
+    for (int i = 0; i < n_classifiers; i++) {
+        J[i][i] += lambda_coef;
+    }
+}

eqc_models-0.10.0.data/platlib/eqc_models/ml/cvqboost_hamiltonian_c_func.h

@@ -0,0 +1,14 @@
+#ifndef CVQBOOST_HAMILTONIAN_C_FUNC_H
+#define CVQBOOST_HAMILTONIAN_C_FUNC_H
+
+void get_hamiltonian_c(
+    float **J,
+    float *C,
+    float **h_vals,
+    float *y,
+    float lambda_coef,
+    int n_records,
+    int n_classifiers
+);
+
+#endif // CVQBOOST_HAMILTONIAN_C_FUNC_H

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

@@ -0,0 +1,131 @@
+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

@@ -0,0 +1,160 @@
+# (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.9.9.data → eqc_models-0.10.0.data}/platlib/eqc_models/utilities/polynomial.py

@@ -48,22 +48,33 @@ def convert_hamiltonian_to_polynomial(
     assert num_vars >= 1, "Invalid number of variables <%d>!" % num_vars
 
     if D is not None:
+        assert len(D.shape) == 4, "Incorrect shape!"                
         assert D.shape[0] == num_vars, "Inconsistent dimensions!"
         assert D.shape[1] == num_vars, "Inconsistent dimensions!"
         assert D.shape[2] == num_vars, "Inconsistent dimensions!"
         assert D.shape[3] == num_vars, "Inconsistent dimensions!"
         poly_order = 4
     elif C is not None:
+        assert len(C.shape) == 3, "Incorrect shape!"                
         assert C.shape[0] == num_vars, "Inconsistent dimensions!"
         assert C.shape[1] == num_vars, "Inconsistent dimensions!"
         assert C.shape[2] == num_vars, "Inconsistent dimensions!"
         poly_order = 3
     elif B is not None:
+        assert len(B.shape) == 2, "Incorrect shape!"        
         assert B.shape[0] == num_vars, "Inconsistent dimensions!"
         assert B.shape[1] == num_vars, "Inconsistent dimensions!"
         poly_order = 2
     elif A is not None:
+        assert len(A.shape) in [1, 2], "Incorrect shape!"
+        if len(A.shape) == 2:
+            if A.shape[1] == 1:
+                A = A.reshape((A.shape[0]))
+            else:
+                assert False, "Incorrect shape!"
+        
         assert A.shape[0] == num_vars, "Inconsistent dimensions!"
+            
         poly_order = 1
     else:
         assert False, "No hamiltonian provided!"

{eqc_models-0.9.9.dist-info → eqc_models-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: eqc-models
-Version: 0.9.9
+Version: 0.10.0
 Summary: Optimization and ML modeling package targeting EQC devices
 Author: Quantum Computing Inc.
 Author-email: support@quantumcomputinginc.com
@@ -13,6 +13,7 @@ License-File: LICENSE.txt
 Requires-Dist: numpy<2,>=1.22.1
 Requires-Dist: networkx<3,>=2.6.3
 Requires-Dist: pandas>=2.1.0
+Requires-Dist: scikit-learn>=1.2.1
 Requires-Dist: qci-client<5,>=4.3.0
 Requires-Dist: emucore-direct==1.0.6
 Provides-Extra: direct

eqc_models-0.10.0.dist-info/RECORD

@@ -0,0 +1,65 @@
+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,,

eqc_models-0.9.9.data/platlib/compile_extensions.py

@@ -1,23 +0,0 @@
-from setuptools import Extension
-from setuptools.command.build_py import build_py as _build_py
-import numpy
-
-# Modules to be compiled and include_dirs when necessary
-extensions = [
-    Extension(
-        "eqc_models.base.polyeval",
-        ["eqc_models/base/polyeval.pyx"], include_dirs=[numpy.get_include()],
-    ),
-]
-
-class build_py(_build_py):
-    def run(self):
-        self.run_command("build_ext")
-        return super().run()
-
-    def initialize_options(self):
-        super().initialize_options()
-        if self.distribution.ext_modules == None:
-            self.distribution.ext_modules = []
-
-        self.distribution.ext_modules.extend(extensions)