mirror of
https://github.com/josdejong/mathjs.git
synced 2026-01-18 14:59:29 +00:00
7dcdad04fc
* feat(simplify): Allow context option If the options argument has a key 'context', it value is interpreted as a context specifying various (non-default) properties of operators. This context is propagated to all rules and all matching. Adds some initial tests that the context option affects the behavior of simplify appropriately. Not all can be activated until in a future commit we add the ability for the application of a rule to be contingent on aspects of the context. Note that the enhanced rule matching necessary to support rules constrained by non-default operator properties led to a couple of changes to the output of rationalize() as well. Since the new output seemed to better match what a person would typical write for the rationalized form, this commit changed the test rather than attempted to preserve the exact prior order of terms. * feat(simplifyCore): strip all parentheses Prior to this commit, simplifyCore stripped internal parentheses, but would leave top-level ones. But top-level parentheses don't carry any semantics, and no tests other than the ones that explicitly checked for the retention of top-level parentheses were affected by this change. Not making a special case for the top level also notably streamlined the code in simplifyCore. Adds tests for the new parenthesis-stripping behavior, as well as for other node types that were added earlier but which did not yet have simplifyCore tests. * refactor(simplifyCore): Strip any node marked as trivial in context This replaces special-case tests for unary + and parentheses, and paves the way for example for 'abs' being marked trivial in a putative positiveContext * refactor(simplify): Rename 'context' parameter to rules and document it. The new name is 'imposeContext' -- the motivation for the change is to distinguish the parameter for 'assuming', which will be added as a new parameter to control rule application based on context. * feat(simplify): Allow context-based conditions on rule application. Adds a new property of rules specified as objects: `assuming`. Its value should be a context, and every property specified in that context must match the incoming context, or else the rule will not be applied. Updates the constant floating rules to require their operators be commutative, as a test of the feature, and adds a unit test for this. * feat(simplify): annotate rules with underlying assumptions Also activates a number of tests of simplifications that should or should not occur in various contexts. To get all tests to pass, I could no longer find a rule ordering that worked in all cases, without the ability to mark an individual rule as applying repeatedly until just that rule stabilized. So this commit also adds that ability, and uses it to eliminate the tricky rule of expanding n1 + (n2 + n3)*(-1) to n1 + n2*(-1) + n3*(-1) late in the rule ordering, in favor of the more intuitive (complete) expansion of (n1 + n2)*(-1) to n1*(-1) + n2*(-1) early in the rule ordering, before constant folding and gathering of like terms. * feat(simplify): Add contexts for specific domains In particular, adds a `simplify.realContext` and a `simplify.positiveContext` which (attempt to) guarantee that no simplifications that change the value of the expression, on any real number or any positive real number, respectively, will occur. Adds multiple tests for these contexts, including verification that the simplification in either context does not change some example values of any of the expressions in any simplify test. This testing uncovered that it is unaryPlus that must be marked as trivial for simplifyCore to work properly, so that marking is added as well. * chore: Alter value consistency tests for browsers/older Node The problem was NaN != NaN in some JavaScripts but not others, so test for "both values NaN" explicitly before using deepEqual. * fix: Implement requested changes from review Added documentation about scope and context in top-level algebra functions page; made variable name less abbreviated; performed suggested refactoring. Co-authored-by: Jos de Jong <wjosdejong@gmail.com>