Matrices

The two matrices are added cell by cell. The result is a new matrix; the inputs are unchanged.

Inserts the array as a column at the given position and increases the column count. If the matrix is empty (0 rows), the added column's length sets the row count.

Inserts the array as a row at the given position and increases the row count. If the matrix is empty (0 columns), the first added row's length sets the column count.

Divides the sum by the cell count. Returns na (not 0) on an empty matrix; guard the result with na().

Collects the column top to bottom into an array. The returned array is a copy; it does not affect the matrix.

Used as the loop bound over columns. matrixColumns is a second name for the same thing.

Returns exactly the same result as matrixCols — an alternative name provided for readability.

Performs a vertical stack (appends rows below). The result is a new matrix; the inputs are unchanged.

The copy is fully separate from the original; changing one does not affect the other. Used to experiment on a matrix without corrupting it.

Computed by elimination with partial pivoting. A determinant of 0 means the matrix has no inverse (its rows/columns are dependent).

If the second argument is a matrix, subtraction is done cell by cell; if it is a single number, that number is subtracted from all cells. The result is a new matrix.

Computed by the Jacobi method for symmetric matrices. Eigenvalues give the matrix's diagonal magnitudes (its scale along the principal axes).

Computed by the Jacobi method for symmetric matrices; each column of the result matrix is an eigenvector, matching the order of matrixEigenvalues.

Useful to check whether a matrix is non-empty before feeding statistics functions (matrixAvg, matrixMedian).

Does not change the size, it just overwrites the contents with a single value. A quick way to reset a matrix before reusing it.

Rows and columns start at 0. An out-of-range index does not crash, it yields na; you can check the result with na().

Computed by Gauss-Jordan elimination. Multiplying by the inverse yields the identity. A matrix with determinant 0 has no inverse; na is returned then.

The anti-diagonal runs from top-right to bottom-left; this check verifies that only that diagonal may be filled.

In an antisymmetric matrix the diagonal is necessarily 0 (since m[i][i] = -m[i][i] holds only for 0).

Used to validate structures that should contain only 0-1, such as an adjacency matrix.

The diagonal values may be any number; the condition is only that the off-diagonal is 0.

The identity is the neutral element in multiplication (m × identity = m). This check tells whether a matrix is the identity.

Used as a guard before functions that require a square matrix (determinant, inverse, power, trace).

This is a row-stochastic check; being square is not required, only that each row sums to 1. Used to validate transition (Markov) matrices.

A symmetric matrix is a mirror across the diagonal. Covariance and correlation matrices are symmetric; the eigenvalue functions are designed for such matrices.

In an upper-triangular matrix the area below the diagonal is zero, in a lower-triangular one the area above. Either case qualifies as triangular.

Can be used to check whether a computation wrote any value into the matrix.

Each cell of m1 is multiplied by all of m2 and placed block by block. The result grows to the product of both sizes.

Compares all cells without distinguishing rows or columns.

All cells are sorted and the middle value is taken. The median is less sensitive to outliers than the mean.

Compares all cells without distinguishing rows or columns.

When several values share the highest frequency, the smallest value is chosen (a stable, deterministic result).

This is true matrix multiplication (not element-wise): result[i][j] is the dot product of a's row i with b's column j.

A matrix is a two-dimensional grid of numbers made of rows and columns; every other matrix function expects an object built this way.

Computed as (mᵀm)⁻¹mᵀ; it gives the least-squares solution for non-square or non-invertible matrices. For a square invertible matrix the result equals the ordinary inverse.

Multiplies the matrix by itself n times (not an ordinary numeric power). At n=0 the identity, at n=1 the matrix itself is returned.

Computed by elimination. If the rank is less than the row or column count, the matrix has dependency (redundancy) and no inverse.

Deletes the column from the matrix (the column count drops by one) and returns that column as an array. Modifies in place.

Deletes the row from the matrix (the row count drops by one) and returns that row as an array. Modifies in place.

Cells are read row-major and poured into the new shape. If the new size is larger, missing cells become 0; if smaller, extra cells are dropped. Does not change the source.

Reverses both the order of rows and the cells within each row; the first cell swaps with the last (a 180° rotation effect). Modifies in place.

The returned array is a copy; modifying it does not affect the source matrix. An empty result reads as size 0 with arraySize.

Used to know the bound before looping over rows. For the column count use matrixCols.

Overwrites an existing cell; it does not grow the matrix. If the index is out of range it silently does nothing. To add a new row/column use matrixAddRow/matrixAddCol.

Rows are reordered as whole units by the value in the chosen column (each row stays intact internally). Does nothing if the column index is invalid.

The end indices are exclusive (r2 and c2 are not included). Does not change the source; returns a copy of the sliced region.

Sums all values without distinguishing rows or columns. Yields 0 for an empty matrix.

Swaps two whole columns. Does nothing if either index is out of range.

Swaps two whole rows. Does nothing if either index is out of range.

For a non-square matrix it sums the diagonal up to the shorter side. The trace reduces the diagonal energy to a single number.

Does not change the source, it returns a new matrix. Cell at row i, column j becomes row j, column i in the output.