_MatrixValue

Element-wise matrix addition.

Returns the element at row i, column j (zero-based).

Sub-expressions subject to recursive structural traversal. Binder positions (e.g. the differentiation variable) are excluded.

Determinant via LU decomposition with partial pivoting, O(n³). None when the matrix is non-square; Some(0.0) when singular (zero pivot). Operates on a defensive clone — the value's storage is untouched.

Renders this matrix at precision decimal places for REPL display; mirrors _Number.round behaviour.

Eigenvalue decomposition via QR iteration with Wilkinson shifts. Returns the n eigenvalues as _Number (real) or _Complex (conjugate pairs from 2×2 blocks). None for non-square matrices or non-convergence within 300·n steps.

Algorithm: shrinking active sub-matrix; deflation when the sub-diagonal drops below tolerance; Wilkinson shift QR step otherwise; 2×2 blocks solved analytically. A tiny perturbation breaks rank deficiency when the shift hits an exact eigenvalue.

Compares the receiver object (this) with the argument object (that) for equivalence.

Any implementation of this method should be an equivalence relation:

• It is reflexive: for any instance x of type Any, x.equals(x) should return true.
• It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any instances x, y, and z of type Any if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.

If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is usually necessary to override hashCode to ensure that objects which are "equal" (o1.equals(o2) returns true) hash to the same scala.Int. (o1.hashCode.equals(o2.hashCode)).

Returns Right(this) — a concrete matrix needs no further reduction.

Matrix exponential e^A = sum(k >= 0) A^k / k!, by scaling and squaring with a degree-13 Padé approximant.

Not the eigen route. V·diag(e^λ)·V⁻¹ is tempting because spectralDecompose already exists, but it needs an eigenbasis and a defective matrix has none — and a defective matrix is ordinary in the problems that want this, since a repeated pole produces one. A Jordan block (λ 1; 0 λ) would come back wrong rather than refused. Scaling and squaring is uniform over both cases, which is why it is the standard method.

The identity e^A = (e^(A/2^s))^(2^s) is what makes it work: A is scaled until its norm is inside the Padé approximant's accurate radius, the approximant is evaluated there, and the result is squared back s times.

Note this is matrix Padé — a fixed rational approximant with tabulated coefficients — and is unrelated to the scalar scalar.padeApproximant, which fits a series.

Exactness follows the decomposition precedent rather than matrix/Exact.scala: the exponential is transcendental, so an exact operand demotes to Double exactly as lu/qr/eigen do — "demote an exact operand rather than lose the operation".

Lifts this matrix into an Either for use in eval: Right(this) when all elements are finite; Left(orElse) otherwise (non-finite is a domain error — stays symbolic like x / 0). Shared by scalar and matrix packages without requiring cross-imports.

Inverse via Gauss–Jordan elimination with partial pivoting, O(n³). None when the matrix is non-square or singular — the caller stays symbolic, the same "domain error stays symbolic" contract as x / 0 in scalar.Ratio.

Returns true when every element is finite (not NaN, not infinite).

Kronecker product this ⊗ that: the (rows·that.rows) × (cols·that.cols) block matrix whose (i, j) block is this(i, j) · that. The kernel behind the vectorized matrix-equation tier: vec(A·X·B) = (Bᵀ ⊗ A) · vec(X).

LU decomposition with partial pivoting: P·A = L·U, where L is unit lower triangular, U is upper triangular, and P is the permutation matrix. None when the matrix is non-square or singular (zero pivot encountered).

Matrix multiplication this × that (this.cols must equal that.rows).

Block-tiled i-k-j loop: Tile × Tile blocks keep the hot tile of that (and out) cache-resident across a whole row block. Within each output cell, k-accumulation is ascending, so results are bit-identical to the untiled kernel. Row blocks write disjoint slices of out and parallelise with no locking above the work-volume threshold.

QR decomposition via modified Gram-Schmidt: A = Q·R (m ≥ n). Q is m × n with orthonormal columns; R is n × n upper triangular. None when rows < cols or the matrix is rank-deficient (a column reduces to zero norm).

Reconstructs the same node shape with replacement sub-expressions.

Multiplies every element by scalar k.

Spectral decomposition: eigenvalues and right eigenvectors. Returns (columns of V, eigenvalues) where eigenvector column j corresponds to eigenvalue j. Complex conjugate pairs (α ± βi) occupy consecutive positions. None when non-square, QR iteration fails, or an eigenvector cannot be extracted (numerically degenerate or defective matrix).

Renders this matrix at Environment.DefaultPrecision decimal places.

Read-only view of the dense storage in row-major order.

Returns the transpose of this matrix (cols × rows).

Column-stacking vectorisation: returns the (rows·cols) × 1 column vector where vec[j·rows + i] = this(i, j). Paired with _MatrixValue$.unvec.

Cached hash code; safe because the storage is immutable.

Cached set of free variable names; O(1) after the first access.