Merge pull request #3409 from josdejong/deepMap-perforance-fix-3

Increase performance of `collection` deepMap and deepForEach with DenseMatrices

Author: dvd101x

src/function/matrix/filter.js

@@ -66,8 +66,11 @@ export const createFilter = /* #__PURE__ */ factory(name, dependencies, ({ typed
  */
 function _filterCallback (x, callback) {
   const fastCallback = optimizeCallback(callback, x, 'filter')
+  if (fastCallback.isUnary) {
+    return filter(x, fastCallback.fn)
+  }
   return filter(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    return fastCallback(value, [index], array)
+    return fastCallback.fn(value, [index], array)
   })
 }

src/function/matrix/forEach.js

@@ -52,5 +52,6 @@ export const createForEach = /* #__PURE__ */ factory(name, dependencies, ({ type
  * @private
  */
 function _forEach (array, callback) {
-  deepForEach(array, optimizeCallback(callback, array, name))
+  const fastCallback = optimizeCallback(callback, array, name)
+  deepForEach(array, fastCallback.fn, fastCallback.isUnary)
 }

src/function/matrix/map.js

@@ -151,6 +151,7 @@ export const createMap = /* #__PURE__ */ factory(name, dependencies, ({ typed })
  * @private
  */
   function _mapArray (array, callback) {
-    return deepMap(array, optimizeCallback(callback, array, name))
+    const fastCallback = optimizeCallback(callback, array, name)
+    return deepMap(array, fastCallback.fn, fastCallback.isUnary)
   }
 })

src/type/matrix/DenseMatrix.js

@@ -529,44 +529,55 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
    * Applies a callback function to a reference to each element of the matrix
    * @memberof DenseMatrix
    * @param {Function} callback   The callback function is invoked with three
-   *                              parameters: an array, an integer index to that
-   *                              array, and the Matrix being traversed.
+   *                              parameters: the array containing the element,
+   *                              the index of the element within that array (as an integer),
+   *                              and for non unarry callbacks copy of the current index (as an array of integers).
    */
   DenseMatrix.prototype._forEach = function (callback) {
-    const me = this
-    const s = me.size()
-    const maxDepth = s.length - 1
+    const isUnary = callback.length === 2 // callback has 2 parameters: value, index
+    const maxDepth = this._size.length - 1
 
-    if (maxDepth < 0) {
+    if (maxDepth < 0) return
+
+    if (isUnary) {
+      iterateUnary(this._data)
       return
     }
 
     if (maxDepth === 0) {
-      const thisSize = s[0]
-      for (let i = 0; i < thisSize; i++) {
-        callback(me._data, i, [i])
+      for (let i = 0; i < this._data.length; i++) {
+        callback(this._data, i, [i])
       }
       return
     }
 
-    const index = Array(s.length)
+    const index = new Array(maxDepth + 1)
 
-    function recurse (data, depth) {
-      const thisSize = s[depth]
+    iterate(this._data)
+    function iterate (data, depth = 0) {
       if (depth < maxDepth) {
-        for (let i = 0; i < thisSize; i++) {
+        for (let i = 0; i < data.length; i++) {
           index[depth] = i
-          recurse(data[i], depth + 1)
+          iterate(data[i], depth + 1)
         }
       } else {
-        for (let i = 0; i < thisSize; i++) {
+        for (let i = 0; i < data.length; i++) {
           index[depth] = i
           callback(data, i, index.slice())
         }
       }
     }
-
-    recurse(me._data, 0)
+    function iterateUnary (data, depth = 0) {
+      if (depth < maxDepth) {
+        for (let i = 0; i < data.length; i++) {
+          iterateUnary(data[i], depth + 1)
+        }
+      } else {
+        for (let i = 0; i < data.length; i++) {
+          callback(data, i)
+        }
+      }
+    }
   }
 
   /**
@@ -576,17 +587,21 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
    * @param {Function} callback   The callback function is invoked with three
    *                              parameters: the value of the element, the index
    *                              of the element, and the Matrix being traversed.
+   * @param {boolean} skipZeros   If true, the callback function is invoked only for non-zero entries
+   * @param {boolean} isUnary     If true, the callback function is invoked with one parameter
    *
    * @return {DenseMatrix} matrix
    */
-  DenseMatrix.prototype.map = function (callback) {
+  DenseMatrix.prototype.map = function (callback, skipZeros = false, isUnary = false) {
     const me = this
     const result = new DenseMatrix(me)
-    const fastCallback = optimizeCallback(callback, me._data, 'map')
+    const fastCallback = optimizeCallback(callback, me._data, 'map', isUnary)
 
-    result._forEach(function (arr, i, index) {
-      arr[i] = fastCallback(arr[i], index, me)
-    })
+    const applyCallback = isUnary || fastCallback.isUnary
+      ? (arr, i) => { arr[i] = fastCallback.fn(arr[i]) }
+      : (arr, i, index) => { arr[i] = fastCallback.fn(arr[i], index, me) }
+
+    result._forEach(applyCallback)
 
     return result
   }
@@ -597,13 +612,18 @@ export const createDenseMatrixClass = /* #__PURE__ */ factory(name, dependencies
    * @param {Function} callback   The callback function is invoked with three
    *                              parameters: the value of the element, the index
    *                              of the element, and the Matrix being traversed.
+   * @param {boolean} skipZeros   If true, the callback function is invoked only for non-zero entries
+   * @param {boolean} isUnary     If true, the callback function is invoked with one parameter
    */
-  DenseMatrix.prototype.forEach = function (callback) {
+  DenseMatrix.prototype.forEach = function (callback, skipZeros = false, isUnary = false) {
     const me = this
-    const fastCallback = optimizeCallback(callback, me._data, 'map')
-    me._forEach(function (arr, i, index) {
-      fastCallback(arr[i], index, me)
-    })
+    const fastCallback = optimizeCallback(callback, me._data, 'map', isUnary)
+
+    const applyCallback = isUnary || fastCallback.isUnary
+      ? (arr, i) => { fastCallback.fn(arr[i]) }
+      : (arr, i, index) => { fastCallback.fn(arr[i], index, me) }
+
+    me._forEach(applyCallback)
   }
 
   /**

src/type/matrix/SparseMatrix.js

@@ -857,7 +857,7 @@ export const createSparseMatrixClass = /* #__PURE__ */ factory(name, dependencie
     // invoke callback
     const invoke = function (v, i, j) {
       // invoke callback
-      return fastCallback(v, [i, j], me)
+      return fastCallback.fn(v, [i, j], me)
     }
     // invoke _map
     return _map(this, 0, rows - 1, 0, columns - 1, invoke, skipZeros)
@@ -976,7 +976,8 @@ export const createSparseMatrixClass = /* #__PURE__ */ factory(name, dependencie
           const i = this._index[k]
 
           // value @ k
-          fastCallback(this._values[k], [i, j], me)
+          // TODO apply a non indexed version of algorithm in case fastCallback is not optimized
+          fastCallback.fn(this._values[k], [i, j], me)
         }
       } else {
         // create a cache holding all defined values
@@ -990,7 +991,7 @@ export const createSparseMatrixClass = /* #__PURE__ */ factory(name, dependencie
         // and either read the value or zero
         for (let i = 0; i < rows; i++) {
           const value = (i in values) ? values[i] : 0
-          fastCallback(value, [i, j], me)
+          fastCallback.fn(value, [i, j], me)
         }
       }
     }

src/utils/collection.js

@@ -27,7 +27,7 @@ export function containsCollections (array) {
  */
 export function deepForEach (array, callback) {
   if (isMatrix(array)) {
-    array.forEach(x => callback(x))
+    array.forEach(x => callback(x), false, true)
   } else {
     arrayDeepForEach(array, callback, true)
   }
@@ -48,14 +48,14 @@ export function deepForEach (array, callback) {
 export function deepMap (array, callback, skipZeros) {
   if (!skipZeros) {
     if (isMatrix(array)) {
-      return array.map(x => callback(x))
+      return array.map(x => callback(x), false, true)
     } else {
       return arrayDeepMap(array, callback, true)
     }
   }
   const skipZerosCallback = (x) => x === 0 ? x : callback(x)
   if (isMatrix(array)) {
-    return array.map(x => skipZerosCallback(x))
+    return array.map(x => skipZerosCallback(x), false, true)
   } else {
     return arrayDeepMap(array, skipZerosCallback, true)
   }

src/utils/optimizeCallback.js

@@ -8,13 +8,19 @@ import { typeOf as _typeOf } from './is.js'
  * @param {Function} callback The original callback function to simplify.
  * @param {Array|Matrix} array The array that will be used with the callback function.
  * @param {string} name The name of the function that is using the callback.
+ * @param {boolean} [isUnary=false] If true, the callback function is unary and will be optimized as such.
  * @returns {Function} Returns a simplified version of the callback function.
  */
-export function optimizeCallback (callback, array, name) {
+export function optimizeCallback (callback, array, name, isUnary = false) {
   if (typed.isTypedFunction(callback)) {
-    const firstIndex = (array.isMatrix ? array.size() : arraySize(array)).map(() => 0)
-    const firstValue = array.isMatrix ? array.get(firstIndex) : get(array, firstIndex)
-    const numberOfArguments = _findNumberOfArguments(callback, firstValue, firstIndex, array)
+    let numberOfArguments
+    if (isUnary) {
+      numberOfArguments = 1
+    } else {
+      const firstIndex = (array.isMatrix ? array.size() : arraySize(array)).map(() => 0)
+      const firstValue = array.isMatrix ? array.get(firstIndex) : get(array, firstIndex)
+      numberOfArguments = _findNumberOfArgumentsTyped(callback, firstValue, firstIndex, array)
+    }
     let fastCallback
     if (array.isMatrix && (array.dataType !== 'mixed' && array.dataType !== undefined)) {
       const singleSignature = _findSingleSignatureWithArity(callback, numberOfArguments)
@@ -23,11 +29,18 @@ export function optimizeCallback (callback, array, name) {
       fastCallback = callback
     }
     if (numberOfArguments >= 1 && numberOfArguments <= 3) {
-      return (...args) => _tryFunctionWithArgs(fastCallback, args.slice(0, numberOfArguments), name, callback.name)
+      return {
+        isUnary: numberOfArguments === 1,
+        fn: (...args) => _tryFunctionWithArgs(fastCallback, args.slice(0, numberOfArguments), name, callback.name)
+      }
     }
-    return (...args) => _tryFunctionWithArgs(fastCallback, args, name, callback.name)
+    return { isUnary: false, fn: (...args) => _tryFunctionWithArgs(fastCallback, args, name, callback.name) }
+  }
+  if (isUnary === undefined) {
+    return { isUnary: _findIfCallbackIsUnary(callback), fn: callback }
+  } else {
+    return { isUnary, fn: callback }
   }
-  return callback
 }
 
 function _findSingleSignatureWithArity (callback, arity) {
@@ -42,7 +55,33 @@ function _findSingleSignatureWithArity (callback, arity) {
   }
 }
 
-function _findNumberOfArguments (callback, value, index, array) {
+/**
+ * Determines if a given callback function is unary (i.e., takes exactly one argument).
+ *
+ * This function checks the following conditions to determine if the callback is unary:
+ * 1. The callback function should have exactly one parameter.
+ * 2. The callback function should not use the `arguments` object.
+ * 3. The callback function should not use rest parameters (`...`).
+ * If in doubt, this function shall return `false` to be safe
+ *
+ * @param {Function} callback - The callback function to be checked.
+ * @returns {boolean} - Returns `true` if the callback is unary, otherwise `false`.
+ */
+function _findIfCallbackIsUnary (callback) {
+  if (callback.length !== 1) return false
+
+  const callbackStr = callback.toString()
+  // Check if the callback function uses `arguments`
+  if (/arguments/.test(callbackStr)) return false
+
+  // Extract the parameters of the callback function
+  const paramsStr = callbackStr.match(/\(.*?\)/)
+  // Check if the callback function uses rest parameters
+  if (/\.\.\./.test(paramsStr)) return false
+  return true
+}
+
+function _findNumberOfArgumentsTyped (callback, value, index, array) {
   const testArgs = [value, index, array]
   for (let i = 3; i > 0; i--) {
     const args = testArgs.slice(0, i)