23923: Interface cases function with SymPy's piecewise

Author: rwst

src/sage/functions/other.py

@@ -2674,5 +2674,25 @@ def _print_latex_(self, l, **kwargs):
             str += r"{%s} & {%s}\\" % (latex(left), latex(right))
         print(str[:-2] + r"\end{cases}")
 
+    def _sympy_(self, l):
+        """
+        Convert this cases expression to its SymPy equivalent.
+
+        EXAMPLES::
+
+            sage: ex = cases(((x<0, pi), (x==1, 1), (True, 0)))
+            sage: assert ex == ex._sympy()._sage_()
+        """
+        from sage.symbolic.ring import SR
+        from sympy import Piecewise as pw
+        args = []
+        for tup in l.operands():
+            cond,expr = tup.operands()
+            if SR(cond).is_numeric():
+                args.append((SR(expr)._sympy_(), bool(SR(cond)._sympy_())))
+            else:
+                args.append((SR(expr)._sympy_(), SR(cond)._sympy_()))
+        return pw(*args)
+
 cases = Function_cases()
 

src/sage/interfaces/sympy.py

@@ -425,6 +425,24 @@ def _sympysage_kronecker_delta(self):
     from sage.functions.generalized import kronecker_delta
     return kronecker_delta(self.args[0]._sage_(), self.args[1]._sage_())
 
+def _sympysage_piecewise(self):
+    """
+    EXAMPLES::
+
+        sage: from sympy import Symbol, pi as spi, Eq, Lt, Piecewise
+        sage: sx = Symbol('x')
+        sage: sp = Piecewise((spi, Lt(sx,0)), (1, Eq(sx,1)), (0, True))
+        sage: ex = cases(((x<0, pi), (x==1, 1), (True, 0)))
+        sage: assert ex._sympy_() == sp
+        sage: assert ex == sp._sage_()
+
+        sage: _ = var('y, z')
+        sage: (x^y - z).integrate(y, algorithm="sympy")
+        -y*z + cases(((log(x) == 0, y), (1, x^y/log(x))))
+    """
+    from sage.functions.other import cases
+    return cases([(p.cond._sage_(),p.expr._sage_()) for p in self.args])
+
 def _sympysage_besselj(self):
     """
     EXAMPLES::
@@ -550,6 +568,29 @@ def _sympysage_relational(self):
     ops = {Eq : eq, Ne : ne, Gt : gt, Lt : lt, Ge : ge, Le : le}
     return ops.get(self.func)(self.lhs._sage_(), self.rhs._sage_())
 
+def _sympysage_false(self):
+    """
+    EXAMPLES::
+
+        sage: from sympy.logic.boolalg import BooleanFalse
+        sage: assert SR(False)._sympy_() == BooleanFalse()      # known bug
+        sage: assert SR(False) == BooleanFalse()._sage_()
+    """
+    from sage.symbolic.ring import SR
+    return SR(False)
+
+def _sympysage_true(self):
+    """
+    EXAMPLES::
+
+        sage: from sympy.logic.boolalg import BooleanTrue
+        sage: assert SR(True)._sympy_() == BooleanTrue()      # known bug
+        sage: assert SR(True) == BooleanTrue()._sage_()
+    """
+    from sage.symbolic.ring import SR
+    return SR(True)
+
+
 #------------------------------------------------------------------
 from sage.repl.ipython_extension import run_once
 
@@ -594,6 +635,7 @@ def sympy_init():
     from sympy.functions.special.hyper import hyper
     from sympy.functions.special.spherical_harmonics import Ynm
     from sympy.functions.special.tensor_functions import KroneckerDelta
+    from sympy.logic.boolalg import BooleanTrue, BooleanFalse
     from sympy.integrals.integrals import Integral
     from sympy.series.order import Order
 
@@ -627,6 +669,7 @@ def sympy_init():
     hyper._sage_ = _sympysage_hyp
     elliptic_k._sage_ = _sympysage_elliptic_k
     KroneckerDelta._sage_ = _sympysage_kronecker_delta
+    Piecewise._sage_ = _sympysage_piecewise
     besselj._sage_ = _sympysage_besselj
     bessely._sage_ = _sympysage_bessely
     besseli._sage_ = _sympysage_besseli
@@ -635,6 +678,8 @@ def sympy_init():
     re._sage_ = _sympysage_re
     im._sage_ = _sympysage_im
     Abs._sage_ = _sympysage_abs
+    BooleanFalse._sage_ = _sympysage_false
+    BooleanTrue._sage_ = _sympysage_true
 
 def check_expression(expr, var_symbols, only_from_sympy=False):
     """

src/sage/symbolic/expression_conversions.py

@@ -781,8 +781,12 @@ def composition(self, ex, operator):
             sage: s.composition(f, f.operator())
             asin(2)
         """
-        f = operator._sympy_init_()
         g = ex.operands()
+        try:
+            return operator._sympy_(*g)
+        except (AttributeError, TypeError):
+            pass
+        f = operator._sympy_init_()
         import sympy
 
         f_sympy = getattr(sympy, f, None)