Ticket #1189: sympy2.patch

sage/calculus/calculus.py

@@ -363 +363 @@
             sage: x.subs(x=y0/y1)
             y0/y1
         """
+        import sympy
         if isinstance(x, CallableSymbolicExpression):
             return x._expr
         elif isinstance(x, SymbolicExpression):
             return x
         elif isinstance(x, MaximaElement):
             return symbolic_expression_from_maxima_element(x)
+        elif isinstance(x, sympy.Basic):
+        #elif hasattr(x, "_sage_"):
+            # if "x" implements the _sage_() method, let's use it to convert
+            # the expression to a SAGE expression (for example SymPy provides
+            # _sage_() methods, some other libraries can too)
+            #
+            # unfortunately, the hasattr() above doesn't work (infinite
+            # recursion), so we check for SymPy directly.
+
+            return self(x._sage_())
         elif is_Polynomial(x) or is_MPolynomial(x):
             if x.base_ring() != self:  # would want coercion to go the other way
                 return SymbolicPolynomial(x)
@@ -3271 +3282 @@
                              infixops[self._operator],
                              ops[1]._maxima_init_())
 
+    def _sympy_(self):
+        """Converts any expression to SymPy."""
+
+        # Current implementation is fragile - it first converts the expression
+        # to string, then preparses it, then gets rid of "Integer" and then
+        # sympifies this string.
+
+        # In order to make this robust, one would have to implement _sympy_
+        # recursively in all expressions. But we want something now, instead of
+        # tomorrow, so the following one-liner does the job for now.
+        # Also all ugly things are concentrated in this line, everything else
+        # (sympy.sympify, sage.all.SR, ...) is clean and robust.
+        import sympy
+        from sage.all import preparse
+        s = sympy.sympify(preparse(repr(self)).replace("Integer",""))
+        return s
+
     def _sys_init_(self, system):
         ops = self._operands
         if self._operator is operator.neg:

sage/calculus/test_sympy.py

@@ -123 +123 @@
 sage: f._sage_()
 8651*x^8/13440 + 241*x^6/240 + 11*x^4/8 + 3*x^2/2 + 1
 
+
+
+Mixing SymPy with SAGE:
+sage: import sympy
+sage: sympy.sympify(var("y"))+sympy.Symbol("x")
+x + y
+sage: o = var("omega")
+sage: s = sympy.Symbol("x")
+sage: t1 = s + o
+sage: t2 = o + s
+sage: print type(t1)
+<class 'sympy.core.add.Add'>
+sage: print type(t2)
+<class 'sage.calculus.calculus.SymbolicArithmetic'>
+sage: print t1, t2
+omega + x                                    x + omega
+sage: e=sympy.sin(var("y"))+sage.all.cos(Symbol("x"))
+sage: print type(e)
+<class 'sympy.core.add.Add'>
+sage: print e
+cos(x) + sin(y)
+sage: e=e._sage_()
+sage: print type(e)
+<class 'sage.calculus.calculus.SymbolicArithmetic'>
+sage: print e
+                                sin(y) + cos(x)
+sage: e = sage.all.cos(var("y")**3)**4+var("x")**2
+sage: e = e._sympy_()
+sage: print e
+    x**2 + cos(y**3)**4
 """

sage/structure/coerce.pyx

@@ -327 +327 @@
                 return x, y            
             return _verify_canonical_coercion_c(x,y)
             
+        if PY_TYPE_CHECK(xp, type) or PY_TYPE_CHECK(yp, type):
+            if hasattr(x, "_sage_") and hasattr(y, "_sage_"):
+                x = x._sage_()
+                y = y._sage_()
+                try:
+                    return _verify_canonical_coercion_c(x,y)
+                except RuntimeError:
+                    # well, the coercion failed or there is some other error,
+                    # and we should leave it as is (errors should never pass
+                    # silently, unless explicitly silenced), but SAGE needs to
+                    # return a TypeError, raised below, so we silence it...
+                    pass
+
         raise TypeError, "no common canonical parent for objects with parents: '%s' and '%s'"%(xp, yp)