def test_complex_space():
c1 = ComplexSpace(2)
assert isinstance(c1, ComplexSpace)
assert c1.dimension == 2
assert sstr(c1) == 'C(2)'
assert srepr(c1) == 'ComplexSpace(Integer(2))'
n = Symbol('n')
c2 = ComplexSpace(n)
assert isinstance(c2, ComplexSpace)
assert c2.dimension == n
assert sstr(c2) == 'C(n)'
assert srepr(c2) == "ComplexSpace(Symbol('n'))"
assert c2.subs(n, 2) == ComplexSpace(2)
def purestr(x, with_args=False):
"""A string that follows ```obj = type(obj)(*obj.args)``` exactly.
Parameters
==========
with_args : boolean, optional
If ``True``, there will be a second argument for the return
value, which is a tuple containing ``purestr`` applied to each
of the subnodes.
If ``False``, there will not be a second argument for the
return.
Default is ``False``
Examples
========
>>> from sympy import Float, Symbol, MatrixSymbol
>>> from sympy import Integer # noqa: F401
>>> from sympy.printing.dot import purestr
Applying ``purestr`` for basic symbolic object:
>>> code = purestr(Symbol('x'))
>>> code
"Symbol('x')"
>>> eval(code) == Symbol('x')
True
For basic numeric object:
>>> purestr(Float(2))
"Float('2.0', precision=53)"
For matrix symbol:
>>> code = purestr(MatrixSymbol('x', 2, 2))
>>> code
"MatrixSymbol(Symbol('x'), Integer(2), Integer(2))"
>>> eval(code) == MatrixSymbol('x', 2, 2)
True
With ``with_args=True``:
>>> purestr(Float(2), with_args=True)
("Float('2.0', precision=53)", ())
>>> purestr(MatrixSymbol('x', 2, 2), with_args=True)
("MatrixSymbol(Symbol('x'), Integer(2), Integer(2))",
("Symbol('x')", 'Integer(2)', 'Integer(2)'))
"""
sargs = ()
if not isinstance(x, Basic):
rv = str(x)
elif not x.args:
rv = srepr(x)
else:
args = x.args
sargs = tuple(map(purestr, args))
rv = "%s(%s)" % (type(x).__name__, ', '.join(sargs))
if with_args:
rv = rv, sargs
return rv
def test_Laplacian():
assert Laplacian(s3) == Laplacian(R.x**2 + R.y**2 + R.z**2)
assert Laplacian(v3) == Laplacian(R.x**2*R.i + R.y**2*R.j + R.z**2*R.k)
assert Laplacian(s3).doit() == 6
assert Laplacian(v3).doit() == 2*R.i + 2*R.j + 2*R.k
assert srepr(Laplacian(s3)) == \
'Laplacian(Add(Pow(R.x, Integer(2)), Pow(R.y, Integer(2)), Pow(R.z, Integer(2))))'
def test_Laplacian():
assert Laplacian(s3) == Laplacian(R.x**2 + R.y**2 + R.z**2)
assert Laplacian(v3) == Laplacian(R.x**2 * R.i + R.y**2 * R.j +
R.z**2 * R.k)
assert Laplacian(s3).doit() == 6
assert Laplacian(v3).doit() == 2 * R.i + 2 * R.j + 2 * R.k
assert srepr(Laplacian(s3)) == \
'Laplacian(Add(Pow(R.x, Integer(2)), Pow(R.y, Integer(2)), Pow(R.z, Integer(2))))'
def test_logaddexp():
lae_xy = logaddexp(x, y)
ref_xy = log(exp(x) + exp(y))
for wrt, deriv_order in product([x, y, z], range(0, 3)):
assert (
lae_xy.diff(wrt, deriv_order) -
ref_xy.diff(wrt, deriv_order)
).rewrite(log).simplify() == 0
one_third_e = 1*exp(1)/3
two_thirds_e = 2*exp(1)/3
logThirdE = log(one_third_e)
logTwoThirdsE = log(two_thirds_e)
lae_sum_to_e = logaddexp(logThirdE, logTwoThirdsE)
assert lae_sum_to_e.rewrite(log) == 1
assert lae_sum_to_e.simplify() == 1
was = logaddexp(2, 3)
assert srepr(was) == srepr(was.simplify()) # cannot simplify with 2, 3
def test_logaddexp2():
lae2_xy = logaddexp2(x, y)
ref2_xy = log(2**x + 2**y)/log(2)
for wrt, deriv_order in product([x, y, z], range(0, 3)):
assert (
lae2_xy.diff(wrt, deriv_order) -
ref2_xy.diff(wrt, deriv_order)
).rewrite(log).cancel() == 0
def lb(x):
return log(x)/log(2)
two_thirds = S.One*2/3
four_thirds = 2*two_thirds
lbTwoThirds = lb(two_thirds)
lbFourThirds = lb(four_thirds)
lae2_sum_to_2 = logaddexp2(lbTwoThirds, lbFourThirds)
assert lae2_sum_to_2.rewrite(log) == 1
assert lae2_sum_to_2.simplify() == 1
was = logaddexp2(x, y)
assert srepr(was) == srepr(was.simplify()) # cannot simplify with x, y
def simplifySymbolicRegressor(model):
locals = {
"sub": lambda x, y: x - y,
"div": lambda x, y: x / y,
"mul": lambda x, y: x * y,
"add": lambda x, y: x + y,
"neg": lambda x: -x,
"pow": lambda x, y: x**y,
"cos": lambda x: sympy.cos(x),
}
return srepr(simplify(sympify(model, locals=locals)))
def test_dyadic_srepr():
from sympy.printing.repr import srepr
N = CoordSys3D('N')
dy = N.i | N.j
res = "BaseDyadic(CoordSys3D(Str('N'), Tuple(ImmutableDenseMatrix([["\
"Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), "\
"Integer(0)], [Integer(0), Integer(0), Integer(1)]]), "\
"VectorZero())).i, CoordSys3D(Str('N'), Tuple(ImmutableDenseMatrix("\
"[[Integer(1), Integer(0), Integer(0)], [Integer(0), Integer(1), "\
"Integer(0)], [Integer(0), Integer(0), Integer(1)]]), VectorZero())).j)"
assert srepr(dy) == res
def test_issue_4788():
assert srepr(S(1.0 + 0J)) == srepr(S(1.0)) == srepr(Float(1.0))
def _get_srepr(expr):
s = srepr(expr)
s = re.sub(r"WildDot\('(\w+)'\)", r"\1", s)
s = re.sub(r"WildPlus\('(\w+)'\)", r"*\1", s)
s = re.sub(r"WildStar\('(\w+)'\)", r"*\1", s)
return s
def test_hilbert_space():
hs = HilbertSpace()
assert isinstance(hs, HilbertSpace)
assert sstr(hs) == 'H'
assert srepr(hs) == 'HilbertSpace()'
def __repr__(self):
return srepr(Symbol(self.name))
def test_srepr():
from sympy.printing.repr import srepr
res = "CoordSys3D(Str('C'), Tuple(ImmutableDenseMatrix([[Integer(1), "\
"Integer(0), Integer(0)], [Integer(0), Integer(1), Integer(0)], "\
"[Integer(0), Integer(0), Integer(1)]]), VectorZero())).i"
assert srepr(C.i) == res
def simplify(expression):
simplified_expr = sp.to_dnf(parse_expr(expression, evaluate=False),
True)
return srepr(simplified_expr)
def simplify(expression):
simplified_expr = sp.simplify_logic(
parse_expr(expression, evaluate=False))
return srepr(simplified_expr)
