tensorplay.linalg API

linalg_diagonal(A, *, offset=0, dim1=-2, dim2=-1) -> Tensor

Returns a view of the diagonals of A: the two dimensions selected by dim1 and dim2 are collapsed into the trailing axis of the output, holding the entries of the diagonal shifted by offset (positive shifts above, negative below the main diagonal).

See tensorplay.diagonal()

linalg_householder_product(Tensor input, Tensor tau) -> Tensor linalg_householder_product.out(Tensor input, Tensor tau, *, Tensor(a!) out) -> Tensor(a!)

linalg_ldl_factor_ex(Tensor A, *, bool hermitian=False, bool check_errors=False) -> (Tensor LD, Tensor pivots, Tensor info) linalg_ldl_factor_ex.out(Tensor self, *, bool hermitian=False, bool check_errors=False, Tensor(a!) LD, Tensor(b!) pivots, Tensor(c!) info) -> (Tensor(a!) LD, Tensor(b!) pivots, Tensor(c!) info)

linalg_ldl_factor(Tensor A, *, bool hermitian=False) -> (Tensor LD, Tensor pivots) linalg_ldl_factor.out(Tensor self, *, bool hermitian=False, Tensor(a!) LD, Tensor(b!) pivots) -> (Tensor(a!) LD, Tensor(b!) pivots)

linalg_ldl_solve(Tensor LD, Tensor pivots, Tensor B, *, bool hermitian=False) -> Tensor linalg_ldl_solve.out(Tensor LD, Tensor pivots, Tensor B, *, bool hermitian=False, Tensor(a!) out) -> Tensor(a!)

linalg_lu_factor_ex(Tensor A, *, bool pivot=True, bool check_errors=False) -> (Tensor LU, Tensor pivots, Tensor info) linalg_lu_factor_ex.out(Tensor A, *, bool pivot=True, bool check_errors=False, Tensor(a!) LU, Tensor(b!) pivots, Tensor(c!) info) -> (Tensor(a!) LU, Tensor(b!) pivots, Tensor(c!) info)

linalg_lu_factor(Tensor A, *, bool pivot=True) -> (Tensor LU, Tensor pivots) linalg_lu_factor.out(Tensor A, *, bool pivot=True, Tensor(a!) LU, Tensor(b!) pivots) -> (Tensor(a!) LU, Tensor(b!) pivots)

linalg_lu_solve(Tensor LU, Tensor pivots, Tensor B, *, bool left=True, bool adjoint=False) -> Tensor linalg_lu_solve.out(Tensor LU, Tensor pivots, Tensor B, *, bool left=True, bool adjoint=False, Tensor(a!) out) -> Tensor(a!)

linalg_lu(Tensor A, *, bool pivot=True) -> (Tensor P, Tensor L, Tensor U) linalg_lu.out(Tensor A, *, bool pivot=True, Tensor(a!) P, Tensor(b!) L, Tensor(c!) U) -> (Tensor(a!) P, Tensor(b!) L, Tensor(c!) U)

Square matrix exponential via the degree-13 Pade approximant with scaling and squaring: A is halved until its 1-norm falls under the approximant’s accuracy threshold, then the result is squared back.

Computes the numerical rank of each matrix in A.

A singular value counts towards the rank when it exceeds the sum of an absolute tolerance and a relative tolerance scaled by the largest singular value of its matrix.

Parameters:

• A (Tensor) – tensor of shape (..., m, n) holding the matrices.

• atol (float, Tensor, optional) – absolute threshold applied to the singular values. Defaults to 0.

• rtol (float, Tensor, optional) – relative threshold applied to the largest singular value. Defaults to max(m, n) times the machine epsilon of A’s dtype.

• hermitian (bool) – when True, A is treated as Hermitian and its rank is derived from eigenvalues instead of singular values.

Returns:

integer tensor with the rank of each matrix, with the batch dimensions of A.

Return type:

Tensor

Matrix square root via the Denman-Beavers fixed-point iteration (converges for matrices with no eigenvalues on the closed negative real axis).

Chained matrix product evaluated in the parenthesization that minimizes the scalar multiplication count (matrix-chain dynamic program).

Moore-Penrose pseudo-inverse. Singular values (eigenvalue magnitudes when hermitian) at or below max(atol, rtol * sigma_max) are treated as zero; rtol defaults to eps * max(m, n), or to zero when only a positive atol is given. The tolerances may be floats or tensors that broadcast against the batch.

linalg_solve_triangular(Tensor A, Tensor B, *, bool upper, bool left=True, bool unitriangular=False) -> Tensor linalg_solve_triangular.out(Tensor self, Tensor B, *, bool upper, bool left=True, bool unitriangular=False, Tensor(a!) out) -> Tensor(a!)

Inverse of A seen as a square matrix over the split at ind: the product of the leading ind dimensions must equal that of the rest.

Solves the tensor equation A X = B after flattening the contracted dimensions into a square matrix. dims identifies dimensions of A that should be moved to the trailing side before the flattening step.

Conjugating dot product over 1-D operands: sum(conj(self) * other).

Dot product along dim with the first argument conjugated for complex inputs.

dim=None norms the whole tensor: the input is flattened first, and keepdim then restores the reduced axes as ones.