mathjs 8.1.0 → 12.2.1

package/lib/cjs/function/matrix/expm.js

@@ -4,23 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createExpm = void 0;
-
 var _is = require("../../utils/is.js");
-
 var _string = require("../../utils/string.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'expm';
 var dependencies = ['typed', 'abs', 'add', 'identity', 'inv', 'multiply'];
-var createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createExpm = exports.createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      abs = _ref.abs,
-      add = _ref.add,
-      identity = _ref.identity,
-      inv = _ref.inv,
-      multiply = _ref.multiply;
-
+    abs = _ref.abs,
+    add = _ref.add,
+    identity = _ref.identity,
+    inv = _ref.inv,
+    multiply = _ref.multiply;
   /**
    * Compute the matrix exponential, expm(A) = e^A. The matrix must be square.
    * Not to be confused with exp(a), which performs element-wise
@@ -50,94 +45,89 @@ var createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
     Matrix: function Matrix(A) {
       // Check matrix size
       var size = A.size();
-
       if (size.length !== 2 || size[0] !== size[1]) {
         throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
       }
+      var n = size[0];
 
-      var n = size[0]; // Desired accuracy of the approximant (The actual accuracy
+      // Desired accuracy of the approximant (The actual accuracy
       // will be affected by round-off error)
+      var eps = 1e-15;
 
-      var eps = 1e-15; // The Padé approximant is not so accurate when the values of A
+      // The Padé approximant is not so accurate when the values of A
       // are "large", so scale A by powers of two. Then compute the
       // exponential, and square the result repeatedly according to
       // the identity e^A = (e^(A/m))^m
+
       // Compute infinity-norm of A, ||A||, to see how "big" it is
+      var infNorm = infinityNorm(A);
 
-      var infNorm = infinityNorm(A); // Find the optimal scaling factor and number of terms in the
+      // Find the optimal scaling factor and number of terms in the
       // Padé approximant to reach the desired accuracy
-
       var params = findParams(infNorm, eps);
       var q = params.q;
-      var j = params.j; // The Pade approximation to e^A is:
+      var j = params.j;
+
+      // The Pade approximation to e^A is:
       // Rqq(A) = Dqq(A) ^ -1 * Nqq(A)
       // where
       // Nqq(A) = sum(i=0, q, (2q-i)!p! / [ (2q)!i!(q-i)! ] A^i
       // Dqq(A) = sum(i=0, q, (2q-i)!q! / [ (2q)!i!(q-i)! ] (-A)^i
-      // Scale A by 1 / 2^j
 
-      var Apos = multiply(A, Math.pow(2, -j)); // The i=0 term is just the identity matrix
+      // Scale A by 1 / 2^j
+      var Apos = multiply(A, Math.pow(2, -j));
 
+      // The i=0 term is just the identity matrix
       var N = identity(n);
-      var D = identity(n); // Initialization (i=0)
+      var D = identity(n);
 
-      var factor = 1; // Initialization (i=1)
+      // Initialization (i=0)
+      var factor = 1;
 
+      // Initialization (i=1)
       var AposToI = Apos; // Cloning not necessary
-
       var alternate = -1;
-
       for (var i = 1; i <= q; i++) {
         if (i > 1) {
           AposToI = multiply(AposToI, Apos);
           alternate = -alternate;
         }
-
         factor = factor * (q - i + 1) / ((2 * q - i + 1) * i);
         N = add(N, multiply(factor, AposToI));
         D = add(D, multiply(factor * alternate, AposToI));
       }
+      var R = multiply(inv(D), N);
 
-      var R = multiply(inv(D), N); // Square j times
-
+      // Square j times
       for (var _i = 0; _i < j; _i++) {
         R = multiply(R, R);
       }
-
       return (0, _is.isSparseMatrix)(A) ? A.createSparseMatrix(R) : R;
     }
   });
-
   function infinityNorm(A) {
     var n = A.size()[0];
     var infNorm = 0;
-
     for (var i = 0; i < n; i++) {
       var rowSum = 0;
-
       for (var j = 0; j < n; j++) {
         rowSum += abs(A.get([i, j]));
       }
-
       infNorm = Math.max(rowSum, infNorm);
     }
-
     return infNorm;
   }
+
   /**
    * Find the best parameters for the Pade approximant given
    * the matrix norm and desired accuracy. Returns the first acceptable
    * combination in order of increasing computational load.
    */
-
-
   function findParams(infNorm, eps) {
     var maxSearchSize = 30;
-
     for (var k = 0; k < maxSearchSize; k++) {
       for (var q = 0; q <= k; q++) {
         var j = k - q;
-
         if (errorEstimate(infNorm, q, j) < eps) {
           return {
             q: q,
@@ -146,30 +136,23 @@ var createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, functi
         }
       }
     }
-
     throw new Error('Could not find acceptable parameters to compute the matrix exponential (try increasing maxSearchSize in expm.js)');
   }
+
   /**
    * Returns the estimated error of the Pade approximant for the given
    * parameters.
    */
-
-
   function errorEstimate(infNorm, q, j) {
     var qfac = 1;
-
     for (var i = 2; i <= q; i++) {
       qfac *= i;
     }
-
     var twoqfac = qfac;
-
     for (var _i2 = q + 1; _i2 <= 2 * q; _i2++) {
       twoqfac *= _i2;
     }
-
     var twoqp1fac = twoqfac * (2 * q + 1);
     return 8.0 * Math.pow(infNorm / Math.pow(2, j), 2 * q) * qfac * qfac / (twoqfac * twoqp1fac);
   }
-});
-exports.createExpm = createExpm;
+});

package/lib/cjs/function/matrix/fft.js

@@ -0,0 +1,152 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFft = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'fft';
+var dependencies = ['typed', 'matrix', 'addScalar', 'multiplyScalar', 'divideScalar', 'exp', 'tau', 'i', 'dotDivide', 'conj', 'pow', 'ceil', 'log2'];
+var createFft = exports.createFft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    addScalar = _ref.addScalar,
+    multiplyScalar = _ref.multiplyScalar,
+    divideScalar = _ref.divideScalar,
+    exp = _ref.exp,
+    tau = _ref.tau,
+    I = _ref.i,
+    dotDivide = _ref.dotDivide,
+    conj = _ref.conj,
+    pow = _ref.pow,
+    ceil = _ref.ceil,
+    log2 = _ref.log2;
+  /**
+   * Calculate N-dimensional fourier transform
+   *
+   * Syntax:
+   *
+   *     math.fft(arr)
+   *
+   * Examples:
+   *
+   *    math.fft([[1, 0], [1, 0]]) // returns [[{re:2, im:0}, {re:2, im:0}], [{re:0, im:0}, {re:0, im:0}]]
+   *
+   *
+   * See Also:
+   *
+   *      ifft
+   *
+   * @param {Array | Matrix} arr    An array or matrix
+   * @return {Array | Matrix}       N-dimensional fourier transformation of the array
+   */
+  return typed(name, {
+    Array: _ndFft,
+    Matrix: function Matrix(matrix) {
+      return matrix.create(_ndFft(matrix.toArray()));
+    }
+  });
+
+  /**
+   * Perform an N-dimensional Fourier transform
+   *
+   * @param {Array} arr      The array
+   * @return {Array}         resulting array
+   */
+  function _ndFft(arr) {
+    var size = (0, _array.arraySize)(arr);
+    if (size.length === 1) return _fft(arr, size[0]);
+    // ndFft along dimension 1,...,N-1 then 1dFft along dimension 0
+    return _1dFft(arr.map(function (slice) {
+      return _ndFft(slice, size.slice(1));
+    }), 0);
+  }
+
+  /**
+   * Perform an 1-dimensional Fourier transform
+   *
+   * @param {Array} arr      The array
+   * @param {number} dim     dimension of the array to perform on
+   * @return {Array}         resulting array
+   */
+  function _1dFft(arr, dim) {
+    var size = (0, _array.arraySize)(arr);
+    if (dim !== 0) return new Array(size[0]).fill(0).map(function (_, i) {
+      return _1dFft(arr[i], dim - 1);
+    });
+    if (size.length === 1) return _fft(arr);
+    function _transpose(arr) {
+      // Swap first 2 dimensions
+      var size = (0, _array.arraySize)(arr);
+      return new Array(size[1]).fill(0).map(function (_, j) {
+        return new Array(size[0]).fill(0).map(function (_, i) {
+          return arr[i][j];
+        });
+      });
+    }
+    return _transpose(_1dFft(_transpose(arr), 1));
+  }
+  /**
+   * Perform an 1-dimensional non-power-of-2 Fourier transform using Chirp-Z Transform
+   *
+   * @param {Array} arr      The array
+   * @return {Array}         resulting array
+   */
+  function _czt(arr) {
+    var n = arr.length;
+    var w = exp(divideScalar(multiplyScalar(-1, multiplyScalar(I, tau)), n));
+    var chirp = [];
+    for (var i = 1 - n; i < n; i++) {
+      chirp.push(pow(w, divideScalar(pow(i, 2), 2)));
+    }
+    var N2 = pow(2, ceil(log2(n + n - 1)));
+    var xp = [].concat((0, _toConsumableArray2["default"])(new Array(n).fill(0).map(function (_, i) {
+      return multiplyScalar(arr[i], chirp[n - 1 + i]);
+    })), (0, _toConsumableArray2["default"])(new Array(N2 - n).fill(0)));
+    var ichirp = [].concat((0, _toConsumableArray2["default"])(new Array(n + n - 1).fill(0).map(function (_, i) {
+      return divideScalar(1, chirp[i]);
+    })), (0, _toConsumableArray2["default"])(new Array(N2 - (n + n - 1)).fill(0)));
+    var fftXp = _fft(xp);
+    var fftIchirp = _fft(ichirp);
+    var fftProduct = new Array(N2).fill(0).map(function (_, i) {
+      return multiplyScalar(fftXp[i], fftIchirp[i]);
+    });
+    var ifftProduct = dotDivide(conj(_ndFft(conj(fftProduct))), N2);
+    var ret = [];
+    for (var _i = n - 1; _i < n + n - 1; _i++) {
+      ret.push(multiplyScalar(ifftProduct[_i], chirp[_i]));
+    }
+    return ret;
+  }
+  /**
+   * Perform an 1-dimensional Fourier transform
+   *
+   * @param {Array} arr      The array
+   * @return {Array}         resulting array
+   */
+  function _fft(arr) {
+    var len = arr.length;
+    if (len === 1) return [arr[0]];
+    if (len % 2 === 0) {
+      var ret = [].concat((0, _toConsumableArray2["default"])(_fft(arr.filter(function (_, i) {
+        return i % 2 === 0;
+      }), len / 2)), (0, _toConsumableArray2["default"])(_fft(arr.filter(function (_, i) {
+        return i % 2 === 1;
+      }), len / 2)));
+      for (var k = 0; k < len / 2; k++) {
+        var p = ret[k];
+        var q = multiplyScalar(ret[k + len / 2], exp(multiplyScalar(multiplyScalar(tau, I), divideScalar(-k, len))));
+        ret[k] = addScalar(p, q);
+        ret[k + len / 2] = addScalar(p, multiplyScalar(-1, q));
+      }
+      return ret;
+    } else {
+      // use chirp-z transform for non-power-of-2 FFT
+      return _czt(arr);
+    }
+    // throw new Error('Can only calculate FFT of power-of-two size')
+  }
+});

package/lib/cjs/function/matrix/filter.js

@@ -4,18 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createFilter = void 0;
-
+var _applyCallback = require("../../utils/applyCallback.js");
 var _array = require("../../utils/array.js");
-
-var _function = require("../../utils/function.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'filter';
 var dependencies = ['typed'];
-var createFilter = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createFilter = exports.createFilter = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
-
   /**
    * Filter the items in an array or one dimensional matrix.
    *
@@ -56,6 +51,7 @@ var createFilter = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
     }
   });
 });
+
 /**
  * Filter values in a callback given a callback function
  * @param {Array} x
@@ -63,21 +59,9 @@ var createFilter = /* #__PURE__ */(0, _factory.factory)(name, dependencies, func
  * @return {Array} Returns the filtered array
  * @private
  */
-
-exports.createFilter = createFilter;
-
 function _filterCallback(x, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = (0, _function.maxArgumentCount)(callback);
   return (0, _array.filter)(x, function (value, index, array) {
     // invoke the callback function with the right number of arguments
-    if (args === 1) {
-      return callback(value);
-    } else if (args === 2) {
-      return callback(value, [index]);
-    } else {
-      // 3 or -1
-      return callback(value, [index], array);
-    }
+    return (0, _applyCallback.applyCallback)(callback, value, [index], array, 'filter');
   });
 }

package/lib/cjs/function/matrix/flatten.js

@@ -4,21 +4,16 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createFlatten = void 0;
-
-var _object = require("../../utils/object.js");
-
 var _array = require("../../utils/array.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'flatten';
 var dependencies = ['typed', 'matrix'];
-var createFlatten = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createFlatten = exports.createFlatten = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      matrix = _ref.matrix;
-
+    matrix = _ref.matrix;
   /**
-   * Flatten a multi dimensional matrix into a single dimensional matrix.
+   * Flatten a multidimensional matrix into a single dimensional matrix.
+   * A new matrix is returned, the original matrix is left untouched.
    *
    * Syntax:
    *
@@ -37,13 +32,12 @@ var createFlatten = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
    */
   return typed(name, {
     Array: function Array(x) {
-      return (0, _array.flatten)((0, _object.clone)(x));
+      return (0, _array.flatten)(x);
     },
     Matrix: function Matrix(x) {
-      var flat = (0, _array.flatten)((0, _object.clone)(x.toArray())); // TODO: return the same matrix type as x
-
+      var flat = (0, _array.flatten)(x.toArray());
+      // TODO: return the same matrix type as x (Dense or Sparse Matrix)
       return matrix(flat);
     }
   });
-});
-exports.createFlatten = createFlatten;
+});

package/lib/cjs/function/matrix/forEach.js

@@ -4,18 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createForEach = void 0;
-
-var _function = require("../../utils/function.js");
-
+var _applyCallback = require("../../utils/applyCallback.js");
 var _array = require("../../utils/array.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'forEach';
 var dependencies = ['typed'];
-var createForEach = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createForEach = exports.createForEach = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
-
   /**
    * Iterate over all elements of a matrix/array, and executes the given callback function.
    *
@@ -42,23 +37,18 @@ var createForEach = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fun
   return typed(name, {
     'Array, function': _forEach,
     'Matrix, function': function MatrixFunction(x, callback) {
-      return x.forEach(callback);
+      x.forEach(callback);
     }
   });
 });
+
 /**
- * forEach for a multi dimensional array
+ * forEach for a multidimensional array
  * @param {Array} array
  * @param {Function} callback
  * @private
  */
-
-exports.createForEach = createForEach;
-
 function _forEach(array, callback) {
-  // figure out what number of arguments the callback function expects
-  var args = (0, _function.maxArgumentCount)(callback);
-
   var recurse = function recurse(value, index) {
     if (Array.isArray(value)) {
       (0, _array.forEach)(value, function (child, i) {
@@ -67,16 +57,8 @@ function _forEach(array, callback) {
       });
     } else {
       // invoke the callback function with the right number of arguments
-      if (args === 1) {
-        callback(value);
-      } else if (args === 2) {
-        callback(value, index);
-      } else {
-        // 3 or -1
-        callback(value, index, array);
-      }
+      return (0, _applyCallback.applyCallback)(callback, value, index, array, 'forEach');
     }
   };
-
   recurse(array, []);
 }

package/lib/cjs/function/matrix/getMatrixDataType.js

@@ -4,18 +4,13 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createGetMatrixDataType = void 0;
-
 var _factory = require("../../utils/factory.js");
-
 var _array = require("../../utils/array.js");
-
 var _is = require("../../utils/is.js");
-
 var name = 'getMatrixDataType';
 var dependencies = ['typed'];
-var createGetMatrixDataType = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createGetMatrixDataType = exports.createGetMatrixDataType = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed;
-
   /**
    * Find the data type of all elements in a matrix or array,
    * for example 'number' if all items are a number and 'Complex' if all values
@@ -30,7 +25,7 @@ var createGetMatrixDataType = /* #__PURE__ */(0, _factory.factory)(name, depende
    *
    *    const x = [ [1, 2, 3], [4, 5, 6] ]
    *    const mixedX = [ [1, true], [2, 3] ]
-   *    const fractionX = [ [math.fraction(1, 3)], [math.fraction(1, 3] ]
+   *    const fractionX = [ [math.fraction(1, 3)], [math.fraction(1, 3)] ]
    *    const unitX = [ [math.unit('5cm')], [math.unit('5cm')] ]
    *    const bigNumberX = [ [math.bignumber(1)], [math.bignumber(0)] ]
    *    const sparse = math.sparse(x)
@@ -58,5 +53,4 @@ var createGetMatrixDataType = /* #__PURE__ */(0, _factory.factory)(name, depende
       return x.getDataType();
     }
   });
-});
-exports.createGetMatrixDataType = createGetMatrixDataType;
+});

package/lib/cjs/function/matrix/identity.js

@@ -4,25 +4,19 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createIdentity = void 0;
-
 var _is = require("../../utils/is.js");
-
 var _array = require("../../utils/array.js");
-
 var _number = require("../../utils/number.js");
-
 var _factory = require("../../utils/factory.js");
-
 var name = 'identity';
 var dependencies = ['typed', 'config', 'matrix', 'BigNumber', 'DenseMatrix', 'SparseMatrix'];
-var createIdentity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+var createIdentity = exports.createIdentity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
-      config = _ref.config,
-      matrix = _ref.matrix,
-      BigNumber = _ref.BigNumber,
-      DenseMatrix = _ref.DenseMatrix,
-      SparseMatrix = _ref.SparseMatrix;
-
+    config = _ref.config,
+    matrix = _ref.matrix,
+    BigNumber = _ref.BigNumber,
+    DenseMatrix = _ref.DenseMatrix,
+    SparseMatrix = _ref.SparseMatrix;
   /**
    * Create a 2-dimensional identity matrix with size m x n or n x n.
    * The matrix has ones on the diagonal and zeros elsewhere.
@@ -85,22 +79,19 @@ var createIdentity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
       return _identityVector(size.valueOf(), format);
     }
   });
-
   function _identityVector(size, format) {
     switch (size.length) {
       case 0:
         return format ? matrix(format) : [];
-
       case 1:
         return _identity(size[0], size[0], format);
-
       case 2:
         return _identity(size[0], size[1], format);
-
       default:
         throw new Error('Vector containing two values expected');
     }
   }
+
   /**
    * Create an identity matrix
    * @param {number | BigNumber} rows
@@ -109,49 +100,41 @@ var createIdentity = /* #__PURE__ */(0, _factory.factory)(name, dependencies, fu
    * @returns {Matrix}
    * @private
    */
-
-
   function _identity(rows, cols, format) {
     // BigNumber constructor with the right precision
     var Big = (0, _is.isBigNumber)(rows) || (0, _is.isBigNumber)(cols) ? BigNumber : null;
     if ((0, _is.isBigNumber)(rows)) rows = rows.toNumber();
     if ((0, _is.isBigNumber)(cols)) cols = cols.toNumber();
-
     if (!(0, _number.isInteger)(rows) || rows < 1) {
       throw new Error('Parameters in function identity must be positive integers');
     }
-
     if (!(0, _number.isInteger)(cols) || cols < 1) {
       throw new Error('Parameters in function identity must be positive integers');
     }
-
     var one = Big ? new BigNumber(1) : 1;
     var defaultValue = Big ? new Big(0) : 0;
-    var size = [rows, cols]; // check we need to return a matrix
+    var size = [rows, cols];
 
+    // check we need to return a matrix
     if (format) {
       // create diagonal matrix (use optimized implementation for storage format)
       if (format === 'sparse') {
         return SparseMatrix.diagonal(size, one, 0, defaultValue);
       }
-
       if (format === 'dense') {
         return DenseMatrix.diagonal(size, one, 0, defaultValue);
       }
-
       throw new TypeError("Unknown matrix type \"".concat(format, "\""));
-    } // create and resize array
-
-
-    var res = (0, _array.resize)([], size, defaultValue); // fill in ones on the diagonal
-
-    var minimum = rows < cols ? rows : cols; // fill diagonal
+    }
 
+    // create and resize array
+    var res = (0, _array.resize)([], size, defaultValue);
+    // fill in ones on the diagonal
+    var minimum = rows < cols ? rows : cols;
+    // fill diagonal
     for (var d = 0; d < minimum; d++) {
       res[d][d] = one;
     }
-
     return res;
   }
-});
-exports.createIdentity = createIdentity;
+});

package/lib/cjs/function/matrix/ifft.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createIfft = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var name = 'ifft';
+var dependencies = ['typed', 'fft', 'dotDivide', 'conj'];
+var createIfft = exports.createIfft = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    fft = _ref.fft,
+    dotDivide = _ref.dotDivide,
+    conj = _ref.conj;
+  /**
+   * Calculate N-dimensional inverse fourier transform
+   *
+   * Syntax:
+   *
+   *     math.ifft(arr)
+   *
+   * Examples:
+   *
+   *    math.ifft([[2, 2], [0, 0]]) // returns [[{re:1, im:0}, {re:0, im:0}], [{re:1, im:0}, {re:0, im:0}]]
+   *
+   * See Also:
+   *
+   *      fft
+   *
+   * @param {Array | Matrix} arr    An array or matrix
+   * @return {Array | Matrix}       N-dimensional fourier transformation of the array
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(arr) {
+      var size = (0, _is.isMatrix)(arr) ? arr.size() : (0, _array.arraySize)(arr);
+      return dotDivide(conj(fft(conj(arr))), size.reduce(function (acc, curr) {
+        return acc * curr;
+      }, 1));
+    }
+  });
+});