StackGenVis: Alignment of Data, Algorithms, and Models for Stacking Ensemble Learning Using Performance Metrics https://doi.org/10.1109/TVCG.2020.3030352
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
StackGenVis/frontend/node_modules/sylvester-es6/target/Matrix.js

746 lines
23 KiB

4 years ago
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Matrix = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _PRECISION = require("./PRECISION");
var _Vector = require("./Vector");
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Matrix = exports.Matrix = function () {
function Matrix(elements) {
_classCallCheck(this, Matrix);
this.setElements(elements);
}
_createClass(Matrix, [{
key: "e",
value: function e(i, j) {
if (i < 1 || i > this.elements.length || j < 1 || j > this.elements[0].length) {
return null;
}
return this.elements[i - 1][j - 1];
}
}, {
key: "row",
value: function row(i) {
if (i > this.elements.length) {
return null;
}
return new _Vector.Vector(this.elements[i - 1]);
}
}, {
key: "col",
value: function col(j) {
if (this.elements.length === 0) {
return null;
}
if (j > this.elements[0].length) {
return null;
}
var col = [],
n = this.elements.length;
for (var i = 0; i < n; i++) {
col.push(this.elements[i][j - 1]);
}
return new _Vector.Vector(col);
}
}, {
key: "dimensions",
value: function dimensions() {
var cols = this.elements.length === 0 ? 0 : this.elements[0].length;
return { rows: this.elements.length, cols: cols };
}
}, {
key: "rows",
value: function rows() {
return this.elements.length;
}
}, {
key: "cols",
value: function cols() {
if (this.elements.length === 0) {
return 0;
}
return this.elements[0].length;
}
}, {
key: "eql",
value: function eql(matrix) {
var M = matrix.elements || matrix;
if (!M[0] || typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
if (this.elements.length === 0 || M.length === 0) {
return this.elements.length === M.length;
}
if (this.elements.length !== M.length) {
return false;
}
if (this.elements[0].length !== M[0].length) {
return false;
}
var i = this.elements.length,
nj = this.elements[0].length,
j;
while (i--) {
j = nj;
while (j--) {
if (Math.abs(this.elements[i][j] - M[i][j]) > _PRECISION.PRECISION) {
return false;
}
}
}
return true;
}
}, {
key: "dup",
value: function dup() {
return new Matrix(this.elements);
}
}, {
key: "map",
value: function map(fn, context) {
if (this.elements.length === 0) {
return new Matrix([]);
}
var els = [],
i = this.elements.length,
nj = this.elements[0].length,
j;
while (i--) {
j = nj;
els[i] = [];
while (j--) {
els[i][j] = fn.call(context, this.elements[i][j], i + 1, j + 1);
}
}
return new Matrix(els);
}
}, {
key: "isSameSizeAs",
value: function isSameSizeAs(matrix) {
var M = matrix.elements || matrix;
if (typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
if (this.elements.length === 0) {
return M.length === 0;
}
return this.elements.length === M.length && this.elements[0].length === M[0].length;
}
}, {
key: "add",
value: function add(matrix) {
if (this.elements.length === 0) {
return this.map(function (x) {
return x;
});
}
var M = matrix.elements || matrix;
if (typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
if (!this.isSameSizeAs(M)) {
return null;
}
return this.map(function (x, i, j) {
return x + M[i - 1][j - 1];
});
}
}, {
key: "subtract",
value: function subtract(matrix) {
if (this.elements.length === 0) {
return this.map(function (x) {
return x;
});
}
var M = matrix.elements || matrix;
if (typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
if (!this.isSameSizeAs(M)) {
return null;
}
return this.map(function (x, i, j) {
return x - M[i - 1][j - 1];
});
}
}, {
key: "canMultiplyFromLeft",
value: function canMultiplyFromLeft(matrix) {
if (this.elements.length === 0) {
return false;
}
var M = matrix.elements || matrix;
if (typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
// this.columns should equal matrix.rows
return this.elements[0].length === M.length;
}
}, {
key: "multiply",
value: function multiply(matrix) {
if (this.elements.length === 0) {
return null;
}
if (!matrix.elements) {
return this.map(function (x) {
return x * matrix;
});
}
var returnVector = matrix.modulus ? true : false;
var M = matrix.elements || matrix;
if (typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
if (!this.canMultiplyFromLeft(M)) {
return null;
}
var i = this.elements.length,
nj = M[0].length,
j;
var cols = this.elements[0].length,
c,
elements = [],
sum;
while (i--) {
j = nj;
elements[i] = [];
while (j--) {
c = cols;
sum = 0;
while (c--) {
sum += this.elements[i][c] * M[c][j];
}
elements[i][j] = sum;
}
}
var M = new Matrix(elements);
return returnVector ? M.col(1) : M;
}
}, {
key: "minor",
value: function minor(a, b, c, d) {
if (this.elements.length === 0) {
return null;
}
var elements = [],
ni = c,
i,
nj,
j;
var rows = this.elements.length,
cols = this.elements[0].length;
while (ni--) {
i = c - ni - 1;
elements[i] = [];
nj = d;
while (nj--) {
j = d - nj - 1;
elements[i][j] = this.elements[(a + i - 1) % rows][(b + j - 1) % cols];
}
}
return new Matrix(elements);
}
}, {
key: "transpose",
value: function transpose() {
if (this.elements.length === 0) {
return new Matrix([]);
}
var rows = this.elements.length,
i,
cols = this.elements[0].length,
j;
var elements = [],
i = cols;
while (i--) {
j = rows;
elements[i] = [];
while (j--) {
elements[i][j] = this.elements[j][i];
}
}
return new Matrix(elements);
}
}, {
key: "isSquare",
value: function isSquare() {
var cols = this.elements.length === 0 ? 0 : this.elements[0].length;
return this.elements.length === cols;
}
}, {
key: "max",
value: function max() {
if (this.elements.length === 0) {
return null;
}
var m = 0,
i = this.elements.length,
nj = this.elements[0].length,
j;
while (i--) {
j = nj;
while (j--) {
if (Math.abs(this.elements[i][j]) > Math.abs(m)) {
m = this.elements[i][j];
}
}
}
return m;
}
}, {
key: "indexOf",
value: function indexOf(x) {
if (this.elements.length === 0) {
return null;
}
var index = null,
ni = this.elements.length,
i,
nj = this.elements[0].length,
j;
for (i = 0; i < ni; i++) {
for (j = 0; j < nj; j++) {
if (this.elements[i][j] === x) {
return {
i: i + 1,
j: j + 1
};
}
}
}
return null;
}
}, {
key: "diagonal",
value: function diagonal() {
if (!this.isSquare) {
return null;
}
var els = [],
n = this.elements.length;
for (var i = 0; i < n; i++) {
els.push(this.elements[i][i]);
}
return new _Vector.Vector(els);
}
}, {
key: "toRightTriangular",
value: function toRightTriangular() {
if (this.elements.length === 0) {
return new Matrix([]);
}
var M = this.dup(),
els;
var n = this.elements.length,
i,
j,
np = this.elements[0].length,
p;
for (i = 0; i < n; i++) {
if (M.elements[i][i] === 0) {
for (j = i + 1; j < n; j++) {
if (M.elements[j][i] !== 0) {
els = [];
for (p = 0; p < np; p++) {
els.push(M.elements[i][p] + M.elements[j][p]);
}
M.elements[i] = els;
break;
}
}
}
if (M.elements[i][i] !== 0) {
for (j = i + 1; j < n; j++) {
var multiplier = M.elements[j][i] / M.elements[i][i];
els = [];
for (p = 0; p < np; p++) {
// Elements with column numbers up to an including the number of the
// row that we're subtracting can safely be set straight to zero,
// since that's the point of this routine and it avoids having to
// loop over and correct rounding errors later
els.push(p <= i ? 0 : M.elements[j][p] - M.elements[i][p] * multiplier);
}
M.elements[j] = els;
}
}
}
return M;
}
}, {
key: "determinant",
value: function determinant() {
if (this.elements.length === 0) {
return 1;
}
if (!this.isSquare()) {
return null;
}
var M = this.toRightTriangular();
var det = M.elements[0][0],
n = M.elements.length;
for (var i = 1; i < n; i++) {
det = det * M.elements[i][i];
}
return det;
}
}, {
key: "isSingular",
value: function isSingular() {
return this.isSquare() && this.determinant() === 0;
}
}, {
key: "trace",
value: function trace() {
if (this.elements.length === 0) {
return 0;
}
if (!this.isSquare()) {
return null;
}
var tr = this.elements[0][0],
n = this.elements.length;
for (var i = 1; i < n; i++) {
tr += this.elements[i][i];
}
return tr;
}
}, {
key: "rank",
value: function rank() {
if (this.elements.length === 0) {
return 0;
}
var M = this.toRightTriangular(),
rank = 0;
var i = this.elements.length,
nj = this.elements[0].length,
j;
while (i--) {
j = nj;
while (j--) {
if (Math.abs(M.elements[i][j]) > _PRECISION.PRECISION) {
rank++;
break;
}
}
}
return rank;
}
}, {
key: "augment",
value: function augment(matrix) {
if (this.elements.length === 0) {
return this.dup();
}
var M = matrix.elements || matrix;
if (typeof M[0][0] === 'undefined') {
M = new Matrix(M).elements;
}
var T = this.dup(),
cols = T.elements[0].length;
var i = T.elements.length,
nj = M[0].length,
j;
if (i !== M.length) {
return null;
}
while (i--) {
j = nj;
while (j--) {
T.elements[i][cols + j] = M[i][j];
}
}
return T;
}
}, {
key: "inverse",
value: function inverse() {
if (this.elements.length === 0) {
return null;
}
if (!this.isSquare() || this.isSingular()) {
return null;
}
var n = this.elements.length,
i = n,
j;
var M = this.augment(Matrix.I(n)).toRightTriangular();
var np = M.elements[0].length,
p,
els,
divisor;
var inverse_elements = [],
new_element;
// Matrix is non-singular so there will be no zeros on the
// diagonal. Cycle through rows from last to first.
while (i--) {
// First, normalise diagonal elements to 1
els = [];
inverse_elements[i] = [];
divisor = M.elements[i][i];
for (p = 0; p < np; p++) {
new_element = M.elements[i][p] / divisor;
els.push(new_element);
// Shuffle off the current row of the right hand side into the results
// array as it will not be modified by later runs through this loop
if (p >= n) {
inverse_elements[i].push(new_element);
}
}
M.elements[i] = els;
// Then, subtract this row from those above it to give the identity matrix
// on the left hand side
j = i;
while (j--) {
els = [];
for (p = 0; p < np; p++) {
els.push(M.elements[j][p] - M.elements[i][p] * M.elements[j][i]);
}
M.elements[j] = els;
}
}
return new Matrix(inverse_elements);
}
}, {
key: "round",
value: function round() {
return this.map(function (x) {
return Math.round(x);
});
}
}, {
key: "snapTo",
value: function snapTo(x) {
return this.map(function (p) {
return Math.abs(p - x) <= _PRECISION.PRECISION ? x : p;
});
}
}, {
key: "inspect",
value: function inspect() {
var matrix_rows = [];
var n = this.elements.length;
if (n === 0) return '[]';
for (var i = 0; i < n; i++) {
matrix_rows.push(new _Vector.Vector(this.elements[i]).inspect());
}
return matrix_rows.join('\n');
}
}, {
key: "setElements",
value: function setElements(els) {
var i,
j,
elements = els.elements || els;
if (elements[0] && typeof elements[0][0] !== 'undefined') {
i = elements.length;
this.elements = [];
while (i--) {
j = elements[i].length;
this.elements[i] = [];
while (j--) {
this.elements[i][j] = elements[i][j];
}
}
return this;
}
var n = elements.length;
this.elements = [];
for (i = 0; i < n; i++) {
this.elements.push([elements[i]]);
}
return this;
}
//From glUtils.js
}, {
key: "flatten",
value: function flatten() {
var result = [];
if (this.elements.length == 0) {
return [];
}
for (var j = 0; j < this.elements[0].length; j++) {
for (var i = 0; i < this.elements.length; i++) {
result.push(this.elements[i][j]);
}
}
return result;
}
//From glUtils.js
}, {
key: "ensure4x4",
value: function ensure4x4() {
if (this.elements.length == 4 && this.elements[0].length == 4) {
return this;
}
if (this.elements.length > 4 || this.elements[0].length > 4) {
return null;
}
for (var i = 0; i < this.elements.length; i++) {
for (var j = this.elements[i].length; j < 4; j++) {
if (i == j) {
this.elements[i].push(1);
} else {
this.elements[i].push(0);
}
}
}
for (var i = this.elements.length; i < 4; i++) {
if (i == 0) {
this.elements.push([1, 0, 0, 0]);
} else if (i == 1) {
this.elements.push([0, 1, 0, 0]);
} else if (i == 2) {
this.elements.push([0, 0, 1, 0]);
} else if (i == 3) {
this.elements.push([0, 0, 0, 1]);
}
}
return this;
}
//From glUtils.js
}, {
key: "make3x3",
value: function make3x3() {
if (this.elements.length != 4 || this.elements[0].length != 4) {
return null;
}
return new Matrix([[this.elements[0][0], this.elements[0][1], this.elements[0][2]], [this.elements[1][0], this.elements[1][1], this.elements[1][2]], [this.elements[2][0], this.elements[2][1], this.elements[2][2]]]);
}
}]);
return Matrix;
}();
Matrix.I = function (n) {
var els = [],
i = n,
j;
while (i--) {
j = n;
els[i] = [];
while (j--) {
els[i][j] = i === j ? 1 : 0;
}
}
return new Matrix(els);
};
Matrix.Diagonal = function (elements) {
var i = elements.length;
var M = Matrix.I(i);
while (i--) {
M.elements[i][i] = elements[i];
}
return M;
};
Matrix.Rotation = function (theta, a) {
if (!a) {
return new Matrix([[Math.cos(theta), -Math.sin(theta)], [Math.sin(theta), Math.cos(theta)]]);
}
var axis = a.dup();
if (axis.elements.length !== 3) {
return null;
}
var mod = axis.modulus();
var x = axis.elements[0] / mod,
y = axis.elements[1] / mod,
z = axis.elements[2] / mod;
var s = Math.sin(theta),
c = Math.cos(theta),
t = 1 - c;
// Formula derived here: http://www.gamedev.net/reference/articles/article1199.asp
// That proof rotates the co-ordinate system so theta becomes -theta and sin
// becomes -sin here.
return new Matrix([[t * x * x + c, t * x * y - s * z, t * x * z + s * y], [t * x * y + s * z, t * y * y + c, t * y * z - s * x], [t * x * z - s * y, t * y * z + s * x, t * z * z + c]]);
};
Matrix.RotationX = function (t) {
var c = Math.cos(t),
s = Math.sin(t);
return new Matrix([[1, 0, 0], [0, c, -s], [0, s, c]]);
};
Matrix.RotationY = function (t) {
var c = Math.cos(t),
s = Math.sin(t);
return new Matrix([[c, 0, s], [0, 1, 0], [-s, 0, c]]);
};
Matrix.RotationZ = function (t) {
var c = Math.cos(t),
s = Math.sin(t);
return new Matrix([[c, -s, 0], [s, c, 0], [0, 0, 1]]);
};
Matrix.Random = function (n, m) {
return Matrix.Zero(n, m).map(function () {
return Math.random();
});
};
//From glUtils.js
Matrix.Translation = function (v) {
if (v.elements.length == 2) {
var r = Matrix.I(3);
r.elements[2][0] = v.elements[0];
r.elements[2][1] = v.elements[1];
return r;
}
if (v.elements.length == 3) {
var r = Matrix.I(4);
r.elements[0][3] = v.elements[0];
r.elements[1][3] = v.elements[1];
r.elements[2][3] = v.elements[2];
return r;
}
throw "Invalid length for Translation";
};
Matrix.Zero = function (n, m) {
var els = [],
i = n,
j;
while (i--) {
j = m;
els[i] = [];
while (j--) {
els[i][j] = 0;
}
}
return new Matrix(els);
};
Matrix.prototype.toUpperTriangular = Matrix.prototype.toRightTriangular;
Matrix.prototype.det = Matrix.prototype.determinant;
Matrix.prototype.tr = Matrix.prototype.trace;
Matrix.prototype.rk = Matrix.prototype.rank;
Matrix.prototype.inv = Matrix.prototype.inverse;
Matrix.prototype.x = Matrix.prototype.multiply;
//# sourceMappingURL=Matrix.js.map