mathjs 12.4.3 → 13.0.0

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

@@ -1,25 +1,25 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createUsolveAll = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _factory = require("../../../utils/factory.js");
 var _solveValidation = require("./utils/solveValidation.js");
-var name = 'usolveAll';
-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,
-    subtractScalar = _ref.subtractScalar,
-    equalScalar = _ref.equalScalar,
-    DenseMatrix = _ref.DenseMatrix;
-  var solveValidation = (0, _solveValidation.createSolveValidation)({
-    DenseMatrix: DenseMatrix
+const name = 'usolveAll';
+const dependencies = ['typed', 'matrix', 'divideScalar', 'multiplyScalar', 'subtractScalar', 'equalScalar', 'DenseMatrix'];
+const createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    typed,
+    matrix,
+    divideScalar,
+    multiplyScalar,
+    subtractScalar,
+    equalScalar,
+    DenseMatrix
+  } = _ref;
+  const solveValidation = (0, _solveValidation.createSolveValidation)({
+    DenseMatrix
   });
 
   /**
@@ -47,18 +47,16 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
    * @return {DenseMatrix[] | Array[]}  An array of affine-independent column vectors (x) that solve the linear system
    */
   return typed(name, {
-    'SparseMatrix, Array | Matrix': function SparseMatrixArrayMatrix(m, b) {
+    'SparseMatrix, Array | Matrix': function (m, b) {
       return _sparseBackwardSubstitution(m, b);
     },
-    'DenseMatrix, Array | Matrix': function DenseMatrixArrayMatrix(m, b) {
+    'DenseMatrix, Array | Matrix': function (m, b) {
       return _denseBackwardSubstitution(m, b);
     },
-    'Array, Array | Matrix': function ArrayArrayMatrix(a, b) {
-      var m = matrix(a);
-      var R = _denseBackwardSubstitution(m, b);
-      return R.map(function (r) {
-        return r.valueOf();
-      });
+    'Array, Array | Matrix': function (a, b) {
+      const m = matrix(a);
+      const R = _denseBackwardSubstitution(m, b);
+      return R.map(r => r.valueOf());
     }
   });
   function _denseBackwardSubstitution(m, b_) {
@@ -66,25 +64,23 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
     // https://www.overleaf.com/read/csvgqdxggyjv
 
     // array of right-hand sides
-    var B = [solveValidation(m, b_, true)._data.map(function (e) {
-      return e[0];
-    })];
-    var M = m._data;
-    var rows = m._size[0];
-    var columns = m._size[1];
+    const B = [solveValidation(m, b_, true)._data.map(e => e[0])];
+    const M = m._data;
+    const rows = m._size[0];
+    const columns = m._size[1];
 
     // loop columns backwards
-    for (var i = columns - 1; i >= 0; i--) {
-      var L = B.length;
+    for (let i = columns - 1; i >= 0; i--) {
+      let L = B.length;
 
       // loop right-hand sides
-      for (var k = 0; k < L; k++) {
-        var b = B[k];
+      for (let k = 0; k < L; k++) {
+        const b = B[k];
         if (!equalScalar(M[i][i], 0)) {
           // non-singular row
 
           b[i] = divideScalar(b[i], M[i][i]);
-          for (var j = i - 1; j >= 0; j--) {
+          for (let j = i - 1; j >= 0; j--) {
             // b[j] -= b[i] * M[j,i]
             b[j] = subtractScalar(b[j], multiplyScalar(b[i], M[j][i]));
           }
@@ -103,55 +99,49 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
         } else if (k === 0) {
           // singular row, RHS is zero
 
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          const bNew = [...b];
           bNew[i] = 1;
-          for (var _j = i - 1; _j >= 0; _j--) {
-            bNew[_j] = subtractScalar(bNew[_j], M[_j][i]);
+          for (let j = i - 1; j >= 0; j--) {
+            bNew[j] = subtractScalar(bNew[j], M[j][i]);
           }
           B.push(bNew);
         }
       }
     }
-    return B.map(function (x) {
-      return new DenseMatrix({
-        data: x.map(function (e) {
-          return [e];
-        }),
-        size: [rows, 1]
-      });
-    });
+    return B.map(x => new DenseMatrix({
+      data: x.map(e => [e]),
+      size: [rows, 1]
+    }));
   }
   function _sparseBackwardSubstitution(m, b_) {
     // array of right-hand sides
-    var B = [solveValidation(m, b_, true)._data.map(function (e) {
-      return e[0];
-    })];
-    var rows = m._size[0];
-    var columns = m._size[1];
-    var values = m._values;
-    var index = m._index;
-    var ptr = m._ptr;
+    const B = [solveValidation(m, b_, true)._data.map(e => e[0])];
+    const rows = m._size[0];
+    const columns = m._size[1];
+    const values = m._values;
+    const index = m._index;
+    const ptr = m._ptr;
 
     // loop columns backwards
-    for (var i = columns - 1; i >= 0; i--) {
-      var L = B.length;
+    for (let i = columns - 1; i >= 0; i--) {
+      let L = B.length;
 
       // loop right-hand sides
-      for (var k = 0; k < L; k++) {
-        var b = B[k];
+      for (let k = 0; k < L; k++) {
+        const b = B[k];
 
         // values & indices (column i)
-        var iValues = [];
-        var iIndices = [];
+        const iValues = [];
+        const iIndices = [];
 
         // first & last indeces in column
-        var firstIndex = ptr[i];
-        var lastIndex = ptr[i + 1];
+        const firstIndex = ptr[i];
+        const lastIndex = ptr[i + 1];
 
         // find the value at [i, i]
-        var Mii = 0;
-        for (var j = lastIndex - 1; j >= firstIndex; j--) {
-          var J = index[j];
+        let Mii = 0;
+        for (let j = lastIndex - 1; j >= firstIndex; j--) {
+          const J = index[j];
           // check row
           if (J === i) {
             Mii = values[j];
@@ -167,9 +157,9 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
           b[i] = divideScalar(b[i], Mii);
 
           // loop upper triangular
-          for (var _j2 = 0, _lastIndex = iIndices.length; _j2 < _lastIndex; _j2++) {
-            var _J = iIndices[_j2];
-            b[_J] = subtractScalar(b[_J], multiplyScalar(b[i], iValues[_j2]));
+          for (let j = 0, lastIndex = iIndices.length; j < lastIndex; j++) {
+            const J = iIndices[j];
+            b[J] = subtractScalar(b[J], multiplyScalar(b[i], iValues[j]));
           }
         } else if (!equalScalar(b[i], 0)) {
           // singular row, nonzero RHS
@@ -186,25 +176,21 @@ var createUsolveAll = exports.createUsolveAll = /* #__PURE__ */(0, _factory.fact
         } else if (k === 0) {
           // singular row, RHS is zero
 
-          var bNew = (0, _toConsumableArray2["default"])(b);
+          const bNew = [...b];
           bNew[i] = 1;
 
           // loop upper triangular
-          for (var _j3 = 0, _lastIndex2 = iIndices.length; _j3 < _lastIndex2; _j3++) {
-            var _J2 = iIndices[_j3];
-            bNew[_J2] = subtractScalar(bNew[_J2], iValues[_j3]);
+          for (let j = 0, lastIndex = iIndices.length; j < lastIndex; j++) {
+            const J = iIndices[j];
+            bNew[J] = subtractScalar(bNew[J], iValues[j]);
           }
           B.push(bNew);
         }
       }
     }
-    return B.map(function (x) {
-      return new DenseMatrix({
-        data: x.map(function (e) {
-          return [e];
-        }),
-        size: [rows, 1]
-      });
-    });
+    return B.map(x => new DenseMatrix({
+      data: x.map(e => [e]),
+      size: [rows, 1]
+    }));
   }
 });

package/lib/cjs/function/algebra/solver/utils/solveValidation.js

@@ -8,7 +8,9 @@ var _is = require("../../../../utils/is.js");
 var _array = require("../../../../utils/array.js");
 var _string = require("../../../../utils/string.js");
 function createSolveValidation(_ref) {
-  var DenseMatrix = _ref.DenseMatrix;
+  let {
+    DenseMatrix
+  } = _ref;
   /**
    * Validates matrix and column vector b for backward/forward substitution algorithms.
    *
@@ -19,30 +21,30 @@ function createSolveValidation(_ref) {
    * @return {DenseMatrix}        Dense column vector b
    */
   return function solveValidation(m, b, copy) {
-    var mSize = m.size();
+    const mSize = m.size();
     if (mSize.length !== 2) {
       throw new RangeError('Matrix must be two dimensional (size: ' + (0, _string.format)(mSize) + ')');
     }
-    var rows = mSize[0];
-    var columns = mSize[1];
+    const rows = mSize[0];
+    const columns = mSize[1];
     if (rows !== columns) {
       throw new RangeError('Matrix must be square (size: ' + (0, _string.format)(mSize) + ')');
     }
-    var data = [];
+    let data = [];
     if ((0, _is.isMatrix)(b)) {
-      var bSize = b.size();
-      var bdata = b._data;
+      const bSize = b.size();
+      const bdata = b._data;
 
       // 1-dim vector
       if (bSize.length === 1) {
         if (bSize[0] !== rows) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-        for (var i = 0; i < rows; i++) {
+        for (let i = 0; i < rows; i++) {
           data[i] = [bdata[i]];
         }
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1],
           datatype: b._datatype
         });
@@ -56,11 +58,11 @@ function createSolveValidation(_ref) {
         if ((0, _is.isDenseMatrix)(b)) {
           if (copy) {
             data = [];
-            for (var _i = 0; _i < rows; _i++) {
-              data[_i] = [bdata[_i][0]];
+            for (let i = 0; i < rows; i++) {
+              data[i] = [bdata[i][0]];
             }
             return new DenseMatrix({
-              data: data,
+              data,
               size: [rows, 1],
               datatype: b._datatype
             });
@@ -68,18 +70,18 @@ function createSolveValidation(_ref) {
           return b;
         }
         if ((0, _is.isSparseMatrix)(b)) {
-          for (var _i2 = 0; _i2 < rows; _i2++) {
-            data[_i2] = [0];
+          for (let i = 0; i < rows; i++) {
+            data[i] = [0];
           }
-          var values = b._values;
-          var index = b._index;
-          var ptr = b._ptr;
-          for (var k1 = ptr[1], k = ptr[0]; k < k1; k++) {
-            var _i3 = index[k];
-            data[_i3][0] = values[k];
+          const values = b._values;
+          const index = b._index;
+          const ptr = b._ptr;
+          for (let k1 = ptr[1], k = ptr[0]; k < k1; k++) {
+            const i = index[k];
+            data[i][0] = values[k];
           }
           return new DenseMatrix({
-            data: data,
+            data,
             size: [rows, 1],
             datatype: b._datatype
           });
@@ -88,16 +90,16 @@ function createSolveValidation(_ref) {
       throw new RangeError('Dimension mismatch. The right side has to be either 1- or 2-dimensional vector.');
     }
     if ((0, _is.isArray)(b)) {
-      var bsize = (0, _array.arraySize)(b);
+      const bsize = (0, _array.arraySize)(b);
       if (bsize.length === 1) {
         if (bsize[0] !== rows) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-        for (var _i4 = 0; _i4 < rows; _i4++) {
-          data[_i4] = [b[_i4]];
+        for (let i = 0; i < rows; i++) {
+          data[i] = [b[i]];
         }
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }
@@ -105,11 +107,11 @@ function createSolveValidation(_ref) {
         if (bsize[0] !== rows || bsize[1] !== 1) {
           throw new RangeError('Dimension mismatch. Matrix columns must match vector length.');
         }
-        for (var _i5 = 0; _i5 < rows; _i5++) {
-          data[_i5] = [b[_i5][0]];
+        for (let i = 0; i < rows; i++) {
+          data[i] = [b[i][0]];
         }
         return new DenseMatrix({
-          data: data,
+          data,
           size: [rows, 1]
         });
       }

package/lib/cjs/function/algebra/sparse/csAmd.js

@@ -12,12 +12,14 @@ var _csTdfs = require("./csTdfs.js");
 // SPDX-License-Identifier: LGPL-2.1+
 // https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source
 
-var name = 'csAmd';
-var dependencies = ['add', 'multiply', 'transpose'];
-var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, function (_ref) {
-  var add = _ref.add,
-    multiply = _ref.multiply,
-    transpose = _ref.transpose;
+const name = 'csAmd';
+const dependencies = ['add', 'multiply', 'transpose'];
+const createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(name, dependencies, _ref => {
+  let {
+    add,
+    multiply,
+    transpose
+  } = _ref;
   /**
    * Approximate minimum degree ordering. The minimum degree algorithm is a widely used
    * heuristic for finding a permutation P so that P*A*P' has fewer nonzeros in its factorization
@@ -33,54 +35,54 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
       return null;
     }
     // a matrix arrays
-    var asize = a._size;
+    const asize = a._size;
     // rows and columns
-    var m = asize[0];
-    var n = asize[1];
+    const m = asize[0];
+    const n = asize[1];
     // initialize vars
-    var lemax = 0;
+    let lemax = 0;
     // dense threshold
-    var dense = Math.max(16, 10 * Math.sqrt(n));
+    let dense = Math.max(16, 10 * Math.sqrt(n));
     dense = Math.min(n - 2, dense);
     // create target matrix C
-    var cm = _createTargetMatrix(order, a, m, n, dense);
+    const cm = _createTargetMatrix(order, a, m, n, dense);
     // drop diagonal entries
     (0, _csFkeep.csFkeep)(cm, _diag, null);
     // C matrix arrays
-    var cindex = cm._index;
-    var cptr = cm._ptr;
+    const cindex = cm._index;
+    const cptr = cm._ptr;
 
     // number of nonzero elements in C
-    var cnz = cptr[n];
+    let cnz = cptr[n];
 
     // allocate result (n+1)
-    var P = [];
+    const P = [];
 
     // create workspace (8 * (n + 1))
-    var W = [];
-    var len = 0; // first n + 1 entries
-    var nv = n + 1; // next n + 1 entries
-    var next = 2 * (n + 1); // next n + 1 entries
-    var head = 3 * (n + 1); // next n + 1 entries
-    var elen = 4 * (n + 1); // next n + 1 entries
-    var degree = 5 * (n + 1); // next n + 1 entries
-    var w = 6 * (n + 1); // next n + 1 entries
-    var hhead = 7 * (n + 1); // last n + 1 entries
+    const W = [];
+    const len = 0; // first n + 1 entries
+    const nv = n + 1; // next n + 1 entries
+    const next = 2 * (n + 1); // next n + 1 entries
+    const head = 3 * (n + 1); // next n + 1 entries
+    const elen = 4 * (n + 1); // next n + 1 entries
+    const degree = 5 * (n + 1); // next n + 1 entries
+    const w = 6 * (n + 1); // next n + 1 entries
+    const hhead = 7 * (n + 1); // last n + 1 entries
 
     // use P as workspace for last
-    var last = P;
+    const last = P;
 
     // initialize quotient graph
-    var mark = _initializeQuotientGraph(n, cptr, W, len, head, last, next, hhead, nv, w, elen, degree);
+    let mark = _initializeQuotientGraph(n, cptr, W, len, head, last, next, hhead, nv, w, elen, degree);
 
     // initialize degree lists
-    var nel = _initializeDegreeLists(n, cptr, W, degree, elen, w, dense, nv, head, last, next);
+    let nel = _initializeDegreeLists(n, cptr, W, degree, elen, w, dense, nv, head, last, next);
 
     // minimum degree node
-    var mindeg = 0;
+    let mindeg = 0;
 
     // vars
-    var i, j, k, k1, k2, e, pj, ln, nvi, pk, eln, p1, p2, pn, h, d;
+    let i, j, k, k1, k2, e, pj, ln, nvi, pk, eln, p1, p2, pn, h, d;
 
     // while (selecting pivots) do
     while (nel < n) {
@@ -94,22 +96,22 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
       // remove k from degree list
       W[head + mindeg] = W[next + k];
       // elenk = |Ek|
-      var elenk = W[elen + k];
+      const elenk = W[elen + k];
       // # of nodes k represents
-      var nvk = W[nv + k];
+      let nvk = W[nv + k];
       // W[nv + k] nodes of A eliminated
       nel += nvk;
 
       // Construct a new element. The new element Lk is constructed in place if |Ek| = 0. nv[i] is
       // negated for all nodes i in Lk to flag them as members of this set. Each node i is removed from the
       // degree lists. All elements e in Ek are absorved into element k.
-      var dk = 0;
+      let dk = 0;
       // flag k as in Lk
       W[nv + k] = -nvk;
-      var p = cptr[k];
+      let p = cptr[k];
       // do in place if W[elen + k] === 0
-      var pk1 = elenk === 0 ? p : cnz;
-      var pk2 = pk1;
+      const pk1 = elenk === 0 ? p : cnz;
+      let pk2 = pk1;
       for (k1 = 1; k1 <= elenk + 1; k1++) {
         if (k1 > elenk) {
           // search the nodes in k
@@ -180,7 +182,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
         }
         // W[nv + i] was negated
         nvi = -W[nv + i];
-        var wnvi = mark - nvi;
+        const wnvi = mark - nvi;
         // scan Ei
         for (p = cptr[i], p1 = cptr[i] + eln - 1; p <= p1; p++) {
           e = cindex[p];
@@ -211,7 +213,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
           // check e is an unabsorbed element
           if (W[w + e] !== 0) {
             // dext = |Le\Lk|
-            var dext = W[w + e] - mark;
+            const dext = W[w + e] - mark;
             if (dext > 0) {
               // sum up the set differences
               d += dext;
@@ -229,13 +231,13 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
         }
         // W[elen + i] = |Ei|
         W[elen + i] = pn - p1 + 1;
-        var p3 = pn;
-        var p4 = p1 + W[len + i];
+        const p3 = pn;
+        const p4 = p1 + W[len + i];
         // prune edges in Ai
         for (p = p2 + 1; p < p4; p++) {
           j = cindex[p];
           // check node j dead or in Lk
-          var nvj = W[nv + j];
+          const nvj = W[nv + j];
           if (nvj <= 0) {
             continue;
           }
@@ -304,10 +306,10 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
           for (p = cptr[i] + 1; p <= cptr[i] + ln - 1; p++) {
             W[w + cindex[p]] = mark;
           }
-          var jlast = i;
+          let jlast = i;
           // compare i with all j
           for (j = W[next + i]; j !== -1;) {
-            var ok = W[len + j] === ln && W[elen + j] === eln;
+            let ok = W[len + j] === ln && W[elen + j] === eln;
             for (p = cptr[j] + 1; ok && p <= cptr[j] + ln - 1; p++) {
               // compare i and j
               if (W[w + cindex[p]] !== mark) {
@@ -442,7 +444,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
    */
   function _createTargetMatrix(order, a, m, n, dense) {
     // compute A'
-    var at = transpose(a);
+    const at = transpose(a);
 
     // check order = 1, matrix must be square
     if (order === 1 && n === m) {
@@ -453,14 +455,14 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
     // check order = 2, drop dense columns from M'
     if (order === 2) {
       // transpose arrays
-      var tindex = at._index;
-      var tptr = at._ptr;
+      const tindex = at._index;
+      const tptr = at._ptr;
       // new column index
-      var p2 = 0;
+      let p2 = 0;
       // loop A' columns (rows)
-      for (var j = 0; j < m; j++) {
+      for (let j = 0; j < m; j++) {
         // column j of AT starts here
-        var p = tptr[j];
+        let p = tptr[j];
         // new column j starts here
         tptr[j] = p2;
         // skip dense col j
@@ -468,7 +470,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
           continue;
         }
         // map rows in column j of A
-        for (var p1 = tptr[j + 1]; p < p1; p++) {
+        for (const p1 = tptr[j + 1]; p < p1; p++) {
           tindex[p2++] = tindex[p];
         }
       }
@@ -494,12 +496,12 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
    */
   function _initializeQuotientGraph(n, cptr, W, len, head, last, next, hhead, nv, w, elen, degree) {
     // Initialize quotient graph
-    for (var k = 0; k < n; k++) {
+    for (let k = 0; k < n; k++) {
       W[len + k] = cptr[k + 1] - cptr[k];
     }
     W[len + n] = 0;
     // initialize workspace
-    for (var i = 0; i <= n; i++) {
+    for (let i = 0; i <= n; i++) {
       // degree list i is empty
       W[head + i] = -1;
       last[i] = -1;
@@ -516,7 +518,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
       W[degree + i] = W[len + i];
     }
     // clear w
-    var mark = _wclear(0, 0, W, w, n);
+    const mark = _wclear(0, 0, W, w, n);
     // n is a dead element
     W[elen + n] = -2;
     // n is a root of assembly tree
@@ -534,11 +536,11 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
    */
   function _initializeDegreeLists(n, cptr, W, degree, elen, w, dense, nv, head, last, next) {
     // result
-    var nel = 0;
+    let nel = 0;
     // loop columns
-    for (var i = 0; i < n; i++) {
+    for (let i = 0; i < n; i++) {
       // degree @ i
-      var d = W[degree + i];
+      const d = W[degree + i];
       // check node i is empty
       if (d === 0) {
         // element i is dead
@@ -556,7 +558,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
         cptr[i] = (0, _csFlip.csFlip)(n);
         W[nv + n]++;
       } else {
-        var h = W[head + d];
+        const h = W[head + d];
         if (h !== -1) {
           last[h] = i;
         }
@@ -569,7 +571,7 @@ var createCsAmd = exports.createCsAmd = /* #__PURE__ */(0, _factory.factory)(nam
   }
   function _wclear(mark, lemax, W, w, n) {
     if (mark < 2 || mark + lemax < 0) {
-      for (var k = 0; k < n; k++) {
+      for (let k = 0; k < n; k++) {
         if (W[w + k] !== 0) {
           W[w + k] = 1;
         }