added option to flatten arrays with homogeneous size

Author: dvd101x

src/function/matrix/flatten.js

@@ -1,4 +1,4 @@
-import { flatten as flattenArray } from '../../utils/array.js'
+import { flatten as flattenArray, arraySize, validate } from '../../utils/array.js'
 import { factory } from '../../utils/factory.js'
 
 const name = 'flatten'
@@ -26,13 +26,17 @@ export const createFlatten = /* #__PURE__ */ factory(name, dependencies, ({ type
    */
   return typed(name, {
     Array: function (x) {
-      return flattenArray(x)
+      try {
+        return flattenArray(x, validate(x, arraySize(x)))
+      } catch {
+        return flattenArray(x)
+      }
     },
 
     Matrix: function (x) {
       // Return the same matrix type as x (Dense or Sparse Matrix)
       // Return the same data type as x
-      return x.create(flattenArray(x.toArray()), x.datatype())
+      return x.create(flattenArray(x.toArray(), true), x.datatype())
     }
   })
 })

src/utils/array.js

@@ -465,40 +465,60 @@ function _unsqueeze (array, dims, dim) {
  * Flatten a multi dimensional array, put all elements in a one dimensional
  * array
  * @param {Array} array   A multi dimensional array
+ * @param {boolean} [isHomogeneous=false] Indicates if the size is homogeneous (like a valid matrix)
  * @return {Array}        The flattened array (1 dimensional)
  */
-export function flatten (array) {
+export function flatten (array, isHomogeneous = false) {
   if (!Array.isArray(array)) {
     // if not an array, return as is
     return array
   }
-  if (typeof Array.prototype.flat === 'function') {
-    return array.flat(Infinity)
+  if (isHomogeneous) {
+    return _flattenHomogeneous(array)
   } else {
-    // TODO: once Array.prototype.flat is supported in all browsers, remove this and the _flatten function
-    return _flatten(array)
+    if (typeof Array.prototype.flat === 'function') {
+      return array.flat(Infinity)
+    } else {
+      return _flattenFallback(array)
+    }
   }
 
-  function _flatten (array) {
+  function _flattenFallback (arr) {
+    // remove this when Array.prototype.flat is broadly supported
     const flat = []
-
-    function flattenHelper (value) {
+    _recurse(arr)
+    return flat
+    function _recurse (value) {
       if (Array.isArray(value)) {
         const len = value.length
         for (let i = 0; i < len; i++) {
-          flattenHelper(value[i]) // traverse through sub-arrays recursively
+          _recurse(value[i]) // traverse through sub-arrays recursively
         }
       } else {
         flat.push(value)
       }
     }
+  }
 
-    const len = array.length
-    for (let i = 0; i < len; i++) {
-      flattenHelper(array[i])
-    }
-
+  function _flattenHomogeneous (arr) {
+    const flat = []
+    _recurse(arr)
     return flat
+
+    function _recurse (value) {
+      if (Array.isArray(value)) {
+        const len = value.length
+        if (Array.isArray(value[0])) {
+          for (let i = 0; i < len; i++) {
+            _recurse(value[i]) // traverse through sub-arrays recursively
+          }
+        } else {
+          for (let i = 0; i < len; i++) {
+            flat.push(value[i]) // traverse through sub-arrays without recursion
+          }
+        }
+      }
+    }
   }
 }