feat: Make Range an implementation of Matrix

  With this commit, Range is now a full-fledged implementation of Matrix,
  representing an arbitrary arithmetic sequence (of any type supported
  by mathjs) in a "lazy" way, i.e. its entries are generated on demand.
  (Thus, even infinite Ranges are supported.)

  Note that Range therefore has many new dependencies, and the `matrix()`
  convertor/constructor function must be able to create Ranges. Therefore,
  to avoid a circular dependency on `matrix`, many mathjs methods have
  their dependence on `matrix()` removed. Often this dependence was
  very superficial, and removing it was essentially trivial; in all other
  cases, the dependence could be shifted to DenseMatrix rather than matrix,
  removing the possibility of circularity.

  In addition, as it seemed very confusing (almost to the point of a bug)
  that `math.parse('2:5')` produced a representation of 2, 3, 4, 5 while
  `Range.parse('2:5')` produced a representation of 2, 3, 4. Therefore, this
  commit changes the interpretation so that both `parse` command include the
  endpoint.

  Finally, this commit fixes the remaining doc examples tests in the
  src/type directory.

Author: gwhitney

src/core/function/typed.js

@@ -132,10 +132,10 @@ export const createTyped = /* #__PURE__ */ factory('typed', dependencies, functi
     { name: 'string', test: isString },
     { name: 'Chain', test: isChain },
     { name: 'Array', test: isArray },
-    { name: 'Matrix', test: isMatrix },
     { name: 'DenseMatrix', test: isDenseMatrix },
     { name: 'SparseMatrix', test: isSparseMatrix },
     { name: 'Range', test: isRange },
+    { name: 'Matrix', test: isMatrix },
     { name: 'Index', test: isIndex },
     { name: 'boolean', test: isBoolean },
     { name: 'ResultSet', test: isResultSet },

src/expression/transform/and.transform.js

@@ -3,10 +3,10 @@ import { factory } from '../../utils/factory.js'
 import { isCollection } from '../../utils/is.js'
 
 const name = 'and'
-const dependencies = ['typed', 'matrix', 'zeros', 'add', 'equalScalar', 'not', 'concat']
+const dependencies = ['typed', 'DenseMatrix', 'zeros', 'add', 'equalScalar', 'not']
 
-export const createAndTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, matrix, equalScalar, zeros, not, concat }) => {
-  const and = createAnd({ typed, matrix, equalScalar, zeros, not, concat })
+export const createAndTransform = /* #__PURE__ */ factory(name, dependencies, provided => {
+  const and = createAnd(provided)
 
   function andTransform (args, math, scope) {
     const condition1 = args[0].compile().evaluate(scope)

src/expression/transform/bitAnd.transform.js

@@ -3,10 +3,10 @@ import { factory } from '../../utils/factory.js'
 import { isCollection } from '../../utils/is.js'
 
 const name = 'bitAnd'
-const dependencies = ['typed', 'matrix', 'zeros', 'add', 'equalScalar', 'not', 'concat']
+const dependencies = ['typed', 'DenseMatrix', 'equalScalar']
 
-export const createBitAndTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, matrix, equalScalar, zeros, not, concat }) => {
-  const bitAnd = createBitAnd({ typed, matrix, equalScalar, zeros, not, concat })
+export const createBitAndTransform = /* #__PURE__ */ factory(name, dependencies, provided => {
+  const bitAnd = createBitAnd(provided)
 
   function bitAndTransform (args, math, scope) {
     const condition1 = args[0].compile().evaluate(scope)

src/expression/transform/bitOr.transform.js

@@ -3,10 +3,10 @@ import { factory } from '../../utils/factory.js'
 import { isCollection } from '../../utils/is.js'
 
 const name = 'bitOr'
-const dependencies = ['typed', 'matrix', 'equalScalar', 'DenseMatrix', 'concat']
+const dependencies = ['typed', 'equalScalar', 'DenseMatrix']
 
-export const createBitOrTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, matrix, equalScalar, DenseMatrix, concat }) => {
-  const bitOr = createBitOr({ typed, matrix, equalScalar, DenseMatrix, concat })
+export const createBitOrTransform = /* #__PURE__ */ factory(name, dependencies, provided => {
+  const bitOr = createBitOr(provided)
 
   function bitOrTransform (args, math, scope) {
     const condition1 = args[0].compile().evaluate(scope)

src/expression/transform/index.transform.js

@@ -4,9 +4,9 @@ import {
 import { factory } from '../../utils/factory.js'
 
 const name = 'index'
-const dependencies = ['Index', 'getMatrixDataType']
+const dependencies = ['Index', 'Range', 'number', 'getMatrixDataType']
 
-export const createIndexTransform = /* #__PURE__ */ factory(name, dependencies, ({ Index, getMatrixDataType }) => {
+export const createIndexTransform = /* #__PURE__ */ factory(name, dependencies, ({ Index, Range, number, getMatrixDataType }) => {
   /**
    * Attach a transform function to math.index
    * Adds a property transform containing the transform function.
@@ -20,8 +20,11 @@ export const createIndexTransform = /* #__PURE__ */ factory(name, dependencies,
 
       // change from one-based to zero based, convert BigNumber to number and leave Array of Booleans as is
       if (isRange(arg)) {
-        arg.start--
-        arg.end -= (arg.step > 0 ? 0 : 2)
+        arg = new Range({
+          from: number(arg.from) - 1,
+          for: arg.for,
+          by: number(arg.by)
+        })
       } else if (arg && arg.isSet === true) {
         arg = arg.map(function (v) { return v - 1 })
       } else if (isArray(arg) || isMatrix(arg)) {

src/expression/transform/nullish.transform.js

@@ -3,10 +3,10 @@ import { factory } from '../../utils/factory.js'
 import { isCollection } from '../../utils/is.js'
 
 const name = 'nullish'
-const dependencies = ['typed', 'matrix', 'size', 'flatten', 'deepEqual']
+const dependencies = ['typed', 'DenseMatrix', 'size', 'flatten', 'deepEqual']
 
-export const createNullishTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, matrix, size, flatten, deepEqual }) => {
-  const nullish = createNullish({ typed, matrix, size, flatten, deepEqual })
+export const createNullishTransform = /* #__PURE__ */ factory(name, dependencies, provided => {
+  const nullish = createNullish(provided)
 
   function nullishTransform (args, math, scope) {
     const left = args[0].compile().evaluate(scope)

src/expression/transform/range.transform.js

@@ -1,19 +1,18 @@
 import { factory } from '../../utils/factory.js'
-import { createRange } from '../../function/matrix/range.js'
+import { createRange, dependencies } from '../../function/matrix/range.js'
 
 const name = 'range'
-const dependencies = ['typed', 'config', '?matrix', '?bignumber', 'equal', 'smaller', 'smallerEq', 'larger', 'largerEq', 'add', 'isZero', 'isPositive']
 
-export const createRangeTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, matrix, bignumber, equal, smaller, smallerEq, larger, largerEq, add, isZero, isPositive }) => {
-  const range = createRange({ typed, config, matrix, bignumber, equal, smaller, smallerEq, larger, largerEq, add, isZero, isPositive })
+export const createRangeTransform = /* #__PURE__ */ factory(name, dependencies, provided => {
+  const range = createRange(provided)
 
   /**
    * Attach a transform function to math.range
    * Adds a property transform containing the transform function.
    *
    * This transform creates a range which includes the end value
    */
-  return typed('range', {
+  return provided.typed('range', {
     '...any': function (args) {
       const lastIndex = args.length - 1
       const last = args[lastIndex]

src/factoriesNumber.js

@@ -83,6 +83,7 @@ export { createTyped } from './core/function/typed.js'
 // classes
 export { createResultSet } from './type/resultset/ResultSet.js'
 export { createRangeClass } from './type/matrix/Range.js'
+export { createMatrixClass } from './type/matrix/Matrix.js'
 export { createHelpClass } from './expression/Help.js'
 export { createChainClass } from './type/chain/Chain.js'
 export { createHelp } from './expression/function/help.js'
@@ -128,6 +129,7 @@ export const createPow = /* #__PURE__ */ createNumberFactory('pow', powNumber)
 export { createOneNumber } from './function/arithmetic/one.js'
 export const createRound = /* #__PURE__ */
   createNumberOptionalSecondArgFactory('round', roundNumber)
+export { createScalarDivide } from './function/arithmetic/scalarDivide.js'
 export const createLog = /* #__PURE__ */
   createNumberOptionalSecondArgFactory('log', logNumber)
 export const createLog1p = /* #__PURE__ */ createNumberFactory('log1p', log1pNumber)
@@ -211,6 +213,7 @@ export const createOr = /* #__PURE__ */ createNumberFactory('or', orNumber)
 export const createXor = /* #__PURE__ */ createNumberFactory('xor', xorNumber)
 
 // matrix
+export { createGetMatrixDataType } from './function/matrix/getMatrixDataType.js'
 export { createMapSlices } from './function/matrix/mapSlices.js'
 export { createFilter } from './function/matrix/filter.js'
 export { createForEach } from './function/matrix/forEach.js'

src/function/arithmetic/add.js

@@ -7,22 +7,20 @@ import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgori
 const name = 'add'
 const dependencies = [
   'typed',
-  'matrix',
   'addScalar',
   'equalScalar',
   'DenseMatrix',
-  'SparseMatrix',
-  'concat'
+  'SparseMatrix'
 ]
 
 export const createAdd = /* #__PURE__ */ factory(
   name,
   dependencies,
-  ({ typed, matrix, addScalar, equalScalar, DenseMatrix, SparseMatrix, concat }) => {
+  ({ typed, addScalar, equalScalar, DenseMatrix, SparseMatrix, math, concat }) => {
     const matAlgo01xDSid = createMatAlgo01xDSid({ typed })
     const matAlgo04xSidSid = createMatAlgo04xSidSid({ typed, equalScalar })
     const matAlgo10xSids = createMatAlgo10xSids({ typed, DenseMatrix })
-    const matrixAlgorithmSuite = createMatrixAlgorithmSuite({ typed, matrix, concat })
+    const matrixAlgorithmSuite = createMatrixAlgorithmSuite({ typed, DenseMatrix })
     /**
      * Add two or more values, `x + y`.
      * For matrices, the function is evaluated element wise.
@@ -70,7 +68,29 @@ export const createAdd = /* #__PURE__ */ factory(
           }
 
           return result
-        })
+        }),
+        'Range, Range': typed.referToSelf(self => (r, p) => {
+          if (r.for !== p.for) throw new Error('Range length mismatch')
+          return r.createRange({
+            from: self(r.from, p.from),
+            for: r.for,
+            by: self(r.by, p.by)
+          })
+        }),
+        'Range, Matrix': typed.referToSelf(
+          self => (r, m) => self(r.valueOf(), m)),
+        'Range, any': typed.referToSelf(self => (r, s) => r.createRange({
+          from: self(r.from, s),
+          for: r.for,
+          by: r.by
+        })),
+        'Matrix, Range': typed.referToSelf(
+          self => (m, r) => self(m, r.valueOf())),
+        'any, Range': typed.referToSelf(self => (s, r) => r.createRange({
+          from: self(s, r.from),
+          for: r.for,
+          by: r.by
+        }))
       },
       matrixAlgorithmSuite({
         elop: addScalar,

src/function/arithmetic/ceil.js

@@ -8,7 +8,7 @@ import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js'
 import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js'
 
 const name = 'ceil'
-const dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix']
+const dependencies = ['typed', 'config', 'round', 'equalScalar', 'zeros', 'DenseMatrix']
 
 const bigTen = new Decimal(10)
 
@@ -46,7 +46,7 @@ export const createCeilNumber = /* #__PURE__ */ factory(
   }
 )
 
-export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, round, matrix, equalScalar, zeros, DenseMatrix }) => {
+export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed, config, round, equalScalar, zeros, DenseMatrix }) => {
   const matAlgo11xS0s = createMatAlgo11xS0s({ typed, equalScalar })
   const matAlgo12xSfs = createMatAlgo12xSfs({ typed, DenseMatrix })
   const matAlgo14xDs = createMatAlgo14xDs({ typed })
@@ -181,7 +181,7 @@ export const createCeil = /* #__PURE__ */ factory(name, dependencies, ({ typed,
     'number | Complex | Fraction | BigNumber, Array':
       typed.referToSelf(self => (x, y) => {
         // use matrix implementation
-        return matAlgo14xDs(matrix(y), x, self, true).valueOf()
+        return matAlgo14xDs(new DenseMatrix(y), x, self, true).valueOf()
       }),
 
     'number | Complex | Fraction | BigNumber, Matrix':