mathjs-min 11.7.2

package/lib/esm/function/arithmetic/fix.js

@@ -0,0 +1,126 @@
+import { factory } from '../../utils/factory.js';
+import { deepMap } from '../../utils/collection.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
+var name = 'fix';
+var dependencies = ['typed', 'Complex', 'matrix', 'ceil', 'floor', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createFixNumber = /* #__PURE__ */factory(name, ['typed', 'ceil', 'floor'], _ref => {
+  var {
+    typed,
+    ceil,
+    floor
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      return x > 0 ? floor(x) : ceil(x);
+    },
+    'number, number': function numberNumber(x, n) {
+      return x > 0 ? floor(x, n) : ceil(x, n);
+    }
+  });
+});
+export var createFix = /* #__PURE__ */factory(name, dependencies, _ref2 => {
+  var {
+    typed,
+    Complex: _Complex,
+    matrix,
+    ceil,
+    floor,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  var fixNumber = createFixNumber({
+    typed,
+    ceil,
+    floor
+  });
+  /**
+   * Round a value towards zero.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.fix(x)
+   *    math.fix(x,n)
+   *
+   * Examples:
+   *
+   *    math.fix(3.2)                // returns number 3
+   *    math.fix(3.8)                // returns number 3
+   *    math.fix(-4.2)               // returns number -4
+   *    math.fix(-4.7)               // returns number -4
+   *
+   *    math.fix(3.12, 1)                // returns number 3.1
+   *    math.fix(3.18, 1)                // returns number 3.1
+   *    math.fix(-4.12, 1)               // returns number -4.1
+   *    math.fix(-4.17, 1)               // returns number -4.1
+   *
+   *    const c = math.complex(3.22, -2.78)
+   *    math.fix(c)                  // returns Complex 3 - 2i
+   *    math.fix(c, 1)               // returns Complex 3.2 -2.7i
+   *
+   *    math.fix([3.2, 3.8, -4.7])      // returns Array [3, 3, -4]
+   *    math.fix([3.2, 3.8, -4.7], 1)   // returns Array [3.2, 3.8, -4.7]
+   *
+   * See also:
+   *
+   *    ceil, floor, 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('fix', {
+    number: fixNumber.signatures.number,
+    'number, number | BigNumber': fixNumber.signatures['number,number'],
+    Complex: function Complex(x) {
+      return new _Complex(x.re > 0 ? Math.floor(x.re) : Math.ceil(x.re), x.im > 0 ? Math.floor(x.im) : Math.ceil(x.im));
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, bn) {
+      var n = bn.toNumber();
+      return new _Complex(x.re > 0 ? floor(x.re, n) : ceil(x.re, n), x.im > 0 ? floor(x.im, n) : ceil(x.im, n));
+    },
+    BigNumber: function BigNumber(x) {
+      return x.isNegative() ? ceil(x) : floor(x);
+    },
+    'BigNumber, number | BigNumber': function BigNumberNumberBigNumber(x, n) {
+      return x.isNegative() ? ceil(x, n) : floor(x, n);
+    },
+    Fraction: function Fraction(x) {
+      return x.s < 0 ? x.ceil() : x.floor();
+    },
+    'Fraction, number | BigNumber': function FractionNumberBigNumber(x, n) {
+      return x.s < 0 ? ceil(x, n) : floor(x, n);
+    },
+    'Array | Matrix': typed.referToSelf(self => x => {
+      // deep map collection, skip zeros since fix(0) = 0
+      return deepMap(x, self, true);
+    }),
+    'Array | Matrix, number | BigNumber': typed.referToSelf(self => (x, n) => {
+      // deep map collection, skip zeros since fix(0) = 0
+      return deepMap(x, i => self(i, n), true);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
+      // use matrix implementation
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (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);
+    })
+  });
+});

package/lib/esm/function/arithmetic/floor.js

@@ -0,0 +1,164 @@
+import Decimal from 'decimal.js';
+import { factory } from '../../utils/factory.js';
+import { deepMap } from '../../utils/collection.js';
+import { nearlyEqual } from '../../utils/number.js';
+import { nearlyEqual as bigNearlyEqual } from '../../utils/bignumber/nearlyEqual.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
+var name = 'floor';
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createFloorNumber = /* #__PURE__ */factory(name, ['typed', 'config', 'round'], _ref => {
+  var {
+    typed,
+    config,
+    round
+  } = _ref;
+  return typed(name, {
+    number: function number(x) {
+      if (nearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return Math.floor(x);
+      }
+    },
+    'number, number': function numberNumber(x, n) {
+      if (nearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        var [number, exponent] = "".concat(x, "e").split('e');
+        var result = Math.floor(Number("".concat(number, "e").concat(Number(exponent) + n)));
+        [number, exponent] = "".concat(result, "e").split('e');
+        return Number("".concat(number, "e").concat(Number(exponent) - n));
+      }
+    }
+  });
+});
+export var createFloor = /* #__PURE__ */factory(name, dependencies, _ref2 => {
+  var {
+    typed,
+    config,
+    round,
+    matrix,
+    equalScalar,
+    zeros,
+    DenseMatrix
+  } = _ref2;
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    typed
+  });
+  var floorNumber = createFloorNumber({
+    typed,
+    config,
+    round
+  });
+  /**
+   * Round a value towards minus infinity.
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.floor(x)
+   *    math.floor(x, n)
+   *
+   * Examples:
+   *
+   *    math.floor(3.2)              // returns number 3
+   *    math.floor(3.8)              // returns number 3
+   *    math.floor(-4.2)             // returns number -5
+   *    math.floor(-4.7)             // returns number -5
+   *
+   *    math.floor(3.212, 2)          // returns number 3.21
+   *    math.floor(3.288, 2)          // returns number 3.28
+   *    math.floor(-4.212, 2)         // returns number -4.22
+   *    math.floor(-4.782, 2)         // returns number -4.79
+   *
+   *    const c = math.complex(3.24, -2.71)
+   *    math.floor(c)                 // returns Complex 3 - 3i
+   *    math.floor(c, 1)              // returns Complex 3.2 -2.8i
+   *
+   *    math.floor([3.2, 3.8, -4.7])       // returns Array [3, 3, -5]
+   *    math.floor([3.21, 3.82, -4.71], 1)  // returns Array [3.2, 3.8, -4.8]
+   *
+   *    math.floor(math.tau, [2, 3])  // returns Array [6.28, 6.283]
+   *
+   *    // Note that floor(array, array) currently not implemented.
+   *
+   * See also:
+   *
+   *    ceil, 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('floor', {
+    number: floorNumber.signatures.number,
+    'number,number': floorNumber.signatures['number,number'],
+    Complex: function Complex(x) {
+      return x.floor();
+    },
+    'Complex, number': function ComplexNumber(x, n) {
+      return x.floor(n);
+    },
+    'Complex, BigNumber': function ComplexBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
+    BigNumber: function BigNumber(x) {
+      if (bigNearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return x.floor();
+      }
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, n) {
+      if (bigNearlyEqual(x, round(x, n), config.epsilon)) {
+        return round(x, n);
+      } else {
+        return x.toDecimalPlaces(n.toNumber(), Decimal.ROUND_FLOOR);
+      }
+    },
+    Fraction: function Fraction(x) {
+      return x.floor();
+    },
+    'Fraction, number': function FractionNumber(x, n) {
+      return x.floor(n);
+    },
+    'Fraction, BigNumber': function FractionBigNumber(x, n) {
+      return x.floor(n.toNumber());
+    },
+    'Array | Matrix': typed.referToSelf(self => x => {
+      // deep map collection, skip zeros since floor(0) = 0
+      return deepMap(x, self, true);
+    }),
+    'Array, number | BigNumber': typed.referToSelf(self => (x, n) => {
+      // deep map collection, skip zeros since ceil(0) = 0
+      return deepMap(x, i => self(i, n), true);
+    }),
+    'SparseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo11xS0s(x, y, self, false);
+    }),
+    'DenseMatrix, number | BigNumber': typed.referToSelf(self => (x, y) => {
+      return matAlgo14xDs(x, y, self, false);
+    }),
+    'number | Complex | Fraction | BigNumber, Array': typed.referToSelf(self => (x, y) => {
+      // use matrix implementation
+      return matAlgo14xDs(matrix(y), x, self, true).valueOf();
+    }),
+    'number | Complex | Fraction | BigNumber, Matrix': typed.referToSelf(self => (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);
+    })
+  });
+});

package/lib/esm/function/arithmetic/gcd.js

@@ -0,0 +1,117 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.js';
+import { createMatAlgo04xSidSid } from '../../type/matrix/utils/matAlgo04xSidSid.js';
+import { createMatAlgo10xSids } from '../../type/matrix/utils/matAlgo10xSids.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+import { gcdNumber } from '../../plain/number/index.js';
+import { ArgumentsError } from '../../error/ArgumentsError.js';
+var name = 'gcd';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'DenseMatrix', 'concat'];
+var gcdTypes = 'number | BigNumber | Fraction | Matrix | Array';
+var gcdManyTypesSignature = "".concat(gcdTypes, ", ").concat(gcdTypes, ", ...").concat(gcdTypes);
+function is1d(array) {
+  return !array.some(element => Array.isArray(element));
+}
+export var createGcd = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    equalScalar,
+    BigNumber,
+    DenseMatrix,
+    concat
+  } = _ref;
+  var matAlgo01xDSid = createMatAlgo01xDSid({
+    typed
+  });
+  var matAlgo04xSidSid = createMatAlgo04xSidSid({
+    typed,
+    equalScalar
+  });
+  var matAlgo10xSids = createMatAlgo10xSids({
+    typed,
+    DenseMatrix
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+
+  /**
+   * Calculate the greatest common divisor for two or more values or arrays.
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.gcd(a, b)
+   *    math.gcd(a, b, c, ...)
+   *
+   * Examples:
+   *
+   *    math.gcd(8, 12)              // returns 4
+   *    math.gcd(-4, 6)              // returns 2
+   *    math.gcd(25, 15, -10)        // returns 5
+   *
+   *    math.gcd([8, -4], [12, 6])   // returns [4, 2]
+   *
+   * See also:
+   *
+   *    lcm, xgcd
+   *
+   * @param {... number | BigNumber | Fraction | Array | Matrix} args  Two or more integer numbers
+   * @return {number | BigNumber | Fraction | Array | Matrix}                           The greatest common divisor
+   */
+  return typed(name, {
+    'number, number': gcdNumber,
+    'BigNumber, BigNumber': _gcdBigNumber,
+    'Fraction, Fraction': (x, y) => x.gcd(y)
+  }, matrixAlgorithmSuite({
+    SS: matAlgo04xSidSid,
+    DS: matAlgo01xDSid,
+    Ss: matAlgo10xSids
+  }), {
+    [gcdManyTypesSignature]: typed.referToSelf(self => (a, b, args) => {
+      var res = self(a, b);
+      for (var i = 0; i < args.length; i++) {
+        res = self(res, args[i]);
+      }
+      return res;
+    }),
+    Array: typed.referToSelf(self => array => {
+      if (array.length === 1 && Array.isArray(array[0]) && is1d(array[0])) {
+        return self(...array[0]);
+      }
+      if (is1d(array)) {
+        return self(...array);
+      }
+      throw new ArgumentsError('gcd() supports only 1d matrices!');
+    }),
+    Matrix: typed.referToSelf(self => matrix => {
+      return self(matrix.toArray());
+    })
+  });
+
+  /**
+   * Calculate gcd for BigNumbers
+   * @param {BigNumber} a
+   * @param {BigNumber} b
+   * @returns {BigNumber} Returns greatest common denominator of a and b
+   * @private
+   */
+  function _gcdBigNumber(a, b) {
+    if (!a.isInt() || !b.isInt()) {
+      throw new Error('Parameters in function gcd must be integer numbers');
+    }
+
+    // https://en.wikipedia.org/wiki/Euclidean_algorithm
+    var zero = new BigNumber(0);
+    while (!b.isZero()) {
+      var r = a.mod(b);
+      a = b;
+      b = r;
+    }
+    return a.lt(zero) ? a.neg() : a;
+  }
+});

package/lib/esm/function/arithmetic/hypot.js

@@ -0,0 +1,77 @@
+import { factory } from '../../utils/factory.js';
+import { flatten } from '../../utils/array.js';
+import { isComplex } from '../../utils/is.js';
+var name = 'hypot';
+var dependencies = ['typed', 'abs', 'addScalar', 'divideScalar', 'multiplyScalar', 'sqrt', 'smaller', 'isPositive'];
+export var createHypot = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    abs,
+    addScalar,
+    divideScalar,
+    multiplyScalar,
+    sqrt,
+    smaller,
+    isPositive
+  } = _ref;
+  /**
+   * Calculate the hypotenusa of a list with values. The hypotenusa is defined as:
+   *
+   *     hypot(a, b, c, ...) = sqrt(a^2 + b^2 + c^2 + ...)
+   *
+   * For matrix input, the hypotenusa is calculated for all values in the matrix.
+   *
+   * Syntax:
+   *
+   *     math.hypot(a, b, ...)
+   *     math.hypot([a, b, c, ...])
+   *
+   * Examples:
+   *
+   *     math.hypot(3, 4)      // 5
+   *     math.hypot(3, 4, 5)   // 7.0710678118654755
+   *     math.hypot([3, 4, 5]) // 7.0710678118654755
+   *     math.hypot(-2)        // 2
+   *
+   * See also:
+   *
+   *     abs, norm
+   *
+   * @param {... number | BigNumber | Array | Matrix} args    A list with numeric values or an Array or Matrix.
+   *                                                          Matrix and Array input is flattened and returns a
+   *                                                          single number for the whole matrix.
+   * @return {number | BigNumber} Returns the hypothenusa of the input values.
+   */
+  return typed(name, {
+    '... number | BigNumber': _hypot,
+    Array: _hypot,
+    Matrix: M => _hypot(flatten(M.toArray()))
+  });
+
+  /**
+   * Calculate the hypotenusa for an Array with values
+   * @param {Array.<number | BigNumber>} args
+   * @return {number | BigNumber} Returns the result
+   * @private
+   */
+  function _hypot(args) {
+    // code based on `hypot` from es6-shim:
+    // https://github.com/paulmillr/es6-shim/blob/master/es6-shim.js#L1619-L1633
+    var result = 0;
+    var largest = 0;
+    for (var i = 0; i < args.length; i++) {
+      if (isComplex(args[i])) {
+        throw new TypeError('Unexpected type of argument to hypot');
+      }
+      var value = abs(args[i]);
+      if (smaller(largest, value)) {
+        result = multiplyScalar(result, multiplyScalar(divideScalar(largest, value), divideScalar(largest, value)));
+        result = addScalar(result, 1);
+        largest = value;
+      } else {
+        result = addScalar(result, isPositive(value) ? multiplyScalar(divideScalar(value, largest), divideScalar(value, largest)) : value);
+      }
+    }
+    return multiplyScalar(largest, sqrt(result));
+  }
+});

package/lib/esm/function/arithmetic/invmod.js

@@ -0,0 +1,55 @@
+import { factory } from '../../utils/factory.js';
+var name = 'invmod';
+var dependencies = ['typed', 'config', 'BigNumber', 'xgcd', 'equal', 'smaller', 'mod', 'add', 'isInteger'];
+export var createInvmod = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    BigNumber,
+    xgcd,
+    equal,
+    smaller,
+    mod,
+    add,
+    isInteger
+  } = _ref;
+  /**
+   * Calculate the (modular) multiplicative inverse of a modulo b. Solution to the equation `ax ≣ 1 (mod b)`
+   * See https://en.wikipedia.org/wiki/Modular_multiplicative_inverse.
+   *
+   * Syntax:
+   *
+   *    math.invmod(a, b)
+   *
+   * Examples:
+   *
+   *    math.invmod(8, 12)             // returns NaN
+   *    math.invmod(7, 13)             // returns 2
+   *    math.invmod(15151, 15122)      // returns 10429
+   *
+   * See also:
+   *
+   *    gcd, xgcd
+   *
+   * @param {number | BigNumber} a  An integer number
+   * @param {number | BigNumber} b  An integer number
+   * @return {number | BigNumber }  Returns an integer number
+   *                              where `invmod(a,b)*a ≣ 1 (mod b)`
+   */
+  return typed(name, {
+    'number, number': invmod,
+    'BigNumber, BigNumber': invmod
+  });
+  function invmod(a, b) {
+    if (!isInteger(a) || !isInteger(b)) throw new Error('Parameters in function invmod must be integer numbers');
+    a = mod(a, b);
+    if (equal(b, 0)) throw new Error('Divisor must be non zero');
+    var res = xgcd(a, b);
+    res = res.valueOf();
+    var [gcd, inv] = res;
+    if (!equal(gcd, BigNumber(1))) return NaN;
+    inv = mod(inv, b);
+    if (smaller(inv, BigNumber(0))) inv = add(inv, b);
+    return inv;
+  }
+});

package/lib/esm/function/arithmetic/lcm.js

@@ -0,0 +1,110 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo06xS0S0 } from '../../type/matrix/utils/matAlgo06xS0S0.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+import { lcmNumber } from '../../plain/number/index.js';
+var name = 'lcm';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'concat'];
+export var createLcm = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    equalScalar,
+    concat
+  } = _ref;
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
+    typed,
+    equalScalar
+  });
+  var matAlgo06xS0S0 = createMatAlgo06xS0S0({
+    typed,
+    equalScalar
+  });
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+  var lcmTypes = 'number | BigNumber | Fraction | Matrix | Array';
+  var lcmManySignature = {};
+  lcmManySignature["".concat(lcmTypes, ", ").concat(lcmTypes, ", ...").concat(lcmTypes)] = typed.referToSelf(self => (a, b, args) => {
+    var res = self(a, b);
+    for (var i = 0; i < args.length; i++) {
+      res = self(res, args[i]);
+    }
+    return res;
+  });
+
+  /**
+   * Calculate the least common multiple for two or more values or arrays.
+   *
+   * lcm is defined as:
+   *
+   *     lcm(a, b) = abs(a * b) / gcd(a, b)
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *    math.lcm(a, b)
+   *    math.lcm(a, b, c, ...)
+   *
+   * Examples:
+   *
+   *    math.lcm(4, 6)               // returns 12
+   *    math.lcm(6, 21)              // returns 42
+   *    math.lcm(6, 21, 5)           // returns 210
+   *
+   *    math.lcm([4, 6], [6, 21])    // returns [12, 42]
+   *
+   * See also:
+   *
+   *    gcd, xgcd
+   *
+   * @param {... number | BigNumber | Array | Matrix} args  Two or more integer numbers
+   * @return {number | BigNumber | Array | Matrix}                           The least common multiple
+   */
+  return typed(name, {
+    'number, number': lcmNumber,
+    'BigNumber, BigNumber': _lcmBigNumber,
+    'Fraction, Fraction': (x, y) => x.lcm(y)
+  }, matrixAlgorithmSuite({
+    SS: matAlgo06xS0S0,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }), lcmManySignature);
+
+  /**
+   * Calculate lcm for two BigNumbers
+   * @param {BigNumber} a
+   * @param {BigNumber} b
+   * @returns {BigNumber} Returns the least common multiple of a and b
+   * @private
+   */
+  function _lcmBigNumber(a, b) {
+    if (!a.isInt() || !b.isInt()) {
+      throw new Error('Parameters in function lcm must be integer numbers');
+    }
+    if (a.isZero()) {
+      return a;
+    }
+    if (b.isZero()) {
+      return b;
+    }
+
+    // https://en.wikipedia.org/wiki/Euclidean_algorithm
+    // evaluate lcm here inline to reduce overhead
+    var prod = a.times(b);
+    while (!b.isZero()) {
+      var t = b;
+      b = a.mod(t);
+      a = t;
+    }
+    return prod.div(a).abs();
+  }
+});