ml-matrix

For specialized mathematical structures, use SymmetricMatrix and DistanceMatrix.

SymmetricMatrix:

• Represents a matrix where $A_{ij} = A_{ji}$.
• toCompact(): Returns a 1D array of the upper-right corner (including diagonal) for efficient storage.
• fromCompact(compact): Reconstructs a SymmetricMatrix from a compact 1D array.
• applyMask(mask): Removes rows/columns based on a boolean/numeric mask.
• removeCross(index) / addCross(index, array): Removes or adds a row and its corresponding column simultaneously to maintain symmetry.

DistanceMatrix:

• A specialized SymmetricMatrix where the diagonal is always 0.
• toCompact(): Returns a 1D array of the upper-right corner (excluding the diagonal).
• fromCompact(compact): Reconstructs a DistanceMatrix from a compact 1D array.

import { SymmetricMatrix, DistanceMatrix } from 'ml-matrix';

// Create a symmetric matrix from compact data
const sym = SymmetricMatrix.fromCompact([1, 2, 3, 4]);

// Create a distance matrix
const dist = new DistanceMatrix(4);
const compactDist = dist.toCompact();

The Matrix class provides static methods for operations between two matrices and instance methods for matrix multiplication.

Static Operations:

• Matrix.add(A, B): Addition
• Matrix.sub(A, B): Subtraction
• Matrix.mul(A, number): Scalar multiplication
• Matrix.div(A, number): Scalar division
• Matrix.mod(B, number): Modulo
• Matrix.max(A, B): Element-wise maximum
• Matrix.min(A, B): Element-wise minimum

Instance Operations:

• A.mmul(B): Matrix multiplication (dot product)

const { Matrix } = require('ml-matrix');

var A = new Matrix([[1, 1], [2, 2]]);
var B = new Matrix([[3, 3], [1, 1]]);

const addition       = Matrix.add(A, B);   // Matrix [[4, 4], [3, 3]]
const subtraction    = Matrix.sub(A, B);   // Matrix [[-2, -2], [1, 1]]
const multiplication = A.mmul(B);          // Matrix [[4, 4], [8, 8]]
const mulByNumber    = Matrix.mul(A, 10);  // Matrix [[10, 10], [20, 20]]
const divByNumber    = Matrix.div(A, 10);  // Matrix [[0.1, 0.1], [0.2, 0.2]]
const modulo         = Matrix.mod(B, 2);   // Matrix [[1, 1], [1, 1]]
const maxMatrix      = Matrix.max(A, B);   // Matrix [[3, 3], [2, 2]]
const minMatrix      = Matrix.min(A, B);   // Matrix [[1, 1], [1, 1]]

Use the following methods and properties to inspect or modify the structure and content of a Matrix:

Properties:

• A.rows: Number of rows
• A.columns: Number of columns
• A.size: Total number of elements

Element Access:

• A.get(row, col): Get value at specific position
• A.set(row, col, value): Set value at specific position

Structural Checks:

• A.isRowVector(): Returns true if it's a row vector
• A.isColumnVector(): Returns true if it's a column vector
• A.isSquare(): Returns true if rows == columns
• A.isSymmetric(): Returns true if the matrix is symmetric

Reductions and Transformations:

• A.diag(): Returns an array of diagonal values
• A.mean(): Returns the mean of all elements
• A.prod(): Returns the product of all elements
• A.norm(): Returns the Frobenius norm
• A.transpose(): Returns the transposed matrix
• A.applyAlongAxis(callback, axis): Applies a callback function along 'row' or 'column' axes.

var A = new Matrix([[1, 1], [-1, -1]]);

var numberRows     = A.rows;             // 2
var numberCols     = A.columns;          // 2
var firstValue     = A.get(0, 0);        // 1
var numberElements = A.size;             // 4
var isRow          = A.isRowVector();    // false
var isColumn       = A.isColumnVector(); // false
var isSquare       = A.isSquare();       // true
var isSym          = A.isSymmetric();    // false

A.set(1, 0, 10);                         // A becomes [[1, 1], [10, -1]]
var diag           = A.diag();           // [1, -1]
var m              = A.mean();           // 0.5 (based on updated A)
var product        = A.prod();           // -10
var norm           = A.norm();           // Frobenius norm
var transpose      = A.transpose();      // Transposed matrix

// Row/Column reductions
var M = new Matrix([[1, 2, 3], [4, 5, 6]]);
var sumOf = (vector) => vector.reduce((total, value) => total + value, 0);
var rowSums    = M.applyAlongAxis(sumOf, 'row');    // [6, 15]
var columnSums = M.applyAlongAxis(sumOf, 'column'); // [5, 7, 9]

The library provides several decomposition classes to break down matrices into simpler components:

• QrDecomposition(A): Provides orthogonalMatrix (Q) and upperTriangularMatrix (R).
• LuDecomposition(A): Provides lowerTriangularMatrix (L), upperTriangularMatrix (U), and pivotPermutationVector (P).
• CholeskyDecomposition(A): Provides lowerTriangularMatrix (L).
• EigenvalueDecomposition(A): Provides realEigenvalues, imaginaryEigenvalues, and eigenvectorMatrix.

const { 
  Matrix, 
  QrDecomposition, 
  LuDecomposition, 
  CholeskyDecomposition, 
  EigenvalueDecomposition 
} = require('ml-matrix');

var A = new Matrix([[2, 3, 5], [4, 1, 6], [1, 3, 0]]);

// QR
var QR = new QrDecomposition(A);
var Q = QR.orthogonalMatrix;
var R = QR.upperTriangularMatrix;

// LU
var LU = new LuDecomposition(A);
var L = LU.lowerTriangularMatrix;
var U = LU.upperTriangularMatrix;
var P = LU.pivotPermutationVector;

// Cholesky
var cholesky = new CholeskyDecomposition(A);
var L_chol = cholesky.lowerTriangularMatrix;

// Eigenvalues
var e = new EigenvalueDecomposition(A);
var real = e.realEigenvalues;
var vectors = e.eigenvectorMatrix;