@kitware/vtk.js 24.19.1 → 25.0.0

package/Common/Core/Math/index.js

@@ -1,4 +1,5 @@
 import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import seedrandom from 'seedrandom';
 import macro from '../../../macros.js';
 
@@ -22,25 +23,38 @@ function notImplemented(method) {
   return function () {
     return vtkErrorMacro("vtkMath::".concat(method, " - NOT IMPLEMENTED"));
   };
-}
+} // Swap rows for n by n matrix
 
-function vtkSwapVectors3(v1, v2) {
-  for (var i = 0; i < 3; i++) {
-    var tmp = v1[i];
-    v1[i] = v2[i];
-    v2[i] = tmp;
+
+function swapRowsMatrix_nxn(matrix, n, row1, row2) {
+  var tmp;
+
+  for (var i = 0; i < n; i++) {
+    tmp = matrix[row1 * n + i];
+    matrix[row1 * n + i] = matrix[row2 * n + i];
+    matrix[row2 * n + i] = tmp;
   }
-}
+} // Swap columns for n by n matrix
 
-function createArray() {
-  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
-  // faster than Array.from and/or while loop
-  return Array(size).fill(0);
+
+function swapColumnsMatrix_nxn(matrix, n, column1, column2) {
+  var tmp;
+
+  for (var i = 0; i < n; i++) {
+    tmp = matrix[i * n + column1];
+    matrix[i * n + column1] = matrix[i * n + column2];
+    matrix[i * n + column2] = tmp;
+  }
 } // ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 
+function createArray() {
+  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;
+  // faster than Array.from and/or while loop
+  return Array(size).fill(0);
+}
 var Pi = function Pi() {
   return Math.PI;
 };
@@ -208,11 +222,15 @@ function dot(x, y) {
   return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];
 }
 function outer(x, y, out_3x3) {
-  for (var i = 0; i < 3; i++) {
-    for (var j = 0; j < 3; j++) {
-      out_3x3[i][j] = x[i] * y[j];
-    }
-  }
+  out_3x3[0] = x[0] * y[0];
+  out_3x3[1] = x[0] * y[1];
+  out_3x3[2] = x[0] * y[2];
+  out_3x3[3] = x[1] * y[0];
+  out_3x3[4] = x[1] * y[1];
+  out_3x3[5] = x[1] * y[2];
+  out_3x3[6] = x[2] * y[0];
+  out_3x3[7] = x[2] * y[1];
+  out_3x3[8] = x[2] * y[2];
 }
 function cross(x, y, out) {
   var Zx = x[1] * y[2] - x[2] * y[1];
@@ -379,11 +397,10 @@ function gaussianWeight(mean, variance, position) {
   return Math.exp(-Math.pow(distanceFromMean, 2) / (2 * variance));
 }
 function outer2D(x, y, out_2x2) {
-  for (var i = 0; i < 2; i++) {
-    for (var j = 0; j < 2; j++) {
-      out_2x2[i][j] = x[i] * y[j];
-    }
-  }
+  out_2x2[0] = x[0] * y[0];
+  out_2x2[1] = x[0] * y[1];
+  out_2x2[2] = x[1] * y[0];
+  out_2x2[3] = x[1] * y[1];
 }
 function norm2D(x2D) {
   return Math.sqrt(x2D[0] * x2D[0] + x2D[1] * x2D[1]);
@@ -398,6 +415,44 @@ function normalize2D(x) {
 
   return den;
 }
+function rowsToMat4(row0, row1, row2, row3, mat) {
+  for (var i = 0; i < 4; i++) {
+    mat[i] = row0[i];
+    mat[4 + i] = row1[i];
+    mat[8 + i] = row2[i];
+    mat[12 + i] = row3[i];
+  }
+
+  return mat;
+}
+function columnsToMat4(column0, column1, column2, column3, mat) {
+  for (var i = 0; i < 4; i++) {
+    mat[4 * i] = column0[i];
+    mat[4 * i + 1] = column1[i];
+    mat[4 * i + 2] = column2[i];
+    mat[4 * i + 3] = column3[i];
+  }
+
+  return mat;
+}
+function rowsToMat3(row0, row1, row2, mat) {
+  for (var i = 0; i < 3; i++) {
+    mat[i] = row0[i];
+    mat[3 + i] = row1[i];
+    mat[6 + i] = row2[i];
+  }
+
+  return mat;
+}
+function columnsToMat3(column0, column1, column2, mat) {
+  for (var i = 0; i < 3; i++) {
+    mat[3 * i] = column0[i];
+    mat[3 * i + 1] = column1[i];
+    mat[3 * i + 2] = column2[i];
+  }
+
+  return mat;
+}
 function determinant2x2() {
   for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
     args[_key] = arguments[_key];
@@ -420,13 +475,13 @@ function LUFactor3x3(mat_3x3, index_3) {
   var scale = [0, 0, 0]; // Loop over rows to get implicit scaling information
 
   for (var i = 0; i < 3; i++) {
-    largest = Math.abs(mat_3x3[i][0]);
+    largest = Math.abs(mat_3x3[i * 3]);
 
-    if ((tmp = Math.abs(mat_3x3[i][1])) > largest) {
+    if ((tmp = Math.abs(mat_3x3[i * 3 + 1])) > largest) {
       largest = tmp;
     }
 
-    if ((tmp = Math.abs(mat_3x3[i][2])) > largest) {
+    if ((tmp = Math.abs(mat_3x3[i * 3 + 2])) > largest) {
       largest = tmp;
     }
 
@@ -435,43 +490,43 @@ function LUFactor3x3(mat_3x3, index_3) {
   // first column
 
 
-  largest = scale[0] * Math.abs(mat_3x3[0][0]);
+  largest = scale[0] * Math.abs(mat_3x3[0]);
   maxI = 0;
 
-  if ((tmp = scale[1] * Math.abs(mat_3x3[1][0])) >= largest) {
+  if ((tmp = scale[1] * Math.abs(mat_3x3[3])) >= largest) {
     largest = tmp;
     maxI = 1;
   }
 
-  if ((tmp = scale[2] * Math.abs(mat_3x3[2][0])) >= largest) {
+  if ((tmp = scale[2] * Math.abs(mat_3x3[6])) >= largest) {
     maxI = 2;
   }
 
   if (maxI !== 0) {
-    vtkSwapVectors3(mat_3x3[maxI], mat_3x3[0]);
+    swapRowsMatrix_nxn(mat_3x3, 3, maxI, 0);
     scale[maxI] = scale[0];
   }
 
   index_3[0] = maxI;
-  mat_3x3[1][0] /= mat_3x3[0][0];
-  mat_3x3[2][0] /= mat_3x3[0][0]; // second column
+  mat_3x3[3] /= mat_3x3[0];
+  mat_3x3[6] /= mat_3x3[0]; // second column
 
-  mat_3x3[1][1] -= mat_3x3[1][0] * mat_3x3[0][1];
-  mat_3x3[2][1] -= mat_3x3[2][0] * mat_3x3[0][1];
-  largest = scale[1] * Math.abs(mat_3x3[1][1]);
+  mat_3x3[4] -= mat_3x3[3] * mat_3x3[1];
+  mat_3x3[7] -= mat_3x3[6] * mat_3x3[1];
+  largest = scale[1] * Math.abs(mat_3x3[4]);
   maxI = 1;
 
-  if ((tmp = scale[2] * Math.abs(mat_3x3[2][1])) >= largest) {
+  if ((tmp = scale[2] * Math.abs(mat_3x3[7])) >= largest) {
     maxI = 2;
-    vtkSwapVectors3(mat_3x3[2], mat_3x3[1]);
+    swapRowsMatrix_nxn(mat_3x3, 3, 1, 2);
     scale[2] = scale[1];
   }
 
   index_3[1] = maxI;
-  mat_3x3[2][1] /= mat_3x3[1][1]; // third column
+  mat_3x3[7] /= mat_3x3[4]; // third column
 
-  mat_3x3[1][2] -= mat_3x3[1][0] * mat_3x3[0][2];
-  mat_3x3[2][2] -= mat_3x3[2][0] * mat_3x3[0][2] + mat_3x3[2][1] * mat_3x3[1][2];
+  mat_3x3[5] -= mat_3x3[3] * mat_3x3[2];
+  mat_3x3[8] -= mat_3x3[6] * mat_3x3[2] + mat_3x3[7] * mat_3x3[5];
   index_3[2] = 2;
 }
 function LUSolve3x3(mat_3x3, index_3, x_3) {
@@ -481,25 +536,25 @@ function LUSolve3x3(mat_3x3, index_3, x_3) {
   x_3[0] = sum;
   sum = x_3[index_3[1]];
   x_3[index_3[1]] = x_3[1];
-  x_3[1] = sum - mat_3x3[1][0] * x_3[0];
+  x_3[1] = sum - mat_3x3[3] * x_3[0];
   sum = x_3[index_3[2]];
   x_3[index_3[2]] = x_3[2];
-  x_3[2] = sum - mat_3x3[2][0] * x_3[0] - mat_3x3[2][1] * x_3[1]; // back substitution
+  x_3[2] = sum - mat_3x3[6] * x_3[0] - mat_3x3[7] * x_3[1]; // back substitution
 
-  x_3[2] /= mat_3x3[2][2];
-  x_3[1] = (x_3[1] - mat_3x3[1][2] * x_3[2]) / mat_3x3[1][1];
-  x_3[0] = (x_3[0] - mat_3x3[0][1] * x_3[1] - mat_3x3[0][2] * x_3[2]) / mat_3x3[0][0];
+  x_3[2] /= mat_3x3[8];
+  x_3[1] = (x_3[1] - mat_3x3[5] * x_3[2]) / mat_3x3[4];
+  x_3[0] = (x_3[0] - mat_3x3[1] * x_3[1] - mat_3x3[2] * x_3[2]) / mat_3x3[0];
 }
 function linearSolve3x3(mat_3x3, x_3, y_3) {
-  var a1 = mat_3x3[0][0];
-  var b1 = mat_3x3[0][1];
-  var c1 = mat_3x3[0][2];
-  var a2 = mat_3x3[1][0];
-  var b2 = mat_3x3[1][1];
-  var c2 = mat_3x3[1][2];
-  var a3 = mat_3x3[2][0];
-  var b3 = mat_3x3[2][1];
-  var c3 = mat_3x3[2][2]; // Compute the adjoint
+  var a1 = mat_3x3[0];
+  var b1 = mat_3x3[1];
+  var c1 = mat_3x3[2];
+  var a2 = mat_3x3[3];
+  var b2 = mat_3x3[4];
+  var c2 = mat_3x3[5];
+  var a3 = mat_3x3[6];
+  var b3 = mat_3x3[7];
+  var c3 = mat_3x3[8]; // Compute the adjoint
 
   var d1 = +determinant2x2(b2, b3, c2, c3);
   var d2 = -determinant2x2(a2, a3, c2, c3);
@@ -522,72 +577,75 @@ function linearSolve3x3(mat_3x3, x_3, y_3) {
   y_3[2] = v3 / det;
 }
 function multiply3x3_vect3(mat_3x3, in_3, out_3) {
-  var x = mat_3x3[0][0] * in_3[0] + mat_3x3[0][1] * in_3[1] + mat_3x3[0][2] * in_3[2];
-  var y = mat_3x3[1][0] * in_3[0] + mat_3x3[1][1] * in_3[1] + mat_3x3[1][2] * in_3[2];
-  var z = mat_3x3[2][0] * in_3[0] + mat_3x3[2][1] * in_3[1] + mat_3x3[2][2] * in_3[2];
+  var x = mat_3x3[0] * in_3[0] + mat_3x3[1] * in_3[1] + mat_3x3[2] * in_3[2];
+  var y = mat_3x3[3] * in_3[0] + mat_3x3[4] * in_3[1] + mat_3x3[5] * in_3[2];
+  var z = mat_3x3[6] * in_3[0] + mat_3x3[7] * in_3[1] + mat_3x3[8] * in_3[2];
   out_3[0] = x;
   out_3[1] = y;
   out_3[2] = z;
 }
 function multiply3x3_mat3(a_3x3, b_3x3, out_3x3) {
-  var tmp = [[0, 0, 0], [0, 0, 0], [0, 0, 0]];
+  var copyA = _toConsumableArray(a_3x3);
 
-  for (var i = 0; i < 3; i++) {
-    tmp[0][i] = a_3x3[0][0] * b_3x3[0][i] + a_3x3[0][1] * b_3x3[1][i] + a_3x3[0][2] * b_3x3[2][i];
-    tmp[1][i] = a_3x3[1][0] * b_3x3[0][i] + a_3x3[1][1] * b_3x3[1][i] + a_3x3[1][2] * b_3x3[2][i];
-    tmp[2][i] = a_3x3[2][0] * b_3x3[0][i] + a_3x3[2][1] * b_3x3[1][i] + a_3x3[2][2] * b_3x3[2][i];
-  }
+  var copyB = _toConsumableArray(b_3x3);
 
-  for (var j = 0; j < 3; j++) {
-    out_3x3[j][0] = tmp[j][0];
-    out_3x3[j][1] = tmp[j][1];
-    out_3x3[j][2] = tmp[j][2];
+  for (var i = 0; i < 3; i++) {
+    out_3x3[i] = copyA[0] * copyB[i] + copyA[1] * copyB[i + 3] + copyA[2] * copyB[i + 6];
+    out_3x3[i + 3] = copyA[3] * copyB[i] + copyA[4] * copyB[i + 3] + copyA[5] * copyB[i + 6];
+    out_3x3[i + 6] = copyA[6] * copyB[i] + copyA[7] * copyB[i + 3] + copyA[8] * copyB[i + 6];
   }
 }
 function multiplyMatrix(a, b, rowA, colA, rowB, colB, out_rowXcol) {
   // we need colA == rowB
   if (colA !== rowB) {
     vtkErrorMacro('Number of columns of A must match number of rows of B.');
-  } // output matrix is rowA*colB
+  } // If a or b is used to store the result, copying them is required
+
+
+  var copyA = _toConsumableArray(a);
+
+  var copyB = _toConsumableArray(b); // output matrix is rowA*colB
   // output row
 
 
   for (var i = 0; i < rowA; i++) {
     // output col
     for (var j = 0; j < colB; j++) {
-      out_rowXcol[i][j] = 0; // sum for this point
+      out_rowXcol[i * colB + j] = 0; // sum for this point
 
       for (var k = 0; k < colA; k++) {
-        out_rowXcol[i][j] += a[i][k] * b[k][j];
+        out_rowXcol[i * colB + j] += copyA[i * colA + k] * copyB[j + colB * k];
       }
     }
   }
 }
 function transpose3x3(in_3x3, outT_3x3) {
-  var tmp;
-  tmp = in_3x3[1][0];
-  outT_3x3[1][0] = in_3x3[0][1];
-  outT_3x3[0][1] = tmp;
-  tmp = in_3x3[2][0];
-  outT_3x3[2][0] = in_3x3[0][2];
-  outT_3x3[0][2] = tmp;
-  tmp = in_3x3[2][1];
-  outT_3x3[2][1] = in_3x3[1][2];
-  outT_3x3[1][2] = tmp;
-  outT_3x3[0][0] = in_3x3[0][0];
-  outT_3x3[1][1] = in_3x3[1][1];
-  outT_3x3[2][2] = in_3x3[2][2];
+  var tmp; // off-diagonal elements
+
+  tmp = in_3x3[3];
+  outT_3x3[3] = in_3x3[1];
+  outT_3x3[1] = tmp;
+  tmp = in_3x3[6];
+  outT_3x3[6] = in_3x3[2];
+  outT_3x3[2] = tmp;
+  tmp = in_3x3[7];
+  outT_3x3[7] = in_3x3[5];
+  outT_3x3[5] = tmp; // on-diagonal elements
+
+  outT_3x3[0] = in_3x3[0];
+  outT_3x3[4] = in_3x3[4];
+  outT_3x3[8] = in_3x3[8];
 }
 function invert3x3(in_3x3, outI_3x3) {
-  var a1 = in_3x3[0][0];
-  var b1 = in_3x3[0][1];
-  var c1 = in_3x3[0][2];
-  var a2 = in_3x3[1][0];
-  var b2 = in_3x3[1][1];
-  var c2 = in_3x3[1][2];
-  var a3 = in_3x3[2][0];
-  var b3 = in_3x3[2][1];
-  var c3 = in_3x3[2][2]; // Compute the adjoint
+  var a1 = in_3x3[0];
+  var b1 = in_3x3[1];
+  var c1 = in_3x3[2];
+  var a2 = in_3x3[3];
+  var b2 = in_3x3[4];
+  var c2 = in_3x3[5];
+  var a3 = in_3x3[6];
+  var b3 = in_3x3[7];
+  var c3 = in_3x3[8]; // Compute the adjoint
 
   var d1 = +determinant2x2(b2, b3, c2, c3);
   var d2 = -determinant2x2(a2, a3, c2, c3);
@@ -600,24 +658,41 @@ function invert3x3(in_3x3, outI_3x3) {
   var f3 = +determinant2x2(a1, a2, b1, b2); // Divide by the determinant
 
   var det = a1 * d1 + b1 * d2 + c1 * d3;
-  outI_3x3[0][0] = d1 / det;
-  outI_3x3[1][0] = d2 / det;
-  outI_3x3[2][0] = d3 / det;
-  outI_3x3[0][1] = e1 / det;
-  outI_3x3[1][1] = e2 / det;
-  outI_3x3[2][1] = e3 / det;
-  outI_3x3[0][2] = f1 / det;
-  outI_3x3[1][2] = f2 / det;
-  outI_3x3[2][2] = f3 / det;
+
+  if (det === 0) {
+    vtkWarningMacro('Matrix has 0 determinant');
+  }
+
+  outI_3x3[0] = d1 / det;
+  outI_3x3[3] = d2 / det;
+  outI_3x3[6] = d3 / det;
+  outI_3x3[1] = e1 / det;
+  outI_3x3[4] = e2 / det;
+  outI_3x3[7] = e3 / det;
+  outI_3x3[2] = f1 / det;
+  outI_3x3[5] = f2 / det;
+  outI_3x3[8] = f3 / det;
+}
+function determinant3x3(mat_3x3) {
+  return mat_3x3[0] * mat_3x3[4] * mat_3x3[8] + mat_3x3[3] * mat_3x3[7] * mat_3x3[2] + mat_3x3[6] * mat_3x3[1] * mat_3x3[5] - mat_3x3[0] * mat_3x3[7] * mat_3x3[5] - mat_3x3[3] * mat_3x3[1] * mat_3x3[8] - mat_3x3[6] * mat_3x3[4] * mat_3x3[2];
 }
 function identity3x3(mat_3x3) {
   for (var i = 0; i < 3; i++) {
-    mat_3x3[i][0] = mat_3x3[i][1] = mat_3x3[i][2] = 0;
-    mat_3x3[i][i] = 1;
+    /* eslint-disable-next-line no-multi-assign */
+    mat_3x3[i * 3] = mat_3x3[i * 3 + 1] = mat_3x3[i * 3 + 2] = 0;
+    mat_3x3[i * 3 + i] = 1;
   }
 }
-function determinant3x3(mat_3x3) {
-  return mat_3x3[0][0] * mat_3x3[1][1] * mat_3x3[2][2] + mat_3x3[1][0] * mat_3x3[2][1] * mat_3x3[0][2] + mat_3x3[2][0] * mat_3x3[0][1] * mat_3x3[1][2] - mat_3x3[0][0] * mat_3x3[2][1] * mat_3x3[1][2] - mat_3x3[1][0] * mat_3x3[0][1] * mat_3x3[2][2] - mat_3x3[2][0] * mat_3x3[1][1] * mat_3x3[0][2];
+function identity(n, mat) {
+  for (var i = 0; i < n; i++) {
+    for (var j = 0; j < n; j++) {
+      mat[i * n + j] = 0;
+    }
+
+    mat[i * n + i] = 1;
+  }
+
+  return mat;
 }
 function quaternionToMatrix3x3(quat_4, mat_3x3) {
   var ww = quat_4[0] * quat_4[0];
@@ -635,15 +710,15 @@ function quaternionToMatrix3x3(quat_4, mat_3x3) {
   var f = 1 / (ww + rr);
   var s = (ww - rr) * f;
   f *= 2;
-  mat_3x3[0][0] = xx * f + s;
-  mat_3x3[1][0] = (xy + wz) * f;
-  mat_3x3[2][0] = (xz - wy) * f;
-  mat_3x3[0][1] = (xy - wz) * f;
-  mat_3x3[1][1] = yy * f + s;
-  mat_3x3[2][1] = (yz + wx) * f;
-  mat_3x3[0][2] = (xz + wy) * f;
-  mat_3x3[1][2] = (yz - wx) * f;
-  mat_3x3[2][2] = zz * f + s;
+  mat_3x3[0] = xx * f + s;
+  mat_3x3[3] = (xy + wz) * f;
+  mat_3x3[6] = (xz - wy) * f;
+  mat_3x3[1] = (xy - wz) * f;
+  mat_3x3[4] = yy * f + s;
+  mat_3x3[7] = (yz + wx) * f;
+  mat_3x3[2] = (xz + wy) * f;
+  mat_3x3[5] = (yz - wx) * f;
+  mat_3x3[8] = zz * f + s;
 }
 /**
  * Returns true if elements of both arrays are equals.
@@ -710,24 +785,18 @@ function jacobiN(a, n, w, v) {
   var b = createArray(n);
   var z = createArray(n);
 
-  var vtkROTATE = function vtkROTATE(aa, ii, jj, kk, ll) {
-    g = aa[ii][jj];
-    h = aa[kk][ll];
-    aa[ii][jj] = g - s * (h + g * tau);
-    aa[kk][ll] = h + s * (g - h * tau);
+  var vtkROTATE = function vtkROTATE(aa, ii, jj) {
+    g = aa[ii];
+    h = aa[jj];
+    aa[ii] = g - s * (h + g * tau);
+    aa[jj] = h + s * (g - h * tau);
   }; // initialize
 
 
-  for (ip = 0; ip < n; ip++) {
-    for (iq = 0; iq < n; iq++) {
-      v[ip][iq] = 0.0;
-    }
-
-    v[ip][ip] = 1.0;
-  }
+  identity(n, v);
 
   for (ip = 0; ip < n; ip++) {
-    b[ip] = w[ip] = a[ip][ip];
+    b[ip] = w[ip] = a[ip + ip * n];
     z[ip] = 0.0;
   } // begin rotation sequence
 
@@ -737,7 +806,7 @@ function jacobiN(a, n, w, v) {
 
     for (ip = 0; ip < n - 1; ip++) {
       for (iq = ip + 1; iq < n; iq++) {
-        sm += Math.abs(a[ip][iq]);
+        sm += Math.abs(a[ip * n + iq]);
       }
     }
 
@@ -754,17 +823,17 @@ function jacobiN(a, n, w, v) {
 
     for (ip = 0; ip < n - 1; ip++) {
       for (iq = ip + 1; iq < n; iq++) {
-        g = 100.0 * Math.abs(a[ip][iq]); // after 4 sweeps
+        g = 100.0 * Math.abs(a[ip * n + iq]); // after 4 sweeps
 
         if (i > 3 && Math.abs(w[ip]) + g === Math.abs(w[ip]) && Math.abs(w[iq]) + g === Math.abs(w[iq])) {
-          a[ip][iq] = 0.0;
-        } else if (Math.abs(a[ip][iq]) > tresh) {
+          a[ip * n + iq] = 0.0;
+        } else if (Math.abs(a[ip * n + iq]) > tresh) {
           h = w[iq] - w[ip];
 
           if (Math.abs(h) + g === Math.abs(h)) {
-            t = a[ip][iq] / h;
+            t = a[ip * n + iq] / h;
           } else {
-            theta = 0.5 * h / a[ip][iq];
+            theta = 0.5 * h / a[ip * n + iq];
             t = 1.0 / (Math.abs(theta) + Math.sqrt(1.0 + theta * theta));
 
             if (theta < 0.0) {
@@ -775,29 +844,29 @@ function jacobiN(a, n, w, v) {
           c = 1.0 / Math.sqrt(1 + t * t);
           s = t * c;
           tau = s / (1.0 + c);
-          h = t * a[ip][iq];
+          h = t * a[ip * n + iq];
           z[ip] -= h;
           z[iq] += h;
           w[ip] -= h;
           w[iq] += h;
-          a[ip][iq] = 0.0; // ip already shifted left by 1 unit
+          a[ip * n + iq] = 0.0; // ip already shifted left by 1 unit
 
           for (j = 0; j <= ip - 1; j++) {
-            vtkROTATE(a, j, ip, j, iq);
+            vtkROTATE(a, j * n + ip, j * n + iq);
           } // ip and iq already shifted left by 1 unit
 
 
           for (j = ip + 1; j <= iq - 1; j++) {
-            vtkROTATE(a, ip, j, j, iq);
+            vtkROTATE(a, ip * n + j, j * n + iq);
           } // iq already shifted left by 1 unit
 
 
           for (j = iq + 1; j < n; j++) {
-            vtkROTATE(a, ip, j, iq, j);
+            vtkROTATE(a, ip * n + j, iq * n + j);
           }
 
           for (j = 0; j < n; j++) {
-            vtkROTATE(v, j, ip, j, iq);
+            vtkROTATE(v, j * n + ip, j * n + iq);
           }
         }
       }
@@ -834,12 +903,7 @@ function jacobiN(a, n, w, v) {
     if (k !== j) {
       w[k] = w[j];
       w[j] = tmp;
-
-      for (i = 0; i < n; i++) {
-        tmp = v[i][j];
-        v[i][j] = v[i][k];
-        v[i][k] = tmp;
-      }
+      swapColumnsMatrix_nxn(v, n, j, k);
     }
   } // ensure eigenvector consistency (i.e., Jacobi can compute vectors that
   // are negative of one another (.707,.707,0) and (-.707,-.707,0). This can
@@ -849,55 +913,47 @@ function jacobiN(a, n, w, v) {
 
   var ceil_half_n = (n >> 1) + (n & 1);
 
-  for (j = 0; j < n; j++) {
-    for (numPos = 0, i = 0; i < n; i++) {
-      if (v[i][j] >= 0.0) {
-        numPos++;
-      }
-    } //    if ( numPos < ceil(double(n)/double(2.0)) )
+  for (numPos = 0, i = 0; i < n * n; i++) {
+    if (v[i] >= 0.0) {
+      numPos++;
+    }
+  } //    if ( numPos < ceil(double(n)/double(2.0)) )
 
 
-    if (numPos < ceil_half_n) {
-      for (i = 0; i < n; i++) {
-        v[i][j] *= -1.0;
-      }
+  if (numPos < ceil_half_n) {
+    for (i = 0; i < n; i++) {
+      v[i * n + j] *= -1.0;
     }
   }
 
   return 1;
 }
 function matrix3x3ToQuaternion(mat_3x3, quat_4) {
-  var tmp = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]; // on-diagonal elements
-
-  tmp[0][0] = mat_3x3[0][0] + mat_3x3[1][1] + mat_3x3[2][2];
-  tmp[1][1] = mat_3x3[0][0] - mat_3x3[1][1] - mat_3x3[2][2];
-  tmp[2][2] = -mat_3x3[0][0] + mat_3x3[1][1] - mat_3x3[2][2];
-  tmp[3][3] = -mat_3x3[0][0] - mat_3x3[1][1] + mat_3x3[2][2]; // off-diagonal elements
-
-  tmp[0][1] = tmp[1][0] = mat_3x3[2][1] - mat_3x3[1][2];
-  tmp[0][2] = tmp[2][0] = mat_3x3[0][2] - mat_3x3[2][0];
-  tmp[0][3] = tmp[3][0] = mat_3x3[1][0] - mat_3x3[0][1];
-  tmp[1][2] = tmp[2][1] = mat_3x3[1][0] + mat_3x3[0][1];
-  tmp[1][3] = tmp[3][1] = mat_3x3[0][2] + mat_3x3[2][0];
-  tmp[2][3] = tmp[3][2] = mat_3x3[2][1] + mat_3x3[1][2];
-  var eigenvectors = [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]];
+  var tmp = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; // on-diagonal elements
+
+  tmp[0] = mat_3x3[0] + mat_3x3[4] + mat_3x3[8];
+  tmp[5] = mat_3x3[0] - mat_3x3[4] - mat_3x3[8];
+  tmp[10] = -mat_3x3[0] + mat_3x3[4] - mat_3x3[8];
+  tmp[15] = -mat_3x3[0] - mat_3x3[4] + mat_3x3[8]; // off-diagonal elements
+
+  tmp[1] = tmp[4] = mat_3x3[7] - mat_3x3[5];
+  tmp[2] = tmp[8] = mat_3x3[2] - mat_3x3[6];
+  tmp[3] = tmp[12] = mat_3x3[3] - mat_3x3[1];
+  tmp[6] = tmp[9] = mat_3x3[3] + mat_3x3[1];
+  tmp[7] = tmp[13] = mat_3x3[2] + mat_3x3[6];
+  tmp[11] = tmp[14] = mat_3x3[7] + mat_3x3[5];
+  var eigenvectors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
   var eigenvalues = [0, 0, 0, 0]; // convert into format that JacobiN can use,
   // then use Jacobi to find eigenvalues and eigenvectors
+  // tmp is copied because jacobiN may modify it
 
-  var NTemp = [0, 0, 0, 0];
-  var eigenvectorsTemp = [0, 0, 0, 0];
-
-  for (var i = 0; i < 4; i++) {
-    NTemp[i] = tmp[i];
-    eigenvectorsTemp[i] = eigenvectors[i];
-  }
-
-  jacobiN(NTemp, 4, eigenvalues, eigenvectorsTemp); // the first eigenvector is the one we want
+  var NTemp = [].concat(tmp);
+  jacobiN(NTemp, 4, eigenvalues, eigenvectors); // the first eigenvector is the one we want
 
-  quat_4[0] = eigenvectors[0][0];
-  quat_4[1] = eigenvectors[1][0];
-  quat_4[2] = eigenvectors[2][0];
-  quat_4[3] = eigenvectors[3][0];
+  quat_4[0] = eigenvectors[0];
+  quat_4[1] = eigenvectors[4];
+  quat_4[2] = eigenvectors[8];
+  quat_4[3] = eigenvectors[12];
 }
 function multiplyQuaternion(quat_1, quat_2, quat_out) {
   var ww = quat_1[0] * quat_2[0];
@@ -923,10 +979,8 @@ function multiplyQuaternion(quat_1, quat_2, quat_out) {
 }
 function orthogonalize3x3(a_3x3, out_3x3) {
   // copy the matrix
-  for (var i = 0; i < 3; i++) {
-    out_3x3[0][i] = a_3x3[0][i];
-    out_3x3[1][i] = a_3x3[1][i];
-    out_3x3[2][i] = a_3x3[2][i];
+  for (var i = 0; i < 9; i++) {
+    out_3x3[i] = a_3x3[i];
   } // Pivot the matrix to improve accuracy
 
 
@@ -935,11 +989,11 @@ function orthogonalize3x3(a_3x3, out_3x3) {
   var largest; // Loop over rows to get implicit scaling information
 
   for (var _i = 0; _i < 3; _i++) {
-    var _x = Math.abs(out_3x3[_i][0]);
+    var _x = Math.abs(out_3x3[_i * 3]);
 
-    var _x2 = Math.abs(out_3x3[_i][1]);
+    var _x2 = Math.abs(out_3x3[_i * 3 + 1]);
 
-    var _x3 = Math.abs(out_3x3[_i][2]);
+    var _x3 = Math.abs(out_3x3[_i * 3 + 2]);
 
     largest = _x2 > _x ? _x2 : _x;
     largest = _x3 > largest ? _x3 : largest;
@@ -951,9 +1005,9 @@ function orthogonalize3x3(a_3x3, out_3x3) {
   } // first column
 
 
-  var x1 = Math.abs(out_3x3[0][0]) * scale[0];
-  var x2 = Math.abs(out_3x3[1][0]) * scale[1];
-  var x3 = Math.abs(out_3x3[2][0]) * scale[2];
+  var x1 = Math.abs(out_3x3[0]) * scale[0];
+  var x2 = Math.abs(out_3x3[3]) * scale[1];
+  var x3 = Math.abs(out_3x3[6]) * scale[2];
   index[0] = 0;
   largest = x1;
 
@@ -967,19 +1021,21 @@ function orthogonalize3x3(a_3x3, out_3x3) {
   }
 
   if (index[0] !== 0) {
-    vtkSwapVectors3(out_3x3[index[0]], out_3x3[0]);
+    // swap vectors
+    swapColumnsMatrix_nxn(out_3x3, 3, index[0], 0);
     scale[index[0]] = scale[0];
   } // second column
 
 
-  var y2 = Math.abs(out_3x3[1][1]) * scale[1];
-  var y3 = Math.abs(out_3x3[2][1]) * scale[2];
+  var y2 = Math.abs(out_3x3[4]) * scale[1];
+  var y3 = Math.abs(out_3x3[7]) * scale[2];
   index[1] = 1;
   largest = y2;
 
   if (y3 >= largest) {
-    index[1] = 2;
-    vtkSwapVectors3(out_3x3[2], out_3x3[1]);
+    index[1] = 2; // swap vectors
+
+    swapColumnsMatrix_nxn(out_3x3, 3, 1, 2);
   } // third column
 
 
@@ -992,10 +1048,8 @@ function orthogonalize3x3(a_3x3, out_3x3) {
   if (determinant3x3(out_3x3) < 0) {
     flip = 1;
 
-    for (var _i2 = 0; _i2 < 3; _i2++) {
-      out_3x3[0][_i2] = -out_3x3[0][_i2];
-      out_3x3[1][_i2] = -out_3x3[1][_i2];
-      out_3x3[2][_i2] = -out_3x3[2][_i2];
+    for (var _i2 = 0; _i2 < 9; _i2++) {
+      out_3x3[_i2] = -out_3x3[_i2];
     }
   } // Do orthogonalization using a quaternion intermediate
   // (this, essentially, does the orthogonalization via
@@ -1008,20 +1062,18 @@ function orthogonalize3x3(a_3x3, out_3x3) {
   quaternionToMatrix3x3(quat, out_3x3); // Put the flip back into the orthogonalized matrix.
 
   if (flip) {
-    for (var _i3 = 0; _i3 < 3; _i3++) {
-      out_3x3[0][_i3] = -out_3x3[0][_i3];
-      out_3x3[1][_i3] = -out_3x3[1][_i3];
-      out_3x3[2][_i3] = -out_3x3[2][_i3];
+    for (var _i3 = 0; _i3 < 9; _i3++) {
+      out_3x3[_i3] = -out_3x3[_i3];
     }
   } // Undo the pivoting
 
 
   if (index[1] !== 1) {
-    vtkSwapVectors3(out_3x3[index[1]], out_3x3[1]);
+    swapColumnsMatrix_nxn(out_3x3, 3, index[1], 1);
   }
 
   if (index[0] !== 0) {
-    vtkSwapVectors3(out_3x3[index[0]], out_3x3[0]);
+    swapColumnsMatrix_nxn(out_3x3, 3, index[0], 0);
   }
 }
 function diagonalize3x3(a_3x3, w_3, v_3x3) {
@@ -1030,22 +1082,12 @@ function diagonalize3x3(a_3x3, w_3, v_3x3) {
   var k;
   var maxI;
   var tmp;
-  var maxVal; // do the matrix[3][3] to **matrix conversion for Jacobi
-
-  var C = [createArray(3), createArray(3), createArray(3)];
-  var ATemp = createArray(3);
-  var VTemp = createArray(3);
+  var maxVal; // a is copied because jacobiN may modify it
 
-  for (i = 0; i < 3; i++) {
-    C[i][0] = a_3x3[i][0];
-    C[i][1] = a_3x3[i][1];
-    C[i][2] = a_3x3[i][2];
-    ATemp[i] = C[i];
-    VTemp[i] = v_3x3[i];
-  } // diagonalize using Jacobi
+  var copyA = _toConsumableArray(a_3x3); // diagonalize using Jacobi
 
 
-  jacobiN(ATemp, 3, w_3, VTemp); // if all the eigenvalues are the same, return identity matrix
+  jacobiN(copyA, 3, w_3, v_3x3); // if all the eigenvalues are the same, return identity matrix
 
   if (w_3[0] === w_3[1] && w_3[0] === w_3[2]) {
     identity3x3(v_3x3);
@@ -1060,11 +1102,11 @@ function diagonalize3x3(a_3x3, w_3, v_3x3) {
     // two eigenvalues are the same
     if (w_3[(i + 1) % 3] === w_3[(i + 2) % 3]) {
       // find maximum element of the independent eigenvector
-      maxVal = Math.abs(v_3x3[i][0]);
+      maxVal = Math.abs(v_3x3[i * 3]);
       maxI = 0;
 
       for (j = 1; j < 3; j++) {
-        if (maxVal < (tmp = Math.abs(v_3x3[i][j]))) {
+        if (maxVal < (tmp = Math.abs(v_3x3[i * 3 + j]))) {
           maxVal = tmp;
           maxI = j;
         }
@@ -1075,26 +1117,32 @@ function diagonalize3x3(a_3x3, w_3, v_3x3) {
         tmp = w_3[maxI];
         w_3[maxI] = w_3[i];
         w_3[i] = tmp;
-        vtkSwapVectors3(v_3x3[i], v_3x3[maxI]);
+        swapRowsMatrix_nxn(v_3x3, 3, i, maxI);
       } // maximum element of eigenvector should be positive
 
 
-      if (v_3x3[maxI][maxI] < 0) {
-        v_3x3[maxI][0] = -v_3x3[maxI][0];
-        v_3x3[maxI][1] = -v_3x3[maxI][1];
-        v_3x3[maxI][2] = -v_3x3[maxI][2];
+      if (v_3x3[maxI * 3 + maxI] < 0) {
+        v_3x3[maxI * 3] = -v_3x3[maxI * 3];
+        v_3x3[maxI * 3 + 1] = -v_3x3[maxI * 3 + 1];
+        v_3x3[maxI * 3 + 2] = -v_3x3[maxI * 3 + 2];
       } // re-orthogonalize the other two eigenvectors
 
 
       j = (maxI + 1) % 3;
       k = (maxI + 2) % 3;
-      v_3x3[j][0] = 0.0;
-      v_3x3[j][1] = 0.0;
-      v_3x3[j][2] = 0.0;
-      v_3x3[j][j] = 1.0;
-      cross(v_3x3[maxI], v_3x3[j], v_3x3[k]);
-      normalize(v_3x3[k]);
-      cross(v_3x3[k], v_3x3[maxI], v_3x3[j]); // transpose vectors back to columns
+      v_3x3[j * 3] = 0.0;
+      v_3x3[j * 3 + 1] = 0.0;
+      v_3x3[j * 3 + 2] = 0.0;
+      v_3x3[j * 3 + j] = 1.0;
+      var vectTmp1 = cross([v_3x3[maxI * 3], v_3x3[maxI * 3 + 1], v_3x3[maxI * 3 + 2]], [v_3x3[j * 3], v_3x3[j * 3 + 1], v_3x3[j * 3 + 2]], []);
+      normalize(vectTmp1);
+      var vectTmp2 = cross(vectTmp1, [v_3x3[maxI * 3], v_3x3[maxI * 3 + 1], v_3x3[maxI * 3 + 2]], []);
+
+      for (var t = 0; t < 3; t++) {
+        v_3x3[k * 3 + t] = vectTmp1[t];
+        v_3x3[j * 3 + t] = vectTmp2[t];
+      } // transpose vectors back to columns
+
 
       transpose3x3(v_3x3, v_3x3);
       return;
@@ -1105,11 +1153,11 @@ function diagonalize3x3(a_3x3, w_3, v_3x3) {
   // the first vector
 
 
-  maxVal = Math.abs(v_3x3[0][0]);
+  maxVal = Math.abs(v_3x3[0]);
   maxI = 0;
 
   for (i = 1; i < 3; i++) {
-    if (maxVal < (tmp = Math.abs(v_3x3[i][0]))) {
+    if (maxVal < (tmp = Math.abs(v_3x3[i * 3]))) {
       maxVal = tmp;
       maxI = i;
     }
@@ -1117,57 +1165,50 @@ function diagonalize3x3(a_3x3, w_3, v_3x3) {
 
 
   if (maxI !== 0) {
-    tmp = w_3[maxI];
+    var eigenValTmp = w_3[maxI];
     w_3[maxI] = w_3[0];
-    w_3[0] = tmp;
-    vtkSwapVectors3(v_3x3[maxI], v_3x3[0]);
+    w_3[0] = eigenValTmp;
+    swapRowsMatrix_nxn(v_3x3, 3, maxI, 0);
   } // do the same for the y element
 
 
-  if (Math.abs(v_3x3[1][1]) < Math.abs(v_3x3[2][1])) {
-    tmp = w_3[2];
+  if (Math.abs(v_3x3[4]) < Math.abs(v_3x3[7])) {
+    var _eigenValTmp = w_3[2];
     w_3[2] = w_3[1];
-    w_3[1] = tmp;
-    vtkSwapVectors3(v_3x3[2], v_3x3[1]);
+    w_3[1] = _eigenValTmp;
+    swapRowsMatrix_nxn(v_3x3, 3, 1, 2);
   } // ensure that the sign of the eigenvectors is correct
 
 
   for (i = 0; i < 2; i++) {
-    if (v_3x3[i][i] < 0) {
-      v_3x3[i][0] = -v_3x3[i][0];
-      v_3x3[i][1] = -v_3x3[i][1];
-      v_3x3[i][2] = -v_3x3[i][2];
+    if (v_3x3[i * 3 + i] < 0) {
+      v_3x3[i * 3] = -v_3x3[i * 3];
+      v_3x3[i * 3 + 1] = -v_3x3[i * 3 + 1];
+      v_3x3[i * 3 + 2] = -v_3x3[i * 3 + 2];
     }
   } // set sign of final eigenvector to ensure that determinant is positive
 
 
   if (determinant3x3(v_3x3) < 0) {
-    v_3x3[2][0] = -v_3x3[2][0];
-    v_3x3[2][1] = -v_3x3[2][1];
-    v_3x3[2][2] = -v_3x3[2][2];
+    v_3x3[6] = -v_3x3[6];
+    v_3x3[7] = -v_3x3[7];
+    v_3x3[8] = -v_3x3[8];
   } // transpose the eigenvectors back again
 
 
   transpose3x3(v_3x3, v_3x3);
 }
 function singularValueDecomposition3x3(a_3x3, u_3x3, w_3, vT_3x3) {
-  var i;
-  var B = [createArray(3), createArray(3), createArray(3)]; // copy so that A can be used for U or VT without risk
+  var i; // copy so that A can be used for U or VT without risk
 
-  for (i = 0; i < 3; i++) {
-    B[0][i] = a_3x3[0][i];
-    B[1][i] = a_3x3[1][i];
-    B[2][i] = a_3x3[2][i];
-  } // temporarily flip if determinant is negative
+  var B = _toConsumableArray(a_3x3); // temporarily flip if determinant is negative
 
 
   var d = determinant3x3(B);
 
   if (d < 0) {
-    for (i = 0; i < 3; i++) {
-      B[0][i] = -B[0][i];
-      B[1][i] = -B[1][i];
-      B[2][i] = -B[2][i];
+    for (i = 0; i < 9; i++) {
+      B[i] = -B[i];
     }
   } // orthogonalize, diagonalize, etc.
 
@@ -1185,6 +1226,13 @@ function singularValueDecomposition3x3(a_3x3, u_3x3, w_3, vT_3x3) {
     w_3[2] = -w_3[2];
   }
 }
+/**
+ * Factor linear equations Ax = b using LU decomposition A = LU. Output factorization LU is in matrix A.
+ * @param {Matrix} A square matrix
+ * @param {Number} index integer array of pivot indices index[0->n-1]
+ * @param {Number} size matrix size
+ */
+
 function luFactorLinearSystem(A, index, size) {
   var i;
   var j;
@@ -1200,7 +1248,7 @@ function luFactorLinearSystem(A, index, size) {
 
   for (i = 0; i < size; i++) {
     for (largest = 0.0, j = 0; j < size; j++) {
-      if ((temp2 = Math.abs(A[i][j])) > largest) {
+      if ((temp2 = Math.abs(A[i * size + j])) > largest) {
         largest = temp2;
       }
     }
@@ -1218,26 +1266,26 @@ function luFactorLinearSystem(A, index, size) {
 
   for (j = 0; j < size; j++) {
     for (i = 0; i < j; i++) {
-      sum = A[i][j];
+      sum = A[i * size + j];
 
       for (k = 0; k < i; k++) {
-        sum -= A[i][k] * A[k][j];
+        sum -= A[i * size + k] * A[k * size + j];
       }
 
-      A[i][j] = sum;
+      A[i * size + j] = sum;
     } //
     // Begin search for largest pivot element
     //
 
 
     for (largest = 0.0, i = j; i < size; i++) {
-      sum = A[i][j];
+      sum = A[i * size + j];
 
       for (k = 0; k < j; k++) {
-        sum -= A[i][k] * A[k][j];
+        sum -= A[i * size + k] * A[k * size + j];
       }
 
-      A[i][j] = sum;
+      A[i * size + j] = sum;
 
       if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {
         largest = temp1;
@@ -1250,9 +1298,9 @@ function luFactorLinearSystem(A, index, size) {
 
     if (j !== maxI) {
       for (k = 0; k < size; k++) {
-        temp1 = A[maxI][k];
-        A[maxI][k] = A[j][k];
-        A[j][k] = temp1;
+        temp1 = A[maxI * size + k];
+        A[maxI * size + k] = A[j * size + k];
+        A[j * size + k] = temp1;
       }
 
       scale[maxI] = scale[j];
@@ -1263,16 +1311,16 @@ function luFactorLinearSystem(A, index, size) {
 
     index[j] = maxI;
 
-    if (Math.abs(A[j][j]) <= VTK_SMALL_NUMBER) {
+    if (Math.abs(A[j * size + j]) <= VTK_SMALL_NUMBER) {
       vtkWarningMacro('Unable to factor linear system');
       return 0;
     }
 
     if (j !== size - 1) {
-      temp1 = 1.0 / A[j][j];
+      temp1 = 1.0 / A[j * size + j];
 
       for (i = j + 1; i < size; i++) {
-        A[i][j] *= temp1;
+        A[i * size + j] *= temp1;
       }
     }
   }
@@ -1296,7 +1344,7 @@ function luSolveLinearSystem(A, index, x, size) {
 
     if (ii >= 0) {
       for (j = ii; j <= i - 1; j++) {
-        sum -= A[i][j] * x[j];
+        sum -= A[i * size + j] * x[j];
       }
     } else if (sum !== 0.0) {
       ii = i;
@@ -1312,37 +1360,37 @@ function luSolveLinearSystem(A, index, x, size) {
     sum = x[i];
 
     for (j = i + 1; j < size; j++) {
-      sum -= A[i][j] * x[j];
+      sum -= A[i * size + j] * x[j];
     }
 
-    x[i] = sum / A[i][i];
+    x[i] = sum / A[i * size + i];
   }
 }
 function solveLinearSystem(A, x, size) {
   // if we solving something simple, just solve it
   if (size === 2) {
     var y = createArray(2);
-    var det = determinant2x2(A[0][0], A[0][1], A[1][0], A[1][1]);
+    var det = determinant2x2(A[0], A[1], A[2], A[3]);
 
     if (det === 0.0) {
       // Unable to solve linear system
       return 0;
     }
 
-    y[0] = (A[1][1] * x[0] - A[0][1] * x[1]) / det;
-    y[1] = (-(A[1][0] * x[0]) + A[0][0] * x[1]) / det;
+    y[0] = (A[3] * x[0] - A[1] * x[1]) / det;
+    y[1] = (-(A[2] * x[0]) + A[0] * x[1]) / det;
     x[0] = y[0];
     x[1] = y[1];
     return 1;
   }
 
   if (size === 1) {
-    if (A[0][0] === 0.0) {
+    if (A[0] === 0.0) {
       // Unable to solve linear system
       return 0;
     }
 
-    x[0] /= A[0][0];
+    x[0] /= A[0];
     return 1;
   } //
   // System of equations is not trivial, use Crout's method
@@ -1380,7 +1428,7 @@ function invertMatrix(A, AI, size) {
     luSolveLinearSystem(A, tmp1Size, tmp2Size, size);
 
     for (var _i4 = 0; _i4 < size; _i4++) {
-      AI[_i4][j] = tmp2Size[_i4];
+      AI[_i4 * size + j] = tmp2Size[_i4];
     }
   }
 
@@ -1392,16 +1440,16 @@ function estimateMatrixCondition(A, size) {
 
   for (var i = 0; i < size; i++) {
     for (var j = i; j < size; j++) {
-      if (Math.abs(A[i][j]) > max) {
-        maxValue = Math.abs(A[i][j]);
+      if (Math.abs(A[i * size + j]) > maxValue) {
+        maxValue = Math.abs(A[i * size + j]);
       }
     }
   } // find the minimum diagonal value
 
 
   for (var _i5 = 0; _i5 < size; _i5++) {
-    if (Math.abs(A[_i5][_i5]) < min) {
-      minValue = Math.abs(A[_i5][_i5]);
+    if (Math.abs(A[_i5 * size + _i5]) < minValue) {
+      minValue = Math.abs(A[_i5 * size + _i5]);
     }
   }
 
@@ -1426,26 +1474,16 @@ function solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt) {
   var k; // set up intermediate variables
   // Allocate matrix to hold X times transpose of X
 
-  var XXt = createArray(xOrder); // size x by x
+  var XXt = createArray(xOrder * xOrder); // size x by x
   // Allocate the array of eigenvalues and eigenvectors
 
   var eigenvals = createArray(xOrder);
-  var eigenvecs = createArray(xOrder); // Clear the upper triangular region (and btw, allocate the eigenvecs as well)
-
-  for (i = 0; i < xOrder; i++) {
-    eigenvecs[i] = createArray(xOrder);
-    XXt[i] = createArray(xOrder);
-
-    for (j = 0; j < xOrder; j++) {
-      XXt[i][j] = 0.0;
-    }
-  } // Calculate XXt upper half only, due to symmetry
-
+  var eigenvecs = createArray(xOrder * xOrder); // Calculate XXt upper half only, due to symmetry
 
   for (k = 0; k < numberOfSamples; k++) {
     for (i = 0; i < xOrder; i++) {
       for (j = i; j < xOrder; j++) {
-        XXt[i][j] += xt[k][i] * xt[k][j];
+        XXt[i * xOrder + j] += xt[k * xOrder + i] * xt[k * xOrder + j];
       }
     }
   } // now fill in the lower half of the XXt matrix
@@ -1453,7 +1491,7 @@ function solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt) {
 
   for (i = 0; i < xOrder; i++) {
     for (j = 0; j < i; j++) {
-      XXt[i][j] = XXt[j][i];
+      XXt[i * xOrder + j] = XXt[j * xOrder + i];
     }
   } // Compute the eigenvectors and eigenvalues
 
@@ -1462,7 +1500,7 @@ function solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt) {
   // corresponding eigenvec.
 
   for (i = 0; i < xOrder; i++) {
-    mt[i][0] = eigenvecs[i][xOrder - 1];
+    mt[i] = eigenvecs[i * xOrder + xOrder - 1];
   }
 
   return 1;
@@ -1499,7 +1537,7 @@ function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
 
     for (i = 0; i < numberOfSamples; i++) {
       for (j = 0; j < yOrder; j++) {
-        if (Math.abs(yt[i][j]) > VTK_SMALL_NUMBER) {
+        if (Math.abs(yt[i * yOrder + j]) > VTK_SMALL_NUMBER) {
           allHomogeneous = 0;
           homogenFlags[j] = 0;
         }
@@ -1529,52 +1567,30 @@ function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
 
   if (someHomogeneous) {
     // hmt is the homogeneous equation version of mt, the general solution.
-    hmt = createArray(xOrder);
-
-    for (j = 0; j < xOrder; j++) {
-      // Only allocate 1 here, not yOrder, because here we're going to solve
-      // just the one homogeneous equation subset of the entire problem
-      hmt[j] = [0];
-    } // Ok, solve the homogeneous problem
-
+    // hmt should be xOrder x yOrder, but since we are solving only the homogeneous part, here it is xOrder x 1
+    hmt = createArray(xOrder); // Ok, solve the homogeneous problem
 
     homogRC = solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, hmt);
   } // set up intermediate variables
 
 
-  var XXt = createArray(xOrder); // size x by x
-
-  var XXtI = createArray(xOrder); // size x by x
-
-  var XYt = createArray(xOrder); // size x by y
-
-  for (i = 0; i < xOrder; i++) {
-    XXt[i] = createArray(xOrder);
-    XXtI[i] = createArray(xOrder);
-
-    for (j = 0; j < xOrder; j++) {
-      XXt[i][j] = 0.0;
-      XXtI[i][j] = 0.0;
-    }
-
-    XYt[i] = createArray(yOrder);
+  var XXt = createArray(xOrder * xOrder); // size x by x
 
-    for (j = 0; j < yOrder; j++) {
-      XYt[i][j] = 0.0;
-    }
-  } // first find the pseudoinverse matrix
+  var XXtI = createArray(xOrder * xOrder); // size x by x
 
+  var XYt = createArray(xOrder * yOrder); // size x by y
+  // first find the pseudoinverse matrix
 
   for (k = 0; k < numberOfSamples; k++) {
     for (i = 0; i < xOrder; i++) {
       // first calculate the XXt matrix, only do the upper half (symmetrical)
       for (j = i; j < xOrder; j++) {
-        XXt[i][j] += xt[k][i] * xt[k][j];
+        XXt[i * xOrder + j] += xt[k * xOrder + i] * xt[k * xOrder + j];
       } // now calculate the XYt matrix
 
 
       for (j = 0; j < yOrder; j++) {
-        XYt[i][j] += xt[k][i] * yt[k][j];
+        XYt[i * yOrder + j] += xt[k * xOrder + i] * yt[k * yOrder + j];
       }
     }
   } // now fill in the lower half of the XXt matrix
@@ -1582,7 +1598,7 @@ function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
 
   for (i = 0; i < xOrder; i++) {
     for (j = 0; j < i; j++) {
-      XXt[i][j] = XXt[j][i];
+      XXt[i * xOrder + j] = XXt[j * xOrder + i];
     }
   }
 
@@ -1591,10 +1607,10 @@ function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
   if (successFlag) {
     for (i = 0; i < xOrder; i++) {
       for (j = 0; j < yOrder; j++) {
-        mt[i][j] = 0.0;
+        mt[i * yOrder + j] = 0.0;
 
         for (k = 0; k < xOrder; k++) {
-          mt[i][j] += XXtI[i][k] * XYt[k][j];
+          mt[i * yOrder + j] += XXtI[i * xOrder + k] * XYt[k * yOrder + j];
         }
       }
     }
@@ -1607,7 +1623,7 @@ function solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {
       if (homogenFlags[j]) {
         // Fix this one
         for (i = 0; i < xOrder; i++) {
-          mt[i][j] = hmt[i][0];
+          mt[i * yOrder + j] = hmt[i * yOrder];
         }
       }
     }
@@ -2157,6 +2173,7 @@ var vtkMath = {
   transpose3x3: transpose3x3,
   invert3x3: invert3x3,
   identity3x3: identity3x3,
+  identity: identity,
   determinant3x3: determinant3x3,
   quaternionToMatrix3x3: quaternionToMatrix3x3,
   areEquals: areEquals,
@@ -2214,6 +2231,7 @@ var vtkMath = {
 
 var vtkMath$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
+  createArray: createArray,
   Pi: Pi,
   radiansFromDegrees: radiansFromDegrees,
   degreesFromRadians: degreesFromRadians,
@@ -2259,6 +2277,10 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   outer2D: outer2D,
   norm2D: norm2D,
   normalize2D: normalize2D,
+  rowsToMat4: rowsToMat4,
+  columnsToMat4: columnsToMat4,
+  rowsToMat3: rowsToMat3,
+  columnsToMat3: columnsToMat3,
   determinant2x2: determinant2x2,
   LUFactor3x3: LUFactor3x3,
   LUSolve3x3: LUSolve3x3,
@@ -2268,8 +2290,9 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   multiplyMatrix: multiplyMatrix,
   transpose3x3: transpose3x3,
   invert3x3: invert3x3,
-  identity3x3: identity3x3,
   determinant3x3: determinant3x3,
+  identity3x3: identity3x3,
+  identity: identity,
   quaternionToMatrix3x3: quaternionToMatrix3x3,
   areEquals: areEquals,
   areMatricesEqual: areMatricesEqual,
@@ -2324,4 +2347,4 @@ var vtkMath$1 = /*#__PURE__*/Object.freeze({
   'default': vtkMath
 });
 
-export { binomial as $, degreesFromRadians as A, areEquals as B, clampValue as C, arrayRange as D, getMajorAxisIndex as E, isInf as F, rgb2hsv as G, rgb2lab as H, lab2rgb as I, floor as J, round as K, normalize2D as L, nearestPowerOfTwo as M, createUninitializedBounds as N, multiply3x3_vect3 as O, areBoundsInitialized as P, isPowerOfTwo as Q, angleBetweenVectors as R, signedAngleBetweenVectors as S, Pi as T, ceil as U, min as V, max as W, arrayMin as X, arrayMax as Y, ceilLog2 as Z, factorial as _, areMatricesEqual as a, beginCombination as a0, nextCombination as a1, randomSeed as a2, getSeed as a3, gaussian as a4, multiplyScalar2D as a5, multiplyAccumulate2D as a6, outer as a7, projectVector as a8, dot2D as a9, hex2float as aA, lab2xyz as aB, xyz2lab as aC, xyz2rgb as aD, rgb2xyz as aE, clampAndNormalizeValue as aF, getScalarTypeFittingRange as aG, getAdjustedScalarRange as aH, extentIsWithinOtherExtent as aI, boundsIsWithinOtherBounds as aJ, pointIsWithinBounds as aK, solve3PointCircle as aL, inf as aM, negInf as aN, isFinite as aO, isNaN as aP, floatToHex2 as aQ, floatRGB2HexCode as aR, float2CssRGBA as aS, projectVector2D as aa, gaussianAmplitude as ab, gaussianWeight as ac, outer2D as ad, norm2D as ae, LUFactor3x3 as af, LUSolve3x3 as ag, linearSolve3x3 as ah, multiply3x3_mat3 as ai, multiplyMatrix as aj, transpose3x3 as ak, invert3x3 as al, identity3x3 as am, quaternionToMatrix3x3 as an, roundNumber as ao, matrix3x3ToQuaternion as ap, multiplyQuaternion as aq, orthogonalize3x3 as ar, diagonalize3x3 as as, singularValueDecomposition3x3 as at, luFactorLinearSystem as au, luSolveLinearSystem as av, invertMatrix as aw, estimateMatrixCondition as ax, solveHomogeneousLeastSquares as ay, solveLeastSquares as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, vtkMath as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };
+export { ceilLog2 as $, rowsToMat3 as A, degreesFromRadians as B, areEquals as C, clampValue as D, arrayRange as E, getMajorAxisIndex as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor as K, round as L, normalize2D as M, nearestPowerOfTwo as N, createUninitializedBounds as O, multiply3x3_vect3 as P, areBoundsInitialized as Q, isPowerOfTwo as R, angleBetweenVectors as S, signedAngleBetweenVectors as T, createArray as U, Pi as V, ceil as W, min as X, max as Y, arrayMin as Z, arrayMax as _, areMatricesEqual as a, factorial as a0, binomial as a1, beginCombination as a2, nextCombination as a3, randomSeed as a4, getSeed as a5, gaussian as a6, multiplyScalar2D as a7, multiplyAccumulate2D as a8, outer as a9, luFactorLinearSystem as aA, luSolveLinearSystem as aB, invertMatrix as aC, estimateMatrixCondition as aD, solveHomogeneousLeastSquares as aE, solveLeastSquares as aF, hex2float as aG, lab2xyz as aH, xyz2lab as aI, xyz2rgb as aJ, rgb2xyz as aK, clampAndNormalizeValue as aL, getScalarTypeFittingRange as aM, getAdjustedScalarRange as aN, extentIsWithinOtherExtent as aO, boundsIsWithinOtherBounds as aP, pointIsWithinBounds as aQ, solve3PointCircle as aR, inf as aS, negInf as aT, isFinite as aU, isNaN as aV, floatToHex2 as aW, floatRGB2HexCode as aX, float2CssRGBA as aY, projectVector as aa, dot2D as ab, projectVector2D as ac, gaussianAmplitude as ad, gaussianWeight as ae, outer2D as af, norm2D as ag, rowsToMat4 as ah, columnsToMat4 as ai, columnsToMat3 as aj, LUFactor3x3 as ak, LUSolve3x3 as al, linearSolve3x3 as am, multiply3x3_mat3 as an, multiplyMatrix as ao, transpose3x3 as ap, invert3x3 as aq, identity3x3 as ar, identity as as, quaternionToMatrix3x3 as at, roundNumber as au, matrix3x3ToQuaternion as av, multiplyQuaternion as aw, orthogonalize3x3 as ax, diagonalize3x3 as ay, singularValueDecomposition3x3 as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, solveLinearSystem as g, hsv2rgb as h, isNan as i, cross as j, add as k, normalize as l, multiplyAccumulate as m, norm as n, determinant2x2 as o, jacobiN as p, perpendiculars as q, radiansFromDegrees as r, subtract as s, vtkMath as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };