Method control

python/cudaq/kernel/kernel_builder.py:1351–1387

Apply the `target` kernel as a controlled operation in-place to `self`. Uses the provided `control` as control qubit/s for the operation. Args: target (:class:`Kernel`): The kernel to apply as a controlled operation in-place to self. control (:c

(self, target, control, *target_arguments)

        return

    def control(self, target, control, *target_arguments):
        """
        Apply the `target` kernel as a controlled operation in-place to `self`.
        Uses the provided `control` as control qubit/s for the operation.

        Args:
        target (:class:`Kernel`): The kernel to apply as a controlled 
            operation in-place to self.
        control (:class:`QuakeValue`): The control qubit or register to 
            use when applying `target`.
        *target_arguments (Optional[:class:`QuakeValue`]): The arguments to the 
            `target` kernel. Leave empty if the `target` kernel doesn't accept 
            any arguments.

        Raises:
        RuntimeError: if the `*target_arguments` passed to the control 
            call don't match the argument signature of `target`.

        ```python
            # Example:
            # Create a `Kernel` that accepts a qubit as an argument.
            # Apply an X-gate on that qubit.
            target_kernel, qubit = cudaq.make_kernel(cudaq.qubit)
            target_kernel.x(qubit)
            # Create another `Kernel` that will apply `target_kernel`
            # as a controlled operation.
            kernel = cudaq.make_kernel()
            control_qubit = kernel.qalloc()
            target_qubit = kernel.qalloc()
            # In this case, `control` performs the equivalent of a 
            # controlled-X gate between `control_qubit` and `target_qubit`.
            kernel.control(target_kernel, control_qubit, target_qubit))
        ```
        """
        self.__applyControlOrAdjoint(target, False, [control.mlirValue],
                                     *target_arguments)
        return

    def apply_call(self, target, *target_arguments):
        """