| Did you know ... | Search Documentation: |
 | Pack logtalk -- logtalk-3.100.1/docs/apis/_sources/linear_algebra_protocol_0.rst.txt |
- HOME
- DOWNLOAD
- DOCUMENTATION
- TUTORIALS
- Beginner▶
- Advanced▶
- Web applications▶
- Semantic web▶
- Graphics▶
- Machine learning▶
- External collections▶
- For packagers▶
- COMMUNITY
- COMMERCIAL
- WIKI
.. index:: single: linear_algebra_protocol .. _linear_algebra_protocol/0:
.. rst-class:: right
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)
.. contents:: :local: :backlinks: top
Public predicates
.. index:: new_vector/3 .. _linear_algebra_protocol/0::new_vector/3:
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)
.. index:: new_vector_like/2 .. _linear_algebra_protocol/0::new_vector_like/2:
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
.. index:: add_vectors/3 .. _linear_algebra_protocol/0::add_vectors/3:
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
.. index:: subtract_vectors/3 .. _linear_algebra_protocol/0::subtract_vectors/3:
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
.. index:: add_scaled_vector/4 .. _linear_algebra_protocol/0::add_scaled_vector/4:
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)
.. index:: scale_vector/3 .. _linear_algebra_protocol/0::scale_vector/3:
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)
.. index:: dot_product/3 .. _linear_algebra_protocol/0::dot_product/3:
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
.. index:: euclidean_norm/2 .. _linear_algebra_protocol/0::euclidean_norm/2:
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
.. index:: vector_norm/3 .. _linear_algebra_protocol/0::vector_norm/3:
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)
.. index:: basis_vector/3 .. _linear_algebra_protocol/0::basis_vector/3:
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)
.. index:: new_matrix/4 .. _linear_algebra_protocol/0::new_matrix/4:
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)
.. index:: identity_matrix/2 .. _linear_algebra_protocol/0::identity_matrix/2:
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)
.. index:: matrix_vector_product/3 .. _linear_algebra_protocol/0::matrix_vector_product/3:
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
.. index:: matrix_matrix_product/3 .. _linear_algebra_protocol/0::matrix_matrix_product/3:
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
.. index:: gram_matrix/2 .. _linear_algebra_protocol/0::gram_matrix/2:
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
.. index:: matrix_row_means/2 .. _linear_algebra_protocol/0::matrix_row_means/2:
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)
.. index:: matrix_column_means/2 .. _linear_algebra_protocol/0::matrix_column_means/2:
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
.. index:: center_gram_matrix/4 .. _linear_algebra_protocol/0::center_gram_matrix/4:
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)
.. index:: center_gram_vector/4 .. _linear_algebra_protocol/0::center_gram_vector/4:
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)
.. index:: outer_product/3 .. _linear_algebra_protocol/0::outer_product/3:
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
.. index:: add_matrices/3 .. _linear_algebra_protocol/0::add_matrices/3:
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
.. index:: subtract_matrices/3 .. _linear_algebra_protocol/0::subtract_matrices/3:
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
.. index:: scale_matrix/3 .. _linear_algebra_protocol/0::scale_matrix/3:
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
.. index:: frobenius_norm/2 .. _linear_algebra_protocol/0::frobenius_norm/2:
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)
.. index:: transpose_matrix/2 .. _linear_algebra_protocol/0::transpose_matrix/2:
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
.. index:: vector_value/3 .. _linear_algebra_protocol/0::vector_value/3:
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)
.. index:: matrix_row/3 .. _linear_algebra_protocol/0::matrix_row/3:
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)
.. index:: matrix_column/3 .. _linear_algebra_protocol/0::matrix_column/3:
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)
.. index:: matrix_value/4 .. _linear_algebra_protocol/0::matrix_value/4:
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)
.. index:: matrix_diagonal/2 .. _linear_algebra_protocol/0::matrix_diagonal/2:
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)
.. index:: matrix_diagonal/3 .. _linear_algebra_protocol/0::matrix_diagonal/3:
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)
.. index:: diagonal_matrix/2 .. _linear_algebra_protocol/0::diagonal_matrix/2:
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
.. index:: diagonal_matrix/3 .. _linear_algebra_protocol/0::diagonal_matrix/3:
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)
.. index:: diagonal_matrix/4 .. _linear_algebra_protocol/0::diagonal_matrix/4:
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)
.. index:: matrix_trace/2 .. _linear_algebra_protocol/0::matrix_trace/2:
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)
.. index:: shift_matrix_diagonal/3 .. _linear_algebra_protocol/0::shift_matrix_diagonal/3:
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)
.. index:: upper_triangular_part/2 .. _linear_algebra_protocol/0::upper_triangular_part/2:
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)
.. index:: upper_triangular_part/3 .. _linear_algebra_protocol/0::upper_triangular_part/3:
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)
.. index:: lower_triangular_part/2 .. _linear_algebra_protocol/0::lower_triangular_part/2:
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)
.. index:: lower_triangular_part/3 .. _linear_algebra_protocol/0::lower_triangular_part/3:
lower_triangular_part/3 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
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)
.. index:: solve_linear_system/3 .. _linear_algebra_protocol/0::solve_linear_system/3:
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)
.. index:: solve_linear_systems/3 .. _linear_algebra_protocol/0::solve_linear_systems/3:
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)
.. index:: determinant/2 .. _linear_algebra_protocol/0::determinant/2:
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)
.. index:: inverse_matrix/2 .. _linear_algebra_protocol/0::inverse_matrix/2:
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)
.. index:: qr_decomposition/3 .. _linear_algebra_protocol/0::qr_decomposition/3:
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)
.. index:: least_squares/3 .. _linear_algebra_protocol/0::least_squares/3:
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)
.. index:: matrix_rank/2 .. _linear_algebra_protocol/0::matrix_rank/2:
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)
.. index:: matrix_rank/3 .. _linear_algebra_protocol/0::matrix_rank/3:
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)
.. index:: symmetric_eigen/3 .. _linear_algebra_protocol/0::symmetric_eigen/3:
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)
.. index:: symmetric_eigen/4 .. _linear_algebra_protocol/0::symmetric_eigen/4:
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)
.. index:: symmetric_eigen/5 .. _linear_algebra_protocol/0::symmetric_eigen/5:
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)
.. index:: pseudo_inverse/2 .. _linear_algebra_protocol/0::pseudo_inverse/2:
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)
.. index:: pseudo_inverse/3 .. _linear_algebra_protocol/0::pseudo_inverse/3:
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)
.. index:: null_space/2 .. _linear_algebra_protocol/0::null_space/2:
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)
.. index:: null_space/3 .. _linear_algebra_protocol/0::null_space/3:
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)
.. index:: normalize_vector/2 .. _linear_algebra_protocol/0::normalize_vector/2:
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
.. index:: normalize_vector/3 .. _linear_algebra_protocol/0::normalize_vector/3:
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)
.. index:: difference_norm/3 .. _linear_algebra_protocol/0::difference_norm/3:
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
.. index:: stabilize_vector_sign/2 .. _linear_algebra_protocol/0::stabilize_vector_sign/2:
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
.. index:: stabilize_vector_sign/3 .. _linear_algebra_protocol/0::stabilize_vector_sign/3:
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)
.. index:: first_significant_component/2 .. _linear_algebra_protocol/0::first_significant_component/2:
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
.. index:: first_significant_component/3 .. _linear_algebra_protocol/0::first_significant_component/3:
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)
.. index:: add_scaled_outer_product/4 .. _linear_algebra_protocol/0::add_scaled_outer_product/4:
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)
.. index:: covariance_matrix/2 .. _linear_algebra_protocol/0::covariance_matrix/2:
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)
.. index:: cholesky_decomposition/2 .. _linear_algebra_protocol/0::cholesky_decomposition/2:
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)
.. index:: solve_cholesky/3 .. _linear_algebra_protocol/0::solve_cholesky/3:
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
.. index:: forward_substitution/3 .. _linear_algebra_protocol/0::forward_substitution/3:
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
.. index:: solve_lower_triangular_matrix/3 .. _linear_algebra_protocol/0::solve_lower_triangular_matrix/3:
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
.. index:: solve_upper_triangular/3 .. _linear_algebra_protocol/0::solve_upper_triangular/3:
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
.. index:: solve_upper_triangular_matrix/3 .. _linear_algebra_protocol/0::solve_upper_triangular_matrix/3:
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
.. index:: backward_substitution/3 .. _linear_algebra_protocol/0::backward_substitution/3:
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
.. index:: invert_from_cholesky/2 .. _linear_algebra_protocol/0::invert_from_cholesky/2:
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
Protected predicates
(none)
Private predicates
(none)
Operators
(none)