symengine_wrapper.pyx: Calculate the zero-th derivative

This is useful for more general, albeit sometimes inefficient, summation
code. Just copying some taylor expansion code from the internet worked
with sympy but not symengine due to the following error:

Traceback (most recent call last):
  File "example.py", line 32, in <module>
    taylor(symengine.sympify('1/(1-x-x^2)'), 0, 15)
  File "example.py", line 27, in taylor
    p = p + (function.diff(x, i).subs(x, x0))/(factorial(i))*(x - x0)**i
  File "symengine_wrapper.pyx", line 923, in symengine.lib.symengine_wrapper.Basic.diff
  File "symengine_wrapper.pyx", line 4020, in symengine.lib.symengine_wrapper.diff
OverflowError: can't convert negative value to size_t

There are a number of inconsistencies compared to the regular sympy library:

1. Takes no argument:

   >>> symengine.sympify('x**2').diff()
   2*x

   This actually seems helpful, except when you have #2 misleading you.

   This is not accepted in sympy, but doesn't necessarily need a fix.

2. Takes a standalone integer argument and returns a nonsense answer:

   >>> symengine.sympify('x**2').diff(1)
   x**2

   This is simply not accepted in the regular sympy library.

3. Takes multiple integer arguments and aggregates:

    diff(x, 1, 1) == diff(x, 2)

   This does not occur with the sympy library, and does not seem useful.
   It can easily be replaced with diff(x, x), if repetition was necessary.

4. Takes only integer arguments > 1:

   diff(x, 0) returns integer overflow

   This is accepted in sympy.

In this patch, 2-4 are all fixed. #1 seems like a potentially useful (and
likely used) feature.

Signed-off-by: Garming Sam <[email protected]>

Author: GSam

symengine/lib/symengine_wrapper.pyx

@@ -4056,18 +4056,55 @@ atexit.register(module_cleanup)
 
 def diff(ex, *args):
     ex = sympify(ex)
-    prev = 0
+    prev = None
     cdef Basic b
     cdef size_t i
-    for x in args:
+    length = len(args)
+
+    if not length:
+        return ex
+
+    l = 0
+    x = args[l]
+    b = sympify(x)
+    l += 1
+
+    while l <= length:
+        # Assume symbol 'x' or 'y' currently in b
+        # Pointer to next arg l is either derivative order or a separate symbol
+
+        prev = b
+
+        if l == length:
+            # No next argument, differentiate with no integer argument
+            if isinstance(b, Integer):
+                raise ValueError("Unexpected integer argument")
+            ex = ex._diff(b)
+            break
+
+        x = args[l]
         b = sympify(x)
+        # Check if the next arg was derivative order
         if isinstance(b, Integer):
-            i = int(b) - 1
+            i = int(b)
             for j in range(i):
                 ex = ex._diff(prev)
+
+            # Move forward to point at next symbol
+            l += 1
+            if l == length:
+                break
+
+            x = args[l]
+            b = sympify(x)
+            if isinstance(b, Integer):
+                raise ValueError("Unexpected double integer argument")
         else:
-            ex = ex._diff(b)
-        prev = b
+            # Separate symbol and no derivative order, differentiate now
+            ex = ex._diff(prev)
+
+        l += 1
+
     return ex
 
 def expand(x, deep=True):