mathjs-min 11.7.2

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

@@ -0,0 +1,35 @@
+import { factory } from '../../utils/factory.js';
+import { multiplyNumber } from '../../plain/number/index.js';
+var name = 'multiplyScalar';
+var dependencies = ['typed'];
+export var createMultiplyScalar = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed
+  } = _ref;
+  /**
+   * Multiply two scalar values, `x * y`.
+   * This function is meant for internal use: it is used by the public function
+   * `multiply`
+   *
+   * This function does not support collections (Array or Matrix).
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x   First value to multiply
+   * @param  {number | BigNumber | Fraction | Complex} y          Second value to multiply
+   * @return {number | BigNumber | Fraction | Complex | Unit}     Multiplication of `x` and `y`
+   * @private
+   */
+  return typed('multiplyScalar', {
+    'number, number': multiplyNumber,
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.mul(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return x.times(y);
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return x.mul(y);
+    },
+    'number | Fraction | BigNumber | Complex, Unit': (x, y) => y.multiply(x),
+    'Unit, number | Fraction | BigNumber | Complex | Unit': (x, y) => x.multiply(y)
+  });
+});

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

@@ -0,0 +1,287 @@
+import { factory } from '../../utils/factory.js';
+var name = 'norm';
+var dependencies = ['typed', 'abs', 'add', 'pow', 'conj', 'sqrt', 'multiply', 'equalScalar', 'larger', 'smaller', 'matrix', 'ctranspose', 'eigs'];
+export var createNorm = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    abs,
+    add,
+    pow,
+    conj,
+    sqrt,
+    multiply,
+    equalScalar,
+    larger,
+    smaller,
+    matrix,
+    ctranspose,
+    eigs
+  } = _ref;
+  /**
+   * Calculate the norm of a number, vector or matrix.
+   *
+   * The second parameter p is optional. If not provided, it defaults to 2.
+   *
+   * Syntax:
+   *
+   *    math.norm(x)
+   *    math.norm(x, p)
+   *
+   * Examples:
+   *
+   *    math.abs(-3.5)                         // returns 3.5
+   *    math.norm(-3.5)                        // returns 3.5
+   *
+   *    math.norm(math.complex(3, -4))         // returns 5
+   *
+   *    math.norm([1, 2, -3], Infinity)        // returns 3
+   *    math.norm([1, 2, -3], -Infinity)       // returns 1
+   *
+   *    math.norm([3, 4], 2)                   // returns 5
+   *
+   *    math.norm([[1, 2], [3, 4]], 1)          // returns 6
+   *    math.norm([[1, 2], [3, 4]], 'inf')     // returns 7
+   *    math.norm([[1, 2], [3, 4]], 'fro')     // returns 5.477225575051661
+   *
+   * See also:
+   *
+   *    abs, hypot
+   *
+   * @param  {number | BigNumber | Complex | Array | Matrix} x
+   *            Value for which to calculate the norm
+   * @param  {number | BigNumber | string} [p=2]
+   *            Vector space.
+   *            Supported numbers include Infinity and -Infinity.
+   *            Supported strings are: 'inf', '-inf', and 'fro' (The Frobenius norm)
+   * @return {number | BigNumber} the p-norm
+   */
+  return typed(name, {
+    number: Math.abs,
+    Complex: function Complex(x) {
+      return x.abs();
+    },
+    BigNumber: function BigNumber(x) {
+      // norm(x) = abs(x)
+      return x.abs();
+    },
+    boolean: function boolean(x) {
+      // norm(x) = abs(x)
+      return Math.abs(x);
+    },
+    Array: function Array(x) {
+      return _norm(matrix(x), 2);
+    },
+    Matrix: function Matrix(x) {
+      return _norm(x, 2);
+    },
+    'Array, number | BigNumber | string': function ArrayNumberBigNumberString(x, p) {
+      return _norm(matrix(x), p);
+    },
+    'Matrix, number | BigNumber | string': function MatrixNumberBigNumberString(x, p) {
+      return _norm(x, p);
+    }
+  });
+
+  /**
+   * Calculate the plus infinity norm for a vector
+   * @param {Matrix} x
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _vectorNormPlusInfinity(x) {
+    // norm(x, Infinity) = max(abs(x))
+    var pinf = 0;
+    // skip zeros since abs(0) === 0
+    x.forEach(function (value) {
+      var v = abs(value);
+      if (larger(v, pinf)) {
+        pinf = v;
+      }
+    }, true);
+    return pinf;
+  }
+
+  /**
+   * Calculate the minus infinity norm for a vector
+   * @param {Matrix} x
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _vectorNormMinusInfinity(x) {
+    // norm(x, -Infinity) = min(abs(x))
+    var ninf;
+    // skip zeros since abs(0) === 0
+    x.forEach(function (value) {
+      var v = abs(value);
+      if (!ninf || smaller(v, ninf)) {
+        ninf = v;
+      }
+    }, true);
+    return ninf || 0;
+  }
+
+  /**
+   * Calculate the norm for a vector
+   * @param {Matrix} x
+   * @param {number | string} p
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _vectorNorm(x, p) {
+    // check p
+    if (p === Number.POSITIVE_INFINITY || p === 'inf') {
+      return _vectorNormPlusInfinity(x);
+    }
+    if (p === Number.NEGATIVE_INFINITY || p === '-inf') {
+      return _vectorNormMinusInfinity(x);
+    }
+    if (p === 'fro') {
+      return _norm(x, 2);
+    }
+    if (typeof p === 'number' && !isNaN(p)) {
+      // check p != 0
+      if (!equalScalar(p, 0)) {
+        // norm(x, p) = sum(abs(xi) ^ p) ^ 1/p
+        var n = 0;
+        // skip zeros since abs(0) === 0
+        x.forEach(function (value) {
+          n = add(pow(abs(value), p), n);
+        }, true);
+        return pow(n, 1 / p);
+      }
+      return Number.POSITIVE_INFINITY;
+    }
+    // invalid parameter value
+    throw new Error('Unsupported parameter value');
+  }
+
+  /**
+   * Calculate the Frobenius norm for a matrix
+   * @param {Matrix} x
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _matrixNormFrobenius(x) {
+    // norm(x) = sqrt(sum(diag(x'x)))
+    var fro = 0;
+    x.forEach(function (value, index) {
+      fro = add(fro, multiply(value, conj(value)));
+    });
+    return abs(sqrt(fro));
+  }
+
+  /**
+   * Calculate the norm L1 for a matrix
+   * @param {Matrix} x
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _matrixNormOne(x) {
+    // norm(x) = the largest column sum
+    var c = [];
+    // result
+    var maxc = 0;
+    // skip zeros since abs(0) == 0
+    x.forEach(function (value, index) {
+      var j = index[1];
+      var cj = add(c[j] || 0, abs(value));
+      if (larger(cj, maxc)) {
+        maxc = cj;
+      }
+      c[j] = cj;
+    }, true);
+    return maxc;
+  }
+
+  /**
+   * Calculate the norm L2 for a matrix
+   * @param {Matrix} x
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _matrixNormTwo(x) {
+    // norm(x) = sqrt( max eigenvalue of A*.A)
+    var sizeX = x.size();
+    if (sizeX[0] !== sizeX[1]) {
+      throw new RangeError('Invalid matrix dimensions');
+    }
+    var tx = ctranspose(x);
+    var squaredX = multiply(tx, x);
+    var eigenVals = eigs(squaredX).values.toArray();
+    var rho = eigenVals[eigenVals.length - 1];
+    return abs(sqrt(rho));
+  }
+
+  /**
+   * Calculate the infinity norm for a matrix
+   * @param {Matrix} x
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _matrixNormInfinity(x) {
+    // norm(x) = the largest row sum
+    var r = [];
+    // result
+    var maxr = 0;
+    // skip zeros since abs(0) == 0
+    x.forEach(function (value, index) {
+      var i = index[0];
+      var ri = add(r[i] || 0, abs(value));
+      if (larger(ri, maxr)) {
+        maxr = ri;
+      }
+      r[i] = ri;
+    }, true);
+    return maxr;
+  }
+
+  /**
+   * Calculate the norm for a 2D Matrix (M*N)
+   * @param {Matrix} x
+   * @param {number | string} p
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _matrixNorm(x, p) {
+    // check p
+    if (p === 1) {
+      return _matrixNormOne(x);
+    }
+    if (p === Number.POSITIVE_INFINITY || p === 'inf') {
+      return _matrixNormInfinity(x);
+    }
+    if (p === 'fro') {
+      return _matrixNormFrobenius(x);
+    }
+    if (p === 2) {
+      return _matrixNormTwo(x);
+    } // invalid parameter value
+
+    throw new Error('Unsupported parameter value ' + p);
+  }
+
+  /**
+   * Calculate the norm for an array
+   * @param {Matrix} x
+   * @param {number | string} p
+   * @returns {number} Returns the norm
+   * @private
+   */
+  function _norm(x, p) {
+    // size
+    var sizeX = x.size();
+
+    // check if it is a vector
+    if (sizeX.length === 1) {
+      return _vectorNorm(x, p);
+    }
+    // MxN matrix
+    if (sizeX.length === 2) {
+      if (sizeX[0] && sizeX[1]) {
+        return _matrixNorm(x, p);
+      } else {
+        throw new RangeError('Invalid matrix dimensions');
+      }
+    }
+  }
+});

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

@@ -0,0 +1,166 @@
+import { factory } from '../../utils/factory.js';
+import { createMatAlgo01xDSid } from '../../type/matrix/utils/matAlgo01xDSid.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 { nthRootNumber } from '../../plain/number/index.js';
+var name = 'nthRoot';
+var dependencies = ['typed', 'matrix', 'equalScalar', 'BigNumber', 'concat'];
+export var createNthRoot = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    matrix,
+    equalScalar,
+    BigNumber: _BigNumber,
+    concat
+  } = _ref;
+  var matAlgo01xDSid = createMatAlgo01xDSid({
+    typed
+  });
+  var matAlgo02xDS0 = createMatAlgo02xDS0({
+    typed,
+    equalScalar
+  });
+  var matAlgo06xS0S0 = createMatAlgo06xS0S0({
+    typed,
+    equalScalar
+  });
+  var matAlgo11xS0s = createMatAlgo11xS0s({
+    typed,
+    equalScalar
+  });
+  var matrixAlgorithmSuite = createMatrixAlgorithmSuite({
+    typed,
+    matrix,
+    concat
+  });
+
+  /**
+   * Calculate the nth root of a value.
+   * The principal nth root of a positive real number A, is the positive real
+   * solution of the equation
+   *
+   *     x^root = A
+   *
+   * For matrices, the function is evaluated element wise.
+   *
+   * Syntax:
+   *
+   *     math.nthRoot(a)
+   *     math.nthRoot(a, root)
+   *
+   * Examples:
+   *
+   *     math.nthRoot(9, 2)    // returns 3 (since 3^2 == 9)
+   *     math.sqrt(9)          // returns 3 (since 3^2 == 9)
+   *     math.nthRoot(64, 3)   // returns 4 (since 4^3 == 64)
+   *
+   * See also:
+   *
+   *     sqrt, pow
+   *
+   * @param {number | BigNumber | Array | Matrix | Complex} a
+   *              Value for which to calculate the nth root
+   * @param {number | BigNumber} [root=2]    The root.
+   * @return {number | Complex | Array | Matrix} Returns the nth root of `a`
+   */
+  function complexErr() {
+    throw new Error('Complex number not supported in function nthRoot. Use nthRoots instead.');
+  }
+  return typed(name, {
+    number: nthRootNumber,
+    'number, number': nthRootNumber,
+    BigNumber: x => _bigNthRoot(x, new _BigNumber(2)),
+    'BigNumber, BigNumber': _bigNthRoot,
+    Complex: complexErr,
+    'Complex, number': complexErr,
+    Array: typed.referTo('DenseMatrix,number', selfDn => x => selfDn(matrix(x), 2).valueOf()),
+    DenseMatrix: typed.referTo('DenseMatrix,number', selfDn => x => selfDn(x, 2)),
+    SparseMatrix: typed.referTo('SparseMatrix,number', selfSn => x => selfSn(x, 2)),
+    'SparseMatrix, SparseMatrix': typed.referToSelf(self => (x, y) => {
+      // density must be one (no zeros in matrix)
+      if (y.density() === 1) {
+        // sparse + sparse
+        return matAlgo06xS0S0(x, y, self);
+      } else {
+        // throw exception
+        throw new Error('Root must be non-zero');
+      }
+    }),
+    'DenseMatrix, SparseMatrix': typed.referToSelf(self => (x, y) => {
+      // density must be one (no zeros in matrix)
+      if (y.density() === 1) {
+        // dense + sparse
+        return matAlgo01xDSid(x, y, self, false);
+      } else {
+        // throw exception
+        throw new Error('Root must be non-zero');
+      }
+    }),
+    'Array, SparseMatrix': typed.referTo('DenseMatrix,SparseMatrix', selfDS => (x, y) => selfDS(matrix(x), y)),
+    'number | BigNumber, SparseMatrix': typed.referToSelf(self => (x, y) => {
+      // density must be one (no zeros in matrix)
+      if (y.density() === 1) {
+        // sparse - scalar
+        return matAlgo11xS0s(y, x, self, true);
+      } else {
+        // throw exception
+        throw new Error('Root must be non-zero');
+      }
+    })
+  }, matrixAlgorithmSuite({
+    scalar: 'number | BigNumber',
+    SD: matAlgo02xDS0,
+    Ss: matAlgo11xS0s,
+    sS: false
+  }));
+
+  /**
+   * Calculate the nth root of a for BigNumbers, solve x^root == a
+   * https://rosettacode.org/wiki/Nth_root#JavaScript
+   * @param {BigNumber} a
+   * @param {BigNumber} root
+   * @private
+   */
+  function _bigNthRoot(a, root) {
+    var precision = _BigNumber.precision;
+    var Big = _BigNumber.clone({
+      precision: precision + 2
+    });
+    var zero = new _BigNumber(0);
+    var one = new Big(1);
+    var inv = root.isNegative();
+    if (inv) {
+      root = root.neg();
+    }
+    if (root.isZero()) {
+      throw new Error('Root must be non-zero');
+    }
+    if (a.isNegative() && !root.abs().mod(2).equals(1)) {
+      throw new Error('Root must be odd when a is negative.');
+    }
+
+    // edge cases zero and infinity
+    if (a.isZero()) {
+      return inv ? new Big(Infinity) : 0;
+    }
+    if (!a.isFinite()) {
+      return inv ? zero : a;
+    }
+    var x = a.abs().pow(one.div(root));
+    // If a < 0, we require that root is an odd integer,
+    // so (-1) ^ (1/root) = -1
+    x = a.isNeg() ? x.neg() : x;
+    return new _BigNumber((inv ? one.div(x) : x).toPrecision(precision));
+  }
+});
+export var createNthRootNumber = /* #__PURE__ */factory(name, ['typed'], _ref2 => {
+  var {
+    typed
+  } = _ref2;
+  return typed(name, {
+    number: nthRootNumber,
+    'number, number': nthRootNumber
+  });
+});

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

@@ -0,0 +1,112 @@
+import { factory } from '../../utils/factory.js';
+var name = 'nthRoots';
+var dependencies = ['config', 'typed', 'divideScalar', 'Complex'];
+export var createNthRoots = /* #__PURE__ */factory(name, dependencies, _ref => {
+  var {
+    typed,
+    config,
+    divideScalar,
+    Complex
+  } = _ref;
+  /**
+   * Each function here returns a real multiple of i as a Complex value.
+   * @param  {number} val
+   * @return {Complex} val, i*val, -val or -i*val for index 0, 1, 2, 3
+   */
+  // This is used to fix float artifacts for zero-valued components.
+  var _calculateExactResult = [function realPos(val) {
+    return new Complex(val, 0);
+  }, function imagPos(val) {
+    return new Complex(0, val);
+  }, function realNeg(val) {
+    return new Complex(-val, 0);
+  }, function imagNeg(val) {
+    return new Complex(0, -val);
+  }];
+
+  /**
+   * Calculate the nth root of a Complex Number a using De Movire's Theorem.
+   * @param  {Complex} a
+   * @param  {number} root
+   * @return {Array} array of n Complex Roots
+   */
+  function _nthComplexRoots(a, root) {
+    if (root < 0) throw new Error('Root must be greater than zero');
+    if (root === 0) throw new Error('Root must be non-zero');
+    if (root % 1 !== 0) throw new Error('Root must be an integer');
+    if (a === 0 || a.abs() === 0) return [new Complex(0, 0)];
+    var aIsNumeric = typeof a === 'number';
+    var offset;
+    // determine the offset (argument of a)/(pi/2)
+    if (aIsNumeric || a.re === 0 || a.im === 0) {
+      if (aIsNumeric) {
+        offset = 2 * +(a < 0); // numeric value on the real axis
+      } else if (a.im === 0) {
+        offset = 2 * +(a.re < 0); // complex value on the real axis
+      } else {
+        offset = 2 * +(a.im < 0) + 1; // complex value on the imaginary axis
+      }
+    }
+
+    var arg = a.arg();
+    var abs = a.abs();
+    var roots = [];
+    var r = Math.pow(abs, 1 / root);
+    for (var k = 0; k < root; k++) {
+      var halfPiFactor = (offset + 4 * k) / root;
+      /**
+       * If (offset + 4*k)/root is an integral multiple of pi/2
+       * then we can produce a more exact result.
+       */
+      if (halfPiFactor === Math.round(halfPiFactor)) {
+        roots.push(_calculateExactResult[halfPiFactor % 4](r));
+        continue;
+      }
+      roots.push(new Complex({
+        r,
+        phi: (arg + 2 * Math.PI * k) / root
+      }));
+    }
+    return roots;
+  }
+
+  /**
+   * Calculate the nth roots of a value.
+   * An nth root of a positive real number A,
+   * is a positive real solution of the equation "x^root = A".
+   * This function returns an array of complex values.
+   *
+   * Syntax:
+   *
+   *    math.nthRoots(x)
+   *    math.nthRoots(x, root)
+   *
+   * Examples:
+   *
+   *    math.nthRoots(1)
+   *    // returns [
+   *    //   {re: 1, im: 0},
+   *    //   {re: -1, im: 0}
+   *    // ]
+   *    math.nthRoots(1, 3)
+   *    // returns [
+   *    //   { re: 1, im: 0 },
+   *    //   { re: -0.4999999999999998, im: 0.8660254037844387 },
+   *    //   { re: -0.5000000000000004, im: -0.8660254037844385 }
+   *    // ]
+   *
+   * See also:
+   *
+   *    nthRoot, pow, sqrt
+   *
+   * @param {number | BigNumber | Fraction | Complex} x Number to be rounded
+   * @param {number} [root=2] Optional root, default value is 2
+   * @return {number | BigNumber | Fraction | Complex} Returns the nth roots
+   */
+  return typed(name, {
+    Complex: function Complex(x) {
+      return _nthComplexRoots(x, 2);
+    },
+    'Complex, number': _nthComplexRoots
+  });
+});