mathjs-min 11.7.2

package/lib/cjs/function/arithmetic/addScalar.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createAddScalar = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'addScalar';
+var dependencies = ['typed'];
+var createAddScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Add two scalar values, `x + y`.
+   * This function is meant for internal use: it is used by the public function
+   * `add`
+   *
+   * This function does not support collections (Array or Matrix).
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x   First value to add
+   * @param  {number | BigNumber | Fraction | Complex} y          Second value to add
+   * @return {number | BigNumber | Fraction | Complex | Unit}     Sum of `x` and `y`
+   * @private
+   */
+  return typed(name, {
+    'number, number': _index.addNumber,
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.add(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return x.plus(y);
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return x.add(y);
+    },
+    'Unit, Unit': typed.referToSelf(function (self) {
+      return function (x, y) {
+        if (x.value === null || x.value === undefined) {
+          throw new Error('Parameter x contains a unit with undefined value');
+        }
+        if (y.value === null || y.value === undefined) {
+          throw new Error('Parameter y contains a unit with undefined value');
+        }
+        if (!x.equalBase(y)) throw new Error('Units do not match');
+        var res = x.clone();
+        res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
+        res.fixPrefix = false;
+        return res;
+      };
+    })
+  });
+});
+exports.createAddScalar = createAddScalar;

package/lib/cjs/function/arithmetic/cbrt.js

@@ -0,0 +1,136 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCbrt = void 0;
+var _factory = require("../../utils/factory.js");
+var _is = require("../../utils/is.js");
+var _index = require("../../plain/number/index.js");
+var name = 'cbrt';
+var dependencies = ['config', 'typed', 'isNegative', 'unaryMinus', 'matrix', 'Complex', 'BigNumber', 'Fraction'];
+var createCbrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var config = _ref.config,
+    typed = _ref.typed,
+    isNegative = _ref.isNegative,
+    unaryMinus = _ref.unaryMinus,
+    matrix = _ref.matrix,
+    Complex = _ref.Complex,
+    BigNumber = _ref.BigNumber,
+    Fraction = _ref.Fraction;
+  /**
+   * Calculate the cubic root of a value.
+   *
+   * To avoid confusion with the matrix cube root, this function does not
+   * apply to matrices. For a matrix, to take the cube root elementwise,
+   * see the examples.
+   *
+   * Syntax:
+   *
+   *    math.cbrt(x)
+   *    math.cbrt(x, allRoots)
+   *
+   * Examples:
+   *
+   *    math.cbrt(27)                  // returns 3
+   *    math.cube(3)                   // returns 27
+   *    math.cbrt(-64)                 // returns -4
+   *    math.cbrt(math.unit('27 m^3')) // returns Unit 3 m
+   *    math.map([27, 64, 125], x => math.cbrt(x))       // returns [3, 4, 5]
+   *
+   *    const x = math.complex('8i')
+   *    math.cbrt(x)                   // returns Complex 1.7320508075689 + i
+   *    math.cbrt(x, true)             // returns Matrix [
+   *                                    //    1.7320508075689 + i
+   *                                    //   -1.7320508075689 + i
+   *                                    //   -2i
+   *                                    // ]
+   *
+   * See also:
+   *
+   *    square, sqrt, cube
+   *
+   * @param {number | BigNumber | Complex | Unit} x
+   *            Value for which to calculate the cubic root.
+   * @param {boolean} [allRoots]  Optional, false by default. Only applicable
+   *            when `x` is a number or complex number. If true, all complex
+   *            roots are returned, if false (default) the principal root is
+   *            returned.
+   * @return {number | BigNumber | Complex | Unit}
+   *            Returns the cubic root of `x`
+   */
+  return typed(name, {
+    number: _index.cbrtNumber,
+    // note: signature 'number, boolean' is also supported,
+    //       created by typed as it knows how to convert number to Complex
+
+    Complex: _cbrtComplex,
+    'Complex, boolean': _cbrtComplex,
+    BigNumber: function BigNumber(x) {
+      return x.cbrt();
+    },
+    Unit: _cbrtUnit
+  });
+
+  /**
+   * Calculate the cubic root for a complex number
+   * @param {Complex} x
+   * @param {boolean} [allRoots]   If true, the function will return an array
+   *                               with all three roots. If false or undefined,
+   *                               the principal root is returned.
+   * @returns {Complex | Array.<Complex> | Matrix.<Complex>} Returns the cubic root(s) of x
+   * @private
+   */
+  function _cbrtComplex(x, allRoots) {
+    // https://www.wikiwand.com/en/Cube_root#/Complex_numbers
+
+    var arg3 = x.arg() / 3;
+    var abs = x.abs();
+
+    // principal root:
+    var principal = new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3).exp());
+    if (allRoots) {
+      var all = [principal, new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3 + Math.PI * 2 / 3).exp()), new Complex((0, _index.cbrtNumber)(abs), 0).mul(new Complex(0, arg3 - Math.PI * 2 / 3).exp())];
+      return config.matrix === 'Array' ? all : matrix(all);
+    } else {
+      return principal;
+    }
+  }
+
+  /**
+   * Calculate the cubic root for a Unit
+   * @param {Unit} x
+   * @return {Unit} Returns the cubic root of x
+   * @private
+   */
+  function _cbrtUnit(x) {
+    if (x.value && (0, _is.isComplex)(x.value)) {
+      var result = x.clone();
+      result.value = 1.0;
+      result = result.pow(1.0 / 3); // Compute the units
+      result.value = _cbrtComplex(x.value); // Compute the value
+      return result;
+    } else {
+      var negate = isNegative(x.value);
+      if (negate) {
+        x.value = unaryMinus(x.value);
+      }
+
+      // TODO: create a helper function for this
+      var third;
+      if ((0, _is.isBigNumber)(x.value)) {
+        third = new BigNumber(1).div(3);
+      } else if ((0, _is.isFraction)(x.value)) {
+        third = new Fraction(1, 3);
+      } else {
+        third = 1 / 3;
+      }
+      var _result = x.pow(third);
+      if (negate) {
+        _result.value = unaryMinus(_result.value);
+      }
+      return _result;
+    }
+  }
+});
+exports.createCbrt = createCbrt;

package/lib/cjs/function/arithmetic/ceil.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCeilNumber = exports.createCeil = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _decimal = _interopRequireDefault(require("decimal.js"));
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.js");
+var _number = require("../../utils/number.js");
+var _nearlyEqual = require("../../utils/bignumber/nearlyEqual.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
+var name = 'ceil';
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+var createCeilNumber = /* #__PURE__ */(0, _factory.factory)(name, ['typed', 'config', 'round'], function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    round = _ref.round;
+  return typed(name, {
+    number: function number(x) {
+      if ((0, _number.nearlyEqual)(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.ceil(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if ((0, _number.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var _split = "".concat(x, "e").split('e'),
+          _split2 = (0, _slicedToArray2["default"])(_split, 2),
+          number = _split2[0],
+          exponent = _split2[1];
+        var result = Math.ceil(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        var _split3 = "".concat(result, "e").split('e');
+        var _split4 = (0, _slicedToArray2["default"])(_split3, 2);
+        number = _split4[0];
+        exponent = _split4[1];
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+exports.createCeilNumber = createCeilNumber;
+var createCeil = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref2) {
+  var typed = _ref2.typed,
+    config = _ref2.config,
+    round = _ref2.round,
+    matrix = _ref2.matrix,
+    equalScalar = _ref2.equalScalar,
+    zeros = _ref2.zeros,
+    DenseMatrix = _ref2.DenseMatrix;
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed: typed
+  });
+  var ceilNumber = createCeilNumber({
+    typed: typed,
+    config: config,
+    round: round
+  });
+  /**
+   * Round a value towards plus infinity
+   * If `x` is complex, both real and imaginary part are rounded towards plus infinity.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.ceil(x)
+   *    math.ceil(x, n)
+   *
+   * Examples:
+   *
+   *    math.ceil(3.2)               // returns number 4
+   *    math.ceil(3.8)               // returns number 4
+   *    math.ceil(-4.2)              // returns number -4
+   *    math.ceil(-4.7)              // returns number -4
+   *
+   *    math.ceil(3.212, 2)          // returns number 3.22
+   *    math.ceil(3.288, 2)          // returns number 3.29
+   *    math.ceil(-4.212, 2)         // returns number -4.21
+   *    math.ceil(-4.782, 2)         // returns number -4.78
+   *
+   *    const c = math.complex(3.24, -2.71)
+   *    math.ceil(c)                 // returns Complex 4 - 2i
+   *    math.ceil(c, 1)              // returns Complex 3.3 - 2.7i
+   *
+   *    math.ceil([3.2, 3.8, -4.7])  // returns Array [4, 4, -4]
+   *    math.ceil([3.21, 3.82, -4.71], 1)  // returns Array [3.3, 3.9, -4.7]
+   *
+   * See also:
+   *
+   *    floor, fix, round
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} x  Number to be rounded
+   * @param  {number | BigNumber | Array} [n=0]                            Number of decimals
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix} Rounded value
+   */
+  return typed('ceil', {
+    number: ceilNumber.signatures.number,
+    'number,number': ceilNumber.signatures['number,number'],
+    Complex: function Complex(x) {
+      return x.ceil();
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.ceil(n);
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
+    BigNumber: function BigNumber(x) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return x.ceil();
+      }
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if ((0, _nearlyEqual.nearlyEqual)(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), _decimal["default"].ROUND_CEIL);
+      }
+    },
+    Fraction: function Fraction(x) {
+      return x.ceil();
+    },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.ceil(n);
+    },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.ceil(n.toNumber());
+    },
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        // deep map collection, skip zeros since ceil(0) = 0
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    }),
+    'Array, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, n) {
+        // deep map collection, skip zeros since ceil(0) = 0
+        return (0, _collection.deepMap)(x, function (i) {
+          return self(i, n);
+        }, true);
+      };
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        return matAlgo11xS0s(x, y, self, false);
+      };
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        return matAlgo14xDs(x, y, self, false);
+      };
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+      };
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        if (equalScalar(x, 0)) return zeros(y.size(), y.storage());
+        if (y.storage() === 'dense') {
+          return matAlgo14xDs(y, x, self, true);
+        }
+        return matAlgo12xSfs(y, x, self, true);
+      };
+    })
+  });
+});
+exports.createCeil = createCeil;

package/lib/cjs/function/arithmetic/cube.js

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCube = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'cube';
+var dependencies = ['typed'];
+var createCube = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Compute the cube of a value, `x * x * x`.
+   * To avoid confusion with `pow(M,3)`, this function does not apply to matrices.
+   * If you wish to cube every entry of a matrix, see the examples.
+   *
+   * Syntax:
+   *
+   *    math.cube(x)
+   *
+   * Examples:
+   *
+   *    math.cube(2)            // returns number 8
+   *    math.pow(2, 3)          // returns number 8
+   *    math.cube(4)            // returns number 64
+   *    4 * 4 * 4               // returns number 64
+   *
+   *    math.map([1, 2, 3, 4], math.cube) // returns Array [1, 8, 27, 64]
+   *
+   * See also:
+   *
+   *    multiply, square, pow, cbrt
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x  Number for which to calculate the cube
+   * @return {number | BigNumber | Fraction | Complex | Unit} Cube of x
+   */
+  return typed(name, {
+    number: _index.cubeNumber,
+    Complex: function Complex(x) {
+      return x.mul(x).mul(x); // Is faster than pow(x, 3)
+    },
+
+    BigNumber: function BigNumber(x) {
+      return x.times(x).times(x);
+    },
+    Fraction: function Fraction(x) {
+      return x.pow(3); // Is faster than mul()mul()mul()
+    },
+
+    Unit: function Unit(x) {
+      return x.pow(3);
+    }
+  });
+});
+exports.createCube = createCube;

package/lib/cjs/function/arithmetic/divide.js

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDivide = void 0;
+var _factory = require("../../utils/factory.js");
+var _object = require("../../utils/object.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
+var _matAlgo14xDs = require("../../type/matrix/utils/matAlgo14xDs.js");
+var name = 'divide';
+var dependencies = ['typed', 'matrix', 'multiply', 'equalScalar', 'divideScalar', 'inv'];
+var createDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    multiply = _ref.multiply,
+    equalScalar = _ref.equalScalar,
+    divideScalar = _ref.divideScalar,
+    inv = _ref.inv;
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo14xDs = (0, _matAlgo14xDs.createMatAlgo14xDs)({
+    typed: typed
+  });
+
+  /**
+   * Divide two values, `x / y`.
+   * To divide matrices, `x` is multiplied with the inverse of `y`: `x * inv(y)`.
+   *
+   * Syntax:
+   *
+   *    math.divide(x, y)
+   *
+   * Examples:
+   *
+   *    math.divide(2, 3)            // returns number 0.6666666666666666
+   *
+   *    const a = math.complex(5, 14)
+   *    const b = math.complex(4, 1)
+   *    math.divide(a, b)            // returns Complex 2 + 3i
+   *
+   *    const c = [[7, -6], [13, -4]]
+   *    const d = [[1, 2], [4, 3]]
+   *    math.divide(c, d)            // returns Array [[-9, 4], [-11, 6]]
+   *
+   *    const e = math.unit('18 km')
+   *    math.divide(e, 4.5)          // returns Unit 4 km
+   *
+   * See also:
+   *
+   *    multiply
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x   Numerator
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix} y          Denominator
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                      Quotient, `x / y`
+   */
+  return typed('divide', (0, _object.extend)({
+    // we extend the signatures of divideScalar with signatures dealing with matrices
+
+    'Array | Matrix, Array | Matrix': function ArrayMatrixArrayMatrix(x, y) {
+      // TODO: implement matrix right division using pseudo inverse
+      // https://www.mathworks.nl/help/matlab/ref/mrdivide.html
+      // https://www.gnu.org/software/octave/doc/interpreter/Arithmetic-Ops.html
+      // https://stackoverflow.com/questions/12263932/how-does-gnu-octave-matrix-division-work-getting-unexpected-behaviour
+      return multiply(x, inv(y));
+    },
+    'DenseMatrix, any': function DenseMatrixAny(x, y) {
+      return matAlgo14xDs(x, y, divideScalar, false);
+    },
+    'SparseMatrix, any': function SparseMatrixAny(x, y) {
+      return matAlgo11xS0s(x, y, divideScalar, false);
+    },
+    'Array, any': function ArrayAny(x, y) {
+      // use matrix implementation
+      return matAlgo14xDs(matrix(x), y, divideScalar, false).valueOf();
+    },
+    'any, Array | Matrix': function anyArrayMatrix(x, y) {
+      return multiply(x, inv(y));
+    }
+  }, divideScalar.signatures));
+});
+exports.createDivide = createDivide;

package/lib/cjs/function/arithmetic/divideScalar.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDivideScalar = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'divideScalar';
+var dependencies = ['typed', 'numeric'];
+var createDivideScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    numeric = _ref.numeric;
+  /**
+   * Divide two scalar values, `x / y`.
+   * This function is meant for internal use: it is used by the public functions
+   * `divide` and `inv`.
+   *
+   * This function does not support collections (Array or Matrix).
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x   Numerator
+   * @param  {number | BigNumber | Fraction | Complex} y          Denominator
+   * @return {number | BigNumber | Fraction | Complex | Unit}     Quotient, `x / y`
+   * @private
+   */
+  return typed(name, {
+    'number, number': function numberNumber(x, y) {
+      return x / y;
+    },
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.div(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return x.div(y);
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return x.div(y);
+    },
+    'Unit, number | Complex | Fraction | BigNumber | Unit': function UnitNumberComplexFractionBigNumberUnit(x, y) {
+      return x.divide(y);
+    },
+    'number | Fraction | Complex | BigNumber, Unit': function numberFractionComplexBigNumberUnit(x, y) {
+      return y.divideInto(x);
+    }
+  });
+});
+exports.createDivideScalar = createDivideScalar;

package/lib/cjs/function/arithmetic/dotDivide.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createDotDivide = void 0;
+var _factory = require("../../utils/factory.js");
+var _matAlgo02xDS = require("../../type/matrix/utils/matAlgo02xDS0.js");
+var _matAlgo03xDSf = require("../../type/matrix/utils/matAlgo03xDSf.js");
+var _matAlgo07xSSf = require("../../type/matrix/utils/matAlgo07xSSf.js");
+var _matAlgo11xS0s = require("../../type/matrix/utils/matAlgo11xS0s.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
+var name = 'dotDivide';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat'];
+var createDotDivide = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    equalScalar = _ref.equalScalar,
+    divideScalar = _ref.divideScalar,
+    DenseMatrix = _ref.DenseMatrix,
+    concat = _ref.concat;
+  var matAlgo02xDS0 = (0, _matAlgo02xDS.createMatAlgo02xDS0)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
+    typed: typed
+  });
+  var matAlgo07xSSf = (0, _matAlgo07xSSf.createMatAlgo07xSSf)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matAlgo11xS0s = (0, _matAlgo11xS0s.createMatAlgo11xS0s)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: concat
+  });
+
+  /**
+   * Divide two matrices element wise. The function accepts both matrices and
+   * scalar values.
+   *
+   * Syntax:
+   *
+   *    math.dotDivide(x, y)
+   *
+   * Examples:
+   *
+   *    math.dotDivide(2, 4)   // returns 0.5
+   *
+   *    a = [[9, 5], [6, 1]]
+   *    b = [[3, 2], [5, 2]]
+   *
+   *    math.dotDivide(a, b)   // returns [[3, 2.5], [1.2, 0.5]]
+   *    math.divide(a, b)      // returns [[1.75, 0.75], [-1.75, 2.25]]
+   *
+   * See also:
+   *
+   *    divide, multiply, dotMultiply
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x Numerator
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Denominator
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Quotient, `x ./ y`
+   */
+  return typed(name, matrixAlgorithmSuite({
+    elop: divideScalar,
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    SD: matAlgo02xDS0,
+    Ss: matAlgo11xS0s,
+    sS: matAlgo12xSfs
+  }));
+});
+exports.createDotDivide = createDotDivide;