Method qalloc

python/cudaq/kernel/kernel_builder.py:769–918

Allocate a register of qubits of size `qubit_count` and return a handle to them as a :class:`QuakeValue`. Args: initializer (Union[`int`,`QuakeValue`, `list[T]`): The number of qubits to allocate or a concrete state to allocate and initialize

(self, initializer=None)

            return cc.CastOp(stateTy, valRef)

    def qalloc(self, initializer=None):
        """
        Allocate a register of qubits of size `qubit_count` and return a handle
        to them as a :class:`QuakeValue`.

        Args:
            initializer (Union[`int`,`QuakeValue`, `list[T]`): The number of
            qubits to allocate or a concrete state to allocate and initialize
            the qubits.
        Returns:
            :class:`QuakeValue`: A handle to the allocated qubits in the MLIR.

        ```python
            # Example:
            kernel = cudaq.make_kernel()
            qubits = kernel.qalloc(10)
        ```
        """
        with self.ctx, self.insertPoint, self.loc:
            # If the initializer is an integer, create `veq<N>`
            if isinstance(initializer, int):
                veqTy = quake.VeqType.get(initializer)
                return self.__createQuakeValue(quake.AllocaOp(veqTy).result)

            if isinstance(initializer, list):
                initializer = np.array(initializer, dtype=type(initializer[0]))

            if isinstance(initializer, np.ndarray):
                if len(initializer.shape) != 1:
                    raise RuntimeError("invalid initializer for qalloc "
                                       "(np.ndarray must be 1D, vector-like)")

                if initializer.dtype not in [
                        complex, np.complex128, np.complex64, float, np.float64,
                        np.float32, int
                ]:
                    raise RuntimeError("invalid initializer for qalloc (must "
                                       "be int, float, or complex dtype)")

                # Get current simulation precision and convert the initializer
                # if needed.
                simulationPrecision = self.simulationPrecision()
                if simulationPrecision == cudaq_runtime.SimulationPrecision.fp64:
                    if initializer.dtype not in [complex, np.complex128]:
                        initializer = initializer.astype(dtype=np.complex128)

                if simulationPrecision == cudaq_runtime.SimulationPrecision.fp32:
                    if initializer.dtype != np.complex64:
                        initializer = initializer.astype(dtype=np.complex64)

                if initializer.dtype == np.complex64:
                    fltTy = self.getFloatType(width=32)
                    eleTy = ComplexType.get(fltTy)
                else:
                    assert initializer.dtype == np.complex128
                    fltTy = self.getFloatType(width=64)
                    eleTy = ComplexType.get(fltTy)