Functions/Subroutines
pure real(dp) function, public	la_dasum (n, dx, incx)
	DASUM: takes the sum of the absolute values.

pure subroutine, public	la_daxpy (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_dcopy (n, dx, incx, dy, incy)
	DCOPY: copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1.

pure real(dp) function, public	la_ddot (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_dgbmv (trans, m, n, kl, ku, alpha, a, lda, x, incx, beta, y, incy)
	DGBMV: performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaA*Tx + 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_dgemm (transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
	DGEMM: performs one of the matrix-matrix operations C := alphaop( A )op( B ) + betaC, 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_dgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	DGEMV: performs one of the matrix-vector operations y := alphaAx + betay, or y := alphaA*Tx + 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_dger (m, n, alpha, x, incx, y, incy, a, lda)
	DGER: performs the rank 1 operation A := alphaxy**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(dp) function, public	la_dnrm2 (n, x, incx)
	!

pure subroutine, public	la_drot (n, dx, incx, dy, incy, c, s)
	DROT: applies a plane rotation.

pure subroutine, public	la_drotg (a, b, c, s)
	!

pure subroutine, public	la_drotm (n, dx, incx, dy, incy, dparam)
	APPLY THE MODIFIED GIVENS TRANSFORMATION, H, TO THE 2 BY N MATRIX (DXT) , WHERE T INDICATES TRANSPOSE. THE ELEMENTS OF DX ARE IN (DY*T) DX(LX+IINCX), 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._dp DFLAG=0._dp DFLAG=1._dp DFLAG=-2.D0 (DH11 DH12) (1._dp DH12) (DH11 1._dp) (1._dp 0._dp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._dp), (-1._dp DH22), (0._dp 1._dp). SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.

pure subroutine, public	la_drotmg (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._dp DFLAG=0._dp DFLAG=1._dp DFLAG=-2.D0 (DH11 DH12) (1._dp DH12) (DH11 1._dp) (1._dp 0._dp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._dp), (-1._dp DH22), (0._dp 1._dp). LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22 RESPECTIVELY. (VALUES OF 1._dp, -1._dp, OR 0._dp 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_dsbmv (uplo, n, k, alpha, a, lda, x, incx, beta, y, incy)
	DSBMV: performs the matrix-vector operation y := alphaAx + 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_dscal (n, da, dx, incx)
	DSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1.

pure real(dp) function, public	la_dsdot (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+IINCX) SY(LY+IINCY), 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_dspmv (uplo, n, alpha, ap, x, incx, beta, y, incy)
	DSPMV: performs the matrix-vector operation y := alphaAx + 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_dspr (uplo, n, alpha, x, incx, ap)
	DSPR: performs the symmetric rank 1 operation A := alphaxx**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_dspr2 (uplo, n, alpha, x, incx, y, incy, ap)
	DSPR2: performs the symmetric rank 2 operation A := alphaxy*T + alphayx*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_dswap (n, dx, incx, dy, incy)
	DSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1.

pure subroutine, public	la_dsymm (side, uplo, m, n, alpha, a, lda, b, ldb, beta, c, ldc)
	DSYMM: performs one of the matrix-matrix operations C := alphaAB + betaC, or C := alphaBA + betaC, where alpha and beta are scalars, A is a symmetric matrix and B and C are m by n matrices.

pure subroutine, public	la_dsymv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	DSYMV: performs the matrix-vector operation y := alphaAx + 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_dsyr (uplo, n, alpha, x, incx, a, lda)
	DSYR: performs the symmetric rank 1 operation A := alphaxx**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_dsyr2 (uplo, n, alpha, x, incx, y, incy, a, lda)
	DSYR2: performs the symmetric rank 2 operation A := alphaxy*T + alphayx*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_dsyr2k (uplo, trans, n, k, alpha, a, lda, b, ldb, beta, c, ldc)
	DSYR2K: performs one of the symmetric rank 2k operations C := alphaAB*T + alphaBAT + betaC, or C := alphaATB + alphaBTA + 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_dsyrk (uplo, trans, n, k, alpha, a, lda, beta, c, ldc)
	DSYRK: performs one of the symmetric rank k operations C := alphaAA*T + betaC, or C := alphaATA + 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_dtbmv (uplo, trans, diag, n, k, a, lda, x, incx)
	DTBMV: performs one of the matrix-vector operations x := Ax, or x := ATx, 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_dtbsv (uplo, trans, diag, n, k, a, lda, x, incx)
	DTBSV: solves one of the systems of equations Ax = b, or ATx = 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_dtpmv (uplo, trans, diag, n, ap, x, incx)
	DTPMV: performs one of the matrix-vector operations x := Ax, or x := ATx, 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_dtpsv (uplo, trans, diag, n, ap, x, incx)
	DTPSV: solves one of the systems of equations Ax = b, or ATx = 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_dtrmm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
	DTRMM: performs one of the matrix-matrix operations B := alphaop( A )B, or B := alphaBop( 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_dtrmv (uplo, trans, diag, n, a, lda, x, incx)
	DTRMV: performs one of the matrix-vector operations x := Ax, or x := ATx, 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_dtrsm (side, uplo, transa, diag, m, n, alpha, a, lda, b, ldb)
	DTRSM: solves one of the matrix equations op( A )X = alphaB, or Xop( A ) = alphaB, 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_dtrsv (uplo, trans, diag, n, a, lda, x, incx)
	DTRSV: solves one of the systems of equations Ax = b, or ATx = 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(dp) function, public	la_dzasum (n, zx, incx)
	DZASUM: takes the sum of the (\|Re(.)\| + \|Im(.)\|)'s of a complex vector and returns a double precision result.

pure real(dp) function, public	la_dznrm2 (n, x, incx)
	!

Function/Subroutine Documentation

◆ la_dasum()

pure real(dp) function, public la_blas_d::la_dasum	(	integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(in)	dx,
		integer(ilp), intent(in)	incx )

DASUM: takes the sum of the absolute values.

Here is the call graph for this function:

◆ la_daxpy()

pure subroutine, public la_blas_d::la_daxpy	(	integer(ilp), intent(in)	n,
		real(dp), intent(in)	da,
		real(dp), dimension(*), intent(in)	dx,
		integer(ilp), intent(in)	incx,
		real(dp), 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_dcopy()

pure subroutine, public la_blas_d::la_dcopy	(	integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(in)	dx,
		integer(ilp), intent(in)	incx,
		real(dp), 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_ddot()

pure real(dp) function, public la_blas_d::la_ddot	(	integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(in)	dx,
		integer(ilp), intent(in)	incx,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dgbmv()

pure subroutine, public la_blas_d::la_dgbmv	(	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(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dgemm()

pure subroutine, public la_blas_d::la_dgemm	(	character, intent(in)	transa,
		character, intent(in)	transb,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dgemv()

pure subroutine, public la_blas_d::la_dgemv	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dger()

pure subroutine, public la_blas_d::la_dger	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dnrm2()

pure real(dp) function, public la_blas_d::la_dnrm2	(	integer(ilp), intent(in)	n,
		real(dp), 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 )

Here is the call graph for this function:

◆ la_drot()

pure subroutine, public la_blas_d::la_drot	(	integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(inout)	dx,
		integer(ilp), intent(in)	incx,
		real(dp), dimension(*), intent(inout)	dy,
		integer(ilp), intent(in)	incy,
		real(dp), intent(in)	c,
		real(dp), intent(in)	s )

DROT: applies a plane rotation.

◆ la_drotg()

pure subroutine, public la_blas_d::la_drotg	(	real(dp), intent(inout)	a,
		real(dp), intent(inout)	b,
		real(dp), intent(out)	c,
		real(dp), 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_drotm()

pure subroutine, public la_blas_d::la_drotm	(	integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(inout)	dx,
		integer(ilp), intent(in)	incx,
		real(dp), dimension(*), intent(inout)	dy,
		integer(ilp), intent(in)	incy,
		real(dp), 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._dp DFLAG=0._dp DFLAG=1._dp DFLAG=-2.D0 (DH11 DH12) (1._dp DH12) (DH11 1._dp) (1._dp 0._dp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._dp), (-1._dp DH22), (0._dp 1._dp). SEE DROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.

◆ la_drotmg()

pure subroutine, public la_blas_d::la_drotmg	(	real(dp), intent(inout)	dd1,
		real(dp), intent(inout)	dd2,
		real(dp), intent(inout)	dx1,
		real(dp), intent(in)	dy1,
		real(dp), 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._dp DFLAG=0._dp DFLAG=1._dp DFLAG=-2.D0 (DH11 DH12) (1._dp DH12) (DH11 1._dp) (1._dp 0._dp) H=( ) ( ) ( ) ( ) (DH21 DH22), (DH21 1._dp), (-1._dp DH22), (0._dp 1._dp). LOCATIONS 2-4 OF DPARAM CONTAIN DH11, DH21, DH12, AND DH22 RESPECTIVELY. (VALUES OF 1._dp, -1._dp, OR 0._dp 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_dsbmv()

pure subroutine, public la_blas_d::la_dsbmv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dscal()

pure subroutine, public la_blas_d::la_dscal	(	integer(ilp), intent(in)	n,
		real(dp), intent(in)	da,
		real(dp), 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_dsdot()

pure real(dp) function, public la_blas_d::la_dsdot	(	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 )

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.

Here is the call graph for this function:

◆ la_dspmv()

pure subroutine, public la_blas_d::la_dspmv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	ap,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dspr()

pure subroutine, public la_blas_d::la_dspr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dspr2()

pure subroutine, public la_blas_d::la_dspr2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dswap()

pure subroutine, public la_blas_d::la_dswap	(	integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(inout)	dx,
		integer(ilp), intent(in)	incx,
		real(dp), dimension(*), intent(inout)	dy,
		integer(ilp), intent(in)	incy )

DSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1.

◆ la_dsymm()

pure subroutine, public la_blas_d::la_dsymm	(	character, intent(in)	side,
		character, intent(in)	uplo,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dsymv()

pure subroutine, public la_blas_d::la_dsymv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dsyr()

pure subroutine, public la_blas_d::la_dsyr	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dsyr2()

pure subroutine, public la_blas_d::la_dsyr2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		real(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(dp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dsyr2k()

pure subroutine, public la_blas_d::la_dsyr2k	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(ldb,*), intent(in)	b,
		integer(ilp), intent(in)	ldb,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dsyrk()

pure subroutine, public la_blas_d::la_dsyrk	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), intent(in)	beta,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtbmv()

pure subroutine, public la_blas_d::la_dtbmv	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtbsv()

pure subroutine, public la_blas_d::la_dtbsv	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	k,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtpmv()

pure subroutine, public la_blas_d::la_dtpmv	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(in)	ap,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtpsv()

pure subroutine, public la_blas_d::la_dtpsv	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		real(dp), dimension(*), intent(in)	ap,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtrmm()

pure subroutine, public la_blas_d::la_dtrmm	(	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(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtrmv()

pure subroutine, public la_blas_d::la_dtrmv	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtrsm()

pure subroutine, public la_blas_d::la_dtrsm	(	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(dp), intent(in)	alpha,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dtrsv()

pure subroutine, public la_blas_d::la_dtrsv	(	character, intent(in)	uplo,
		character, intent(in)	trans,
		character, intent(in)	diag,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(dp), 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.

Here is the call graph for this function:

◆ la_dzasum()

pure real(dp) function, public la_blas_d::la_dzasum	(	integer(ilp), intent(in)	n,
		complex(dp), 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 double precision result.

Here is the call graph for this function:

◆ la_dznrm2()

pure real(dp) function, public la_blas_d::la_dznrm2	(	integer(ilp), intent(in)	n,
		complex(dp), 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 )

Here is the call graph for this function:

Functions/Subroutines

Function/Subroutine Documentation

◆ la_dasum()

◆ la_daxpy()

◆ la_dcopy()

◆ la_ddot()

◆ la_dgbmv()

◆ la_dgemm()

◆ la_dgemv()

◆ la_dger()

◆ la_dnrm2()

◆ la_drot()

◆ la_drotg()

◆ la_drotm()

◆ la_drotmg()

◆ la_dsbmv()

◆ la_dscal()

◆ la_dsdot()

◆ la_dspmv()

◆ la_dspr()

◆ la_dspr2()

◆ la_dswap()

◆ la_dsymm()

◆ la_dsymv()

◆ la_dsyr()

◆ la_dsyr2()

◆ la_dsyr2k()

◆ la_dsyrk()

◆ la_dtbmv()

◆ la_dtbsv()

◆ la_dtpmv()

◆ la_dtpsv()

◆ la_dtrmm()

◆ la_dtrmv()

◆ la_dtrsm()

◆ la_dtrsv()

◆ la_dzasum()

◆ la_dznrm2()