pyqrack-cpu-complex128 1.58.9__py3-none-manylinux_2_39_x86_64.whl → 1.70.2__py3-none-manylinux_2_39_x86_64.whl

pyqrack/qrack_ace_backend.py

@@ -139,6 +139,12 @@ class LHVQubit:
         new_y = 2 * (rho_prime[0][1].imag - rho_prime[1][0].imag)
         new_z = 2 * rho_prime[0][0].real - 1  # since Tr(ρ') = 1
 
+        p = math.sqrt(new_x**2 + new_y**2 + new_z**2)
+
+        new_x /= p
+        new_y /= p
+        new_z /= p
+
         self.bloch = [new_x, new_y, new_z]
 
     def prob(self, basis=Pauli.PauliZ):
@@ -207,8 +213,8 @@ class QrackAceBackend:
     def __init__(
         self,
         qubit_count=1,
-        long_range_columns=5,
-        long_range_rows=2,
+        long_range_columns=4,
+        long_range_rows=4,
         is_transpose=False,
         isTensorNetwork=False,
         isSchmidtDecomposeMulti=False,
@@ -272,12 +278,8 @@ class QrackAceBackend:
             if long_range_rows < self._col_length:
                 self._is_row_long_range[-1] = False
         sim_count = col_patch_count * row_patch_count
-        self._row_offset = 0
-        for r in range(self._col_length):
-            for c in self._is_col_long_range:
-                self._row_offset += 1 if c else 3
 
-        self._qubit_dict = {}
+        self._qubits = []
         sim_counts = [0] * sim_count
         sim_id = 0
         tot_qubits = 0
@@ -294,7 +296,7 @@ class QrackAceBackend:
                     qubit.append(
                         LHVQubit(
                             toClone=(
-                                toClone._qubit_dict[tot_qubits][2] if toClone else None
+                                toClone._qubits[tot_qubits][2] if toClone else None
                             )
                         )
                     )
@@ -311,7 +313,7 @@ class QrackAceBackend:
                 if not c:
                     sim_id = (sim_id + 1) % sim_count
 
-                self._qubit_dict[tot_qubits] = qubit
+                self._qubits.append(qubit)
                 tot_qubits += 1
 
         self.sim = []
@@ -336,7 +338,8 @@ class QrackAceBackend:
 
             # You can still "monkey-patch" this, after the constructor.
             if "QRACK_QUNIT_SEPARABILITY_THRESHOLD" not in os.environ:
-                self.sim[i].set_sdrp(0.02375)
+                # (1 - 1 / sqrt(2)) / 4 (but empirically tuned)
+                self.sim[i].set_sdrp(0.073223304703363119)
 
     def clone(self):
         return QrackAceBackend(toClone=self)
@@ -427,7 +430,7 @@ class QrackAceBackend:
         self._qec_x(c)
 
     def _unpack(self, lq):
-        return self._qubit_dict[lq]
+        return self._qubits[lq]
 
     def _get_qb_lhv_indices(self, hq):
         qb = []
@@ -443,43 +446,50 @@ class QrackAceBackend:
 
         return qb, lhv
 
+    def _get_lhv_bloch_angles(self, sim):
+        # Z axis
+        z = sim.bloch[2]
+
+        # X axis
+        x = sim.bloch[0]
+
+        # Y axis
+        y = sim.bloch[1]
+
+        inclination = math.atan2(math.sqrt(x**2 + y**2), z)
+        azimuth = math.atan2(y, x)
+
+        return azimuth, inclination
+
     def _get_bloch_angles(self, hq):
-        sim = self.sim[hq[0]]
+        sim = self.sim[hq[0]].clone()
         q = hq[1]
+        sim.separate([q])
 
         # Z axis
         z = 1 - 2 * sim.prob(q)
-        prob = z**2
 
         # X axis
         sim.h(q)
         x = 1 - 2 * sim.prob(q)
-        prob += x**2
         sim.h(q)
 
         # Y axis
         sim.adjs(q)
         sim.h(q)
         y = 1 - 2 * sim.prob(q)
-        prob += y**2
         sim.h(q)
         sim.s(q)
 
-        prob = math.sqrt(prob)
         inclination = math.atan2(math.sqrt(x**2 + y**2), z)
         azimuth = math.atan2(y, x)
 
-        return prob, azimuth, inclination
+        return azimuth, inclination
 
-    def _rotate_to_bloch(
-        self, hq, azimuth_curr, inclination_curr, azimuth_target, inclination_target
-    ):
+    def _rotate_to_bloch(self, hq, delta_azimuth, delta_inclination):
         sim = self.sim[hq[0]]
         q = hq[1]
 
-        delta_azimuth = azimuth_target - azimuth_curr
-        delta_inclination = inclination_target - inclination_curr
-
         # Apply rotation as "Azimuth, Inclination" (AI)
         cosA = math.cos(delta_azimuth)
         sinA = math.sin(delta_azimuth)
@@ -493,8 +503,21 @@ class QrackAceBackend:
 
         sim.mtrx([m00, m01, m10, m11], q)
 
+    def _rotate_lhv_to_bloch(self, sim, delta_azimuth, delta_inclination):
+        # Apply rotation as "Azimuth, Inclination" (AI)
+        cosA = math.cos(delta_azimuth)
+        sinA = math.sin(delta_azimuth)
+        cosI = math.cos(delta_inclination / 2)
+        sinI = math.sin(delta_inclination / 2)
+
+        m00 = complex(cosI, 0)
+        m01 = complex(-cosA, sinA) * sinI
+        m10 = complex(cosA, sinA) * sinI
+        m11 = complex(cosI, 0)
+
+        sim.mtrx([m00, m01, m10, m11])
 
-    def _correct(self, lq, phase=False):
+    def _correct(self, lq, phase=False, skip_rotation=False):
         hq = self._unpack(lq)
 
         if len(hq) == 1:
@@ -545,31 +568,32 @@ class QrackAceBackend:
                     else:
                         self.sim[hq[q][0]].x(hq[q][1])
 
-            p, a, i = [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]
-            p[0], a[0], i[0] = self._get_bloch_angles(hq[0])
-            p[1], a[1], i[1] = self._get_bloch_angles(hq[1])
-            p[3], a[3], i[3] = self._get_bloch_angles(hq[3])
-            p[4], a[4], i[4] = self._get_bloch_angles(hq[4])
-
-            indices = []
-            a_target = 0
-            i_target = 0
-            weight = 0
-            for x in range(5):
-                if p[x] < 0.5:
-                    continue
-                indices.append(x)
-                w = (1.5 - p[x])
-                w *= w
-                a_target += w * a[x]
-                i_target += w * i[x]
-                weight += w
-
-            if len(indices) > 1:
-                a_target /= weight
-                i_target /= weight
-                for x in indices:
-                    self._rotate_to_bloch(hq[x], a[x], i[x], a_target, i_target)
+            if not skip_rotation:
+                a, i = [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]
+                a[0], i[0] = self._get_bloch_angles(hq[0])
+                a[1], i[1] = self._get_bloch_angles(hq[1])
+                a[2], i[2] = self._get_lhv_bloch_angles(hq[2])
+                a[3], i[3] = self._get_bloch_angles(hq[3])
+                a[4], i[4] = self._get_bloch_angles(hq[4])
+
+                a_target = 0
+                i_target = 0
+                for x in range(5):
+                    if x == 2:
+                        continue
+                    a_target += a[x]
+                    i_target += i[x]
+
+                a_target /= 5
+                i_target /= 5
+                for x in range(5):
+                    if x == 2:
+                        self._rotate_lhv_to_bloch(
+                            hq[x], a_target - a[x], i_target - i[x]
+                        )
+                    else:
+                        self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
+
         else:
             # RMS
             p = [
@@ -589,29 +613,29 @@ class QrackAceBackend:
                     else:
                         self.sim[hq[q][0]].x(hq[q][1])
 
-            p, a, i = [0, 0, 0], [0, 0, 0], [0, 0, 0]
-            p[0], a[0], i[0] = self._get_bloch_angles(hq[0])
-            p[1], a[1], i[1] = self._get_bloch_angles(hq[1])
-
-            indices = []
-            a_target = 0
-            i_target = 0
-            weight = 0
-            for x in range(3):
-                if p[x] < 0.5:
-                    continue
-                indices.append(x)
-                w = (1.5 - p[x])
-                w *= w
-                a_target += w * a[x]
-                i_target += w * i[x]
-                weight += w
-
-            if len(indices) > 1:
-                a_target /= weight
-                i_target /= weight
-                for x in indices:
-                    self._rotate_to_bloch(hq[x], a[x], i[x], a_target, i_target)
+            if not skip_rotation:
+                a, i = [0, 0, 0], [0, 0, 0]
+                a[0], i[0] = self._get_bloch_angles(hq[0])
+                a[1], i[1] = self._get_bloch_angles(hq[1])
+                a[2], i[2] = self._get_lhv_bloch_angles(hq[2])
+
+                a_target = 0
+                i_target = 0
+                for x in range(3):
+                    if x == 2:
+                        continue
+                    a_target += a[x]
+                    i_target += i[x]
+
+                a_target /= 3
+                i_target /= 3
+                for x in range(3):
+                    if x == 2:
+                        self._rotate_lhv_to_bloch(
+                            hq[x], a_target - a[x], i_target - i[x]
+                        )
+                    else:
+                        self._rotate_to_bloch(hq[x], a_target - a[x], i_target - i[x])
 
         if phase:
             for q in qb:
@@ -620,6 +644,29 @@ class QrackAceBackend:
             b = hq[lhv]
             b.h()
 
+    def apply_magnetic_bias(self, q, b):
+        if b == 0:
+            return
+        b = math.exp(b)
+        for x in q:
+            hq = self._unpack(x)
+            for c in range(len(hq)):
+                h = hq[c]
+                if c == 2:
+                    a, i = self._get_lhv_bloch_angles(h)
+                    self._rotate_lhv_to_bloch(
+                        h,
+                        math.atan(math.tan(a) * b) - a,
+                        math.atan(math.tan(i) * b) - i,
+                    )
+                else:
+                    a, i = self._get_bloch_angles(h)
+                    self._rotate_to_bloch(
+                        h,
+                        math.atan(math.tan(a) * b) - a,
+                        math.atan(math.tan(i) * b) - i,
+                    )
+
     def u(self, lq, th, ph, lm):
         hq = self._unpack(lq)
         if len(hq) < 2:
@@ -636,8 +683,8 @@ class QrackAceBackend:
         b = hq[lhv]
         b.u(th, ph, lm)
 
-        self._correct(lq, False)
-        self._correct(lq, True)
+        self._correct(lq, False, True)
+        self._correct(lq, True, False)
 
     def r(self, p, th, lq):
         hq = self._unpack(lq)
@@ -661,7 +708,7 @@ class QrackAceBackend:
             b.rz(th)
 
         if p != Pauli.PauliZ:
-            self._correct(lq, False)
+            self._correct(lq, False, p != Pauli.PauliX)
         if p != Pauli.PauliX:
             self._correct(lq, True)
 
@@ -885,7 +932,7 @@ class QrackAceBackend:
 
         self._correct(lq1, True)
         if pauli != Pauli.PauliZ:
-            self._correct(lq2, False)
+            self._correct(lq2, False, pauli != Pauli.PauliX)
         if pauli != Pauli.PauliX:
             self._correct(lq2, True)
 

pyqrack/qrack_simulator.py

@@ -60,6 +60,7 @@ class QrackSimulator:
         isHostPointer=(
             True if os.environ.get("PYQRACK_HOST_POINTER_DEFAULT_ON") else False
         ),
+        isSparse=False,
         noise=0,
         pyzxCircuit=None,
         qiskitCircuit=None,
@@ -99,6 +100,7 @@ class QrackSimulator:
                 isCpuGpuHybrid,
                 isOpenCL,
                 isHostPointer,
+                isSparse
             )
 
         self._throw_if_error()
@@ -1053,9 +1055,16 @@ class QrackSimulator:
         Returns:
             Measurement result of all qubits.
         """
-        result = Qrack.qrack_lib.MAll(self.sid)
+        num_q = self.num_qubits()
+        num_words = (num_q + 63) // 64
+        _r = (ctypes.c_ulonglong * num_words)()
+        Qrack.qrack_lib.MAllLong(self.sid, _r)
         self._throw_if_error()
-        return result
+        r = 0
+        for w in range(num_words):
+            r <<= 64
+            r |= _r[w]
+        return r
 
     def measure_pauli(self, b, q):
         """Pauli Measurement gate
@@ -2125,9 +2134,7 @@ class QrackSimulator:
     def decompose(self, q):
         """Decompose system
 
-        Decompose the given qubit out of the system.
-        Warning: The qubit subsystem state must be separable, or the behavior
-        of this method is undefined.
+        Factorize a set of contiguous bits with minimal fidelity loss.
 
         Args:
             q: qubit id
@@ -2137,7 +2144,7 @@ class QrackSimulator:
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot decompose()! (Turn off just this option, in the constructor.)
 
         Returns:
-            State of the systems.
+            Decomposed subsystem simulator.
         """
         if self.is_tensor_network:
             raise RuntimeError(
@@ -2154,10 +2161,8 @@ class QrackSimulator:
     def dispose(self, q):
         """Dispose qubits
 
-        Minimally decompose a set of contiguous bits from the separably
-        composed unit, and discard the separable bits.
-        Warning: The qubit subsystem state must be separable, or the behavior
-        of this method is undefined.
+        Factorize a set of contiguous bits with minimal fidelity loss,
+        and discard the separable bits.
 
         Args:
             q: qubit
@@ -2165,9 +2170,6 @@ class QrackSimulator:
         Raises:
             RuntimeError: QrackSimulator raised an exception.
             RuntimeError: QrackSimulator with isTensorNetwork=True option cannot dispose()! (Turn off just this option, in the constructor.)
-
-        Returns:
-            State of the systems.
         """
         if self.is_tensor_network:
             raise RuntimeError(
@@ -2285,6 +2287,72 @@ class QrackSimulator:
         self._throw_if_error()
         return list(probs)
 
+    def out_rdm(self, q):
+        """Get reduced density matrix
+
+        Returns the raw reduced density matrix of the simulator, for the qubit list.
+        Warning: State vector or is not always the internal representation leading
+        to sub-optimal performance of the method.
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            flat list structure representing the reduced density matrix.
+        """
+        amp_count = 1 << len(q)
+        sqr_amp_count = amp_count * amp_count
+        flat_rdm = self._qrack_complex_byref([complex(0, 0)] * sqr_amp_count)
+        Qrack.qrack_lib.OutReducedDensityMatrix(self.sid, len(q), self._ulonglong_byref(q), flat_rdm)
+        self._throw_if_error()
+        return [complex(r, i) for r, i in self._pairwise(flat_rdm)]
+
+    def highest_prob_perm(self):
+        """Get the permutation (bit string) with the highest probability
+
+        Returns the single highest-probability bit string in the Hilbert space
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            Highest probability dimension index
+        """
+        num_q = self.num_qubits()
+        num_words = (num_q + 63) // 64
+        _r = (ctypes.c_ulonglong * num_words)()
+        Qrack.qrack_lib.HighestProbAll(self.sid, _r)
+        self._throw_if_error()
+        r = 0
+        for w in range(num_words):
+            r <<= 64
+            r |= _r[w]
+        return r
+
+    def highest_n_prob_perm(self, n):
+        """Get the top n permutations (bit strings) with the highest probability
+
+        Returns the top n highest-probability bit strings in the Hilbert space
+
+        Raises:
+            RuntimeError: QrackSimulator raised an exception.
+
+        Returns:
+            Top n highest probability dimension indices
+        """
+        num_q = self.num_qubits()
+        num_words = (num_q + 63) // 64
+        _r = (ctypes.c_ulonglong * (num_words * n))()
+        Qrack.qrack_lib.HighestProbAllN(self.sid, n, _r)
+        self._throw_if_error()
+        r = [0] * n
+        for i in range(n):
+            r[i] = 0
+            for w in range(num_words):
+                r[i] <<= 64
+                r[i] |= _r[(i * num_words) + w]
+        return r
+
     def prob_all(self, q):
         """Probabilities of all subset permutations
 

pyqrack/qrack_system/qrack_system.py

@@ -87,19 +87,22 @@ class QrackSystem:
             CFUNCTYPE(c_ulonglong, c_double, c_double),
         ]
 
-        # These next two methods need to have c_double pointers, if PyQrack is built with fp64.
+        # These next few methods need to have c_double pointers, if PyQrack is built with fp64.
         self.qrack_lib.InKet.restype = None
         self.qrack_lib.OutKet.restype = None
         self.qrack_lib.OutProbs.restype = None
+        self.qrack_lib.OutReducedDensityMatrix.restype = None
 
         if self.fppow < 6:
             self.qrack_lib.InKet.argtypes = [c_ulonglong, POINTER(c_float)]
             self.qrack_lib.OutKet.argtypes = [c_ulonglong, POINTER(c_float)]
             self.qrack_lib.OutProbs.argtypes = [c_ulonglong, POINTER(c_float)]
+            self.qrack_lib.OutReducedDensityMatrix.argtypes = [c_ulonglong, c_ulonglong, POINTER(c_ulonglong), POINTER(c_float)]
         else:
             self.qrack_lib.InKet.argtypes = [c_ulonglong, POINTER(c_double)]
             self.qrack_lib.OutKet.argtypes = [c_ulonglong, POINTER(c_double)]
             self.qrack_lib.OutProbs.argtypes = [c_ulonglong, POINTER(c_double)]
+            self.qrack_lib.OutReducedDensityMatrix.argtypes = [c_ulonglong, c_ulonglong, POINTER(c_ulonglong), POINTER(c_double)]
 
         self.qrack_lib.init.restype = c_ulonglong
         self.qrack_lib.init.argtypes = []
@@ -108,10 +111,10 @@ class QrackSystem:
         self.qrack_lib.get_error.argtypes = [c_ulonglong]
 
         self.qrack_lib.init_count.restype = c_ulonglong
-        self.qrack_lib.init_count.argtypes = [c_ulonglong, c_bool]
+        self.qrack_lib.init_count.argtypes = [c_ulonglong, c_bool, c_bool]
 
         self.qrack_lib.init_count_pager.restype = c_ulonglong
-        self.qrack_lib.init_count_pager.argtypes = [c_ulonglong, c_bool]
+        self.qrack_lib.init_count_pager.argtypes = [c_ulonglong, c_bool, c_bool]
 
         self.qrack_lib.init_count_type.restype = c_ulonglong
         self.qrack_lib.init_count_type.argtypes = [
@@ -126,6 +129,7 @@ class QrackSystem:
             c_bool,
             c_bool,
             c_bool,
+            c_bool
         ]
 
         self.qrack_lib.init_count_stabilizer.restype = c_ulonglong
@@ -155,6 +159,12 @@ class QrackSystem:
 
         # pseudo-quantum
 
+        self.qrack_lib.HighestProbAll.restype = None
+        self.qrack_lib.HighestProbAll.argtypes = [c_ulonglong, POINTER(c_ulonglong)]
+
+        self.qrack_lib.HighestProbAllN.restype = None
+        self.qrack_lib.HighestProbAllN.argtypes = [c_ulonglong, c_ulonglong, POINTER(c_ulonglong)]
+
         self.qrack_lib.ProbAll.restype = None
         if self.fppow == 5:
             self.qrack_lib.ProbAll.argtypes = [
@@ -790,6 +800,9 @@ class QrackSystem:
         self.qrack_lib.MAll.restype = c_ulonglong
         self.qrack_lib.MAll.argtypes = [c_ulonglong]
 
+        self.qrack_lib.MAllLong.restype = None
+        self.qrack_lib.MAllLong.argtypes = [c_ulonglong, POINTER(c_ulonglong)]
+
         self.qrack_lib.Measure.restype = c_ulonglong
         self.qrack_lib.Measure.argtypes = [
             c_ulonglong,

{pyqrack_cpu_complex128-1.58.9.dist-info → pyqrack_cpu_complex128-1.70.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyqrack-cpu-complex128
-Version: 1.58.9
+Version: 1.70.2
 Summary: pyqrack - Pure Python vm6502q/qrack Wrapper
 Home-page: https://github.com/vm6502q/pyqrack
 Author: Daniel Strano
@@ -52,7 +52,7 @@ Dynamic: provides-extra
 Dynamic: summary
 
 # pyqrack
-[![Downloads](https://pepy.tech/badge/pyqrack-cpu)](https://pepy.tech/project/pyqrack-cpu) [![Downloads](https://pepy.tech/badge/pyqrack-cpu/month)](https://pepy.tech/project/pyqrack-cpu) [![Downloads](https://static.pepy.tech/badge/pyqrack-cpu/week)](https://pepy.tech/project/pyqrack-cpu)
+[![Downloads](https://pepy.tech/badge/pyqrack-cpu-complex128)](https://pepy.tech/project/pyqrack-cpu-complex128) [![Downloads](https://pepy.tech/badge/pyqrack-cpu-complex128/month)](https://pepy.tech/project/pyqrack-cpu-complex128) [![Downloads](https://static.pepy.tech/badge/pyqrack-cpu-complex128/week)](https://pepy.tech/project/pyqrack-cpu-complex128)
 
 Pure Python bindings for the pure C++11 Qrack quantum computer simulator library
 
@@ -88,4 +88,4 @@ For custom Qrack build floating-point precision, where options are `half`, `floa
 
 Please feel welcome to open an issue, if you'd like help. 😃
 
-**Special thanks go to Zeeshan Ahmed, for bug fixes and design suggestions, Ashish Panigrahi, for documentation and design suggestions, WingCode, for documentation, and to the broader community of Qrack contributors, for years of happy Qracking! You rock!**
+**Special thanks go to Zeeshan Ahmed, for bug fixes and design suggestions, Ashish Panigrahi, for documentation and design suggestions, WingCode, for documentation, Or Golan, for CI build pipeline tooling, and to the broader community of Qrack contributors, for years of happy Qracking! You rock!**

{pyqrack_cpu_complex128-1.58.9.dist-info → pyqrack_cpu_complex128-1.70.2.dist-info}/RECORD

@@ -1,23 +1,23 @@
 pyqrack/__init__.py,sha256=3tBwfCCD-zQjQ2g1EUZdggKdn-3b2uSFTbT7LS0YLaU,785
 pyqrack/neuron_activation_fn.py,sha256=fQTTFfsvwcot_43Vopacot47IV2Rxk8pelUyuzwpXPs,593
 pyqrack/pauli.py,sha256=wg500wDOwdIU4lEVJoMmjtbAdmtakZYzLPjdzC2rwUQ,654
-pyqrack/qrack_ace_backend.py,sha256=Q9XFDoe2miRqbqTm-ZrMdXBfZ8Bk2dkvJuaBc3RBcM8,47776
+pyqrack/qrack_ace_backend.py,sha256=Prw1NhVVt0csbHiJeW8MJI9rl1P1YS63sXM5quoNPrI,49392
 pyqrack/qrack_circuit.py,sha256=vDCKGbcEHJDFUKprjCpWgit8lXFnMrPimKHURD2_Hj4,19538
 pyqrack/qrack_neuron.py,sha256=UiJdjAGB6usjAGHWSosSFCUUeIkhh3MtZbsaxfsIsNw,9043
 pyqrack/qrack_neuron_torch_layer.py,sha256=Bs5BLC2GFevfSpo_jSJ2AZl-hfDRJmzlGN9pFw1CtoQ,6160
-pyqrack/qrack_simulator.py,sha256=2z4zGNPvDvVz2ctjeJl3jxUnKu0CxkABHvW5zxdUHa8,143781
+pyqrack/qrack_simulator.py,sha256=PSrcEIlzCt33WXjoEo5dZdmzx9zR90QI_Dw9LTphjMg,146030
 pyqrack/qrack_stabilizer.py,sha256=O-7VJ9Vw4h25PK_kesSjIqHXGSo8lLrQLIyGgmzG7Co,2124
 pyqrack/quimb_circuit_type.py,sha256=Sk-Tmn38kUYmAkJJ75btWuhYZyTXOOezmowFhfdiGDc,621
 pyqrack/qrack_system/__init__.py,sha256=-oZ9dsb1hixsnrkUJRY_C5DzQ_l6MtifF_Z465BgqV4,334
-pyqrack/qrack_system/qrack_system.py,sha256=FWEMiBfDDoNIAo8jbqFR9MkvRGr6rOU_frvKGMgnTO8,42943
+pyqrack/qrack_system/qrack_system.py,sha256=3NFejSMePILaND-h3bdwRrX-WuhdZj-Uzt-8i90_xQE,43719
 pyqrack/qrack_system/qrack_cl_precompile/qrack_cl_precompile,sha256=Yt1YxAOJ9vqlndghgIIXrosZEE3AZDG7eNpsmVUqBr4,16392
-pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.so,sha256=rhvAMOC9Xoi3mfAfFuMxV-qqZqxoGEsbu-iB0ZQ7ESs,3586520
-pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.so.9.21.0,sha256=rhvAMOC9Xoi3mfAfFuMxV-qqZqxoGEsbu-iB0ZQ7ESs,3586520
+pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.so,sha256=M_0LKmuwKaMZ0dytTZAn_EGGfffzoZpP-iJhzFFepWU,4517232
+pyqrack/qrack_system/qrack_lib/libqrack_pinvoke.so.9.29.2,sha256=M_0LKmuwKaMZ0dytTZAn_EGGfffzoZpP-iJhzFFepWU,4517232
 pyqrack/stats/__init__.py,sha256=Hla85my2fY_roR9lIjGBVpEG7ySOTMwjWa8D6-kgCnY,276
 pyqrack/stats/load_quantized_data.py,sha256=z12u9F7Nt3P-i44nY1xxvso_klS6WIHS3iqq7R2_lqE,1184
 pyqrack/stats/quantize_by_range.py,sha256=UM0_7jJDdQ7g30cR3UQAxkbzkqrmsy1oUfqg0h11FUY,2270
-pyqrack_cpu_complex128-1.58.9.dist-info/licenses/LICENSE,sha256=HxB-7SaWTuewAk1nz-3_3FUD6QhgX73kNT_taKVUTq8,1069
-pyqrack_cpu_complex128-1.58.9.dist-info/METADATA,sha256=fz8yI7-lUs7hmjNU7sSHL1pFbvT1-Q9krowpgwrKdYk,6151
-pyqrack_cpu_complex128-1.58.9.dist-info/WHEEL,sha256=k8EuOMBHdXsN9XSTE5LrpwS4FtdLkoSlyO_7W-lE_zg,109
-pyqrack_cpu_complex128-1.58.9.dist-info/top_level.txt,sha256=YE_3q9JTGRLMilNg2tGP1y7uU-Dx8PDao2OhwoIbv8E,8
-pyqrack_cpu_complex128-1.58.9.dist-info/RECORD,,
+pyqrack_cpu_complex128-1.70.2.dist-info/licenses/LICENSE,sha256=HxB-7SaWTuewAk1nz-3_3FUD6QhgX73kNT_taKVUTq8,1069
+pyqrack_cpu_complex128-1.70.2.dist-info/METADATA,sha256=IREfHo0IjEzILMenknlMSoy9jN4rafGh76kZ-I3D_fM,6258
+pyqrack_cpu_complex128-1.70.2.dist-info/WHEEL,sha256=k8EuOMBHdXsN9XSTE5LrpwS4FtdLkoSlyO_7W-lE_zg,109
+pyqrack_cpu_complex128-1.70.2.dist-info/top_level.txt,sha256=YE_3q9JTGRLMilNg2tGP1y7uU-Dx8PDao2OhwoIbv8E,8
+pyqrack_cpu_complex128-1.70.2.dist-info/RECORD,,