Merge pull request #100 from isuruf/pydy

Improve subs and msubs

Author: certik

benchmarks/pydy_pendulum.py

@@ -6,7 +6,7 @@
 import sympy
 import symengine
 import pydy
-from pydy.models import n_link_pendulum_on_cart
+from sympy.physics.mechanics.models import n_link_pendulum_on_cart
 
 print(sympy.__file__)
 print(symengine.__file__)

symengine/lib/symengine_wrapper.pyx

@@ -12,7 +12,7 @@ import itertools
 from operator import mul
 from functools import reduce
 import collections
-
+import warnings
 
 include "config.pxi"
 
@@ -365,6 +365,27 @@ class DictBasic(_DictBasic, collections.MutableMapping):
     def __repr__(self):
         return self.__str__()
 
+def get_dict(*args):
+    """
+    Returns a DictBasic instance from args. Inputs can be,
+        1. a DictBasic
+        2. a Python dictionary
+        3. two args old, new
+    """
+    if len(args) == 2:
+        arg = {args[0]: args[1]}
+    elif len(args) == 1:
+        arg = args[0]
+    else:
+        raise TypeError("subs/msubs takes one or two arguments (%d given)" % \
+                len(args))
+    if isinstance(arg, DictBasic):
+        return arg
+    cdef _DictBasic D = DictBasic()
+    for k, v in arg.items():
+        D.add(k, v)
+    return D
+
 
 cdef class Basic(object):
 
@@ -467,49 +488,23 @@ cdef class Basic(object):
         cdef Basic s = sympify(x)
         return c2py(symengine.diff(self.thisptr, s.thisptr))
 
-    def subs_dict(Basic self not None, subs_dict):
-        cdef _DictBasic D
-        if isinstance(subs_dict, DictBasic):
-          D = subs_dict
-          return c2py(symengine.ssubs(self.thisptr, D.c))
-        cdef symengine.map_basic_basic d
-        cdef Basic K, V
-        for k in subs_dict:
-            K = sympify(k)
-            V = sympify(subs_dict[k])
-            d[K.thisptr] = V.thisptr
-        return c2py(symengine.ssubs(self.thisptr, d))
+    def subs_dict(Basic self not None, *args):
+        warnings.warn("subs_dict() is deprecated. Use subs() instead", DeprecationWarning)
+        return self.subs(*args)
 
     def subs_oldnew(Basic self not None, old, new):
-        return self.subs_dict({old: new})
+        warnings.warn("subs_oldnew() is deprecated. Use subs() instead", DeprecationWarning)
+        return self.subs({old: new})
 
     def subs(Basic self not None, *args):
-        if len(args) == 1:
-            return self.subs_dict(args[0])
-        elif len(args) == 2:
-            return self.subs_oldnew(args[0], args[1])
-        else:
-            raise TypeError("subs() takes one or two arguments (%d given)" % \
-                    len(args))
+        cdef _DictBasic D = get_dict(*args)
+        return c2py(symengine.ssubs(self.thisptr, D.c))
 
     xreplace = subs
 
     def msubs(Basic self not None, *args):
-        if len(args) == 2:
-            arg = {args[0]: args[1]}
-        else:
-            arg = args[0]
-        cdef _DictBasic D
-        if isinstance(arg, DictBasic):
-          D = arg
-          return c2py(symengine.msubs(self.thisptr, D.c))
-        cdef symengine.map_basic_basic d
-        cdef Basic K, V
-        for k in arg:
-            K = sympify(k)
-            V = sympify(arg[k])
-            d[K.thisptr] = V.thisptr
-        return c2py(symengine.msubs(self.thisptr, d))
+        cdef _DictBasic D = get_dict(*args)
+        return c2py(symengine.msubs(self.thisptr, D.c))
 
     def n(self, prec = 53, real = False):
         if real:
@@ -1721,15 +1716,21 @@ cdef class DenseMatrix(MatrixBase):
         return self.transpose()
 
     def _applyfunc(self, f):
-        for i in range(self.nrows()):
-            for j in range(self.ncols()):
-                e_ = self._set(i, j, f(self._get(i, j)))
+        cdef int nr = self.nrows()
+        cdef int nc = self.ncols()
+        for i in range(nr):
+            for j in range(nc):
+                self._set(i, j, f(self._get(i, j)))
 
     def applyfunc(self, f):
-        out = DenseMatrix(self)
+        cdef DenseMatrix out = DenseMatrix(self)
         out._applyfunc(f)
         return out
 
+    def msubs(self, *args):
+        cdef _DictBasic D = get_dict(*args)
+        return self.applyfunc(lambda x: x.msubs(D))
+
     def diff(self, x):
         cdef Basic x_ = sympify(x)
         R = DenseMatrix(self.rows, self.cols)
@@ -1738,8 +1739,10 @@ cdef class DenseMatrix(MatrixBase):
         return R
 
     #TODO: implement this in C++
-    def subs(self, subs_dict):
-        return self.applyfunc(lambda y: y.subs(subs_dict))
+    def subs(self, *args):
+        cdef _DictBasic D = get_dict(*args)
+        return self.applyfunc(lambda x: x.subs(D))
+
 
     @property
     def free_symbols(self):