doctests -> pytest for layout and optimization

fix maximize/minimize

Author: mmatera

mathics/builtin/layout.py

@@ -177,12 +177,6 @@ class Infix(Builtin):
 
     >> Infix[{a, b, c}, {"+", "-"}]
      = a + b - c
-
-    #> Format[r[items___]] := Infix[If[Length[{items}] > 1, {items}, {ab}], "~"]
-    #> r[1, 2, 3]
-     = 1 ~ 2 ~ 3
-    #> r[1]
-     = ab
     """
 
     messages = {

mathics/builtin/optimization.py

@@ -46,12 +46,6 @@ class Maximize(Builtin):
 
     >> Maximize[-2 x^2 - 3 x + 5, x]
      = {{49 / 8, {x -> -3 / 4}}}
-
-    #>> Maximize[1 - (x y - 3)^2, {x, y}]
-     = {{1, {x -> 3, y -> 1}}}
-
-    #>> Maximize[{x - 2 y, x^2 + y^2 <= 1}, {x, y}]
-     = {{Sqrt[5], {x -> Sqrt[5] / 5, y -> -2 Sqrt[5] / 5}}}
     """
 
     attributes = A_PROTECTED | A_READ_PROTECTED
@@ -79,11 +73,12 @@ def eval_constraints(self, f, vars, evaluation: Evaluation):
         "Maximize[f_List, vars_]"
 
         constraints = [function for function in f.elements]
-        constraints[0] = from_sympy(constraints[0].to_sympy() * IntegerM1)
-
-        dual_solutions = (
-            Expression(SymbolMinimize, constraints, vars).evaluate(evaluation).elements
+        constraints[0] = from_sympy(-(constraints[0].to_sympy()))
+        constraints = ListExpression(*constraints)
+        minimize_expr = Expression(SymbolMinimize, constraints, vars).evaluate(
+            evaluation
         )
+        dual_solutions = minimize_expr.evaluate(evaluation).elements
 
         solutions = []
         for dual_solution in dual_solutions:
@@ -107,20 +102,13 @@ class Minimize(Builtin):
 
     >> Minimize[2 x^2 - 3 x + 5, x]
      = {{31 / 8, {x -> 3 / 4}}}
-
-    #>> Minimize[(x y - 3)^2 + 1, {x, y}]
-     = {{1, {x -> 3, y -> 1}}}
-
-    #>> Minimize[{x - 2 y, x^2 + y^2 <= 1}, {x, y}]
-     = {{-Sqrt[5], {x -> -Sqrt[5] / 5, y -> 2 Sqrt[5] / 5}}}
     """
 
     attributes = A_PROTECTED | A_READ_PROTECTED
     summary_text = "compute the minimum of a function"
 
     def eval_onevariable(self, f, x, evaluation: Evaluation):
         "Minimize[f_?NotListQ, x_?NotListQ]"
-
         sympy_x = x.to_sympy()
         sympy_f = f.to_sympy()
 
@@ -129,7 +117,6 @@ def eval_onevariable(self, f, x, evaluation: Evaluation):
         candidates = sympy.solve(derivative, sympy_x, real=True, dict=True)
 
         minimum_list = []
-
         for candidate in candidates:
             value = second_derivative.subs(candidate)
             if value.is_real and value > 0:
@@ -190,7 +177,6 @@ def eval_multiplevariable(self, f, vars, evaluation: Evaluation):
             candidates.append(candidate)
 
         minimum_list = []
-
         for candidate in candidates:
             eigenvals = hessian.subs(candidate).eigenvals()
 
@@ -214,14 +200,16 @@ def eval_multiplevariable(self, f, vars, evaluation: Evaluation):
             *(
                 ListExpression(
                     from_sympy(sympy_f.subs(minimum).simplify()),
-                    [
-                        Expression(
-                            SymbolRule,
-                            from_sympy(list(minimum.keys())[i]),
-                            from_sympy(list(minimum.values())[i]),
+                    ListExpression(
+                        *(
+                            Expression(
+                                SymbolRule,
+                                from_sympy(list(minimum.keys())[i]),
+                                from_sympy(list(minimum.values())[i]),
+                            )
+                            for i in range(len(vars_sympy))
                         )
-                        for i in range(len(vars_sympy))
-                    ],
+                    ),
                 )
                 for minimum in minimum_list
             )
@@ -407,14 +395,16 @@ def eval_constraints(self, f, vars, evaluation: Evaluation):
             *(
                 ListExpression(
                     from_sympy(objective_function.subs(minimum).simplify()),
-                    [
-                        Expression(
-                            SymbolRule,
-                            from_sympy(list(minimum.keys())[i]),
-                            from_sympy(list(minimum.values())[i]),
+                    ListExpression(
+                        *(
+                            Expression(
+                                SymbolRule,
+                                from_sympy(list(minimum.keys())[i]),
+                                from_sympy(list(minimum.values())[i]),
+                            )
+                            for i in range(len(vars_sympy))
                         )
-                        for i in range(len(vars_sympy))
-                    ],
+                    ),
                 )
                 for minimum in minimum_list
             )

test/builtin/numbers/test_calculus.py

@@ -193,3 +193,36 @@ def test_Solve(str_expr: str, str_expected: str, expected_messages):
         str_expected=str_expected,
         expected_messages=expected_messages,
     )
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    [
+        (None, None, None, None),
+        ("Maximize[1 - (x y - 3)^2, {x, y}]", None, "{{1, {x -> 3, y -> 1}}}", None),
+        (
+            "Maximize[{x - 2 y, x^2 + y^2 <= 1}, {x, y}]",
+            None,
+            "{{Sqrt[5], {x -> Sqrt[5] / 5, y -> -2 Sqrt[5] / 5}}}",
+            None,
+        ),
+        ("Minimize[(x y - 3)^2 + 1, {x, y}]", None, "{{1, {x -> 3, y -> 1}}}", None),
+        (
+            "Minimize[{x - 2 y, x^2 + y^2 <= 1}, {x, y}]",
+            None,
+            "{{-Sqrt[5], {x -> -Sqrt[5] / 5, y -> 2 Sqrt[5] / 5}}}",
+            None,
+        ),
+    ],
+)
+def test_private_doctests_optimization(str_expr, msgs, str_expected, fail_msg):
+    """ """
+    check_evaluation(
+        str_expr,
+        str_expected,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=fail_msg,
+        expected_messages=msgs,
+    )

test/builtin/test_strings.py

@@ -530,7 +530,6 @@ def test_private_doctests_patterns(str_expr, msgs, str_expected, fail_msg):
             "FromCharacterCode[{{97, 98, x}, {100, 101, x}}]",
             None,
         ),
-        
         # These tests are commented out due to the bug reported in issue #906
         # Octal and hexadecimal notation works alone, but fails
         # as a part of another expression. For example,
@@ -561,14 +560,20 @@ def test_private_doctests_characters(str_expr, msgs, str_expected, fail_msg):
         expected_messages=msgs,
     )
 
+
 # These tests are separated due to the bug reported in issue #906
 
+
 @pytest.mark.parametrize(
     ("str_expr", "str_expected", "fail_msg"),
     [
         (r"\.78\.79\.7A", "xyz", "variable name using hexadecimal characters"),
         (r"\:0078\:0079\:007A", "xyz", "variable name using hexadecimal characters"),
-        (r"\101\102\103\061\062\063", "ABC123", "variable name using hexadecimal characters"),
+        (
+            r"\101\102\103\061\062\063",
+            "ABC123",
+            "variable name using hexadecimal characters",
+        ),
     ],
 )
 def test_private_doctests_characters(str_expr, str_expected, fail_msg):

test/format/test_format.py

@@ -977,3 +977,32 @@ def test_format_private_doctests(str_expr, str_expected, msg):
         hold_expected=True,
         failure_message=msg,
     )
+
+
+@pytest.mark.parametrize(
+    ("str_expr", "msgs", "str_expected", "fail_msg"),
+    [
+        (
+            (
+                'Format[r[items___]] := Infix[If[Length[{items}] > 1, {items}, {ab}], "~"];'
+                "r[1, 2, 3]"
+            ),
+            None,
+            "1 ~ 2 ~ 3",
+            None,
+        ),
+        ("r[1]", None, "ab", None),
+        (None, None, None, None),
+    ],
+)
+def test_private_doctests_layout(str_expr, msgs, str_expected, fail_msg):
+    """ """
+    check_evaluation(
+        str_expr,
+        str_expected,
+        to_string_expr=True,
+        to_string_expected=True,
+        hold_expected=True,
+        failure_message=fail_msg,
+        expected_messages=msgs,
+    )