Functions/Subroutines | |
| pure real(sp) function, public | la_sasum (n, sx, incx) |
| SASUM: takes the sum of the absolute values. uses unrolled loops for increment equal to one. | |
| pure subroutine, public | la_saxpy (n, sa, sx, incx, sy, incy) |
| SAXPY: constant times a vector plus a vector. uses unrolled loops for increments equal to one. | |
| pure real(sp) function, public | la_scasum (n, cx, incx) |
| SCASUM: takes the sum of the (|Re(.)| + |Im(.)|)'s of a complex vector and returns a single precision result. | |
| pure real(sp) function, public | la_scnrm2 (n, x, incx) |
| ! | |
| pure subroutine, public | la_scopy (n, sx, incx, sy, incy) |
| SCOPY: copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1. | |
| pure real(sp) function, public | la_sdot (n, sx, incx, sy, incy) |
| SDOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one. | |
| pure real(sp) function, public | la_sdsdot (n, sb, sx, incx, sy, incy) |
| Compute the inner product of two vectors with extended precision accumulation. Returns S.P. result with dot product accumulated in D.P. SDSDOT: = SB + sum for I = 0 to N-1 of SX(LX+I*INCX)*SY(LY+I*INCY), where LX = 1 if INCX >= 0, else LX = 1+(1-N)*INCX, and LY is defined in a similar way using INCY. | |
| pure subroutine, public | la_sgbmv (trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) |
| SGBMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n band matrix, with kl sub-diagonals and ku super-diagonals. | |
| pure subroutine, public | la_sgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| SGEMM: performs one of the matrix-matrix operations C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of op( X ) = X or op( X ) = X**T, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix. | |
| pure subroutine, public | la_sgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| SGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix. | |
| pure subroutine, public | la_sger (m, n, alpha, x, incx, y, incy, a, lda) |
| SGER: performs the rank 1 operation A := alpha*x*y**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix. | |
| pure real(sp) function, public | la_snrm2 (n, x, incx) |
| ! | |
| pure subroutine, public | la_srot (n, sx, incx, sy, incy, c, s) |
| applies a plane rotation. | |
| pure subroutine, public | la_srotg (a, b, c, s) |
| ! | |
| pure subroutine, public | la_srotm (n, sx, incx, sy, incy, sparam) |
| APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX (SX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF SX ARE IN (SX**T) SX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX >= 0, ELSE LX = (-INCX)*N, AND SIMILARLY FOR SY USING USING LY AND INCY. WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS.. SFLAG=-1._sp SFLAG=0._sp SFLAG=1._sp SFLAG=-2.E0 (SH11 SH12) (1._sp SH12) (SH11 1._sp) (1._sp 0._sp) H=( ) ( ) ( ) ( ) (SH21 SH22), (SH21 1._sp), (-1._sp SH22), (0._sp 1._sp). SEE SROTMG FOR A DESCRIPTION OF DATA STORAGE IN SPARAM. | |
| pure subroutine, public | la_srotmg (sd1, sd2, sx1, sy1, sparam) |
| CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS THE SECOND COMPONENT OF THE 2-VECTOR (SQRT(SD1)*SX1,SQRT(SD2) SY2)**T. WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS.. SFLAG=-1._sp SFLAG=0._sp SFLAG=1._sp SFLAG=-2.E0 (SH11 SH12) (1._sp SH12) (SH11 1._sp) (1._sp 0._sp) H=( ) ( ) ( ) ( ) (SH21 SH22), (SH21 1._sp), (-1._sp SH22), (0._sp 1._sp). LOCATIONS 2-4 OF SPARAM CONTAIN SH11,SH21,SH12, AND SH22 RESPECTIVELY. (VALUES OF 1._sp, -1._sp, OR 0._sp IMPLIED BY THE VALUE OF SPARAM(1) ARE NOT STORED IN SPARAM.) THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE INEXACT. THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE OF SD1 AND SD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM. | |
| pure subroutine, public | la_ssbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) |
| SSBMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric band matrix, with k super-diagonals. | |
| pure subroutine, public | la_sscal (n, sa, sx, incx) |
| SSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1. | |
| pure subroutine, public | la_sspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| SSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_sspr (uplo, n, alpha, x, incx, ap) |
| SSPR: performs the symmetric rank 1 operation A := alpha*x*x**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_sspr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| SSPR2: performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form. | |
| pure subroutine, public | la_sswap (n, sx, incx, sy, incy) |
| SSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1. | |
| pure subroutine, public | la_ssymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| SSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices. | |
| pure subroutine, public | la_ssymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| SSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_ssyr (uplo, n, alpha, x, incx, a, lda) |
| SSYR: performs the symmetric rank 1 operation A := alpha*x*x**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_ssyr2 (uplo, n, alpha, x, incx, y, incy, a, lda) |
| SSYR2: performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix. | |
| pure subroutine, public | la_ssyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| SSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case. | |
| pure subroutine, public | la_ssyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| SSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case. | |
| pure subroutine, public | la_stbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| STBMV: performs one of the matrix-vector operations x := A*x, or x := A**T*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals. | |
| pure subroutine, public | la_stbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| STBSV: solves one of the systems of equations A*x = b, or A**T*x = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine. | |
| pure subroutine, public | la_stpmv (uplo, trans, diag, n, ap, x, incx) |
| STPMV: performs one of the matrix-vector operations x := A*x, or x := A**T*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form. | |
| pure subroutine, public | la_stpsv (uplo, trans, diag, n, ap, x, incx) |
| STPSV: solves one of the systems of equations A*x = b, or A**T*x = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine. | |
| pure subroutine, public | la_strmm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) |
| STRMM: performs one of the matrix-matrix operations B := alpha*op( A )*B, or B := alpha*B*op( A ), where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. | |
| pure subroutine, public | la_strmv (uplo, trans, diag, n, a, lda, x, incx) |
| STRMV: performs one of the matrix-vector operations x := A*x, or x := A**T*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix. | |
| pure subroutine, public | la_strsm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) |
| STRSM: solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. The matrix X is overwritten on B. | |
| pure subroutine, public | la_strsv (uplo, trans, diag, n, a, lda, x, incx) |
| STRSV: solves one of the systems of equations A*x = b, or A**T*x = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine. | |
Function/Subroutine Documentation
◆ la_sasum()
| pure real(sp) function, public la_blas_s::la_sasum | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(in) | sx, | ||
| integer(ilp), intent(in) | incx ) |
SASUM: takes the sum of the absolute values. uses unrolled loops for increment equal to one.
◆ la_saxpy()
| pure subroutine, public la_blas_s::la_saxpy | ( | integer(ilp), intent(in) | n, |
| real(sp), intent(in) | sa, | ||
| real(sp), dimension(*), intent(in) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | sy, | ||
| integer(ilp), intent(in) | incy ) |
SAXPY: constant times a vector plus a vector. uses unrolled loops for increments equal to one.
◆ la_scasum()
| pure real(sp) function, public la_blas_s::la_scasum | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(in) | cx, | ||
| integer(ilp), intent(in) | incx ) |
SCASUM: takes the sum of the (|Re(.)| + |Im(.)|)'s of a complex vector and returns a single precision result.
◆ la_scnrm2()
| pure real(sp) function, public la_blas_s::la_scnrm2 | ( | integer(ilp), intent(in) | n, |
| complex(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx ) |
!
SCNRM2: returns the euclidean norm of a vector via the function name, so that SCNRM2 := sqrt( x**H*x )
◆ la_scopy()
| pure subroutine, public la_blas_s::la_scopy | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(in) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(out) | sy, | ||
| integer(ilp), intent(in) | incy ) |
SCOPY: copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1.
◆ la_sdot()
| pure real(sp) function, public la_blas_s::la_sdot | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(in) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(in) | sy, | ||
| integer(ilp), intent(in) | incy ) |
SDOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one.
◆ la_sdsdot()
| pure real(sp) function, public la_blas_s::la_sdsdot | ( | integer(ilp), intent(in) | n, |
| real(sp), intent(in) | sb, | ||
| real(sp), dimension(*), intent(in) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(in) | sy, | ||
| integer(ilp), intent(in) | incy ) |
Compute the inner product of two vectors with extended precision accumulation. Returns S.P. result with dot product accumulated in D.P. SDSDOT: = SB + sum for I = 0 to N-1 of SX(LX+I*INCX)*SY(LY+I*INCY), where LX = 1 if INCX >= 0, else LX = 1+(1-N)*INCX, and LY is defined in a similar way using INCY.
◆ la_sgbmv()
| pure subroutine, public la_blas_s::la_sgbmv | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | kl, | ||
| integer(ilp), intent(in) | ku, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SGBMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n band matrix, with kl sub-diagonals and ku super-diagonals.
◆ la_sgemm()
| pure subroutine, public la_blas_s::la_sgemm | ( | character, intent(in) | transa, |
| character, intent(in) | transb, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SGEMM: performs one of the matrix-matrix operations C := alpha*op( A )*op( B ) + beta*C, where op( X ) is one of op( X ) = X or op( X ) = X**T, alpha and beta are scalars, and A, B and C are matrices, with op( A ) an m by k matrix, op( B ) a k by n matrix and C an m by n matrix.
◆ la_sgemv()
| pure subroutine, public la_blas_s::la_sgemv | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
◆ la_sger()
| pure subroutine, public la_blas_s::la_sger | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
SGER: performs the rank 1 operation A := alpha*x*y**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.
◆ la_snrm2()
| pure real(sp) function, public la_blas_s::la_snrm2 | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx ) |
!
SNRM2: returns the euclidean norm of a vector via the function name, so that SNRM2 := sqrt( x'*x ).
◆ la_srot()
| pure subroutine, public la_blas_s::la_srot | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | sy, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), intent(in) | c, | ||
| real(sp), intent(in) | s ) |
applies a plane rotation.
◆ la_srotg()
| pure subroutine, public la_blas_s::la_srotg | ( | real(sp), intent(inout) | a, |
| real(sp), intent(inout) | b, | ||
| real(sp), intent(out) | c, | ||
| real(sp), intent(out) | s ) |
!
The computation uses the formulas sigma = sgn(a) if |a| > |b| = sgn(b) if |b| >= |a| r = sigma*sqrt( a**2 + b**2 ) c = 1; s = 0 if r = 0 c = a/r; s = b/r if r != 0 The subroutine also computes z = s if |a| > |b|, = 1/c if |b| >= |a| and c != 0 = 1 if c = 0 This allows c and s to be reconstructed from z as follows: If z = 1, set c = 0, s = 1. If |z| < 1, set c = sqrt(1 - z**2) and s = z. If |z| > 1, set c = 1/z and s = sqrt( 1 - c**2).
◆ la_srotm()
| pure subroutine, public la_blas_s::la_srotm | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | sy, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), dimension(5), intent(in) | sparam ) |
APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX (SX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF SX ARE IN (SX**T) SX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX >= 0, ELSE LX = (-INCX)*N, AND SIMILARLY FOR SY USING USING LY AND INCY. WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS.. SFLAG=-1._sp SFLAG=0._sp SFLAG=1._sp SFLAG=-2.E0 (SH11 SH12) (1._sp SH12) (SH11 1._sp) (1._sp 0._sp) H=( ) ( ) ( ) ( ) (SH21 SH22), (SH21 1._sp), (-1._sp SH22), (0._sp 1._sp). SEE SROTMG FOR A DESCRIPTION OF DATA STORAGE IN SPARAM.
◆ la_srotmg()
| pure subroutine, public la_blas_s::la_srotmg | ( | real(sp), intent(inout) | sd1, |
| real(sp), intent(inout) | sd2, | ||
| real(sp), intent(inout) | sx1, | ||
| real(sp), intent(in) | sy1, | ||
| real(sp), dimension(5), intent(out) | sparam ) |
CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS THE SECOND COMPONENT OF THE 2-VECTOR (SQRT(SD1)*SX1,SQRT(SD2) SY2)**T. WITH SPARAM(1)=SFLAG, H HAS ONE OF THE FOLLOWING FORMS.. SFLAG=-1._sp SFLAG=0._sp SFLAG=1._sp SFLAG=-2.E0 (SH11 SH12) (1._sp SH12) (SH11 1._sp) (1._sp 0._sp) H=( ) ( ) ( ) ( ) (SH21 SH22), (SH21 1._sp), (-1._sp SH22), (0._sp 1._sp). LOCATIONS 2-4 OF SPARAM CONTAIN SH11,SH21,SH12, AND SH22 RESPECTIVELY. (VALUES OF 1._sp, -1._sp, OR 0._sp IMPLIED BY THE VALUE OF SPARAM(1) ARE NOT STORED IN SPARAM.) THE VALUES OF GAMSQ AND RGAMSQ SET IN THE DATA STATEMENT MAY BE INEXACT. THIS IS OK AS THEY ARE ONLY USED FOR TESTING THE SIZE OF SD1 AND SD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM.
◆ la_ssbmv()
| pure subroutine, public la_blas_s::la_ssbmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SSBMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric band matrix, with k super-diagonals.
◆ la_sscal()
| pure subroutine, public la_blas_s::la_sscal | ( | integer(ilp), intent(in) | n, |
| real(sp), intent(in) | sa, | ||
| real(sp), dimension(*), intent(inout) | sx, | ||
| integer(ilp), intent(in) | incx ) |
SSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1.
◆ la_sspmv()
| pure subroutine, public la_blas_s::la_sspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SSPMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
◆ la_sspr()
| pure subroutine, public la_blas_s::la_sspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | ap ) |
SSPR: performs the symmetric rank 1 operation A := alpha*x*x**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix, supplied in packed form.
◆ la_sspr2()
| pure subroutine, public la_blas_s::la_sspr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), dimension(*), intent(inout) | ap ) |
SSPR2: performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix, supplied in packed form.
◆ la_sswap()
| pure subroutine, public la_blas_s::la_sswap | ( | integer(ilp), intent(in) | n, |
| real(sp), dimension(*), intent(inout) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(inout) | sy, | ||
| integer(ilp), intent(in) | incy ) |
SSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1.
◆ la_ssymm()
| pure subroutine, public la_blas_s::la_ssymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SSYMM: performs one of the matrix-matrix operations C := alpha*A*B + beta*C, or C := alpha*B*A + beta*C, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.
◆ la_ssymv()
| pure subroutine, public la_blas_s::la_ssymv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
SSYMV: performs the matrix-vector operation y := alpha*A*x + beta*y, where alpha and beta are scalars, x and y are n element vectors and A is an n by n symmetric matrix.
◆ la_ssyr()
| pure subroutine, public la_blas_s::la_ssyr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
SSYR: performs the symmetric rank 1 operation A := alpha*x*x**T + A, where alpha is a real scalar, x is an n element vector and A is an n by n symmetric matrix.
◆ la_ssyr2()
| pure subroutine, public la_blas_s::la_ssyr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(sp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(sp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
SSYR2: performs the symmetric rank 2 operation A := alpha*x*y**T + alpha*y*x**T + A, where alpha is a scalar, x and y are n element vectors and A is an n by n symmetric matrix.
◆ la_ssyr2k()
| pure subroutine, public la_blas_s::la_ssyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SSYR2K: performs one of the symmetric rank 2k operations C := alpha*A*B**T + alpha*B*A**T + beta*C, or C := alpha*A**T*B + alpha*B**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A and B are n by k matrices in the first case and k by n matrices in the second case.
◆ la_ssyrk()
| pure subroutine, public la_blas_s::la_ssyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), intent(in) | beta, | ||
| real(sp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
SSYRK: performs one of the symmetric rank k operations C := alpha*A*A**T + beta*C, or C := alpha*A**T*A + beta*C, where alpha and beta are scalars, C is an n by n symmetric matrix and A is an n by k matrix in the first case and a k by n matrix in the second case.
◆ la_stbmv()
| pure subroutine, public la_blas_s::la_stbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
STBMV: performs one of the matrix-vector operations x := A*x, or x := A**T*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals.
◆ la_stbsv()
| pure subroutine, public la_blas_s::la_stbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
STBSV: solves one of the systems of equations A*x = b, or A**T*x = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular band matrix, with ( k + 1 ) diagonals. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
◆ la_stpmv()
| pure subroutine, public la_blas_s::la_stpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
STPMV: performs one of the matrix-vector operations x := A*x, or x := A**T*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form.
◆ la_stpsv()
| pure subroutine, public la_blas_s::la_stpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(*), intent(in) | ap, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
STPSV: solves one of the systems of equations A*x = b, or A**T*x = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix, supplied in packed form. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
◆ la_strmm()
| pure subroutine, public la_blas_s::la_strmm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| character, intent(in) | transa, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
STRMM: performs one of the matrix-matrix operations B := alpha*op( A )*B, or B := alpha*B*op( A ), where alpha is a scalar, B is an m by n matrix, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T.
◆ la_strmv()
| pure subroutine, public la_blas_s::la_strmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
STRMV: performs one of the matrix-vector operations x := A*x, or x := A**T*x, where x is an n element vector and A is an n by n unit, or non-unit, upper or lower triangular matrix.
◆ la_strsm()
| pure subroutine, public la_blas_s::la_strsm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| character, intent(in) | transa, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), intent(in) | alpha, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
STRSM: solves one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B, where alpha is a scalar, X and B are m by n matrices, A is a unit, or non-unit, upper or lower triangular matrix and op( A ) is one of op( A ) = A or op( A ) = A**T. The matrix X is overwritten on B.
◆ la_strsv()
| pure subroutine, public la_blas_s::la_strsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(sp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(sp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
STRSV: solves one of the systems of equations A*x = b, or A**T*x = b, where b and x are n element vectors and A is an n by n unit, or non-unit, upper or lower triangular matrix. No test for singularity or near-singularity is included in this routine. Such tests must be performed before calling this routine.
