WIP: Extend factorial

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/embeddedDocs/embeddedDocs.js

@@ -55,6 +55,7 @@ import { ceilDocs } from './function/arithmetic/ceil.js'
 import { cubeDocs } from './function/arithmetic/cube.js'
 import { divideDocs } from './function/arithmetic/divide.js'
 import { dotDivideDocs } from './function/arithmetic/dotDivide.js'
+import { scalarDivideDocs } from './function/arithmetic/scalarDivide.js'
 import { dotMultiplyDocs } from './function/arithmetic/dotMultiply.js'
 import { dotPowDocs } from './function/arithmetic/dotPow.js'
 import { expDocs } from './function/arithmetic/exp.js'
@@ -75,11 +76,13 @@ import { multiplyDocs } from './function/arithmetic/multiply.js'
 import { normDocs } from './function/arithmetic/norm.js'
 import { nthRootDocs } from './function/arithmetic/nthRoot.js'
 import { nthRootsDocs } from './function/arithmetic/nthRoots.js'
+import { oneDocs } from './function/arithmetic/one.js'
 import { powDocs } from './function/arithmetic/pow.js'
 import { roundDocs } from './function/arithmetic/round.js'
 import { signDocs } from './function/arithmetic/sign.js'
 import { sqrtDocs } from './function/arithmetic/sqrt.js'
 import { sqrtmDocs } from './function/arithmetic/sqrtm.js'
+import { zeroDocs } from './function/arithmetic/zero.js'
 import { sylvesterDocs } from './function/algebra/sylvester.js'
 import { schurDocs } from './function/algebra/schur.js'
 import { lyapDocs } from './function/algebra/lyap.js'
@@ -377,6 +380,7 @@ export const embeddedDocs = {
   cube: cubeDocs,
   divide: divideDocs,
   dotDivide: dotDivideDocs,
+  scalarDivide: scalarDivideDocs,
   dotMultiply: dotMultiplyDocs,
   dotPow: dotPowDocs,
   exp: expDocs,
@@ -396,6 +400,7 @@ export const embeddedDocs = {
   norm: normDocs,
   nthRoot: nthRootDocs,
   nthRoots: nthRootsDocs,
+  one: oneDocs,
   pow: powDocs,
   round: roundDocs,
   sign: signDocs,
@@ -407,6 +412,7 @@ export const embeddedDocs = {
   unaryPlus: unaryPlusDocs,
   xgcd: xgcdDocs,
   invmod: invmodDocs,
+  zero: zeroDocs,
 
   // functions - bitwise
   bitAnd: bitAndDocs,

src/expression/embeddedDocs/function/arithmetic/one.js

@@ -0,0 +1,8 @@
+export const oneDocs = {
+  name: 'one',
+  category: 'arithmetic',
+  syntax: ['one(x)'],
+  description: 'returns the multiplicative identity of the same type as x',
+  examples: ['one(2/3)', 'one([[1, -1], [-1, 2]])'],
+  seealso: ['zero', 'typeOf', 'numeric']
+}

src/expression/embeddedDocs/function/arithmetic/scalarDivide.js

@@ -0,0 +1,17 @@
+export const scalarDivideDocs = {
+  name: 'scalarDivide',
+  category: 'arithmetic',
+  syntax: [
+    'scalarDivide(x, y)'
+  ],
+  description: 'Determine if one entity is a scalar multiple of another',
+  examples: [
+    'scalarDivide([3, 2, 0], [6, 4, 0])',
+    'scalarDivide([3, 2, 1], [6, 4, 1])',
+    'scalarDivide(3, 0)'
+  ],
+  seealso: [
+    'divide',
+    'dotDivide'
+  ]
+}

src/expression/embeddedDocs/function/arithmetic/scalarDivide.js~

@@ -0,0 +1,17 @@
+export const scalarDivideDocs = {
+  name: 'scalarDivide',
+  category: 'arithmetic',
+  syntax: [
+    'scalarDivide(x, y)'
+  ],
+  description: 'Determine if one entity is a scalar multiple of another',
+  examples: [
+    'scalarDivide([3, 2, 0], [6, 4, 0])',
+    'scalarDivide([3, 2, 1], [6, 4, 1])',
+    'scalarDivide(3, 0)',
+  ],
+  seealso: [
+    'divide',
+    'dotDivide',
+  ]
+}

src/expression/embeddedDocs/function/arithmetic/zero.js

@@ -0,0 +1,8 @@
+export const zeroDocs = {
+  name: 'zero',
+  category: 'arithmetic',
+  syntax: ['zero(x)'],
+  description: 'returns the additive identity of the same type as x',
+  examples: ['zero(2/3)', 'zero([[1, -1, 1], [-1, 2, -1]])'],
+  seealso: ['one', 'typeOf', 'numeric']
+}

src/expression/embeddedDocs/function/arithmetic/zero.js~

@@ -0,0 +1,8 @@
+export const oneDocs = {
+  name: 'one',
+  category: 'arithmetic',
+  syntax: ['one(x)'],
+  description: 'returns the multiplicative identity of the same type as x',
+  examples: ['one(2/3)', 'one([[1, -1], [-1, 2]])'],
+  seealso: ['typeOf', 'numeric']
+}

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/expression/transform/subset.transform.js

@@ -1,20 +1,19 @@
 import { factory } from '../../utils/factory.js'
 import { errorTransform } from './utils/errorTransform.js'
-import { createSubset } from '../../function/matrix/subset.js'
+import { createSubset, dependencies } from '../../function/matrix/subset.js'
 
 const name = 'subset'
-const dependencies = ['typed', 'matrix', 'zeros', 'add']
 
-export const createSubsetTransform = /* #__PURE__ */ factory(name, dependencies, ({ typed, matrix, zeros, add }) => {
-  const subset = createSubset({ typed, matrix, zeros, add })
+export const createSubsetTransform = /* #__PURE__ */ factory(name, dependencies, provided => {
+  const subset = createSubset(provided)
 
   /**
    * Attach a transform function to math.subset
    * Adds a property transform containing the transform function.
    *
    * This transform creates a range which includes the end value
    */
-  return typed('subset', {
+  return provided.typed('subset', {
     '...any': function (args) {
       try {
         return subset.apply(null, args)

src/factoriesAny.js

@@ -114,13 +114,16 @@ export { createToBest } from './function/unit/toBest.js'
 export { createIsPrime } from './function/utils/isPrime.js'
 export { createNumeric } from './function/utils/numeric.js'
 export { createDivideScalar } from './function/arithmetic/divideScalar.js'
+export { createOneUnitless, createOne } from './function/arithmetic/one.js'
 export { createPow } from './function/arithmetic/pow.js'
 export { createRound } from './function/arithmetic/round.js'
 export { createLog } from './function/arithmetic/log.js'
 export { createLog1p } from './function/arithmetic/log1p.js'
 export { createNthRoots } from './function/arithmetic/nthRoots.js'
 export { createDotPow } from './function/arithmetic/dotPow.js'
 export { createDotDivide } from './function/arithmetic/dotDivide.js'
+export { createScalarDivide } from './function/arithmetic/scalarDivide.js'
+export { createZero } from './function/arithmetic/zero.js'
 export { createLsolve } from './function/algebra/solver/lsolve.js'
 export { createUsolve } from './function/algebra/solver/usolve.js'
 export { createLsolveAll } from './function/algebra/solver/lsolveAll.js'

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'
@@ -105,6 +106,7 @@ export const createSubtractScalar = /* #__PURE__ */ createNumberFactory('subtrac
 export const createCbrt = /* #__PURE__ */ createNumberFactory('cbrt', cbrtNumber)
 export { createCeilNumber as createCeil } from './function/arithmetic/ceil.js'
 export const createCube = /* #__PURE__ */ createNumberFactory('cube', cubeNumber)
+export { createDotMultiplyNumber } from './function/arithmetic/dotMultiply.js'
 export const createExp = /* #__PURE__ */ createNumberFactory('exp', expNumber)
 export const createExpm1 = /* #__PURE__ */ createNumberFactory('expm1', expm1Number)
 export { createFixNumber as createFix } from './function/arithmetic/fix.js'
@@ -115,7 +117,7 @@ export const createLog10 = /* #__PURE__ */ createNumberFactory('log10', log10Num
 export const createLog2 = /* #__PURE__ */ createNumberFactory('log2', log2Number)
 export const createMod = /* #__PURE__ */ createNumberFactory('mod', modNumber)
 export const createMultiplyScalar = /* #__PURE__ */ createNumberFactory('multiplyScalar', multiplyNumber)
-export const createMultiply = /* #__PURE__ */ createNumberFactory('multiply', multiplyNumber)
+export { createMultiplyNumber } from './function/arithmetic/multiply.js'
 export const createNthRoot = /* #__PURE__ */
   createNumberOptionalSecondArgFactory('nthRoot', nthRootNumber)
 export const createSign = /* #__PURE__ */ createNumberFactory('sign', signNumber)
@@ -125,15 +127,18 @@ export const createSubtract = /* #__PURE__ */ createNumberFactory('subtract', su
 export const createXgcd = /* #__PURE__ */ createNumberFactory('xgcd', xgcdNumber)
 export const createDivideScalar = /* #__PURE__ */ createNumberFactory('divideScalar', divideNumber)
 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)
 export const createAdd = /* #__PURE__ */ createNumberFactory('add', addNumber)
 export { createHypot } from './function/arithmetic/hypot.js'
 export const createNorm = /* #__PURE__ */ createNumberFactory('norm', normNumber)
 export const createDivide = /* #__PURE__ */ createNumberFactory('divide', divideNumber)
+export { createZeroNumber } from './function/arithmetic/zero.js'
 
 // bitwise
 export const createBitAnd = /* #__PURE__ */ createNumberFactory('bitAnd', bitAndNumber)
@@ -209,6 +214,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'
@@ -219,6 +225,8 @@ export { createSize } from './function/matrix/size.js'
 export const createIndex = /* #__PURE__ */ factory('index', [], () => noIndex)
 export const createMatrix = /* #__PURE__ */ factory('matrix', [], () => noMatrix) // FIXME: needed now because subset transform needs it. Remove the need for it in subset
 export const createSubset = /* #__PURE__ */ factory('subset', [], () => noSubset)
+export { createSqueeze } from './function/matrix/squeeze.js'
+
 // TODO: provide number+array implementations for map, filter, forEach, zeros, ...?
 // TODO: create range implementation for range?
 export { createPartitionSelect } from './function/matrix/partitionSelect.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,