mathjs-min 11.7.2

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

@@ -0,0 +1,196 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPow = void 0;
+var _factory = require("../../utils/factory.js");
+var _number = require("../../utils/number.js");
+var _array = require("../../utils/array.js");
+var _index = require("../../plain/number/index.js");
+var name = 'pow';
+var dependencies = ['typed', 'config', 'identity', 'multiply', 'matrix', 'inv', 'fraction', 'number', 'Complex'];
+var createPow = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    config = _ref.config,
+    identity = _ref.identity,
+    multiply = _ref.multiply,
+    matrix = _ref.matrix,
+    inv = _ref.inv,
+    number = _ref.number,
+    fraction = _ref.fraction,
+    Complex = _ref.Complex;
+  /**
+   * Calculates the power of x to y, `x ^ y`.
+   *
+   * Matrix exponentiation is supported for square matrices `x` and integers `y`:
+   * when `y` is nonnegative, `x` may be any square matrix; and when `y` is
+   * negative, `x` must be invertible, and then this function returns
+   * inv(x)^(-y).
+   *
+   * For cubic roots of negative numbers, the function returns the principal
+   * root by default. In order to let the function return the real root,
+   * math.js can be configured with `math.config({predictable: true})`.
+   * To retrieve all cubic roots of a value, use `math.cbrt(x, true)`.
+   *
+   * Syntax:
+   *
+   *    math.pow(x, y)
+   *
+   * Examples:
+   *
+   *    math.pow(2, 3)               // returns number 8
+   *
+   *    const a = math.complex(2, 3)
+   *    math.pow(a, 2)                // returns Complex -5 + 12i
+   *
+   *    const b = [[1, 2], [4, 3]]
+   *    math.pow(b, 2)               // returns Array [[9, 8], [16, 17]]
+   *
+   *    const c = [[1, 2], [4, 3]]
+   *    math.pow(c, -1)               // returns Array [[-0.6, 0.4], [0.8, -0.2]]
+   *
+   * See also:
+   *
+   *    multiply, sqrt, cbrt, nthRoot
+   *
+   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x  The base
+   * @param  {number | BigNumber | Complex} y                          The exponent
+   * @return {number | BigNumber | Complex | Array | Matrix} The value of `x` to the power `y`
+   */
+  return typed(name, {
+    'number, number': _pow,
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.pow(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      if (y.isInteger() || x >= 0 || config.predictable) {
+        return x.pow(y);
+      } else {
+        return new Complex(x.toNumber(), 0).pow(y.toNumber(), 0);
+      }
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      var result = x.pow(y);
+      if (result != null) {
+        return result;
+      }
+      if (config.predictable) {
+        throw new Error('Result of pow is non-rational and cannot be expressed as a fraction');
+      } else {
+        return _pow(x.valueOf(), y.valueOf());
+      }
+    },
+    'Array, number': _powArray,
+    'Array, BigNumber': function ArrayBigNumber(x, y) {
+      return _powArray(x, y.toNumber());
+    },
+    'Matrix, number': _powMatrix,
+    'Matrix, BigNumber': function MatrixBigNumber(x, y) {
+      return _powMatrix(x, y.toNumber());
+    },
+    'Unit, number | BigNumber': function UnitNumberBigNumber(x, y) {
+      return x.pow(y);
+    }
+  });
+
+  /**
+   * Calculates the power of x to y, x^y, for two numbers.
+   * @param {number} x
+   * @param {number} y
+   * @return {number | Complex} res
+   * @private
+   */
+  function _pow(x, y) {
+    // Alternatively could define a 'realmode' config option or something, but
+    // 'predictable' will work for now
+    if (config.predictable && !(0, _number.isInteger)(y) && x < 0) {
+      // Check to see if y can be represented as a fraction
+      try {
+        var yFrac = fraction(y);
+        var yNum = number(yFrac);
+        if (y === yNum || Math.abs((y - yNum) / y) < 1e-14) {
+          if (yFrac.d % 2 === 1) {
+            return (yFrac.n % 2 === 0 ? 1 : -1) * Math.pow(-x, y);
+          }
+        }
+      } catch (ex) {
+        // fraction() throws an error if y is Infinity, etc.
+      }
+
+      // Unable to express y as a fraction, so continue on
+    }
+
+    // **for predictable mode** x^Infinity === NaN if x < -1
+    // N.B. this behavour is different from `Math.pow` which gives
+    // (-2)^Infinity === Infinity
+    if (config.predictable && (x < -1 && y === Infinity || x > -1 && x < 0 && y === -Infinity)) {
+      return NaN;
+    }
+    if ((0, _number.isInteger)(y) || x >= 0 || config.predictable) {
+      return (0, _index.powNumber)(x, y);
+    } else {
+      // TODO: the following infinity checks are duplicated from powNumber. Deduplicate this somehow
+
+      // x^Infinity === 0 if -1 < x < 1
+      // A real number 0 is returned instead of complex(0)
+      if (x * x < 1 && y === Infinity || x * x > 1 && y === -Infinity) {
+        return 0;
+      }
+      return new Complex(x, 0).pow(y, 0);
+    }
+  }
+
+  /**
+   * Calculate the power of a 2d array
+   * @param {Array} x     must be a 2 dimensional, square matrix
+   * @param {number} y    a integer value (positive if `x` is not invertible)
+   * @returns {Array}
+   * @private
+   */
+  function _powArray(x, y) {
+    if (!(0, _number.isInteger)(y)) {
+      throw new TypeError('For A^b, b must be an integer (value is ' + y + ')');
+    }
+    // verify that A is a 2 dimensional square matrix
+    var s = (0, _array.arraySize)(x);
+    if (s.length !== 2) {
+      throw new Error('For A^b, A must be 2 dimensional (A has ' + s.length + ' dimensions)');
+    }
+    if (s[0] !== s[1]) {
+      throw new Error('For A^b, A must be square (size is ' + s[0] + 'x' + s[1] + ')');
+    }
+    if (y < 0) {
+      try {
+        return _powArray(inv(x), -y);
+      } catch (error) {
+        if (error.message === 'Cannot calculate inverse, determinant is zero') {
+          throw new TypeError('For A^b, when A is not invertible, b must be a positive integer (value is ' + y + ')');
+        }
+        throw error;
+      }
+    }
+    var res = identity(s[0]).valueOf();
+    var px = x;
+    while (y >= 1) {
+      if ((y & 1) === 1) {
+        res = multiply(px, res);
+      }
+      y >>= 1;
+      px = multiply(px, px);
+    }
+    return res;
+  }
+
+  /**
+   * Calculate the power of a 2d matrix
+   * @param {Matrix} x     must be a 2 dimensional, square matrix
+   * @param {number} y    a positive, integer value
+   * @returns {Matrix}
+   * @private
+   */
+  function _powMatrix(x, y) {
+    return matrix(_powArray(x.valueOf(), y));
+  }
+});
+exports.createPow = createPow;

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

@@ -0,0 +1,169 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRound = void 0;
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.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 _index = require("../../plain/number/index.js");
+var NO_INT = 'Number of decimals in function round must be an integer';
+var name = 'round';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'zeros', 'BigNumber', 'DenseMatrix'];
+var createRound = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    equalScalar = _ref.equalScalar,
+    zeros = _ref.zeros,
+    BigNumber = _ref.BigNumber,
+    DenseMatrix = _ref.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
+  });
+
+  /**
+   * Round a value towards the nearest rounded value.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.round(x)
+   *    math.round(x, n)
+   *
+   * Examples:
+   *
+   *    math.round(3.22)             // returns number 3
+   *    math.round(3.82)             // returns number 4
+   *    math.round(-4.2)             // returns number -4
+   *    math.round(-4.7)             // returns number -5
+   *    math.round(3.22, 1)          // returns number 3.2
+   *    math.round(3.88, 1)          // returns number 3.9
+   *    math.round(-4.21, 1)         // returns number -4.2
+   *    math.round(-4.71, 1)         // returns number -4.7
+   *    math.round(math.pi, 3)       // returns number 3.142
+   *    math.round(123.45678, 2)     // returns number 123.46
+   *
+   *    const c = math.complex(3.2, -2.7)
+   *    math.round(c)                // returns Complex 3 - 3i
+   *
+   *    math.round([3.2, 3.8, -4.7]) // returns Array [3, 4, -5]
+   *
+   * See also:
+   *
+   *    ceil, fix, floor
+   *
+   * @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(name, {
+    number: _index.roundNumber,
+    'number, number': _index.roundNumber,
+    'number, BigNumber': function numberBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+      return new BigNumber(x).toDecimalPlaces(n.toNumber());
+    },
+    Complex: function Complex(x) {
+      return x.round();
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      if (n % 1) {
+        throw new TypeError(NO_INT);
+      }
+      return x.round(n);
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+      var _n = n.toNumber();
+      return x.round(_n);
+    },
+    BigNumber: function BigNumber(x) {
+      return x.toDecimalPlaces(0);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+      return x.toDecimalPlaces(n.toNumber());
+    },
+    Fraction: function Fraction(x) {
+      return x.round();
+    },
+    'Fraction, number': function FractionNumber(x, n) {
+      if (n % 1) {
+        throw new TypeError(NO_INT);
+      }
+      return x.round(n);
+    },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      if (!n.isInteger()) {
+        throw new TypeError(NO_INT);
+      }
+      return x.round(n.toNumber());
+    },
+    // deep map collection, skip zeros since round(0) = 0
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self, 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);
+      };
+    }),
+    'Array, number | BigNumber': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(x), y, self, false).valueOf();
+      };
+    }),
+    'number | Complex | BigNumber | Fraction, SparseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // check scalar is zero
+        if (equalScalar(x, 0)) {
+          // do not execute algorithm, result will be a zero matrix
+          return zeros(y.size(), y.storage());
+        }
+        return matAlgo12xSfs(y, x, self, true);
+      };
+    }),
+    'number | Complex | BigNumber | Fraction, DenseMatrix': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // check scalar is zero
+        if (equalScalar(x, 0)) {
+          // do not execute algorithm, result will be a zero matrix
+          return zeros(y.size(), y.storage());
+        }
+        return matAlgo14xDs(y, x, self, true);
+      };
+    }),
+    'number | Complex | BigNumber | Fraction, Array': typed.referToSelf(function (self) {
+      return function (x, y) {
+        // use matrix implementation
+        return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+      };
+    })
+  });
+});
+exports.createRound = createRound;

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

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSign = void 0;
+var _factory = require("../../utils/factory.js");
+var _collection = require("../../utils/collection.js");
+var _index = require("../../plain/number/index.js");
+var name = 'sign';
+var dependencies = ['typed', 'BigNumber', 'Fraction', 'complex'];
+var createSign = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    _BigNumber = _ref.BigNumber,
+    complex = _ref.complex,
+    _Fraction = _ref.Fraction;
+  /**
+   * Compute the sign of a value. The sign of a value x is:
+   *
+   * -  1 when x > 0
+   * - -1 when x < 0
+   * -  0 when x == 0
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.sign(x)
+   *
+   * Examples:
+   *
+   *    math.sign(3.5)               // returns 1
+   *    math.sign(-4.2)              // returns -1
+   *    math.sign(0)                 // returns 0
+   *
+   *    math.sign([3, 5, -2, 0, 2])  // returns [1, 1, -1, 0, 1]
+   *
+   * See also:
+   *
+   *    abs
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Array | Matrix | Unit} x
+   *            The number for which to determine the sign
+   * @return {number | BigNumber | Fraction | Complex | Array | Matrix | Unit}
+   *            The sign of `x`
+   */
+  return typed(name, {
+    number: _index.signNumber,
+    Complex: function Complex(x) {
+      return x.im === 0 ? complex((0, _index.signNumber)(x.re)) : x.sign();
+    },
+    BigNumber: function BigNumber(x) {
+      return new _BigNumber(x.cmp(0));
+    },
+    Fraction: function Fraction(x) {
+      return new _Fraction(x.s, 1);
+    },
+    // deep map collection, skip zeros since sign(0) = 0
+    'Array | Matrix': typed.referToSelf(function (self) {
+      return function (x) {
+        return (0, _collection.deepMap)(x, self, true);
+      };
+    }),
+    Unit: typed.referToSelf(function (self) {
+      return function (x) {
+        if (!x._isDerived() && x.units[0].unit.offset !== 0) {
+          throw new TypeError('sign is ambiguous for units with offset');
+        }
+        return typed.find(self, x.valueType())(x.value);
+      };
+    })
+  });
+});
+exports.createSign = createSign;

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

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSqrt = void 0;
+var _factory = require("../../utils/factory.js");
+var name = 'sqrt';
+var dependencies = ['config', 'typed', 'Complex'];
+var createSqrt = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var config = _ref.config,
+    typed = _ref.typed,
+    Complex = _ref.Complex;
+  /**
+   * Calculate the square root of a value.
+   *
+   * For matrices, if you want the matrix square root of a square matrix,
+   * use the `sqrtm` function. If you wish to apply `sqrt` elementwise to
+   * a matrix M, use `math.map(M, math.sqrt)`.
+   *
+   * Syntax:
+   *
+   *    math.sqrt(x)
+   *
+   * Examples:
+   *
+   *    math.sqrt(25)                // returns 5
+   *    math.square(5)               // returns 25
+   *    math.sqrt(-4)                // returns Complex 2i
+   *
+   * See also:
+   *
+   *    square, multiply, cube, cbrt, sqrtm
+   *
+   * @param {number | BigNumber | Complex | Unit} x
+   *            Value for which to calculate the square root.
+   * @return {number | BigNumber | Complex | Unit}
+   *            Returns the square root of `x`
+   */
+  return typed('sqrt', {
+    number: _sqrtNumber,
+    Complex: function Complex(x) {
+      return x.sqrt();
+    },
+    BigNumber: function BigNumber(x) {
+      if (!x.isNegative() || config.predictable) {
+        return x.sqrt();
+      } else {
+        // negative value -> downgrade to number to do complex value computation
+        return _sqrtNumber(x.toNumber());
+      }
+    },
+    Unit: function Unit(x) {
+      // Someday will work for complex units when they are implemented
+      return x.pow(0.5);
+    }
+  });
+
+  /**
+   * Calculate sqrt for a number
+   * @param {number} x
+   * @returns {number | Complex} Returns the square root of x
+   * @private
+   */
+  function _sqrtNumber(x) {
+    if (isNaN(x)) {
+      return NaN;
+    } else if (x >= 0 || config.predictable) {
+      return Math.sqrt(x);
+    } else {
+      return new Complex(x, 0).sqrt();
+    }
+  }
+});
+exports.createSqrt = createSqrt;

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

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

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

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubtract = void 0;
+var _factory = require("../../utils/factory.js");
+var _matAlgo01xDSid = require("../../type/matrix/utils/matAlgo01xDSid.js");
+var _matAlgo03xDSf = require("../../type/matrix/utils/matAlgo03xDSf.js");
+var _matAlgo05xSfSf = require("../../type/matrix/utils/matAlgo05xSfSf.js");
+var _matAlgo10xSids = require("../../type/matrix/utils/matAlgo10xSids.js");
+var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
+var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
+var name = 'subtract';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'addScalar', 'unaryMinus', 'DenseMatrix', 'concat'];
+var createSubtract = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    matrix = _ref.matrix,
+    equalScalar = _ref.equalScalar,
+    addScalar = _ref.addScalar,
+    unaryMinus = _ref.unaryMinus,
+    DenseMatrix = _ref.DenseMatrix,
+    concat = _ref.concat;
+  // TODO: split function subtract in two: subtract and subtractScalar
+
+  var matAlgo01xDSid = (0, _matAlgo01xDSid.createMatAlgo01xDSid)({
+    typed: typed
+  });
+  var matAlgo03xDSf = (0, _matAlgo03xDSf.createMatAlgo03xDSf)({
+    typed: typed
+  });
+  var matAlgo05xSfSf = (0, _matAlgo05xSfSf.createMatAlgo05xSfSf)({
+    typed: typed,
+    equalScalar: equalScalar
+  });
+  var matAlgo10xSids = (0, _matAlgo10xSids.createMatAlgo10xSids)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matAlgo12xSfs = (0, _matAlgo12xSfs.createMatAlgo12xSfs)({
+    typed: typed,
+    DenseMatrix: DenseMatrix
+  });
+  var matrixAlgorithmSuite = (0, _matrixAlgorithmSuite.createMatrixAlgorithmSuite)({
+    typed: typed,
+    matrix: matrix,
+    concat: concat
+  });
+
+  /**
+   * Subtract two values, `x - y`.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.subtract(x, y)
+   *
+   * Examples:
+   *
+   *    math.subtract(5.3, 2)        // returns number 3.3
+   *
+   *    const a = math.complex(2, 3)
+   *    const b = math.complex(4, 1)
+   *    math.subtract(a, b)          // returns Complex -2 + 2i
+   *
+   *    math.subtract([5, 7, 4], 4)  // returns Array [1, 3, 0]
+   *
+   *    const c = math.unit('2.1 km')
+   *    const d = math.unit('500m')
+   *    math.subtract(c, d)          // returns Unit 1.6 km
+   *
+   * See also:
+   *
+   *    add
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x
+   *            Initial value
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y
+   *            Value to subtract from `x`
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}
+   *            Subtraction of `x` and `y`
+   */
+  return typed(name, {
+    'number, number': function numberNumber(x, y) {
+      return x - y;
+    },
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.sub(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return x.minus(y);
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return x.sub(y);
+    },
+    'Unit, Unit': typed.referToSelf(function (self) {
+      return function (x, y) {
+        if (x.value === null) {
+          throw new Error('Parameter x contains a unit with undefined value');
+        }
+        if (y.value === null) {
+          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;
+      };
+    })
+  }, matrixAlgorithmSuite({
+    SS: matAlgo05xSfSf,
+    DS: matAlgo01xDSid,
+    SD: matAlgo03xDSf,
+    Ss: matAlgo12xSfs,
+    sS: matAlgo10xSids
+  }));
+});
+exports.createSubtract = createSubtract;