def dot_product(self, alpha: Sequence[float] | np.ndarray) -> np.ndarray:
"""
Computes the standard dot product of `alpha` with the paulis.
Args:
alpha (Sequence[float] | np.ndarray): The pauli coefficients.
Returns:
(np.ndarray): Sum of element-wise multiplication of `alpha`
and `self.paulis`.
Raises:
ValueError: If `alpha` and `self.paulis` are incompatible.
"""
if not is_sequence(alpha) or not all(is_numeric(a) for a in alpha):
raise TypeError(
'Expected a sequence of numbers, got %s.' % type(alpha), )
if len(alpha) != len(self):
raise ValueError(
'Incorrect number of alpha values, expected %d, got %d.' %
(len(self), len(alpha)), )
return np.array(np.sum([a * s for a, s in zip(alpha, self.paulis)], 0))
def check_parameters(self, params: Sequence[float] | np.ndarray) -> None:
"""Checks to ensure parameters are valid and match the unitary."""
if not is_sequence(params):
raise TypeError(
'Expected a sequence type for params, got %s.' %
type(params), )
if not all(is_numeric(p) for p in params):
typechecks = [is_numeric(p) for p in params]
fail_idx = typechecks.index(False)
raise TypeError(
'Expected params to be floats, got %s.' %
type(params[fail_idx]), )
if len(params) != self.get_num_params():
raise ValueError(
'Expected %d params, got %d.' %
(self.get_num_params(), len(params)), )
def test_type(self, r6_qudit_circuit: Circuit) -> None:
params = r6_qudit_circuit.get_params()
assert isinstance(params, np.ndarray)
assert all(is_numeric(param) for param in params)
def test_not_a_seq_float(self, not_a_seq_float: Any) -> None:
assert (not is_sequence(not_a_seq_float)
or isinstance(not_a_seq_float, str)
or any(not is_numeric(f) or is_integer(f) or is_complex(f)
for f in not_a_seq_float))
def test_a_seq_float(self, a_seq_float: Any) -> None:
assert is_sequence(a_seq_float)
assert len(a_seq_float) >= 0
assert all(
is_numeric(f) and not is_integer(f) and not is_complex(f)
for f in a_seq_float)
def test_not_a_float(self, not_a_float: Any) -> None:
assert (not is_numeric(not_a_float) or is_integer(not_a_float)
or is_complex(not_a_float))
def test_a_float(self, a_float: Any) -> None:
assert (is_numeric(a_float) and not is_integer(a_float)
and not is_complex(a_float))