Fix tests for cupy and cuquantum backends

src/qibo/backends/__init__.py

@@ -1,6 +1,7 @@
 import os
 
-from qibo.backends.abstract import Backend
+import numpy as np
+
 from qibo.backends.clifford import CliffordBackend
 from qibo.backends.npmatrices import NumpyMatrices
 from qibo.backends.numpy import NumpyBackend
@@ -200,3 +201,29 @@ def _check_backend(backend):
         return GlobalBackend()
 
     return backend
+
+
+def _check_backend_and_local_state(seed, backend):
+    if (
+        seed is not None
+        and not isinstance(seed, int)
+        and not isinstance(seed, np.random.Generator)
+    ):
+        raise_error(
+            TypeError, "seed must be either type int or numpy.random.Generator."
+        )
+
+    backend = _check_backend(backend)
+
+    if seed is None or isinstance(seed, int):
+        if backend.__class__.__name__ in [
+            "CupyBackend",
+            "CuQuantumBackend",
+        ]:  # pragma: no cover
+            local_state = backend.np.random.default_rng(seed)
+        else:
+            local_state = np.random.default_rng(seed)
+    else:
+        local_state = seed
+
+    return backend, local_state

src/qibo/backends/numpy.py

@@ -641,19 +641,23 @@ def aggregate_shots(self, shots):
         return self.cast(shots, dtype=shots[0].dtype)
 
     def samples_to_binary(self, samples, nqubits):
-        qrange = self.np.arange(nqubits - 1, -1, -1, dtype=self.np.int32)
-        return self.np.mod(
-            self.np.right_shift(self.cast(samples[:, None], dtype="int32"), qrange), 2
-        )
+        ### This is faster just staying @ NumPy.
+        qrange = np.arange(nqubits - 1, -1, -1, dtype=np.int32)
+        samples = self.to_numpy(samples)
+        return np.mod(np.right_shift(samples[:, None], qrange), 2)
 
     def samples_to_decimal(self, samples, nqubits):
-        qrange = self.np.arange(nqubits - 1, -1, -1, dtype=self.np.int32)
+        ### This is faster just staying @ NumPy.
+        qrange = np.arange(nqubits - 1, -1, -1, dtype=np.int32)
         qrange = (2**qrange)[:, None]
-        return self.np.matmul(samples, qrange)[:, 0]
+        samples = np.asarray(samples.tolist())
+        return np.matmul(samples, qrange)[:, 0]
 
     def calculate_frequencies(self, samples):
         # Samples are a list of strings so there is no advantage in using other backends
         res, counts = np.unique(samples, return_counts=True)
+        res = self.to_numpy(res).tolist()
+        counts = self.to_numpy(counts).tolist()
         return collections.Counter(dict(zip(res, counts)))
 
     def update_frequencies(self, frequencies, probabilities, nsamples):
@@ -677,6 +681,7 @@ def sample_frequencies(self, probabilities, nshots):
         )
 
     def apply_bitflips(self, noiseless_samples, bitflip_probabilities):
+        noiseless_samples = self.cast(noiseless_samples, dtype=noiseless_samples.dtype)
         fprobs = self.cast(bitflip_probabilities, dtype="float64")
         sprobs = self.cast(np.random.random(noiseless_samples.shape), dtype="float64")
         flip_0 = self.cast(sprobs < fprobs[0], dtype=noiseless_samples.dtype)