def test_dim_simplify_dimless():
assert dim_simplify(Mul(Pow(sin(Mul(L, Pow(L, -1))), 2), L)) == L
assert dim_simplify(sin(L * L**(-1))**2 * L) == L
def test_pretty_basic():
assert pretty(-Rational(1) / 2) == '-1/2'
assert pretty( -Rational(13)/22 ) == \
"""\
13\n\
- --\n\
22\
"""
expr = oo
ascii_str = \
"""\
oo\
"""
ucode_str = \
u"""\
∞\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x**2)
ascii_str = \
"""\
2\n\
x \
"""
ucode_str = \
u"""\
2\n\
x \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = 1 / x
ascii_str = \
"""\
1\n\
-\n\
x\
"""
ucode_str = \
u"""\
1\n\
─\n\
x\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = y * x**-2
ascii_str = \
"""\
y \n\
--\n\
2\n\
x \
"""
ucode_str = \
u"""\
y \n\
──\n\
2\n\
x \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = x**Rational(-5, 2)
ascii_str = \
"""\
1 \n\
----\n\
5/2\n\
x \
"""
ucode_str = \
u"""\
1 \n\
────\n\
5/2\n\
x \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (-2)**x
ascii_str = \
"""\
x\n\
(-2) \
"""
ucode_str = \
u"""\
x\n\
(-2) \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
# See issue 1824
expr = Pow(3, 1, evaluate=False)
ascii_str = \
"""\
1\n\
3 \
"""
ucode_str = \
u"""\
1\n\
3 \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x**2 + x + 1)
ascii_str_1 = \
"""\
2\n\
1 + x + x \
"""
ascii_str_2 = \
"""\
2 \n\
x + x + 1\
"""
ascii_str_3 = \
"""\
2 \n\
x + 1 + x\
"""
ucode_str_1 = \
u"""\
2\n\
1 + x + x \
"""
ucode_str_2 = \
u"""\
2 \n\
x + x + 1\
"""
ucode_str_3 = \
u"""\
2 \n\
x + 1 + x\
"""
assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
expr = 1 - x
ascii_str_1 = \
"""\
1 - x\
"""
ascii_str_2 = \
"""\
-x + 1\
"""
ucode_str_1 = \
u"""\
1 - x\
"""
ucode_str_2 = \
u"""\
-x + 1\
"""
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = 1 - 2 * x
ascii_str_1 = \
"""\
1 - 2*x\
"""
ascii_str_2 = \
"""\
-2*x + 1\
"""
ucode_str_1 = \
u"""\
1 - 2⋅x\
"""
ucode_str_2 = \
u"""\
-2⋅x + 1\
"""
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = x / y
ascii_str = \
"""\
x\n\
-\n\
y\
"""
ucode_str = \
u"""\
x\n\
─\n\
y\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -x / y
ascii_str = \
"""\
-x\n\
--\n\
y \
"""
ucode_str = \
u"""\
-x\n\
──\n\
y \
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = (x + 2) / y
ascii_str_1 = \
"""\
2 + x\n\
-----\n\
y \
"""
ascii_str_2 = \
"""\
x + 2\n\
-----\n\
y \
"""
ucode_str_1 = \
u"""\
2 + x\n\
─────\n\
y \
"""
ucode_str_2 = \
u"""\
x + 2\n\
─────\n\
y \
"""
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = (1 + x) * y
ascii_str_1 = \
"""\
y*(1 + x)\
"""
ascii_str_2 = \
"""\
(1 + x)*y\
"""
ascii_str_3 = \
"""\
y*(x + 1)\
"""
ucode_str_1 = \
u"""\
y⋅(1 + x)\
"""
ucode_str_2 = \
u"""\
(1 + x)⋅y\
"""
ucode_str_3 = \
u"""\
y⋅(x + 1)\
"""
assert pretty(expr) in [ascii_str_1, ascii_str_2, ascii_str_3]
assert upretty(expr) in [ucode_str_1, ucode_str_2, ucode_str_3]
# Test for correct placement of the negative sign
expr = -5 * x / (x + 10)
ascii_str_1 = \
"""\
-5*x \n\
------\n\
10 + x\
"""
ascii_str_2 = \
"""\
-5*x \n\
------\n\
x + 10\
"""
ucode_str_1 = \
u"""\
-5⋅x \n\
──────\n\
10 + x\
"""
ucode_str_2 = \
u"""\
-5⋅x \n\
──────\n\
x + 10\
"""
assert pretty(expr) in [ascii_str_1, ascii_str_2]
assert upretty(expr) in [ucode_str_1, ucode_str_2]
expr = -S(1) / 2 - 3 * x
ascii_str = \
"""\
-3*x - 1/2\
"""
ucode_str = \
u"""\
-3⋅x - 1/2\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = S(1) / 2 - 3 * x
ascii_str = \
"""\
-3*x + 1/2\
"""
ucode_str = \
u"""\
-3⋅x + 1/2\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = -S(1) / 2 - 3 * x / 2
ascii_str = \
"""\
3*x 1\n\
- --- - -\n\
2 2\
"""
ucode_str = \
u"""\
3⋅x 1\n\
- ─── - ─\n\
2 2\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
expr = S(1) / 2 - 3 * x / 2
ascii_str = \
"""\
3*x 1\n\
- --- + -\n\
2 2\
"""
ucode_str = \
u"""\
3⋅x 1\n\
- ─── + ─\n\
2 2\
"""
assert pretty(expr) == ascii_str
assert upretty(expr) == ucode_str
def test_dim_simplify_pow():
assert dim_simplify(Pow(L, 2)) == L.pow(2)
def mason(graph: Graph, start: Node, end: Node) -> MasonResult:
# mason = (sum(path[i] * delta[i])) / (delta)
# delta = 1 - sum of all loops
# + sum of products of two loops
# - sum of products of three loops
# + sum of products of four loops
# ....
# delta: determinante
# paths[i]: forward path i
# delta_per_path[i]: delta without loops that touch the forward path i
result = MasonResult()
delta = Integer(1) # Initialize determinante with 1
# Loops with their corresponding symbol
loops: List[List[Branch]] = list()
loop_symbols: List[Symbol] = list()
# Create a sorted list of simple cycles
simple_cycle_list = sorted(simple_cycles(graph),
key=lambda L: '%s' % (loop_to_expression(L), ))
# Find loops and replace the branch copies with the original branch
for loop_index, loop in enumerate(simple_cycle_list, start=0):
new_loop = list()
for loop_branch in loop:
branch_iter = iter(graph.branches)
existing_branch = next(branch_iter)
while not existing_branch.id == loop_branch.id:
existing_branch = next(branch_iter)
new_loop.append(existing_branch)
loops.append(new_loop)
loop_symbols.append(Symbol("L" + str(loop_index + 1)))
for i, loop in enumerate(loops):
# Add to delta
delta = Add(delta, Mul(Integer(-1), loop_symbols[i]))
# Append to loops in result
result.loops.append((loop_symbols[i], loop_to_expression(loops[i])))
# Add or substract sum of product of two, three, ... loops
loop_groups = sorted(find_loop_groups(loops), key=attrgetter('loop_count'))
for loop_group in loop_groups:
if loop_group.loop_count > 1: # Skip loop groups with one member
expr = Integer(1)
i = 0
while i < len(loop_group.loops):
loop_index = loops.index(loop_group.loops[i])
expr = Mul(expr, loop_symbols[loop_index])
i += 1
# Insert negative sign if necessary
if loop_group.loop_count % 2 == 1:
expr = Mul(Integer(-1), expr)
delta = Add(delta, expr)
# Summation of products of paths and its determinantes
paths = find_paths(start, end)
numerator: Expr = Integer(0)
# Create a sorted list of paths
path_list = sorted(paths, key=lambda L: '%s' % (loop_to_expression(L), ))
for i, path in enumerate(path_list, start=1):
# Create symbol and append to paths in result
path_symbol = Symbol("P" + str(i))
result.paths.append((path_symbol, loop_to_expression(path)))
dpp_symbol = Symbol("D" + str(i))
dpp = __get_delta_per_path(loops, loop_symbols, loop_groups, path)
# Append to paths in result
result.paths.append((dpp_symbol, dpp))
# Add delta_per_path to sum
numerator = Add(numerator, Mul(path_symbol, dpp_symbol))
delta_symbol = Symbol("Delta")
result.determinant = [(delta_symbol, delta)]
numerator_symbol = Symbol("T_num")
result.numerator = [(numerator_symbol, numerator)]
denominator_symbol = Symbol("T_den")
result.denominator = [(denominator_symbol, delta_symbol)]
transfer_function_symbol = Symbol("T")
transfer_function = Mul(numerator_symbol,
Pow(denominator_symbol, Integer(-1))) # Division
result.transfer_function = [(transfer_function_symbol, transfer_function)]
return result
def test_nested_substitution():
# Substitution within a substitution.
e = Add(Pow(w * x + y, 2), sqrt(w * x + y))
substs, reduced = cse([e])
assert substs == [(x0, w * x + y)]
assert reduced == [sqrt(x0) + x0**2]
def inv(a):
return Pow(a, -1)
def test_issue_3512a():
assert Mul.flatten([3**Rational(1, 3),
Pow(-Rational(1, 9), Rational(2, 3), evaluate=False)]) == \
([Rational(1, 3), (-1)**Rational(2, 3)], [], None)
def test_variable_percentage():
assert_equal(
"\\variable{x}\\%",
Mul(Symbol('x' + hashlib.md5('x'.encode()).hexdigest(), real=True),
Pow(100, -1, evaluate=False),
evaluate=False))
def __rdiv__(self, other):
return MatSymbolicMul(other, Pow(self, S.NegativeOne))
def redlich_kister_sum(self, phase, param_search, param_query):
"""
Construct parameter in Redlich-Kister polynomial basis, using
the Muggianu ternary parameter extension.
"""
rk_terms = []
# search for desired parameters
params = param_search(param_query)
for param in params:
# iterate over every sublattice
mixing_term = S.One
for subl_index, comps in enumerate(param['constituent_array']):
comp_symbols = None
# convert strings to symbols
if comps[0] == '*':
# Handle wildcards in constituent array
comp_symbols = \
[
v.SiteFraction(phase.name, subl_index, comp)
for comp in set(phase.constituents[subl_index])\
.intersection(self.components)
]
mixing_term *= Add(*comp_symbols)
else:
comp_symbols = \
[
v.SiteFraction(phase.name, subl_index, comp)
for comp in comps
]
mixing_term *= Mul(*comp_symbols)
# is this a higher-order interaction parameter?
if len(comps) == 2 and param['parameter_order'] > 0:
# interacting sublattice, add the interaction polynomial
mixing_term *= Pow(comp_symbols[0] - \
comp_symbols[1], param['parameter_order'])
if len(comps) == 3:
# 'parameter_order' is an index to a variable when
# we are in the ternary interaction parameter case
# NOTE: The commercial software packages seem to have
# a "feature" where, if only the zeroth
# parameter_order term of a ternary parameter is specified,
# the other two terms are automatically generated in order
# to make the parameter symmetric.
# In other words, specifying only this parameter:
# PARAMETER G(FCC_A1,AL,CR,NI;0) 298.15 +30300; 6000 N !
# Actually implies:
# PARAMETER G(FCC_A1,AL,CR,NI;0) 298.15 +30300; 6000 N !
# PARAMETER G(FCC_A1,AL,CR,NI;1) 298.15 +30300; 6000 N !
# PARAMETER G(FCC_A1,AL,CR,NI;2) 298.15 +30300; 6000 N !
#
# If either 1 or 2 is specified, no implicit parameters are
# generated.
# We need to handle this case.
if param['parameter_order'] == 0:
# are _any_ of the other parameter_orders specified?
ternary_param_query = (
(where('phase_name') == param['phase_name']) & \
(where('parameter_type') == \
param['parameter_type']) & \
(where('constituent_array') == \
param['constituent_array'])
)
other_tern_params = param_search(ternary_param_query)
if len(other_tern_params) == 1 and \
other_tern_params[0] == param:
# only the current parameter is specified
# We need to generate the other two parameters.
order_one = copy.deepcopy(param)
order_one['parameter_order'] = 1
order_two = copy.deepcopy(param)
order_two['parameter_order'] = 2
# Add these parameters to our iteration.
params.extend((order_one, order_two))
# Include variable indicated by parameter order index
# Perform Muggianu adjustment to site fractions
mixing_term *= comp_symbols[param['parameter_order']].subs(
self._Muggianu_correction_dict(comp_symbols),
simultaneous=True)
rk_terms.append(mixing_term * param['parameter'])
return Add(*rk_terms)
def my_division(a, b):
return Mul(x, Pow(y, -1))
def test_dim_simplify_pow():
assert Pow(L, 2) == L**2
'CNOT',
'SWAP',
'H',
'X',
'Y',
'Z',
'T',
'S',
'Phase',
'normalized',
'gate_sort',
'gate_simp',
'random_circuit',
]
sqrt2_inv = Pow(2, Rational(-1, 2), evaluate=False)
#-----------------------------------------------------------------------------
# Gate Super-Classes
#-----------------------------------------------------------------------------
_normalized = True
def normalized(normalize):
"""Should Hadamard gates be normalized by a 1/sqrt(2).
This is a global setting that can be used to simplify the look of various
expressions, by leaving of the leading 1/sqrt(2) of the Hadamard gate.
Parameters
def test_qsimplify_pow():
assert qsimplify(Pow(q1, 2)) == q1.pow(2)
def _Pow(a, b):
return Pow(a, b, evaluate=False)
def test_ops():
k0 = Ket(0)
k1 = Ket(1)
k = 2 * I * k0 - (x / sqrt(2)) * k1
assert k == Add(Mul(2, I, k0),
Mul(Rational(-1, 2), x, Pow(2, Rational(1, 2)), k1))
def div(a, b):
return Mul(a, Pow(b, -1))
def GeneralizedMultivariateLogGammaOmega(syms, omega, v, lamda, mu):
"""
Extends GeneralizedMultivariateLogGamma.
Parameters
==========
syms: list/tuple/set of symbols for identifying each component
omega: A square matrix
Every element of square matrix must be absolute value of
sqaure root of correlation coefficient
v: positive real
lamda: a list of positive reals
mu: a list of positive reals
Returns
=======
A Random Symbol
Examples
========
>>> from sympy.stats import density
>>> from sympy.stats.joint_rv import marginal_distribution
>>> from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega
>>> from sympy import Matrix, symbols, S
>>> omega = Matrix([[1, S.Half, S.Half], [S.Half, 1, S.Half], [S.Half, S.Half, 1]])
>>> v = 1
>>> l, mu = [1, 1, 1], [1, 1, 1]
>>> G = GeneralizedMultivariateLogGammaOmega('G', omega, v, l, mu)
>>> y = symbols('y_1:4', positive=True)
>>> density(G)(y[0], y[1], y[2])
sqrt(2)*Sum((1 - sqrt(2)/2)**n*exp((n + 1)*(y_1 + y_2 + y_3) - exp(y_1) -
exp(y_2) - exp(y_3))/gamma(n + 1)**3, (n, 0, oo))/2
References
==========
See references of GeneralizedMultivariateLogGamma.
Notes
=====
If the GeneralizedMultivariateLogGammaOmega is too long to type use,
`from sympy.stats.joint_rv_types import GeneralizedMultivariateLogGammaOmega as GMVLGO`
"""
_value_check((omega.is_square, isinstance(omega, Matrix)),
"omega must be a"
" square matrix")
for val in omega.values():
_value_check(
(val >= 0, val <= 1),
"all values in matrix must be between 0 and 1(both inclusive).")
_value_check(omega.diagonal().equals(ones(1, omega.shape[0])),
"all the elements of diagonal should be 1.")
_value_check((omega.shape[0] == len(lamda), len(lamda) == len(mu)),
"lamda, mu should be of same length and omega should "
" be of shape (length of lamda, length of mu)")
_value_check(
len(lamda) > 1, "the distribution should have at least"
" two random variables.")
delta = Pow(Rational(omega.det()), Rational(1, len(lamda) - 1))
return GeneralizedMultivariateLogGamma(syms, delta, v, lamda, mu)
def test_issue_2941():
a, b = Pow(1, 2, evaluate=False), S.One
assert a != b
assert b != a
assert not (a == b)
assert not (b == a)
def test_evaluate_false():
for no in [0, False]:
assert Add(3, 2, evaluate=no).is_Add
assert Mul(3, 2, evaluate=no).is_Mul
assert Pow(3, 2, evaluate=no).is_Pow
assert Pow(y, 2, evaluate=True) - Pow(y, 2, evaluate=True) == 0
def test_powers_Integer():
"""Test Integer._eval_power"""
# check infinity
assert S(1)**S.Infinity == 1
assert S(-1)**S.Infinity == S.NaN
assert S(2)**S.Infinity == S.Infinity
assert S(-2)**S.Infinity == S.Infinity + S.Infinity * S.ImaginaryUnit
assert S(0)**S.Infinity == 0
# check Nan
assert S(1)**S.NaN == S.One
assert S(-1)**S.NaN == S.NaN
# check for exact roots
assert S(-1)**Rational(6, 5) == -(-1)**(S(1) / 5)
assert sqrt(S(4)) == 2
assert sqrt(S(-4)) == I * 2
assert S(16)**Rational(1, 4) == 2
assert S(-16)**Rational(1, 4) == 2 * (-1)**Rational(1, 4)
assert S(9)**Rational(3, 2) == 27
assert S(-9)**Rational(3, 2) == -27 * I
assert S(27)**Rational(2, 3) == 9
assert S(-27)**Rational(2, 3) == 9 * (S(-1)**Rational(2, 3))
assert (-2)**Rational(-2, 1) == Rational(1, 4)
# not exact roots
assert sqrt(-3) == I * sqrt(3)
assert (3)**(S(3) / 2) == 3 * sqrt(3)
assert (-3)**(S(3) / 2) == -3 * sqrt(-3)
assert (-3)**(S(5) / 2) == 9 * I * sqrt(3)
assert (-3)**(S(7) / 2) == -I * 27 * sqrt(3)
assert (2)**(S(3) / 2) == 2 * sqrt(2)
assert (2)**(S(-3) / 2) == sqrt(2) / 4
assert (81)**(S(2) / 3) == 9 * (S(3)**(S(2) / 3))
assert (-81)**(S(2) / 3) == 9 * (S(-3)**(S(2) / 3))
assert (-3)**Rational(-7,
3) == -(-1)**Rational(2, 3) * 3**Rational(2, 3) / 27
assert (-3)**Rational(-2,
3) == -(-1)**Rational(1, 3) * 3**Rational(1, 3) / 3
# join roots
assert sqrt(6) + sqrt(24) == 3 * sqrt(6)
assert sqrt(2) * sqrt(3) == sqrt(6)
# separate symbols & constansts
x = Symbol("x")
assert sqrt(49 * x) == 7 * sqrt(x)
assert sqrt((3 - sqrt(pi))**2) == 3 - sqrt(pi)
# check that it is fast for big numbers
assert (2**64 + 1)**Rational(4, 3)
assert (2**64 + 1)**Rational(17, 25)
# negative rational power and negative base
assert (-3)**Rational(-7,
3) == -(-1)**Rational(2, 3) * 3**Rational(2, 3) / 27
assert (-3)**Rational(-2,
3) == -(-1)**Rational(1, 3) * 3**Rational(1, 3) / 3
assert S(1234).factors() == {617: 1, 2: 1}
assert Rational(2 * 3, 3 * 5 * 7).factors() == {2: 1, 5: -1, 7: -1}
# test that eval_power factors numbers bigger than limit (2**15)
from sympy import nextprime
n = nextprime(
2**15) # bigger than the current limit in factor_trial_division
assert sqrt(n**2) == n
assert sqrt(n**3) == n * sqrt(n)
assert sqrt(4 * n) == 2 * sqrt(n)
# check that factors of base with powers sharing gcd with power are removed
assert (2**4 * 3)**Rational(1, 6) == 2**Rational(2, 3) * 3**Rational(1, 6)
assert (2**4 * 3)**Rational(
5, 6) == 8 * 2**Rational(1, 3) * 3**Rational(5, 6)
# check that bases sharing a gcd are exptracted
assert 2**Rational(1, 3)*3**Rational(1, 4)*6**Rational(1, 5) == \
2**Rational(8, 15)*3**Rational(9, 20)
assert sqrt(8)*24**Rational(1, 3)*6**Rational(1, 5) == \
4*2**Rational(7, 10)*3**Rational(8, 15)
assert sqrt(8)*(-24)**Rational(1, 3)*(-6)**Rational(1, 5) == \
4*(-3)**Rational(8, 15)*2**Rational(7, 10)
assert 2**Rational(1, 3) * 2**Rational(8, 9) == 2 * 2**Rational(2, 9)
assert 2**Rational(2, 3) * 6**Rational(1, 3) == 2 * 3**Rational(1, 3)
assert 2**Rational(2, 3) * 6**Rational(8, 9) == 2 * 2**Rational(
5, 9) * 3**Rational(8, 9)
assert (-2)**Rational(2, S(3)) * (-4)**Rational(
1, S(3)) == -2 * 2**Rational(1, 3)
assert 3 * Pow(3, 2, evaluate=False) == 3**3
assert 3 * Pow(3, -1 / S(3), evaluate=False) == 3**(2 / S(3))
assert (-2)**(1/S(3))*(-3)**(1/S(4))*(-5)**(5/S(6)) == \
-(-1)**Rational(5, 12)*2**Rational(1, 3)*3**Rational(1, 4)*5**Rational(5, 6)
assert Integer(-2)**Symbol('', even=True) == Integer(2)**Symbol('',
even=True)
assert (-1)**Float(.5) == 1.0 * I
def test_chop_value():
for i in range(-27, 28):
assert (Pow(10, i) *
2).n(chop=10**i) and not (Pow(10, i)).n(chop=10**i)
def test_cse_single():
# Simple substitution.
e = Add(Pow(x + y, 2), sqrt(x + y))
substs, reduced = cse([e])
assert substs == [(x0, x + y)]
assert reduced == [sqrt(x0) + x0**2]
def test_cse_single2():
# Simple substitution, test for being able to pass the expression directly
e = Add(Pow(x + y, 2), sqrt(x + y))
substs, reduced = cse(e, optimizations=[])
assert substs == [(x0, x + y)]
assert reduced == [sqrt(x0) + x0**2]
class TestAllGood(object):
# These latex strings should parse to the corresponding SymPy expression
GOOD_PAIRS = [
("0", 0),
("1", 1),
("-3.14", -3.14),
("5-3", _Add(5, -3)),
("(-7.13)(1.5)", _Mul(Rational('-7.13'), Rational('1.5'))),
("\\left(-7.13\\right)\\left(1.5\\right)", _Mul(Rational('-7.13'), Rational('1.5'))),
("x", x),
("2x", 2 * x),
("x^2", x**2),
("x^{3 + 1}", x**_Add(3, 1)),
("x^{\\left\\{3 + 1\\right\\}}", x**_Add(3, 1)),
("-3y + 2x", _Add(_Mul(2, x), Mul(-1, 3, y, evaluate=False))),
("-c", -c),
("a \\cdot b", a * b),
("a / b", a / b),
("a \\div b", a / b),
("a + b", a + b),
("a + b - a", Add(a, b, _Mul(-1, a), evaluate=False)),
("a^2 + b^2 = c^2", Eq(a**2 + b**2, c**2)),
("a^2 + b^2 != 2c^2", Ne(a**2 + b**2, 2 * c**2)),
("a\\mod b", Mod(a, b)),
("\\sin \\theta", sin(theta)),
("\\sin(\\theta)", sin(theta)),
("\\sin\\left(\\theta\\right)", sin(theta)),
("\\sin^{-1} a", asin(a)),
("\\sin a \\cos b", _Mul(sin(a), cos(b))),
("\\sin \\cos \\theta", sin(cos(theta))),
("\\sin(\\cos \\theta)", sin(cos(theta))),
("\\arcsin(a)", asin(a)),
("\\arccos(a)", acos(a)),
("\\arctan(a)", atan(a)),
("\\sinh(a)", sinh(a)),
("\\cosh(a)", cosh(a)),
("\\tanh(a)", tanh(a)),
("\\sinh^{-1}(a)", asinh(a)),
("\\cosh^{-1}(a)", acosh(a)),
("\\tanh^{-1}(a)", atanh(a)),
("\\arcsinh(a)", asinh(a)),
("\\arccosh(a)", acosh(a)),
("\\arctanh(a)", atanh(a)),
("\\arsinh(a)", asinh(a)),
("\\arcosh(a)", acosh(a)),
("\\artanh(a)", atanh(a)),
("\\operatorname{arcsinh}(a)", asinh(a)),
("\\operatorname{arccosh}(a)", acosh(a)),
("\\operatorname{arctanh}(a)", atanh(a)),
("\\operatorname{arsinh}(a)", asinh(a)),
("\\operatorname{arcosh}(a)", acosh(a)),
("\\operatorname{artanh}(a)", atanh(a)),
("\\cos^2(x)", cos(x)**2),
("\\cos(x)^2", cos(x)**2),
("\\frac{a}{b}", a / b),
("\\frac{a + b}{c}", _Mul(a + b, _Pow(c, -1))),
("\\frac{7}{3}", _Mul(7, _Pow(3, -1))),
("(\\csc x)(\\sec y)", csc(x) * sec(y)),
("\\lim_{x \\to 3} a", Limit(a, x, 3)),
("\\lim_{x \\rightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\Rightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\longrightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\Longrightarrow 3} a", Limit(a, x, 3)),
("\\lim_{x \\to 3^{+}} a", Limit(a, x, 3, dir='+')),
("\\lim_{x \\to 3^{-}} a", Limit(a, x, 3, dir='-')),
("\\infty", oo),
("\\infty\\%", oo),
("\\$\\infty", oo),
("-\\infty", -oo),
("-\\infty\\%", -oo),
("-\\$\\infty", -oo),
("\\lim_{x \\to \\infty} \\frac{1}{x}", Limit(_Mul(1, _Pow(x, -1)), x, oo)),
("\\frac{d}{dx} x", Derivative(x, x)),
("\\frac{d}{dt} x", Derivative(x, t)),
# ("f(x)", f(x)),
# ("f(x, y)", f(x, y)),
# ("f(x, y, z)", f(x, y, z)),
# ("\\frac{d f(x)}{dx}", Derivative(f(x), x)),
# ("\\frac{d\\theta(x)}{dx}", Derivative(theta(x), x)),
("|x|", _Abs(x)),
("\\left|x\\right|", _Abs(x)),
("||x||", _Abs(Abs(x))),
("|x||y|", _Abs(x) * _Abs(y)),
("||x||y||", _Abs(_Abs(x) * _Abs(y))),
("\\pi^{|xy|}", pi**_Abs(x * y)),
("\\frac{\\pi}{3}", _Mul(pi, _Pow(3, -1))),
("\\sin{\\frac{\\pi}{2}}", sin(_Mul(pi, _Pow(2, -1)), evaluate=False)),
("a+bI", a + I * b),
("e^{I\\pi}", -1),
("\\int x dx", Integral(x, x)),
("\\int x d\\theta", Integral(x, theta)),
("\\int (x^2 - y)dx", Integral(x**2 - y, x)),
("\\int x + a dx", Integral(_Add(x, a), x)),
("\\int da", Integral(1, a)),
("\\int_0^7 dx", Integral(1, (x, 0, 7))),
("\\int_a^b x dx", Integral(x, (x, a, b))),
("\\int^b_a x dx", Integral(x, (x, a, b))),
("\\int_{a}^b x dx", Integral(x, (x, a, b))),
("\\int^{b}_a x dx", Integral(x, (x, a, b))),
("\\int_{a}^{b} x dx", Integral(x, (x, a, b))),
("\\int_{ }^{}x dx", Integral(x, x)),
("\\int^{ }_{ }x dx", Integral(x, x)),
("\\int^{b}_{a} x dx", Integral(x, (x, a, b))),
# ("\\int_{f(a)}^{f(b)} f(z) dz", Integral(f(z), (z, f(a), f(b)))),
("\\int (x+a)", Integral(_Add(x, a), x)),
("\\int a + b + c dx", Integral(Add(a, b, c, evaluate=False), x)),
("\\int \\frac{dz}{z}", Integral(Pow(z, -1), z)),
("\\int \\frac{3 dz}{z}", Integral(3 * Pow(z, -1), z)),
("\\int \\frac{1}{x} dx", Integral(Pow(x, -1), x)),
("\\int \\frac{1}{a} + \\frac{1}{b} dx", Integral(_Add(_Pow(a, -1), Pow(b, -1)), x)),
("\\int \\frac{3 \\cdot d\\theta}{\\theta}", Integral(3 * _Pow(theta, -1), theta)),
("\\int \\frac{1}{x} + 1 dx", Integral(_Add(_Pow(x, -1), 1), x)),
("x_0", Symbol('x_{0}', real=True)),
("x_{1}", Symbol('x_{1}', real=True)),
("x_a", Symbol('x_{a}', real=True)),
("x_{b}", Symbol('x_{b}', real=True)),
("h_\\theta", Symbol('h_{theta}', real=True)),
("h_{\\theta}", Symbol('h_{theta}', real=True)),
# ("h_{\\theta}(x_0, x_1)", Symbol('h_{theta}', real=True)(Symbol('x_{0}', real=True), Symbol('x_{1}', real=True))),
("x!", _factorial(x)),
("100!", _factorial(100)),
("\\theta!", _factorial(theta)),
("(x + 1)!", _factorial(_Add(x, 1))),
("\\left(x + 1\\right)!", _factorial(_Add(x, 1))),
("(x!)!", _factorial(_factorial(x))),
("x!!!", _factorial(_factorial(_factorial(x)))),
("5!7!", _Mul(_factorial(5), _factorial(7))),
("\\sqrt{x}", sqrt(x)),
("\\sqrt{x + b}", sqrt(_Add(x, b))),
("\\sqrt[3]{\\sin x}", root(sin(x), 3)),
("\\sqrt[y]{\\sin x}", root(sin(x), y)),
("\\sqrt[\\theta]{\\sin x}", root(sin(x), theta)),
("x < y", StrictLessThan(x, y)),
("x \\leq y", LessThan(x, y)),
("x > y", StrictGreaterThan(x, y)),
("x \\geq y", GreaterThan(x, y)),
("\\sum_{k = 1}^{3} c", Sum(c, (k, 1, 3))),
("\\sum_{k = 1}^3 c", Sum(c, (k, 1, 3))),
("\\sum^{3}_{k = 1} c", Sum(c, (k, 1, 3))),
("\\sum^3_{k = 1} c", Sum(c, (k, 1, 3))),
("\\sum_{k = 1}^{10} k^2", Sum(k**2, (k, 1, 10))),
("\\sum_{n = 0}^{\\infty} \\frac{1}{n!}", Sum(_Pow(_factorial(n), -1), (n, 0, oo))),
("\\prod_{a = b}^{c} x", Product(x, (a, b, c))),
("\\prod_{a = b}^c x", Product(x, (a, b, c))),
("\\prod^{c}_{a = b} x", Product(x, (a, b, c))),
("\\prod^c_{a = b} x", Product(x, (a, b, c))),
("\\ln x", _log(x, E)),
("\\ln xy", _log(x * y, E)),
("\\log x", _log(x, 10)),
("\\log xy", _log(x * y, 10)),
# ("\\log_2 x", _log(x, 2)),
("\\log_{2} x", _log(x, 2)),
# ("\\log_a x", _log(x, a)),
("\\log_{a} x", _log(x, a)),
("\\log_{11} x", _log(x, 11)),
("\\log_{a^2} x", _log(x, _Pow(a, 2))),
("[x]", x),
("[a + b]", _Add(a, b)),
("\\frac{d}{dx} [ \\tan x ]", Derivative(tan(x), x)),
("2\\overline{x}", 2 * Symbol('xbar', real=True)),
("2\\overline{x}_n", 2 * Symbol('xbar_{n}', real=True)),
("\\frac{x}{\\overline{x}_n}", x / Symbol('xbar_{n}', real=True)),
("\\frac{\\sin(x)}{\\overline{x}_n}", sin(Symbol('x', real=True)) / Symbol('xbar_{n}', real=True)),
("2\\bar{x}", 2 * Symbol('xbar', real=True)),
("2\\bar{x}_n", 2 * Symbol('xbar_{n}', real=True)),
("\\sin\\left(\\theta\\right) \\cdot4", sin(theta) * 4),
("\\ln\\left(\\theta\\right)", _log(theta, E)),
("\\ln\\left(x-\\theta\\right)", _log(x - theta, E)),
("\\ln\\left(\\left(x-\\theta\\right)\\right)", _log(x - theta, E)),
("\\ln\\left(\\left[x-\\theta\\right]\\right)", _log(x - theta, E)),
("\\ln\\left(\\left\\{x-\\theta\\right\\}\\right)", _log(x - theta, E)),
("\\ln\\left(\\left|x-\\theta\\right|\\right)", _log(_Abs(x - theta), E)),
("\\frac{1}{2}xy(x+y)", Mul(_Pow(2, -1), x, y, (x + y), evaluate=False)),
("\\frac{1}{2}\\theta(x+y)", Mul(_Pow(2, -1), theta, (x + y), evaluate=False)),
("1-f(x)", 1 - f * x),
("\\begin{matrix}1&2\\\\3&4\\end{matrix}", Matrix([[1, 2], [3, 4]])),
("\\begin{matrix}x&x^2\\\\\\sqrt{x}&x\\end{matrix}", Matrix([[x, x**2], [_Pow(x, S.Half), x]])),
("\\begin{matrix}\\sqrt{x}\\\\\\sin(\\theta)\\end{matrix}", Matrix([_Pow(x, S.Half), sin(theta)])),
("\\begin{pmatrix}1&2\\\\3&4\\end{pmatrix}", Matrix([[1, 2], [3, 4]])),
("\\begin{bmatrix}1&2\\\\3&4\\end{bmatrix}", Matrix([[1, 2], [3, 4]])),
# scientific notation
("2.5\\times 10^2", 250),
("1,500\\times 10^{-1}", 150),
# e notation
("2.5E2", 250),
("1,500E-1", 150),
# multiplication without cmd
("2x2y", Mul(2, x, 2, y, evaluate=False)),
("2x2", Mul(2, x, 2, evaluate=False)),
("x2", x * 2),
# lin alg processing
("\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(theta, Matrix([[1, 2], [3, 4]]), evaluate=False)),
("\\theta\\begin{matrix}1\\\\3\\end{matrix} - \\begin{matrix}-1\\\\2\\end{matrix}", MatAdd(MatMul(theta, Matrix([[1], [3]]), evaluate=False), MatMul(-1, Matrix([[-1], [2]]), evaluate=False), evaluate=False)),
("\\theta\\begin{matrix}1&0\\\\0&1\\end{matrix}*\\begin{matrix}3\\\\-2\\end{matrix}", MatMul(theta, Matrix([[1, 0], [0, 1]]), Matrix([3, -2]), evaluate=False)),
("\\frac{1}{9}\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(Pow(9, -1, evaluate=False), theta, Matrix([[1, 2], [3, 4]]), evaluate=False)),
("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix};\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]),
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix},\\begin{pmatrix}1\\\\1\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1]), Matrix([1, 1, 1])]),
("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right\\}", Matrix([1, 2, 3])),
("\\left{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right}", Matrix([1, 2, 3])),
("{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}}", Matrix([1, 2, 3])),
# us dollars
("\\$1,000.00", 1000),
("\\$543.21", 543.21),
("\\$0.009", 0.009),
# percentages
("100\\%", 1),
("1.5\\%", 0.015),
("0.05\\%", 0.0005),
# empty set
("\\emptyset", S.EmptySet)
]
def test_good_pair(self, s, eq):
assert_equal(s, eq)
# q is between a and b: cr(a,q,b,c) = cr(A,Q,B,C) = (AB/QB)/(AC/QC)
if q_left:
ab = np.linalg.linalg.norm(a-b)
qb = np.linalg.linalg.norm(q-b)
ac = np.linalg.linalg.norm(a-c)
qc = np.linalg.linalg.norm(q-c)
cross_ratio = ((ab)/(qb))/((ac)/(qc))
AB = np.linalg.norm(A-B)
AC = np.linalg.norm(A-C)
BC = AC-AB
# use cross ratio + geometry
QB = sym.symbols('QB',real=True)
QB = sym.solve((AB/QB)/(AC/(BC+QB))-cross_ratio, QB)[0] # cross
QC = BC + QB # geometric relationship: BC + QB = QC
Qx, Qy = sym.symbols('Qx, Qy')
sol = sym.solve((sqrt(Pow(Qx - B[0],2) + Pow(Qy - B[1],2))-QB,sqrt(Pow(Qx - C[0],2) + Pow(Qy - C[1],2))-QC),(Qx,Qy))
else: # cr(a,b,q,c) = cr(A,B,Q,C) = (AQ/BQ)*(AC/BC)
# q is between b and c... flip the problem (swap a and c from above condition)
aq = np.linalg.linalg.norm(q-a)
qb = np.linalg.linalg.norm(q-b)
ac = np.linalg.linalg.norm(a-c)
bc = np.linalg.linalg.norm(b-c)
cross_ratio = ((aq)/(qb))/((ac)/(bc))
AC = np.linalg.norm(A-C)
CB = np.linalg.norm(C-B)
AB = AC-CB
# use cross ratio + geometry
QB = sym.symbols('QB',real=True)
QB = sym.solve(((AB+QB)/QB)/(AC/CB)-cross_ratio, QB)[0] # cross
QA = AB + QB # geometric relationship: BC + QB = QC
def test_big_expr():
f = Function('f')
x = symbols('x')
e1 = Dagger(AntiCommutator(Operator('A') + Operator('B'), Pow(DifferentialOperator(Derivative(f(x), x), f(x)), 3))*TensorProduct(Jz**2, Operator('A') + Operator('B')))*(JzBra(1, 0) + JzBra(1, 1))*(JzKet(0, 0) + JzKet(1, -1))
e2 = Commutator(Jz**2, Operator('A') + Operator('B'))*AntiCommutator(Dagger(Operator('C')*Operator('D')), Operator('E').inv()**2)*Dagger(Commutator(Jz, J2))
e3 = Wigner3j(1, 2, 3, 4, 5, 6)*TensorProduct(Commutator(Operator('A') + Dagger(Operator('B')), Operator('C') + Operator('D')), Jz - J2)*Dagger(OuterProduct(Dagger(JzBra(1, 1)), JzBra(1, 0)))*TensorProduct(JzKetCoupled(1, 1, (1, 1)) + JzKetCoupled(1, 0, (1, 1)), JzKetCoupled(1, -1, (1, 1)))
e4 = (ComplexSpace(1)*ComplexSpace(2) + FockSpace()**2)*(L2(Interval(
0, oo)) + HilbertSpace())
assert str(e1) == '(Jz**2)x(Dagger(A) + Dagger(B))*{Dagger(DifferentialOperator(Derivative(f(x), x),f(x)))**3,Dagger(A) + Dagger(B)}*(<1,0| + <1,1|)*(|0,0> + |1,-1>)'
ascii_str = \
"""\
/ 3 \\ \n\
|/ +\\ | \n\
2 / + +\\ <| /d \\ | + +> \n\
/J \\ x \\A + B /*||DifferentialOperator|--(f(x)),f(x)| | ,A + B |*(<1,0| + <1,1|)*(|0,0> + |1,-1>)\n\
\\ z/ \\\\ \dx / / / \
"""
ucode_str = \
u"""\
⎧ 3 ⎫ \n\
⎪⎛ †⎞ ⎪ \n\
2 ⎛ † †⎞ ⎨⎜ ⎛d ⎞ ⎟ † †⎬ \n\
⎛J ⎞ ⨂ ⎝A + B ⎠⋅⎪⎜DifferentialOperator⎜──(f(x)),f(x)⎟ ⎟ ,A + B ⎪⋅(⟨1,0❘ + ⟨1,1❘)⋅(❘0,0⟩ + ❘1,-1⟩)\n\
⎝ z⎠ ⎩⎝ ⎝dx ⎠ ⎠ ⎭ \
"""
assert pretty(e1) == ascii_str
assert upretty(e1) == ucode_str
assert latex(e1) == \
r'{\left(J_z\right)^{2}}\otimes \left({A^{\dag} + B^{\dag}}\right) \left\{\left(DifferentialOperator\left(\frac{d}{d x} f{\left (x \right )},f{\left (x \right )}\right)^{\dag}\right)^{3},A^{\dag} + B^{\dag}\right\} \left({\left\langle 1,0\right|} + {\left\langle 1,1\right|}\right) \left({\left|0,0\right\rangle } + {\left|1,-1\right\rangle }\right)'
sT(e1, "Mul(TensorProduct(Pow(JzOp(Symbol('J')), Integer(2)), Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), AntiCommutator(Pow(Dagger(DifferentialOperator(Derivative(Function('f')(Symbol('x')), Symbol('x')),Function('f')(Symbol('x')))), Integer(3)),Add(Dagger(Operator(Symbol('A'))), Dagger(Operator(Symbol('B'))))), Add(JzBra(Integer(1),Integer(0)), JzBra(Integer(1),Integer(1))), Add(JzKet(Integer(0),Integer(0)), JzKet(Integer(1),Integer(-1))))")
assert str(e2) == '[Jz**2,A + B]*{E**(-2),Dagger(D)*Dagger(C)}*[J2,Jz]'
ascii_str = \
"""\
[ 2 ] / -2 + +\\ [ 2 ]\n\
[/J \\ ,A + B]*<E ,D *C >*[J ,J ]\n\
[\\ z/ ] \\ / [ z]\
"""
ucode_str = \
u"""\
⎡ 2 ⎤ ⎧ -2 † †⎫ ⎡ 2 ⎤\n\
⎢⎛J ⎞ ,A + B⎥⋅⎨E ,D ⋅C ⎬⋅⎢J ,J ⎥\n\
⎣⎝ z⎠ ⎦ ⎩ ⎭ ⎣ z⎦\
"""
assert pretty(e2) == ascii_str
assert upretty(e2) == ucode_str
assert latex(e2) == \
r'\left[\left(J_z\right)^{2},A + B\right] \left\{\left(E\right)^{-2},D^{\dag} C^{\dag}\right\} \left[J^2,J_z\right]'
sT(e2, "Mul(Commutator(Pow(JzOp(Symbol('J')), Integer(2)),Add(Operator(Symbol('A')), Operator(Symbol('B')))), AntiCommutator(Pow(Operator(Symbol('E')), Integer(-2)),Mul(Dagger(Operator(Symbol('D'))), Dagger(Operator(Symbol('C'))))), Commutator(J2Op(Symbol('J')),JzOp(Symbol('J'))))")
assert str(e3) == \
"Wigner3j(1, 2, 3, 4, 5, 6)*[Dagger(B) + A,C + D]x(-J2 + Jz)*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x|1,-1,j1=1,j2=1>"
ascii_str = \
"""\
[ + ] / 2 \\ \n\
/1 3 5\\*[B + A,C + D]x |- J + J |*|1,0><1,1|*(|1,0,j1=1,j2=1> + |1,1,j1=1,j2=1>)x |1,-1,j1=1,j2=1>\n\
| | \\ z/ \n\
\\2 4 6/ \
"""
ucode_str = \
u"""\
⎡ † ⎤ ⎛ 2 ⎞ \n\
⎛1 3 5⎞⋅⎣B + A,C + D⎦⨂ ⎜- J + J ⎟⋅❘1,0⟩⟨1,1❘⋅(❘1,0,j₁=1,j₂=1⟩ + ❘1,1,j₁=1,j₂=1⟩)⨂ ❘1,-1,j₁=1,j₂=1⟩\n\
⎜ ⎟ ⎝ z⎠ \n\
⎝2 4 6⎠ \
"""
assert pretty(e3) == ascii_str
assert upretty(e3) == ucode_str
assert latex(e3) == \
r'\left(\begin{array}{ccc} 1 & 3 & 5 \\ 2 & 4 & 6 \end{array}\right) {\left[B^{\dag} + A,C + D\right]}\otimes \left({- J^2 + J_z}\right) {\left|1,0\right\rangle }{\left\langle 1,1\right|} \left({{\left|1,0,j_{1}=1,j_{2}=1\right\rangle } + {\left|1,1,j_{1}=1,j_{2}=1\right\rangle }}\right)\otimes {{\left|1,-1,j_{1}=1,j_{2}=1\right\rangle }}'
sT(e3, "Mul(Wigner3j(Integer(1), Integer(2), Integer(3), Integer(4), Integer(5), Integer(6)), TensorProduct(Commutator(Add(Dagger(Operator(Symbol('B'))), Operator(Symbol('A'))),Add(Operator(Symbol('C')), Operator(Symbol('D')))), Add(Mul(Integer(-1), J2Op(Symbol('J'))), JzOp(Symbol('J')))), OuterProduct(JzKet(Integer(1),Integer(0)),JzBra(Integer(1),Integer(1))), TensorProduct(Add(JzKetCoupled(Integer(1),Integer(0),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1)))), JzKetCoupled(Integer(1),Integer(1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))), JzKetCoupled(Integer(1),Integer(-1),Tuple(Integer(1), Integer(1)),Tuple(Tuple(Integer(1), Integer(2), Integer(1))))))")
assert str(e4) == '(C(1)*C(2)+F**2)*(L2([0, oo))+H)'
ascii_str = \
"""\
// 1 2\\ x2\\ / 2 \\\n\
\\\\C x C / + F / x \L + H/\
"""
ucode_str = \
u"""\
⎛⎛ 1 2⎞ ⨂2⎞ ⎛ 2 ⎞\n\
⎝⎝C ⨂ C ⎠ ⊕ F ⎠ ⨂ ⎝L ⊕ H⎠\
"""
assert pretty(e4) == ascii_str
assert upretty(e4) == ucode_str
assert latex(e4) == \
r'\left(\left(\mathcal{C}^{1}\otimes \mathcal{C}^{2}\right)\oplus {\mathcal{F}}^{\otimes 2}\right)\otimes \left({\mathcal{L}^2}\left( \left[0, \infty\right) \right)\oplus \mathcal{H}\right)'
sT(e4, "TensorProductHilbertSpace((DirectSumHilbertSpace(TensorProductHilbertSpace(ComplexSpace(Integer(1)),ComplexSpace(Integer(2))),TensorPowerHilbertSpace(FockSpace(),Integer(2)))),(DirectSumHilbertSpace(L2(Interval(Integer(0), oo, False, True)),HilbertSpace())))")
("\\int x dx", Integral(x, x)),
("\\int x d\\theta", Integral(x, theta)),
("\\int (x^2 - y)dx", Integral(x**2 - y, x)),
("\\int x + a dx", Integral(_Add(x, a), x)),
("\\int da", Integral(1, a)),
("\\int_0^7 dx", Integral(1, (x, 0, 7))),
("\\int_a^b x dx", Integral(x, (x, a, b))),
("\\int^b_a x dx", Integral(x, (x, a, b))),
("\\int_{a}^b x dx", Integral(x, (x, a, b))),
("\\int^{b}_a x dx", Integral(x, (x, a, b))),
("\\int_{a}^{b} x dx", Integral(x, (x, a, b))),
("\\int^{b}_{a} x dx", Integral(x, (x, a, b))),
("\\int_{f(a)}^{f(b)} f(z) dz", Integral(f(z), (z, f(a), f(b)))),
("\\int (x+a)", Integral(_Add(x, a), x)),
("\\int a + b + c dx", Integral(_Add(_Add(a, b), c), x)),
("\\int \\frac{dz}{z}", Integral(Pow(z, -1), z)),
("\\int \\frac{3 dz}{z}", Integral(3 * Pow(z, -1), z)),
("\\int \\frac{1}{x} dx", Integral(Pow(x, -1), x)),
("\\int \\frac{1}{a} + \\frac{1}{b} dx",
Integral(_Add(_Pow(a, -1), Pow(b, -1)), x)),
("\\int \\frac{3 \\cdot d\\theta}{\\theta}",
Integral(3 * _Pow(theta, -1), theta)),
("\\int \\frac{1}{x} + 1 dx", Integral(_Add(_Pow(x, -1), 1), x)),
("x_0", Symbol('x_{0}')),
("x_{1}", Symbol('x_{1}')),
("x_a", Symbol('x_{a}')),
("x_{b}", Symbol('x_{b}')),
("h_\\theta", Symbol('h_{theta}')),
("h_{\\theta}", Symbol('h_{theta}')),
("h_{\\theta}(x_0, x_1)", Function('h_{theta}')(Symbol('x_{0}'),
Symbol('x_{1}'))),
def test_dim_simplify_dimless():
assert dim_simplify(Mul(Pow(sin(Mul(L, Pow(L, -1))), 2), L)) == L
def test_complex():
a = Symbol("a", real=True)
b = Symbol("b", real=True)
e = (a + I * b) * (a - I * b)
assert e.expand() == a**2 + b**2
assert sqrt(I) == Pow(I, S.Half)
