mathjs 9.4.0 → 9.4.4

package/lib/esm/function/geometry/intersect.js

@@ -1,7 +1,7 @@
 import { isBigNumber } from '../../utils/is.js';
 import { factory } from '../../utils/factory.js';
 var name = 'intersect';
-var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar'];
+var dependencies = ['typed', 'config', 'abs', 'add', 'addScalar', 'matrix', 'multiply', 'multiplyScalar', 'divideScalar', 'subtract', 'smaller', 'equalScalar', 'flatten'];
 export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     typed,
@@ -15,7 +15,8 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     divideScalar,
     subtract,
     smaller,
-    equalScalar
+    equalScalar,
+    flatten
   } = _ref;
 
   /**
@@ -42,74 +43,104 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
    * @param  {Array | Matrix} y   Co-ordinates of first end-point of second line
    *                              OR Co-efficients of the plane's equation
    * @param  {Array | Matrix} z   Co-ordinates of second end-point of second line
-   *                              OR null if the calculation is for line and plane
+   *                              OR undefined if the calculation is for line and plane
    * @return {Array}              Returns the point of intersection of lines/lines-planes
    */
   return typed('intersect', {
-    'Array, Array, Array': function ArrayArrayArray(x, y, plane) {
-      if (!_3d(x)) {
+    'Array, Array, Array': _AAA,
+    'Array, Array, Array, Array': _AAAA,
+    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(x, y, plane) {
+      var arr = _AAA(x.valueOf(), y.valueOf(), plane.valueOf());
+
+      return arr === null ? null : matrix(arr);
+    },
+    'Matrix, Matrix, Matrix, Matrix': function MatrixMatrixMatrixMatrix(w, x, y, z) {
+      // TODO: output matrix type should match input matrix type
+      var arr = _AAAA(w.valueOf(), x.valueOf(), y.valueOf(), z.valueOf());
+
+      return arr === null ? null : matrix(arr);
+    }
+  });
+
+  function _AAA(x, y, plane) {
+    x = _coerceArr(x);
+    y = _coerceArr(y);
+    plane = _coerceArr(plane);
+
+    if (!_3d(x)) {
+      throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
+    }
+
+    if (!_3d(y)) {
+      throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
+    }
+
+    if (!_4d(plane)) {
+      throw new TypeError('Array with 4 numbers expected as third argument');
+    }
+
+    return _intersectLinePlane(x[0], x[1], x[2], y[0], y[1], y[2], plane[0], plane[1], plane[2], plane[3]);
+  }
+
+  function _AAAA(w, x, y, z) {
+    w = _coerceArr(w);
+    x = _coerceArr(x);
+    y = _coerceArr(y);
+    z = _coerceArr(z);
+
+    if (w.length === 2) {
+      if (!_2d(w)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
+      }
+
+      if (!_2d(x)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for second argument');
+      }
+
+      if (!_2d(y)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
+      }
+
+      if (!_2d(z)) {
+        throw new TypeError('Array with 2 numbers or BigNumbers expected for fourth argument');
+      }
+
+      return _intersect2d(w, x, y, z);
+    } else if (w.length === 3) {
+      if (!_3d(w)) {
         throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
       }
 
-      if (!_3d(y)) {
+      if (!_3d(x)) {
         throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
       }
 
-      if (!_4d(plane)) {
-        throw new TypeError('Array with 4 numbers expected as third argument');
+      if (!_3d(y)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for third argument');
       }
 
-      return _intersectLinePlane(x[0], x[1], x[2], y[0], y[1], y[2], plane[0], plane[1], plane[2], plane[3]);
-    },
-    'Array, Array, Array, Array': function ArrayArrayArrayArray(w, x, y, z) {
-      if (w.length === 2) {
-        if (!_2d(w)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for first argument');
-        }
-
-        if (!_2d(x)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for second argument');
-        }
-
-        if (!_2d(y)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for third argument');
-        }
-
-        if (!_2d(z)) {
-          throw new TypeError('Array with 2 numbers or BigNumbers expected for fourth argument');
-        }
-
-        return _intersect2d(w, x, y, z);
-      } else if (w.length === 3) {
-        if (!_3d(w)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for first argument');
-        }
-
-        if (!_3d(x)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for second argument');
-        }
-
-        if (!_3d(y)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for third argument');
-        }
-
-        if (!_3d(z)) {
-          throw new TypeError('Array with 3 numbers or BigNumbers expected for fourth argument');
-        }
-
-        return _intersect3d(w[0], w[1], w[2], x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
-      } else {
-        throw new TypeError('Arrays with two or thee dimensional points expected');
+      if (!_3d(z)) {
+        throw new TypeError('Array with 3 numbers or BigNumbers expected for fourth argument');
       }
-    },
-    'Matrix, Matrix, Matrix': function MatrixMatrixMatrix(x, y, plane) {
-      return matrix(this(x.valueOf(), y.valueOf(), plane.valueOf()));
-    },
-    'Matrix, Matrix, Matrix, Matrix': function MatrixMatrixMatrixMatrix(w, x, y, z) {
-      // TODO: output matrix type should match input matrix type
-      return matrix(this(w.valueOf(), x.valueOf(), y.valueOf(), z.valueOf()));
+
+      return _intersect3d(w[0], w[1], w[2], x[0], x[1], x[2], y[0], y[1], y[2], z[0], z[1], z[2]);
+    } else {
+      throw new TypeError('Arrays with two or thee dimensional points expected');
     }
-  });
+  }
+  /** Coerce row and column 2-dim arrays to 1-dim array */
+
+
+  function _coerceArr(arr) {
+    // row matrix
+    if (arr.length === 1) return arr[0]; // column matrix
+
+    if (arr.length > 1 && Array.isArray(arr[0])) {
+      if (arr.every(el => Array.isArray(el) && el.length === 1)) return flatten(arr);
+    }
+
+    return arr;
+  }
 
   function _isNumeric(a) {
     // intersect supports numbers and bignumbers
@@ -189,7 +220,9 @@ export var createIntersect = /* #__PURE__ */factory(name, dependencies, _ref =>
     var y2y = multiplyScalar(y2, y);
     var z1z = multiplyScalar(z1, z);
     var z2z = multiplyScalar(z2, z);
-    var t = divideScalar(subtract(subtract(subtract(c, x1x), y1y), z1z), subtract(subtract(subtract(addScalar(addScalar(x2x, y2y), z2z), x1x), y1y), z1z));
+    var numerator = subtract(subtract(subtract(c, x1x), y1y), z1z);
+    var denominator = subtract(subtract(subtract(addScalar(addScalar(x2x, y2y), z2z), x1x), y1y), z1z);
+    var t = divideScalar(numerator, denominator);
     var px = addScalar(x1, multiplyScalar(t, subtract(x2, x1)));
     var py = addScalar(y1, multiplyScalar(t, subtract(y2, y1)));
     var pz = addScalar(z1, multiplyScalar(t, subtract(z2, z1)));

package/lib/esm/function/matrix/eigs/complexEigs.js

@@ -13,15 +13,14 @@ export function createComplexEigs(_ref) {
     diag,
     inv,
     qr,
+    usolve,
     usolveAll,
     equal,
     complex,
     larger,
     smaller,
-    round,
-    log10,
-    transpose,
-    matrixFromColumns
+    matrixFromColumns,
+    dot
   } = _ref;
 
   /**
@@ -64,7 +63,7 @@ export function createComplexEigs(_ref) {
     var vectors;
 
     if (findVectors) {
-      vectors = findEigenvectors(arr, N, C, values, prec);
+      vectors = findEigenvectors(arr, N, C, values, prec, type);
       vectors = matrixFromColumns(...vectors);
     }
 
@@ -397,13 +396,18 @@ export function createComplexEigs(_ref) {
    * @param {number} N size of A
    * @param {Matrix} C column transformation matrix that turns A into upper triangular
    * @param {number[]} values array of eigenvalues of A
+   * @param {'number'|'BigNumber'|'Complex'} type
    * @returns {number[][]} eigenvalues
    */
 
 
-  function findEigenvectors(A, N, C, values, prec) {
+  function findEigenvectors(A, N, C, values, prec, type) {
     var Cinv = inv(C);
-    var U = multiply(Cinv, A, C); // turn values into a kind of "multiset"
+    var U = multiply(Cinv, A, C);
+    var big = type === 'BigNumber';
+    var cplx = type === 'Complex';
+    var zero = big ? bignumber(0) : cplx ? complex(0) : 0;
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1; // turn values into a kind of "multiset"
     // this way it is easier to find eigenvectors
 
     var uniqueValues = [];
@@ -413,11 +417,7 @@ export function createComplexEigs(_ref) {
       var i = indexOf(uniqueValues, λ, equal);
 
       if (i === -1) {
-        // a dirty trick that helps us find more vectors
-        // TODO with iterative algorithm this can be removed
-        // Note: the round around log10 is needed to prevent rounding off errors in IE
-        var rounded = round(λ, subtract(-1, round(log10(prec))));
-        uniqueValues.push(rounded);
+        uniqueValues.push(λ);
         multiplicities.push(1);
       } else {
         multiplicities[i] += 1;
@@ -429,20 +429,32 @@ export function createComplexEigs(_ref) {
 
     var vectors = [];
     var len = uniqueValues.length;
-    var b = Array(N).fill(0);
-    var E = diag(Array(N).fill(1)); // eigenvalues for which usolve failed (due to numerical error)
+    var b = Array(N).fill(zero);
+    var E = diag(Array(N).fill(one)); // eigenvalues for which usolve failed (due to numerical error)
 
     var failedLambdas = [];
 
     for (var _i4 = 0; _i4 < len; _i4++) {
       var _λ = uniqueValues[_i4];
-      var solutions = usolveAll(subtract(U, multiply(_λ, E)), b);
+
+      var _A = subtract(U, multiply(_λ, E)); // the characteristic matrix
+
+
+      var solutions = usolveAll(_A, b);
       solutions = solutions.map(v => multiply(C, v));
       solutions.shift(); // ignore the null vector
-      // looks like we missed something
+      // looks like we missed something, try inverse iteration
+
+      while (solutions.length < multiplicities[_i4]) {
+        var approxVec = inverseIterate(_A, N, solutions, prec, type);
+
+        if (approxVec == null) {
+          // no more vectors were found
+          failedLambdas.push(_λ);
+          break;
+        }
 
-      if (solutions.length < multiplicities[_i4]) {
-        failedLambdas.push(_λ);
+        solutions.push(approxVec);
       }
 
       vectors.push(...solutions.map(v => flatten(v)));
@@ -581,6 +593,128 @@ export function createComplexEigs(_ref) {
 
     return -1;
   }
+  /**
+   * Provided a near-singular upper-triangular matrix A and a list of vectors,
+   * finds an eigenvector of A with the smallest eigenvalue, which is orthogonal
+   * to each vector in the list
+   * @template T
+   * @param {T[][]} A near-singular square matrix
+   * @param {number} N dimension
+   * @param {T[][]} orthog list of vectors
+   * @param {number} prec epsilon
+   * @param {'number'|'BigNumber'|'Complex'} type
+   * @return {T[] | null} eigenvector
+   *
+   * @see Numerical Recipes for Fortran 77 – 11.7 Eigenvalues or Eigenvectors by Inverse Iteration
+   */
+
+
+  function inverseIterate(A, N, orthog, prec, type) {
+    var largeNum = type === 'BigNumber' ? bignumber(1000) : 1000;
+    var b; // the vector
+    // you better choose a random vector before I count to five
+
+    var i = 0;
+
+    while (true) {
+      b = randomOrthogonalVector(N, orthog, type);
+      b = usolve(A, b);
+
+      if (larger(norm(b), largeNum)) {
+        break;
+      }
+
+      if (++i >= 5) {
+        return null;
+      }
+    } // you better converge before I count to ten
+
+
+    i = 0;
+
+    while (true) {
+      var c = usolve(A, b);
+
+      if (smaller(norm(orthogonalComplement(b, [c])), prec)) {
+        break;
+      }
+
+      if (++i >= 10) {
+        return null;
+      }
+
+      b = normalize(c);
+    }
+
+    return b;
+  }
+  /**
+   * Generates a random unit vector of dimension N, orthogonal to each vector in the list
+   * @template T
+   * @param {number} N dimension
+   * @param {T[][]} orthog list of vectors
+   * @param {'number'|'BigNumber'|'Complex'} type
+   * @returns {T[]} random vector
+   */
+
+
+  function randomOrthogonalVector(N, orthog, type) {
+    var big = type === 'BigNumber';
+    var cplx = type === 'Complex'; // generate random vector with the correct type
+
+    var v = Array(N).fill(0).map(_ => 2 * Math.random() - 1);
+
+    if (big) {
+      v = v.map(n => bignumber(n));
+    }
+
+    if (cplx) {
+      v = v.map(n => complex(n));
+    } // project to orthogonal complement
+
+
+    v = orthogonalComplement(v, orthog); // normalize
+
+    return normalize(v, type);
+  }
+  /**
+   * Project vector v to the orthogonal complement of an array of vectors
+   */
+
+
+  function orthogonalComplement(v, orthog) {
+    for (var w of orthog) {
+      // v := v − (w, v)/∥w∥² w
+      v = subtract(v, multiply(divideScalar(dot(w, v), dot(w, w)), w));
+    }
+
+    return v;
+  }
+  /**
+   * Calculate the norm of a vector.
+   * We can't use math.norm because factory can't handle circular dependency.
+   * Seriously, I'm really fed up with factory.
+   */
+
+
+  function norm(v) {
+    return abs(sqrt(dot(v, v)));
+  }
+  /**
+   * Normalize a vector
+   * @template T
+   * @param {T[]} v
+   * @param {'number'|'BigNumber'|'Complex'} type
+   * @returns {T[]} normalized vec
+   */
+
+
+  function normalize(v, type) {
+    var big = type === 'BigNumber';
+    var cplx = type === 'Complex';
+    var one = big ? bignumber(1) : cplx ? complex(1) : 1;
+    return multiply(divideScalar(one, norm(v)), v);
+  }
 
   return complexEigs;
 }

package/lib/esm/function/matrix/eigs.js

@@ -5,7 +5,7 @@ import { createRealSymmetric } from './eigs/realSymetric.js';
 import { typeOf, isNumber, isBigNumber, isComplex, isFraction } from '../../utils/is.js';
 var name = 'eigs'; // The absolute state of math.js's dependency system:
 
-var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'qr', 'usolveAll', 'im', 're', 'smaller', 'round', 'log10', 'transpose', 'matrixFromColumns'];
+var dependencies = ['config', 'typed', 'matrix', 'addScalar', 'equal', 'subtract', 'abs', 'atan', 'cos', 'sin', 'multiplyScalar', 'divideScalar', 'inv', 'bignumber', 'multiply', 'add', 'larger', 'column', 'flatten', 'number', 'complex', 'sqrt', 'diag', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
 export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
   var {
     config,
@@ -32,14 +32,13 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
     sqrt,
     diag,
     qr,
+    usolve,
     usolveAll,
     im,
     re,
     smaller,
-    round,
-    log10,
-    transpose,
-    matrixFromColumns
+    matrixFromColumns,
+    dot
   } = _ref;
   var doRealSymetric = createRealSymmetric({
     config,
@@ -73,15 +72,14 @@ export var createEigs = /* #__PURE__ */factory(name, dependencies, _ref => {
     diag,
     qr,
     inv,
+    usolve,
     usolveAll,
     equal,
     complex,
     larger,
     smaller,
-    round,
-    log10,
-    transpose,
-    matrixFromColumns
+    matrixFromColumns,
+    dot
   });
   /**
    * Compute eigenvalues and eigenvectors of a matrix. The eigenvalues are sorted by their absolute value, ascending.

package/lib/esm/type/bignumber/BigNumber.js

@@ -7,12 +7,11 @@ export var createBigNumberClass = /* #__PURE__ */factory(name, dependencies, _re
     on,
     config
   } = _ref;
-  var EUCLID = 9; // Use euclidian division for mod calculation
-
   var BigNumber = Decimal.clone({
     precision: config.precision,
-    modulo: EUCLID
+    modulo: Decimal.EUCLID
   });
+  BigNumber.prototype = Object.create(BigNumber.prototype);
   /**
    * Attach type information
    */

package/lib/esm/utils/is.js

@@ -15,7 +15,19 @@ export function isNumber(x) {
   return typeof x === 'number';
 }
 export function isBigNumber(x) {
-  return x && x.constructor.prototype.isBigNumber === true || false;
+  if (!x || typeof x !== 'object' || typeof x.constructor !== 'function') {
+    return false;
+  }
+
+  if (x.isBigNumber === true && typeof x.constructor.prototype === 'object' && x.constructor.prototype.isBigNumber === true) {
+    return true;
+  }
+
+  if (typeof x.constructor.isDecimal === 'function' && x.constructor.isDecimal(x) === true) {
+    return true;
+  }
+
+  return false;
 }
 export function isComplex(x) {
   return x && typeof x === 'object' && Object.getPrototypeOf(x).isComplex === true || false;

package/lib/esm/version.js

@@ -1,2 +1,2 @@
-export var version = '9.4.0'; // Note: This file is automatically generated when building math.js.
+export var version = '9.4.4'; // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mathjs",
-  "version": "9.4.0",
+  "version": "9.4.4",
   "description": "Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices.",
   "author": "Jos de Jong <wjosdejong@gmail.com> (https://github.com/josdejong)",
   "homepage": "https://mathjs.org",
@@ -25,27 +25,28 @@
     "unit"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.14.0",
-    "complex.js": "^2.0.13",
-    "decimal.js": "^10.2.1",
+    "@babel/runtime": "^7.14.6",
+    "complex.js": "^2.0.15",
+    "decimal.js": "^10.3.1",
     "escape-latex": "^1.2.0",
-    "fraction.js": "^4.1.0",
+    "fraction.js": "^4.1.1",
     "javascript-natural-sort": "^0.7.1",
     "seedrandom": "^3.0.5",
     "tiny-emitter": "^2.1.0",
     "typed-function": "^2.0.0"
   },
   "devDependencies": {
-    "@babel/core": "7.14.2",
-    "@babel/plugin-transform-object-assign": "7.12.13",
-    "@babel/plugin-transform-runtime": "7.14.2",
-    "@babel/preset-env": "7.14.2",
-    "@babel/register": "7.13.16",
+    "@babel/core": "7.14.6",
+    "@babel/plugin-transform-object-assign": "7.14.5",
+    "@babel/plugin-transform-runtime": "7.14.5",
+    "@babel/preset-env": "7.14.7",
+    "@babel/register": "7.14.5",
     "babel-loader": "8.2.2",
     "benchmark": "2.1.4",
     "codecov": "3.8.2",
+    "core-js": "3.15.2",
     "del": "6.0.0",
-    "dtslint": "^4.0.9",
+    "dtslint": "4.1.1",
     "expr-eval": "2.0.2",
     "fancy-log": "1.3.3",
     "glob": "7.1.7",
@@ -54,13 +55,13 @@
     "handlebars": "4.7.7",
     "istanbul": "0.4.5",
     "jsep": "0.4.0",
-    "karma": "6.3.2",
+    "karma": "6.3.4",
     "karma-browserstack-launcher": "1.6.0",
-    "karma-firefox-launcher": "2.1.0",
+    "karma-firefox-launcher": "2.1.1",
     "karma-mocha": "2.0.1",
     "karma-mocha-reporter": "2.2.5",
     "karma-webpack": "4.0.2",
-    "math-expression-evaluator": "1.3.7",
+    "math-expression-evaluator": "1.3.8",
     "mkdirp": "1.0.4",
     "mocha": "8.4.0",
     "ndarray": "1.0.19",
@@ -73,7 +74,7 @@
     "pad-right": "0.2.2",
     "standard": "16.0.3",
     "sylvester": "0.0.21",
-    "typescript": "^4.2.4",
+    "typescript": "4.3.5",
     "webpack": "4.46.0",
     "zeros": "1.0.0"
   },
@@ -114,6 +115,7 @@
     "lib",
     "examples",
     "main",
+    "types",
     "number.cjs",
     "LICENSE",
     "NOTICE",
@@ -131,13 +133,13 @@
     "lint": "standard --env=mocha --env=worker",
     "validate:ascii": "gulp --gulpfile gulpfile.cjs validate:ascii",
     "test": "npm run test:src && npm run lint",
-    "test:src": "mocha test/unit-tests --recursive --forbid-only",
-    "test:generated": "mocha test/generated-code-tests --recursive --forbid-only",
-    "test:node": "mocha test/node-tests/*.test.js test/node-tests/**/*.test.js --recursive --forbid-only",
+    "test:src": "mocha test/unit-tests",
+    "test:generated": "mocha test/generated-code-tests",
+    "test:node": "mocha test/node-tests/*.test.js test/node-tests/**/*.test.js",
     "test:all": "npm run test:src && npm run test:generated && npm run test:node",
     "test:browser": "karma start test/browser-test-config/local-karma.js",
     "test:browserstack": "karma start test/browser-test-config/browserstack-karma.js",
-    "coverage": "nyc --reporter=lcov --reporter=text-summary mocha test/unit-tests --recursive && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"",
+    "coverage": "nyc --reporter=lcov --reporter=text-summary mocha test/unit-tests && echo \"\nDetailed coverage report is available at ./coverage/lcov-report/index.html\"",
     "prepublishOnly": "npm run test:all && npm run lint",
     "prepare": "npm run build",
     "update-authors": "node ./tools/update-authors.js"
@@ -146,7 +148,7 @@
     "mathjs": "./bin/cli.js"
   },
   "engines": {
-    "node": ">= 10"
+    "node": ">= 12"
   },
   "bugs": {
     "url": "https://github.com/josdejong/mathjs/issues"