mathjs-min 11.7.2

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCount = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'count';
+var dependencies = ['typed', 'size', 'prod'];
+var createCount = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    size = _ref.size,
+    prod = _ref.prod;
+  /**
+   * Count the number of elements of a matrix, array or string.
+   *
+   * Syntax:
+   *
+   *     math.count(x)
+   *
+   * Examples:
+   *
+   *     math.count('hello world')        // returns 11
+   *     const A = [[1, 2, 3], [4, 5, 6]]
+   *     math.count(A)                    // returns 6
+   *     math.count(math.range(1,6))      // returns 5
+   *
+   * See also:
+   *
+   *     size
+   *
+   * @param {string | Array | Matrix} x  A matrix or string
+   * @return {number} An integer with the elements in `x`.
+   */
+  return typed(name, {
+    string: function string(x) {
+      return x.length;
+    },
+    'Matrix | Array': function MatrixArray(x) {
+      return prod(size(x));
+    }
+  });
+});
+exports.createCount = createCount;

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

@@ -0,0 +1,86 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCross = void 0;
+var _array = require("../../utils/array.js");
+var _factory = require("../../utils/factory.js");
+var name = 'cross';
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply'];
+var createCross = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    subtract = _ref.subtract,
+    multiply = _ref.multiply;
+  /**
+   * Calculate the cross product for two vectors in three dimensional space.
+   * The cross product of `A = [a1, a2, a3]` and `B = [b1, b2, b3]` is defined
+   * as:
+   *
+   *    cross(A, B) = [
+   *      a2 * b3 - a3 * b2,
+   *      a3 * b1 - a1 * b3,
+   *      a1 * b2 - a2 * b1
+   *    ]
+   *
+   * If one of the input vectors has a dimension greater than 1, the output
+   * vector will be a 1x3 (2-dimensional) matrix.
+   *
+   * Syntax:
+   *
+   *    math.cross(x, y)
+   *
+   * Examples:
+   *
+   *    math.cross([1, 1, 0],   [0, 1, 1])       // Returns [1, -1, 1]
+   *    math.cross([3, -3, 1],  [4, 9, 2])       // Returns [-15, -2, 39]
+   *    math.cross([2, 3, 4],   [5, 6, 7])       // Returns [-3, 6, -3]
+   *    math.cross([[1, 2, 3]], [[4], [5], [6]]) // Returns [[-3, 6, -3]]
+   *
+   * See also:
+   *
+   *    dot, multiply
+   *
+   * @param  {Array | Matrix} x   First vector
+   * @param  {Array | Matrix} y   Second vector
+   * @return {Array | Matrix}     Returns the cross product of `x` and `y`
+   */
+  return typed(name, {
+    'Matrix, Matrix': function MatrixMatrix(x, y) {
+      return matrix(_cross(x.toArray(), y.toArray()));
+    },
+    'Matrix, Array': function MatrixArray(x, y) {
+      return matrix(_cross(x.toArray(), y));
+    },
+    'Array, Matrix': function ArrayMatrix(x, y) {
+      return matrix(_cross(x, y.toArray()));
+    },
+    'Array, Array': _cross
+  });
+
+  /**
+   * Calculate the cross product for two arrays
+   * @param {Array} x  First vector
+   * @param {Array} y  Second vector
+   * @returns {Array} Returns the cross product of x and y
+   * @private
+   */
+  function _cross(x, y) {
+    var highestDimension = Math.max((0, _array.arraySize)(x).length, (0, _array.arraySize)(y).length);
+    x = (0, _array.squeeze)(x);
+    y = (0, _array.squeeze)(y);
+    var xSize = (0, _array.arraySize)(x);
+    var ySize = (0, _array.arraySize)(y);
+    if (xSize.length !== 1 || ySize.length !== 1 || xSize[0] !== 3 || ySize[0] !== 3) {
+      throw new RangeError('Vectors with length 3 expected ' + '(Size A = [' + xSize.join(', ') + '], B = [' + ySize.join(', ') + '])');
+    }
+    var product = [subtract(multiply(x[1], y[2]), multiply(x[2], y[1])), subtract(multiply(x[2], y[0]), multiply(x[0], y[2])), subtract(multiply(x[0], y[1]), multiply(x[1], y[0]))];
+    if (highestDimension > 1) {
+      return [product];
+    } else {
+      return product;
+    }
+  }
+});
+exports.createCross = createCross;

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

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCtranspose = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'ctranspose';
+var dependencies = ['typed', 'transpose', 'conj'];
+var createCtranspose = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    transpose = _ref.transpose,
+    conj = _ref.conj;
+  /**
+   * Transpose and complex conjugate a matrix. All values of the matrix are
+   * reflected over its main diagonal and then the complex conjugate is
+   * taken. This is equivalent to complex conjugation for scalars and
+   * vectors.
+   *
+   * Syntax:
+   *
+   *     math.ctranspose(x)
+   *
+   * Examples:
+   *
+   *     const A = [[1, 2, 3], [4, 5, math.complex(6,7)]]
+   *     math.ctranspose(A)               // returns [[1, 4], [2, 5], [3, {re:6,im:7}]]
+   *
+   * See also:
+   *
+   *     transpose, diag, inv, subset, squeeze
+   *
+   * @param {Array | Matrix} x  Matrix to be ctransposed
+   * @return {Array | Matrix}   The ctransposed matrix
+   */
+  return typed(name, {
+    any: function any(x) {
+      return conj(transpose(x));
+    }
+  });
+});
+exports.createCtranspose = createCtranspose;

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

@@ -0,0 +1,150 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDet = void 0;
+var _is = require("../../utils/is.js");
+var _object = require("../../utils/object.js");
+var _string = require("../../utils/string.js");
+var _factory = require("../../utils/factory.js");
+var name = 'det';
+var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
+var createDet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    subtract = _ref.subtract,
+    multiply = _ref.multiply,
+    divideScalar = _ref.divideScalar,
+    isZero = _ref.isZero,
+    unaryMinus = _ref.unaryMinus;
+  /**
+   * Calculate the determinant of a matrix.
+   *
+   * Syntax:
+   *
+   *    math.det(x)
+   *
+   * Examples:
+   *
+   *    math.det([[1, 2], [3, 4]]) // returns -2
+   *
+   *    const A = [
+   *      [-2, 2, 3],
+   *      [-1, 1, 3],
+   *      [2, 0, -1]
+   *    ]
+   *    math.det(A) // returns 6
+   *
+   * See also:
+   *
+   *    inv
+   *
+   * @param {Array | Matrix} x  A matrix
+   * @return {number} The determinant of `x`
+   */
+  return typed(name, {
+    any: function any(x) {
+      return (0, _object.clone)(x);
+    },
+    'Array | Matrix': function det(x) {
+      var size;
+      if ((0, _is.isMatrix)(x)) {
+        size = x.size();
+      } else if (Array.isArray(x)) {
+        x = matrix(x);
+        size = x.size();
+      } else {
+        // a scalar
+        size = [];
+      }
+      switch (size.length) {
+        case 0:
+          // scalar
+          return (0, _object.clone)(x);
+        case 1:
+          // vector
+          if (size[0] === 1) {
+            return (0, _object.clone)(x.valueOf()[0]);
+          }
+          if (size[0] === 0) {
+            return 1; // det of an empty matrix is per definition 1
+          } else {
+            throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
+          }
+        case 2:
+          {
+            // two-dimensional array
+            var rows = size[0];
+            var cols = size[1];
+            if (rows === cols) {
+              return _det(x.clone().valueOf(), rows, cols);
+            }
+            if (cols === 0) {
+              return 1; // det of an empty matrix is per definition 1
+            } else {
+              throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
+            }
+          }
+        default:
+          // multi dimensional array
+          throw new RangeError('Matrix must be two dimensional ' + '(size: ' + (0, _string.format)(size) + ')');
+      }
+    }
+  });
+
+  /**
+   * Calculate the determinant of a matrix
+   * @param {Array[]} matrix  A square, two dimensional matrix
+   * @param {number} rows     Number of rows of the matrix (zero-based)
+   * @param {number} cols     Number of columns of the matrix (zero-based)
+   * @returns {number} det
+   * @private
+   */
+  function _det(matrix, rows, cols) {
+    if (rows === 1) {
+      // this is a 1 x 1 matrix
+      return (0, _object.clone)(matrix[0][0]);
+    } else if (rows === 2) {
+      // this is a 2 x 2 matrix
+      // the determinant of [a11,a12;a21,a22] is det = a11*a22-a21*a12
+      return subtract(multiply(matrix[0][0], matrix[1][1]), multiply(matrix[1][0], matrix[0][1]));
+    } else {
+      // Bareiss algorithm
+      // this algorithm have same complexity as LUP decomposition (O(n^3))
+      // but it preserve precision of floating point more relative to the LUP decomposition
+      var negated = false;
+      var rowIndices = new Array(rows).fill(0).map(function (_, i) {
+        return i;
+      }); // matrix index of row i
+      for (var k = 0; k < rows; k++) {
+        var k_ = rowIndices[k];
+        if (isZero(matrix[k_][k])) {
+          var _k = void 0;
+          for (_k = k + 1; _k < rows; _k++) {
+            if (!isZero(matrix[rowIndices[_k]][k])) {
+              k_ = rowIndices[_k];
+              rowIndices[_k] = rowIndices[k];
+              rowIndices[k] = k_;
+              negated = !negated;
+              break;
+            }
+          }
+          if (_k === rows) return matrix[k_][k]; // some zero of the type
+        }
+
+        var piv = matrix[k_][k];
+        var piv_ = k === 0 ? 1 : matrix[rowIndices[k - 1]][k - 1];
+        for (var i = k + 1; i < rows; i++) {
+          var i_ = rowIndices[i];
+          for (var j = k + 1; j < rows; j++) {
+            matrix[i_][j] = divideScalar(subtract(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
+          }
+        }
+      }
+      var det = matrix[rowIndices[rows - 1]][rows - 1];
+      return negated ? unaryMinus(det) : det;
+    }
+  }
+});
+exports.createDet = createDet;

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

@@ -0,0 +1,160 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDiag = 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 = 'diag';
+var dependencies = ['typed', 'matrix', 'DenseMatrix', 'SparseMatrix'];
+var createDiag = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    DenseMatrix = _ref.DenseMatrix,
+    SparseMatrix = _ref.SparseMatrix;
+  /**
+   * Create a diagonal matrix or retrieve the diagonal of a matrix
+   *
+   * When `x` is a vector, a matrix with vector `x` on the diagonal will be returned.
+   * When `x` is a two dimensional matrix, the matrixes `k`th diagonal will be returned as vector.
+   * When k is positive, the values are placed on the super diagonal.
+   * When k is negative, the values are placed on the sub diagonal.
+   *
+   * Syntax:
+   *
+   *     math.diag(X)
+   *     math.diag(X, format)
+   *     math.diag(X, k)
+   *     math.diag(X, k, format)
+   *
+   * Examples:
+   *
+   *     // create a diagonal matrix
+   *     math.diag([1, 2, 3])      // returns [[1, 0, 0], [0, 2, 0], [0, 0, 3]]
+   *     math.diag([1, 2, 3], 1)   // returns [[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3]]
+   *     math.diag([1, 2, 3], -1)  // returns [[0, 0, 0], [1, 0, 0], [0, 2, 0], [0, 0, 3]]
+   *
+   *    // retrieve the diagonal from a matrix
+   *    const a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+   *    math.diag(a)   // returns [1, 5, 9]
+   *
+   * See also:
+   *
+   *     ones, zeros, identity
+   *
+   * @param {Matrix | Array} x          A two dimensional matrix or a vector
+   * @param {number | BigNumber} [k=0]  The diagonal where the vector will be filled
+   *                                    in or retrieved.
+   * @param {string} [format='dense']   The matrix storage format.
+   *
+   * @returns {Matrix | Array} Diagonal matrix from input vector, or diagonal from input matrix.
+   */
+  return typed(name, {
+    // FIXME: simplify this huge amount of signatures as soon as typed-function supports optional arguments
+
+    Array: function Array(x) {
+      return _diag(x, 0, (0, _array.arraySize)(x), null);
+    },
+    'Array, number': function ArrayNumber(x, k) {
+      return _diag(x, k, (0, _array.arraySize)(x), null);
+    },
+    'Array, BigNumber': function ArrayBigNumber(x, k) {
+      return _diag(x, k.toNumber(), (0, _array.arraySize)(x), null);
+    },
+    'Array, string': function ArrayString(x, format) {
+      return _diag(x, 0, (0, _array.arraySize)(x), format);
+    },
+    'Array, number, string': function ArrayNumberString(x, k, format) {
+      return _diag(x, k, (0, _array.arraySize)(x), format);
+    },
+    'Array, BigNumber, string': function ArrayBigNumberString(x, k, format) {
+      return _diag(x, k.toNumber(), (0, _array.arraySize)(x), format);
+    },
+    Matrix: function Matrix(x) {
+      return _diag(x, 0, x.size(), x.storage());
+    },
+    'Matrix, number': function MatrixNumber(x, k) {
+      return _diag(x, k, x.size(), x.storage());
+    },
+    'Matrix, BigNumber': function MatrixBigNumber(x, k) {
+      return _diag(x, k.toNumber(), x.size(), x.storage());
+    },
+    'Matrix, string': function MatrixString(x, format) {
+      return _diag(x, 0, x.size(), format);
+    },
+    'Matrix, number, string': function MatrixNumberString(x, k, format) {
+      return _diag(x, k, x.size(), format);
+    },
+    'Matrix, BigNumber, string': function MatrixBigNumberString(x, k, format) {
+      return _diag(x, k.toNumber(), x.size(), format);
+    }
+  });
+
+  /**
+   * Creeate diagonal matrix from a vector or vice versa
+   * @param {Array | Matrix} x
+   * @param {number} k
+   * @param {string} format Storage format for matrix. If null,
+   *                          an Array is returned
+   * @returns {Array | Matrix}
+   * @private
+   */
+  function _diag(x, k, size, format) {
+    if (!(0, _number.isInteger)(k)) {
+      throw new TypeError('Second parameter in function diag must be an integer');
+    }
+    var kSuper = k > 0 ? k : 0;
+    var kSub = k < 0 ? -k : 0;
+
+    // check dimensions
+    switch (size.length) {
+      case 1:
+        return _createDiagonalMatrix(x, k, format, size[0], kSub, kSuper);
+      case 2:
+        return _getDiagonal(x, k, format, size, kSub, kSuper);
+    }
+    throw new RangeError('Matrix for function diag must be 2 dimensional');
+  }
+  function _createDiagonalMatrix(x, k, format, l, kSub, kSuper) {
+    // matrix size
+    var ms = [l + kSub, l + kSuper];
+    if (format && format !== 'sparse' && format !== 'dense') {
+      throw new TypeError("Unknown matrix type ".concat(format, "\""));
+    }
+
+    // create diagonal matrix
+    var m = format === 'sparse' ? SparseMatrix.diagonal(ms, x, k) : DenseMatrix.diagonal(ms, x, k);
+    // check we need to return a matrix
+    return format !== null ? m : m.valueOf();
+  }
+  function _getDiagonal(x, k, format, s, kSub, kSuper) {
+    // check x is a Matrix
+    if ((0, _is.isMatrix)(x)) {
+      // get diagonal matrix
+      var dm = x.diagonal(k);
+      // check we need to return a matrix
+      if (format !== null) {
+        // check we need to change matrix format
+        if (format !== dm.storage()) {
+          return matrix(dm, format);
+        }
+        return dm;
+      }
+      return dm.valueOf();
+    }
+    // vector size
+    var n = Math.min(s[0] - kSub, s[1] - kSuper);
+    // diagonal values
+    var vector = [];
+    // loop diagonal
+    for (var i = 0; i < n; i++) {
+      vector[i] = x[i + kSub][i + kSuper];
+    }
+    // check we need to return a matrix
+    return format !== null ? matrix(vector) : vector;
+  }
+});
+exports.createDiag = createDiag;

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

@@ -0,0 +1,178 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDiff = void 0;
+var _factory = require("../../utils/factory.js");
+var _number = require("../../utils/number.js");
+var _is = require("../../utils/is.js");
+var name = 'diff';
+var dependencies = ['typed', 'matrix', 'subtract', 'number'];
+var createDiff = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    subtract = _ref.subtract,
+    number = _ref.number;
+  /**
+   * Create a new matrix or array of the difference between elements of the given array
+   * The optional dim parameter lets you specify the dimension to evaluate the difference of
+   * If no dimension parameter is passed it is assumed as dimension 0
+   *
+   * Dimension is zero-based in javascript and one-based in the parser and can be a number or bignumber
+   * Arrays must be 'rectangular' meaning arrays like [1, 2]
+   * If something is passed as a matrix it will be returned as a matrix but other than that all matrices are converted to arrays
+   *
+   * Syntax:
+   *
+   *     math.diff(arr)
+   *     math.diff(arr, dim)
+   *
+   * Examples:
+   *
+   *     const arr = [1, 2, 4, 7, 0]
+   *     math.diff(arr) // returns [1, 2, 3, -7] (no dimension passed so 0 is assumed)
+   *     math.diff(math.matrix(arr)) // returns Matrix [1, 2, 3, -7]
+   *
+   *     const arr = [[1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [9, 8, 7, 6, 4]]
+   *     math.diff(arr) // returns [[0, 0, 0, 0, 0], [8, 6, 4, 2, -1]]
+   *     math.diff(arr, 0) // returns [[0, 0, 0, 0, 0], [8, 6, 4, 2, -1]]
+   *     math.diff(arr, 1) // returns [[1, 1, 1, 1], [1, 1, 1, 1], [-1, -1, -1, -2]]
+   *     math.diff(arr, math.bignumber(1)) // returns [[1, 1, 1, 1], [1, 1, 1, 1], [-1, -1, -1, -2]]
+   *
+   *     math.diff(arr, 2) // throws RangeError as arr is 2 dimensional not 3
+   *     math.diff(arr, -1) // throws RangeError as negative dimensions are not allowed
+   *
+   *     // These will all produce the same result
+   *     math.diff([[1, 2], [3, 4]])
+   *     math.diff([math.matrix([1, 2]), math.matrix([3, 4])])
+   *     math.diff([[1, 2], math.matrix([3, 4])])
+   *     math.diff([math.matrix([1, 2]), [3, 4]])
+   *     // They do not produce the same result as  math.diff(math.matrix([[1, 2], [3, 4]])) as this returns a matrix
+   *
+   * See Also:
+   *
+   *      sum
+   *      subtract
+   *      partitionSelect
+   *
+   * @param {Array | Matrix} arr      An array or matrix
+   * @param {number | BigNumber} dim  Dimension
+   * @return {Array | Matrix}         Difference between array elements in given dimension
+   */
+  return typed(name, {
+    'Array | Matrix': function ArrayMatrix(arr) {
+      // No dimension specified => assume dimension 0
+      if ((0, _is.isMatrix)(arr)) {
+        return matrix(_diff(arr.toArray()));
+      } else {
+        return _diff(arr);
+      }
+    },
+    'Array | Matrix, number': function ArrayMatrixNumber(arr, dim) {
+      if (!(0, _number.isInteger)(dim)) throw new RangeError('Dimension must be a whole number');
+      if ((0, _is.isMatrix)(arr)) {
+        return matrix(_recursive(arr.toArray(), dim));
+      } else {
+        return _recursive(arr, dim);
+      }
+    },
+    'Array, BigNumber': typed.referTo('Array,number', function (selfAn) {
+      return function (arr, dim) {
+        return selfAn(arr, number(dim));
+      };
+    }),
+    'Matrix, BigNumber': typed.referTo('Matrix,number', function (selfMn) {
+      return function (arr, dim) {
+        return selfMn(arr, number(dim));
+      };
+    })
+  });
+
+  /**
+   * Recursively find the correct dimension in the array/matrix
+   * Then Apply _diff to that dimension
+   *
+   * @param {Array} arr      The array
+   * @param {number} dim     Dimension
+   * @return {Array}         resulting array
+   */
+  function _recursive(arr, dim) {
+    if ((0, _is.isMatrix)(arr)) {
+      arr = arr.toArray(); // Makes sure arrays like [ matrix([0, 1]), matrix([1, 0]) ] are processed properly
+    }
+
+    if (!Array.isArray(arr)) {
+      throw RangeError('Array/Matrix does not have that many dimensions');
+    }
+    if (dim > 0) {
+      var result = [];
+      arr.forEach(function (element) {
+        result.push(_recursive(element, dim - 1));
+      });
+      return result;
+    } else if (dim === 0) {
+      return _diff(arr);
+    } else {
+      throw RangeError('Cannot have negative dimension');
+    }
+  }
+
+  /**
+   * Difference between elements in the array
+   *
+   * @param {Array} arr      An array
+   * @return {Array}         resulting array
+   */
+  function _diff(arr) {
+    var result = [];
+    var size = arr.length;
+    for (var i = 1; i < size; i++) {
+      result.push(_ElementDiff(arr[i - 1], arr[i]));
+    }
+    return result;
+  }
+
+  /**
+   * Difference between 2 objects
+   *
+   * @param {Object} obj1    First object
+   * @param {Object} obj2    Second object
+   * @return {Array}         resulting array
+   */
+  function _ElementDiff(obj1, obj2) {
+    // Convert matrices to arrays
+    if ((0, _is.isMatrix)(obj1)) obj1 = obj1.toArray();
+    if ((0, _is.isMatrix)(obj2)) obj2 = obj2.toArray();
+    var obj1IsArray = Array.isArray(obj1);
+    var obj2IsArray = Array.isArray(obj2);
+    if (obj1IsArray && obj2IsArray) {
+      return _ArrayDiff(obj1, obj2);
+    }
+    if (!obj1IsArray && !obj2IsArray) {
+      return subtract(obj2, obj1); // Difference is (second - first) NOT (first - second)
+    }
+
+    throw TypeError('Cannot calculate difference between 1 array and 1 non-array');
+  }
+
+  /**
+   * Difference of elements in 2 arrays
+   *
+   * @param {Array} arr1     Array 1
+   * @param {Array} arr2     Array 2
+   * @return {Array}         resulting array
+   */
+  function _ArrayDiff(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+      throw RangeError('Not all sub-arrays have the same length');
+    }
+    var result = [];
+    var size = arr1.length;
+    for (var i = 0; i < size; i++) {
+      result.push(_ElementDiff(arr1[i], arr2[i]));
+    }
+    return result;
+  }
+});
+exports.createDiff = createDiff;