fix(simplify): Array and object simplification (#2382)

* fix(simplify): Allow simplify to work in arrays, objects, and indexing

  Mostly ArrayNode, ObjectNode, AccessorNode, and IndexNode nodes are
  simply transparent to simplification -- they simply allow it to occur
  within subexpressions. Then main exception is that if an array or object
  is indexed by a constant, the expression can be replaced by the
  corresponding subitem, e.g. `[3,4,5][2]` simplifies to `4`.

  This at least partially resolves #1913 (see my latest comment there).

* fix(simplify): Resolve operations on constant arrays

  This involves allowing ArrayNodes containing only constant entries
  to temporarily convert to Matrix type inside of simplifyConstant, so that
  function and operator calls can occur on them.
  I also had to add a special case for the function `size` because
  it can be computed even on symbolic arrays, since the result depends
  only on the shape, not the entries.

  Deals with additional cases of #1913; unclear if there are remaining
  aspects of that issue on which further work is desirable.

* chore: fix alphabetization of dependencies

  And restores inadvertent deletion of a blank line.

Co-authored-by: Jos de Jong <[email protected]>

Author: gwhitney

src/function/algebra/rationalize.js

@@ -19,10 +19,14 @@ const dependencies = [
   '?bignumber',
   '?fraction',
   'mathWithTransform',
+  'matrix',
+  'AccessorNode',
   'ArrayNode',
   'ConstantNode',
-  'OperatorNode',
   'FunctionNode',
+  'IndexNode',
+  'ObjectNode',
+  'OperatorNode',
   'SymbolNode',
   'ParenthesisNode'
 ]
@@ -42,23 +46,31 @@ export const createRationalize = /* #__PURE__ */ factory(name, dependencies, ({
   fraction,
   bignumber,
   mathWithTransform,
+  matrix,
+  AccessorNode,
   ArrayNode,
   ConstantNode,
-  OperatorNode,
   FunctionNode,
+  IndexNode,
+  ObjectNode,
+  OperatorNode,
   SymbolNode,
   ParenthesisNode
 }) => {
   const simplifyConstant = createSimplifyConstant({
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
     ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode
   })
   const simplifyCore = createSimplifyCore({
@@ -69,9 +81,13 @@ export const createRationalize = /* #__PURE__ */ factory(name, dependencies, ({
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     ParenthesisNode
   })
 

src/function/algebra/simplify.js

@@ -22,9 +22,13 @@ const dependencies = [
   '?fraction',
   '?bignumber',
   'mathWithTransform',
+  'matrix',
+  'AccessorNode',
   'ArrayNode',
   'ConstantNode',
   'FunctionNode',
+  'IndexNode',
+  'ObjectNode',
   'OperatorNode',
   'ParenthesisNode',
   'SymbolNode'
@@ -45,9 +49,13 @@ export const createSimplify = /* #__PURE__ */ factory(name, dependencies, (
     fraction,
     bignumber,
     mathWithTransform,
+    matrix,
+    AccessorNode,
     ArrayNode,
     ConstantNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
     OperatorNode,
     ParenthesisNode,
     SymbolNode
@@ -57,12 +65,16 @@ export const createSimplify = /* #__PURE__ */ factory(name, dependencies, (
     typed,
     config,
     mathWithTransform,
+    matrix,
     fraction,
     bignumber,
+    AccessorNode,
     ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     SymbolNode
   })
   const simplifyCore = createSimplifyCore({
@@ -73,9 +85,13 @@ export const createSimplify = /* #__PURE__ */ factory(name, dependencies, (
     multiply,
     divide,
     pow,
+    AccessorNode,
+    ArrayNode,
     ConstantNode,
-    OperatorNode,
     FunctionNode,
+    IndexNode,
+    ObjectNode,
+    OperatorNode,
     ParenthesisNode
   })
   const resolve = createResolve({
@@ -418,6 +434,14 @@ export const createSimplify = /* #__PURE__ */ factory(name, dependencies, (
     return new SymbolNode('_p' + _lastsym++)
   }
 
+  function mapRule (nodes, rule) {
+    if (nodes) {
+      for (let i = 0; i < nodes.length; ++i) {
+        nodes[i] = applyRule(nodes[i], rule)
+      }
+    }
+  }
+
   /**
    * Returns a simplfied form of node, or the original node if no simplification was possible.
    *
@@ -432,18 +456,29 @@ export const createSimplify = /* #__PURE__ */ factory(name, dependencies, (
       let res = node
 
       // First replace our child nodes with their simplified versions
-      // If a child could not be simplified, the assignments will have
-      // no effect since the node is returned unchanged
+      // If a child could not be simplified, applying the rule to it
+      // will have no effect since the node is returned unchanged
       if (res instanceof OperatorNode || res instanceof FunctionNode) {
-        if (res.args) {
-          for (let i = 0; i < res.args.length; i++) {
-            res.args[i] = applyRule(res.args[i], rule)
-          }
-        }
+        mapRule(res.args, rule)
       } else if (res instanceof ParenthesisNode) {
         if (res.content) {
           res.content = applyRule(res.content, rule)
         }
+      } else if (res instanceof ArrayNode) {
+        mapRule(res.items, rule)
+      } else if (res instanceof AccessorNode) {
+        if (res.object) {
+          res.object = applyRule(res.object, rule)
+        }
+        if (res.index) {
+          res.index = applyRule(res.index, rule)
+        }
+      } else if (res instanceof IndexNode) {
+        mapRule(res.dimensions, rule)
+      } else if (res instanceof ObjectNode) {
+        for (const prop in res.properties) {
+          res.properties[prop] = applyRule(res.properties[prop], rule)
+        }
       }
 
       // Try to match a rule against this node