fix Times with infinite factors. I^q->(-1)^(q/2)

adding an option to mathics/test.py for storing errors in a log file. Fixing some tests. Fixing -Infinity.

adding an option to mathics/test.py for storing errors in a log file. Fixing some tests. Fixing -Infinity.

Author: mmatera

CHANGES.rst

@@ -26,7 +26,7 @@ Enhancements
   ``Compile[] and CompiledFunction[]``  every expression can have a compiled form,
   as a Python function.
 * ``Equal[]`` now compares complex against other numbers properly.
-
+* Improvements in handling products with infinite factors: ``0 Infinity``-> ``Indeterminate``, and ``expr Infinity``-> ``DirectedInfinite[expr]``
 
 Bug fixes
 +++++++++

mathics/builtin/arithmetic.py

@@ -46,6 +46,7 @@
 from mathics.builtin.lists import _IterationFunction
 from mathics.core.convert import from_sympy, SympyExpression
 
+
 @lru_cache(maxsize=1024)
 def call_mpmath(mpmath_function, mpmath_args):
     try:
@@ -687,15 +688,14 @@ def apply(self, items, evaluation):
                 )
             elif item.get_head().same(SymbolDirectedInfinity):
                 infinity_factor = True
-                direction = item.leaves[0]
-                if isinstance(direction, Number):
-                    numbers.append(direction)
-                else:
-                    leaves.append(direction)
-                item.leaves[0]
-            elif (item.same(SymbolInfinity) or item.same(SymbolComplexInfinity)):
+                if len(item.leaves)>1:
+                    direction = item.leaves[0]
+                    if isinstance(direction, Number):
+                        numbers.append(direction)
+                    else:
+                        leaves.append(direction)
+            elif item.same(SymbolInfinity) or item.same(SymbolComplexInfinity):
                 infinity_factor = True
-                item.leaves[0]                
             else:
                 leaves.append(item)
 
@@ -720,7 +720,7 @@ def apply(self, items, evaluation):
             number = None
         elif number.is_zero:
             if infinity_factor:
-                return Symbol('Indeterminate')
+                return Symbol("Indeterminate")
             return number
         elif number.same(Integer(-1)) and leaves and leaves[0].has_form("Plus", None):
             leaves[0] = Expression(
@@ -733,16 +733,14 @@ def apply(self, items, evaluation):
             leaf.clear_cache()
 
         if number is not None:
-            if infinity_factor:
-                number = Expression(SymbolDirectedInfinity,number/Expression("Abs",number))
             leaves.insert(0, number)
 
         if not leaves:
             if infinity_factor:
                 return SymbolInfinity
             return Integer(1)
-        
-        elif len(leaves) == 1:
+
+        if len(leaves) == 1:
             ret = leaves[0]
         else:
             ret = Expression("Times", *leaves)
@@ -855,7 +853,7 @@ class Power(BinaryOperator, _MPMathFunction):
 
     #> 1/0
      : Infinite expression 1 / 0 encountered.
-     = ComplexInfinity
+     = Infinity
     #> 0 ^ -2
      : Infinite expression 1 / 0 ^ 2 encountered.
      = ComplexInfinity
@@ -883,7 +881,7 @@ class Power(BinaryOperator, _MPMathFunction):
     #> (3/2+1/2I)^2
      = 2 + 3 I / 2
     #> I ^ I
-     = I ^ I
+     = -1 ^ (I / 2)
 
     #> 2 ^ 2.0
      = 4.
@@ -916,7 +914,6 @@ class Power(BinaryOperator, _MPMathFunction):
     }
 
     formats = {
-        
         Expression(
             "Power",
             Expression("Pattern", Symbol("x"), Expression("Blank")),
@@ -934,7 +931,7 @@ class Power(BinaryOperator, _MPMathFunction):
         ),
         ("", "x_?Negative ^ y_"): (
             'Infix[{HoldForm[(x)], HoldForm[y]},"^", 590, Right]'
-        ),        
+        ),
     }
 
     rules = {
@@ -963,8 +960,8 @@ def apply_check(self, x, y, evaluation):
                     return Symbol("ComplexInfinity")
         if isinstance(x, Complex) and x.real.is_zero:
             yhalf = Expression("Times", y, Rational(1, 2))
-            factor =  self.apply(Expression("Sequence", x.imag, y), evaluation)
-            return Expression("Times", factor , Expression("Power", Integer(-1), yhalf))
+            factor = self.apply(Expression("Sequence", x.imag, y), evaluation)
+            return Expression("Times", factor, Expression("Power", Integer(-1), yhalf))
 
         result = self.apply(Expression("Sequence", x, y), evaluation)
         if result is None or result != SymbolNull:
@@ -1083,6 +1080,10 @@ class DirectedInfinity(SympyFunction):
      : Indeterminate expression -Infinity + Infinity encountered.
      = Indeterminate
 
+    >> DirectedInfinity[0]
+     : Indeterminate expression 0 Infinity encountered.
+     = Indeterminate
+
     #> DirectedInfinity[1+I]+DirectedInfinity[2+I]
      = (2 / 5 + I / 5) Sqrt[5] Infinity + (1 / 2 + I / 2) Sqrt[2] Infinity
 
@@ -1091,15 +1092,16 @@ class DirectedInfinity(SympyFunction):
     """
 
     rules = {
+        "DirectedInfinity[Indeterminate]":"Indeterminate",
         "DirectedInfinity[args___] ^ -1": "0",
         "0 * DirectedInfinity[args___]": "Message[Infinity::indet, Unevaluated[0 DirectedInfinity[args]]]; Indeterminate",
         "DirectedInfinity[a_?NumericQ] /; N[Abs[a]] != 1": "DirectedInfinity[a / Abs[a]]",
         "DirectedInfinity[a_] * DirectedInfinity[b_]": "DirectedInfinity[a*b]",
         "DirectedInfinity[] * DirectedInfinity[args___]": "DirectedInfinity[]",
         "DirectedInfinity[0]": "DirectedInfinity[]",
-# Rules already implemented in Times.apply
-#        "z_?NumberQ * DirectedInfinity[]": "DirectedInfinity[]",
-#        "z_?NumberQ * DirectedInfinity[a_]": "DirectedInfinity[z * a]",
+        # Rules already implemented in Times.apply
+        #        "z_?NumberQ * DirectedInfinity[]": "DirectedInfinity[]",
+        #        "z_?NumberQ * DirectedInfinity[a_]": "DirectedInfinity[z * a]",
         "DirectedInfinity[a_] + DirectedInfinity[b_] /; b == -a": (
             "Message[Infinity::indet,"
             "  Unevaluated[DirectedInfinity[a] + DirectedInfinity[b]]];"
@@ -1111,12 +1113,23 @@ class DirectedInfinity(SympyFunction):
             "Indeterminate"
         ),
         "DirectedInfinity[args___] + _?NumberQ": "DirectedInfinity[args]",
+        "DirectedInfinity[0]": (
+            "Message[Infinity::indet,"
+            "  Unevaluated[DirectedInfinity[0]]];"
+            "Indeterminate"
+        ),
+        "DirectedInfinity[0.]": (
+            "Message[Infinity::indet,"
+            "  Unevaluated[DirectedInfinity[0.]]];"
+            "Indeterminate"
+        ),
     }
 
     formats = {
         "DirectedInfinity[1]": "HoldForm[Infinity]",
         "DirectedInfinity[-1]": "HoldForm[-Infinity]",
         "DirectedInfinity[]": "HoldForm[ComplexInfinity]",
+        "DirectedInfinity[DirectedInfinity[z_]]": "DirectedInfinity[z]",
         "DirectedInfinity[z_?NumericQ]": "HoldForm[z Infinity]",
     }
 
@@ -1304,19 +1317,12 @@ class Sign(SympyFunction):
     def apply(self, x, evaluation):
         "%(name)s[x_]"
         # Sympy and mpmath do not give the desired form of complex number
-        print(x)
         if isinstance(x, Complex):
             return Expression("Times", x, Expression("Power", Expression("Abs", x), -1))
 
         sympy_x = x.to_sympy()
         if sympy_x is None:
-            print(x, " does not have a sympy form")
-            if x.is_zero():
-                return Real(0)
-            return Expression("Times", x,
-                              Expression("Power",
-                                         Expression("Abs", x), -1)).evaluate(evaluation)
-        print(sympy_x)
+            return None
         return super().apply(x)
 
     def apply_error(self, x, seqs, evaluation):
@@ -1407,7 +1413,7 @@ def apply(self, expr, evaluation):
         sympy_expr = expr.to_sympy()
         result = _iszero(sympy_expr)
         if result is None:
-        # try expanding the expression
+            # try expanding the expression
             exprexp = Expression("ExpandAll", expr).evaluate(evaluation)
             exprexp = exprexp.to_sympy()
             result = _iszero(exprexp)

mathics/builtin/base.py

@@ -447,6 +447,7 @@ def get_sympy_names(self) -> typing.List[str]:
             return [self.sympy_name]
         return []
 
+
 class UnaryOperator(Operator):
     def __init__(self, format_function, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -534,7 +535,6 @@ def apply(self, expr, evaluation) -> Symbol:
 
 
 class SympyFunction(SympyObject):
-
     def apply(self, *args):
         """
         Generic apply method that uses the class sympy_name.
@@ -585,8 +585,6 @@ def prepare_mathics(self, sympy_expr):
         return sympy_expr
 
 
-
-
 class InvalidLevelspecError(Exception):
     pass
 

mathics/builtin/comparison.py

@@ -3,6 +3,7 @@
 
 from mathics.version import __version__  # noqa used in loading to check consistency.
 
+import itertools
 from typing import Optional, Union
 
 import sympy
@@ -217,7 +218,6 @@ class _EqualityOperator(_InequalityOperator):
     "Compares all pairs e.g. a == b == c compares a == b, b == c, and a == c."
 
     def do_compare(self, l1, l2) -> Union[bool, None]:
-        print("do_compare:", (l1,l2))
         if l1.same(l2):
             return True
         elif l1 == SymbolTrue and l2 == SymbolFalse:
@@ -275,13 +275,11 @@ def apply(self, items, evaluation):
         if n <= 1:
             return SymbolTrue
         is_exact_vals = [Expression("ExactNumberQ", arg).evaluate(evaluation) for arg in items_sequence]
-        if all(test is SymbolTrue for test in is_exact_vals):
+        if all(val == SymbolTrue for val in is_exact_vals):
             return self.apply_other(items, evaluation)
         args = self.numerify_args(items, evaluation)
         wanted = operators[self.get_name()]
-        pairs = zip(args[:-1],args[1:])
-        print("Compare.apply:", args)
-        for x, y in pairs:
+        for x, y in itertools.combinations(args, 2):
             if isinstance(x, String) or isinstance(y, String):
                 if not (isinstance(x, String) and isinstance(y, String)):
                     c = 1
@@ -299,9 +297,7 @@ def apply(self, items, evaluation):
     def apply_other(self, args, evaluation):
         "%(name)s[args___?(!ExactNumberQ[#]&)]"
         args = args.get_sequence()
-        pairs = zip(args[:-1],args[1:])
-        print("apply_other:", args)
-        for x, y in pairs:
+        for x, y in itertools.combinations(args, 2):
             c = self.do_compare(x, y)
             if c is None:
                 return

mathics/builtin/inout.py

@@ -1409,7 +1409,7 @@ class Check(Builtin):
 
     #> Check[1/0, err, Compile::cpbool]
      : Infinite expression 1 / 0 encountered.
-     = ComplexInfinity
+     = Infinity
 
     #> Check[{0^0, 1/0}, err]
      : Indeterminate expression 0 ^ 0 encountered.
@@ -1432,7 +1432,7 @@ class Check(Builtin):
 
     #> Off[Power::infy]
     #> Check[1 / 0, err]
-     = ComplexInfinity
+     = Infinity
 
     #> On[Power::infy]
     #> Check[1 / 0, err]
@@ -1627,7 +1627,7 @@ class Off(Builtin):
 
     >> Off[Power::infy]
     >> 1 / 0
-     = ComplexInfinity
+     = Infinity
 
     >> Off[Power::indet, Syntax::com]
     >> {0 ^ 0,}
@@ -1673,11 +1673,11 @@ class On(Builtin):
 
     >> Off[Power::infy]
     >> 1 / 0
-     = ComplexInfinity
+     = Infinity
     >> On[Power::infy]
     >> 1 / 0
      : Infinite expression 1 / 0 encountered.
-     = ComplexInfinity
+     = Infinity
     """
 
     # TODO

mathics/core/expression.py

@@ -2018,6 +2018,7 @@ def __getnewargs__(self):
 SymbolDirectedInfinity = Symbol("DirectedInfinity")
 SymbolList = Symbol("List")
 
+
 @lru_cache(maxsize=1024)
 def from_mpmath(value, prec=None):
     "Converts mpf or mpc to Number."

mathics/doc/documentation/1-Manual.mdoc

@@ -140,7 +140,7 @@ The precision of numerical evaluation can be set:
 Division by zero is forbidden:
 >> 1 / 0
  : Infinite expression 1 / 0 encountered.
- = ComplexInfinity
+ = Infinity
 Other expressions involving 'Infinity' are evaluated:
 >> Infinity + 2 Infinity
  = Infinity