def test_sqrt(braket):
"""Test QAlgebra's scalar sqrt"""
half = sympify(1) / 2
expr = sqrt(braket)
assert expr == ScalarPower(braket, ScalarValue(half))
expr = 1 / sqrt(braket)
assert expr == ScalarPower(braket, ScalarValue(-half))
braket_abssq = braket * braket.dag()
expr = sqrt(braket_abssq)
assert expr**2 == braket_abssq
assert sqrt(half) == sympy_sqrt(half)
assert isinstance(sqrt(half), ScalarValue)
v = sqrt(ScalarValue(half))
assert isinstance(v, ScalarValue)
assert v == sympy_sqrt(half)
v = sqrt(2)
assert v == sympy_sqrt(2)
assert isinstance(v, ScalarValue)
v = sqrt(0.5)
assert v == np.sqrt(0.5)
assert isinstance(v, ScalarValue)
assert sqrt(-1) == sqrt(-One) == sqrt(-sympify(1)) == ScalarValue(I)
assert isinstance(sqrt(-1), ScalarValue)
assert sqrt(One) is One
assert sqrt(sympify(1)) is One
assert sqrt(Zero) is Zero
assert sqrt(sympify(0)) is Zero
with pytest.raises(TypeError):
assert sqrt(None) is Zero
def test_one():
"""Test use of the scalar One"""
alpha = ScalarValue(symbols('alpha'))
expr = alpha * One
assert expr == alpha
expr = alpha * 1
assert expr == alpha
expr = alpha / alpha
assert expr is One
assert expr == 1
assert hash(expr) == hash(1)
assert ScalarValue.create(1) is One
assert ScalarValue(1) == One
assert sympify(1) == One
assert One == sympify(1)
assert 1 == One
assert One == 1
assert 1 + 0j == One
assert One.val == 1
assert len(One.args) == 0
assert One.adjoint() == One.conjugate() == One
def test_zero():
"""Test use of the scalar Zero"""
alpha = ScalarValue(symbols('alpha'))
expr = alpha - alpha
assert expr is Zero
assert expr == 0
assert hash(expr) == hash(0)
expr = alpha + Zero
assert expr == alpha
expr = alpha + 0
assert expr == alpha
assert ScalarValue.create(0) is Zero
assert ScalarValue(0) == Zero
assert sympify(0) == Zero
assert Zero == sympify(0)
assert 0 == Zero
assert Zero == 0
assert 0j == Zero
assert Zero.val == 0
assert len(Zero.args) == 0
assert Zero.adjoint() == Zero.conjugate() == Zero
def test_sympify_scalar(braket):
"""Test that ScalarValue can be converted to sympy"""
two = ScalarValue.create(2)
half = sympify(1) / 2
assert One / 2 == half
alpha = symbols('alpha')
assert sympify(two) == sympify(2)
assert sympify(ScalarValue.create(alpha)) == alpha
with pytest.raises(SympifyError):
sympify(braket)
def test_differentiation(braket):
"""Test symbolic differentiation of scalars"""
t = symbols('t', real=True)
alpha = symbols('alpha')
expr = ScalarValue(alpha * t**2 / 2 + 2 * t)
half = sympify(1) / 2
assert expr.diff(t, 1) == alpha * t + 2
assert expr.diff(t, 2) == alpha
assert ScalarValue(2).diff(t, 1) is Zero
assert ScalarValue(2)._diff(t) is Zero
assert One.diff(t, 1) is Zero
assert One._diff(t) is Zero
assert Zero.diff(t, 1) is Zero
assert Zero._diff(t) is Zero
expr = braket * t**2 / 2 + 2 * t
assert isinstance(expr, Scalar)
assert expr.diff(t, 1) == braket * t + 2
expr = sqrt(braket * t)
assert expr.diff(t, 1) == half * braket * (braket * t)**(-half)
assert expr.diff(
t, 2) == -(half * half) * braket**2 * (braket * t)**(-3 * half)
expr = braket**2
assert expr.diff(t, 1) is Zero
def sqrt(scalar):
"""Square root of a :class:`.Scalar` or scalar value.
This always returns a :class:`Scalar`, and uses a symbolic square root if
possible (i.e., for non-floats)::
>>> sqrt(2)
sqrt(2)
>>> sqrt(2.0)
1.414213...
For a :class:`ScalarExpression` argument, it returns a
:class:`ScalarPower` instance::
>>> braket = KetSymbol('Psi', hs=0).dag() * KetSymbol('Phi', hs=0)
>>> nrm = sqrt(braket * braket.dag())
>>> print(srepr(nrm, indented=True))
ScalarPower(
ScalarTimes(
BraKet(
KetSymbol(
'Phi',
hs=LocalSpace(
'0')),
KetSymbol(
'Psi',
hs=LocalSpace(
'0'))),
BraKet(
KetSymbol(
'Psi',
hs=LocalSpace(
'0')),
KetSymbol(
'Phi',
hs=LocalSpace(
'0')))),
ScalarValue(
Rational(1, 2)))
"""
if isinstance(scalar, ScalarValue):
scalar = scalar.val
if scalar == 1:
return One
elif scalar == 0:
return Zero
elif isinstance(scalar, (float, complex, complex128, float64)):
return ScalarValue.create(numpy.sqrt(scalar))
elif isinstance(scalar, (int, sympy.Basic, int64)):
return ScalarValue.create(sympy.sqrt(scalar))
elif isinstance(scalar, Scalar):
return scalar ** (_sympyOne / 2)
else:
raise TypeError("Unknown type of scalar: %r" % type(scalar))
def __truediv__(self, other):
if other == 1:
return self
elif other == 0:
raise ZeroDivisionError("integer division or modulo by zero")
elif other == self:
return One
if isinstance(other, ScalarValue):
other = other.val
if isinstance(other, (float, complex, complex128, float64)):
return (ScalarValue(1 / other)) * self
elif isinstance(other, (int, sympy.Basic, int64)):
return (ScalarValue(_sympyOne / other)) * self
return super().__truediv__(other)
def _extract_delta(expr, idx):
"""Extract a "simple" Kronecker delta containing `idx` from `expr`.
Assuming `expr` can be written as the product of a Kronecker Delta and a
`new_expr`, return a tuple of the sympy.KroneckerDelta instance and
`new_expr`. Otherwise, return a tuple of None and the original `expr`
(possibly converted to a :class:`.QuantumExpression`).
On input, `expr` can be a :class:`QuantumExpression` or a
:class:`sympy.Basic` object. On output, `new_expr` is guaranteed to be a
:class:`QuantumExpression`.
"""
from qalgebra.core.abstract_quantum_algebra import QuantumExpression
from qalgebra.core.scalar_algebra import ScalarValue
sympy_factor, quantum_factor = _split_sympy_quantum_factor(expr)
delta, new_expr = _sympy_extract_delta(sympy_factor, idx)
if delta is None:
new_expr = expr
else:
new_expr = new_expr * quantum_factor
if isinstance(new_expr, ScalarValue._val_types):
new_expr = ScalarValue.create(new_expr)
assert isinstance(new_expr, QuantumExpression)
return delta, new_expr
def __init__(self, label, *sym_args, hs):
from qalgebra.core.scalar_algebra import ScalarValue
self._label = label
sym_args = [ScalarValue.create(arg) for arg in sym_args]
self._sym_args = tuple(sym_args)
if isinstance(label, str):
if not self._rx_label.match(label):
raise ValueError(
"label '%s' does not match pattern '%s'"
% (label, self._rx_label.pattern)
)
elif isinstance(label, SymbolicLabelBase):
self._label = label
else:
raise TypeError(
"type of label must be str or SymbolicLabelBase, not %s"
% type(label)
)
if isinstance(hs, (str, int)):
hs = self._default_hs_cls(hs)
elif isinstance(hs, tuple):
hs = ProductSpace.create(*[self._default_hs_cls(h) for h in hs])
self._hs = hs
super().__init__(label, *sym_args, hs=hs)
def test_scalar_times(braket):
"""Test instantiation of a ScalarTimes expression"""
expr = 2 * braket
assert expr == ScalarTimes(ScalarValue(2), braket)
assert expr == ScalarTimes.create(ScalarValue(2), braket)
assert expr == braket * 2
expr = ScalarTimes.create(2, braket, 2)
assert expr == 4 * braket
half = sympify(1) / 2
expr = ScalarTimes.create(2, braket, half)
assert expr == braket
expr = braket / 2
assert expr == ScalarTimes(ScalarValue(half), braket)
def test_scalar_power(braket):
"""Test instantiation of a ScalarPower expression"""
expr = braket * braket
assert expr == ScalarPower(braket, ScalarValue(2))
expr = braket**5
assert expr == ScalarPower(braket, ScalarValue(5))
expr = (1 + braket)**5
assert expr == ScalarPower(ScalarPlus(One, braket), ScalarValue(5))
expr = 2 / braket
assert expr == ScalarTimes(ScalarValue(2),
ScalarPower(braket, ScalarValue(-1)))
assert braket**0 is One
assert braket**1 == braket
def __init__(self, coeff, term):
from qalgebra.core.scalar_algebra import Scalar, ScalarValue
if not isinstance(coeff, Scalar):
coeff = ScalarValue.create(coeff)
self._order_coeff = coeff
self._order_args = KeyTuple([term._order_key])
super().__init__(coeff, term)
def test_scalar_invariant_create(braket):
"""Test that `ScalarValue.create` is invariant w.r.t existing scalars"""
three = ScalarValue(3)
assert ScalarValue.create(3) == three == 3
assert ScalarValue.create(three) is three
assert ScalarValue.create(braket) is braket
assert ScalarValue.create(One) is One
assert ScalarValue.create(Zero) is Zero
with pytest.raises(TypeError):
ScalarValue(ScalarValue(3))
def __add__(self, other):
if isinstance(other, ScalarValue):
return ScalarValue.create(1 + other.val)
elif isinstance(other, self._val_types):
return ScalarValue.create(1 + other)
elif other == 1:
return ScalarValue(2)
else:
return super().__add__(other)
def convert_to_scalars(cls, ops, kwargs):
"""Convert any entry in `ops` that is not a :class:`.Scalar` instance into
a :class:`.ScalarValue` instance"""
from qalgebra.core.scalar_algebra import Scalar, ScalarValue
scalar_ops = []
for op in ops:
if not isinstance(op, Scalar):
scalar_ops.append(ScalarValue(op))
else:
scalar_ops.append(op)
return scalar_ops, kwargs
def test_scalar_plus(braket):
"""Test instantiation of a ScalarPlus expression"""
expr = 1 + braket
assert expr == ScalarPlus(ScalarValue(1), braket)
assert expr.operands == (1, braket)
assert expr == ScalarPlus.create(braket, ScalarValue(1))
assert expr == braket + 1
alpha = symbols('alpha')
expr = braket - alpha
assert expr == ScalarPlus(ScalarValue(-alpha), braket)
assert expr == ScalarPlus.create(braket, ScalarValue(-alpha))
expr = alpha - braket
assert expr == ScalarPlus(ScalarValue(alpha),
ScalarTimes(ScalarValue(-1), braket))
assert expr == ScalarPlus.create(-braket, alpha)
expr = braket + braket
assert expr == ScalarTimes(ScalarValue(2), braket)
expr = ScalarPlus.create(1, braket, 3)
assert expr == 4 + braket
expr = ScalarPlus.create(1, 2, 3)
assert expr == ScalarValue(6)
expr = ScalarPlus.create(1, braket, -1)
assert expr == braket
expr = ScalarPlus.create(1, braket, -1, 3 * braket)
assert expr == 4 * braket
expr = ScalarPlus.create(1, braket, alpha)
assert expr == (1 + alpha) + braket
expr = ScalarPlus.create(ScalarValue(1), braket, ScalarValue(alpha))
assert expr == (1 + alpha) + braket
def test_scalar_conjugate(braket):
"""Test taking the complex conjugate (adjoint) of a scalar"""
Psi = KetSymbol("Psi", hs=0)
Phi = KetSymbol("Phi", hs=0)
phi = symbols('phi', real=True)
alpha = symbols('alpha')
expr = ScalarValue(1 + 1j)
assert expr.adjoint() == expr.conjugate() == 1 - 1j
assert braket.adjoint() == BraKet.create(Phi, Psi)
expr = 1j + braket
assert expr.adjoint() == expr.conjugate() == braket.adjoint() - 1j
expr = (1 + 1j) * braket
assert expr.adjoint() == expr.conjugate() == (1 - 1j) * braket.adjoint()
expr = braket**(I * phi)
assert expr.conjugate() == braket.adjoint()**(-I * phi)
expr = braket**alpha
assert expr.conjugate() == braket.adjoint()**(alpha.conjugate())
def test_real_complex():
"""Test converting ScalarValue to float/complex"""
val = ScalarValue(1 - 2j)
with pytest.raises(TypeError):
float(val)
c = complex(val)
assert c == 1 - 2j
assert c == val
assert c.real == 1
assert c.imag == -2
assert isinstance(c, complex)
val = ScalarValue(1.25)
f = float(val)
assert f == 1.25
assert f == val
assert isinstance(f, float)
alpha = ScalarValue(symbols('alpha'))
with pytest.raises(TypeError):
assert float(alpha) == 0
with pytest.raises(TypeError):
assert complex(alpha) == 0
def __mul__(self, other):
from qalgebra.core.scalar_algebra import ScalarValue, is_scalar
if not isinstance(other, self._base_cls):
if is_scalar(other):
other = ScalarValue.create(other)
# if other was an ScalarExpression, the conversion above leaves
# it unchanged
return self.__class__._scalar_times_expr_cls.create(
other, self
)
if isinstance(other, self.__class__._base_cls):
return self.__class__._times_cls.create(self, other)
else:
return NotImplemented
def terms(self):
"""Iterator over the terms of the sum.
Yield from the (possibly) infinite list of terms of the indexed sum, if
the sum was written out explicitly. Each yielded term in an instance of
:class:`.Expression`
"""
from qalgebra.core.scalar_algebra import ScalarValue
for mapping in yield_from_ranges(self.ranges):
term = self.term.substitute(mapping)
if isinstance(term, ScalarValue._val_types):
term = ScalarValue.create(term)
assert isinstance(term, Expression)
yield term
def test_scalar_expr_order_key():
"""Test that expr_order_key for ScalarValue instances compares just like
the wrapped values, in particular for Zero and One"""
half = ScalarValue(0.5)
two = ScalarValue(2.0)
alpha = ScalarValue(sympy.symbols('alpha'))
neg_two = ScalarValue(-2.0)
neg_alpha = ScalarValue(-sympy.symbols('alpha'))
key_half = expr_order_key(half)
key_two = expr_order_key(two)
key_one = expr_order_key(One)
key_zero = expr_order_key(Zero)
key_alpha = expr_order_key(alpha)
key_neg_two = expr_order_key(neg_two)
key_neg_alpha = expr_order_key(neg_alpha)
assert key_half < key_two
assert key_half < key_one
assert key_zero < key_half
assert key_zero < key_one
assert key_neg_two < key_zero
# comparison with symbolic should go by string representation, with the
# nice side-effect that negative symbols are smaller than positive numbers
assert key_one < key_alpha
assert key_neg_alpha < key_one
assert key_zero < key_alpha
assert key_neg_alpha < key_zero
assert key_two < key_alpha
assert key_neg_alpha < key_two
assert str(-2.0) < "alpha"
assert key_neg_two < key_alpha
assert str(-2.0) < "-alpha"
assert key_neg_two < key_neg_alpha
def test_scalar_times_expr_conversion(braket):
"""Test that the coefficient in ScalarTimesQuantumExpression is a Scalar,
and that Scalar times QuantumExpression is ScalarTimesQantumExpression"""
# We test with with a ScalarTimesOperator, but this will work for any
# ScalarTimesQuantumExpression
A = OperatorSymbol("A", hs=0)
alpha = symbols('alpha')
for coeff in (0.5, alpha / 2, braket, ScalarValue.create(alpha)):
for expr in (coeff * A, A * coeff):
assert isinstance(expr, ScalarTimesOperator)
assert isinstance(expr.coeff, Scalar)
assert expr.coeff == coeff
assert One * A == A
assert A * One == A
assert Zero * A is ZeroOperator
assert A * Zero is ZeroOperator
def KroneckerDelta(i, j, simplify=True):
"""Kronecker delta symbol.
Return :class:`One` (`i` equals `j`)), :class:`Zero` (`i` and `j` are
non-symbolic an unequal), or a :class:`ScalarValue` wrapping SymPy's
:class:`~sympy.functions.special.tensor_functions.KroneckerDelta`.
>>> i, j = IdxSym('i'), IdxSym('j')
>>> KroneckerDelta(i, i)
One
>>> KroneckerDelta(1, 2)
Zero
>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
By default, the Kronecker delta is returned in a simplified form, e.g::
>>> KroneckerDelta((i+1)/2, (j+1)/2)
KroneckerDelta(i, j)
This may be suppressed by setting `simplify` to False::
>>> KroneckerDelta((i+1)/2, (j+1)/2, simplify=False)
KroneckerDelta(i/2 + 1/2, j/2 + 1/2)
Raises:
TypeError: if `i` or `j` is not an integer or sympy expression. There
is no automatic sympification of `i` and `j`.
"""
from qalgebra.core.scalar_algebra import One, ScalarValue
if not isinstance(i, (int, sympy.Basic)):
raise TypeError(
"i is not an integer or sympy expression: %s" % type(i)
)
if not isinstance(j, (int, sympy.Basic)):
raise TypeError(
"j is not an integer or sympy expression: %s" % type(j)
)
if i == j:
return One
else:
delta = sympy.KroneckerDelta(i, j)
if simplify:
delta = _simplify_delta(delta)
return ScalarValue.create(delta)
def test_scalar_real_imag(braket):
"""Test taking the real and imaginary part of a scalar"""
alpha = symbols('alpha')
a, b = symbols('a, b', real=True)
braket_dag = braket.adjoint()
expr = ScalarValue(1 + 1j)
assert (expr.real, expr.imag) == (1, 1)
expr = ScalarValue(a + I * b)
assert (expr.real, expr.imag) == (a, b)
expr = ScalarValue(alpha)
assert (expr.real, expr.imag) == expr.as_real_imag()
assert (expr.real, expr.imag) == alpha.as_real_imag()
expr = Zero
assert (expr.real, expr.imag) == (Zero, Zero)
expr = One
assert (expr.real, expr.imag) == (One, Zero)
assert braket.real == (braket + braket_dag) / 2
assert braket.imag == (I / 2) * (braket_dag - braket)
expr = braket + One + I
assert expr.real.expand().simplify_scalar() == 1 + braket.real.expand()
assert expr.imag.expand().simplify_scalar() == 1 + braket.imag.expand()
expr = I * braket
assert expr.real.expand() == (-I / 2) * braket_dag + (I / 2) * braket
assert expr.imag.expand() == braket / 2 + braket_dag / 2
expr = braket**alpha
assert expr.real == (expr.adjoint() + expr) / 2
assert expr.imag == (I / 2) * (expr.adjoint() - expr)
def test_forwarded_attributes():
"""Test that ScalarValues forward unknown properties/methods to the wrapped
value"""
alpha_sym = symbols('alpha', positive=True)
alpha = ScalarValue(alpha_sym)
assert alpha.is_positive
assert alpha.compare(-1) == alpha_sym.compare(-1)
assert alpha.as_numer_denom() == (alpha_sym, 1)
with pytest.raises(AttributeError):
alpha.to_bytes(2, byteorder='big')
five = ScalarValue(5)
assert five.to_bytes(2, byteorder='big') == b'\x00\x05'
with pytest.raises(AttributeError):
five.is_positive
with pytest.raises(AttributeError):
five.as_numer_denom()
def test_scalar_numeric_methods(braket):
"""Test all of the numerical magic methods for scalars"""
three = ScalarValue(3)
two = ScalarValue(2)
spOne = sympify(1)
spZero = sympify(0)
spHalf = spOne / 2
assert three == 3
assert three == three
assert three != symbols('alpha')
assert three <= 3
assert three <= ScalarValue(4)
assert three >= 3
assert three >= ScalarValue(2)
assert three < 3.1
assert three < ScalarValue(4)
assert three > ScalarValue(2)
assert three == sympify(3)
assert three <= sympify(3)
assert three >= sympify(3)
assert three < sympify(3.1)
assert three > sympify(2.9)
with pytest.raises(TypeError):
assert three < symbols('alpha')
with pytest.raises(TypeError):
assert three <= symbols('alpha')
with pytest.raises(TypeError):
assert three > symbols('alpha')
with pytest.raises(TypeError):
assert three >= symbols('alpha')
assert hash(three) == hash(3)
v = -three
assert v == -3
assert isinstance(v, ScalarValue)
v = three + 1
assert v == 4
assert isinstance(v, ScalarValue)
v = three + two
assert v == 5
assert isinstance(v, ScalarValue)
v = three + Zero
assert v is three
assert three + spZero == three
v = three + One
assert v == 4
assert isinstance(v, ScalarValue)
assert three + spOne == 4
v = abs(ScalarValue(-3))
assert v == 3
assert isinstance(v, ScalarValue)
v = three - 4
assert v == -1
assert isinstance(v, ScalarValue)
v = three - two
assert v == 1
assert v is One
v = three - Zero
assert v is three
assert three - spZero == three
v = three - One
assert v == 2
assert isinstance(v, ScalarValue)
assert three - spOne == 2
v = three * 2
assert v == 6
assert isinstance(v, ScalarValue)
v = three * two
assert v == 6
assert isinstance(v, ScalarValue)
v = three * Zero
assert v == 0
assert v is Zero
assert three * spZero is Zero
v = three * One
assert v is three
assert three * spOne == three
v = three // 2
assert v is One
assert ScalarValue(3.5) // 1 == 3.0
v = three // two
assert v is One
v = three // One
assert v == three
assert three // spOne == three
with pytest.raises(ZeroDivisionError):
v = three // Zero
with pytest.raises(ZeroDivisionError):
v = three // spZero
with pytest.raises(ZeroDivisionError):
v = three // 0
v = three / 2
assert v == 3 / 2
assert isinstance(v, ScalarValue)
v = three / two
assert v == 3 / 2
assert isinstance(v, ScalarValue)
v = three / One
assert v is three
assert three / spOne == three
with pytest.raises(ZeroDivisionError):
v = three / Zero
with pytest.raises(ZeroDivisionError):
v = three / spZero
with pytest.raises(ZeroDivisionError):
v = three / 0
v = three % 2
assert v is One
assert three % 0.2 == 3 % 0.2
v = three % two
assert v is One
v = three % One
assert v is Zero
assert three % spOne is Zero
with pytest.raises(ZeroDivisionError):
v = three % Zero
with pytest.raises(ZeroDivisionError):
v = three % spZero
with pytest.raises(ZeroDivisionError):
v = three % 0
v = three**2
assert v == 9
assert isinstance(v, ScalarValue)
v = three**two
assert v == 9
assert isinstance(v, ScalarValue)
v = three**One
assert v is three
assert three**spOne == three
v = three**Zero
assert v is One
assert three**spZero is One
v = 1 + three
assert v == 4
assert isinstance(v, ScalarValue)
v = two + three
assert v == 5
assert isinstance(v, ScalarValue)
v = sympify(2) + three
assert v == 5
assert isinstance(v, SympyBasic)
v = 2.0 + three
assert v == 5
assert isinstance(v, ScalarValue)
v = Zero + three
assert v is three
with pytest.raises(TypeError):
None + three
assert spZero + three == three
v = One + three
assert v == 4
assert isinstance(v, ScalarValue)
assert spOne + three == 4
v = 1 - three
assert v == -2
assert isinstance(v, ScalarValue)
v = two - three
assert v == -1
assert isinstance(v, ScalarValue)
v = 2.0 - three
assert v == -1
assert isinstance(v, ScalarValue)
v = sympify(2) - three
assert v == -1
assert isinstance(v, SympyBasic)
v = Zero - three
assert v == -3
assert isinstance(v, ScalarValue)
with pytest.raises(TypeError):
None - three
assert spZero - three == -3
v = One - three
assert v == -2
assert isinstance(v, ScalarValue)
assert spOne - three == -2
v = 2 * three
assert v == 6
assert isinstance(v, ScalarValue)
v = Zero * three
assert v == 0
assert v is Zero
v = spZero * three
assert v == Zero
assert isinstance(v, SympyBasic)
v = One * three
assert v is three
assert spOne * three == three
with pytest.raises(TypeError):
None * three
v = 2 // three
assert v is Zero
v = two // three
assert v is Zero
v = One // three
assert v is Zero
v = spOne // three
assert v == Zero
assert isinstance(v, SympyBasic)
v = Zero // three
assert v is Zero
v = spZero // three
assert v == Zero
assert isinstance(v, SympyBasic)
v = 1 // three
assert v is Zero
with pytest.raises(TypeError):
None // three
v = 2 / three
assert float(v) == 2 / 3
assert v == Rational(2, 3)
assert isinstance(v, ScalarValue)
v = two / three
assert v == 2 / 3
assert isinstance(v, ScalarValue)
v = One / three
assert v == 1 / 3
assert isinstance(v, ScalarValue)
v = 1 / three
assert v == Rational(1, 3)
assert isinstance(v, ScalarValue)
assert float(spOne / three) == 1 / 3
v = Zero / three
assert v is Zero
v = spZero / three
assert v == Zero
assert isinstance(v, SympyBasic)
with pytest.raises(TypeError):
None / three
v = 2**three
assert v == 8
assert isinstance(v, ScalarValue)
v = 0**three
assert v is Zero
v = two**three
assert v == 8
assert isinstance(v, ScalarValue)
v = One**three
assert v is One
with pytest.raises(TypeError):
None**three
v = 1**three
assert v is One
v = One**spHalf
assert v is One
v = spOne**three
assert v == One
assert isinstance(v, SympyBasic)
v = Zero**three
assert v is Zero
v = spZero**three
assert v == Zero
assert isinstance(v, SympyBasic)
v = complex(three)
assert v == 3 + 0j
assert isinstance(v, complex)
v = int(ScalarValue(3.45))
assert v == 3
assert isinstance(v, int)
v = float(three)
assert v == 3.0
assert isinstance(v, float)
assert Zero == 0
assert Zero != symbols('alpha')
assert Zero <= One
assert Zero <= three
assert Zero >= Zero
assert Zero >= -three
assert Zero < One
assert Zero < three
assert Zero > -One
assert Zero > -three
assert Zero == spZero
assert Zero <= spZero
assert Zero >= spZero
assert Zero < spOne
assert Zero > -spOne
with pytest.raises(TypeError):
assert Zero < symbols('alpha')
with pytest.raises(TypeError):
assert Zero <= symbols('alpha')
with pytest.raises(TypeError):
assert Zero > symbols('alpha')
with pytest.raises(TypeError):
assert Zero >= symbols('alpha')
assert hash(Zero) == hash(0)
assert abs(Zero) is Zero
assert abs(One) is One
assert abs(ScalarValue(-1)) is One
assert -Zero is Zero
v = -One
assert v == -1
assert isinstance(v, ScalarValue)
assert Zero + One is One
assert One + Zero is One
assert Zero + Zero is Zero
assert Zero - Zero is Zero
assert One + One == 2
assert One - One is Zero
v = Zero + 2
assert v == 2
assert isinstance(v, ScalarValue)
v = Zero - One
assert v == -1
assert isinstance(v, ScalarValue)
v = Zero - 5
assert v == -5
assert isinstance(v, ScalarValue)
v = 2 + Zero
assert v == 2
assert isinstance(v, ScalarValue)
v = 2 - Zero
assert v == 2
assert isinstance(v, ScalarValue)
v = sympify(2) + Zero
assert v == 2
assert isinstance(v, SympyBasic)
v = sympify(2) - Zero
assert v == 2
assert isinstance(v, SympyBasic)
v = One + 2
assert v == 3
assert isinstance(v, ScalarValue)
v = 2 + One
assert v == 3
assert isinstance(v, ScalarValue)
v = 2 - One
assert v is One
v = 3 - One
assert v == 2
assert isinstance(v, ScalarValue)
v = One - 3
assert v == -2
assert isinstance(v, ScalarValue)
v = sympify(2) + One
assert v == 3
assert isinstance(v, SympyBasic)
v = sympify(2) - One
assert v == 1
assert isinstance(v, SympyBasic)
v = sympify(3) - One
assert v == 2
assert isinstance(v, SympyBasic)
with pytest.raises(TypeError):
None + Zero
with pytest.raises(TypeError):
None - Zero
with pytest.raises(TypeError):
None + One
with pytest.raises(TypeError):
None - One
alpha = symbols('alpha')
assert Zero * alpha is Zero
v = alpha * Zero
assert v == Zero
assert isinstance(v, SympyBasic)
assert 3 * Zero is Zero
with pytest.raises(TypeError):
None * Zero
assert Zero * alpha is Zero
assert Zero // 3 is Zero
assert One // 1 is One
assert One / 1 is One
assert One == 1
assert One != symbols('alpha')
assert One <= One
assert One <= three
assert One >= Zero
assert One >= -three
assert One < three
assert One > -three
assert One == spOne
assert One <= spOne
assert One >= spOne
assert One < sympify(3)
assert One > -sympify(3)
with pytest.raises(TypeError):
assert One < symbols('alpha')
with pytest.raises(TypeError):
assert One <= symbols('alpha')
with pytest.raises(TypeError):
assert One > symbols('alpha')
with pytest.raises(TypeError):
assert One >= symbols('alpha')
with pytest.raises(ZeroDivisionError):
One // 0
with pytest.raises(ZeroDivisionError):
One / 0
with pytest.raises(TypeError):
One // None
with pytest.raises(TypeError):
One / None
with pytest.raises(ZeroDivisionError):
3 // Zero
with pytest.raises(TypeError):
Zero // None
with pytest.raises(TypeError):
None // Zero
assert Zero / 3 is Zero
with pytest.raises(TypeError):
Zero / None
assert Zero % 3 is Zero
assert Zero % three is Zero
with pytest.raises(TypeError):
assert Zero % None
assert One % 3 is One
assert One % three is One
assert three % One is Zero
assert 3 % One is Zero
with pytest.raises(TypeError):
None % 3
v = sympify(3) % One
assert v == 0
assert isinstance(v, SympyBasic)
with pytest.raises(TypeError):
assert One % None
with pytest.raises(TypeError):
assert None % One
assert Zero**2 is Zero
assert Zero**spHalf is Zero
with pytest.raises(TypeError):
Zero**None
with pytest.raises(ZeroDivisionError):
v = Zero**-1
with pytest.raises(ZeroDivisionError):
v = 1 / Zero
v = spOne / Zero
assert v == sympy_infinity
with pytest.raises(ZeroDivisionError):
v = 1 / Zero
assert One - Zero is One
assert Zero * One is Zero
assert One * Zero is Zero
with pytest.raises(ZeroDivisionError):
v = 3 / Zero
with pytest.raises(ZeroDivisionError):
v = 3 % Zero
v = 3 / One
assert v == 3
assert isinstance(v, ScalarValue)
v = 3 % One
assert v is Zero
v = 1 % three
assert v is One
v = spOne % three
assert v == 1
assert isinstance(v, SympyBasic)
v = sympify(2) % three
assert v == 2
with pytest.raises(TypeError):
None % three
assert 3**Zero is One
v = 3**One
assert v == 3
assert isinstance(v, ScalarValue)
v = complex(Zero)
assert v == 0j
assert isinstance(v, complex)
v = int(Zero)
assert v == 0
assert isinstance(v, int)
v = float(Zero)
assert v == 0.0
assert isinstance(v, float)
v = complex(One)
assert v == 1j
assert isinstance(v, complex)
v = int(One)
assert v == 1
assert isinstance(v, int)
v = float(One)
assert v == 1.0
assert isinstance(v, float)
assert braket**Zero is One
assert braket**0 is One
assert braket**One is braket
assert braket**1 is braket
v = 1 / braket
assert v == braket**(-1)
assert isinstance(v, ScalarPower)
assert v.base == braket
assert v.exp == -1
v = three * braket
assert isinstance(v, ScalarTimes)
assert v == braket * 3
assert v == braket * sympify(3)
assert v == 3 * braket
assert v == sympify(3) * braket
assert braket * One is braket
assert braket * Zero is Zero
assert One * braket is braket
assert Zero * braket is Zero
assert spOne * braket is braket
assert spZero * braket is Zero
with pytest.raises(TypeError):
braket // 3
with pytest.raises(TypeError):
braket % 3
with pytest.raises(TypeError):
1 // braket
with pytest.raises(TypeError):
3 % braket
with pytest.raises(TypeError):
3**braket
assert 0**braket is Zero
assert 1**braket is One
assert spZero**braket is Zero
assert spOne**braket is One
assert One**braket is One
assert 0 // braket is Zero
assert 0 / braket is Zero
assert 0 % braket is Zero
with pytest.raises(ZeroDivisionError):
assert 0 / Zero
with pytest.raises(ZeroDivisionError):
assert 0 / ScalarValue.create(0)
assert 0 / ScalarValue(0) == sympy.nan
A = OperatorSymbol('A', hs=0)
v = A / braket
assert isinstance(v, ScalarTimesOperator)
assert v.coeff == braket**-1
assert v.term == A
with pytest.raises(TypeError):
v = None / braket
assert braket / three == (1 / three) * braket == (spOne / 3) * braket
assert braket / 3 == (1 / three) * braket
v = braket / 0.25
assert v == 4 * braket # 0.25 and 4 are exact floats
assert braket / sympify(3) == (1 / three) * braket
assert 3 / braket == 3 * braket**-1
assert three / braket == 3 * braket**-1
assert spOne / braket == braket**-1
braket2 = BraKet.create(KetSymbol("Chi", hs=0), KetSymbol("Psi", hs=0))
v = braket / braket2
assert v == braket * braket2**-1
with pytest.raises(ZeroDivisionError):
braket / Zero
with pytest.raises(ZeroDivisionError):
braket / 0
with pytest.raises(ZeroDivisionError):
braket / sympify(0)
assert braket / braket is One
with pytest.raises(TypeError):
braket / None
v = 1 + braket
assert v == braket + 1
assert isinstance(v, Scalar)
v = One + braket
assert v == braket + One
assert isinstance(v, Scalar)
assert Zero + braket is braket
assert spZero + braket is braket
assert braket + Zero is braket
assert braket + spZero is braket
assert 0 + braket is braket
assert braket + 0 is braket
assert (-1) * braket == -braket
assert Zero - braket == -braket
assert spZero - braket == -braket
assert braket - Zero is braket
assert braket - spZero is braket
assert 0 - braket == -braket
assert braket - 0 is braket
assert sympify(3) - braket == 3 - braket
def __neg__(self):
return ScalarValue(-1)
def test_series_expand(braket):
"""Test expansion of scalar into a series"""
t = symbols('t', real=True)
alpha = symbols('alpha')
three = ScalarValue(3)
expr = ScalarValue(alpha * t**2 / 2 + 2 * t)
assert expr.series_expand(t, about=0, order=4) == (
Zero,
2,
alpha / 2,
Zero,
Zero,
)
assert expr.series_expand(t, about=0, order=1) == (Zero, 2)
terms = expr.series_expand(t, about=1, order=4)
for term in terms:
assert isinstance(term, Scalar)
expr_from_terms = sum([terms[i] * (t - 1)**i for i in range(1, 5)],
terms[0])
assert expr_from_terms.val.expand() == expr
assert expr.series_expand(alpha, about=0, order=4) == (
2 * t,
t**2 / 2,
Zero,
Zero,
Zero,
)
assert expr.series_expand(symbols('x'), about=0, order=4) == (
expr,
Zero,
Zero,
Zero,
Zero,
)
assert three.series_expand(symbols('x'), 0, 2) == (three, Zero, Zero)
assert Zero.series_expand(symbols('x'), 0, 2) == (Zero, Zero, Zero)
assert One.series_expand(symbols('x'), 0, 2) == (One, Zero, Zero)
expr = One / ScalarValue(t)
with pytest.raises(ValueError) as exc_info:
expr.series_expand(t, 0, 2)
assert "singular" in str(exc_info.value)
expr = sqrt(ScalarValue(t))
assert expr.series_expand(t, 1, 2) == (One, One / 2, -One / 8)
with pytest.raises(ValueError) as exc_info:
expr.series_expand(t, 0, 2)
assert "singular" in str(exc_info.value)
expr = braket.bra
assert expr.series_expand(t, 0, 2) == (
braket.bra,
Bra(ZeroKet),
Bra(ZeroKet),
)
expr = braket
assert expr.series_expand(t, 0, 2) == (braket, Zero, Zero)
expr = t * braket
assert expr.series_expand(t, 0, 2) == (Zero, braket, Zero)
expr = (1 + t * braket)**2
assert expr.series_expand(t, 0, 2) == (One, 2 * braket, braket**2)
expr = (1 + t * braket)**(sympify(1) / 2)
with pytest.raises(ValueError):
expr.series_expand(t, 0, 2)
def a_b_c(braket):
"""Three example scalars for testing algebraic properties"""
a = braket
b = ScalarValue(symbols('b'))
c = ScalarValue(symbols('c'))
return (a, b, c)
def test_scalar_indexed_sum(braket):
"""Test instantiation and behavior of a ScalarIndexedSum"""
i = IdxSym('i')
ip = i.prime
ipp = ip.prime
alpha = IndexedBase('alpha')
a = symbols('a')
hs = LocalSpace(0)
ket_sum = KetIndexedSum(
alpha[1, i] * BasisKet(FockIndex(i), hs=hs),
ranges=(IndexOverRange(i, 1, 2), ),
)
bra = KetSymbol('Psi', hs=hs).dag()
expr = bra * ket_sum
half = sympify(1) / 2
assert isinstance(expr, ScalarIndexedSum)
assert isinstance(expr.term, ScalarTimes)
assert expr.term == bra * ket_sum.term
assert expr.ranges == ket_sum.ranges
assert expr.doit() == (alpha[1, 1] * bra * BasisKet(1, hs=hs) +
alpha[1, 2] * bra * BasisKet(2, hs=hs))
expr = ScalarIndexedSum.create(i, ranges=(IndexOverRange(i, 1, 2), ))
assert expr == ScalarIndexedSum(i, ranges=(IndexOverRange(i, 1, 2), ))
assert isinstance(expr.doit(), ScalarValue)
assert expr.doit() == 3
assert expr.real == expr
assert expr.imag == Zero
assert expr.conjugate() == expr
assert 3 * expr == expr * 3 == Sum(i, 1, 2)(3 * i)
assert a * expr == expr * a == Sum(i, 1, 2)(a * i)
assert braket * expr == ScalarTimes(braket, Sum(i, 1, 2)(i))
assert expr * braket == ScalarTimes(braket, Sum(i, 1, 2)(i))
assert (2 * i) * expr == 2 * expr * i
assert (2 * i) * expr == Sum(i, 1, 2)(2 * i * i.prime)
assert expr * expr == ScalarIndexedSum(
ScalarValue(i * ip),
ranges=(IndexOverRange(i, 1, 2), IndexOverRange(ip, 1, 2)),
)
sum3 = expr**3
assert sum3 == ScalarIndexedSum(
ScalarValue(i * ip * ipp),
ranges=(
IndexOverRange(i, 1, 2),
IndexOverRange(ip, 1, 2),
IndexOverRange(ipp, 1, 2),
),
)
assert expr**0 is One
assert expr**1 is expr
assert (expr**alpha).exp == alpha
assert expr**-1 == 1 / expr
assert (1 / expr).exp == -1
assert (expr**-alpha).exp == -alpha
sqrt_sum = sqrt(expr)
assert sqrt_sum == ScalarPower(expr, ScalarValue(half))
expr = ScalarIndexedSum.create(I * i, ranges=(IndexOverRange(i, 1, 2), ))
assert expr.real == Zero
assert expr.imag == ScalarIndexedSum.create(i,
ranges=(IndexOverRange(
i, 1, 2), ))
assert expr.conjugate() == -expr