Wrapped Infty and NaN classes

Author: ShikharJ

symengine/__init__.py

@@ -1,13 +1,13 @@
 from .lib.symengine_wrapper import (Symbol, sympify as S, sympify,
-        SympifyError, Add, Mul, Pow, function_symbol, I, E, pi,
-        have_mpfr, have_mpc, have_flint, have_piranha, have_llvm, 
-        Integer, Rational, Float, Number, RealNumber, RealDouble,
-        ComplexDouble, Max, Min, DenseMatrix, Matrix, ImmutableMatrix,
-        ImmutableDenseMatrix, MutableDenseMatrix, MatrixBase, Basic,
-        Lambdify, LambdifyCSE, Lambdify as lambdify, DictBasic, symarray,
-        series, diff, zeros, eye, diag, ones, Derivative, Subs,
-        add, expand, has_symbol, UndefFunction, Function,
-        FunctionSymbol as AppliedUndef)
+        SympifyError, Add, Mul, Pow, function_symbol, I, E, pi, oo,
+        zoo, nan, have_mpfr, have_mpc, have_flint, have_piranha,
+        have_llvm, Integer, Rational, Float, Number, RealNumber,
+        RealDouble, ComplexDouble, Max, Min, DenseMatrix, Matrix,
+        ImmutableMatrix, ImmutableDenseMatrix, MutableDenseMatrix,
+        MatrixBase, Basic, Lambdify, LambdifyCSE, Lambdify as lambdify,
+        DictBasic, symarray, series, diff, zeros, eye, diag, ones,
+        Derivative, Subs, add, expand, has_symbol, UndefFunction,
+        Function, FunctionSymbol as AppliedUndef)
 from .utilities import var, symbols
 from .functions import *
 

symengine/lib/symengine.pxd

@@ -144,6 +144,7 @@ cdef extern from "<symengine/symengine_rcp.h>" namespace "SymEngine":
     RCP[const Abs] rcp_static_cast_Abs "SymEngine::rcp_static_cast<const SymEngine::Abs>"(RCP[const Basic] &b) nogil
     RCP[const Max] rcp_static_cast_Max "SymEngine::rcp_static_cast<const SymEngine::Max>"(RCP[const Basic] &b) nogil
     RCP[const Min] rcp_static_cast_Min "SymEngine::rcp_static_cast<const SymEngine::Min>"(RCP[const Basic] &b) nogil
+    RCP[const Infty] rcp_static_cast_Infty "SymEngine::rcp_static_cast<const SymEngine::Infty>"(RCP[const Basic] &b) nogil
     RCP[const Gamma] rcp_static_cast_Gamma "SymEngine::rcp_static_cast<const SymEngine::Gamma>"(RCP[const Basic] &b) nogil
     RCP[const Derivative] rcp_static_cast_Derivative "SymEngine::rcp_static_cast<const SymEngine::Derivative>"(RCP[const Basic] &b) nogil
     RCP[const Subs] rcp_static_cast_Subs "SymEngine::rcp_static_cast<const SymEngine::Subs>"(RCP[const Basic] &b) nogil
@@ -226,6 +227,8 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     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_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
     bool is_a_Sin "SymEngine::is_a<SymEngine::Sin>"(const Basic &b) nogil
     bool is_a_Cos "SymEngine::is_a<SymEngine::Cos>"(const Basic &b) nogil
     bool is_a_Tan "SymEngine::is_a<SymEngine::Tan>"(const Basic &b) nogil
@@ -348,7 +351,17 @@ cdef extern from "<symengine/constants.h>" namespace "SymEngine":
     RCP[const Basic] I
     RCP[const Basic] E
     RCP[const Basic] pi
+    RCP[const Basic] Inf
+    RCP[const Basic] ComplexInf
+    RCP[const Basic] Nan
+  
+cdef extern from "<symengine/infinity.h>" namespace "SymEngine":
+    cdef cppclass Infty(Number):
+        pass
 
+cdef extern from "<symengine/nan.h>" namespace "SymEngine":
+    cdef cppclass NaN(Number):
+        pass
 
 cdef extern from "<symengine/add.h>" namespace "SymEngine":
     cdef RCP[const Basic] add(RCP[const Basic] &a, RCP[const Basic] &b) nogil except+
@@ -392,6 +405,8 @@ cdef extern from "<symengine/basic.h>" namespace "SymEngine":
     RCP[const Basic] make_rcp_Symbol "SymEngine::make_rcp<const SymEngine::Symbol>"(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
+    RCP[const Basic] make_rcp_NaN "SymEngine::make_rcp<const SymEngine::NaN>"() nogil
     RCP[const Basic] make_rcp_Integer "SymEngine::make_rcp<const SymEngine::Integer>"(int i) nogil
     RCP[const Basic] make_rcp_Integer "SymEngine::make_rcp<const SymEngine::Integer>"(integer_class i) nogil
     RCP[const Basic] make_rcp_Subs "SymEngine::make_rcp<const SymEngine::Subs>"(RCP[const Basic] arg, const map_basic_basic &x) nogil

symengine/lib/symengine_wrapper.pyx

@@ -40,6 +40,15 @@ cdef c2py(RCP[const symengine.Basic] o):
         r = Basic.__new__(Symbol)
     elif (symengine.is_a_Constant(deref(o))):
         r = Constant.__new__(Constant)
+    elif (symengine.is_a_Infty(deref(o))):
+        if (deref(symengine.rcp_static_cast_Infty(o)).is_positive()):
+            r = Number.__new__(Infinity)
+        elif (deref(symengine.rcp_static_cast_Infty(o)).is_negative()):
+            r = Number.__new__(NegativeInfinity)
+        else:
+            r = Number.__new__(ComplexInfinity)
+    elif (symengine.is_a_NaN(deref(o))):
+        r = Number.__new__(NaN)
     elif (symengine.is_a_PyFunction(deref(o))):
         r = PyFunction.__new__(PyFunction)
     elif (symengine.is_a_FunctionSymbol(deref(o))):
@@ -160,6 +169,14 @@ def sympy2symengine(a, raise_error=False):
         return E
     elif a is sympy.pi:
         return pi
+    elif a is sympy.S.NegativeInfinity:
+        return -oo
+    elif a is sympy.S.Infinity:
+        return oo
+    elif a is sympy.S.ComplexInfinity:
+        return zoo
+    elif a is sympy.nan:
+        return nan
     elif isinstance(a, sympy.functions.elementary.trigonometric.TrigonometricFunction):
         if isinstance(a, sympy.sin):
             return sin(a.args[0])
@@ -1161,6 +1178,58 @@ cdef class Complex(Number):
         import sage.all as sage
         return self.real_part()._sage_() + sage.I * self.imaginary_part()._sage_()
 
+class Infinity(Number):
+
+    def __new__(cls):
+        return oo
+
+    def _sympy_(self):
+        import sympy
+        return sympy.oo
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.oo
+
+class NegativeInfinity(Number):
+
+    def __new__(cls):
+        return -oo
+
+    def _sympy_(self):
+        import sympy
+        return -sympy.oo
+
+    def _sage_(self):
+        import sage.all as sage
+        return -sage.oo
+
+class ComplexInfinity(Number):
+
+    def __new__(cls):
+        return zoo
+
+    def _sympy_(self):
+        import sympy
+        return sympy.zoo
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.unsigned_infinity
+
+class NaN(Number):
+
+    def __new__(cls):
+        return nan
+
+    def _sympy_(self):
+        import sympy
+        return sympy.nan
+
+    def _sage_(self):
+        import sage.all as sage
+        return sage.NaN
+
 class Add(Basic):
 
     def __new__(cls, *args, **kwargs):
@@ -2456,10 +2525,13 @@ cdef class Sieve_iterator:
 I = c2py(symengine.I)
 E = c2py(symengine.E)
 pi = c2py(symengine.pi)
+oo = c2py(symengine.Inf)
+zoo = c2py(symengine.ComplexInf)
+nan = c2py(symengine.Nan)
 
 def module_cleanup():
-    global I, E, pi, sympy_module, sage_module
-    del I, E, pi, sympy_module, sage_module
+    global I, E, pi, oo, zoo, nan, sympy_module, sage_module
+    del I, E, pi, oo, zoo, nan, sympy_module, sage_module
 
 import atexit
 atexit.register(module_cleanup)

symengine/tests/test_sage.py

@@ -1,5 +1,5 @@
-from symengine import (Integer, symbols, sin, cos, pi, E, I, Add,
-    function_symbol, DenseMatrix, sympify, log)
+from symengine import (Integer, symbols, sin, cos, pi, E, I, oo, zoo,
+    nan, Add, function_symbol, DenseMatrix, sympify, log)
 from symengine.lib.symengine_wrapper import (PyNumber, PyFunction,
     sage_module, wrap_sage_function)
 
@@ -72,9 +72,15 @@ def test_sage_conversions():
     assert pi._sage_() == sage.pi
     assert E._sage_() == sage.e
     assert I._sage_() == sage.I
+    assert oo._sage_() == sage.oo
+    assert zoo._sage_() == sage.unsigned_infinity
+    assert nan._sage_() == sage.NaN
 
     assert pi == sympify(sage.pi)
     assert E == sympify(sage.e)
+    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)

symengine/tests/test_sympy_compat.py

@@ -1,5 +1,5 @@
 from symengine.sympy_compat import (Integer, Rational, S, Basic, Add, Mul,
-    Pow, symbols, Symbol, log, sin, cos, sech, csch, zeros, atan2, Number, Float,
+    Pow, symbols, Symbol, log, sin, cos, sech, csch, zeros, atan2, nan, Number, Float,
     Min, Max, RealDouble, have_mpfr, Abs)
 from symengine.utilities import raises
 
@@ -119,6 +119,10 @@ def test_Min():
     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)

symengine/tests/test_sympy_conv.py

@@ -1,8 +1,8 @@
 from symengine import (Symbol, Integer, sympify, SympifyError, log,
-        function_symbol, I, E, pi, exp, gamma, have_mpfr, have_mpc,
-        DenseMatrix, sin, cos, tan, cot, csc, sec, asin, acos, atan,
-        acot, acsc, asec, sinh, cosh, tanh, coth, asinh, acosh, atanh,
-        acoth, Add, Mul, Pow, diff)
+        function_symbol, I, E, pi, oo, zoo, nan, exp, gamma, have_mpfr,
+        have_mpc, DenseMatrix, sin, cos, tan, cot, csc, sec, asin, acos,
+        atan, acot, acsc, asec, sinh, cosh, tanh, coth, asinh, acosh,
+        atanh, acoth, Add, Mul, Pow, diff)
 from symengine.lib.symengine_wrapper import (Subs, Derivative, RealMPFR,
         ComplexMPC, PyNumber, Function)
 import sympy
@@ -370,6 +370,15 @@ def test_constants():
     assert sympify(sympy.pi) == pi
     assert sympy.pi == pi._sympy_()
 
+    assert sympify(sympy.oo) == oo
+    assert sympy.oo == oo._sympy_()
+
+    assert sympify(sympy.zoo) == zoo
+    assert sympy.zoo == zoo._sympy_()
+
+    assert sympify(sympy.nan) == nan
+    assert sympy.nan == nan._sympy_()
+
 
 def test_abs():
     x = Symbol("x")