symengine 0.14.0__cp313-cp313t-win_amd64.whl

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

@@ -0,0 +1,254 @@
+from symengine.test_utilities import raises
+
+from symengine.lib.symengine_wrapper import (isprime, nextprime, gcd,
+    lcm, gcd_ext, mod, quotient, quotient_mod, mod_inverse, crt, fibonacci,
+    fibonacci2, lucas, lucas2, binomial, factorial, divides, factor,
+    factor_lehman_method, factor_pollard_pm1_method, factor_pollard_rho_method,
+    prime_factors, prime_factor_multiplicities, Sieve, Sieve_iterator,
+    bernoulli, primitive_root, primitive_root_list, totient, carmichael,
+    multiplicative_order, legendre, jacobi, kronecker, nthroot_mod,
+    nthroot_mod_list, powermod, powermod_list, Integer, sqrt_mod)
+
+
+def test_probab_prime_p():
+    s = set(Sieve.generate_primes(1000))
+    for n in range(1001):
+        assert (n in s) == isprime(n)
+
+
+def test_nextprime():
+    assert nextprime(-3) == 2
+    assert nextprime(5) == 7
+    assert nextprime(9) == 11
+
+
+def test_gcd():
+    assert gcd(10, 14) == 2
+    assert gcd(-5, 3) == 1
+
+
+def test_lcm():
+    assert lcm(10, 14) == 70
+    assert lcm(-5, 3) == 15
+
+
+def test_gcd_ext():
+    (q, r, p) = gcd_ext(6, 9)
+    assert p == q * 6 + r * 9
+    (q, r, p) = gcd_ext(-15, 10)
+    assert p == q * -15 + r * 10
+    (q, r, p) = gcd_ext(2, 3)
+    assert p == q * 2 + r * 3
+    assert p == 1
+    (q, r, p) = gcd_ext(10, 12)
+    assert p == q * 10 + r * 12
+    assert p == 2
+    (q, r, p) = gcd_ext(100, 2004)
+    assert p == q * 100 + r * 2004
+    assert p == 4
+
+
+def test_mod():
+    assert mod(13, 5) == 3
+    assert mod(-4, 7) == 3
+
+
+def test_mod_error():
+    raises(ZeroDivisionError, lambda: mod(2, 0))
+
+
+def test_quotient():
+    assert quotient(13, 5) == 2
+    assert quotient(-4, 7) == -1
+
+
+def test_quotient_error():
+    raises(ZeroDivisionError, lambda: quotient(1, 0))
+
+
+def test_quotient_mod():
+    assert quotient_mod(13, 5) == (2, 3)
+    assert quotient_mod(-4, 7) == (-1, 3)
+
+
+def test_quotient_mod_error():
+    raises(ZeroDivisionError, lambda: quotient_mod(1, 0))
+
+
+def test_mod_inverse():
+    mod_inverse(2, 7) == 4
+    mod_inverse(0, 3) is None
+    mod_inverse(4, 6) is None
+
+
+def test_crt():
+    assert crt([0, 1, 2, 4], [2, 3, 4, 5]) == 34
+    assert crt([3, 5], [6, 21]) is None
+
+
+def test_fibonacci():
+    assert fibonacci(0) == 0
+    assert fibonacci(5) == 5
+
+
+def test_fibonacci_error():
+    raises(NotImplementedError, lambda: fibonacci(-3))
+
+
+def test_fibonacci2():
+    assert fibonacci2(0) == [0, 1]
+    assert fibonacci2(5) == [5, 3]
+
+
+def test_fibonacci2_error():
+    raises(NotImplementedError, lambda: fibonacci2(-1))
+
+
+def test_lucas():
+    assert lucas(2) == 3
+    assert lucas(3) == 4
+
+
+def test_lucas_error():
+    raises(NotImplementedError, lambda: lucas(-1))
+
+
+def test_lucas2():
+    assert lucas2(3) == [4, 3]
+    assert lucas2(5) == [11, 7]
+
+
+def test_lucas2_error():
+    raises(NotImplementedError, lambda: lucas2(-1))
+
+
+def test_binomial():
+    assert binomial(5, 2) == 10
+    assert binomial(5, 7) == 0
+    assert binomial(-5, 2) == 15
+
+
+def test_binomial_error():
+    raises(ArithmeticError, lambda: binomial(5, -1))
+
+
+def test_factorial():
+    assert factorial(5) == 120
+    assert factorial(0) == 1
+
+
+def test_factorial_error():
+    raises(ArithmeticError, lambda: factorial(-1))
+
+
+def test_divides():
+    assert divides(5, 2) is False
+    assert divides(10, 5) is True
+    assert divides(0, 0) is True
+    assert divides(5, 0) is False
+
+
+def test_factor():
+    f = factor(102)
+    assert f is not None and divides(102, f)
+    assert factor(101) is None
+
+
+def test_prime_factors():
+    assert prime_factors(100) == [2, 2, 5, 5]
+    assert prime_factors(1) == []
+
+
+def test_prime_factor_multiplicities():
+    assert prime_factor_multiplicities(90) == \
+           {Integer(2): 1, Integer(3): 2, Integer(5): 1}
+    assert prime_factor_multiplicities(1) == {}
+
+
+def test_sieve():
+    assert Sieve.generate_primes(50) == [2, 3, 5, 7, 11, 13, 17,
+                                         19, 23, 29, 31, 37, 41, 43, 47]
+    assert len(Sieve.generate_primes(1009)) == 169
+
+
+def test_sieve_iterator():
+    it = Sieve_iterator(101)
+    assert len([i for i in it]) == 26
+
+
+def test_primitive_root():
+    assert primitive_root(27) in [2, 5, 11, 14, 20, 23]
+    assert primitive_root(15) is None
+
+
+def test_primitive_root_list():
+    assert primitive_root_list(54) == [5, 11, 23, 29, 41, 47]
+    assert primitive_root_list(12) == []
+
+
+def test_totient():
+    assert totient(1) == 1
+    assert totient(-15) == 8
+
+
+def test_carmichael():
+    assert carmichael(8) == 2
+    assert carmichael(-21) == 6
+
+
+def test_multiplicative_order():
+    assert multiplicative_order(2, 21) == 6
+    assert multiplicative_order(5, 10) is None
+
+
+def test_legendre():
+    assert legendre(-1, 5) == 1
+    assert legendre(0, 5) == 0
+    assert legendre(2, 5) == -1
+
+
+def test_jacobi():
+    assert legendre(-1, 77) == 1
+    assert legendre(14, 15) == -1
+
+
+def test_kronecker():
+    assert kronecker(9, 2) == 1
+    assert kronecker(-5, -1) == -1
+
+
+def test_nthroot_mod():
+    assert nthroot_mod(12, 5, 77) in [3, 31, 38, 45, 59]
+    assert nthroot_mod(3, 2, 5) is None
+
+
+def test_sqrt_mod():
+    assert sqrt_mod(3, 13) == 9
+    assert sqrt_mod(6, 23) == 12
+    assert sqrt_mod(345, 690) == 345
+    assert sqrt_mod(9, 27, True) == [3, 6, 12, 15, 21, 24]
+    assert sqrt_mod(9, 81, True) == [3, 24, 30, 51, 57, 78]
+    assert sqrt_mod(9, 3**5, True) == [3, 78, 84, 159, 165, 240]
+    assert sqrt_mod(81, 3**4, True) == [0, 9, 18, 27, 36, 45, 54, 63, 72]
+    assert sqrt_mod(81, 3**5, True) == [9, 18, 36, 45, 63, 72, 90, 99, 117,\
+            126, 144, 153, 171, 180, 198, 207, 225, 234]
+    assert sqrt_mod(81, 3**6, True) == [9, 72, 90, 153, 171, 234, 252, 315,\
+            333, 396, 414, 477, 495, 558, 576, 639, 657, 720]
+    assert sqrt_mod(81, 3**7, True) == [9, 234, 252, 477, 495, 720, 738, 963,\
+            981, 1206, 1224, 1449, 1467, 1692, 1710, 1935, 1953, 2178]
+
+
+def test_nthroot_mod_list():
+    assert nthroot_mod_list(-4, 4, 65) == [4, 6, 7, 9, 17, 19, 22, 32,
+                                           33, 43, 46, 48, 56, 58, 59, 61]
+    assert nthroot_mod_list(2, 3, 7) == []
+
+
+def test_powermod():
+    assert powermod(3, 8, 7) == 2
+    assert powermod(3, Integer(11)/2, 13) in [3, 10]
+
+
+def test_powermod_list():
+    assert powermod_list(15, Integer(1)/6, 21) == [3, 6, 9, 12, 15, 18]
+    assert powermod_list(2, Integer(5)/2, 11) == []

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

@@ -0,0 +1,186 @@
+from symengine.test_utilities import raises
+
+from symengine import Integer, I, S, Symbol, pi, Rational
+from symengine.lib.symengine_wrapper import (perfect_power, is_square, integer_nthroot)
+
+
+def test_integer():
+    i = Integer(5)
+    assert str(i) == "5"
+    assert int(i) == 5
+    assert float(i) == 5.0
+    assert complex(i) == 5.0 + 0j
+    assert i.real == i
+    assert i.imag == S.Zero
+
+
+def test_integer_long():
+    py_int = 123434444444444444444
+    i = Integer(py_int)
+    assert str(i) == str(py_int)
+    assert int(i) == py_int
+
+
+def test_integer_string():
+    assert Integer("133") == 133
+
+
+def test_rational():
+    i = Integer(5)/10
+    assert str(i) == "1/2"
+    assert int(i) == 0
+    assert float(i) == 0.5
+    assert complex(i) == 0.5 + 0j
+    assert i.real == i
+    assert i.imag == S.Zero
+
+
+def test_complex():
+    i = Integer(5)/10 + I
+    assert str(i) == "1/2 + I"
+    assert complex(i) == 0.5 + 1j
+    assert i.real == Integer(1)/2
+    assert i.imag == 1
+
+    i = 0.5 + I
+    assert str(i) == "0.5 + 1.0*I"
+    assert complex(i) == 0.5 + 1j
+    assert i.real == 0.5
+    assert i.imag == 1.0
+
+
+def test_smallfloat_valid():
+    i = Integer(7.5)
+    assert str(i) == "7"
+
+
+def test_bigfloat_valid():
+    i = Integer(13333333333333334.5)
+    assert str(i) == "13333333333333334"
+
+
+def test_is_conditions():
+    i = Integer(-123)
+    assert not i.is_zero
+    assert not i.is_positive
+    assert i.is_negative
+    assert i.is_nonzero
+    assert i.is_nonpositive
+    assert not i.is_nonnegative
+    assert not i.is_complex
+
+    i = Integer(123)
+    assert not i.is_zero
+    assert i.is_positive
+    assert not i.is_negative
+    assert i.is_nonzero
+    assert not i.is_nonpositive
+    assert i.is_nonnegative
+    assert not i.is_complex
+
+    i = Integer(0)
+    assert i.is_zero
+    assert not i.is_positive
+    assert not i.is_negative
+    assert not i.is_nonzero
+    assert i.is_nonpositive
+    assert i.is_nonnegative
+    assert not i.is_complex
+
+    i = Integer(1) + I
+    assert not i.is_zero
+    assert not i.is_positive
+    assert not i.is_negative
+    assert not i.is_nonzero
+    assert not i.is_nonpositive
+    assert not i.is_nonnegative
+    assert i.is_complex
+
+    assert pi.is_number
+
+
+def test_perfect_power():
+    assert perfect_power(1) == True
+    assert perfect_power(7) == False
+    assert perfect_power(8) == True
+    assert perfect_power(9) == True
+    assert perfect_power(10) == False
+    assert perfect_power(1024) == True
+    assert perfect_power(1025) == False
+    assert perfect_power(6**7) == True
+    assert perfect_power(-27) == True
+    assert perfect_power(-64) == True
+    assert perfect_power(-32) == True
+
+
+def test_perfect_square():
+    assert is_square(7) == False
+    assert is_square(8) == False
+    assert is_square(9) == True
+    assert is_square(10) == False
+    assert perfect_power(49) == True
+    assert perfect_power(50) == False
+
+
+def test_integer_nthroot():
+    assert integer_nthroot(1, 2) == (1, True)
+    assert integer_nthroot(1, 5) == (1, True)
+    assert integer_nthroot(2, 1) == (2, True)
+    assert integer_nthroot(2, 2) == (1, False)
+    assert integer_nthroot(2, 5) == (1, False)
+    assert integer_nthroot(4, 2) == (2, True)
+    assert integer_nthroot(123**25, 25) == (123, True)
+    assert integer_nthroot(123**25 + 1, 25) == (123, False)
+    assert integer_nthroot(123**25 - 1, 25) == (122, False)
+    assert integer_nthroot(1, 1) == (1, True)
+    assert integer_nthroot(0, 1) == (0, True)
+    assert integer_nthroot(0, 3) == (0, True)
+    assert integer_nthroot(10000, 1) == (10000, True)
+    assert integer_nthroot(4, 2) == (2, True)
+    assert integer_nthroot(16, 2) == (4, True)
+    assert integer_nthroot(26, 2) == (5, False)
+    assert integer_nthroot(1234567**7, 7) == (1234567, True)
+    assert integer_nthroot(1234567**7 + 1, 7) == (1234567, False)
+    assert integer_nthroot(1234567**7 - 1, 7) == (1234566, False)
+    b = 25**1000
+    assert integer_nthroot(b, 1000) == (25, True)
+    assert integer_nthroot(b + 1, 1000) == (25, False)
+    assert integer_nthroot(b - 1, 1000) == (24, False)
+    c = 10**400
+    c2 = c**2
+    assert integer_nthroot(c2, 2) == (c, True)
+    assert integer_nthroot(c2 + 1, 2) == (c, False)
+    assert integer_nthroot(c2 - 1, 2) == (c - 1, False)
+
+
+def test_is_zero():
+    assert Symbol('x').is_zero is None
+
+
+def test_is_positive():
+    assert Rational(1, 2).is_positive
+    assert not Rational(-2, 3).is_positive
+    assert Symbol('x').is_positive is None
+
+
+def test_is_negative():
+    assert not Rational(1, 2).is_negative
+    assert Rational(-2, 3).is_negative
+    assert Symbol('x').is_negative is None
+
+
+def test_is_nonpositive():
+    assert not Rational(1, 2).is_nonpositive
+    assert Rational(-2, 3).is_nonpositive
+    assert Symbol('x').is_nonpositive is None
+
+
+def test_is_nonnegative():
+    assert Rational(1, 2).is_nonnegative
+    assert not Rational(-2, 3).is_nonnegative
+    assert Symbol('x').is_nonnegative is None
+
+
+def test_is_real():
+    assert Rational(1, 2).is_real
+    assert Symbol('x').is_real is None

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

@@ -0,0 +1,59 @@
+from symengine import symbols, sin, sinh, have_numpy, have_llvm, cos, Symbol
+from symengine.test_utilities import raises
+import pickle
+import unittest
+
+
+def test_basic():
+    x, y, z = symbols('x y z')
+    expr = sin(cos(x + y)/z)**2
+    s = pickle.dumps(expr)
+    expr2 = pickle.loads(s)
+    assert expr == expr2
+
+
+class MySymbolBase(Symbol):
+    def __init__(self, name, attr):
+        super().__init__(name=name)
+        self.attr = attr
+
+    def __eq__(self, other):
+        if not isinstance(other, MySymbolBase):
+            return False
+        return self.name == other.name and self.attr == other.attr
+
+
+class MySymbol(MySymbolBase):
+    def __reduce__(self):
+        return (self.__class__, (self.name, self.attr))
+
+
+def test_pysymbol():
+    a = MySymbol("hello", attr=1)
+    b = pickle.loads(pickle.dumps(a + 2)) - 2
+    try:
+        assert a == b
+    finally:
+        a._unsafe_reset()
+        b._unsafe_reset()
+
+    a = MySymbolBase("hello", attr=1)
+    try:
+        raises(NotImplementedError, lambda: pickle.dumps(a))
+        raises(NotImplementedError, lambda: pickle.dumps(a + 2))
+    finally:
+        a._unsafe_reset()
+
+
+@unittest.skipUnless(have_llvm, "No LLVM support")
+@unittest.skipUnless(have_numpy, "Numpy not installed")
+def test_llvm_double():
+    import numpy as np
+    from symengine import Lambdify
+    args = x, y, z = symbols('x y z')
+    expr = sin(sinh(x+y) + z)
+    l = Lambdify(args, expr, cse=True, backend='llvm')
+    ss = pickle.dumps(l)
+    ll = pickle.loads(ss)
+    inp = [1, 2, 3]
+    assert np.allclose(l(inp), ll(inp))

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

@@ -0,0 +1,38 @@
+from symengine import (ccode, unicode, Symbol, sqrt, Pow, Max, sin, Integer, MutableDenseMatrix)
+from symengine.test_utilities import raises
+from symengine.printing import CCodePrinter, init_printing
+
+def test_ccode():
+    x = Symbol("x")
+    y = Symbol("y")
+    assert ccode(x) == "x"
+    assert ccode(x**3) == "pow(x, 3)"
+    assert ccode(x**(y**3)) == "pow(x, pow(y, 3))"
+    assert ccode(x**-1.0) == "pow(x, -1.0)"
+    assert ccode(Max(x, x*x)) == "fmax(x, pow(x, 2))"
+    assert ccode(sin(x)) == "sin(x)"
+    assert ccode(Integer(67)) == "67"
+    assert ccode(Integer(-1)) == "-1"
+
+def test_CCodePrinter():
+    x = Symbol("x")
+    y = Symbol("y")
+    myprinter = CCodePrinter()
+
+    assert myprinter.doprint(1+x, "bork") == "bork = 1 + x;"
+    assert myprinter.doprint(1*x) == "x"
+    assert myprinter.doprint(MutableDenseMatrix(1, 2, [x, y]), "larry") == "larry[0] = x;\nlarry[1] = y;"
+    raises(TypeError, lambda: myprinter.doprint(sin(x), Integer))
+    raises(RuntimeError, lambda: myprinter.doprint(MutableDenseMatrix(1, 2, [x, y])))
+
+def test_init_printing():
+    x = Symbol("x")
+    assert x._repr_latex_() is None
+    init_printing()
+    assert x._repr_latex_() == '$x$'
+
+
+def test_unicode():
+    x = Symbol("x")
+    y = Integer(2)
+    assert unicode(x / 2) == "x\n―\n2"

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

@@ -0,0 +1,175 @@
+from symengine import (Integer, symbols, sin, cos, pi, E, I, oo, zoo,
+    nan, true, false, Add, function_symbol, DenseMatrix,
+    sympify, log, EulerGamma, Catalan, GoldenRatio)
+from symengine.lib.symengine_wrapper import (PyNumber, PyFunction,
+    sage_module, wrap_sage_function, LambertW, KroneckerDelta, erf,
+    lowergamma, uppergamma, loggamma, beta, floor, ceiling, conjugate)
+import unittest
+
+try:
+    import sage.all as sage
+    have_sage = True
+except ImportError:
+    have_sage = False
+
+@unittest.skipUnless(have_sage, "Sage not installed")
+def test_sage_conversions():
+
+    x, y = sage.SR.var('x y')
+    x1, y1 = symbols('x, y')
+
+    # Symbol
+    assert x1._sage_() == x
+    assert x1 == sympify(x)
+
+    # Integer
+    assert Integer(12)._sage_() == sage.Integer(12)
+    assert Integer(12) == sympify(sage.Integer(12))
+
+    # Rational
+    assert (Integer(1) / 2)._sage_() == sage.Integer(1) / 2
+    assert Integer(1) / 2 == sympify(sage.Integer(1) / 2)
+
+    # Operators
+    assert x1 + y == x1 + y1
+    assert x1 * y == x1 * y1
+    assert x1 ** y == x1 ** y1
+    assert x1 - y == x1 - y1
+    assert x1 / y == x1 / y1
+
+    assert x + y1 == x + y
+    assert x * y1 == x * y
+    # Doesn't work in Sage 6.1.1ubuntu2
+    # assert x ** y1 == x ** y
+    assert x - y1 == x - y
+    assert x / y1 == x / y
+
+    # Conversions
+    assert (x1 + y1)._sage_() == x + y
+    assert (x1 * y1)._sage_() == x * y
+    assert (x1 ** y1)._sage_() == x ** y
+    assert (x1 - y1)._sage_() == x - y
+    assert (x1 / y1)._sage_() == x / y
+
+    assert x1 + y1 == sympify(x + y)
+    assert x1 * y1 == sympify(x * y)
+    assert x1 ** y1 == sympify(x ** y)
+    assert x1 - y1 == sympify(x - y)
+    assert x1 / y1 == sympify(x / y)
+
+    # Functions
+    assert sin(x1) == sin(x)
+    assert sin(x1)._sage_() == sage.sin(x)
+    assert sin(x1) == sympify(sage.sin(x))
+
+    assert cos(x1) == cos(x)
+    assert cos(x1)._sage_() == sage.cos(x)
+    assert cos(x1) == sympify(sage.cos(x))
+
+    assert function_symbol('f', x1, y1)._sage_() == sage.function('f')(x, y)
+    assert (function_symbol('f', 2 * x1, x1 + y1).diff(x1)._sage_() ==
+            sage.function('f')(2 * x, x + y).diff(x))
+
+    assert LambertW(x1) == LambertW(x)
+    assert LambertW(x1)._sage_() == sage.lambert_w(x)
+
+    assert KroneckerDelta(x1, y1) == KroneckerDelta(x, y)
+    assert KroneckerDelta(x1, y1)._sage_() == sage.kronecker_delta(x, y)
+
+    assert erf(x1) == erf(x)
+    assert erf(x1)._sage_() == sage.erf(x)
+
+    assert lowergamma(x1, y1) == lowergamma(x, y)
+    assert lowergamma(x1, y1)._sage_() == sage.gamma_inc_lower(x, y)
+
+    assert uppergamma(x1, y1) == uppergamma(x, y)
+    assert uppergamma(x1, y1)._sage_() == sage.gamma_inc(x, y)
+
+    assert loggamma(x1) == loggamma(x)
+    assert loggamma(x1)._sage_() == sage.log_gamma(x)
+
+    assert beta(x1, y1) == beta(x, y)
+    assert beta(x1, y1)._sage_() == sage.beta(x, y)
+
+    assert floor(x1) == floor(x)
+    assert floor(x1)._sage_() == sage.floor(x)
+
+    assert ceiling(x1) == ceiling(x)
+    assert ceiling(x1)._sage_() == sage.ceil(x)
+
+    assert conjugate(x1) == conjugate(x)
+    assert conjugate(x1)._sage_() == sage.conjugate(x)
+
+    # For the following test, sage needs to be modified
+    # assert sage.sin(x) == sage.sin(x1)
+
+    # Constants and Booleans
+    assert pi._sage_() == sage.pi
+    assert E._sage_() == sage.e
+    assert I._sage_() == sage.I
+    assert GoldenRatio._sage_() == sage.golden_ratio
+    assert Catalan._sage_() == sage.catalan
+    assert EulerGamma._sage_() == sage.euler_gamma
+    assert oo._sage_() == sage.oo
+    assert zoo._sage_() == sage.unsigned_infinity
+    assert nan._sage_() == sage.NaN
+    assert true._sage_() == True
+    assert false._sage_() == False
+
+    assert pi == sympify(sage.pi)
+    assert E == sympify(sage.e)
+    assert GoldenRatio == sympify(sage.golden_ratio)
+    assert Catalan == sympify(sage.catalan)
+    assert EulerGamma == sympify(sage.euler_gamma)
+    assert oo == sympify(sage.oo)
+    assert zoo == sympify(sage.unsigned_infinity)
+    assert nan == sympify(sage.NaN)
+
+    # SympyConverter does not support converting the following
+    # assert I == sympify(sage.I)
+
+    # Matrix
+    assert DenseMatrix(1, 2, [x1, y1])._sage_() == sage.matrix([[x, y]])
+
+    # SympyConverter does not support converting the following
+    # assert DenseMatrix(1, 2, [x1, y1]) == sympify(sage.matrix([[x, y]]))
+
+    # Sage Number
+    a = sage.Mod(2, 7)
+    b = PyNumber(a, sage_module)
+
+    a = a + 8
+    b = b + 8
+    assert isinstance(b, PyNumber)
+    assert b._sage_() == a
+    assert str(a) == str(b)
+
+    # Sage Function
+    e = x1 + wrap_sage_function(sage.log_gamma(x))
+    assert str(e) == "x + log_gamma(x)"
+    assert isinstance(e, Add)
+    assert (e + wrap_sage_function(sage.log_gamma(x)) ==
+            x1 + 2*wrap_sage_function(sage.log_gamma(x)))
+
+    f = e.subs({x1: 10})
+    assert f == 10 + log(362880)
+
+    f = e.subs({x1: 2})
+    assert f == 2
+
+    f = e.subs({x1: 100})
+    v = f.n(53, real=True)
+    assert abs(float(v) - 459.13420537) < 1e-7
+
+    f = e.diff(x1)
+    # Enable this once symengine conversions are in
+    #  sage as sage.psi is converted to a sympy function in `e.diff(x1)`
+    # assert f == 1 + wrap_sage_function(sage.psi(x))
+
+
+# This string contains Sage doctests, that execute all the functions above.
+# When you add a new function, add it here as well.
+"""
+TESTS::
+    sage: test_sage_conversions()
+"""