def assert_has_consistent_apply_unitary_for_various_exponents( val: Any, *, exponents=(0, 1, -1, 0.5, 0.25, -0.5, 0.1, sympy.Symbol('s')), qubit_count: Optional[int] = None) -> None: """Tests whether a value's _apply_unitary_ is correct. Contrasts the effects of the value's `_apply_unitary_` with the matrix returned by the value's `_unitary_` method. Attempts this after attempting to raise the value to several exponents. Args: val: The value under test. Should have a `__pow__` method. exponents: The exponents to try. Defaults to a variety of special and arbitrary angles, as well as a parameterized angle (a symbol). If the value's `__pow__` returns `NotImplemented` for any of these, they are skipped. qubit_count: A minimum qubit count for the test system. This argument isn't needed if the gate has a unitary matrix or implements `cirq.SingleQubitGate`/`cirq.TwoQubitGate`/`cirq.ThreeQubitGate`; it will be inferred. """ for exponent in exponents: gate = protocols.pow(val, exponent, default=None) if gate is not None: assert_has_consistent_apply_unitary( gate, qubit_count=qubit_count)
def __pow__(self, exponent: Any) -> 'ControlledOperation': new_sub_op = protocols.pow(self.sub_operation, exponent, NotImplemented) if new_sub_op is NotImplemented: return NotImplemented return ControlledOperation(self.controls, new_sub_op, self.control_values)
def assert_implements_consistent_protocols( val: Any, *, exponents: Sequence[Any] = (0, 1, -1, 0.25, -0.5, 0.1, sympy.Symbol('s')), qubit_count: Optional[int] = None, ignoring_global_phase: bool = False, setup_code: str = 'import cirq\nimport numpy as np\nimport sympy', global_vals: Optional[Dict[str, Any]] = None, local_vals: Optional[Dict[str, Any]] = None, ) -> None: """Checks that a value is internally consistent and has a good __repr__.""" global_vals = global_vals or {} local_vals = local_vals or {} _assert_meets_standards_helper( val, ignoring_global_phase=ignoring_global_phase, setup_code=setup_code, global_vals=global_vals, local_vals=local_vals, ) for exponent in exponents: p = protocols.pow(val, exponent, None) if p is not None: _assert_meets_standards_helper( val**exponent, ignoring_global_phase=ignoring_global_phase, setup_code=setup_code, global_vals=global_vals, local_vals=local_vals, )
def __pow__(self, exponent: Any) -> 'ControlledGate': new_sub_gate = protocols.pow(self.sub_gate, exponent, NotImplemented) if new_sub_gate is NotImplemented: return NotImplemented return ControlledGate(new_sub_gate, self.control_qubits)
def __pow__(self, exponent: Any) -> 'ControlledGate': new_sub_gate = protocols.pow(self.sub_gate, exponent, NotImplemented) if new_sub_gate is NotImplemented: return NotImplemented return ControlledGate(new_sub_gate, self.num_controls(), control_values=self.control_values, control_qid_shape=self.control_qid_shape)
def __pow__(self, power): if power == 1: return self new_ops = [] for op in self.operations: new_op = protocols.pow(op, power, default=None) if new_op is None: return NotImplemented new_ops.append(new_op) return Moment(new_ops)
def assert_implements_consistent_protocols( val: Any, *, exponents: Sequence[Any] = (0, 1, -1, 0.5, 0.25, -0.5, 0.1, value.Symbol('s')), qubit_count: Optional[int] = None, setup_code: str = 'import cirq\nimport numpy as np') -> None: """Checks that a value is internally consistent and has a good __repr__.""" _assert_meets_standards_helper(val, qubit_count, setup_code) for exponent in exponents: p = protocols.pow(val, exponent, None) if p is not None: _assert_meets_standards_helper(val**exponent, qubit_count, setup_code)
def __pow__(self, exponent: Any) -> 'ParallelGate': """Raises underlying gate to a power, applying same number of copies. For extrapolatable gate G this means the following two are equivalent: (G ** 1.5) x k or (G x k) ** 1.5 Args: exponent: The amount to scale the gate's effect by. Returns: ParallelGate with same num_copies with the scaled underlying gate. """ new_gate = protocols.pow(self.sub_gate, exponent, NotImplemented) if new_gate is NotImplemented: return NotImplemented return self.with_gate(new_gate)
def __pow__(self, exponent: Any) -> 'cirq.Operation': """Raise gate to a power, then reapply to the same qubits. Only works if the gate implements cirq.ExtrapolatableEffect. For extrapolatable gate G this means the following two are equivalent: (G ** 1.5)(qubit) or G(qubit) ** 1.5 Args: exponent: The amount to scale the gate's effect by. Returns: A new operation on the same qubits with the scaled gate. """ new_gate = protocols.pow(self.gate, exponent, NotImplemented) if new_gate is NotImplemented: return NotImplemented return self.with_gate(new_gate)
def assert_has_consistent_apply_unitary_for_various_exponents( val: Any, *, exponents=(0, 1, -1, 0.5, 0.25, -0.5, 0.1, sympy.Symbol('s'))) -> None: """Tests whether a value's _apply_unitary_ is correct. Contrasts the effects of the value's `_apply_unitary_` with the matrix returned by the value's `_unitary_` method. Attempts this after attempting to raise the value to several exponents. Args: val: The value under test. Should have a `__pow__` method. exponents: The exponents to try. Defaults to a variety of special and arbitrary angles, as well as a parameterized angle (a symbol). If the value's `__pow__` returns `NotImplemented` for any of these, they are skipped. """ for exponent in exponents: gate = protocols.pow(val, exponent, default=None) if gate is not None: assert_has_consistent_apply_unitary(gate)