protocol

`linear_algebra_protocol`

Linear algebra protocol.

Availability:

logtalk_load(linear_algebra(loader))

Author: Paulo Moura
Version: 1:0:0
Date: 2026-05-05

Compilation flags:

static

Dependencies:

(none)

Remarks:

(none)

Inherited public predicates:

(none)

Public predicates 

`new_vector/3`

Constructs a numeric vector with the requested length, filled with the given value.

Compilation flags:

static

Template:

new_vector(Count,Value,Vector)

Mode and number of proofs:

new_vector(+integer,+number,-list(number)) - one

Exceptions:

Count is a variable:

instantiation_error

Value is a variable:

instantiation_error

Count is neither a variable nor an integer:

type_error(integer,Count)

Value is neither a variable nor a number:

type_error(number,Value)

Count is an integer that is less than zero:

domain_error(non_negative_integer,Count)

`new_vector_like/2`

Constructs a numeric zero vector matching the length of the reference list.

Compilation flags:

static

Template:

new_vector_like(Reference,Zeroes)

Mode and number of proofs:

new_vector_like(+list,-list(number)) - one

`add_vectors/3`

Adds two numeric vectors element-wise.

Compilation flags:

static

Template:

add_vectors(Vector1,Vector2,Vector)

Mode and number of proofs:

add_vectors(+list(number),+list(number),-list(number)) - one

`subtract_vectors/3`

Subtracts the second numeric vector from the first element-wise.

Compilation flags:

static

Template:

subtract_vectors(Vector1,Vector2,Vector)

Mode and number of proofs:

subtract_vectors(+list(number),+list(number),-list(number)) - one

`add_scaled_vector/4`

Adds a scaled numeric vector to another numeric vector.

Compilation flags:

static

Template:

add_scaled_vector(Vector,Scale,Vector0,UpdatedVector)

Mode and number of proofs:

add_scaled_vector(+list(number),+number,+list(number),-list(number)) - one

Exceptions:

Scale is a variable:

instantiation_error

Scale is neither a variable nor a number:

type_error(number,Scale)

`scale_vector/3`

Scales a numeric vector by the given factor.

Compilation flags:

static

Template:

scale_vector(Vector,Scale,ScaledVector)

Mode and number of proofs:

scale_vector(+list(number),+number,-list(number)) - one

Exceptions:

Scale is a variable:

instantiation_error

Scale is neither a variable nor a number:

type_error(number,Scale)

`dot_product/3`

Computes the dot product of two numeric vectors.

Compilation flags:

static

Template:

dot_product(Vector1,Vector2,Product)

Mode and number of proofs:

dot_product(+list(number),+list(number),-number) - one

`euclidean_norm/2`

Computes the Euclidean norm of a numeric vector.

Compilation flags:

static

Template:

euclidean_norm(Vector,Norm)

Mode and number of proofs:

euclidean_norm(+list(number),-float) - one

`vector_norm/3`

Computes the norm of a numeric vector for a positive numeric order or the atoms inf and infinity.

Compilation flags:

static

Template:

vector_norm(Vector,Order,Norm)

Mode and number of proofs:

vector_norm(+list(number),@term,-number) - one_or_error

Exceptions:

Order is a variable:

instantiation_error

Order is neither a variable, a number, nor one of the atoms inf and infinity:

type_error(number,Order)

Order is a number but not a valid positive_number_or_infinity:

domain_error(positive_number_or_infinity,Order)

`basis_vector/3`

Constructs a numeric basis vector with value 1.0 at the given one-based index and 0.0 elsewhere.

Compilation flags:

static

Template:

basis_vector(Size,Index,Vector)

Mode and number of proofs:

basis_vector(+integer,+integer,-list(number)) - one

Exceptions:

Size is a variable:

instantiation_error

Index is a variable:

instantiation_error

Size is neither a variable nor an integer:

type_error(integer,Size)

Index is neither a variable nor an integer:

type_error(integer,Index)

Size is an integer that is less than one:

domain_error(positive_integer,Size)

Index is an integer that is less than one:

domain_error(positive_integer,Index)

`new_matrix/4`

Constructs a numeric matrix with the requested row and column counts, filled with the given value.

Compilation flags:

static

Template:

new_matrix(Rows,Columns,Value,Matrix)

Mode and number of proofs:

new_matrix(+integer,+integer,+number,-list(list(number))) - one

Exceptions:

Rows is a variable:

instantiation_error

Columns is a variable:

instantiation_error

Value is a variable:

instantiation_error

Rows is neither a variable nor an integer:

type_error(integer,Rows)

Columns is neither a variable nor an integer:

type_error(integer,Columns)

Value is neither a variable nor a number:

type_error(number,Value)

Rows is an integer that is less than zero:

domain_error(non_negative_integer,Rows)

Columns is an integer that is less than zero:

domain_error(non_negative_integer,Columns)

`identity_matrix/2`

Constructs a square identity matrix with the requested size.

Compilation flags:

static

Template:

identity_matrix(Size,Matrix)

Mode and number of proofs:

identity_matrix(+integer,-list(list(number))) - one

Exceptions:

Size is a variable:

instantiation_error

Size is neither a variable nor an integer:

type_error(integer,Size)

Size is an integer that is less than zero:

domain_error(non_negative_integer,Size)

`matrix_vector_product/3`

Computes the matrix-vector product for a numeric matrix and vector, returning the list of row-wise dot products between each matrix row and the vector.

Compilation flags:

static

Template:

matrix_vector_product(Matrix,Vector,Product)

Mode and number of proofs:

matrix_vector_product(+list(list(number)),+list(number),-list(number)) - one

`matrix_matrix_product/3`

Computes the matrix-matrix product for two numeric matrices.

Compilation flags:

static

Template:

matrix_matrix_product(Matrix1,Matrix2,Product)

Mode and number of proofs:

matrix_matrix_product(+list(list(number)),+list(list(number)),-list(list(number))) - one

`gram_matrix/2`

Computes the row Gram matrix of a numeric row matrix by taking all row-wise dot products.

Compilation flags:

static

Template:

gram_matrix(Rows,GramMatrix)

Mode and number of proofs:

gram_matrix(+list(list(number)),-list(list(number))) - one

`matrix_row_means/2`

Computes the arithmetic mean of each row in a numeric matrix.

Compilation flags:

static

Template:

matrix_row_means(Matrix,Means)

Mode and number of proofs:

matrix_row_means(+list(list(number)),-list(number)) - one

Exceptions:

Matrix contains an empty row Row:

domain_error(minimum_number_of_values(1),Row)

`matrix_column_means/2`

Computes the arithmetic mean of each column in a numeric matrix.

Compilation flags:

static

Template:

matrix_column_means(Matrix,Means)

Mode and number of proofs:

matrix_column_means(+list(list(number)),-list(number)) - one

`center_gram_matrix/4`

Double-centers a numeric Gram matrix and also returns its row means and total mean.

Compilation flags:

static

Template:

center_gram_matrix(GramMatrix,CenteredGramMatrix,RowMeans,TotalMean)

Mode and number of proofs:

center_gram_matrix(+list(list(number)),-list(list(number)),-list(number),-number) - one

Exceptions:

GramMatrix is empty:

domain_error(minimum_number_of_values(1),GramMatrix)

GramMatrix contains an empty row Row:

domain_error(minimum_number_of_values(1),Row)

`center_gram_vector/4`

Centers a numeric Gram vector using training row means and total mean.

Compilation flags:

static

Template:

center_gram_vector(GramVector,RowMeans,TotalMean,CenteredGramVector)

Mode and number of proofs:

center_gram_vector(+list(number),+list(number),+number,-list(number)) - one

Exceptions:

GramVector is empty:

domain_error(minimum_number_of_values(1),GramVector)

`outer_product/3`

Computes the outer product of two numeric vectors.

Compilation flags:

static

Template:

outer_product(Vector1,Vector2,Matrix)

Mode and number of proofs:

outer_product(+list(number),+list(number),-list(list(number))) - one

`add_matrices/3`

Adds two numeric matrices element-wise.

Compilation flags:

static

Template:

add_matrices(Matrix1,Matrix2,Matrix)

Mode and number of proofs:

add_matrices(+list(list(number)),+list(list(number)),-list(list(number))) - one

`subtract_matrices/3`

Subtracts the second numeric matrix from the first element-wise.

Compilation flags:

static

Template:

subtract_matrices(Matrix1,Matrix2,Matrix)

Mode and number of proofs:

subtract_matrices(+list(list(number)),+list(list(number)),-list(list(number))) - one

`scale_matrix/3`

Scales each element of a numeric matrix by the given factor.

Compilation flags:

static

Template:

scale_matrix(Matrix,Scale,ScaledMatrix)

Mode and number of proofs:

scale_matrix(+list(list(number)),+number,-list(list(number))) - one

`frobenius_norm/2`

Computes the Frobenius norm of a numeric matrix.

Compilation flags:

static

Template:

frobenius_norm(Matrix,Norm)

Mode and number of proofs:

frobenius_norm(+list(list(number)),-float) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`transpose_matrix/2`

Transposes a numeric matrix represented as a list of row lists.

Compilation flags:

static

Template:

transpose_matrix(Matrix,Transpose)

Mode and number of proofs:

transpose_matrix(+list(list(number)),-list(list(number))) - one

`vector_value/3`

Looks up a numeric vector element using a one-based index.

Compilation flags:

static

Template:

vector_value(Vector,Index,Value)

Mode and number of proofs:

vector_value(+list(number),+integer,-number) - one

Exceptions:

Index is a variable:

instantiation_error

Index is neither a variable nor an integer:

type_error(integer,Index)

Index is an integer that is less than one:

domain_error(positive_integer,Index)

`matrix_row/3`

Looks up a numeric matrix row using a one-based row index.

Compilation flags:

static

Template:

matrix_row(Matrix,RowIndex,Row)

Mode and number of proofs:

matrix_row(+list(list(number)),+integer,-list(number)) - one

Exceptions:

RowIndex is a variable:

instantiation_error

RowIndex is neither a variable nor an integer:

type_error(integer,RowIndex)

RowIndex is an integer that is less than one:

domain_error(positive_integer,RowIndex)

`matrix_column/3`

Looks up a numeric matrix column using a one-based column index.

Compilation flags:

static

Template:

matrix_column(Matrix,ColumnIndex,Column)

Mode and number of proofs:

matrix_column(+list(list(number)),+integer,-list(number)) - one

Exceptions:

ColumnIndex is a variable:

instantiation_error

ColumnIndex is neither a variable nor an integer:

type_error(integer,ColumnIndex)

ColumnIndex is an integer that is less than one:

domain_error(positive_integer,ColumnIndex)

`matrix_value/4`

Looks up a numeric matrix element using one-based row and column indices.

Compilation flags:

static

Template:

matrix_value(Matrix,RowIndex,ColumnIndex,Value)

Mode and number of proofs:

matrix_value(+list(list(number)),+integer,+integer,-number) - one

Exceptions:

RowIndex is a variable:

instantiation_error

ColumnIndex is a variable:

instantiation_error

RowIndex is neither a variable nor an integer:

type_error(integer,RowIndex)

ColumnIndex is neither a variable nor an integer:

type_error(integer,ColumnIndex)

RowIndex is an integer that is less than one:

domain_error(positive_integer,RowIndex)

ColumnIndex is an integer that is less than one:

domain_error(positive_integer,ColumnIndex)

`matrix_diagonal/2`

Extracts the main diagonal of a numeric matrix as a vector.

Compilation flags:

static

Template:

matrix_diagonal(Matrix,Diagonal)

Mode and number of proofs:

matrix_diagonal(+list(list(number)),-list(number)) - one

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`matrix_diagonal/3`

Extracts the diagonal of a numeric matrix at the given offset, where positive offsets select superdiagonals and negative offsets select subdiagonals.

Compilation flags:

static

Template:

matrix_diagonal(Matrix,Offset,Diagonal)

Mode and number of proofs:

matrix_diagonal(+list(list(number)),+integer,-list(number)) - one_or_error

Exceptions:

Offset is a variable:

instantiation_error

Offset is neither a variable nor an integer:

type_error(integer,Offset)

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`diagonal_matrix/2`

Constructs a square diagonal matrix from a numeric vector of diagonal entries.

Compilation flags:

static

Template:

diagonal_matrix(Diagonal,Matrix)

Mode and number of proofs:

diagonal_matrix(+list(number),-list(list(number))) - one

`diagonal_matrix/3`

Constructs the minimal square numeric matrix whose diagonal at the given offset matches the input vector.

Compilation flags:

static

Template:

diagonal_matrix(Diagonal,Offset,Matrix)

Mode and number of proofs:

diagonal_matrix(+list(number),+integer,-list(list(number))) - one_or_error

Exceptions:

Offset is a variable:

instantiation_error

Offset is neither a variable nor an integer:

type_error(integer,Offset)

`diagonal_matrix/4`

Constructs a square numeric matrix of the requested size whose diagonal at the given offset matches the input vector.

Compilation flags:

static

Template:

diagonal_matrix(Diagonal,Offset,Size,Matrix)

Mode and number of proofs:

diagonal_matrix(+list(number),+integer,+integer,-list(list(number))) - one_or_error

Exceptions:

Offset is a variable:

instantiation_error

Offset is neither a variable nor an integer:

type_error(integer,Offset)

Size is a variable:

instantiation_error

Size is neither a variable nor an integer:

type_error(integer,Size)

Size is an integer that is less than zero:

domain_error(non_negative_integer,Size)

Size is smaller than the minimum size required by Diagonal and Offset:

domain_error(minimum_matrix_size(A),Size)

`matrix_trace/2`

Computes the trace of a numeric matrix by summing its main diagonal entries.

Compilation flags:

static

Template:

matrix_trace(Matrix,Trace)

Mode and number of proofs:

matrix_trace(+list(list(number)),-number) - one

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`shift_matrix_diagonal/3`

Shifts the main diagonal of a numeric matrix by the given value.

Compilation flags:

static

Template:

shift_matrix_diagonal(Matrix,Shift,ShiftedMatrix)

Mode and number of proofs:

shift_matrix_diagonal(+list(list(number)),+number,-list(list(number))) - one

Exceptions:

Shift is a variable:

instantiation_error

Shift is neither a variable nor a number:

type_error(number,Shift)

`upper_triangular_part/2`

Returns the upper-triangular part of a numeric matrix including the main diagonal.

Compilation flags:

static

Template:

upper_triangular_part(Matrix,UpperTriangular)

Mode and number of proofs:

upper_triangular_part(+list(list(number)),-list(list(number))) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`upper_triangular_part/3`

Returns the upper-triangular part of a numeric matrix using the given diagonal offset, where positive offsets exclude leading diagonals and negative offsets include additional subdiagonals.

Compilation flags:

static

Template:

upper_triangular_part(Matrix,Offset,UpperTriangular)

Mode and number of proofs:

upper_triangular_part(+list(list(number)),+integer,-list(list(number))) - one_or_error

Exceptions:

Offset is a variable:

instantiation_error

Offset is neither a variable nor an integer:

type_error(integer,Offset)

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`lower_triangular_part/2`

Returns the lower-triangular part of a numeric matrix including the main diagonal.

Compilation flags:

static

Template:

lower_triangular_part(Matrix,LowerTriangular)

Mode and number of proofs:

lower_triangular_part(+list(list(number)),-list(list(number))) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

Returns the lower-triangular part of a numeric matrix using the given diagonal offset, where positive offsets include additional superdiagonals and negative offsets exclude leading diagonals below the main diagonal.

Compilation flags:

static

Template:

lower_triangular_part(Matrix,Offset,LowerTriangular)

Mode and number of proofs:

lower_triangular_part(+list(list(number)),+integer,-list(list(number))) - one_or_error

Exceptions:

Offset is a variable:

instantiation_error

Offset is neither a variable nor an integer:

type_error(integer,Offset)

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`solve_linear_system/3`

Solves a non-singular square numeric linear system with a vector right-hand side using pivoted elimination.

Compilation flags:

static

Template:

solve_linear_system(Matrix,Values,Solution)

Mode and number of proofs:

solve_linear_system(+list(list(number)),+list(number),-list(float)) - one_or_error

Exceptions:

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

Values does not have the same length as the size of Matrix:

domain_error(vector_length(A),Values)

Matrix is singular:

evaluation_error(zero_divisor)

`solve_linear_systems/3`

Solves a non-singular square numeric linear system with a matrix right-hand side using pivoted elimination.

Compilation flags:

static

Template:

solve_linear_systems(Matrix,RightHandSides,Solutions)

Mode and number of proofs:

solve_linear_systems(+list(list(number)),+list(list(number)),-list(list(float))) - one_or_error

Exceptions:

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

RightHandSides does not have the same number of rows as the size of Matrix:

domain_error(matrix_row_count(A),RightHandSides)

Matrix is singular:

evaluation_error(zero_divisor)

`determinant/2`

Computes the determinant of a square numeric matrix.

Compilation flags:

static

Template:

determinant(Matrix,Determinant)

Mode and number of proofs:

determinant(+list(list(number)),-number) - one_or_error

Exceptions:

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

`inverse_matrix/2`

Computes the inverse of a non-singular square numeric matrix by solving one linear system per identity column.

Compilation flags:

static

Template:

inverse_matrix(Matrix,Inverse)

Mode and number of proofs:

inverse_matrix(+list(list(number)),-list(list(float))) - one_or_error

Exceptions:

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

Matrix is singular:

evaluation_error(zero_divisor)

`qr_decomposition/3`

Computes a thin QR decomposition of a rectangular numeric matrix, returning orthogonal columns and an upper-trapezoidal factor.

Compilation flags:

static

Template:

qr_decomposition(Matrix,Orthogonal,UpperTriangular)

Mode and number of proofs:

qr_decomposition(+list(list(number)),-list(list(float)),-list(list(float))) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`least_squares/3`

Computes a least-squares solution for a rectangular numeric linear system using a pivoted orthogonal solve without forming normal equations.

Compilation flags:

static

Template:

least_squares(Matrix,Values,Solution)

Mode and number of proofs:

least_squares(+list(list(number)),+list(number),-list(float)) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

Values does not have the same length as the number of rows of Matrix:

domain_error(vector_length(A),Values)

`matrix_rank/2`

Estimates the rank of a numeric matrix using the default library numerical tolerance of 1.0e-12.

Compilation flags:

static

Template:

matrix_rank(Matrix,Rank)

Mode and number of proofs:

matrix_rank(+list(list(number)),-integer) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`matrix_rank/3`

Estimates the rank of a numeric matrix using the given non-negative numerical tolerance.

Compilation flags:

static

Template:

matrix_rank(Matrix,Tolerance,Rank)

Mode and number of proofs:

matrix_rank(+list(list(number)),+number,-integer) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`symmetric_eigen/3`

Computes an orthonormal eigendecomposition of a real symmetric dense matrix using the default library numerical tolerance of 1.0e-12.

Compilation flags:

static

Template:

symmetric_eigen(Matrix,Eigenvectors,Eigenvalues)

Mode and number of proofs:

symmetric_eigen(+list(list(number)),-list(list(float)),-list(float)) - one_or_error

Exceptions:

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

Matrix is not symmetric within the default numerical tolerance:

domain_error(symmetric_matrix,Matrix)

`symmetric_eigen/4`

Computes an orthonormal eigendecomposition of a real symmetric dense matrix using the given non-negative numerical tolerance.

Compilation flags:

static

Template:

symmetric_eigen(Matrix,Tolerance,Eigenvectors,Eigenvalues)

Mode and number of proofs:

symmetric_eigen(+list(list(number)),+number,-list(list(float)),-list(float)) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

Matrix is not symmetric within Tolerance:

domain_error(symmetric_matrix,Matrix)

`symmetric_eigen/5`

Computes an orthonormal eigendecomposition of a real symmetric dense matrix using the given non-negative numerical tolerance and positive iteration bound.

Compilation flags:

static

Template:

symmetric_eigen(Matrix,Tolerance,MaximumIterations,Eigenvectors,Eigenvalues)

Mode and number of proofs:

symmetric_eigen(+list(list(number)),+number,+integer,-list(list(float)),-list(float)) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

MaximumIterations is a variable:

instantiation_error

MaximumIterations is neither a variable nor an integer:

type_error(integer,MaximumIterations)

MaximumIterations is an integer that is less than one:

domain_error(positive_integer,MaximumIterations)

Matrix is not a square matrix:

domain_error(square_matrix,Matrix)

Matrix is not symmetric within Tolerance:

domain_error(symmetric_matrix,Matrix)

`pseudo_inverse/2`

Computes the Moore-Penrose pseudo-inverse of a rectangular numeric matrix using the default library numerical tolerance of 1.0e-12.

Compilation flags:

static

Template:

pseudo_inverse(Matrix,PseudoInverse)

Mode and number of proofs:

pseudo_inverse(+list(list(number)),-list(list(float))) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`pseudo_inverse/3`

Computes the Moore-Penrose pseudo-inverse of a rectangular numeric matrix using the given non-negative numerical tolerance.

Compilation flags:

static

Template:

pseudo_inverse(Matrix,Tolerance,PseudoInverse)

Mode and number of proofs:

pseudo_inverse(+list(list(number)),+number,-list(list(float))) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`null_space/2`

Computes an orthonormal basis for the right null space of a rectangular numeric matrix using the default library numerical tolerance of 1.0e-12.

Compilation flags:

static

Template:

null_space(Matrix,Basis)

Mode and number of proofs:

null_space(+list(list(number)),-list(list(float))) - one_or_error

Exceptions:

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`null_space/3`

Computes an orthonormal basis for the right null space of a rectangular numeric matrix using the given non-negative numerical tolerance.

Compilation flags:

static

Template:

null_space(Matrix,Tolerance,Basis)

Mode and number of proofs:

null_space(+list(list(number)),+number,-list(list(float))) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

Matrix is not a rectangular matrix:

domain_error(rectangular_matrix,Matrix)

`normalize_vector/2`

Normalizes a numeric vector to unit length when its norm is above the default library numerical tolerance of 1.0e-12.

Compilation flags:

static

Template:

normalize_vector(Vector,NormalizedVector)

Mode and number of proofs:

normalize_vector(+list(number),-list(number)) - one

`normalize_vector/3`

Normalizes a numeric vector to unit length when its norm is above the given non-negative numerical tolerance.

Compilation flags:

static

Template:

normalize_vector(Vector,Tolerance,NormalizedVector)

Mode and number of proofs:

normalize_vector(+list(number),+number,-list(number)) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

`difference_norm/3`

Computes the Euclidean norm of the difference between two numeric vectors.

Compilation flags:

static

Template:

difference_norm(Vector1,Vector2,Norm)

Mode and number of proofs:

difference_norm(+list(number),+list(number),-float) - one

`stabilize_vector_sign/2`

Normalizes a vector sign convention by flipping vectors whose first significant component is negative.

Compilation flags:

static

Template:

stabilize_vector_sign(Vector,StableVector)

Mode and number of proofs:

stabilize_vector_sign(+list(number),-list(number)) - one

`stabilize_vector_sign/3`

Normalizes a vector sign convention by flipping vectors whose first significant component under the given non-negative numerical tolerance is negative.

Compilation flags:

static

Template:

stabilize_vector_sign(Vector,Tolerance,StableVector)

Mode and number of proofs:

stabilize_vector_sign(+list(number),+number,-list(number)) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

`first_significant_component/2`

Returns the first component whose absolute value exceeds the default library numerical tolerance of 1.0e-12, defaulting to zero when no such component exists.

Compilation flags:

static

Template:

first_significant_component(Vector,First)

Mode and number of proofs:

first_significant_component(+list(number),-number) - one

`first_significant_component/3`

Returns the first component whose absolute value exceeds the given non-negative numerical tolerance, defaulting to zero when no such component exists.

Compilation flags:

static

Template:

first_significant_component(Vector,Tolerance,First)

Mode and number of proofs:

first_significant_component(+list(number),+number,-number) - one_or_error

Exceptions:

Tolerance is a variable:

instantiation_error

Tolerance is neither a variable nor a number:

type_error(number,Tolerance)

Tolerance is a number but not a non-negative number:

domain_error(non_negative_number,Tolerance)

`add_scaled_outer_product/4`

Adds a scaled outer product of a vector with itself to an accumulated matrix.

Compilation flags:

static

Template:

add_scaled_outer_product(Vector,Scale,Matrix0,Matrix)

Mode and number of proofs:

add_scaled_outer_product(+list(number),+number,+list(list(number)),-list(list(number))) - one

Exceptions:

Scale is a variable:

instantiation_error

Scale is neither a variable nor a number:

type_error(number,Scale)

`covariance_matrix/2`

Computes the sample covariance matrix from a list of centered numeric row vectors.

Compilation flags:

static

Template:

covariance_matrix(Rows,CovarianceMatrix)

Mode and number of proofs:

covariance_matrix(+list(list(number)),-list(list(number))) - one_or_error

Exceptions:

Rows contains fewer than two rows:

domain_error(minimum_number_of_rows(2),Rows)

`cholesky_decomposition/2`

Computes the lower-triangular Cholesky factor of a positive definite numeric matrix.

Compilation flags:

static

Template:

cholesky_decomposition(Matrix,CholeskyFactor)

Mode and number of proofs:

cholesky_decomposition(+list(list(number)),-list(list(float))) - one_or_error

Exceptions:

Matrix is not numerically positive definite:

domain_error(positive_definite_matrix,Matrix)

`solve_cholesky/3`

Solves a positive definite linear system from a lower-triangular Cholesky factor and a right-hand-side vector.

Compilation flags:

static

Template:

solve_cholesky(CholeskyFactor,Values,Solution)

Mode and number of proofs:

solve_cholesky(+list(list(number)),+list(number),-list(float)) - one

`forward_substitution/3`

Solves a lower-triangular system by forward substitution.

Compilation flags:

static

Template:

forward_substitution(LowerTriangular,Values,Solution)

Mode and number of proofs:

forward_substitution(+list(list(number)),+list(number),-list(float)) - one

`solve_lower_triangular_matrix/3`

Solves a lower-triangular system with a matrix right-hand side by forward substitution on each column.

Compilation flags:

static

Template:

solve_lower_triangular_matrix(LowerTriangular,Matrix,Solution)

Mode and number of proofs:

solve_lower_triangular_matrix(+list(list(number)),+list(list(number)),-list(list(float))) - one

`solve_upper_triangular/3`

Solves an upper-triangular system by backward substitution.

Compilation flags:

static

Template:

solve_upper_triangular(UpperTriangular,Values,Solution)

Mode and number of proofs:

solve_upper_triangular(+list(list(number)),+list(number),-list(float)) - one

`solve_upper_triangular_matrix/3`

Solves an upper-triangular system with a matrix right-hand side by backward substitution on each column.

Compilation flags:

static

Template:

solve_upper_triangular_matrix(UpperTriangular,Matrix,Solution)

Mode and number of proofs:

solve_upper_triangular_matrix(+list(list(number)),+list(list(number)),-list(list(float))) - one

`backward_substitution/3`

Solves the transposed upper-triangular system induced by a lower-triangular Cholesky factor using backward substitution.

Compilation flags:

static

Template:

backward_substitution(CholeskyFactor,Values,Solution)

Mode and number of proofs:

backward_substitution(+list(list(number)),+list(number),-list(float)) - one

`invert_from_cholesky/2`

Computes a matrix inverse from a Cholesky factor by solving one linear system per basis column.

Compilation flags:

static

Template:

invert_from_cholesky(CholeskyFactor,Inverse)

Mode and number of proofs:

invert_from_cholesky(+list(list(number)),-list(list(float))) - one

linear_algebra_protocol

`linear_algebra_protocol`