Improvements

Author: ShikharJ

symengine/__init__.py

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

symengine/lib/symengine.pxd

@@ -372,6 +372,7 @@ cdef extern from "<symengine/rational.h>" namespace "SymEngine":
     cdef RCP[const Number] from_mpq "SymEngine::Rational::from_mpq"(rational_class r) nogil
     cdef void get_num_den(const Rational &rat, const Ptr[RCP[Integer]] &num,
                      const Ptr[RCP[Integer]] &den) nogil
+    cdef RCP[const Number] rational(long n, long d) nogil
 
 cdef extern from "<symengine/complex.h>" namespace "SymEngine":
     cdef cppclass Complex(Number):

symengine/lib/symengine_wrapper.pyx

@@ -1174,92 +1174,96 @@ cdef class Constant(Basic):
         self.thisptr = symengine.make_rcp_Constant(name.encode("utf-8"))
 
     def _sympy_(self):
-        import sympy
-        if self == E:
-            return sympy.E
-        elif self == pi:
-            return sympy.pi
-        elif self == golden_ratio:
-            return sympy.GoldenRatio
-        elif self == catalan:
-            return sympy.Catalan
-        elif self == eulergamma:
-            return sympy.EulerGamma
-        else:
-            raise Exception("Unknown Constant")
+        raise Exception("Unknown Constant")
 
     def _sage_(self):
-        import sage.all as sage
-        if self == E:
-            return sage.e
-        elif self == pi:
-            return sage.pi
-        elif self == golden_ratio:
-            return sage.golden_ratio
-        elif self == catalan:
-            return sage.catalan
-        elif self == eulergamma:
-            return sage.euler_gamma
-        else:
-            raise Exception("Unknown Constant")
+        raise Exception("Unknown Constant")
 
 
-class ImaginaryUnit(Complex):
+cdef class ImaginaryUnit(Complex):
 
-    def __new__(cls):
-        cdef Basic r = Complex.__new__(ImaginaryUnit)
-        r.thisptr = symengine.I
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.I
 
 I = ImaginaryUnit()
 
 
-class Pi(Constant):
+cdef class Pi(Constant):
 
-    def __new__(cls):
-        cdef Basic r = Constant.__new__(Pi)
-        r.thisptr = symengine.pi
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.pi
+
+    def _sympy_(self):
+        import sympy
+        return sympy.pi
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.pi
 
 pi = Pi()
 
 
-class Exp1(Constant):
+cdef class Exp1(Constant):
 
-    def __new__(cls):
-        cdef Basic r = Constant.__new__(Exp1)
-        r.thisptr = symengine.E
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.E
+
+    def _sympy_(self):
+        import sympy
+        return sympy.E
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.e
 
 E = Exp1()
 
 
-class GoldenRatio(Constant):
+cdef class GoldenRatio(Constant):
 
-    def __new__(cls):
-        cdef Basic r = Constant.__new__(GoldenRatio)
-        r.thisptr = symengine.GoldenRatio
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.GoldenRatio
+
+    def _sympy_(self):
+        import sympy
+        return sympy.GoldenRatio
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.golden_ratio
 
 golden_ratio = GoldenRatio()
 
 
-class Catalan(Constant):
+cdef class Catalan(Constant):
 
-    def __new__(cls):
-        cdef Basic r = Constant.__new__(Catalan)
-        r.thisptr = symengine.Catalan
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.Catalan
+
+    def _sympy_(self):
+        import sympy
+        return sympy.Catalan
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.catalan
 
 catalan = Catalan()
 
 
-class EulerGamma(Constant):
+cdef class EulerGamma(Constant):
 
-    def __new__(cls):
-        cdef Basic r = Constant.__new__(EulerGamma)
-        r.thisptr = symengine.EulerGamma
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.EulerGamma
+
+    def _sympy_(self):
+        import sympy
+        return sympy.EulerGamma
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.euler_gamma
 
 eulergamma = EulerGamma()
 
@@ -1270,7 +1274,7 @@ cdef class Boolean(Basic):
         return c2py(<RCP[const symengine.Basic]>(deref(symengine.rcp_static_cast_Boolean(self.thisptr)).logical_not()))
 
 
-class BooleanAtom(Boolean):
+cdef class BooleanAtom(Boolean):
 
     @property
     def is_Boolean(self):
@@ -1281,12 +1285,10 @@ class BooleanAtom(Boolean):
         return True
 
 
-class BooleanTrue(BooleanAtom):
+cdef class BooleanTrue(BooleanAtom):
 
-    def __new__(cls):
-        cdef Basic r = BooleanAtom.__new__(BooleanTrue)
-        r.thisptr = symengine.boolTrue
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.boolTrue
 
     def _sympy_(self):
         import sympy
@@ -1298,12 +1300,10 @@ class BooleanTrue(BooleanAtom):
 true = BooleanTrue()
 
 
-class BooleanFalse(BooleanAtom):
+cdef class BooleanFalse(BooleanAtom):
 
-    def __new__(cls):
-        cdef Basic r = BooleanAtom.__new__(BooleanFalse)
-        r.thisptr = symengine.boolFalse
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.boolFalse
 
     def _sympy_(self):
         import sympy
@@ -1842,16 +1842,14 @@ cdef class Complex(Number):
         return self.real_part()._sage_() + sage.I * self.imaginary_part()._sage_()
 
 
-class Infinity(Number):
+cdef class Infinity(Number):
 
     @property
     def is_infinite(self):
         return True
 
-    def __new__(cls):
-        cdef Basic r = Number.__new__(Infinity)
-        r.thisptr = symengine.Inf
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.Inf
 
     def _sympy_(self):
         import sympy
@@ -1864,16 +1862,14 @@ class Infinity(Number):
 oo = Infinity()
 
 
-class NegativeInfinity(Number):
+cdef class NegativeInfinity(Number):
 
     @property
     def is_infinite(self):
         return True
 
-    def __new__(cls):
-        cdef Basic r = Number.__new__(NegativeInfinity)
-        r.thisptr = symengine.neg(symengine.Inf)
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.neg(symengine.Inf)
 
     def _sympy_(self):
         import sympy
@@ -1886,16 +1882,14 @@ class NegativeInfinity(Number):
 minus_oo = NegativeInfinity()
 
 
-class ComplexInfinity(Number):
+cdef class ComplexInfinity(Number):
 
     @property
     def is_infinite(self):
         return True
 
-    def __new__(cls):
-        cdef Basic r = Number.__new__(ComplexInfinity)
-        r.thisptr = symengine.ComplexInf
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.ComplexInf
 
     def _sympy_(self):
         import sympy
@@ -1908,7 +1902,7 @@ class ComplexInfinity(Number):
 zoo = ComplexInfinity()
 
 
-class NaN(Number):
+cdef class NaN(Number):
 
     @property
     def is_rational(self):
@@ -1926,10 +1920,8 @@ class NaN(Number):
     def is_finite(self):
         return None
 
-    def __new__(cls):
-        cdef Basic r = Number.__new__(NaN)
-        r.thisptr = symengine.Nan
-        return r
+    def __cinit__(Basic self):
+        self.thisptr = symengine.Nan
 
     def _sympy_(self):
         import sympy
@@ -1971,12 +1963,8 @@ minus_one = NegativeOne()
 
 class Half(Rational):
     def __new__(cls):
-        cdef Basic r = Number.__new__(Integer)
-        cdef Basic s = Number.__new__(Integer)
         cdef Basic q = Number.__new__(Half)
-        r.thisptr = <RCP[const symengine.Basic]>symengine.integer(1)
-        s.thisptr = <RCP[const symengine.Basic]>symengine.integer(2)
-        q.thisptr = symengine.div(r.thisptr, s.thisptr)
+        q.thisptr = <RCP[const symengine.Basic]>symengine.rational(1, 2)
         return q
 
 half = Half()
@@ -3698,9 +3686,9 @@ cdef class Sieve_iterator:
 
 
 def module_cleanup():
-    global I, E, pi, oo, zoo, nan, true, false, golden_ratio, catalan, eulergamma, sympy_module, sage_module
+    global I, E, pi, oo, minus_oo, zoo, nan, true, false, golden_ratio, catalan, eulergamma, sympy_module, sage_module
     funcs.clear()
-    del I, E, pi, oo, zoo, nan, true, false, golden_ratio, catalan, eulergamma, sympy_module, sage_module
+    del I, E, pi, oo, minus_oo, zoo, nan, true, false, golden_ratio, catalan, eulergamma, sympy_module, sage_module
 
 import atexit
 atexit.register(module_cleanup)

symengine/tests/test_functions.py

@@ -1,10 +1,10 @@
 from symengine import (Symbol, sin, cos, sqrt, Add, Mul, function_symbol, Integer, log, E, symbols, I,
-                      Rational)
+                      Rational, EulerGamma)
 from symengine.lib.symengine_wrapper import (Subs, Derivative, LambertW, zeta, dirichlet_eta,
                                             zoo, pi, KroneckerDelta, LeviCivita, erf, erfc,
                                             oo, lowergamma, uppergamma, exp, loggamma, beta,
-                                            polygamma, digamma, trigamma, eulergamma, sign,
-                                            floor, ceiling, conjugate, nan, Float)
+                                            polygamma, digamma, trigamma, sign, floor, ceiling,
+                                            conjugate, nan, Float)
 
 import unittest
 
@@ -281,8 +281,8 @@ def test_polygamma():
     assert polygamma(0, -9) == zoo
     assert polygamma(0, -1) == zoo
     assert polygamma(0, 0) == zoo
-    assert polygamma(0, 1) == -eulergamma
-    assert polygamma(0, 7) == Rational(49, 20) - eulergamma
+    assert polygamma(0, 1) == -EulerGamma
+    assert polygamma(0, 7) == Rational(49, 20) - EulerGamma
     assert polygamma(1, 1) == pi**2/6
     assert polygamma(1, 2) == pi**2/6 - 1
     assert polygamma(1, 3) == pi**2/6 - Rational(5, 4)
@@ -295,7 +295,7 @@ def test_digamma():
     x = Symbol("x")
     assert digamma(x) == polygamma(0, x)
     assert digamma(0) == zoo
-    assert digamma(1) == -eulergamma
+    assert digamma(1) == -EulerGamma
 
 
 def test_trigamma():

symengine/tests/test_sage.py

@@ -1,10 +1,9 @@
 from symengine import (Integer, symbols, sin, cos, pi, E, I, oo, zoo,
     nan, true, false, Add, function_symbol, DenseMatrix,
-    sympify, log)
+    sympify, log, EulerGamma, Catalan, GoldenRatio)
 from symengine.lib.symengine_wrapper import (PyNumber, PyFunction,
-    sage_module, wrap_sage_function, catalan, golden_ratio, eulergamma,
-    LambertW, KroneckerDelta, erf, lowergamma, uppergamma, loggamma,
-    beta, floor, ceiling, conjugate)
+    sage_module, wrap_sage_function, LambertW, KroneckerDelta, erf,
+    lowergamma, uppergamma, loggamma, beta, floor, ceiling, conjugate)
 import unittest
 
 try:
@@ -108,9 +107,9 @@ def test_sage_conversions():
     assert pi._sage_() == sage.pi
     assert E._sage_() == sage.e
     assert I._sage_() == sage.I
-    assert golden_ratio._sage_() == sage.golden_ratio
-    assert catalan._sage_() == sage.catalan
-    assert eulergamma._sage_() == sage.euler_gamma
+    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
@@ -119,9 +118,9 @@ def test_sage_conversions():
 
     assert pi == sympify(sage.pi)
     assert E == sympify(sage.e)
-    assert golden_ratio == sympify(sage.golden_ratio)
-    assert catalan == sympify(sage.catalan)
-    assert eulergamma == sympify(sage.euler_gamma)
+    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)