symengine 0.14.0__cp313-cp313t-win_amd64.whl

symengine-0.14.0.data/purelib/symengine/tests/test_series_expansion.py

@@ -0,0 +1,22 @@
+from symengine.test_utilities import raises
+from symengine.lib.symengine_wrapper import (series, have_piranha, have_flint,
+    Symbol, Integer, sin, cos, exp, sqrt, E)
+
+
+def test_series_expansion():
+    x = Symbol('x')
+    ex = series(sin(1+x), x, n=10)
+    assert ex.coeff(x, 7) == -cos(1)/5040
+
+    x = Symbol('x')
+    ex = series(1/(1-x), x, n=10)
+    assert ex.coeff(x, 9) == 1
+    ex = series(sin(x)*cos(x), x, n=10)
+    assert ex.coeff(x, 8) == 0
+    assert ex.coeff(x, 9) == Integer(2)/Integer(2835)
+
+    ex = series(E**x, x, n=10)
+    assert ex.coeff(x, 9) == Integer(1)/Integer(362880)
+    ex1 = series(1/sqrt(4-x), x, n=50)
+    ex2 = series((4-x)**(Integer(-1)/Integer(2)), x, n=50)
+    assert ex1.coeff(x, 49) == ex2.coeff(x, 49)

symengine-0.14.0.data/purelib/symengine/tests/test_sets.py

@@ -0,0 +1,118 @@
+from symengine.test_utilities import raises
+from symengine.lib.symengine_wrapper import (Interval, EmptySet, UniversalSet,
+    FiniteSet, Union, Complement, ImageSet, ConditionSet, Reals, Rationals,
+    Integers, And, Or, oo, Symbol, true, Ge, Eq, Gt)
+
+
+def test_Interval():
+    assert Interval(0, oo) == Interval(0, oo, False, True)
+    assert Interval(0, oo) == Interval(0, oo, left_open=False, right_open=True)
+    assert Interval(-oo, 0) == Interval(-oo, 0, True, False)
+    assert Interval(-oo, 0) == Interval(-oo, 0, left_open=True, right_open=False)
+    assert Interval(oo, -oo) == EmptySet()
+    assert Interval(oo, oo) == EmptySet()
+    assert Interval(-oo, -oo) == EmptySet()
+    assert isinstance(Interval(1, 1), FiniteSet)
+
+    assert Interval(1, 0) == EmptySet()
+    assert Interval(1, 1, False, True) == EmptySet()
+    assert Interval(1, 1, True, False) == EmptySet()
+    assert Interval(1, 1, True, True) == EmptySet()
+    assert Interval(1, 2).union(Interval(2, 3)) == Interval(1, 3)
+
+    assert Interval(-oo, 0).start == -oo
+    assert Interval(-oo, 0).end == 0
+
+
+def test_EmptySet():
+    E = EmptySet()
+    assert E.intersection(UniversalSet()) == E
+
+
+def test_UniversalSet():
+    U = UniversalSet()
+    x = Symbol("x")
+    assert U.union(Interval(2, 4)) == U
+    assert U.intersection(Interval(2, 4)) == Interval(2, 4)
+    assert U.contains(0) == true
+
+
+def test_Reals():
+    R = Reals()
+    assert R.union(Interval(2, 4)) == R
+    assert R.contains(0) == true
+
+
+def test_Rationals():
+    Q = Rationals()
+    assert Q.union(FiniteSet(2, 3)) == Q
+    assert Q.contains(0) == true
+
+
+def test_Integers():
+    Z = Integers()
+    assert Z.union(FiniteSet(2, 4)) == Z
+    assert Z.contains(0) == true
+
+
+def test_FiniteSet():
+    x = Symbol("x")
+    A = FiniteSet(1, 2, 3)
+    B = FiniteSet(3, 4, 5)
+    AorB = Union(A, B)
+    AandB = A.intersection(B)
+    assert AandB == FiniteSet(3)
+
+    assert FiniteSet(EmptySet()) != EmptySet()
+    assert FiniteSet(FiniteSet(1, 2, 3)) != FiniteSet(1, 2, 3)
+
+
+def test_Union():
+    assert Union(Interval(1, 2), Interval(2, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 2), Interval(2, 3, True)) == Interval(1, 3)
+    assert Union(Interval(1, 3), Interval(2, 4)) == Interval(1, 4)
+    assert Union(Interval(1, 2), Interval(1, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 3), Interval(1, 2)) == Interval(1, 3)
+    assert Union(Interval(1, 3, False, True), Interval(1, 2)) == \
+        Interval(1, 3, False, True)
+    assert Union(Interval(1, 3), Interval(1, 2, False, True)) == Interval(1, 3)
+    assert Union(Interval(1, 2, True), Interval(1, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 2, True), Interval(1, 3, True)) == \
+        Interval(1, 3, True)
+    assert Union(Interval(1, 2, True), Interval(1, 3, True, True)) == \
+        Interval(1, 3, True, True)
+    assert Union(Interval(1, 2, True, True), Interval(1, 3, True)) == \
+        Interval(1, 3, True)
+    assert Union(Interval(1, 3), Interval(2, 3)) == Interval(1, 3)
+    assert Union(Interval(1, 3, False, True), Interval(2, 3)) == \
+        Interval(1, 3)
+    assert Union(Interval(1, 2, False, True), Interval(2, 3, True)) != \
+        Interval(1, 3)
+    assert Union(Interval(1, 2), EmptySet()) == Interval(1, 2)
+    assert Union(EmptySet()) == EmptySet()
+
+
+def test_Complement():
+    assert Complement(Interval(1, 3), Interval(1, 2)) == Interval(2, 3, True)
+    assert Complement(FiniteSet(1, 3, 4), FiniteSet(3, 4)) == FiniteSet(1)
+    assert Complement(Union(Interval(0, 2),
+                            FiniteSet(2, 3, 4)), Interval(1, 3)) == \
+        Union(Interval(0, 1, False, True), FiniteSet(4))
+
+
+def test_ConditionSet():
+    x = Symbol("x")
+    i1 = Interval(-oo, oo)
+    f1 = FiniteSet(0, 1, 2, 4)
+    cond1 = Ge(x**2, 9)
+    assert ConditionSet(x, And(Eq(0, 1), i1.contains(x))) == EmptySet()
+    assert ConditionSet(x, And(Gt(1, 0), i1.contains(x))) == i1
+    assert ConditionSet(x, And(cond1, f1.contains(x))) == FiniteSet(4)
+
+
+def test_ImageSet():
+    x = Symbol("x")
+    i1 = Interval(0, 1)
+    assert ImageSet(x, x**2, EmptySet()) == EmptySet()
+    assert ImageSet(x, 1, i1) == FiniteSet(1)
+    assert ImageSet(x, x, i1) == i1

symengine-0.14.0.data/purelib/symengine/tests/test_solve.py

@@ -0,0 +1,25 @@
+from symengine.test_utilities import raises
+from symengine import (Interval, EmptySet, FiniteSet, I, oo, Eq, Symbol,
+    linsolve)
+from symengine.lib.symengine_wrapper import solve
+
+def test_solve():
+    x = Symbol("x")
+    reals = Interval(-oo, oo)
+
+    assert solve(1, x, reals) == EmptySet
+    assert solve(0, x, reals) == reals
+    assert solve(x + 3, x, reals) == FiniteSet(-3)
+    assert solve(x + 3, x, Interval(0, oo)) == EmptySet
+    assert solve(x, x, reals) == FiniteSet(0)
+    assert solve(x**2 + 1, x) == FiniteSet(-I, I)
+    assert solve(x**2 - 2*x + 1, x) == FiniteSet(1)
+    assert solve(Eq(x**3 + 3*x**2 + 3*x, -1), x, reals) == FiniteSet(-1)
+    assert solve(x**3 - x, x) == FiniteSet(0, 1, -1)
+
+def test_linsolve():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert linsolve([x - 2], [x]) == (2,)
+    assert linsolve([x - 2, y - 3], [x, y]) == (2, 3)
+    assert linsolve([x + y - 3, x + 2*y - 4], [x, y]) == (2, 1)

symengine-0.14.0.data/purelib/symengine/tests/test_subs.py

@@ -0,0 +1,82 @@
+import unittest
+
+from symengine.test_utilities import raises
+from symengine import Symbol, sin, cos, sqrt, Add, function_symbol, have_numpy, log
+
+
+def test_basic():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    e = x+y+z
+    assert e.subs({x: y, z: y}) == 3*y
+
+
+def test_sin():
+    x = Symbol("x")
+    y = Symbol("y")
+    e = sin(x)
+    assert e.subs({x: y}) == sin(y)
+    assert e.subs({x: y}) != sin(x)
+
+    e = cos(x)
+    assert e.subs({x: 0}) == 1
+    assert e.subs(x, 0) == 1
+
+
+def test_subs_exception():
+    x = Symbol("x")
+    expr = sin(log(x))
+    raises(RuntimeError, lambda: expr.subs({x: 0}))
+
+
+def test_args():
+    x = Symbol("x")
+    e = cos(x)
+    raises(TypeError, lambda: e.subs(x, 0, 3))
+
+
+def test_f():
+    x = Symbol("x")
+    y = Symbol("y")
+    f = function_symbol("f", x)
+    g = function_symbol("g", x)
+    assert f.subs({function_symbol("f", x): function_symbol("g", x)}) == g
+    assert ((f+g).subs({function_symbol("f", x): function_symbol("g", x)}) ==
+            2*g)
+
+    e = (f+x)**3
+    assert e.subs({f: y}) == (x+y)**3
+    e = e.expand()
+    assert e.subs({f: y}) == ((x+y)**3).expand()
+
+
+def test_msubs():
+    x = Symbol("x")
+    y = Symbol("y")
+    f = function_symbol("f", x)
+    assert f.msubs({f: y}) == y
+    assert f.diff(x).msubs({f: y}) == f.diff(x)
+
+
+def test_xreplace():
+    x = Symbol("x")
+    y = Symbol("y")
+    f = sin(cos(x))
+    assert f.xreplace({x: y}) == sin(cos(y))
+
+
+@unittest.skipUnless(have_numpy, "Numpy not installed")
+def test_float32():
+    import numpy as np
+    x = Symbol("x")
+    expr = x * 2
+    assert expr.subs({x: np.float32(2)}) == 4.0
+
+
+@unittest.skipUnless(have_numpy, "Numpy not installed")
+def test_float16():
+    import numpy as np
+    x = Symbol("x")
+    expr = x * 2
+    assert expr.subs({x: np.float16(2)}) == 4.0

symengine-0.14.0.data/purelib/symengine/tests/test_symbol.py

@@ -0,0 +1,179 @@
+from symengine import Symbol, symbols, symarray, has_symbol, Dummy
+from symengine.test_utilities import raises
+import unittest
+import platform
+
+
+def test_symbol():
+    x = Symbol("x")
+    assert x.name == "x"
+    assert str(x) == "x"
+    assert str(x) != "y"
+    assert repr(x) == str(x)
+
+
+def test_symbols():
+    x = Symbol('x')
+    y = Symbol('y')
+    z = Symbol('z')
+
+    assert symbols('x') == x
+    assert symbols('x ') == x
+    assert symbols(' x ') == x
+    assert symbols('x,') == (x,)
+    assert symbols('x, ') == (x,)
+    assert symbols('x ,') == (x,)
+
+    assert symbols('x , y') == (x, y)
+
+    assert symbols('x,y,z') == (x, y, z)
+    assert symbols('x y z') == (x, y, z)
+
+    assert symbols('x,y,z,') == (x, y, z)
+    assert symbols('x y z ') == (x, y, z)
+
+    xyz = Symbol('xyz')
+    abc = Symbol('abc')
+
+    assert symbols('xyz') == xyz
+    assert symbols('xyz,') == (xyz,)
+    assert symbols('xyz,abc') == (xyz, abc)
+
+    assert symbols(('xyz',)) == (xyz,)
+    assert symbols(('xyz,',)) == ((xyz,),)
+    assert symbols(('x,y,z,',)) == ((x, y, z),)
+    assert symbols(('xyz', 'abc')) == (xyz, abc)
+    assert symbols(('xyz,abc',)) == ((xyz, abc),)
+    assert symbols(('xyz,abc', 'x,y,z')) == ((xyz, abc), (x, y, z))
+
+    assert symbols(('x', 'y', 'z')) == (x, y, z)
+    assert symbols(['x', 'y', 'z']) == [x, y, z]
+    assert symbols({'x', 'y', 'z'}) == {x, y, z}
+
+    raises(ValueError, lambda: symbols(''))
+    raises(ValueError, lambda: symbols(','))
+    raises(ValueError, lambda: symbols('x,,y,,z'))
+    raises(ValueError, lambda: symbols(('x', '', 'y', '', 'z')))
+
+    x0 = Symbol('x0')
+    x1 = Symbol('x1')
+    x2 = Symbol('x2')
+
+    y0 = Symbol('y0')
+    y1 = Symbol('y1')
+
+    assert symbols('x0:0') == ()
+    assert symbols('x0:1') == (x0,)
+    assert symbols('x0:2') == (x0, x1)
+    assert symbols('x0:3') == (x0, x1, x2)
+
+    assert symbols('x:0') == ()
+    assert symbols('x:1') == (x0,)
+    assert symbols('x:2') == (x0, x1)
+    assert symbols('x:3') == (x0, x1, x2)
+
+    assert symbols('x1:1') == ()
+    assert symbols('x1:2') == (x1,)
+    assert symbols('x1:3') == (x1, x2)
+
+    assert symbols('x1:3,x,y,z') == (x1, x2, x, y, z)
+
+    assert symbols('x:3,y:2') == (x0, x1, x2, y0, y1)
+    assert symbols(('x:3', 'y:2')) == ((x0, x1, x2), (y0, y1))
+
+    a = Symbol('a')
+    b = Symbol('b')
+    c = Symbol('c')
+    d = Symbol('d')
+
+    assert symbols('x:z') == (x, y, z)
+    assert symbols('a:d,x:z') == (a, b, c, d, x, y, z)
+    assert symbols(('a:d', 'x:z')) == ((a, b, c, d), (x, y, z))
+
+    aa = Symbol('aa')
+    ab = Symbol('ab')
+    ac = Symbol('ac')
+    ad = Symbol('ad')
+
+    assert symbols('aa:d') == (aa, ab, ac, ad)
+    assert symbols('aa:d,x:z') == (aa, ab, ac, ad, x, y, z)
+    assert symbols(('aa:d', 'x:z')) == ((aa, ab, ac, ad), (x, y, z))
+
+    def sym(s):
+        return str(symbols(s))
+    assert sym('a0:4') == '(a0, a1, a2, a3)'
+    assert sym('a2:4,b1:3') == '(a2, a3, b1, b2)'
+    assert sym('a1(2:4)') == '(a12, a13)'
+    assert sym('a0:2.0:2') == '(a0.0, a0.1, a1.0, a1.1)'
+    assert sym('aa:cz') == '(aaz, abz, acz)'
+    assert sym('aa:c0:2') == '(aa0, aa1, ab0, ab1, ac0, ac1)'
+    assert sym('aa:ba:b') == '(aaa, aab, aba, abb)'
+    assert sym('a:3b') == '(a0b, a1b, a2b)'
+    assert sym('a-1:3b') == '(a-1b, a-2b)'
+    assert sym(r'a:2\,:2' + chr(0)) == '(a0,0%s, a0,1%s, a1,0%s, a1,1%s)' % (
+        (chr(0),)*4)
+    assert sym('x(:a:3)') == '(x(a0), x(a1), x(a2))'
+    assert sym('x(:c):1') == '(xa0, xb0, xc0)'
+    assert sym('x((:a)):3') == '(x(a)0, x(a)1, x(a)2)'
+    assert sym('x(:a:3') == '(x(a0, x(a1, x(a2)'
+    assert sym(':2') == '(0, 1)'
+    assert sym(':b') == '(a, b)'
+    assert sym(':b:2') == '(a0, a1, b0, b1)'
+    assert sym(':2:2') == '(00, 01, 10, 11)'
+    assert sym(':b:b') == '(aa, ab, ba, bb)'
+
+    raises(ValueError, lambda: symbols(':'))
+    raises(ValueError, lambda: symbols('a:'))
+    raises(ValueError, lambda: symbols('::'))
+    raises(ValueError, lambda: symbols('a::'))
+    raises(ValueError, lambda: symbols(':a:'))
+    raises(ValueError, lambda: symbols('::a'))
+
+
+def test_symarray():
+    try:
+        import numpy as np
+    except ImportError:
+        return
+    x0, x1, x2 = arr = symarray('x', 3)
+    assert arr.shape == (3,)
+
+    assert symarray('y', (2, 3)).shape == (2, 3)
+
+
+def test_has_symbol():
+    a = Symbol('a')
+    b = Symbol('b')
+    c = Symbol('c')
+
+    assert not has_symbol(2, a)
+    assert not has_symbol(c, a)
+    assert has_symbol(a+b, b)
+
+
+def test_dummy():
+    x1 = Symbol('x')
+    x2 = Symbol('x')
+    xdummy1 = Dummy('x')
+    xdummy2 = Dummy('x')
+
+    assert x1 == x2
+    assert x1 != xdummy1
+    assert xdummy1 == (xdummy1 + 1) - 1
+    assert xdummy1 != xdummy2
+    assert Dummy() != Dummy()
+    assert Dummy('x') != Dummy('x')
+
+# Cython cdef classes on PyPy has a __dict__ attribute always
+# __slots__ on PyPy are useless anyways. https://stackoverflow.com/a/23077685/4768820
+@unittest.skipUnless(platform.python_implementation()=="CPython", "__slots__ are useless on PyPy")
+def test_slots():
+    x = Dummy('x')
+    # Verify the successful use of slots.
+    assert not hasattr(x, "__dict__")
+    assert not hasattr(x, "__weakref__")
+
+    x1 = Symbol('x')
+    # Verify the successful use of slots.
+    assert not hasattr(x, "__dict__")
+    assert not hasattr(x, "__weakref__")

symengine-0.14.0.data/purelib/symengine/tests/test_sympify.py

@@ -0,0 +1,63 @@
+from symengine.test_utilities import raises
+
+from symengine import (Symbol, Integer, sympify, SympifyError, true, false, pi, nan, oo,
+                       zoo, E, I, GoldenRatio, Catalan, Rational, sqrt, Eq)
+from symengine.lib.symengine_wrapper import _sympify, S, One, polygamma
+
+
+def test_sympify1():
+    assert sympify(1) == Integer(1)
+    assert sympify(2) != Integer(1)
+    assert sympify(-5) == Integer(-5)
+    assert sympify(Integer(3)) == Integer(3)
+    assert sympify(('0', '0')) == (0, 0)
+    assert sympify(['0', '0']) == [0, 0]
+    assert sympify("3+5") == Integer(8)
+    assert true == sympify(True)
+    assert false == sympify(False)
+
+
+def test_S():
+    assert S(0) == Integer(0)
+    assert S(1) == Integer(1)
+    assert S(-1) == Integer(-1)
+    assert S(1) / 2 == Rational(1, 2)
+    assert S.One is S(1)
+    assert S.Zero is S(0)
+    assert S.NegativeOne is S(-1)
+    assert S.Half is S(1) / 2
+    assert S.Pi is pi
+    assert S.NaN is S(0) / 0
+    assert S.Infinity is -oo * -10
+    assert S.NegativeInfinity is oo * (-3)
+    assert S.ComplexInfinity is zoo
+    assert S.Exp1 is (E + 1 - 1)
+    assert S.ImaginaryUnit is sqrt(-1)
+    assert S.GoldenRatio * 2 / 2 is GoldenRatio
+    assert S.Catalan * 1 is Catalan
+    assert S.EulerGamma is polygamma(0, 1) * -1
+    assert S.true is Eq(2, 2)
+    assert S.false is Eq(2, 3)
+    assert S(1) / 0 is zoo
+    assert S.Pi * 1 is pi
+    assert type(S.One) == One
+
+
+def test_sympify_error1a():
+    class Test:
+        pass
+    raises(SympifyError, lambda: sympify(Test()))
+
+
+def test_sympify_error1b():
+    assert not _sympify("1***2", raise_error=False)
+
+
+def test_error1():
+    # _sympify doesn't parse strings
+    raises(SympifyError, lambda: _sympify("x"))
+
+
+def test_sympify_pow():
+    # https://github.com/symengine/symengine.py/issues/251
+    assert sympify('y*pow(x, -1)') == Symbol('y')/Symbol('x')

symengine-0.14.0.data/purelib/symengine/tests/test_sympy_compat.py

@@ -0,0 +1,200 @@
+from symengine.sympy_compat import (Integer, Rational, S, Basic, Add, Mul,
+    Pow, symbols, Symbol, log, sin, cos, sech, csch, zeros, atan2, nan, Number, Float,
+    Min, Max, RealDouble, have_mpfr, Abs)
+from symengine.test_utilities import raises
+
+
+def test_Integer():
+    i = Integer(5)
+    assert isinstance(i, Integer)
+    assert isinstance(i, Rational)
+    assert isinstance(i, Number)
+    assert isinstance(i, Basic)
+    assert i.p == 5
+    assert i.q == 1
+
+
+def test_Rational():
+    i = S(1)/2
+    assert isinstance(i, Rational)
+    assert isinstance(i, Number)
+    assert isinstance(i, Basic)
+    assert i.p == 1
+    assert i.q == 2
+    x = symbols("x")
+    assert not isinstance(x, Rational)
+    assert not isinstance(x, Number)
+
+
+def test_Float():
+    A = Float("1.23", precision = 53)
+    B = Float("1.23")
+    C = Float(A)
+    assert A == B == C
+    assert isinstance(A, Float)
+    assert isinstance(B, Float)
+    assert isinstance(C, Float)
+    assert isinstance(A, RealDouble)
+    assert isinstance(B, RealDouble)
+    assert isinstance(C, RealDouble)
+    raises(ValueError, lambda: Float("1.23", dps = 3, precision = 10))
+    raises(ValueError, lambda: Float(A, dps = 3, precision = 16))
+    if have_mpfr:
+        from symengine.sympy_compat import RealMPFR
+        A = Float("1.23", dps = 16)
+        B = Float("1.23", precision = 56)
+        assert A == B
+        assert isinstance(A, Float)
+        assert isinstance(B, Float)
+        assert isinstance(A, RealMPFR)
+        assert isinstance(B, RealMPFR)
+        A = Float(C, dps = 16)
+        assert A == B
+        assert isinstance(A, Float)
+        assert isinstance(A, RealMPFR)
+        A = Float(A, precision = 53)
+        assert A == C
+        assert isinstance(A, Float)
+        assert isinstance(A, RealDouble)
+    if not have_mpfr:
+        raises(ValueError, lambda: Float("1.23", precision = 58))        
+
+
+def test_Add():
+    x, y = symbols("x y")
+    i = Add(x, x)
+    assert isinstance(i, Mul)
+    i = Add(x, y)
+    assert isinstance(i, Add)
+    assert isinstance(i, Basic)
+    assert i.func(y, x) == i
+
+
+def test_Mul():
+    x, y = symbols("x y")
+    i = Mul(x, x)
+    assert isinstance(i, Pow)
+    i = Mul(x, y)
+    assert isinstance(i, Mul)
+    assert isinstance(i, Basic)
+    assert i.func(y, x) == i
+
+
+def test_Pow():
+    x = symbols("x")
+    i = Pow(x, 1)
+    assert isinstance(i, Symbol)
+    i = Pow(x, 2)
+    assert isinstance(i, Pow)
+    assert isinstance(i, Basic)
+    assert i.func(x, 2) == i
+
+
+def test_Max():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert Max(Integer(6)/3, 1) == 2
+    assert Max(-2, 2) == 2
+    assert Max(2, 2) == 2
+    assert Max(0.2, 0.3) == 0.3
+    assert Max(x, x) == x
+    assert Max(x, y) == Max(y, x)
+    assert Max(x, y, z) == Max(z, y, x)
+    assert Max(x, Max(y, z)) == Max(z, y, x)
+    assert Max(1000, 100, -100, x, y, z) == Max(x, y, z, 1000)
+    assert Max(cos(x), sin(x)) == Max(sin(x), cos(x))
+
+
+def test_Min():
+    x = Symbol("x")
+    y = Symbol("y")
+    z = Symbol("z")
+    assert Min(Integer(6)/3, 1) == 1
+    assert Min(-2, 2) == -2
+    assert Min(2, 2) == 2
+    assert Min(0.2, 0.3) == 0.2
+    assert Min(x, x) == x
+    assert Min(x, y) == Min(y, x)
+    assert Min(x, y, z) == Min(z, y, x)
+    assert Min(x, Min(y, z)) == Min(z, y, x)
+    assert Min(1000, 100, -100, x, y, z) == Min(x, y, z, -100)
+    assert Min(cos(x), sin(x)) == Min(cos(x), sin(x))
+
+
+def test_NaN():
+    type(nan)() == nan
+
+
+def test_sin():
+    x = symbols("x")
+    i = sin(0)
+    assert isinstance(i, Integer)
+    i = sin(x)
+    assert isinstance(i, sin)
+
+
+def test_sech():
+    x = symbols("x")
+    i = sech(0)
+    assert isinstance(i, Integer)
+    i = sech(x)
+    assert isinstance(i, sech)
+
+
+def test_csch():
+    x = symbols("x")
+    i = csch(x)
+    assert isinstance(i, csch)
+    i = csch(-1)
+    j = csch(1)
+    assert i == -j
+
+
+def test_log():
+    x, y = symbols("x y")
+    i = log(x, y)
+    assert isinstance(i, Mul)
+    i = log(x)
+    assert isinstance(i, log)
+
+
+def test_ATan2():
+    x, y = symbols("x y")
+    i = atan2(x, y)
+    assert isinstance(i, atan2)
+    i = atan2(0, 1)
+    assert i == 0
+
+
+def test_zeros():
+    assert zeros(3, c=2).shape == (3, 2)
+
+
+def test_has_functions_module():
+    import symengine.sympy_compat as sp
+    assert sp.functions.sin(0) == 0
+
+
+def test_subclass_symbol():
+    # Subclass of Symbol with an extra attribute
+    class Wrapper(Symbol):
+        def __new__(cls, name, extra_attribute):
+            return Symbol.__new__(cls, name)
+
+        def __init__(self, name, extra_attribute):
+            super().__init__(name)
+            self.extra_attribute = extra_attribute
+
+    # Instantiate the subclass
+    x = Wrapper("x", extra_attribute=3)
+    assert x.extra_attribute == 3
+    two_x = 2 * x
+    # Check that after arithmetic, same subclass is returned
+    assert two_x.args[1] is x
+    del two_x
+    x._unsafe_reset()
+
+def test_Abs():
+    x = symbols("x")
+    assert Abs(x) == Abs(-x)