Functions/Subroutines | |
| pure real(qp) function, public | la_qasum (n, dx, incx) |
| DASUM: takes the sum of the absolute values. | |
| pure subroutine, public | la_qaxpy (n, da, dx, incx, dy, incy) |
| DAXPY: constant times a vector plus a vector. uses unrolled loops for increments equal to one. | |
| pure subroutine, public | la_qcopy (n, dx, incx, dy, incy) |
| DCOPY: copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1. | |
| pure real(qp) function, public | la_qdot (n, dx, incx, dy, incy) |
| DDOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one. | |
| pure subroutine, public | la_qgbmv (trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy) |
| DGBMV: 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_qgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| DGEMM: 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_qgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy) |
| DGEMV: 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_qger (m, n, alpha, x, incx, y, incy, a, lda) |
| DGER: 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(qp) function, public | la_qnrm2 (n, x, incx) |
| ! | |
| pure subroutine, public | la_qrot (n, dx, incx, dy, incy, c, s) |
| DROT: applies a plane rotation. | |
| pure subroutine, public | la_qrotg (a, b, c, s) |
| ! | |
| pure subroutine, public | la_qrotm (n, dx, incx, dy, incy, dparam) |
| APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX (DX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN (DY**T) DX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX >= 0, ELSE LX = (-INCX)*N, AND SIMILARLY FOR SY USING LY AND INCY. WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. DFLAG=-1._qp DFLAG=0._qp DFLAG=1._qp DFLAG=-2.D0 (DH11 DH12) (1._qp DH12) (DH11 1._qp) (1._qp 0._qp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._qp), (-1._qp DH22), (0._qp 1._qp). SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM. | |
| pure subroutine, public | la_qrotmg (dd1, dd2, dx1, dy1, dparam) |
| CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS THE SECOND COMPONENT OF THE 2-VECTOR (SQRT(DD1)*DX1,SQRT(DD2) DY2)**T. WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. DFLAG=-1._qp DFLAG=0._qp DFLAG=1._qp DFLAG=-2.D0 (DH11 DH12) (1._qp DH12) (DH11 1._qp) (1._qp 0._qp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._qp), (-1._qp DH22), (0._qp 1._qp). LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22 RESPECTIVELY. (VALUES OF 1._qp, -1._qp, OR 0._qp IMPLIED BY THE VALUE OF DPARAM(1) ARE NOT STORED IN DPARAM.) 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 DD1 AND DD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM. | |
| pure subroutine, public | la_qsbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy) |
| DSBMV: 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_qscal (n, da, dx, incx) |
| DSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1. | |
| pure real(qp) function, public | la_qsdot (n, sx, incx, sy, incy) |
| Compute the inner product of two vectors with extended precision accumulation and result. Returns D.P. dot product accumulated in D.P., for S.P. SX and SY DSDOT: = 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_qspmv (uplo, n, alpha, ap, x, incx, beta, y, incy) |
| DSPMV: 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_qspr (uplo, n, alpha, x, incx, ap) |
| DSPR: 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_qspr2 (uplo, n, alpha, x, incx, y, incy, ap) |
| DSPR2: 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_qswap (n, dx, incx, dy, incy) |
| DSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1. | |
| pure subroutine, public | la_qsymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc) |
| DSYMM: 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_qsymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy) |
| DSYMV: 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_qsyr (uplo, n, alpha, x, incx, a, lda) |
| DSYR: 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_qsyr2 (uplo, n, alpha, x, incx, y, incy, a, lda) |
| DSYR2: 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_qsyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc) |
| DSYR2K: 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_qsyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc) |
| DSYRK: 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_qtbmv (uplo, trans, diag, n, k, a, lda, x, incx) |
| DTBMV: 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_qtbsv (uplo, trans, diag, n, k, a, lda, x, incx) |
| DTBSV: 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_qtpmv (uplo, trans, diag, n, ap, x, incx) |
| DTPMV: 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_qtpsv (uplo, trans, diag, n, ap, x, incx) |
| DTPSV: 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_qtrmm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) |
| DTRMM: 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_qtrmv (uplo, trans, diag, n, a, lda, x, incx) |
| DTRMV: 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_qtrsm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb) |
| DTRSM: 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_qtrsv (uplo, trans, diag, n, a, lda, x, incx) |
| DTRSV: 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. | |
| pure real(qp) function, public | la_qzasum (n, zx, incx) |
| DZASUM: takes the sum of the (|Re(.)| + |Im(.)|)'s of a complex vector and returns a quad precision result. | |
| pure real(qp) function, public | la_qznrm2 (n, x, incx) |
| ! | |
Function/Subroutine Documentation
◆ la_qasum()
| pure real(qp) function, public la_blas_q::la_qasum | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(in) | dx, | ||
| integer(ilp), intent(in) | incx ) |
DASUM: takes the sum of the absolute values.
◆ la_qaxpy()
| pure subroutine, public la_blas_q::la_qaxpy | ( | integer(ilp), intent(in) | n, |
| real(qp), intent(in) | da, | ||
| real(qp), dimension(*), intent(in) | dx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | dy, | ||
| integer(ilp), intent(in) | incy ) |
DAXPY: constant times a vector plus a vector. uses unrolled loops for increments equal to one.
◆ la_qcopy()
| pure subroutine, public la_blas_q::la_qcopy | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(in) | dx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(out) | dy, | ||
| integer(ilp), intent(in) | incy ) |
DCOPY: copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1.
◆ la_qdot()
| pure real(qp) function, public la_blas_q::la_qdot | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(in) | dx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(in) | dy, | ||
| integer(ilp), intent(in) | incy ) |
DDOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one.
◆ la_qgbmv()
| pure subroutine, public la_blas_q::la_qgbmv | ( | 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(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DGBMV: 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_qgemm()
| pure subroutine, public la_blas_q::la_qgemm | ( | character, intent(in) | transa, |
| character, intent(in) | transb, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DGEMM: 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_qgemv()
| pure subroutine, public la_blas_q::la_qgemv | ( | character, intent(in) | trans, |
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DGEMV: 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_qger()
| pure subroutine, public la_blas_q::la_qger | ( | integer(ilp), intent(in) | m, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
DGER: 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_qnrm2()
| pure real(qp) function, public la_blas_q::la_qnrm2 | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx ) |
!
DNRM2: returns the euclidean norm of a vector via the function name, so that DNRM2 := sqrt( x'*x )
◆ la_qrot()
| pure subroutine, public la_blas_q::la_qrot | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | dx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | dy, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), intent(in) | c, | ||
| real(qp), intent(in) | s ) |
DROT: applies a plane rotation.
◆ la_qrotg()
| pure subroutine, public la_blas_q::la_qrotg | ( | real(qp), intent(inout) | a, |
| real(qp), intent(inout) | b, | ||
| real(qp), intent(out) | c, | ||
| real(qp), 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_qrotm()
| pure subroutine, public la_blas_q::la_qrotm | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | dx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | dy, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), dimension(5), intent(in) | dparam ) |
APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX (DX**T) , WHERE **T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN (DY**T) DX(LX+I*INCX), I = 0 TO N-1, WHERE LX = 1 IF INCX >= 0, ELSE LX = (-INCX)*N, AND SIMILARLY FOR SY USING LY AND INCY. WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. DFLAG=-1._qp DFLAG=0._qp DFLAG=1._qp DFLAG=-2.D0 (DH11 DH12) (1._qp DH12) (DH11 1._qp) (1._qp 0._qp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._qp), (-1._qp DH22), (0._qp 1._qp). SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.
◆ la_qrotmg()
| pure subroutine, public la_blas_q::la_qrotmg | ( | real(qp), intent(inout) | dd1, |
| real(qp), intent(inout) | dd2, | ||
| real(qp), intent(inout) | dx1, | ||
| real(qp), intent(in) | dy1, | ||
| real(qp), dimension(5), intent(out) | dparam ) |
CONSTRUCT THE MODIFIED GIVENS TRANSFORMATION MATRIX H WHICH ZEROS THE SECOND COMPONENT OF THE 2-VECTOR (SQRT(DD1)*DX1,SQRT(DD2) DY2)**T. WITH DPARAM(1)=DFLAG, H HAS ONE OF THE FOLLOWING FORMS.. DFLAG=-1._qp DFLAG=0._qp DFLAG=1._qp DFLAG=-2.D0 (DH11 DH12) (1._qp DH12) (DH11 1._qp) (1._qp 0._qp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._qp), (-1._qp DH22), (0._qp 1._qp). LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22 RESPECTIVELY. (VALUES OF 1._qp, -1._qp, OR 0._qp IMPLIED BY THE VALUE OF DPARAM(1) ARE NOT STORED IN DPARAM.) 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 DD1 AND DD2. ALL ACTUAL SCALING OF DATA IS DONE USING GAM.
◆ la_qsbmv()
| pure subroutine, public la_blas_q::la_qsbmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DSBMV: 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_qscal()
| pure subroutine, public la_blas_q::la_qscal | ( | integer(ilp), intent(in) | n, |
| real(qp), intent(in) | da, | ||
| real(qp), dimension(*), intent(inout) | dx, | ||
| integer(ilp), intent(in) | incx ) |
DSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1.
◆ la_qsdot()
| pure real(qp) function, public la_blas_q::la_qsdot | ( | integer(ilp), intent(in) | n, |
| real(dp), dimension(*), intent(in) | sx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(dp), dimension(*), intent(in) | sy, | ||
| integer(ilp), intent(in) | incy ) |
Compute the inner product of two vectors with extended precision accumulation and result. Returns D.P. dot product accumulated in D.P., for S.P. SX and SY DSDOT: = 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_qspmv()
| pure subroutine, public la_blas_q::la_qspmv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DSPMV: 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_qspr()
| pure subroutine, public la_blas_q::la_qspr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | ap ) |
DSPR: 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_qspr2()
| pure subroutine, public la_blas_q::la_qspr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), dimension(*), intent(inout) | ap ) |
DSPR2: 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_qswap()
| pure subroutine, public la_blas_q::la_qswap | ( | integer(ilp), intent(in) | n, |
| real(qp), dimension(*), intent(inout) | dx, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(inout) | dy, | ||
| integer(ilp), intent(in) | incy ) |
DSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1.
◆ la_qsymm()
| pure subroutine, public la_blas_q::la_qsymm | ( | character, intent(in) | side, |
| character, intent(in) | uplo, | ||
| integer(ilp), intent(in) | m, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DSYMM: 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_qsymv()
| pure subroutine, public la_blas_q::la_qsymv | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(*), intent(inout) | y, | ||
| integer(ilp), intent(in) | incy ) |
DSYMV: 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_qsyr()
| pure subroutine, public la_blas_q::la_qsyr | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
DSYR: 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_qsyr2()
| pure subroutine, public la_blas_q::la_qsyr2 | ( | character, intent(in) | uplo, |
| integer(ilp), intent(in) | n, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx, | ||
| real(qp), dimension(*), intent(in) | y, | ||
| integer(ilp), intent(in) | incy, | ||
| real(qp), dimension(lda,*), intent(inout) | a, | ||
| integer(ilp), intent(in) | lda ) |
DSYR2: 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_qsyr2k()
| pure subroutine, public la_blas_q::la_qsyr2k | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(in) | b, | ||
| integer(ilp), intent(in) | ldb, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DSYR2K: 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_qsyrk()
| pure subroutine, public la_blas_q::la_qsyrk | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), intent(in) | beta, | ||
| real(qp), dimension(ldc,*), intent(inout) | c, | ||
| integer(ilp), intent(in) | ldc ) |
DSYRK: 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_qtbmv()
| pure subroutine, public la_blas_q::la_qtbmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
DTBMV: 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_qtbsv()
| pure subroutine, public la_blas_q::la_qtbsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| integer(ilp), intent(in) | k, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
DTBSV: 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_qtpmv()
| pure subroutine, public la_blas_q::la_qtpmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
DTPMV: 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_qtpsv()
| pure subroutine, public la_blas_q::la_qtpsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(*), intent(in) | ap, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
DTPSV: 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_qtrmm()
| pure subroutine, public la_blas_q::la_qtrmm | ( | 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(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
DTRMM: 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_qtrmv()
| pure subroutine, public la_blas_q::la_qtrmv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
DTRMV: 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_qtrsm()
| pure subroutine, public la_blas_q::la_qtrsm | ( | 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(qp), intent(in) | alpha, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(ldb,*), intent(inout) | b, | ||
| integer(ilp), intent(in) | ldb ) |
DTRSM: 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_qtrsv()
| pure subroutine, public la_blas_q::la_qtrsv | ( | character, intent(in) | uplo, |
| character, intent(in) | trans, | ||
| character, intent(in) | diag, | ||
| integer(ilp), intent(in) | n, | ||
| real(qp), dimension(lda,*), intent(in) | a, | ||
| integer(ilp), intent(in) | lda, | ||
| real(qp), dimension(*), intent(inout) | x, | ||
| integer(ilp), intent(in) | incx ) |
DTRSV: 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.
◆ la_qzasum()
| pure real(qp) function, public la_blas_q::la_qzasum | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(*), intent(in) | zx, | ||
| integer(ilp), intent(in) | incx ) |
DZASUM: takes the sum of the (|Re(.)| + |Im(.)|)'s of a complex vector and returns a quad precision result.
◆ la_qznrm2()
| pure real(qp) function, public la_blas_q::la_qznrm2 | ( | integer(ilp), intent(in) | n, |
| complex(qp), dimension(*), intent(in) | x, | ||
| integer(ilp), intent(in) | incx ) |
!
DZNRM2: returns the euclidean norm of a vector via the function name, so that DZNRM2 := sqrt( x**H*x )
