It provides a lot of subroutines to manipulate the matrix and implement the linear algebra.

Type

subroutines

Source

src/s_matrix.f90

Naming Convention

Usage

Matrix Construction

subroutine s_zeros_i(n, A)
subroutine s_zeros_d(n, A)
subroutine s_zeros_z(n, A)

Purpose:

Build a matrix with all elements set to zero.

Arguments:

subroutine s_ones_i(n, A)
subroutine s_ones_d(n, A)
subroutine s_ones_z(n, A)

Purpose:

Build a matrix with all elements set to one.

Arguments:

subroutine s_any_i(n, i, A)
subroutine s_any_d(n, d, A)
subroutine s_any_z(n, z, A)

Purpose:

Build a matrix with all elements set to a specified value.

Arguments:

subroutine s_eye_i(n, k, A)
subroutine s_eye_d(n, k, A)
subroutine s_eye_z(n, k, A)

Purpose:

Build a matrix with ones on the specified diagonal and zeros elsewhere.

Arguments:

subroutine s_identity_i(n, A)
subroutine s_identity_d(n, A)
subroutine s_identity_z(n, A)

Purpose:

Build an identity matrix (ones on the main diagonal, zeros elsewhere).

Arguments:

subroutine s_diag_i(n, v, A)
subroutine s_diag_d(n, v, A)
subroutine s_diag_z(n, v, A)

Purpose:

Build a diagonal matrix from a vector, placing the vector elements on the main diagonal.

Arguments:

Matrix Query

subroutine s_trace_d(n, A, tr)
subroutine s_trace_z(n, A, tr)

Purpose:

Calculate the trace (sum of diagonal elements) of a matrix.

Arguments:

subroutine s_det_d(ndim, dmat, ddet)
subroutine s_det_z(ndim, zmat, zdet)

Purpose:

Calculate the determinant of a matrix using LU factorization.

Arguments:

subroutine s_cond_d(n, A, cond, norm_type)
subroutine s_cond_z(n, A, cond, norm_type)

Purpose:

Estimate the condition number of a matrix using LAPACK.

Arguments:

subroutine s_rank_d(m, n, A, rank, tol)
subroutine s_rank_z(m, n, A, rank, tol)

Purpose:

Estimate the rank of a matrix using SVD. Returns the number of singular values greater than the tolerance threshold.

Arguments:

subroutine s_sparsity_ratio_i(n, A, ratio)
subroutine s_sparsity_ratio_d(n, A, ratio)
subroutine s_sparsity_ratio_z(n, A, ratio)

Purpose:

Calculate the sparsity ratio (ratio of zero elements) of a matrix.

Arguments:

Matrix Manipulation

subroutine s_inv_d(ndim, dmat)
subroutine s_inv_z(ndim, zmat)

Purpose:

Invert a matrix using LAPACK (LU factorization).

Arguments:

subroutine s_pinv_d(m, n, A, pinv, tol)
subroutine s_pinv_z(m, n, A, pinv, tol)

Purpose:

Compute the Moore-Penrose pseudo-inverse of a general matrix using SVD decomposition: pinv(A) = V * Σ⁺ * U^T (or U^H for complex).

Arguments:

Eigenvalue Problems

subroutine s_eig_dg(ldim, ndim, amat, eval, evec)
subroutine s_eig_zg(ldim, ndim, zmat, zeig, zvec)

Purpose:

Compute all eigenvalues and eigenvectors of a general matrix.

Arguments:

subroutine s_eigvals_dg(ldim, ndim, amat, eval)
subroutine s_eigvals_zg(ldim, ndim, zmat, zeig)

Purpose:

Compute only eigenvalues of a general matrix (no eigenvectors).

Arguments:

subroutine s_eig_sy(ldim, ndim, amat, eval, evec)
subroutine s_eig_he(ldim, ndim, amat, eval, evec)

Purpose:

Compute all eigenvalues and eigenvectors of a symmetric/Hermitian matrix.

Arguments:

subroutine s_eigvals_sy(ldim, ndim, amat, eval)
subroutine s_eigvals_he(ldim, ndim, amat, eval)

Purpose:

Compute only eigenvalues of a symmetric/Hermitian matrix (no eigenvectors).

Arguments:

subroutine s_geig_sy(ldim, n, A, B, eval, evec)
subroutine s_geig_he(ldim, n, A, B, eval, evec)

Purpose:

Solve the generalized eigenvalue problem A*x = λ*B*x, where A and B are symmetric/Hermitian matrices.

Arguments:

Linear Equation Solver

subroutine s_solve_dg(n, nrhs, A, B)
subroutine s_solve_zg(n, nrhs, A, B)
subroutine s_solve_sy(n, nrhs, A, B)
subroutine s_solve_he(n, nrhs, A, B)

Purpose:

Solve a linear system AX = B. On exit, B is overwritten by the solution matrix X.

Arguments:

Matrix Decomposition

subroutine s_svd_dg(m, n, min_mn, amat, umat, svec, vmat)
subroutine s_svd_zg(m, n, min_mn, amat, umat, svec, vmat)

Purpose:

Perform the singular value decomposition for a general m-by-n matrix A, where A = U * Σ * V^T (or V^H for complex).

Arguments:

subroutine s_qr_d(m, n, min_mn, amat, qmat, rmat)
subroutine s_qr_z(m, n, min_mn, amat, qmat, rmat)

Purpose:

Perform QR decomposition for a general m-by-n matrix A, where A = Q * R.

Arguments:

subroutine s_cholesky_d(n, A, L)
subroutine s_cholesky_z(n, A, L)

Purpose:

Perform Cholesky decomposition for a symmetric/Hermitian positive-definite matrix A, where A = L * L^T (or L * L^H).

Arguments:

subroutine s_lu_d(n, A, L, U, ipiv)
subroutine s_lu_z(n, A, L, U, ipiv)

Purpose:

Perform LU decomposition for a general matrix A, where A = P * L * U.

Arguments:

subroutine s_schur_d(ldim, n, A, T, Q)
subroutine s_schur_z(ldim, n, A, T, Q)

Purpose:

Perform Schur decomposition for a general matrix A, where A = Q * T * Q^T (or Q * T * Q^H).

Arguments:

Matrix Property Checking

subroutine s_is_symmetric_d(n, A, is_symmetric, tol)

Purpose:

Check if a real matrix is symmetric (A = A^T).

Arguments:

subroutine s_is_hermitian_z(n, A, is_hermitian, tol)

Purpose:

Check if a complex matrix is Hermitian (A = A^H).

Arguments:

subroutine s_is_skew_symmetric_d(n, A, is_skew_symmetric, tol)

Purpose:

Check if a real matrix is skew-symmetric (A = -A^T).

Arguments:

subroutine s_is_skew_hermitian_z(n, A, is_skew_hermitian, tol)

Purpose:

Check if a complex matrix is skew-Hermitian (A = -A^H).

Arguments:

subroutine s_is_diagonal_d(n, A, is_diagonal, tol)
subroutine s_is_diagonal_z(n, A, is_diagonal, tol)

Purpose:

Check if a matrix is diagonal (all off-diagonal elements are zero).

Arguments:

subroutine s_is_tridiagonal_d(n, A, is_tridiagonal, tol)
subroutine s_is_tridiagonal_z(n, A, is_tridiagonal, tol)

Purpose:

Check if a matrix is tridiagonal (only main diagonal and adjacent diagonals can be non-zero).

Arguments:

subroutine s_is_positive_definite_d(n, A, is_positive_definite)
subroutine s_is_positive_definite_z(n, A, is_positive_definite)

Purpose:

Check if a symmetric/Hermitian matrix is positive-definite using Cholesky decomposition.

Arguments:

subroutine s_is_positive_semidefinite_d(ldim, n, A, is_positive_semidefinite, tol)
subroutine s_is_positive_semidefinite_z(ldim, n, A, is_positive_semidefinite, tol)

Purpose:

Check if a symmetric/Hermitian matrix is positive-semidefinite (all eigenvalues ≥ 0).

Arguments:

subroutine s_is_upper_triangular_d(n, A, is_upper_triangular, tol)
subroutine s_is_upper_triangular_z(n, A, is_upper_triangular, tol)

Purpose:

Check if a matrix is upper triangular (all elements below main diagonal are zero).

Arguments:

subroutine s_is_lower_triangular_d(n, A, is_lower_triangular, tol)
subroutine s_is_lower_triangular_z(n, A, is_lower_triangular, tol)

Purpose:

Check if a matrix is lower triangular (all elements above main diagonal are zero).

Arguments:

subroutine s_is_singular_d(n, A, is_singular)
subroutine s_is_singular_z(n, A, is_singular)

Purpose:

Check if a matrix is singular (determinant is zero) using LU factorization.

Arguments:

subroutine s_is_orthogonal_d(n, Q, is_orthogonal, tol)

Purpose:

Check if a real matrix is orthogonal (Q^T * Q = I).

Arguments:

subroutine s_is_unitary_z(n, Q, is_unitary, tol)

Purpose:

Check if a complex matrix is unitary (Q^H * Q = I).

Arguments:

subroutine s_is_normal_d(n, A, is_normal, tol)
subroutine s_is_normal_z(n, A, is_normal, tol)

Purpose:

Check if a matrix is normal (A^T * A = A * A^T or A^H * A = A * A^H).

Arguments:

Matrix Extraction and Concatenation

subroutine s_extract_submatrix_d(m_src, n_src, A_src, i_start, j_start, m_sub, n_sub, A_sub)
subroutine s_extract_submatrix_z(m_src, n_src, A_src, i_start, j_start, m_sub, n_sub, A_sub)

Purpose:

Extract a submatrix from a source matrix.

Arguments:

subroutine s_concat_horiz_d(m_A, n_A, A, m_B, n_B, B, m_C, n_C, C)
subroutine s_concat_horiz_z(m_A, n_A, A, m_B, n_B, B, m_C, n_C, C)

Purpose:

Concatenate two matrices horizontally: C = [A | B]. Matrices A and B must have the same number of rows.

Arguments:

subroutine s_concat_vert_d(m_A, n_A, A, m_B, n_B, B, m_C, n_C, C)
subroutine s_concat_vert_z(m_A, n_A, A, m_B, n_B, B, m_C, n_C, C)

Purpose:

Concatenate two matrices vertically: C = [A; B]. Matrices A and B must have the same number of columns.

Arguments:

Special Matrix Construction

subroutine s_upper_triangular_d(n, A)
subroutine s_upper_triangular_z(n, A)

Purpose:

Construct an upper triangular matrix by setting all elements below the main diagonal to zero.

Arguments:

subroutine s_lower_triangular_d(n, A)
subroutine s_lower_triangular_z(n, A)

Purpose:

Construct a lower triangular matrix by setting all elements above the main diagonal to zero.

Arguments:

subroutine s_tridiagonal_d(n, A)
subroutine s_tridiagonal_z(n, A)

Purpose:

Construct a tridiagonal matrix by setting all elements except main diagonal, super-diagonal, and sub-diagonal to zero.

Arguments:

subroutine s_hilbert_d(n, A)

Purpose:

Build a Hilbert matrix with elements H(i,j) = 1 / (i + j - 1).

Arguments:

subroutine s_vandermonde_d(n, x, A)
subroutine s_vandermonde_z(n, x, A)

Purpose:

Build a Vandermonde matrix with elements V(i,j) = x_i^(j-1).

Arguments:

subroutine s_pascal_d(n, A)

Purpose:

Build a Pascal matrix with elements P(i,j) = C(i+j-2, j-1).

Arguments:

subroutine s_wilkinson_d(n, A)

Purpose:

Build a Wilkinson's W+ matrix. Main diagonal: W(i,i) = n/2 + 1 - i, super/sub-diagonal elements equal to 1.

Arguments:

Random Matrix Construction

subroutine s_sparse_random_d(n, sparsity, A)
subroutine s_sparse_random_z(n, sparsity, A)

Purpose:

Build a sparse random matrix. The sparsity parameter controls the fraction of non-zero elements (0-1). Uses Fisher-Yates shuffle to guarantee exactly nnz = int(n*n*sparsity) non-zero elements.

Arguments:

subroutine s_random_symmetric_d(n, A)

Purpose:

Build a random symmetric matrix A = B + B^T, where B is random.

Arguments:

subroutine s_random_hermitian_z(n, A)

Purpose:

Build a random Hermitian matrix A = B + B^H, where B is random complex.

Arguments:

subroutine s_random_positive_definite_d(n, A)
subroutine s_random_positive_definite_z(n, A)

Purpose:

Build a random positive-definite matrix A = B * B^T + I (or B * B^H + I for complex), where B is random.

Arguments: