mathjs-min 11.7.2

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

@@ -0,0 +1,297 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRealSymmetric = createRealSymmetric;
+var _object = require("../../../utils/object.js");
+function createRealSymmetric(_ref) {
+  var config = _ref.config,
+    addScalar = _ref.addScalar,
+    subtract = _ref.subtract,
+    abs = _ref.abs,
+    atan = _ref.atan,
+    cos = _ref.cos,
+    sin = _ref.sin,
+    multiplyScalar = _ref.multiplyScalar,
+    inv = _ref.inv,
+    bignumber = _ref.bignumber,
+    multiply = _ref.multiply,
+    add = _ref.add;
+  /**
+   * @param {number[] | BigNumber[]} arr
+   * @param {number} N
+   * @param {number} prec
+   * @param {'number' | 'BigNumber'} type
+   */
+  function main(arr, N) {
+    var prec = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : config.epsilon;
+    var type = arguments.length > 3 ? arguments[3] : undefined;
+    if (type === 'number') {
+      return diag(arr, prec);
+    }
+    if (type === 'BigNumber') {
+      return diagBig(arr, prec);
+    }
+    throw TypeError('Unsupported data type: ' + type);
+  }
+
+  // diagonalization implementation for number (efficient)
+  function diag(x, precision) {
+    var N = x.length;
+    var e0 = Math.abs(precision / N);
+    var psi;
+    var Sij = new Array(N);
+    // Sij is Identity Matrix
+    for (var i = 0; i < N; i++) {
+      Sij[i] = createArray(N, 0);
+      Sij[i][i] = 1.0;
+    }
+    // initial error
+    var Vab = getAij(x);
+    while (Math.abs(Vab[1]) >= Math.abs(e0)) {
+      var _i = Vab[0][0];
+      var j = Vab[0][1];
+      psi = getTheta(x[_i][_i], x[j][j], x[_i][j]);
+      x = x1(x, psi, _i, j);
+      Sij = Sij1(Sij, psi, _i, j);
+      Vab = getAij(x);
+    }
+    var Ei = createArray(N, 0); // eigenvalues
+    for (var _i2 = 0; _i2 < N; _i2++) {
+      Ei[_i2] = x[_i2][_i2];
+    }
+    return sorting((0, _object.clone)(Ei), (0, _object.clone)(Sij));
+  }
+
+  // diagonalization implementation for bigNumber
+  function diagBig(x, precision) {
+    var N = x.length;
+    var e0 = abs(precision / N);
+    var psi;
+    var Sij = new Array(N);
+    // Sij is Identity Matrix
+    for (var i = 0; i < N; i++) {
+      Sij[i] = createArray(N, 0);
+      Sij[i][i] = 1.0;
+    }
+    // initial error
+    var Vab = getAijBig(x);
+    while (abs(Vab[1]) >= abs(e0)) {
+      var _i3 = Vab[0][0];
+      var j = Vab[0][1];
+      psi = getThetaBig(x[_i3][_i3], x[j][j], x[_i3][j]);
+      x = x1Big(x, psi, _i3, j);
+      Sij = Sij1Big(Sij, psi, _i3, j);
+      Vab = getAijBig(x);
+    }
+    var Ei = createArray(N, 0); // eigenvalues
+    for (var _i4 = 0; _i4 < N; _i4++) {
+      Ei[_i4] = x[_i4][_i4];
+    }
+    // return [clone(Ei), clone(Sij)]
+    return sorting((0, _object.clone)(Ei), (0, _object.clone)(Sij));
+  }
+
+  // get angle
+  function getTheta(aii, ajj, aij) {
+    var denom = ajj - aii;
+    if (Math.abs(denom) <= config.epsilon) {
+      return Math.PI / 4.0;
+    } else {
+      return 0.5 * Math.atan(2.0 * aij / (ajj - aii));
+    }
+  }
+
+  // get angle
+  function getThetaBig(aii, ajj, aij) {
+    var denom = subtract(ajj, aii);
+    if (abs(denom) <= config.epsilon) {
+      return bignumber(-1).acos().div(4);
+    } else {
+      return multiplyScalar(0.5, atan(multiply(2.0, aij, inv(denom))));
+    }
+  }
+
+  // update eigvec
+  function Sij1(Sij, theta, i, j) {
+    var N = Sij.length;
+    var c = Math.cos(theta);
+    var s = Math.sin(theta);
+    var Ski = createArray(N, 0);
+    var Skj = createArray(N, 0);
+    for (var k = 0; k < N; k++) {
+      Ski[k] = c * Sij[k][i] - s * Sij[k][j];
+      Skj[k] = s * Sij[k][i] + c * Sij[k][j];
+    }
+    for (var _k = 0; _k < N; _k++) {
+      Sij[_k][i] = Ski[_k];
+      Sij[_k][j] = Skj[_k];
+    }
+    return Sij;
+  }
+  // update eigvec for overlap
+  function Sij1Big(Sij, theta, i, j) {
+    var N = Sij.length;
+    var c = cos(theta);
+    var s = sin(theta);
+    var Ski = createArray(N, bignumber(0));
+    var Skj = createArray(N, bignumber(0));
+    for (var k = 0; k < N; k++) {
+      Ski[k] = subtract(multiplyScalar(c, Sij[k][i]), multiplyScalar(s, Sij[k][j]));
+      Skj[k] = addScalar(multiplyScalar(s, Sij[k][i]), multiplyScalar(c, Sij[k][j]));
+    }
+    for (var _k2 = 0; _k2 < N; _k2++) {
+      Sij[_k2][i] = Ski[_k2];
+      Sij[_k2][j] = Skj[_k2];
+    }
+    return Sij;
+  }
+
+  // update matrix
+  function x1Big(Hij, theta, i, j) {
+    var N = Hij.length;
+    var c = bignumber(cos(theta));
+    var s = bignumber(sin(theta));
+    var c2 = multiplyScalar(c, c);
+    var s2 = multiplyScalar(s, s);
+    var Aki = createArray(N, bignumber(0));
+    var Akj = createArray(N, bignumber(0));
+    // 2cs Hij
+    var csHij = multiply(bignumber(2), c, s, Hij[i][j]);
+    //  Aii
+    var Aii = addScalar(subtract(multiplyScalar(c2, Hij[i][i]), csHij), multiplyScalar(s2, Hij[j][j]));
+    var Ajj = add(multiplyScalar(s2, Hij[i][i]), csHij, multiplyScalar(c2, Hij[j][j]));
+    // 0  to i
+    for (var k = 0; k < N; k++) {
+      Aki[k] = subtract(multiplyScalar(c, Hij[i][k]), multiplyScalar(s, Hij[j][k]));
+      Akj[k] = addScalar(multiplyScalar(s, Hij[i][k]), multiplyScalar(c, Hij[j][k]));
+    }
+    // Modify Hij
+    Hij[i][i] = Aii;
+    Hij[j][j] = Ajj;
+    Hij[i][j] = bignumber(0);
+    Hij[j][i] = bignumber(0);
+    // 0  to i
+    for (var _k3 = 0; _k3 < N; _k3++) {
+      if (_k3 !== i && _k3 !== j) {
+        Hij[i][_k3] = Aki[_k3];
+        Hij[_k3][i] = Aki[_k3];
+        Hij[j][_k3] = Akj[_k3];
+        Hij[_k3][j] = Akj[_k3];
+      }
+    }
+    return Hij;
+  }
+
+  // update matrix
+  function x1(Hij, theta, i, j) {
+    var N = Hij.length;
+    var c = Math.cos(theta);
+    var s = Math.sin(theta);
+    var c2 = c * c;
+    var s2 = s * s;
+    var Aki = createArray(N, 0);
+    var Akj = createArray(N, 0);
+    //  Aii
+    var Aii = c2 * Hij[i][i] - 2 * c * s * Hij[i][j] + s2 * Hij[j][j];
+    var Ajj = s2 * Hij[i][i] + 2 * c * s * Hij[i][j] + c2 * Hij[j][j];
+    // 0  to i
+    for (var k = 0; k < N; k++) {
+      Aki[k] = c * Hij[i][k] - s * Hij[j][k];
+      Akj[k] = s * Hij[i][k] + c * Hij[j][k];
+    }
+    // Modify Hij
+    Hij[i][i] = Aii;
+    Hij[j][j] = Ajj;
+    Hij[i][j] = 0;
+    Hij[j][i] = 0;
+    // 0  to i
+    for (var _k4 = 0; _k4 < N; _k4++) {
+      if (_k4 !== i && _k4 !== j) {
+        Hij[i][_k4] = Aki[_k4];
+        Hij[_k4][i] = Aki[_k4];
+        Hij[j][_k4] = Akj[_k4];
+        Hij[_k4][j] = Akj[_k4];
+      }
+    }
+    return Hij;
+  }
+
+  // get max off-diagonal value from Upper Diagonal
+  function getAij(Mij) {
+    var N = Mij.length;
+    var maxMij = 0;
+    var maxIJ = [0, 1];
+    for (var i = 0; i < N; i++) {
+      for (var j = i + 1; j < N; j++) {
+        if (Math.abs(maxMij) < Math.abs(Mij[i][j])) {
+          maxMij = Math.abs(Mij[i][j]);
+          maxIJ = [i, j];
+        }
+      }
+    }
+    return [maxIJ, maxMij];
+  }
+
+  // get max off-diagonal value from Upper Diagonal
+  function getAijBig(Mij) {
+    var N = Mij.length;
+    var maxMij = 0;
+    var maxIJ = [0, 1];
+    for (var i = 0; i < N; i++) {
+      for (var j = i + 1; j < N; j++) {
+        if (abs(maxMij) < abs(Mij[i][j])) {
+          maxMij = abs(Mij[i][j]);
+          maxIJ = [i, j];
+        }
+      }
+    }
+    return [maxIJ, maxMij];
+  }
+
+  // sort results
+  function sorting(E, S) {
+    var N = E.length;
+    var values = Array(N);
+    var vectors = Array(N);
+    for (var k = 0; k < N; k++) {
+      vectors[k] = Array(N);
+    }
+    for (var i = 0; i < N; i++) {
+      var minID = 0;
+      var minE = E[0];
+      for (var j = 0; j < E.length; j++) {
+        if (abs(E[j]) < abs(minE)) {
+          minID = j;
+          minE = E[minID];
+        }
+      }
+      values[i] = E.splice(minID, 1)[0];
+      for (var _k5 = 0; _k5 < N; _k5++) {
+        vectors[_k5][i] = S[_k5][minID];
+        S[_k5].splice(minID, 1);
+      }
+    }
+    return {
+      values: values,
+      vectors: vectors
+    };
+  }
+
+  /**
+   * Create an array of a certain size and fill all items with an initial value
+   * @param {number} size
+   * @param {number} value
+   * @return {number[]}
+   */
+  function createArray(size, value) {
+    // TODO: as soon as all browsers support Array.fill, use that instead (IE doesn't support it)
+    var array = new Array(size);
+    for (var i = 0; i < size; i++) {
+      array[i] = value;
+    }
+    return array;
+  }
+  return main;
+}

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

@@ -0,0 +1,259 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEigs = void 0;
+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 _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 createEigs = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var config = _ref.config,
+    typed = _ref.typed,
+    matrix = _ref.matrix,
+    addScalar = _ref.addScalar,
+    subtract = _ref.subtract,
+    equal = _ref.equal,
+    abs = _ref.abs,
+    atan = _ref.atan,
+    cos = _ref.cos,
+    sin = _ref.sin,
+    multiplyScalar = _ref.multiplyScalar,
+    divideScalar = _ref.divideScalar,
+    inv = _ref.inv,
+    bignumber = _ref.bignumber,
+    multiply = _ref.multiply,
+    add = _ref.add,
+    larger = _ref.larger,
+    column = _ref.column,
+    flatten = _ref.flatten,
+    number = _ref.number,
+    complex = _ref.complex,
+    sqrt = _ref.sqrt,
+    diag = _ref.diag,
+    qr = _ref.qr,
+    usolve = _ref.usolve,
+    usolveAll = _ref.usolveAll,
+    im = _ref.im,
+    re = _ref.re,
+    smaller = _ref.smaller,
+    matrixFromColumns = _ref.matrixFromColumns,
+    dot = _ref.dot;
+  var doRealSymetric = (0, _realSymetric.createRealSymmetric)({
+    config: config,
+    addScalar: addScalar,
+    subtract: subtract,
+    column: column,
+    flatten: flatten,
+    equal: equal,
+    abs: abs,
+    atan: atan,
+    cos: cos,
+    sin: sin,
+    multiplyScalar: multiplyScalar,
+    inv: inv,
+    bignumber: bignumber,
+    complex: complex,
+    multiply: multiply,
+    add: add
+  });
+  var doComplexEigs = (0, _complexEigs.createComplexEigs)({
+    config: config,
+    addScalar: addScalar,
+    subtract: subtract,
+    multiply: multiply,
+    multiplyScalar: multiplyScalar,
+    flatten: flatten,
+    divideScalar: divideScalar,
+    sqrt: sqrt,
+    abs: abs,
+    bignumber: bignumber,
+    diag: diag,
+    qr: qr,
+    inv: inv,
+    usolve: usolve,
+    usolveAll: usolveAll,
+    equal: equal,
+    complex: complex,
+    larger: larger,
+    smaller: smaller,
+    matrixFromColumns: matrixFromColumns,
+    dot: dot
+  });
+
+  /**
+   * 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
+   * in `err.values` and `err.vectors`.
+   *
+   * Syntax:
+   *
+   *     math.eigs(x, [prec])
+   *
+   * Examples:
+   *
+   *     const { eigs, multiply, column, transpose } = 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 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
+   *
+   * See also:
+   *
+   *     inv
+   *
+   * @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.
+   *
+   */
+  return typed('eigs', {
+    Array: function Array(x) {
+      var mat = matrix(x);
+      return computeValuesAndVectors(mat);
+    },
+    'Array, number|BigNumber': function ArrayNumberBigNumber(x, prec) {
+      var mat = matrix(x);
+      return computeValuesAndVectors(mat, prec);
+    },
+    Matrix: function Matrix(mat) {
+      var _computeValuesAndVect = computeValuesAndVectors(mat),
+        values = _computeValuesAndVect.values,
+        vectors = _computeValuesAndVect.vectors;
+      return {
+        values: matrix(values),
+        vectors: matrix(vectors)
+      };
+    },
+    '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)
+      };
+    }
+  });
+  function computeValuesAndVectors(mat, prec) {
+    if (prec === undefined) {
+      prec = config.epsilon;
+    }
+    var size = mat.size();
+    if (size.length !== 2 || size[0] !== size[1]) {
+      throw new RangeError('Matrix must be square (size: ' + (0, _string.format)(size) + ')');
+    }
+    var arr = mat.toArray();
+    var N = size[0];
+    if (isReal(arr, N, prec)) {
+      coerceReal(arr, N);
+      if (isSymmetric(arr, N, prec)) {
+        var _type = coerceTypes(mat, arr, N);
+        return doRealSymetric(arr, N, prec, _type);
+      }
+    }
+    var type = coerceTypes(mat, arr, N);
+    return doComplexEigs(arr, N, prec, type);
+  }
+
+  /** @return {boolean} */
+  function isSymmetric(arr, N, prec) {
+    for (var i = 0; i < N; i++) {
+      for (var j = i; j < N; j++) {
+        // TODO proper comparison of bignum and frac
+        if (larger(bignumber(abs(subtract(arr[i][j], arr[j][i]))), prec)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  /** @return {boolean} */
+  function isReal(arr, N, prec) {
+    for (var i = 0; i < N; i++) {
+      for (var j = 0; j < N; j++) {
+        // TODO proper comparison of bignum and frac
+        if (larger(bignumber(abs(im(arr[i][j]))), prec)) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  function coerceReal(arr, N) {
+    for (var i = 0; i < N; i++) {
+      for (var j = 0; j < N; j++) {
+        arr[i][j] = re(arr[i][j]);
+      }
+    }
+  }
+
+  /** @return {'number' | 'BigNumber' | 'Complex'} */
+  function coerceTypes(mat, arr, N) {
+    /** @type {string} */
+    var type = mat.datatype();
+    if (type === 'number' || type === 'BigNumber' || type === 'Complex') {
+      return type;
+    }
+    var hasNumber = false;
+    var hasBig = false;
+    var hasComplex = false;
+    for (var i = 0; i < N; i++) {
+      for (var j = 0; j < N; j++) {
+        var el = arr[i][j];
+        if ((0, _is.isNumber)(el) || (0, _is.isFraction)(el)) {
+          hasNumber = true;
+        } else if ((0, _is.isBigNumber)(el)) {
+          hasBig = true;
+        } else if ((0, _is.isComplex)(el)) {
+          hasComplex = true;
+        } else {
+          throw TypeError('Unsupported type in Matrix: ' + (0, _is.typeOf)(el));
+        }
+      }
+    }
+    if (hasBig && hasComplex) {
+      console.warn('Complex BigNumbers not supported, this operation will lose precission.');
+    }
+    if (hasComplex) {
+      for (var _i = 0; _i < N; _i++) {
+        for (var _j = 0; _j < N; _j++) {
+          arr[_i][_j] = complex(arr[_i][_j]);
+        }
+      }
+      return 'Complex';
+    }
+    if (hasBig) {
+      for (var _i2 = 0; _i2 < N; _i2++) {
+        for (var _j2 = 0; _j2 < N; _j2++) {
+          arr[_i2][_j2] = bignumber(arr[_i2][_j2]);
+        }
+      }
+      return 'BigNumber';
+    }
+    if (hasNumber) {
+      for (var _i3 = 0; _i3 < N; _i3++) {
+        for (var _j3 = 0; _j3 < N; _j3++) {
+          arr[_i3][_j3] = number(arr[_i3][_j3]);
+        }
+      }
+      return 'number';
+    } else {
+      throw TypeError('Matrix contains unsupported types only.');
+    }
+  }
+});
+exports.createEigs = createEigs;

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

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createExpm = void 0;
+var _is = require("../../utils/is.js");
+var _string = require("../../utils/string.js");
+var _factory = require("../../utils/factory.js");
+var name = 'expm';
+var dependencies = ['typed', 'abs', 'add', 'identity', 'inv', 'multiply'];
+var createExpm = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
+  var typed = _ref.typed,
+    abs = _ref.abs,
+    add = _ref.add,
+    identity = _ref.identity,
+    inv = _ref.inv,
+    multiply = _ref.multiply;
+  /**
+   * Compute the matrix exponential, expm(A) = e^A. The matrix must be square.
+   * Not to be confused with exp(a), which performs element-wise
+   * exponentiation.
+   *
+   * The exponential is calculated using the Padé approximant with scaling and
+   * squaring; see "Nineteen Dubious Ways to Compute the Exponential of a
+   * Matrix," by Moler and Van Loan.
+   *
+   * Syntax:
+   *
+   *     math.expm(x)
+   *
+   * Examples:
+   *
+   *     const A = [[0,2],[0,0]]
+   *     math.expm(A)        // returns [[1,2],[0,1]]
+   *
+   * See also:
+   *
+   *     exp
+   *
+   * @param {Matrix} x  A square Matrix
+   * @return {Matrix}   The exponential of x
+   */
+  return typed(name, {
+    Matrix: function Matrix(A) {
+      // Check matrix size
+      var size = A.size();
+      if (size.length !== 2 || size[0] !== size[1]) {
+        throw new RangeError('Matrix must be square ' + '(size: ' + (0, _string.format)(size) + ')');
+      }
+      var n = size[0];
+
+      // Desired accuracy of the approximant (The actual accuracy
+      // will be affected by round-off error)
+      var eps = 1e-15;
+
+      // The Padé approximant is not so accurate when the values of A
+      // are "large", so scale A by powers of two. Then compute the
+      // exponential, and square the result repeatedly according to
+      // the identity e^A = (e^(A/m))^m
+
+      // Compute infinity-norm of A, ||A||, to see how "big" it is
+      var infNorm = infinityNorm(A);
+
+      // Find the optimal scaling factor and number of terms in the
+      // Padé approximant to reach the desired accuracy
+      var params = findParams(infNorm, eps);
+      var q = params.q;
+      var j = params.j;
+
+      // The Pade approximation to e^A is:
+      // Rqq(A) = Dqq(A) ^ -1 * Nqq(A)
+      // where
+      // Nqq(A) = sum(i=0, q, (2q-i)!p! / [ (2q)!i!(q-i)! ] A^i
+      // Dqq(A) = sum(i=0, q, (2q-i)!q! / [ (2q)!i!(q-i)! ] (-A)^i
+
+      // Scale A by 1 / 2^j
+      var Apos = multiply(A, Math.pow(2, -j));
+
+      // The i=0 term is just the identity matrix
+      var N = identity(n);
+      var D = identity(n);
+
+      // Initialization (i=0)
+      var factor = 1;
+
+      // Initialization (i=1)
+      var AposToI = Apos; // Cloning not necessary
+      var alternate = -1;
+      for (var i = 1; i <= q; i++) {
+        if (i > 1) {
+          AposToI = multiply(AposToI, Apos);
+          alternate = -alternate;
+        }
+        factor = factor * (q - i + 1) / ((2 * q - i + 1) * i);
+        N = add(N, multiply(factor, AposToI));
+        D = add(D, multiply(factor * alternate, AposToI));
+      }
+      var R = multiply(inv(D), N);
+
+      // Square j times
+      for (var _i = 0; _i < j; _i++) {
+        R = multiply(R, R);
+      }
+      return (0, _is.isSparseMatrix)(A) ? A.createSparseMatrix(R) : R;
+    }
+  });
+  function infinityNorm(A) {
+    var n = A.size()[0];
+    var infNorm = 0;
+    for (var i = 0; i < n; i++) {
+      var rowSum = 0;
+      for (var j = 0; j < n; j++) {
+        rowSum += abs(A.get([i, j]));
+      }
+      infNorm = Math.max(rowSum, infNorm);
+    }
+    return infNorm;
+  }
+
+  /**
+   * Find the best parameters for the Pade approximant given
+   * the matrix norm and desired accuracy. Returns the first acceptable
+   * combination in order of increasing computational load.
+   */
+  function findParams(infNorm, eps) {
+    var maxSearchSize = 30;
+    for (var k = 0; k < maxSearchSize; k++) {
+      for (var q = 0; q <= k; q++) {
+        var j = k - q;
+        if (errorEstimate(infNorm, q, j) < eps) {
+          return {
+            q: q,
+            j: j
+          };
+        }
+      }
+    }
+    throw new Error('Could not find acceptable parameters to compute the matrix exponential (try increasing maxSearchSize in expm.js)');
+  }
+
+  /**
+   * Returns the estimated error of the Pade approximant for the given
+   * parameters.
+   */
+  function errorEstimate(infNorm, q, j) {
+    var qfac = 1;
+    for (var i = 2; i <= q; i++) {
+      qfac *= i;
+    }
+    var twoqfac = qfac;
+    for (var _i2 = q + 1; _i2 <= 2 * q; _i2++) {
+      twoqfac *= _i2;
+    }
+    var twoqp1fac = twoqfac * (2 * q + 1);
+    return 8.0 * Math.pow(infNorm / Math.pow(2, j), 2 * q) * qfac * qfac / (twoqfac * twoqp1fac);
+  }
+});
+exports.createExpm = createExpm;