feat: (x, y, z,...) notation for lists (= Arrays); subset transform tests

Author: gwhitney

docs/expressions/syntax.md

@@ -14,13 +14,15 @@ the lower level syntax of math.js. Differences are:
 
 - No need to prefix functions and constants with the `math.*` namespace,
   you can just enter `sin(pi / 4)`.
-- Matrix indexes are one-based instead of zero-based.
+- By default, bracket notation `[1, 2, 3]` produces a Matrix object rather
+  than an Array; and an Array can be written with list notation, as `(1, 2, 3)`.
+- Matrix and Array indexes are one-based instead of zero-based.
 - There are index and range operators which allow more conveniently getting
   and setting matrix indexes, like `A[2:4, 1]`.
 - Both indexes and ranges and have the upper-bound included.
 - There is a differing syntax for defining functions. Example: `f(x) = x^2`.
 - There are custom operators like `x + y` instead of `add(x, y)`.
-- Some operators are different. For example  `^` is used for exponentiation,
+- Some operators are different. For example, `^` is used for exponentiation,
   not bitwise xor.
 - Implicit multiplication, like `2 pi`, is supported and has special rules.
 - Relational operators (`<`, `>`, `<=`, `>=`, `==`, and `!=`) are chained, so the expression `5 < x < 10` is equivalent to `5 < x and x < 10`.
@@ -58,7 +60,8 @@ Functions below.
 Operator    | Name                        | Syntax      | Associativity | Example               | Result
 ----------- |-----------------------------|-------------| ------------- |-----------------------| ---------------
 `(`, `)`    | Grouping                    | `(x)`       | None          | `2 * (3 + 4)`         | `14`
-`[`, `]`    | Matrix, Index               | `[...]`     | None          | `[[1,2],[3,4]]`       | `[[1,2],[3,4]]`
+            | Array, function arguments   | `(x, y,...)`| None          | `((), (1,), (1,2))`   | `[[], [1], [1,2]]`
+`[`, `]`    | Matrix, Index               | `[...]`     | None          | `[[1,2],[3,4]]`       | `matrix([[1,2],[3,4]])`
 `{`, `}`    | Object                      | `{...}`     | None          | `{a: 1, b: 2}`        | `{a: 1, b: 2}`
 `,`         | Parameter separator         | `x, y`      | Left to right | `max(2, 1, 5)`        | `5`
 `.`         | Property accessor           | `obj.prop`  | Left to right | `obj={a: 12}; obj.a`  | `12`
@@ -112,7 +115,7 @@ The operators have the following precedence, from highest to lowest:
 
 Operators                         | Description
 --------------------------------- | --------------------
-`(...)`<br>`[...]`<br>`{...}`     | Grouping<br>Matrix<br>Object
+`(...)`<br>`[...]`<br>`{...}`     | Grouping/Array<br>Matrix<br>Object
 `x(...)`<br>`x[...]`<br>`obj.prop`<br>`:`| Function call<br>Matrix index<br>Property accessor<br>Key/value separator
 `'`                               | Matrix transpose
 `!`                               | Factorial

src/expression/node/ArrayNode.js

@@ -13,11 +13,15 @@ export const createArrayNode = /* #__PURE__ */ factory(name, dependencies, ({ No
      * @constructor ArrayNode
      * @extends {Node}
      * Holds an 1-dimensional array with items
-     * @param {Node[]} [items]   1 dimensional array with items
+     * @param {Node[]} [items]        1 dimensional array with items
+     * @param {boolean} [forceArray]
+     *     Should the result always be Array regardless of config? (default
+     *     is false)
      */
-    constructor (items) {
+    constructor (items, forceArray = false) {
       super()
       this.items = items || []
+      this.forceArray = forceArray
 
       // validate input
       if (!Array.isArray(this.items) || !this.items.every(isNode)) {
@@ -47,7 +51,7 @@ export const createArrayNode = /* #__PURE__ */ factory(name, dependencies, ({ No
         return item._compile(math, argNames)
       })
 
-      const asMatrix = (math.config.matrix !== 'Array')
+      const asMatrix = !this.forceArray && (math.config.matrix !== 'Array')
       if (asMatrix) {
         const matrix = math.matrix
         return function evalArrayNode (scope, args, context) {

src/expression/parse.js

@@ -1745,28 +1745,37 @@ export const createParse = /* #__PURE__ */ factory(name, dependencies, ({
    * @private
    */
   function parseParentheses (state) {
-    let node
-
     // check if it is a parenthesized expression
-    if (state.token === '(') {
-      // parentheses (...)
-      openParams(state)
-      getToken(state)
-
-      node = parseAssignment(state) // start again
+    if (state.token !== '(') return parseEnd(state)
+    // Yes, we have parentheses (...)
+    openParams(state)
+    getToken(state)
 
-      if (state.token !== ')') {
-        throw createSyntaxError(state, 'Parenthesis ) expected')
-      }
+    if (state.token === ')') { // `()` is empty array
       closeParams(state)
       getToken(state)
+      return parseAccessors(state, new ArrayNode([], true))
+    }
 
-      node = new ParenthesisNode(node)
-      node = parseAccessors(state, node)
-      return node
+    let node = parseAssignment(state) // start again
+
+    if (state.token === ',') { // Array notation
+      const items = [node]
+      do {
+        getToken(state)
+        if (state.token === ')') break
+        items.push(parseAssignment(state))
+      } while (state.token === ',')
+      node = new ArrayNode(items, true)
+    } else node = new ParenthesisNode(node)
+
+    if (state.token !== ')') {
+      throw createSyntaxError(state, 'Parenthesis ) expected')
     }
+    closeParams(state)
+    getToken(state)
 
-    return parseEnd(state)
+    return parseAccessors(state, node)
   }
 
   /**

src/expression/transform/subset.transform.js

@@ -33,7 +33,7 @@ export const createSubsetTransform = /* #__PURE__ */ factory(
             // supplied an array instead of an index for the 2nd argument, so
             // have to turn that into an Index with indexTransform rather than
             // just plain index, as subset will if we just let it have at it.
-            args[1] = indexTransform.apply(null, args)
+            args[1] = indexTransform.apply(null, args[1])
           }
           return subset.apply(null, args)
         } catch (err) {

src/type/matrix/Matrix.js

@@ -146,7 +146,7 @@ export const createMatrixClass = /* #__PURE__ */ factory(name, dependencies, ()
         if (fields.start === '') fields.start = index.shiftPosition
         if (fields.end === '') fields.end = size[dim] + index.shiftPosition - 1
         fields.start -= index.shiftPosition
-        fields.end -= index
+        fields.end -= index.shiftPosition
         const attributes = index.includeEnd
           ? { start: fields.start, last: fields.end, step: fields.step }
           : fields

src/type/matrix/Range.js

@@ -729,7 +729,9 @@ export const createRangeClass = /* #__PURE__ */ factory(name, dependencies, ({
     callback, skipZeros = false, isUnary = false
   ) {
     if (!Number.isFinite(this.length)) {
-      throw new Error('Attempt to infinite loop')
+      throw new Error(
+        'Attempt to infinite loop Range with ' +
+        `start=${this.start} step=${this.step}`)
     }
     const array = []
     let x = this.start

test/unit-tests/expression/parse.test.js

@@ -890,6 +890,19 @@ describe('parse', function () {
       const scope = {}
       assert.throws(function () { parseAndEval('c=concat(a, [1,2,3])', scope) })
     })
+
+    it(
+      'should interpret comma-separated expressions in parentheses as arrays',
+      function () {
+        assert.deepStrictEqual(parseAndEval('(3,4,5)'), [3, 4, 5])
+        assert.deepStrictEqual(parseAndEval('(5,12,13,)'), [5, 12, 13])
+        assert.deepStrictEqual(parseAndEval('(5,)'), [5])
+        assert.deepStrictEqual(parseAndEval('()'), [])
+        assert.strictEqual(parseAndEval('(7,24,25)[2]'), 24)
+        assert.deepStrictEqual(parseAndEval('size((8, 15, 17))'), [3])
+        assert.deepStrictEqual(
+          parseAndEval('((),(0,),(0,1))'), [[], [0], [0, 1]])
+      })
   })
 
   describe('objects', function () {

test/unit-tests/expression/security.test.js

@@ -248,9 +248,17 @@ describe('security', function () {
   it('should not allow replacing validateSafeMethod with a local variant', function () {
     assert.throws(function () {
       math.evaluate("evaluate(\"f(validateSafeMethod)=cos.constructor(\\\"return evaluate\\\")()\")(evaluate(\"f(x,y)=0\"))(\"console.log('hacked...')\")")
-    }, /SyntaxError: Value expected/)
+    }, /TypeError: Unexpected type of argument/)
   })
 
+  it(
+    'should not allow replacing validateSafeMethod with a local variant (2)',
+    function () {
+      assert.throws(function () {
+        math.evaluate("evaluate(\"f(validateSafeMethod)=cos.constructor(\\\"return evaluate\\\")()\")?.(evaluate(\"f(x,y)=0\"))(\"console.log('hacked...')\")")
+      }, /No access to method .constructor/)
+    })
+
   it('should not allow abusing toString', function () {
     assert.throws(function () {
       math.evaluate("badToString = evaluate(\"f() = 1\"); badReplace = evaluate(\"f(a, b) = \\\"evaluate\\\"\"); badNumber = {toString:badToString, replace:badReplace}; badNode = {\"isNode\": true, \"type\": \"ConstantNode\", \"valueType\": \"number\", \"value\": badNumber}; x = evaluate(\"f(child, path, parent) = badNode\", {badNode:badNode}); parse(\"(1)\").map(x).compile().evaluate()(\"console.log('hacked...')\")")
@@ -260,13 +268,13 @@ describe('security', function () {
   it('should not allow creating a bad FunctionAssignmentNode', function () {
     assert.throws(function () {
       math.evaluate("badNode={isNode:true,type:\"FunctionAssignmentNode\",expr:parse(\"1\"),types:{join:evaluate(\"f(a)=\\\"\\\"\")},params:{\"forEach\":evaluate(\"f(x)=1\"),\"join\":evaluate(\"f(x)=\\\"){return evaluate;}});return fn;})())}});return fn;})());}};//\\\"\")}};parse(\"f()=x\").map(evaluate(\"f(a,b,c)=badNode\",{\"badNode\":badNode})).compile().evaluate()()()(\"console.log('hacked...')\")")
-    }, /SyntaxError: Value expected/)
+    }, /TypeError: Callback function must return a Node/)
   })
 
   it('should not allow creating a bad OperatorNode (1)', function () {
     assert.throws(function () {
       math.evaluate("badNode={isNode:true,type:\"FunctionAssignmentNode\",expr:parse(\"1\"),types:{join:evaluate(\"f(a)=\\\"\\\"\")},params:{\"forEach\":evaluate(\"f(x)=1\"),\"join\":evaluate(\"f(x)=\\\"){return evaluate;}});return fn;})())}});return fn;})());}};//\\\"\")}};parse(\"f()=x\").map(evaluate(\"f(a,b,c)=badNode\",{\"badNode\":badNode})).compile().evaluate()()()(\"console.log('hacked...')\")")
-    }, /SyntaxError: Value expected/)
+    }, /TypeError: Callback function must return a Node/)
   })
 
   it('should not allow creating a bad OperatorNode (2)', function () {
@@ -316,7 +324,7 @@ describe('security', function () {
           'evilMath=x.create().done();' +
           'evilMath.import({"_compile":f(a,b,c)="evaluate","isNode":f()=true}); ' +
           "parse(\"(1)\").map(g(a,b,c)=evilMath.chain()).compile().evaluate()(\"console.log('hacked...')\")")
-    }, /SyntaxError: Value expected/)
+    }, /Error: Undefined symbol Chain/)
   })
 
   it('should not allow passing a function name containg bad contents', function () {

test/unit-tests/expression/transform/subset.transform.test.js

@@ -0,0 +1,16 @@
+import assert from 'assert'
+import math from '../../../../src/defaultInstance.js'
+
+const ev = math.evaluate
+const matrix = math.matrix
+const nummat = x => matrix(x, 'dense', 'number')
+
+describe('subset.transform', function () {
+  it('should obey indexing conventions of expressions', function () {
+    assert.strictEqual(ev('subset([1,2;3,4], (2, 1))'), 3)
+    assert.deepStrictEqual(
+      ev('subset(range(2,10), ([9,7,5],))'), nummat([10, 8, 6]))
+    assert.deepStrictEqual(
+      ev("subset([1,2,3;4,5,6], ('1:2', '2:3'))"), matrix([[2, 3], [5, 6]]))
+  })
+})