mathjs-min 11.7.2

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

@@ -0,0 +1,161 @@
+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 = 'ceil';
+var dependencies = ['typed', 'config', 'round', 'matrix', 'equalScalar', 'zeros', 'DenseMatrix'];
+export var createCeilNumber = /* #__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.ceil(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.ceil(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 createCeil = /* #__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 ceilNumber = createCeilNumber({
+    typed,
+    config,
+    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 (bigNearlyEqual(x, round(x), config.epsilon)) {
+        return round(x);
+      } else {
+        return x.ceil();
+      }
+    },
+    '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_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(self => x => {
+      // deep map collection, skip zeros since ceil(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/cube.js

@@ -0,0 +1,51 @@
+import { factory } from '../../utils/factory.js';
+import { cubeNumber } from '../../plain/number/index.js';
+var name = 'cube';
+var dependencies = ['typed'];
+export var createCube = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * 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: 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);
+    }
+  });
+});

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

@@ -0,0 +1,79 @@
+import { factory } from '../../utils/factory.js';
+import { extend } from '../../utils/object.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo14xDs } from '../../type/matrix/utils/matAlgo14xDs.js';
+var name = 'divide';
+var dependencies = ['typed', 'matrix', 'multiply', 'equalScalar', 'divideScalar', 'inv'];
+export var createDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    multiply,
+    equalScalar,
+    divideScalar,
+    inv
+  } = _ref;
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matAlgo14xDs = createMatAlgo14xDs({
+    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', 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));
+});

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

@@ -0,0 +1,37 @@
+import { factory } from '../../utils/factory.js';
+var name = 'divideScalar';
+var dependencies = ['typed', 'numeric'];
+export var createDivideScalar = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    numeric
+  } = _ref;
+  /**
+   * 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': (x, y) => x.divide(y),
+    'number | Fraction | Complex | BigNumber, Unit': (x, y) => y.divideInto(x)
+  });
+});

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

@@ -0,0 +1,78 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+var name = 'dotDivide';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'divideScalar', 'DenseMatrix', 'concat'];
+export var createDotDivide = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    equalScalar,
+    divideScalar,
+    DenseMatrix,
+    concat
+  } = _ref;
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
+    typed,
+    equalScalar
+  });
+  var matAlgo03xDSf = createMatAlgo03xDSf({
+    typed
+  });
+  var matAlgo07xSSf = createMatAlgo07xSSf({
+    typed,
+    DenseMatrix
+  });
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    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
+  }));
+});

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

@@ -0,0 +1,66 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo02xDS0 } from '../../type/matrix/utils/matAlgo02xDS0.js';
+import { createMatAlgo09xS0Sf } from '../../type/matrix/utils/matAlgo09xS0Sf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+var name = 'dotMultiply';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'multiplyScalar', 'concat'];
+export var createDotMultiply = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    equalScalar,
+    multiplyScalar,
+    concat
+  } = _ref;
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
+    typed,
+    equalScalar
+  });
+  var matAlgo09xS0Sf = createMatAlgo09xS0Sf({
+    typed,
+    equalScalar
+  });
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+
+  /**
+   * Multiply two matrices element wise. The function accepts both matrices and
+   * scalar values.
+   *
+   * Syntax:
+   *
+   *    math.dotMultiply(x, y)
+   *
+   * Examples:
+   *
+   *    math.dotMultiply(2, 4) // returns 8
+   *
+   *    a = [[9, 5], [6, 1]]
+   *    b = [[3, 2], [5, 2]]
+   *
+   *    math.dotMultiply(a, b) // returns [[27, 10], [30, 2]]
+   *    math.multiply(a, b)    // returns [[52, 28], [23, 14]]
+   *
+   * See also:
+   *
+   *    multiply, divide, dotDivide
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x Left hand value
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Right hand value
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}                    Multiplication of `x` and `y`
+   */
+  return typed(name, matrixAlgorithmSuite({
+    elop: multiplyScalar,
+    SS: matAlgo09xS0Sf,
+    DS: matAlgo02xDS0,
+    Ss: matAlgo11xS0s
+  }));
+});

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

@@ -0,0 +1,78 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo03xDSf } from '../../type/matrix/utils/matAlgo03xDSf.js';
+import { createMatAlgo07xSSf } from '../../type/matrix/utils/matAlgo07xSSf.js';
+import { createMatAlgo11xS0s } from '../../type/matrix/utils/matAlgo11xS0s.js';
+import { createMatAlgo12xSfs } from '../../type/matrix/utils/matAlgo12xSfs.js';
+import { createMatrixAlgorithmSuite } from '../../type/matrix/utils/matrixAlgorithmSuite.js';
+var name = 'dotPow';
+var dependencies = ['typed', 'equalScalar', 'matrix', 'pow', 'DenseMatrix', 'concat'];
+export var createDotPow = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    equalScalar,
+    matrix,
+    pow,
+    DenseMatrix,
+    concat
+  } = _ref;
+  var matAlgo03xDSf = createMatAlgo03xDSf({
+    typed
+  });
+  var matAlgo07xSSf = createMatAlgo07xSSf({
+    typed,
+    DenseMatrix
+  });
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matAlgo12xSfs = createMatAlgo12xSfs({
+    typed,
+    DenseMatrix
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+  var powScalarSignatures = {};
+  for (var signature in pow.signatures) {
+    if (Object.prototype.hasOwnProperty.call(pow.signatures, signature)) {
+      if (!signature.includes('Matrix') && !signature.includes('Array')) {
+        powScalarSignatures[signature] = pow.signatures[signature];
+      }
+    }
+  }
+  var powScalar = typed(powScalarSignatures);
+
+  /**
+   * Calculates the power of x to y element wise.
+   *
+   * Syntax:
+   *
+   *    math.dotPow(x, y)
+   *
+   * Examples:
+   *
+   *    math.dotPow(2, 3)            // returns number 8
+   *
+   *    const a = [[1, 2], [4, 3]]
+   *    math.dotPow(a, 2)            // returns Array [[1, 4], [16, 9]]
+   *    math.pow(a, 2)               // returns Array [[9, 8], [16, 17]]
+   *
+   * See also:
+   *
+   *    pow, sqrt, multiply
+   *
+   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} x  The base
+   * @param  {number | BigNumber | Complex | Unit | Array | Matrix} y  The exponent
+   * @return {number | BigNumber | Complex | Unit | Array | Matrix}                     The value of `x` to the power `y`
+   */
+  return typed(name, matrixAlgorithmSuite({
+    elop: powScalar,
+    SS: matAlgo07xSSf,
+    DS: matAlgo03xDSf,
+    Ss: matAlgo11xS0s,
+    sS: matAlgo12xSfs
+  }));
+});

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

@@ -0,0 +1,48 @@
+import { factory } from '../../utils/factory.js';
+import { expNumber } from '../../plain/number/index.js';
+var name = 'exp';
+var dependencies = ['typed'];
+export var createExp = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Calculate the exponential of a value.
+   * For matrices, if you want the matrix exponential of square matrix, use
+   * the `expm` function; if you want to take the exponential of each element,
+   * see the examples.
+   *
+   * Syntax:
+   *
+   *    math.exp(x)
+   *
+   * Examples:
+   *
+   *    math.exp(2)                  // returns number 7.3890560989306495
+   *    math.pow(math.e, 2)          // returns number 7.3890560989306495
+   *    math.log(math.exp(2))        // returns number 2
+   *
+   *    math.map([1, 2, 3], math.exp)
+   *    // returns Array [
+   *    //   2.718281828459045,
+   *    //   7.3890560989306495,
+   *    //   20.085536923187668
+   *    // ]
+   *
+   * See also:
+   *
+   *    expm1, expm, log, pow
+   *
+   * @param {number | BigNumber | Complex} x  A number to exponentiate
+   * @return {number | BigNumber | Complex} Exponential of `x`
+   */
+  return typed(name, {
+    number: expNumber,
+    Complex: function Complex(x) {
+      return x.exp();
+    },
+    BigNumber: function BigNumber(x) {
+      return x.exp();
+    }
+  });
+});

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

@@ -0,0 +1,53 @@
+import { factory } from '../../utils/factory.js';
+import { expm1Number } from '../../plain/number/index.js';
+var name = 'expm1';
+var dependencies = ['typed', 'Complex'];
+export var createExpm1 = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    Complex: _Complex
+  } = _ref;
+  /**
+   * Calculate the value of subtracting 1 from the exponential value.
+   * This function is more accurate than `math.exp(x)-1` when `x` is near 0
+   * To avoid ambiguity with the matrix exponential `expm`, this function
+   * does not operate on matrices; if you wish to apply it elementwise, see
+   * the examples.
+   *
+   * Syntax:
+   *
+   *    math.expm1(x)
+   *
+   * Examples:
+   *
+   *    math.expm1(2)                      // returns number 6.38905609893065
+   *    math.pow(math.e, 2) - 1            // returns number 6.3890560989306495
+   *    math.expm1(1e-8)                   // returns number 1.0000000050000001e-8
+   *    math.exp(1e-8) - 1                 // returns number 9.9999999392253e-9
+   *    math.log(math.expm1(2) + 1)        // returns number 2
+   *
+   *    math.map([1, 2, 3], math.expm1)
+   *    // returns Array [
+   *    //   1.718281828459045,
+   *    //   6.3890560989306495,
+   *    //   19.085536923187668
+   *    // ]
+   *
+   * See also:
+   *
+   *    exp, expm, log, pow
+   *
+   * @param {number | BigNumber | Complex} x  The number to exponentiate
+   * @return {number | BigNumber | Complex} Exponential of `x`, minus one
+   */
+  return typed(name, {
+    number: expm1Number,
+    Complex: function Complex(x) {
+      var r = Math.exp(x.re);
+      return new _Complex(r * Math.cos(x.im) - 1, r * Math.sin(x.im));
+    },
+    BigNumber: function BigNumber(x) {
+      return x.exp().minus(1);
+    }
+  });
+});