From e35f3a4a931a80c22b801996e957815d7e8605f8 Mon Sep 17 00:00:00 2001 From: mmatera Date: Sun, 20 Feb 2022 09:03:12 -0300 Subject: [PATCH 1/2] fix the issue with Simplify --- CHANGES.rst | 2 +- mathics/builtin/numbers/algebra.py | 14 +++++++++----- mathics/builtin/numbers/calculus.py | 2 +- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/CHANGES.rst b/CHANGES.rst index e6ff33d27..cc8c9491c 100644 --- a/CHANGES.rst +++ b/CHANGES.rst @@ -63,7 +63,7 @@ Bugs * ``N`` now handles arbitrary precision numbers when the number of digits is not specified. * ``Set*``: fixed issue #128. * ``SameQ``: comparison with MachinePrecision only needs to be exact within the last bit Issue #148. - +* Fix a bug in `Simplify` that produced expressions of the form ``ConditionalExpression[_,{True}]``. 4.0.1 ----- diff --git a/mathics/builtin/numbers/algebra.py b/mathics/builtin/numbers/algebra.py index a9d818652..9288b0a73 100644 --- a/mathics/builtin/numbers/algebra.py +++ b/mathics/builtin/numbers/algebra.py @@ -416,8 +416,8 @@ class Simplify(Builtin): "Simplify[rule_Rule]": "Simplify /@ rule", "Simplify[list_List, assum_]": "Simplify[#1, assum]& /@ list", "Simplify[rule_Rule, assum_]": "Simplify[#1, assum]& /@ rule", - "Simplify[0^a_, assum_]": "ConditionalExpression[0,Simplify[a>0]]", - "Simplify[b_^a_, assum_]": "ConditionalExpression[b,Simplify[{Or[a>0, b!=0]}]]", + "Simplify[0^a_, assum_]": "ConditionalExpression[0,Simplify[a>0, assum]]", + "Simplify[b_^a_, assum_]": "ConditionalExpression[b,Simplify[Or[a>0, b!=0],assum]]", } def apply_assuming(self, expr, assumptions, evaluation): @@ -432,6 +432,8 @@ def apply_assuming(self, expr, assumptions, evaluation): def apply(self, expr, evaluation): "%(name)s[expr_]" # Check first if we are dealing with a logic expression... + if expr in (SymbolTrue, SymbolFalse, SymbolList): + return expr expr = evaluate_predicate(expr, evaluation) if expr.is_atom(): return expr @@ -439,12 +441,14 @@ def apply(self, expr, evaluation): leaves = [self.apply(leaf, evaluation) for leaf in expr._leaves] head = self.apply(expr.get_head(), evaluation) expr = Expression(head, *leaves) - sympy_expr = expr.to_sympy() + # If the expression cannot be handled by Sympy, just return it. if sympy_expr is None: - return + return expr + # Tries to apply the rules sympy_result = sympy.simplify(sympy_expr) - return from_sympy(sympy_result) + result = from_sympy(sympy_result).evaluate(evaluation) + return result class FullSimplify(Simplify): diff --git a/mathics/builtin/numbers/calculus.py b/mathics/builtin/numbers/calculus.py index 957d293cb..2bcf202ab 100644 --- a/mathics/builtin/numbers/calculus.py +++ b/mathics/builtin/numbers/calculus.py @@ -711,7 +711,6 @@ def apply(self, f, xs, evaluation, options): if default.has_form("Integrate", None): if default._leaves[0] == f: default = SymbolUndefined - simplified_cases = [] for case in cases: # TODO: if something like 0^n or 1/expr appears, @@ -742,6 +741,7 @@ def apply(self, f, xs, evaluation, options): # Sympy returned the same expression, so it can't be evaluated. return result = Expression("Simplify", result, assuming) + result = result.evaluate(evaluation) return result def apply_D(self, func, domain, var, evaluation, options): From 1fba2b3d0140e4d7e13bd0e0a5f47764e8f698f2 Mon Sep 17 00:00:00 2001 From: mmatera Date: Sun, 20 Feb 2022 09:15:58 -0300 Subject: [PATCH 2/2] remaining fix --- mathics/builtin/numbers/algebra.py | 2 +- test/test_calculus.py | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/mathics/builtin/numbers/algebra.py b/mathics/builtin/numbers/algebra.py index 9288b0a73..2a9ff715d 100644 --- a/mathics/builtin/numbers/algebra.py +++ b/mathics/builtin/numbers/algebra.py @@ -417,7 +417,7 @@ class Simplify(Builtin): "Simplify[list_List, assum_]": "Simplify[#1, assum]& /@ list", "Simplify[rule_Rule, assum_]": "Simplify[#1, assum]& /@ rule", "Simplify[0^a_, assum_]": "ConditionalExpression[0,Simplify[a>0, assum]]", - "Simplify[b_^a_, assum_]": "ConditionalExpression[b,Simplify[Or[a>0, b!=0],assum]]", + "Simplify[b_^a_, assum_]": "ConditionalExpression[b^a,Simplify[Or[a>0, b!=0],assum]]", } def apply_assuming(self, expr, assumptions, evaluation): diff --git a/test/test_calculus.py b/test/test_calculus.py index 168e1b6b1..541bdff84 100644 --- a/test/test_calculus.py +++ b/test/test_calculus.py @@ -38,5 +38,6 @@ def test_calculus(): "{x->1.51213}", "Issue #1235", ), + ("Integrate[Integrate[1,{y,0,E^x}],{x,0,Log[13]}]", "12", "Issue #153"), ): check_evaluation(str_expr, str_expected, message)