Even more error checking DRYness (#1468)

DRY error checking in `Round[]` and `Sign[]`.

Author: rocky

mathics/builtin/numeric.py

@@ -19,6 +19,7 @@
     Complex,
     Integer,
     Integer0,
+    Integer1,
     IntegerM1,
     Number,
     Rational,
@@ -41,6 +42,7 @@
     SymbolDivide,
     SymbolFalse,
     SymbolMachinePrecision,
+    SymbolPlus,
     SymbolTimes,
     SymbolTrue,
 )
@@ -707,17 +709,31 @@ class Round(Builtin):
 
     attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
 
+    # Set checking that the number of arguments required is one or two.
+    eval_error = Builtin.generic_argument_error
+    expected_args = (1, 2)
+
+    # For now, we handle Rounding Complex numnbers as rules.
+    # In the future consider folding this into the code.
     rules = {
-        "Round[expr_?NumericQ]": "Round[Re[expr], 1] + I * Round[Im[expr], 1]",
+        "Round[expr_Complex]": "Round[Re[expr], 1] + I * Round[Im[expr], 1]",
         "Round[expr_Complex, k_?RealValuedNumberQ]": (
             "Round[Re[expr], k] + I * Round[Im[expr], k]"
         ),
     }
 
     summary_text = "find closest integer or multiple of"
 
-    def eval(self, expr, k, evaluation: Evaluation):
-        "Round[expr_?NumericQ, k_?NumericQ]"
+    def eval_one_arg(self, expr, evaluation: Evaluation):
+        "Round[expr_]"
+        return self.eval_two_args(expr, Integer1, evaluation)
+
+    def eval_two_args(self, expr, k, evaluation: Evaluation):
+        "Round[expr_, k_]"
+
+        if not expr.is_numeric(evaluation):
+            # We can't evaluate, so keep the symbolic representation.
+            return
 
         n = Expression(SymbolDivide, expr, k).round_to_float(
             evaluation, permit_complex=True
@@ -760,20 +776,20 @@ class Sign(SympyFunction):
 
     """
 
-    summary_text = "complex sign of a number"
-    sympy_name = "sign"
-    # mpmath_name = 'sign'
-
     attributes = A_LISTABLE | A_NUMERIC_FUNCTION | A_PROTECTED
 
-    messages = {
-        "argx": "Sign called with `1` arguments; 1 argument is expected.",
-    }
+    # Set checking that the number of arguments required is one.
+    eval_error = Builtin.generic_argument_error
+    expected_args = 1
 
     rules = {
         "Sign[Power[a_, b_]]": "Power[Sign[a], b]",
     }
 
+    summary_text = "complex sign of a number"
+    sympy_name = "sign"
+    # mpmath_name = 'sign'
+
     def eval(self, x, evaluation: Evaluation):
         "Sign[x_]"
         result = eval_Sign(x)
@@ -787,10 +803,6 @@ def eval(self, x, evaluation: Evaluation):
         # Unhandled cases. Use sympy
         return super(Sign, self).eval(x, evaluation)
 
-    def eval_error(self, x, seqs, evaluation: Evaluation):
-        "Sign[x_, seqs__]"
-        evaluation.message("Sign", "argx", Integer(len(seqs.get_sequence()) + 1))
-
 
 class UnitStep(Builtin):
     """

mathics/builtin/specialfns/elliptic.py

@@ -53,7 +53,7 @@ class EllipticE(SympyFunction):
 
     attributes = A_NUMERIC_FUNCTION | A_PROTECTED
 
-    # Set checking that the number of arguments required is two or three.
+    # Set checking that the number of arguments required is one or two.
     eval_error = Builtin.generic_argument_error
     expected_args = (1, 2)
 

mathics/core/builtin.py

@@ -439,12 +439,12 @@ def contextify_form_name(f):
             makeboxes_def.add_rule(rule)
 
     # This method is used to produce generic argument mismatch errors
-    # (tags: argx, argr, argrx, argt, argtu) for builtin functions that define this
-    # as an eval method. e.g.  For example for Sqrt[a, b] (one
-    # argument expected) or Subtract[a] (two arguments expected) It
-    # assumes each builtin defines "expected_args" for the correct
-    # number of arguments to give.  See class
-    # mathics.builtins.basic.Sqrt for how to set up.
+    # (tags: "argx", "argr", "argrx", "argt", or "argtu") for builtin
+    # functions that define this as an eval method. e.g.  For example
+    # for Sqrt[a, b] (one argument expected) or Subtract[a] (two
+    # arguments expected) It assumes each builtin defines
+    # "expected_args" for the correct number of arguments to give.
+    # See class mathics.builtins.basic.Sqrt for how to set up.
     def generic_argument_error(self, invalid, evaluation: Evaluation):
         "%(name)s[invalid___]"
 

test/builtin/test_numeric.py

@@ -118,12 +118,6 @@ def test_realvalued():
             None,
         ),
         ("Sign[1 - 4*I] == (1/17 - 4 I/17) Sqrt[17]", None, "True", None),
-        (
-            "Sign[4, 5, 6]",
-            ("Sign called with 3 arguments; 1 argument is expected.",),
-            "Sign[4, 5, 6]",
-            None,
-        ),
         ('Sign["20"]', None, "Sign[20]", None),
     ],
 )
@@ -138,3 +132,46 @@ def test_private_doctests_numeric(str_expr, msgs, str_expected, fail_msg):
         failure_message=fail_msg,
         expected_messages=msgs,
     )
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "assert_fail_msg"),
+    [
+        (
+            "Round[a, b]",
+            None,
+            "Round with one symbolic argument should not give an error message",
+        ),
+        (
+            "Round[a, b]",
+            None,
+            "Round with two symbolic arguments should not give an error message",
+        ),
+        (
+            "Round[a, b, c]",
+            ("Round called with 3 arguments; 1 or 2 arguments are expected.",),
+            "Round wrong number of arguments",
+        ),
+        (
+            "Sign[x]",
+            None,
+            "Sign with one symbolic argument should not give an error message",
+        ),
+        (
+            "Sign[4, 5, 6]",
+            ("Sign called with 3 arguments; 1 argument is expected.",),
+            "Sign wrong number of arguments",
+        ),
+    ],
+)
+def test_wrong_number_of_arguments(str_expr, msgs, assert_fail_msg):
+    """ """
+    check_evaluation(
+        str_expr,
+        str_expr,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=assert_fail_msg,
+        expected_messages=msgs,
+    )