Wrapped miscellaneous functions

Author: ShikharJ

symengine/__init__.py

@@ -9,7 +9,8 @@
         UndefFunction, Function, FunctionSymbol as AppliedUndef,
         have_numpy, true, false, Equality, Unequality, GreaterThan,
         LessThan, StrictGreaterThan, StrictLessThan, Eq, Ne, Ge, Le,
-        Gt, Lt, GoldenRatio, Catalan, EulerGamma)
+        Gt, Lt, GoldenRatio, Catalan, EulerGamma, Dummy, perfect_power,
+        integer_nthroot, isprime, sqrt_mod)
 from .utilities import var, symbols
 from .functions import *
 

symengine/lib/symengine.pxd

@@ -227,6 +227,7 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     bool is_a_Rational "SymEngine::is_a<SymEngine::Rational>"(const Basic &b) nogil
     bool is_a_Complex "SymEngine::is_a<SymEngine::Complex>"(const Basic &b) nogil
     bool is_a_Symbol "SymEngine::is_a<SymEngine::Symbol>"(const Basic &b) nogil
+    bool is_a_Dummy "SymEngine::is_a<SymEngine::Dummy>"(const Basic &b) nogil
     bool is_a_Constant "SymEngine::is_a<SymEngine::Constant>"(const Basic &b) nogil
     bool is_a_Infty "SymEngine::is_a<SymEngine::Infty>"(const Basic &b) nogil
     bool is_a_NaN "SymEngine::is_a<SymEngine::NaN>"(const Basic &b) nogil
@@ -305,6 +306,8 @@ cdef extern from "<symengine/symbol.h>" namespace "SymEngine":
     cdef cppclass Symbol(Basic):
         Symbol(string name) nogil
         string get_name() nogil
+    cdef cppclass Dummy(Symbol):
+        pass
 
 cdef extern from "<symengine/number.h>" namespace "SymEngine":
     cdef cppclass Number(Basic):
@@ -339,6 +342,9 @@ cdef extern from "<symengine/integer.h>" namespace "SymEngine":
         integer_class as_mpz() nogil
     cdef RCP[const Integer] integer(int i) nogil
     cdef RCP[const Integer] integer(integer_class i) nogil
+    int i_nth_root(const Ptr[RCP[Integer]] &r, const Integer &a, unsigned long int n) nogil
+    bool perfect_square(const Integer &n) nogil
+    bool perfect_power(const Integer &n) nogil
 
 cdef extern from "<symengine/rational.h>" namespace "SymEngine":
     cdef cppclass Rational(Number):
@@ -414,20 +420,17 @@ cdef extern from "<symengine/pow.h>" namespace "SymEngine":
     cdef RCP[const Basic] pow(RCP[const Basic] &a, RCP[const Basic] &b) nogil except+
     cdef RCP[const Basic] sqrt(RCP[const Basic] &x) nogil except+
     cdef RCP[const Basic] exp(RCP[const Basic] &x) nogil except+
-    cdef RCP[const Basic] log(RCP[const Basic] &x) nogil except+
-    cdef RCP[const Basic] log(RCP[const Basic] &x, RCP[const Basic] &y) nogil except+
 
     cdef cppclass Pow(Basic):
         RCP[const Basic] get_base() nogil
         RCP[const Basic] get_exp() nogil
 
-    cdef cppclass Log(Basic):
-        RCP[const Basic] get_arg() nogil
-
 
 cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     # We need to specialize these for our classes:
     RCP[const Basic] make_rcp_Symbol "SymEngine::make_rcp<const SymEngine::Symbol>"(string name) nogil
+    RCP[const Basic] make_rcp_Dummy "SymEngine::make_rcp<const SymEngine::Dummy>"() nogil
+    RCP[const Basic] make_rcp_Dummy "SymEngine::make_rcp<const SymEngine::Dummy>"(string name) nogil
     RCP[const Basic] make_rcp_PySymbol "SymEngine::make_rcp<const SymEngine::PySymbol>"(string name, PyObject * pyobj) nogil
     RCP[const Basic] make_rcp_Constant "SymEngine::make_rcp<const SymEngine::Constant>"(string name) nogil
     RCP[const Basic] make_rcp_Infty "SymEngine::make_rcp<const SymEngine::Infty>"(RCP[const Number] i) nogil
@@ -499,7 +502,8 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef RCP[const Basic] floor(RCP[const Basic] &x) nogil except+
     cdef RCP[const Basic] ceiling(RCP[const Basic] &x) nogil except+
     cdef RCP[const Basic] conjugate(RCP[const Basic] &x) nogil except+
-
+    cdef RCP[const Basic] log(RCP[const Basic] &x) nogil except+
+    cdef RCP[const Basic] log(RCP[const Basic] &x, RCP[const Basic] &y) nogil except+
 
     cdef cppclass Function(Basic):
         pass
@@ -667,6 +671,9 @@ cdef extern from "<symengine/functions.h>" namespace "SymEngine":
     cdef cppclass Conjugate(OneArgFunction):
         pass
 
+    cdef cppclass Log(Function):
+        pass
+
 IF HAVE_SYMENGINE_MPFR:
     cdef extern from "mpfr.h":
         ctypedef struct __mpfr_struct:

symengine/lib/symengine_wrapper.pyx

@@ -42,6 +42,8 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = Number.__new__(Rational)
     elif (symengine.is_a_Complex(deref(o))):
         r = Complex.__new__(Complex)
+    elif (symengine.is_a_Dummy(deref(o))):
+        r = Symbol.__new__(Dummy)
     elif (symengine.is_a_Symbol(deref(o))):
         if (symengine.is_a_PySymbol(deref(o))):
             return <object>(deref(symengine.rcp_static_cast_PySymbol(o)).get_py_object())
@@ -197,6 +199,8 @@ def sympy2symengine(a, raise_error=False):
     from sympy.core.function import AppliedUndef as sympy_AppliedUndef
     if isinstance(a, sympy.Symbol):
         return Symbol(a.name)
+    elif isinstance(a, sympy.Dummy):
+        return Dummy(a.name)
     elif isinstance(a, sympy.Mul):
         return mul(*[sympy2symengine(x, raise_error) for x in a.args])
     elif isinstance(a, sympy.Add):
@@ -710,6 +714,8 @@ cdef class Basic(object):
         else:
             return eval(self, prec)
 
+    evalf = n
+
     @property
     def args(self):
         cdef symengine.vec_basic args = deref(self.thisptr).get_args()
@@ -895,6 +901,27 @@ class Symbol(Basic):
         return self.__class__
 
 
+class Dummy(Symbol):
+    
+    def __init__(Basic self, name=None, *args, **kwargs):
+        if name is None:
+            self.thisptr = symengine.make_rcp_Dummy()
+        else:
+            self.thisptr = symengine.make_rcp_Dummy(name.encode("utf-8"))
+
+    def _sympy_(self):
+        import sympy
+        return sympy.Dummy(str(self))
+
+    @property
+    def is_Dummy(self):
+        return True
+
+    @property
+    def func(self):
+        return self.__class__
+
+
 def symarray(prefix, shape, **kwargs):
     """ Creates an nd-array of symbols
 
@@ -2956,6 +2983,8 @@ def diff(ex, *x):
 def expand(x):
     return sympify(x).expand()
 
+expand_mul = expand
+
 def function_symbol(name, *args):
     cdef symengine.vec_basic v
     cdef Basic e_
@@ -2973,6 +3002,23 @@ def exp(x):
     cdef Basic X = sympify(x)
     return c2py(symengine.exp(X.thisptr))
 
+def perfect_power(n):
+    cdef Basic _n = sympify(n)
+    require(_n, Integer)
+    return symengine.perfect_power(deref(symengine.rcp_static_cast_Integer(_n.thisptr)))
+
+def is_square(n):
+    cdef Basic _n = sympify(n)
+    require(_n, Integer)
+    return symengine.perfect_square(deref(symengine.rcp_static_cast_Integer(_n.thisptr)))
+
+def integer_nthroot(a, n):
+    cdef Basic _a = sympify(a)
+    require(_a, Integer)
+    cdef RCP[const symengine.Integer] _r
+    cdef int ret_val = symengine.i_nth_root(symengine.outArg_Integer(_r), deref(symengine.rcp_static_cast_Integer(_a.thisptr)), n)
+    return (c2py(<RCP[const symengine.Basic]>_r), ret_val == 1)
+
 def _max(*args):
     cdef symengine.vec_basic v
     cdef Basic e_
@@ -3103,6 +3149,8 @@ def probab_prime_p(n, reps = 25):
     require(_n, Integer)
     return symengine.probab_prime_p(deref(symengine.rcp_static_cast_Integer(_n.thisptr)), reps) >= 1
 
+isprime = probab_prime_p
+
 def nextprime(n):
     cdef Basic _n = sympify(n)
     require(_n, Integer)
@@ -3132,7 +3180,9 @@ def gcd_ext(a, b):
     cdef RCP[const symengine.Integer] g, s, t
     symengine.gcd_ext(symengine.outArg_Integer(g), symengine.outArg_Integer(s), symengine.outArg_Integer(t),
         deref(symengine.rcp_static_cast_Integer(_a.thisptr)), deref(symengine.rcp_static_cast_Integer(_b.thisptr)))
-    return [c2py(<RCP[const symengine.Basic]>g), c2py(<RCP[const symengine.Basic]>s), c2py(<RCP[const symengine.Basic]>t)]
+    return (c2py(<RCP[const symengine.Basic]>s), c2py(<RCP[const symengine.Basic]>t), c2py(<RCP[const symengine.Basic]>g))
+
+igcdex = gcd_ext
 
 def mod(a, b):
     if b == 0:
@@ -3418,6 +3468,11 @@ def nthroot_mod_list(a, n, m):
         s.append(c2py(<RCP[const symengine.Basic]>(root_list[i])))
     return s
 
+def sqrt_mod(a, p, all_roots=False):
+    if all_roots:
+        return nthroot_mod_list(a, 2, p)
+    return nthroot_mod(a, 2, p)
+
 def powermod(a, b, m):
     cdef Basic _a = sympify(a)
     cdef Basic _m = sympify(m)

symengine/tests/test_ntheory.py

@@ -1,18 +1,19 @@
 from symengine.utilities import raises
 
-from symengine.lib.symengine_wrapper import (probab_prime_p, nextprime, gcd,
+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)
+    nthroot_mod_list, powermod, powermod_list, Integer, sqrt_mod)
 
 
 def test_probab_prime_p():
-    assert probab_prime_p(101) is True
-    assert probab_prime_p(100) is False
+    s = set(Sieve.generate_primes(1000))
+    for n in range(1001):
+        assert (n in s) == isprime(n)
 
 
 def test_nextprime():
@@ -32,10 +33,13 @@ def test_lcm():
 
 
 def test_gcd_ext():
-    [p, q, r] = gcd_ext(6, 9)
+    (q, r, p) = gcd_ext(6, 9)
     assert p == q * 6 + r * 9
-    [p, q, r] = gcd_ext(-15, 10)
+    (q, r, p) = gcd_ext(-15, 10)
     assert p == q * -15 + r * 10
+    assert gcd_ext(2, 3) == (-1, 1, 1)
+    assert gcd_ext(10, 12) == (-1, 1, 2)
+    assert gcd_ext(100, 2004) == (-20, 1, 4)
 
 
 def test_mod():
@@ -212,6 +216,22 @@ def test_nthroot_mod():
     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]

symengine/tests/test_number.py

@@ -1,6 +1,7 @@
 from symengine.utilities import raises
 
 from symengine import Integer, I
+from symengine.lib.symengine_wrapper import (perfect_power, is_square, integer_nthroot)
 
 
 def test_integer():
@@ -63,3 +64,57 @@ def test_is_conditions():
     assert not i.is_nonpositive
     assert not i.is_nonnegative
     assert i.is_complex
+
+
+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)

symengine/tests/test_symbol.py

@@ -1,4 +1,4 @@
-from symengine import Symbol, symbols, symarray, has_symbol
+from symengine import Symbol, symbols, symarray, has_symbol, Dummy
 from symengine.utilities import raises
 
 
@@ -147,3 +147,15 @@ def test_has_symbol():
     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 != xdummy2
+    assert Dummy() != Dummy()
+    assert Dummy('x') != Dummy('x')

symengine_version.txt

@@ -1 +1 @@
-3e87d58a9404535fbc2bb8d09357faf4ab8eb5a1
+d13fec95c651bbce195988a6d9a146e9b726b2c2