mathjs 11.11.2 → 12.0.0

package/lib/cjs/function/algebra/solver/usolve.js

@@ -7,13 +7,13 @@ exports.createUsolve = void 0;
 var _factory = require("../../../utils/factory.js");
 var _solveValidation = require("./utils/solveValidation.js");
 var name = 'usolve';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
+var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
 var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     matrix = _ref.matrix,
     divideScalar = _ref.divideScalar,
     multiplyScalar = _ref.multiplyScalar,
-    subtract = _ref.subtract,
+    subtractScalar = _ref.subtractScalar,
     equalScalar = _ref.equalScalar,
     DenseMatrix = _ref.DenseMatrix;
   var solveValidation = (0, _solveValidation.createSolveValidation)({
@@ -85,7 +85,7 @@ var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(n
         // loop rows
         for (var i = j - 1; i >= 0; i--) {
           // update copy of b
-          bdata[i] = [subtract(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
+          bdata[i] = [subtractScalar(bdata[i][0] || 0, multiplyScalar(xj, mdata[i][j]))];
         }
       } else {
         // zero value at j
@@ -149,7 +149,7 @@ var createUsolve = exports.createUsolve = /* #__PURE__ */(0, _factory.factory)(n
         var xj = divideScalar(bj, vjj);
         for (var _k = 0, _lastIndex = jIndices.length; _k < _lastIndex; _k++) {
           var _i = jIndices[_k];
-          bdata[_i] = [subtract(bdata[_i][0], multiplyScalar(xj, jValues[_k]))];
+          bdata[_i] = [subtractScalar(bdata[_i][0], multiplyScalar(xj, jValues[_k]))];
         }
         x[j] = [xj];
       } else {

package/lib/cjs/function/algebra/solver/usolveAll.js

@@ -9,13 +9,13 @@ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers
 var _factory = require("../../../utils/factory.js");
 var _solveValidation = require("./utils/solveValidation.js");
 var name = 'usolveAll';
-var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtract', 'equalScalar', 'DenseMatrix'];
+var dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
 var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     matrix = _ref.matrix,
     divideScalar = _ref.divideScalar,
     multiplyScalar = _ref.multiplyScalar,
-    subtract = _ref.subtract,
+    subtractScalar = _ref.subtractScalar,
     equalScalar = _ref.equalScalar,
     DenseMatrix = _ref.DenseMatrix;
   var solveValidation = (0, _solveValidation.createSolveValidation)({
@@ -86,7 +86,7 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
           b[i] = divideScalar(b[i], M[i][i]);
           for (var j = i - 1; j >= 0; j--) {
             // b[j] -= b[i] * M[j,i]
-            b[j] = subtract(b[j], multiplyScalar(b[i], M[j][i]));
+            b[j] = subtractScalar(b[j], multiplyScalar(b[i], M[j][i]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
@@ -106,7 +106,7 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
           var bNew = (0, _toConsumableArray2["default"])(b);
           bNew[i] = 1;
           for (var _j = i - 1; _j >= 0; _j--) {
-            bNew[_j] = subtract(bNew[_j], M[_j][i]);
+            bNew[_j] = subtractScalar(bNew[_j], M[_j][i]);
           }
           B.push(bNew);
         }
@@ -169,7 +169,7 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
           // loop upper triangular
           for (var _j2 = 0, _lastIndex = iIndices.length; _j2 < _lastIndex; _j2++) {
             var _J = iIndices[_j2];
-            b[_J] = subtract(b[_J], multiplyScalar(b[i], iValues[_j2]));
+            b[_J] = subtractScalar(b[_J], multiplyScalar(b[i], iValues[_j2]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
@@ -192,7 +192,7 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
           // loop upper triangular
           for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {
             var _J2 = iIndices[_j3];
-            bNew[_J2] = subtract(bNew[_J2], iValues[_j3]);
+            bNew[_J2] = subtractScalar(bNew[_J2], iValues[_j3]);
           }
           B.push(bNew);
         }

package/lib/cjs/function/arithmetic/subtract.js

@@ -12,12 +12,12 @@ var _matAlgo10xSids = require("../../type/matrix/utils/matAlgo10xSids.js");
 var _matAlgo12xSfs = require("../../type/matrix/utils/matAlgo12xSfs.js");
 var _matrixAlgorithmSuite = require("../../type/matrix/utils/matrixAlgorithmSuite.js");
 var name = 'subtract';
-var dependencies = ['typed', 'matrix', 'equalScalar', 'addScalar', 'unaryMinus', 'DenseMatrix', 'concat'];
+var dependencies = ['typed', 'matrix', 'equalScalar', 'subtractScalar', 'unaryMinus', 'DenseMatrix', 'concat'];
 var createSubtract = exports.createSubtract = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     matrix = _ref.matrix,
     equalScalar = _ref.equalScalar,
-    addScalar = _ref.addScalar,
+    subtractScalar = _ref.subtractScalar,
     unaryMinus = _ref.unaryMinus,
     DenseMatrix = _ref.DenseMatrix,
     concat = _ref.concat;
@@ -73,44 +73,14 @@ var createSubtract = exports.createSubtract = /* #__PURE__ */(0, _factory.factor
    *
    *    add
    *
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x
-   *            Initial value
-   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y
-   *            Value to subtract from `x`
-   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix}
-   *            Subtraction of `x` and `y`
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} x Initial value
+   * @param  {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} y Value to subtract from `x`
+   * @return {number | BigNumber | Fraction | Complex | Unit | Array | Matrix} Subtraction of `x` and `y`
    */
   return typed(name, {
-    'number, number': function numberNumber(x, y) {
-      return x - y;
-    },
-    'Complex, Complex': function ComplexComplex(x, y) {
-      return x.sub(y);
-    },
-    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
-      return x.minus(y);
-    },
-    'Fraction, Fraction': function FractionFraction(x, y) {
-      return x.sub(y);
-    },
-    'Unit, Unit': typed.referToSelf(function (self) {
-      return function (x, y) {
-        if (x.value === null) {
-          throw new Error('Parameter x contains a unit with undefined value');
-        }
-        if (y.value === null) {
-          throw new Error('Parameter y contains a unit with undefined value');
-        }
-        if (!x.equalBase(y)) {
-          throw new Error('Units do not match');
-        }
-        var res = x.clone();
-        res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
-        res.fixPrefix = false;
-        return res;
-      };
-    })
+    'any, any': subtractScalar
   }, matrixAlgorithmSuite({
+    elop: subtractScalar,
     SS: matAlgo05xSfSf,
     DS: matAlgo01xDSid,
     SD: matAlgo03xDSf,

package/lib/cjs/function/arithmetic/subtractScalar.js

@@ -0,0 +1,52 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubtractScalar = void 0;
+var _factory = require("../../utils/factory.js");
+var _index = require("../../plain/number/index.js");
+var name = 'subtractScalar';
+var dependencies = ['typed'];
+var createSubtractScalar = exports.createSubtractScalar = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed;
+  /**
+   * Subtract two scalar values, `x - y`.
+   * This function is meant for internal use: it is used by the public function
+   * `subtract`
+   *
+   * This function does not support collections (Array or Matrix).
+   *
+   * @param  {number | BigNumber | Fraction | Complex | Unit} x   First value
+   * @param  {number | BigNumber | Fraction | Complex} y          Second value to be subtracted from `x`
+   * @return {number | BigNumber | Fraction | Complex | Unit}     Difference of `x` and `y`
+   * @private
+   */
+  return typed(name, {
+    'number, number': _index.subtractNumber,
+    'Complex, Complex': function ComplexComplex(x, y) {
+      return x.sub(y);
+    },
+    'BigNumber, BigNumber': function BigNumberBigNumber(x, y) {
+      return x.minus(y);
+    },
+    'Fraction, Fraction': function FractionFraction(x, y) {
+      return x.sub(y);
+    },
+    'Unit, Unit': typed.referToSelf(function (self) {
+      return function (x, y) {
+        if (x.value === null || x.value === undefined) {
+          throw new Error('Parameter x contains a unit with undefined value');
+        }
+        if (y.value === null || y.value === undefined) {
+          throw new Error('Parameter y contains a unit with undefined value');
+        }
+        if (!x.equalBase(y)) throw new Error('Units do not match');
+        var res = x.clone();
+        res.value = typed.find(self, [res.valueType(), y.valueType()])(res.value, y.value);
+        res.fixPrefix = false;
+        return res;
+      };
+    })
+  });
+});

package/lib/cjs/function/combinatorics/stirlingS2.js

@@ -7,11 +7,11 @@ exports.createStirlingS2 = void 0;
 var _factory = require("../../utils/factory.js");
 var _is = require("../../utils/is.js");
 var name = 'stirlingS2';
-var dependencies = ['typed', 'addScalar', 'subtract', 'multiplyScalar', 'divideScalar', 'pow', 'factorial', 'combinations', 'isNegative', 'isInteger', 'number', '?bignumber', 'larger'];
+var dependencies = ['typed', 'addScalar', 'subtractScalar', 'multiplyScalar', 'divideScalar', 'pow', 'factorial', 'combinations', 'isNegative', 'isInteger', 'number', '?bignumber', 'larger'];
 var createStirlingS2 = exports.createStirlingS2 = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     addScalar = _ref.addScalar,
-    subtract = _ref.subtract,
+    subtractScalar = _ref.subtractScalar,
     multiplyScalar = _ref.multiplyScalar,
     divideScalar = _ref.divideScalar,
     pow = _ref.pow,

package/lib/cjs/function/geometry/distance.js

@@ -7,11 +7,11 @@ exports.createDistance = void 0;
 var _is = require("../../utils/is.js");
 var _factory = require("../../utils/factory.js");
 var name = 'distance';
-var dependencies = ['typed', 'addScalar', 'subtract', 'divideScalar', 'multiplyScalar', 'deepEqual', 'sqrt', 'abs'];
+var dependencies = ['typed', 'addScalar', 'subtractScalar', 'divideScalar', 'multiplyScalar', 'deepEqual', 'sqrt', 'abs'];
 var createDistance = exports.createDistance = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     addScalar = _ref.addScalar,
-    subtract = _ref.subtract,
+    subtractScalar = _ref.subtractScalar,
     multiplyScalar = _ref.multiplyScalar,
     divideScalar = _ref.divideScalar,
     deepEqual = _ref.deepEqual,
@@ -84,9 +84,9 @@ var createDistance = exports.createDistance = /* #__PURE__ */(0, _factory.factor
         if (deepEqual(y, z)) {
           throw new TypeError('LinePoint1 should not be same with LinePoint2');
         }
-        var xCoeff = subtract(z[1], y[1]);
-        var yCoeff = subtract(y[0], z[0]);
-        var constant = subtract(multiplyScalar(z[0], y[1]), multiplyScalar(y[0], z[1]));
+        var xCoeff = subtractScalar(z[1], y[1]);
+        var yCoeff = subtractScalar(y[0], z[0]);
+        var constant = subtractScalar(multiplyScalar(z[0], y[1]), multiplyScalar(y[0], z[1]));
         return _distancePointLine2D(x[0], x[1], xCoeff, yCoeff, constant);
       } else {
         throw new TypeError('Invalid Arguments: Try again');
@@ -107,9 +107,9 @@ var createDistance = exports.createDistance = /* #__PURE__ */(0, _factory.factor
           throw new TypeError('LinePoint1 should not be same with LinePoint2');
         }
         if ('pointX' in x && 'pointY' in x && 'lineOnePtX' in y && 'lineOnePtY' in y && 'lineTwoPtX' in z && 'lineTwoPtY' in z) {
-          var xCoeff = subtract(z.lineTwoPtY, y.lineOnePtY);
-          var yCoeff = subtract(y.lineOnePtX, z.lineTwoPtX);
-          var constant = subtract(multiplyScalar(z.lineTwoPtX, y.lineOnePtY), multiplyScalar(y.lineOnePtX, z.lineTwoPtY));
+          var xCoeff = subtractScalar(z.lineTwoPtY, y.lineOnePtY);
+          var yCoeff = subtractScalar(y.lineOnePtX, z.lineTwoPtX);
+          var constant = subtractScalar(multiplyScalar(z.lineTwoPtX, y.lineOnePtY), multiplyScalar(y.lineOnePtX, z.lineTwoPtY));
           return _distancePointLine2D(x.pointX, x.pointY, xCoeff, yCoeff, constant);
         } else {
           throw new TypeError('Key names do not match');
@@ -277,7 +277,7 @@ var createDistance = exports.createDistance = /* #__PURE__ */(0, _factory.factor
     return divideScalar(num, den);
   }
   function _distancePointLine3D(x, y, z, x0, y0, z0, a, b, c) {
-    var num = [subtract(multiplyScalar(subtract(y0, y), c), multiplyScalar(subtract(z0, z), b)), subtract(multiplyScalar(subtract(z0, z), a), multiplyScalar(subtract(x0, x), c)), subtract(multiplyScalar(subtract(x0, x), b), multiplyScalar(subtract(y0, y), a))];
+    var num = [subtractScalar(multiplyScalar(subtractScalar(y0, y), c), multiplyScalar(subtractScalar(z0, z), b)), subtractScalar(multiplyScalar(subtractScalar(z0, z), a), multiplyScalar(subtractScalar(x0, x), c)), subtractScalar(multiplyScalar(subtractScalar(x0, x), b), multiplyScalar(subtractScalar(y0, y), a))];
     num = sqrt(addScalar(addScalar(multiplyScalar(num[0], num[0]), multiplyScalar(num[1], num[1])), multiplyScalar(num[2], num[2])));
     var den = sqrt(addScalar(addScalar(multiplyScalar(a, a), multiplyScalar(b, b)), multiplyScalar(c, c)));
     return divideScalar(num, den);
@@ -287,7 +287,7 @@ var createDistance = exports.createDistance = /* #__PURE__ */(0, _factory.factor
     var result = 0;
     var diff = 0;
     for (var i = 0; i < vectorSize; i++) {
-      diff = subtract(x[i], y[i]);
+      diff = subtractScalar(x[i], y[i]);
       result = addScalar(multiplyScalar(diff, diff), result);
     }
     return sqrt(result);

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

@@ -9,11 +9,11 @@ var _object = require("../../utils/object.js");
 var _string = require("../../utils/string.js");
 var _factory = require("../../utils/factory.js");
 var name = 'det';
-var dependencies = ['typed', 'matrix', 'subtract', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
+var dependencies = ['typed', 'matrix', 'subtractScalar', 'multiply', 'divideScalar', 'isZero', 'unaryMinus'];
 var createDet = exports.createDet = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
   var typed = _ref.typed,
     matrix = _ref.matrix,
-    subtract = _ref.subtract,
+    subtractScalar = _ref.subtractScalar,
     multiply = _ref.multiply,
     divideScalar = _ref.divideScalar,
     isZero = _ref.isZero,
@@ -108,7 +108,7 @@ var createDet = exports.createDet = /* #__PURE__ */(0, _factory.factory)(name, d
     } else if (rows === 2) {
       // this is a 2 x 2 matrix
       // the determinant of [a11,a12;a21,a22] is det = a11*a22-a21*a12
-      return subtract(multiply(matrix[0][0], matrix[1][1]), multiply(matrix[1][0], matrix[0][1]));
+      return subtractScalar(multiply(matrix[0][0], matrix[1][1]), multiply(matrix[1][0], matrix[0][1]));
     } else {
       // Bareiss algorithm
       // this algorithm have same complexity as LUP decomposition (O(n^3))
@@ -138,7 +138,7 @@ var createDet = exports.createDet = /* #__PURE__ */(0, _factory.factory)(name, d
         for (var i = k + 1; i < rows; i++) {
           var i_ = rowIndices[i];
           for (var j = k + 1; j < rows; j++) {
-            matrix[i_][j] = divideScalar(subtract(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
+            matrix[i_][j] = divideScalar(subtractScalar(multiply(matrix[i_][j], piv), multiply(matrix[i_][k], matrix[k_][j])), piv_);
           }
         }
       }

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

@@ -21,6 +21,8 @@ function createComplexEigs(_ref) {
     abs = _ref.abs,
     bignumber = _ref.bignumber,
     diag = _ref.diag,
+    size = _ref.size,
+    reshape = _ref.reshape,
     inv = _ref.inv,
     qr = _ref.qr,
     usolve = _ref.usolve,
@@ -40,11 +42,8 @@ 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
@@ -53,9 +52,9 @@ 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
@@ -65,7 +64,7 @@ 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 _iterateUntilTriangul = iterateUntilTriangular(arr, N, prec, type, findVectors),
@@ -75,17 +74,18 @@ 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.apply(void 0, (0, _toConsumableArray2["default"])(vectors));
+      var eigenvectors = findEigenvectors(arr, N, C, R, values, prec, type);
+      return {
+        values: values,
+        eigenvectors: eigenvectors
+      };
     }
     return {
-      values: values,
-      vectors: vectors
+      values: values
     };
   }
 
@@ -125,9 +125,8 @@ 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
@@ -135,21 +134,21 @@ 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) {
@@ -161,13 +160,13 @@ 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);
             }
           }
         }
@@ -175,7 +174,7 @@ function createComplexEigs(_ref) {
     }
 
     // return the diagonal row transformation matrix
-    return diag(Rdiag);
+    return findVectors ? diag(Rdiag) : null;
   }
 
   /**
@@ -274,7 +273,7 @@ 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
@@ -296,7 +295,7 @@ 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
@@ -308,7 +307,12 @@ 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);
@@ -427,17 +431,17 @@ function createComplexEigs(_ref) {
       _step;
     try {
       for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var λ = _step.value;
-        var _i4 = indexOf(uniqueValues, λ, equal);
+        var lambda = _step.value;
+        var _i4 = indexOf(uniqueValues, lambda, equal);
         if (_i4 === -1) {
-          uniqueValues.push(λ);
+          uniqueValues.push(lambda);
           multiplicities.push(1);
         } else {
           multiplicities[_i4] += 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)
     } catch (err) {
@@ -449,24 +453,21 @@ 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[i];
-      var S = subtract(U, multiply(λ, E)); // the characteristic matrix
+      var lambda = uniqueValues[i];
+      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[i]) {
         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);
       }
 
@@ -476,18 +477,15 @@ function createComplexEigs(_ref) {
         return multiply(correction, v);
       });
       vectors.push.apply(vectors, (0, _toConsumableArray2["default"])(solutions.map(function (v) {
-        return flatten(v);
+        return {
+          value: lambda,
+          vector: flatten(v)
+        };
       })));
     };
     for (var i = 0; i < len; i++) {
       _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;
   }
 
@@ -496,7 +494,7 @@ 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);
@@ -506,7 +504,7 @@ 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
@@ -530,23 +528,22 @@ 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) {
@@ -633,15 +630,21 @@ 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
@@ -697,12 +700,14 @@ function createComplexEigs(_ref) {
    * Project vector v to the orthogonal complement of an array of vectors
    */
   function orthogonalComplement(v, orthog) {
+    var vectorShape = size(v);
     var _iterator3 = _createForOfIteratorHelper(orthog),
       _step3;
     try {
       for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
         var w = _step3.value;
-        // 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));
       }
     } catch (err) {