merge

Author: mmatera

mathics/builtin/algebra.py

@@ -10,6 +10,7 @@
     Atom,
     Expression,
     Integer,
+    Integer1,
     Number,
     Symbol,
     SymbolFalse,
@@ -497,17 +498,17 @@ class FactorTermsList(Builtin):
     def apply_list(self, expr, vars, evaluation):
         "FactorTermsList[expr_, vars_List]"
         if expr == Integer(0):
-            return Expression("List", Integer(1), Integer(0))
+            return Expression("List", Integer1, Integer(0))
         elif isinstance(expr, Number):
-            return Expression("List", expr, Integer(1))
+            return Expression("List", expr, Integer1)
 
         for x in vars.leaves:
             if not (isinstance(x, Atom)):
                 return evaluation.message("CoefficientList", "ivar", x)
 
         sympy_expr = expr.to_sympy()
         if sympy_expr is None:
-            return Expression("List", Integer(1), expr)
+            return Expression("List", Integer1, expr)
         sympy_expr = sympy.together(sympy_expr)
 
         sympy_vars = [
@@ -1160,7 +1161,7 @@ def apply_noform(self, expr, evaluation):
 
     def apply(self, expr, form, evaluation):
         "Coefficient[expr_, form_]"
-        return _coefficient(self.__class__.__name__, expr, form, Integer(1), evaluation)
+        return _coefficient(self.__class__.__name__, expr, form, Integer1, evaluation)
 
     def apply_n(self, expr, form, n, evaluation):
         "Coefficient[expr_, form_, n_]"
@@ -1401,7 +1402,7 @@ class Exponent(Builtin):
 
     def apply_novar(self, expr, evaluation):
         "Exponent[expr_]"
-        return evaluation.message("Exponent", "argtu", Integer(1))
+        return evaluation.message("Exponent", "argtu", Integer1)
 
     def apply(self, expr, form, h, evaluation):
         "Exponent[expr_, form_, h_]"

mathics/builtin/arithmetic.py

@@ -26,19 +26,21 @@
     Complex,
     Expression,
     Integer,
+    Integer1,
     Number,
     Rational,
     Real,
     String,
     Symbol,
     SymbolComplexInfinity,
     SymbolDirectedInfinity,
-    SymbolFalse,
     SymbolInfinity,
     SymbolN,
     SymbolNull,
     SymbolSequence,
     SymbolTrue,
+    SymbolFalse,
+    SymbolUndefined,
     from_mpmath,
     from_python,
 )
@@ -112,7 +114,7 @@ def apply(self, z, evaluation):
                 if mpmath.isinf(result) and isinstance(result, mpmath.mpc):
                     result = Symbol("ComplexInfinity")
                 elif mpmath.isinf(result) and result > 0:
-                    result = Expression("DirectedInfinity", Integer(1))
+                    result = Expression("DirectedInfinity", Integer1)
                 elif mpmath.isinf(result) and result < 0:
                     result = Expression("DirectedInfinity", Integer(-1))
                 elif mpmath.isnan(result):
@@ -260,7 +262,7 @@ def negate(item):
             if item.has_form("Times", 1, None):
                 if isinstance(item.leaves[0], Number):
                     neg = -item.leaves[0]
-                    if neg.sameQ(Integer(1)):
+                    if neg.sameQ(Integer1):
                         if len(item.leaves) == 1:
                             return neg
                         else:
@@ -583,7 +585,7 @@ def inverse(item):
                 item.leaves[1], (Integer, Rational, Real)
             ):
                 neg = -item.leaves[1]
-                if neg.sameQ(Integer(1)):
+                if neg.sameQ(Integer1):
                     return item.leaves[0]
                 else:
                     return Expression("Power", item.leaves[0], neg)
@@ -603,7 +605,7 @@ def inverse(item):
                 negative.append(inverse(item))
             elif isinstance(item, Rational):
                 numerator = item.numerator()
-                if not numerator.sameQ(Integer(1)):
+                if not numerator.sameQ(Integer1):
                     positive.append(numerator)
                 negative.append(item.denominator())
             else:
@@ -618,7 +620,7 @@ def inverse(item):
         if positive:
             positive = create_infix(positive, op, 400, "None")
         else:
-            positive = Integer(1)
+            positive = Integer1
         if negative:
             negative = create_infix(negative, op, 400, "None")
             result = Expression(
@@ -675,18 +677,20 @@ def apply(self, items, evaluation):
                     Expression("Plus", item.leaves[1], leaves[-1].leaves[1]),
                 )
             elif (
-                leaves and item.has_form("Power", 2) and item.leaves[0].sameQ(leaves[-1])
+                leaves
+                and item.has_form("Power", 2)
+                and item.leaves[0].sameQ(leaves[-1])
             ):
                 leaves[-1] = Expression(
-                    "Power", leaves[-1], Expression("Plus", item.leaves[1], Integer(1))
+                    "Power", leaves[-1], Expression("Plus", item.leaves[1], Integer1)
                 )
             elif (
                 leaves
                 and leaves[-1].has_form("Power", 2)
                 and leaves[-1].leaves[0].sameQ(item)
             ):
                 leaves[-1] = Expression(
-                    "Power", item, Expression("Plus", Integer(1), leaves[-1].leaves[1])
+                    "Power", item, Expression("Plus", Integer1, leaves[-1].leaves[1])
                 )
             elif item.get_head().sameQ(SymbolDirectedInfinity):
                 infinity_factor = True
@@ -716,9 +720,9 @@ def apply(self, items, evaluation):
                 number = sympy.Mul(*[item.to_sympy() for item in numbers])
                 number = from_sympy(number)
         else:
-            number = Integer(1)
+            number = Integer1
 
-        if number.sameQ(Integer(1)):
+        if number.sameQ(Integer1):
             number = None
         elif number.is_zero:
             if infinity_factor:
@@ -740,7 +744,7 @@ def apply(self, items, evaluation):
         if not leaves:
             if infinity_factor:
                 return SymbolComplexInfinity
-            return Integer(1)
+            return Integer1
 
         if len(leaves) == 1:
             ret = leaves[0]
@@ -1351,7 +1355,7 @@ class I(Predefined):
     python_equivalent = 1j
 
     def evaluate(self, evaluation):
-        return Complex(Integer(0), Integer(1))
+        return Complex(Integer(0), Integer1)
 
 
 class NumberQ(Test):
@@ -2210,7 +2214,110 @@ def apply(self, expr, evaluation):
         "%(name)s[expr_]"
         if isinstance(expr, Symbol):
             if expr == SymbolTrue:
-                return Integer(1)
+                return Integer1
             elif expr == SymbolFalse:
                 return Integer(0)
         return None
+
+
+class Assumptions(Predefined):
+    """
+    <dl>
+    <dt>'$Assumptions'
+      <dd>is the default setting for the Assumptions option used in such
+   functions as Simplify, Refine, and Integrate.
+    </dl>
+    """
+
+    name = "$Assumptions"
+    attributes = ("Unprotected",)
+    rules = {
+        "$Assumptions": "True",
+    }
+
+
+class Assuming(Builtin):
+    """
+    <dl>
+    <dt>'Assuming[$cond$, $expr$]'
+      <dd>Evaluates $expr$ assuming the conditions $cond$
+    </dl>
+    >> $Assumptions = { x > 0 }
+     = {x > 0}
+    >> Assuming[y>0, $Assumptions]
+     = {x > 0, y > 0}
+    """
+
+    attributes = ("HoldRest",)
+
+    def apply_assuming(self, cond, expr, evaluation):
+        "Assuming[cond_, expr_]"
+        cond = cond.evaluate(evaluation)
+        if cond.is_true():
+            cond = []
+        elif cond.is_symbol() or not cond.has_form("List", None):
+            cond = [cond]
+        else:
+            cond = cond.leaves
+        assumptions = evaluation.definitions.get_definition(
+            "System`$Assumptions", only_if_exists=True
+        )
+
+        if assumptions:
+            assumptions = assumptions.ownvalues
+            if len(assumptions) > 0:
+                assumptions = assumptions[0].replace
+            else:
+                assumptions = None
+        if assumptions:
+            if assumptions.is_symbol() or not assumptions.has_form("List", None):
+                assumptions = [assumptions]
+            else:
+                assumptions = assumptions.leaves
+            cond = assumptions + tuple(cond)
+        Expression(
+            "Set", Symbol("System`$Assumptions"), Expression("List", *cond)
+        ).evaluate(evaluation)
+        ret = expr.evaluate(evaluation)
+        if assumptions:
+            Expression(
+                "Set", Symbol("System`$Assumptions"), Expression("List", *assumptions)
+            ).evaluate(evaluation)
+        else:
+            Expression(
+                "Set", Symbol("System`$Assumptions"), Expression("List", SymbolTrue)
+            ).evaluate(evaluation)
+        return ret
+
+
+class ConditionalExpression(Builtin):
+    """
+    <dl>
+    <dt>'ConditionalExpression[$expr$, $cond$]'
+      <dd>returns $expr$ if $cond$ evaluates to $True$, $Undefined$ if
+          $cond$ evaluates to $False$.
+    </dl>
+
+    >> f = ConditionalExpression[x^2, x>0]
+     = ConditionalExpression[x ^ 2, x > 0]
+    >> f /. x -> 2
+     = 4
+    >> f /. x -> -2
+     = Undefined
+    """
+
+    rules = {
+        "ConditionalExpression[expr_, True]": "expr",
+        "ConditionalExpression[expr_, False]": "Undefined",
+    }
+
+    def apply_generic(self, expr, cond, evaluation):
+        "ConditionalExpression[expr_, cond_]"
+        cond = cond.evaluate(evaluation)
+        if cond is None:
+            return
+        if cond.is_true():
+            return expr
+        if cond == SymbolFalse:
+            return SymbolUndefined
+        return