operations between jagged arrays and scalars

src/type/matrix/utils/matAlgo14xDs.js

@@ -1,5 +1,4 @@
 import { factory } from '../../../utils/factory.js'
-import { clone } from '../../../utils/object.js'
 
 const name = 'matAlgo14xDs'
 const dependencies = ['typed']
@@ -21,11 +20,6 @@ export const createMatAlgo14xDs = /* #__PURE__ */ factory(name, dependencies, ({
    * https://github.com/josdejong/mathjs/pull/346#issuecomment-97659042
    */
   return function matAlgo14xDs (a, b, callback, inverse) {
-    // a arrays
-    const adata = a._data
-    const asize = a._size
-    const adt = a._datatype
-
     // datatype
     let dt
     // callback signature to use
@@ -34,42 +28,13 @@ export const createMatAlgo14xDs = /* #__PURE__ */ factory(name, dependencies, ({
     // process data types
     if (typeof adt === 'string') {
       // datatype
-      dt = adt
+      dt = a._datatype
       // convert b to the same datatype
       b = typed.convert(b, dt)
       // callback
       cf = typed.find(callback, [dt, dt])
     }
 
-    // populate cdata, iterate through dimensions
-    const cdata = asize.length > 0 ? _iterate(cf, 0, asize, asize[0], adata, b, inverse) : []
-
-    // c matrix
-    return a.createDenseMatrix({
-      data: cdata,
-      size: clone(asize),
-      datatype: dt
-    })
-  }
-
-  // recursive function
-  function _iterate (f, level, s, n, av, bv, inverse) {
-    // initialize array for this level
-    const cv = []
-    // check we reach the last level
-    if (level === s.length - 1) {
-      // loop arrays in last level
-      for (let i = 0; i < n; i++) {
-        // invoke callback and store value
-        cv[i] = inverse ? f(bv, av[i]) : f(av[i], bv)
-      }
-    } else {
-      // iterate current level
-      for (let j = 0; j < n; j++) {
-        // iterate next level
-        cv[j] = _iterate(f, level + 1, s, s[level + 1], av[j], bv, inverse)
-      }
-    }
-    return cv
+    return inverse ? a.map(v => cf(b, v)) : a.map(v => cf(v, b))
   }
 })

src/type/matrix/utils/matAlgo15xAs.js

@@ -0,0 +1,26 @@
+import { factory } from '../../../utils/factory.js'
+import { deepMap as map } from '../../../utils/array.js'
+
+const name = 'matAlgo15xAs'
+const dependencies = []
+
+export const createMatAlgo15xAs = /* #__PURE__ */ factory(name, dependencies, () => {
+  /**
+   * Iterates over Array items and invokes the callback function f(Aij..z, b).
+   * Callback function invoked MxN times.
+   *
+   * C(i,j,...z) = f(Aij..z, b)
+   *
+   * @param {Array}    a                 The Array instance (A)
+   * @param {Scalar}   b                 The Scalar value
+   * @param {Function} cf                The f(Aij..z,b) operation to invoke
+   * @param {boolean}  inverse           A true value indicates callback should be invoked f(b,Aij..z)
+   *
+   * @return {Array}                    Array (C)
+   *
+   * https://github.com/josdejong/mathjs/pull/346#issuecomment-97659042
+   */
+  return function matAlgo15xAs (a, b, cf, inverse) {
+    return inverse ? map(a, v => cf(b, v)) : map(a, v => cf(v, b))
+  }
+})

src/type/matrix/utils/matrixAlgorithmSuite.js

@@ -2,6 +2,7 @@ import { factory } from '../../../utils/factory.js'
 import { extend } from '../../../utils/object.js'
 import { createMatAlgo13xDD } from './matAlgo13xDD.js'
 import { createMatAlgo14xDs } from './matAlgo14xDs.js'
+import { createMatAlgo15xAs } from './matAlgo15xAs.js'
 import { broadcast } from './broadcast.js'
 
 const name = 'matrixAlgorithmSuite'
@@ -11,6 +12,7 @@ export const createMatrixAlgorithmSuite = /* #__PURE__ */ factory(
   name, dependencies, ({ typed, matrix }) => {
     const matAlgo13xDD = createMatAlgo13xDD({ typed })
     const matAlgo14xDs = createMatAlgo14xDs({ typed })
+    const matAlgo15xAs = createMatAlgo15xAs()
 
     /**
      * Return a signatures object with the usual boilerplate of
@@ -115,9 +117,9 @@ export const createMatrixAlgorithmSuite = /* #__PURE__ */ factory(
           matrixSignatures[scalar + ', DenseMatrix'] =
             (x, y) => matAlgo14xDs(y, x, elop, true)
           matrixSignatures['Array,' + scalar] =
-            (x, y) => matAlgo14xDs(matrix(x), y, elop, false).valueOf()
+            (x, y) => matAlgo15xAs(x, y, elop, false)
           matrixSignatures[scalar + ', Array'] =
-            (x, y) => matAlgo14xDs(matrix(y), x, elop, true).valueOf()
+            (x, y) => matAlgo15xAs(y, x, elop, true)
         } else {
           matrixSignatures['DenseMatrix,' + scalar] =
             typed.referToSelf(self => (x, y) => {
@@ -129,11 +131,11 @@ export const createMatrixAlgorithmSuite = /* #__PURE__ */ factory(
             })
           matrixSignatures['Array,' + scalar] =
             typed.referToSelf(self => (x, y) => {
-              return matAlgo14xDs(matrix(x), y, self, false).valueOf()
+              return matAlgo15xAs(x, y, self, false)
             })
           matrixSignatures[scalar + ', Array'] =
             typed.referToSelf(self => (x, y) => {
-              return matAlgo14xDs(matrix(y), x, self, true).valueOf()
+              return matAlgo15xAs(y, x, self, true)
             })
         }
       }