sympy_compat: Add a (fake) functions sub-module that resembles

sympy.functions.

Author: mattwala

symengine/sympy_compat.py

@@ -64,158 +64,182 @@ def __new__(cls, name):
         return symengine.UndefFunction(name)
 
 
-class log(Function):
+from types import ModuleType
+
+functions = ModuleType(__name__ + ".functions")
+import sys
+sys.modules[functions.__name__] = functions
+
+functions.sqrt = sqrt
+functions.exp = exp
+
+
+class _FunctionRegistrarMeta(BasicMeta):
+
+    def __new__(mcls, name, bases, dict):
+        cls = BasicMeta.__new__(mcls, name, bases, dict)
+        if not name.startswith("_"):
+            setattr(functions, name, cls)
+        return cls
+
+
+class _RegisteredFunction(with_metaclass(_FunctionRegistrarMeta, Function)):
+    pass
+
+
+class log(_RegisteredFunction):
     _classes = (symengine.Log,)
 
     def __new__(cls, a, b = E):
         return symengine.log(a, b)
 
 
-class sin(Function):
+class sin(_RegisteredFunction):
     _classes = (symengine.Sin,)
 
     def __new__(cls, a):
         return symengine.sin(a)
 
 
-class cos(Function):
+class cos(_RegisteredFunction):
     _classes = (symengine.Cos,)
 
     def __new__(cls, a):
         return symengine.cos(a)
 
 
-class tan(Function):
+class tan(_RegisteredFunction):
     _classes = (symengine.Tan,)
 
     def __new__(cls, a):
         return symengine.tan(a)
 
-class gamma(Function):
+class gamma(_RegisteredFunction):
     _classes = (symengine.Gamma,)
 
     def __new__(cls, a):
         return symengine.gamma(a)
 
 
-class cot(Function):
+class cot(_RegisteredFunction):
     _classes = (symengine.Cot,)
 
     def __new__(cls, a):
         return symengine.cot(a)
 
 
-class csc(Function):
+class csc(_RegisteredFunction):
     _classes = (symengine.Csc,)
 
     def __new__(cls, a):
         return symengine.csc(a)
 
 
-class sec(Function):
+class sec(_RegisteredFunction):
     _classes = (symengine.Sec,)
 
     def __new__(cls, a):
         return symengine.sec(a)
 
 
-class asin(Function):
+class asin(_RegisteredFunction):
     _classes = (symengine.ASin,)
 
     def __new__(cls, a):
         return symengine.asin(a)
 
 
-class acos(Function):
+class acos(_RegisteredFunction):
     _classes = (symengine.ACos,)
 
     def __new__(cls, a):
         return symengine.acos(a)
 
 
-class atan(Function):
+class atan(_RegisteredFunction):
     _classes = (symengine.ATan,)
 
     def __new__(cls, a):
         return symengine.atan(a)
 
 
-class acot(Function):
+class acot(_RegisteredFunction):
     _classes = (symengine.ACot,)
 
     def __new__(cls, a):
         return symengine.acot(a)
 
 
-class acsc(Function):
+class acsc(_RegisteredFunction):
     _classes = (symengine.ACsc,)
 
     def __new__(cls, a):
         return symengine.acsc(a)
 
 
-class asec(Function):
+class asec(_RegisteredFunction):
     _classes = (symengine.ASec,)
 
     def __new__(cls, a):
         return symengine.asec(a)
 
 
-class sinh(Function):
+class sinh(_RegisteredFunction):
     _classes = (symengine.Sinh,)
 
     def __new__(cls, a):
         return symengine.sinh(a)
 
 
-class cosh(Function):
+class cosh(_RegisteredFunction):
     _classes = (symengine.Cosh,)
 
     def __new__(cls, a):
         return symengine.cosh(a)
 
 
-class tanh(Function):
+class tanh(_RegisteredFunction):
     _classes = (symengine.Tanh,)
 
     def __new__(cls, a):
         return symengine.tanh(a)
 
 
-class coth(Function):
+class coth(_RegisteredFunction):
     _classes = (symengine.Coth,)
 
     def __new__(cls, a):
         return symengine.coth(a)
 
 
-class asinh(Function):
+class asinh(_RegisteredFunction):
     _classes = (symengine.ASinh,)
 
     def __new__(cls, a):
         return symengine.asinh(a)
 
 
-class acosh(Function):
+class acosh(_RegisteredFunction):
     _classes = (symengine.ACosh,)
 
     def __new__(cls, a):
         return symengine.acosh(a)
 
 
-class atanh(Function):
+class atanh(_RegisteredFunction):
     _classes = (symengine.ATanh,)
 
     def __new__(cls, a):
         return symengine.atanh(a)
 
 
-class acoth(Function):
+class acoth(_RegisteredFunction):
     _classes = (symengine.ACoth,)
 
     def __new__(cls, a):
         return symengine.acoth(a)
 
+
 '''
 for i in ("""Sin Cos Tan Gamma Cot Csc Sec ASin ACos ATan
           ACot ACsc ASec Sinh Cosh Tanh Coth ASinh ACosh ATanh

symengine/tests/test_sympy_compat.py

@@ -53,3 +53,6 @@ def test_log():
 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