Changeset 7571:d691d0e61066

Timestamp:

11/13/07 07:06:23 (6 years ago)

Author:

Ondrej Certik <ondrej@…>

Branch:

default

Message:

SymPy? and SAGE objects can now be mixed

Location:

sage

Files:

• calculus/calculus.py (modified) (3 diffs)
• calculus/test_sympy.py (modified) (1 diff)
• structure/coerce.pyx (modified) (1 diff)

sage/calculus/calculus.py

@@ -271 +271 @@
 import sage.functions.functions
 
+#needed for converting from SymPy to SAGE
+import sympy
+
 is_simplified = False
 
@@ -378 +381 @@
         elif isinstance(x, MaximaElement):
             return symbolic_expression_from_maxima_element(x)
+        # if "x" is a SymPy object, convert it to a SAGE object
+        elif isinstance(x, sympy.Basic):
+            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
@@ -3845 +3851 @@
                              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):

sage/calculus/test_sympy.py

@@ -124 +124 @@
 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

@@ -328 +328 @@
             return _verify_canonical_coercion_c(x,y)
             
+        try:
+            if PY_TYPE_CHECK(xp, type) or PY_TYPE_CHECK(yp, type):
+                x = x._sage_()
+                y = y._sage_()
+                return self.canonical_coercion_c(x, y)
+        except AttributeError:
+            pass
+
         raise TypeError, "no common canonical parent for objects with parents: '%s' and '%s'"%(xp, yp)