mathjs 11.12.0 → 12.0.0

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

@@ -1,18 +1,20 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createEigs = void 0;
+var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
 var _factory = require("../../utils/factory.js");
 var _string = require("../../utils/string.js");
 var _complexEigs = require("./eigs/complexEigs.js");
-var _realSymetric = require("./eigs/realSymetric.js");
+var _realSymmetric = require("./eigs/realSymmetric.js");
 var _is = require("../../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', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
+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', 'size', 'reshape', 'qr', 'usolve', 'usolveAll', 'im', 're', 'smaller', 'matrixFromColumns', 'dot'];
 var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var config = _ref.config,
     typed = _ref.typed,
@@ -37,6 +39,8 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     complex = _ref.complex,
     sqrt = _ref.sqrt,
     diag = _ref.diag,
+    size = _ref.size,
+    reshape = _ref.reshape,
     qr = _ref.qr,
     usolve = _ref.usolve,
     usolveAll = _ref.usolveAll,
@@ -45,7 +49,7 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     smaller = _ref.smaller,
     matrixFromColumns = _ref.matrixFromColumns,
     dot = _ref.dot;
-  var doRealSymetric = (0, _realSymetric.createRealSymmetric)({
+  var doRealSymmetric = (0, _realSymmetric.createRealSymmetric)({
     config: config,
     addScalar: addScalar,
     subtract: subtract,
@@ -75,6 +79,8 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
     abs: abs,
     bignumber: bignumber,
     diag: diag,
+    size: size,
+    reshape: reshape,
     qr: qr,
     inv: inv,
     usolve: usolve,
@@ -88,26 +94,54 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
   });
 
   /**
-   * Compute eigenvalues and eigenvectors of a matrix. The eigenvalues are sorted by their absolute value, ascending.
-   * An eigenvalue with multiplicity k will be listed k times. The eigenvectors are returned as columns of a matrix –
-   * the eigenvector that belongs to the j-th eigenvalue in the list (eg. `values[j]`) is the j-th column (eg. `column(vectors, j)`).
-   * If the algorithm fails to converge, it will throw an error – in that case, however, you may still find useful information
+   * Compute eigenvalues and optionally eigenvectors of a square matrix.
+   * The eigenvalues are sorted by their absolute value, ascending, and
+   * returned as a vector in the `values` property of the returned project.
+   * An eigenvalue with algebraic multiplicity k will be listed k times, so
+   * that the returned `values` vector always has length equal to the size
+   * of the input matrix.
+   *
+   * The `eigenvectors` property of the return value provides the eigenvectors.
+   * It is an array of plain objects: the `value` property of each gives the
+   * associated eigenvalue, and the `vector` property gives the eigenvector
+   * itself. Note that the same `value` property will occur as many times in
+   * the list provided by `eigenvectors` as the geometric multiplicity of
+   * that value.
+   *
+   * If the algorithm fails to converge, it will throw an error –
+   * in that case, however, you may still find useful information
    * in `err.values` and `err.vectors`.
    *
+   * Note that the 'precision' option does not directly specify the _accuracy_
+   * of the returned eigenvalues. Rather, it determines how small an entry
+   * of the iterative approximations to an upper triangular matrix must be
+   * in order to be considered zero. The actual accuracy of the returned
+   * eigenvalues may be greater or less than the precision, depending on the
+   * conditioning of the matrix and how far apart or close the actual
+   * eigenvalues are. Note that currently, relatively simple, "traditional"
+   * methods of eigenvalue computation are being used; this is not a modern,
+   * high-precision eigenvalue computation. That said, it should typically
+   * produce fairly reasonable results.
+   *
    * Syntax:
    *
    *     math.eigs(x, [prec])
+   *     math.eigs(x, {options})
    *
    * Examples:
    *
-   *     const { eigs, multiply, column, transpose } = math
+   *     const { eigs, multiply, column, transpose, matrixFromColumns } = math
    *     const H = [[5, 2.3], [2.3, 1]]
-   *     const ans = eigs(H) // returns {values: [E1,E2...sorted], vectors: [v1,v2.... corresponding vectors as columns]}
+   *     const ans = eigs(H) // returns {values: [E1,E2...sorted], eigenvectors: [{value: E1, vector: v2}, {value: e, vector: v2}, ...]
    *     const E = ans.values
-   *     const U = ans.vectors
-   *     multiply(H, column(U, 0)) // returns multiply(E[0], column(U, 0))
-   *     const UTxHxU = multiply(transpose(U), H, U) // diagonalizes H
-   *     E[0] == UTxHxU[0][0]  // returns true
+   *     const V = ans.eigenvectors
+   *     multiply(H, V[0].vector)) // returns multiply(E[0], V[0].vector))
+   *     const U = matrixFromColumns(...V.map(obj => obj.vector))
+   *     const UTxHxU = multiply(transpose(U), H, U) // diagonalizes H if possible
+   *     E[0] == UTxHxU[0][0]  // returns true always
+   *
+   *     // Compute only approximate eigenvalues:
+   *     const {values} = eigs(H, {eigenvectors: false, precision: 1e-6})
    *
    * See also:
    *
@@ -115,57 +149,96 @@ var createEigs = exports.createEigs = /* #__PURE__ */(0, _factory.factory)(name,
    *
    * @param {Array | Matrix} x  Matrix to be diagonalized
    *
-   * @param {number | BigNumber} [prec] Precision, default value: 1e-15
-   * @return {{values: Array|Matrix, vectors: Array|Matrix}} Object containing an array of eigenvalues and a matrix with eigenvectors as columns.
+   * @param {number | BigNumber | OptsObject} [opts] Object with keys `precision`, defaulting to config.epsilon, and `eigenvectors`, defaulting to true and specifying whether to compute eigenvectors. If just a number, specifies precision.
+   * @return {{values: Array|Matrix, eigenvectors?: Array<EVobj>}} Object containing an array of eigenvalues and an array of {value: number|BigNumber, vector: Array|Matrix} objects. The eigenvectors property is undefined if eigenvectors were not requested.
    *
    */
   return typed('eigs', {
+    // The conversion to matrix in the first two implementations,
+    // just to convert back to an array right away in
+    // computeValuesAndVectors, is unfortunate, and should perhaps be
+    // streamlined. It is done because the Matrix object carries some
+    // type information about its entries, and so constructing the matrix
+    // is a roundabout way of doing type detection.
     Array: function Array(x) {
-      var mat = matrix(x);
-      return computeValuesAndVectors(mat);
+      return doEigs(matrix(x));
     },
     'Array, number|BigNumber': function ArrayNumberBigNumber(x, prec) {
-      var mat = matrix(x);
-      return computeValuesAndVectors(mat, prec);
+      return doEigs(matrix(x), {
+        precision: prec
+      });
+    },
+    'Array, Object': function ArrayObject(x, opts) {
+      return doEigs(matrix(x), opts);
     },
     Matrix: function Matrix(mat) {
-      var _computeValuesAndVect = computeValuesAndVectors(mat),
-        values = _computeValuesAndVect.values,
-        vectors = _computeValuesAndVect.vectors;
-      return {
-        values: matrix(values),
-        vectors: matrix(vectors)
-      };
+      return doEigs(mat, {
+        matricize: true
+      });
     },
     'Matrix, number|BigNumber': function MatrixNumberBigNumber(mat, prec) {
-      var _computeValuesAndVect2 = computeValuesAndVectors(mat, prec),
-        values = _computeValuesAndVect2.values,
-        vectors = _computeValuesAndVect2.vectors;
-      return {
-        values: matrix(values),
-        vectors: matrix(vectors)
+      return doEigs(mat, {
+        precision: prec,
+        matricize: true
+      });
+    },
+    'Matrix, Object': function MatrixObject(mat, opts) {
+      var useOpts = {
+        matricize: true
       };
+      (0, _extends2["default"])(useOpts, opts);
+      return doEigs(mat, useOpts);
     }
   });
-  function computeValuesAndVectors(mat, prec) {
-    if (prec === undefined) {
-      prec = config.epsilon;
+  function doEigs(mat) {
+    var _opts$precision;
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var computeVectors = 'eigenvectors' in opts ? opts.eigenvectors : true;
+    var prec = (_opts$precision = opts.precision) !== null && _opts$precision !== void 0 ? _opts$precision : config.epsilon;
+    var result = computeValuesAndVectors(mat, prec, computeVectors);
+    if (opts.matricize) {
+      result.values = matrix(result.values);
+      if (computeVectors) {
+        result.eigenvectors = result.eigenvectors.map(function (_ref2) {
+          var value = _ref2.value,
+            vector = _ref2.vector;
+          return {
+            value: value,
+            vector: matrix(vector)
+          };
+        });
+      }
+    }
+    if (computeVectors) {
+      Object.defineProperty(result, 'vectors', {
+        enumerable: false,
+        // to make sure that the eigenvectors can still be
+        // converted to string.
+        get: function get() {
+          throw new Error('eigs(M).vectors replaced with eigs(M).eigenvectors');
+        }
+      });
     }
-    var size = mat.size();
-    if (size.length !== 2 || size[0] !== size[1]) {
-      throw new RangeError('Matrix must be square (size: ' + (0, _string.format)(size) + ')');
+    return result;
+  }
+  function computeValuesAndVectors(mat, prec, computeVectors) {
+    var arr = mat.toArray(); // NOTE: arr is guaranteed to be unaliased
+    // and so safe to modify in place
+    var asize = mat.size();
+    if (asize.length !== 2 || asize[0] !== asize[1]) {
+      throw new RangeError("Matrix must be square (size: ".concat((0, _string.format)(asize), ")"));
     }
-    var arr = mat.toArray();
-    var N = size[0];
+    var N = asize[0];
     if (isReal(arr, N, prec)) {
-      coerceReal(arr, N);
+      coerceReal(arr, N); // modifies arr by side effect
+
       if (isSymmetric(arr, N, prec)) {
-        var _type = coerceTypes(mat, arr, N);
-        return doRealSymetric(arr, N, prec, _type);
+        var _type = coerceTypes(mat, arr, N); // modifies arr by side effect
+        return doRealSymmetric(arr, N, prec, _type, computeVectors);
       }
     }
-    var type = coerceTypes(mat, arr, N);
-    return doComplexEigs(arr, N, prec, type);
+    var type = coerceTypes(mat, arr, N); // modifies arr by side effect
+    return doComplexEigs(arr, N, prec, type, computeVectors);
   }
 
   /** @return {boolean} */

package/lib/cjs/header.js

@@ -6,7 +6,7 @@
  * It features real and complex numbers, units, matrices, a large set of
  * mathematical functions, and a flexible expression parser.
  *
- * @version 11.12.0
+ * @version 12.0.0
  * @date    2023-10-26
  *
  * @license

package/lib/cjs/utils/number.js

@@ -604,7 +604,7 @@ function nearlyEqual(x, y, epsilon) {
   if (isFinite(x) && isFinite(y)) {
     // check numbers are very close, needed when comparing numbers near zero
     var diff = Math.abs(x - y);
-    if (diff < DBL_EPSILON) {
+    if (diff <= DBL_EPSILON) {
       return true;
     } else {
       // use relative error

package/lib/cjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.version = void 0;
-var version = exports.version = '11.12.0';
+var version = exports.version = '12.0.0';
 // Note: This file is automatically generated when building math.js.
 // Changes made in this file will be overwritten.

package/lib/esm/entry/dependenciesAny/dependenciesEigs.generated.js

@@ -25,7 +25,9 @@ import { multiplyScalarDependencies } from './dependenciesMultiplyScalar.generat
 import { numberDependencies } from './dependenciesNumber.generated.js';
 import { qrDependencies } from './dependenciesQr.generated.js';
 import { reDependencies } from './dependenciesRe.generated.js';
+import { reshapeDependencies } from './dependenciesReshape.generated.js';
 import { sinDependencies } from './dependenciesSin.generated.js';
+import { sizeDependencies } from './dependenciesSize.generated.js';
 import { smallerDependencies } from './dependenciesSmaller.generated.js';
 import { sqrtDependencies } from './dependenciesSqrt.generated.js';
 import { subtractDependencies } from './dependenciesSubtract.generated.js';
@@ -57,7 +59,9 @@ export var eigsDependencies = {
   numberDependencies,
   qrDependencies,
   reDependencies,
+  reshapeDependencies,
   sinDependencies,
+  sizeDependencies,
   smallerDependencies,
   sqrtDependencies,
   subtractDependencies,

package/lib/esm/entry/pureFunctionsAny.generated.js

@@ -1582,7 +1582,9 @@ export var eigs = /* #__PURE__ */createEigs({
   number,
   qr,
   re,
+  reshape,
   sin,
+  size,
   smaller,
   sqrt,
   subtract,

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

@@ -2,7 +2,7 @@ export var eigsDocs = {
   name: 'eigs',
   category: 'Matrix',
   syntax: ['eigs(x)'],
-  description: 'Calculate the eigenvalues and eigenvectors of a real symmetric matrix',
-  examples: ['eigs([[5, 2.3], [2.3, 1]])'],
+  description: 'Calculate the eigenvalues and optionally eigenvectors of a square matrix',
+  examples: ['eigs([[5, 2.3], [2.3, 1]])', 'eigs([[1, 2, 3], [4, 5, 6], [7, 8, 9]], { precision: 1e-6, eigenvectors: false }'],
   seealso: ['inv']
 };

package/lib/esm/expression/node/AssignmentNode.js

@@ -295,7 +295,7 @@ export var createAssignmentNode = /* #__PURE__ */factory(name, dependencies, _re
       if (needParenthesis(this, options && options.parenthesis, options && options.implicit)) {
         value = "\\left(".concat(value, "\\right)");
       }
-      return object + index + ':=' + value;
+      return object + index + '=' + value;
     }
   }
   _defineProperty(AssignmentNode, "name", name);

package/lib/esm/expression/node/FunctionAssignmentNode.js

@@ -224,7 +224,7 @@ export var createFunctionAssignmentNode = /* #__PURE__ */factory(name, dependenc
       if (needParenthesis(this, parenthesis, options && options.implicit)) {
         expr = "\\left(".concat(expr, "\\right)");
       }
-      return '\\mathrm{' + this.name + '}\\left(' + this.params.map(toSymbol).join(',') + '\\right):=' + expr;
+      return '\\mathrm{' + this.name + '}\\left(' + this.params.map(toSymbol).join(',') + '\\right)=' + expr;
     }
   }
   _defineProperty(FunctionAssignmentNode, "name", name);

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

@@ -11,6 +11,8 @@ export function createComplexEigs(_ref) {
     abs,
     bignumber,
     diag,
+    size,
+    reshape,
     inv,
     qr,
     usolve,
@@ -31,11 +33,8 @@ export function createComplexEigs(_ref) {
    *
    * @returns {{ values: number[], vectors: number[][] }}
    */
-  function complexEigs(arr, N, prec, type, findVectors) {
-    if (findVectors === undefined) {
-      findVectors = true;
-    }
-
+  function complexEigs(arr, N, prec, type) {
+    var findVectors = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
     // TODO check if any row/col are zero except the diagonal
 
     // make sure corresponding rows and columns have similar magnitude
@@ -44,9 +43,9 @@ export function createComplexEigs(_ref) {
     var R = balance(arr, N, prec, type, findVectors);
 
     // R is the row transformation matrix
-    // arr = A' = R A R⁻¹, A is the original matrix
+    // arr = A' = R A R^-1, A is the original matrix
     // (if findVectors is false, R is undefined)
-    // (And so to return to original matrix: A = R⁻¹ arr R)
+    // (And so to return to original matrix: A = R^-1 arr R)
 
     // TODO if magnitudes of elements vary over many orders,
     // move greatest elements to the top left corner
@@ -56,7 +55,7 @@ export function createComplexEigs(_ref) {
     // updates the transformation matrix R with new row operationsq
     // MODIFIES arr by side effect!
     reduceToHessenberg(arr, N, prec, type, findVectors, R);
-    // still true that original A = R⁻¹ arr R)
+    // still true that original A = R^-1 arr R)
 
     // find eigenvalues
     var {
@@ -67,17 +66,18 @@ export function createComplexEigs(_ref) {
     // values is the list of eigenvalues, C is the column
     // transformation matrix that transforms arr, the hessenberg
     // matrix, to upper triangular
-    // (So U = C⁻¹ arr C and the relationship between current arr
+    // (So U = C^-1 arr C and the relationship between current arr
     // and original A is unchanged.)
 
-    var vectors;
     if (findVectors) {
-      vectors = findEigenvectors(arr, N, C, R, values, prec, type);
-      vectors = matrixFromColumns(...vectors);
+      var eigenvectors = findEigenvectors(arr, N, C, R, values, prec, type);
+      return {
+        values,
+        eigenvectors
+      };
     }
     return {
-      values,
-      vectors
+      values
     };
   }
 
@@ -117,9 +117,8 @@ export function createComplexEigs(_ref) {
         var rowNorm = realzero;
         for (var j = 0; j < N; j++) {
           if (i === j) continue;
-          var c = abs(arr[i][j]); // should be real
-          colNorm = addScalar(colNorm, c);
-          rowNorm = addScalar(rowNorm, c);
+          colNorm = addScalar(colNorm, abs(arr[j][i]));
+          rowNorm = addScalar(rowNorm, abs(arr[i][j]));
         }
         if (!equal(colNorm, 0) && !equal(rowNorm, 0)) {
           // find integer power closest to balancing the matrix
@@ -127,21 +126,21 @@ export function createComplexEigs(_ref) {
           // so that we don't lose any precision due to round-off)
 
           var f = realone;
-          var _c = colNorm;
+          var c = colNorm;
           var rowDivRadix = divideScalar(rowNorm, radix);
           var rowMulRadix = multiplyScalar(rowNorm, radix);
-          while (smaller(_c, rowDivRadix)) {
-            _c = multiplyScalar(_c, radixSq);
+          while (smaller(c, rowDivRadix)) {
+            c = multiplyScalar(c, radixSq);
             f = multiplyScalar(f, radix);
           }
-          while (larger(_c, rowMulRadix)) {
-            _c = divideScalar(_c, radixSq);
+          while (larger(c, rowMulRadix)) {
+            c = divideScalar(c, radixSq);
             f = divideScalar(f, radix);
           }
 
           // check whether balancing is needed
           // condition = (c + rowNorm) / f < 0.95 * (colNorm + rowNorm)
-          var condition = smaller(divideScalar(addScalar(_c, rowNorm), f), multiplyScalar(addScalar(colNorm, rowNorm), 0.95));
+          var condition = smaller(divideScalar(addScalar(c, rowNorm), f), multiplyScalar(addScalar(colNorm, rowNorm), 0.95));
 
           // apply balancing similarity transformation
           if (condition) {
@@ -153,13 +152,13 @@ export function createComplexEigs(_ref) {
               if (i === _j) {
                 continue;
               }
-              arr[i][_j] = multiplyScalar(arr[i][_j], f);
-              arr[_j][i] = multiplyScalar(arr[_j][i], g);
+              arr[i][_j] = multiplyScalar(arr[i][_j], g);
+              arr[_j][i] = multiplyScalar(arr[_j][i], f);
             }
 
             // keep track of transformations
             if (findVectors) {
-              Rdiag[i] = multiplyScalar(Rdiag[i], f);
+              Rdiag[i] = multiplyScalar(Rdiag[i], g);
             }
           }
         }
@@ -167,7 +166,7 @@ export function createComplexEigs(_ref) {
     }
 
     // return the diagonal row transformation matrix
-    return diag(Rdiag);
+    return findVectors ? diag(Rdiag) : null;
   }
 
   /**
@@ -266,7 +265,7 @@ export function createComplexEigs(_ref) {
 
     // The Francis Algorithm
     // The core idea of this algorithm is that doing successive
-    // A' = Q⁺AQ transformations will eventually converge to block-
+    // A' = QtAQ transformations will eventually converge to block-
     // upper-triangular with diagonal blocks either 1x1 or 2x2.
     // The Q here is the one from the QR decomposition, A = QR.
     // Since the eigenvalues of a block-upper-triangular matrix are
@@ -288,7 +287,7 @@ export function createComplexEigs(_ref) {
     // N×N matrix describing the overall transformation done during the QR algorithm
     var Qtotal = findVectors ? diag(Array(N).fill(one)) : undefined;
 
-    // n×n matrix describing the QR transformations done since last convergence
+    // nxn matrix describing the QR transformations done since last convergence
     var Qpartial = findVectors ? diag(Array(n).fill(one)) : undefined;
 
     // last eigenvalue converged before this many steps
@@ -300,7 +299,12 @@ export function createComplexEigs(_ref) {
 
       // Perform the factorization
 
-      var k = 0; // TODO set close to an eigenvalue
+      var k = arr[n - 1][n - 1]; // TODO this is apparently a somewhat
+      // old-fashioned choice; ideally set close to an eigenvalue, or
+      // perhaps better yet switch to the implicit QR version that is sometimes
+      // specifically called the "Francis algorithm" that is alluded to
+      // in the following TODO. (Or perhaps we switch to an independently
+      // optimized third-party package for the linear algebra operations...)
 
       for (var i = 0; i < n; i++) {
         arr[i][i] = subtract(arr[i][i], k);
@@ -414,17 +418,17 @@ export function createComplexEigs(_ref) {
     // this way it is easier to find eigenvectors
     var uniqueValues = [];
     var multiplicities = [];
-    for (var λ of values) {
-      var i = indexOf(uniqueValues, λ, equal);
+    for (var lambda of values) {
+      var i = indexOf(uniqueValues, lambda, equal);
       if (i === -1) {
-        uniqueValues.push(λ);
+        uniqueValues.push(lambda);
         multiplicities.push(1);
       } else {
         multiplicities[i] += 1;
       }
     }
 
-    // find eigenvectors by solving U − λE = 0
+    // find eigenvectors by solving U − lambdaE = 0
     // TODO replace with an iterative eigenvector algorithm
     // (this one might fail for imprecise eigenvalues)
 
@@ -432,41 +436,35 @@ export function createComplexEigs(_ref) {
     var len = uniqueValues.length;
     var b = Array(N).fill(zero);
     var E = diag(Array(N).fill(one));
-
-    // eigenvalues for which usolve failed (due to numerical error)
-    var failedLambdas = [];
     var _loop = function _loop() {
-      var λ = uniqueValues[_i4];
-      var S = subtract(U, multiply(λ, E)); // the characteristic matrix
+      var lambda = uniqueValues[_i4];
+      var S = subtract(U, multiply(lambda, E)); // the characteristic matrix
 
       var solutions = usolveAll(S, b);
       solutions.shift(); // ignore the null vector
 
       // looks like we missed something, try inverse iteration
+      // But if that fails, just presume that the original matrix truly
+      // was defective.
       while (solutions.length < multiplicities[_i4]) {
         var approxVec = inverseIterate(S, N, solutions, prec, type);
-        if (approxVec == null) {
-          // no more vectors were found
-          failedLambdas.push(λ);
+        if (approxVec === null) {
           break;
-        }
+        } // no more vectors were found
         solutions.push(approxVec);
       }
 
       // Transform back into original array coordinates
       var correction = multiply(inv(R), C);
       solutions = solutions.map(v => multiply(correction, v));
-      vectors.push(...solutions.map(v => flatten(v)));
+      vectors.push(...solutions.map(v => ({
+        value: lambda,
+        vector: flatten(v)
+      })));
     };
     for (var _i4 = 0; _i4 < len; _i4++) {
       _loop();
     }
-    if (failedLambdas.length !== 0) {
-      var err = new Error('Failed to find eigenvectors for the following eigenvalues: ' + failedLambdas.join(', '));
-      err.values = values;
-      err.vectors = vectors;
-      throw err;
-    }
     return vectors;
   }
 
@@ -475,7 +473,7 @@ export function createComplexEigs(_ref) {
    * @return {[number,number]}
    */
   function eigenvalues2x2(a, b, c, d) {
-    // λ± = ½ trA ± ½ √( tr²A - 4 detA )
+    // lambda_+- = 1/2 trA +- 1/2 sqrt( tr^2 A - 4 detA )
     var trA = addScalar(a, d);
     var detA = subtract(multiplyScalar(a, d), multiplyScalar(b, c));
     var x = multiplyScalar(trA, 0.5);
@@ -485,7 +483,7 @@ export function createComplexEigs(_ref) {
 
   /**
    * For an 2x2 matrix compute the transformation matrix S,
-   * so that SAS⁻¹ is an upper triangular matrix
+   * so that SAS^-1 is an upper triangular matrix
    * @return {[[number,number],[number,number]]}
    * @see https://math.berkeley.edu/~ogus/old/Math_54-05/webfoils/jordan.pdf
    * @see http://people.math.harvard.edu/~knill/teaching/math21b2004/exhibits/2dmatrices/index.html
@@ -509,23 +507,22 @@ export function createComplexEigs(_ref) {
     }
 
     // matrix is not diagonalizable
-    // compute off-diagonal elements of N = A - λI
-    // N₁₂ = 0 ⇒ S = ( N⃗₁, I⃗₁ )
-    // N₁₂ ≠ 0 ⇒ S = ( N⃗₂, I⃗₂ )
-
+    // compute diagonal elements of N = A - lambdaI
     var na = subtract(a, l1);
-    var nb = subtract(b, l1);
-    var nc = subtract(c, l1);
     var nd = subtract(d, l1);
-    if (smaller(abs(nb), prec)) {
-      return [[na, one], [nc, zero]];
+
+    // col(N,2) = 0  implies  S = ( col(N,1), e_1 )
+    // col(N,2) != 0 implies  S = ( col(N,2), e_2 )
+
+    if (smaller(abs(b), prec) && smaller(abs(nd), prec)) {
+      return [[na, one], [c, zero]];
     } else {
-      return [[nb, zero], [nd, one]];
+      return [[b, zero], [nd, one]];
     }
   }
 
   /**
-   * Enlarge the matrix from n×n to N×N, setting the new
+   * Enlarge the matrix from nxn to NxN, setting the new
    * elements to 1 on diagonal and 0 elsewhere
    */
   function inflateMatrix(arr, N) {
@@ -602,15 +599,21 @@ export function createComplexEigs(_ref) {
 
     // you better choose a random vector before I count to five
     var i = 0;
-    while (true) {
+    for (; i < 5; ++i) {
       b = randomOrthogonalVector(N, orthog, type);
-      b = usolve(A, b);
+      try {
+        b = usolve(A, b);
+      } catch (_unused) {
+        // That direction didn't work, likely because the original matrix
+        // was defective. But still make the full number of tries...
+        continue;
+      }
       if (larger(norm(b), largeNum)) {
         break;
       }
-      if (++i >= 5) {
-        return null;
-      }
+    }
+    if (i >= 5) {
+      return null; // couldn't find any orthogonal vector in the image
     }
 
     // you better converge before I count to ten
@@ -660,8 +663,10 @@ export function createComplexEigs(_ref) {
    * Project vector v to the orthogonal complement of an array of vectors
    */
   function orthogonalComplement(v, orthog) {
+    var vectorShape = size(v);
     for (var w of orthog) {
-      // v := v − (w, v)/∥w∥² w
+      w = reshape(w, vectorShape); // make sure this is just a vector computation
+      // v := v − (w, v)/|w|^2 w
       v = subtract(v, multiply(divideScalar(dot(w, v), dot(w, w)), w));
     }
     return v;