specialmatrices_diagonal Module


Uses

    • stdlib_linalg_constants

Used by


Interfaces

public interface Diagonal

This interface provides different methods to construct a Diagonal matrix. Only the diagonal elements of are being stored, i.e.

Syntax

  • Construct a Diagonal matrix filled with zeros:
   integer, parameter :: n = 100
   type(Diagonal) :: A

   A = Diagonal(n)
  • Construct a Diagonal matrix from a vector.
   integer, parameter :: n = 100
   real(dp), allocatable :: dv(:)
   type(Diagonal) :: A
   integer :: i

   dv = [(i, i=1, n)]; A = Diagonal(dv)
  • Construct a Diagonal matrix with constant diagonal element.
   integer, parameter :: n = 100
   real(dp), parameter :: d = 2.0_dp
   type(Diagonal) :: A

   A = Diagonal(d, n)
  • Construct a Diagonal matrix from a standard rank-2 array.
   integer, parameter :: n = 100
   real(dp) :: B(n, n)
   type(Diagonal) :: A

   call random_number(B); A = Diagonal(B)

Note

Only double precision is currently supported for this matrix type.

  • private pure module function construct(dv) result(A)

    Utility function to construct a Diagonal matrix from a rank-1 array.

    Arguments

    Type IntentOptional Attributes Name
    real(kind=dp), intent(in) :: dv(:)

    Diagonal elements of the matrix.

    Return Value type(Diagonal)

    Corresponding diagonal matrix.

  • private pure module function construct_constant(d, n) result(A)

    Utility function to construct a Diagonal matrix with constant diagonal element.

    Arguments

    Type IntentOptional Attributes Name
    real(kind=dp), intent(in) :: d

    Constant diagonal element of the matrix.
    integer(kind=ilp), intent(in) :: n

    Dimension of the matrix.

    Return Value type(Diagonal)

    Corresponding diagonal matrix.

  • private module function dense_to_diag(A) result(B)

    Utility function to construct a Diagonal matrix from a rank-2 array. The resulting matrix is constructed from the diagonal element of the input matrix, even if the latter is not diagonal.

    Arguments

    Type IntentOptional Attributes Name
    real(kind=dp), intent(in) :: A(:,:)

    Dense matrix from which to construct the Diagonal one.

    Return Value type(Diagonal)

    Corresponding diagonal matrix.

  • private pure module function initialize(n) result(A)

    Utility function to construct a Diagonal matrix filled with zeros.

    Arguments

    Type IntentOptional Attributes Name
    integer(kind=ilp), intent(in) :: n

    Dimension of the matrix.

    Return Value type(Diagonal)

    Corresponding diagonal matrix.

public interface dense

This interface provides methods to convert a Diagonal matrix to a regular rank-2 array.

Syntax

   B = dense(A)

Arguments

  • A : Matrix of Diagonal type. It is an intent(in) argument.

  • B : Rank-2 array representation of the matrix .

  • private module function dense_rdp(A) result(B)

    Convert a Diagonal matrix to a rank-2 array.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input diagonal matrix.

    Return Value real(kind=dp), allocatable, (:,:)

    Output dense rank-2 array.

public interface det

This interface overloads the det interface from stdlib_linag to compute the determinant where is of type Diagonal.

Syntax

   d = det(A)

Arguments

  • A : Matrix of Diagonal type. It is in an intent(in) argument.

  • d : Determinant of the matrix.

  • private pure module function det_rdp(A) result(d)

    Compute the determinant of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value real(kind=dp)

    Determinant of the matrix.

public interface eigh

This interface overloads the eigh interface from stdlib_linalg to compute the eigenvalues and eigenvectors of a real-valued matrix whose type is Diagonal.

Syntax

   call eigh(A, lambda [, vectors])

Arguments

  • A : real-valued matrix of Diagonal. It is an intent(in) argument.

  • lambda : Rank-1 real array returning the eigenvalues of A in increasing order. It is an intent(out) argument.

  • vectors (optional) : Rank-2 array of the same kind as A returning the eigenvectors of A. It is an intent(out) argument.

  • private module subroutine eigh_rdp(A, lambda, vectors)

    Utility function to compute the eigenvalues and eigenvectors of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.
    real(kind=dp), intent(out), allocatable :: lambda(:)

    Eigenvalues.
    real(kind=dp), intent(out), optional, allocatable :: vectors(:,:)

    Eigenvectors.

public interface eigvalsh

This interface overloads the eigvalsh interface from stdlib_linalg to compute the eigenvalues of a real-valued matrix whose type is Diagonal.

Syntax

   lambda = eigvalsh(A)

Arguments

  • A : real-valued matrix of Diagonal type. It is an intent(in) argument.

  • lambda : Vector of eigenvalues in increasing order.

  • private module function eigvalsh_rdp(A) result(lambda)

    Utility function to compute the eigenvalues of a real Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value real(kind=dp), allocatable, (:)

    Eigenvalues.

public interface inv

  • private pure module function inv_rdp(A) result(B)

    Utility function to compute the inverse of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value type(Diagonal)

    Inverse of A.

public interface matmul

This interface overloads the Fortran intrinsic matmul for a Diagonal matrix, both for matrix-vector and matrix-matrix products. For a matrix-matrix product , only the matrix has to be a Diagonal matrix. Both and need to be standard Fortran rank-2 arrays. All the underlying functions are defined as pure.

Syntax

   y = matmul(A, x)

  • private pure module function spmv(A, x) result(y)

    Compute the matrix-vector product for a Diagonal matrix . Both x and y are rank-1 arrays with the same kind as A.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.
    real(kind=dp), intent(in) :: x(:)

    Input vector.

    Return Value real(kind=dp), allocatable, (:)

    Output vector.

  • private pure module function spmvs(A, X) result(Y)

    Compute the matrix-matrix product for a Diagonal matrix and a dense matrix (rank-2 array). is also a rank-2 array with the same dimensions as .

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.
    real(kind=dp), intent(in) :: X(:,:)

    Input vectors.

    Return Value real(kind=dp), allocatable, (:,:)

    Output vectors.

public interface operator(*)

  • private pure module function scalar_multiplication_bis_rdp(A, alpha) result(B)

    Utility function to perform a scalar multiplication with a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A
    real(kind=dp), intent(in) :: alpha

    Return Value type(Diagonal)

  • private pure module function scalar_multiplication_rdp(alpha, A) result(B)

    Utility function to perform a scalar multiplication with a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    real(kind=dp), intent(in) :: alpha
    type(Diagonal), intent(in) :: A

    Return Value type(Diagonal)

public interface shape

  • private pure module function shape_rdp(A) result(arr_shape)

    Utility function to get the shape of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value integer(kind=ilp), (2)

    Shape of the matrix.

public interface size

  • private pure module function size_rdp(A, dim) result(arr_size)

    Utility function to return the size of Diagonal matrix along a given dimension.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.
    integer(kind=ilp), intent(in), optional :: dim

    Queried dimension.

    Return Value integer(kind=ilp)

    Size of the matrix along the dimension dim.

public interface solve

This interface overloads the solve interface from stdlib_linalg for solving a linear system where is a Diagonal matrix. It also enables to solve a linear system with multiple right-hand sides.

Syntax

   x = solve(A, b)

Arguments

  • A : Matrix of Diagonal type. It is an intent(in) argument.

  • b : Rank-1 or rank-2 array defining the right-hand side(s). It is an intent(in) argument.

  • x : Solution of the linear system. It has the same type and shape as b.

  • private pure module function solve_multi_rhs(A, B) result(X)

    Solve the linear system where is of type Diagonal and B a standard rank-2 array. The solution matrix X has the same dimensions and kind as the right-hand side matrix B.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Coefficient matrix.
    real(kind=dp), intent(in) :: B(:,:)

    Right-hand side vectors.

    Return Value real(kind=dp), allocatable, (:,:)

    Solution vectors.

  • private pure module function solve_single_rhs(A, b) result(x)

    Solve the linear system where is of type Diagonal and b a standard rank-1 array. The solution vector x has the same dimension and kind as the right-hand side vector b.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Coefficient matrix.
    real(kind=dp), intent(in) :: b(:)

    Right-hand side vector.

    Return Value real(kind=dp), allocatable, (:)

    Solution vector.

public interface svd

This interface overloads the svd interface from stdlib_linalg to compute the the singular value decomposition of a Diagonal matrix .

Syntax

   call svd(A, s [, u] [, vt])

Arguments

  • A : Matrix of Diagonal type. It is an intent(in) argument.

  • s : Rank-1 real array returning the singular values of A. It is an intent(out) argument.

  • u (optional) : Rank-2 array of the same kind as A returning the left singular vectors of A as columns. Its size should be [n, n]. It is an intent(out) argument.

  • vt (optional) : Rank-2 array of the same kind as A returning the right singular vectors of A as rows. Its size should be [n, n]. It is an intent(out) argument.

  • private module subroutine svd_rdp(A, u, s, vt)

    Compute the singular value decomposition of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.
    real(kind=dp), intent(out), optional, allocatable :: u(:,:)

    Left singular vectors as columns.
    real(kind=dp), intent(out), allocatable :: s(:)

    Singular values in descending order.
    real(kind=dp), intent(out), optional, allocatable :: vt(:,:)

    Right singular vectors as rows.

public interface svdvals

This interface overloads the svdvals interface from stdlib_linalg to compute the singular values of a Diagonal matrix .

Syntax

   s = svdvals(A)

Arguments

  • A : Matrix of Diagonal type. It is an intent(in) argument.

  • s : Vector of singular values sorted in decreasing order.

  • private pure module function svdvals_rdp(A) result(s)

    Compute the singular values of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value real(kind=dp), allocatable, (:)

    Singular values in descending order.

public interface trace

This interface overloads the trace interface from stdlib_linalg to compute the trace of a matrix of type Diagonal.

Syntax

   tr = trace(A)

Arguments

  • A : Matrix of Diagonal type. It is an intent(in) argument.

  • tr: Trace of the matrix.

  • private pure module function trace_rdp(A) result(tr)

    Compute the trace of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value real(kind=dp)

    Trace of the matrix.

public interface transpose

This interface overloads the Fortran intrinsic procedure to define the transpose operation for a Diagonal matrix.

Syntax

   B = transpose(A)

Arguments

  • A : Matrix of Diagonal type. It is an intent(in) argument.

  • B : Resulting transposed matrix. It is of the same type as A.

  • private pure module function transpose_rdp(A) result(B)

    Utility function to compute the transpose of a Diagonal matrix.

    Arguments

    Type IntentOptional Attributes Name
    type(Diagonal), intent(in) :: A

    Input matrix.

    Return Value type(Diagonal)

    Transpose of the matrix.


Derived Types

type, public ::  Diagonal

Base type used to define a Diagonal matrix of size [n x n] with diagonal elements given by the rank-1 array dv.

Constructor

This interface provides different methods to construct a Diagonal matrix. Only the diagonal elements of are being stored, i.e.

Read more…
private pure, module function construct (dv)

Utility function to construct a Diagonal matrix from a rank-1 array.
private pure, module function construct_constant (d, n)

Utility function to construct a Diagonal matrix with constant diagonal element.
private module function dense_to_diag (A)

Utility function to construct a Diagonal matrix from a rank-2 array. The resulting matrix is constructed from the diagonal element of the input matrix, even if the latter is not diagonal.
private pure, module function initialize (n)

Utility function to construct a Diagonal matrix filled with zeros.