BLAS level 1: vector operations. More...

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 real(dp) function, public	la_dasum (n, dx, incx)
	DASUM: takes the sum of the absolute values.

pure real(qp) function, public	la_qasum (n, qx, incx)
	QASUM: takes the sum of the absolute values.

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 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_qaxpy (n, qa, qx, incx, qy, incy)
	QAXPY: constant times a vector plus a vector. uses unrolled loops for increments equal to one.

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 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 subroutine, public	la_qcopy (n, qx, incx, qy, incy)
	QCOPY: 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(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 real(qp) function, public	la_qdot (n, qx, incx, qy, incy)
	QDOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one.

pure real(sp) function, public	la_snrm2 (n, x, incx)
	!

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

pure real(qp) function, public	la_qnrm2 (n, x, incx)
	!

pure subroutine, public	la_srot (n, sx, incx, sy, incy, c, s)
	applies a plane rotation.

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

pure subroutine, public	la_qrot (n, qx, incx, qy, incy, c, s)
	QROT: applies a plane rotation.

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

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

pure subroutine, public	la_qrotg (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 (SXT) , WHERE T INDICATES TRANSPOSE. THE ELEMENTS OF SX ARE IN (SX*T) SX(LX+IINCX), 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_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_qrotm (n, qx, incx, qy, incy, qparam)
	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._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 QROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.

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_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_qrotmg (qd1, qd2, qx1, qy1, qparam)
	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_sscal (n, sa, sx, incx)
	SSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1.

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 subroutine, public	la_qscal (n, qa, qx, incx)
	QSCAL: 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 real(qp) function, public	la_qddot (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 QDDOT: = 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_sswap (n, sx, incx, sy, incy)
	SSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1.

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_qswap (n, qx, incx, qy, incy)
	QSWAP: interchanges two vectors. uses unrolled loops for increments equal to 1.

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(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(qp) function, public	la_qwasum (n, wx, incx)
	QWASUM: takes the sum of the (\|Re(.)\| + \|Im(.)\|)'s of a complex vector and returns a quad precision result.

pure real(sp) function, public	la_scnrm2 (n, x, incx)
	!

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

pure real(qp) function, public	la_qwnrm2 (n, x, incx)
	!

pure subroutine, public	la_caxpy (n, ca, cx, incx, cy, incy)
	CAXPY: constant times a vector plus a vector.

pure subroutine, public	la_zaxpy (n, za, zx, incx, zy, incy)
	ZAXPY: constant times a vector plus a vector.

pure subroutine, public	la_waxpy (n, wa, wx, incx, wy, incy)
	WAXPY: constant times a vector plus a vector.

pure subroutine, public	la_ccopy (n, cx, incx, cy, incy)
	CCOPY: copies a vector x to a vector y.

pure subroutine, public	la_zcopy (n, zx, incx, zy, incy)
	ZCOPY: copies a vector, x, to a vector, y.

pure subroutine, public	la_wcopy (n, wx, incx, wy, incy)
	WCOPY: copies a vector, x, to a vector, y.

pure complex(sp) function, public	la_cdotc (n, cx, incx, cy, incy)
	CDOTC: forms the dot product of two complex vectors CDOTC = X^H * Y.

pure complex(dp) function, public	la_zdotc (n, zx, incx, zy, incy)
	ZDOTC: forms the dot product of two complex vectors ZDOTC = X^H * Y.

pure complex(qp) function, public	la_wdotc (n, wx, incx, wy, incy)
	WDOTC: forms the dot product of two complex vectors WDOTC = X^H * Y.

pure complex(sp) function, public	la_cdotu (n, cx, incx, cy, incy)
	CDOTU: forms the dot product of two complex vectors CDOTU = X^T * Y.

pure complex(dp) function, public	la_zdotu (n, zx, incx, zy, incy)
	ZDOTU: forms the dot product of two complex vectors ZDOTU = X^T * Y.

pure complex(qp) function, public	la_wdotu (n, wx, incx, wy, incy)
	WDOTU: forms the dot product of two complex vectors WDOTU = X^T * Y.

pure subroutine, public	la_csrot (n, cx, incx, cy, incy, c, s)
	CSROT: applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

pure subroutine, public	la_zdrot (n, zx, incx, zy, incy, c, s)
	Applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

pure subroutine, public	la_wqrot (n, wx, incx, wy, incy, c, s)
	Applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

pure subroutine, public	la_csscal (n, sa, cx, incx)
	CSSCAL: scales a complex vector by a real constant.

pure subroutine, public	la_zdscal (n, da, zx, incx)
	ZDSCAL: scales a vector by a constant.

pure subroutine, public	la_wqscal (n, qa, wx, incx)
	WQSCAL: scales a vector by a constant.

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

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

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

pure subroutine, public	la_cscal (n, ca, cx, incx)
	CSCAL: scales a vector by a constant.

pure subroutine, public	la_zscal (n, za, zx, incx)
	ZSCAL: scales a vector by a constant.

pure subroutine, public	la_wscal (n, wa, wx, incx)
	WSCAL: scales a vector by a constant.

pure subroutine, public	la_cswap (n, cx, incx, cy, incy)
	CSWAP: interchanges two vectors.

pure subroutine, public	la_zswap (n, zx, incx, zy, incy)
	ZSWAP: interchanges two vectors.

pure subroutine, public	la_wswap (n, wx, incx, wy, incy)
	WSWAP: interchanges two vectors.

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+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.

Detailed Description

BLAS level 1: vector operations.

Function/Subroutine Documentation

◆ la_caxpy()

pure subroutine, public la_blas_level1::la_caxpy	(	integer(ilp), intent(in)	n,
		complex(sp), intent(in)	ca,
		complex(sp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy )

CAXPY: constant times a vector plus a vector.

Here is the call graph for this function:

◆ la_ccopy()

pure subroutine, public la_blas_level1::la_ccopy	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(out)	cy,
		integer(ilp), intent(in)	incy )

CCOPY: copies a vector x to a vector y.

◆ la_cdotc()

pure complex(sp) function, public la_blas_level1::la_cdotc	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(in)	cy,
		integer(ilp), intent(in)	incy )

CDOTC: forms the dot product of two complex vectors CDOTC = X^H * Y.

Here is the call graph for this function:

◆ la_cdotu()

pure complex(sp) function, public la_blas_level1::la_cdotu	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(in)	cy,
		integer(ilp), intent(in)	incy )

CDOTU: forms the dot product of two complex vectors CDOTU = X^T * Y.

Here is the call graph for this function:

◆ la_crotg()

pure subroutine, public la_blas_level1::la_crotg	(	complex(sp), intent(inout)	a,
		complex(sp), intent(in)	b,
		real(sp), intent(out)	c,
		complex(sp), intent(out)	s )

!

The computation uses the formulas |x| = sqrt( Re(x)**2 + Im(x)**2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|**2 + |b|**2) s = sgn(a) * conjg(b) / sqrt(|a|**2 + |b|**2) When a and b are real and r /= 0, the formulas simplify to r = sgn(a)*sqrt(|a|**2 + |b|**2) c = a / r s = b / r the same as in SROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by SROTG if the signs of a and b are not the same.

◆ la_cscal()

pure subroutine, public la_blas_level1::la_cscal	(	integer(ilp), intent(in)	n,
		complex(sp), intent(in)	ca,
		complex(sp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx )

CSCAL: scales a vector by a constant.

◆ la_csrot()

pure subroutine, public la_blas_level1::la_csrot	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy,
		real(sp), intent(in)	c,
		real(sp), intent(in)	s )

CSROT: applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

◆ la_csscal()

pure subroutine, public la_blas_level1::la_csscal	(	integer(ilp), intent(in)	n,
		real(sp), intent(in)	sa,
		complex(sp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx )

CSSCAL: scales a complex vector by a real constant.

◆ la_cswap()

pure subroutine, public la_blas_level1::la_cswap	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy )

CSWAP: interchanges two vectors.

◆ la_dasum()

pure real(dp) function, public la_blas_level1::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_level1::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_level1::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_level1::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_dnrm2()

pure real(dp) function, public la_blas_level1::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_level1::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_level1::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_level1::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_level1::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_dscal()

pure subroutine, public la_blas_level1::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_level1::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_dswap()

pure subroutine, public la_blas_level1::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_dzasum()

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

◆ la_qasum()

pure real(qp) function, public la_blas_level1::la_qasum	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(in)	qx,
		integer(ilp), intent(in)	incx )

QASUM: takes the sum of the absolute values.

Here is the call graph for this function:

◆ la_qaxpy()

pure subroutine, public la_blas_level1::la_qaxpy	(	integer(ilp), intent(in)	n,
		real(qp), intent(in)	qa,
		real(qp), dimension(*), intent(in)	qx,
		integer(ilp), intent(in)	incx,
		real(qp), dimension(*), intent(inout)	qy,
		integer(ilp), intent(in)	incy )

QAXPY: constant times a vector plus a vector. uses unrolled loops for increments equal to one.

◆ la_qcopy()

pure subroutine, public la_blas_level1::la_qcopy	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(in)	qx,
		integer(ilp), intent(in)	incx,
		real(qp), dimension(*), intent(out)	qy,
		integer(ilp), intent(in)	incy )

QCOPY: copies a vector, x, to a vector, y. uses unrolled loops for increments equal to 1.

◆ la_qddot()

pure real(qp) function, public la_blas_level1::la_qddot	(	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 QDDOT: = 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_qdot()

pure real(qp) function, public la_blas_level1::la_qdot	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(in)	qx,
		integer(ilp), intent(in)	incx,
		real(qp), dimension(*), intent(in)	qy,
		integer(ilp), intent(in)	incy )

QDOT: forms the dot product of two vectors. uses unrolled loops for increments equal to one.

Here is the call graph for this function:

◆ la_qnrm2()

pure real(qp) function, public la_blas_level1::la_qnrm2	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx )

!

QNRM2: returns the euclidean norm of a vector via the function name, so that QNRM2 := sqrt( x'*x )

Here is the call graph for this function:

◆ la_qrot()

pure subroutine, public la_blas_level1::la_qrot	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(inout)	qx,
		integer(ilp), intent(in)	incx,
		real(qp), dimension(*), intent(inout)	qy,
		integer(ilp), intent(in)	incy,
		real(qp), intent(in)	c,
		real(qp), intent(in)	s )

QROT: applies a plane rotation.

◆ la_qrotg()

pure subroutine, public la_blas_level1::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_level1::la_qrotm	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(inout)	qx,
		integer(ilp), intent(in)	incx,
		real(qp), dimension(*), intent(inout)	qy,
		integer(ilp), intent(in)	incy,
		real(qp), dimension(5), intent(in)	qparam )

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 QROTMG FOR A DESCRIPTION OF DATA STORAGE IN DPARAM.

◆ la_qrotmg()

pure subroutine, public la_blas_level1::la_qrotmg	(	real(qp), intent(inout)	qd1,
		real(qp), intent(inout)	qd2,
		real(qp), intent(inout)	qx1,
		real(qp), intent(in)	qy1,
		real(qp), dimension(5), intent(out)	qparam )

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_qscal()

pure subroutine, public la_blas_level1::la_qscal	(	integer(ilp), intent(in)	n,
		real(qp), intent(in)	qa,
		real(qp), dimension(*), intent(inout)	qx,
		integer(ilp), intent(in)	incx )

QSCAL: scales a vector by a constant. uses unrolled loops for increment equal to 1.

◆ la_qswap()

pure subroutine, public la_blas_level1::la_qswap	(	integer(ilp), intent(in)	n,
		real(qp), dimension(*), intent(inout)	qx,
		integer(ilp), intent(in)	incx,
		real(qp), dimension(*), intent(inout)	qy,
		integer(ilp), intent(in)	incy )

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

◆ la_qwasum()

pure real(qp) function, public la_blas_level1::la_qwasum	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	wx,
		integer(ilp), intent(in)	incx )

QWASUM: takes the sum of the (|Re(.)| + |Im(.)|)'s of a complex vector and returns a quad precision result.

Here is the call graph for this function:

◆ la_qwnrm2()

pure real(qp) function, public la_blas_level1::la_qwnrm2	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx )

!

QWNRM2: returns the euclidean norm of a vector via the function name, so that QWNRM2 := sqrt( x**H*x )

Here is the call graph for this function:

◆ la_sasum()

pure real(sp) function, public la_blas_level1::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.

Here is the call graph for this function:

◆ la_saxpy()

pure subroutine, public la_blas_level1::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_level1::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.

Here is the call graph for this function:

◆ la_scnrm2()

pure real(sp) function, public la_blas_level1::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 )

Here is the call graph for this function:

◆ la_scopy()

pure subroutine, public la_blas_level1::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_level1::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.

Here is the call graph for this function:

◆ la_sdsdot()

pure real(sp) function, public la_blas_level1::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.

Here is the call graph for this function:

◆ la_snrm2()

pure real(sp) function, public la_blas_level1::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 ).

Here is the call graph for this function:

◆ la_srot()

pure subroutine, public la_blas_level1::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_level1::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_level1::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_level1::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_sscal()

pure subroutine, public la_blas_level1::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_sswap()

pure subroutine, public la_blas_level1::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_waxpy()

pure subroutine, public la_blas_level1::la_waxpy	(	integer(ilp), intent(in)	n,
		complex(qp), intent(in)	wa,
		complex(qp), dimension(*), intent(in)	wx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(inout)	wy,
		integer(ilp), intent(in)	incy )

WAXPY: constant times a vector plus a vector.

Here is the call graph for this function:

◆ la_wcopy()

pure subroutine, public la_blas_level1::la_wcopy	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	wx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(out)	wy,
		integer(ilp), intent(in)	incy )

WCOPY: copies a vector, x, to a vector, y.

◆ la_wdotc()

pure complex(qp) function, public la_blas_level1::la_wdotc	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	wx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(in)	wy,
		integer(ilp), intent(in)	incy )

WDOTC: forms the dot product of two complex vectors WDOTC = X^H * Y.

Here is the call graph for this function:

◆ la_wdotu()

pure complex(qp) function, public la_blas_level1::la_wdotu	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	wx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(in)	wy,
		integer(ilp), intent(in)	incy )

WDOTU: forms the dot product of two complex vectors WDOTU = X^T * Y.

Here is the call graph for this function:

◆ la_wqrot()

pure subroutine, public la_blas_level1::la_wqrot	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(inout)	wx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(inout)	wy,
		integer(ilp), intent(in)	incy,
		real(qp), intent(in)	c,
		real(qp), intent(in)	s )

Applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

◆ la_wqscal()

pure subroutine, public la_blas_level1::la_wqscal	(	integer(ilp), intent(in)	n,
		real(qp), intent(in)	qa,
		complex(qp), dimension(*), intent(inout)	wx,
		integer(ilp), intent(in)	incx )

WQSCAL: scales a vector by a constant.

◆ la_wrotg()

pure subroutine, public la_blas_level1::la_wrotg	(	complex(qp), intent(inout)	a,
		complex(qp), intent(in)	b,
		real(qp), intent(out)	c,
		complex(qp), intent(out)	s )

!

The computation uses the formulas |x| = sqrt( Re(x)**2 + Im(x)**2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|**2 + |b|**2) s = sgn(a) * conjg(b) / sqrt(|a|**2 + |b|**2) When a and b are real and r /= 0, the formulas simplify to r = sgn(a)*sqrt(|a|**2 + |b|**2) c = a / r s = b / r the same as in QROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by QROTG if the signs of a and b are not the same.

◆ la_wscal()

pure subroutine, public la_blas_level1::la_wscal	(	integer(ilp), intent(in)	n,
		complex(qp), intent(in)	wa,
		complex(qp), dimension(*), intent(inout)	wx,
		integer(ilp), intent(in)	incx )

WSCAL: scales a vector by a constant.

◆ la_wswap()

pure subroutine, public la_blas_level1::la_wswap	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(inout)	wx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(inout)	wy,
		integer(ilp), intent(in)	incy )

WSWAP: interchanges two vectors.

◆ la_zaxpy()

pure subroutine, public la_blas_level1::la_zaxpy	(	integer(ilp), intent(in)	n,
		complex(dp), intent(in)	za,
		complex(dp), dimension(*), intent(in)	zx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(inout)	zy,
		integer(ilp), intent(in)	incy )

ZAXPY: constant times a vector plus a vector.

Here is the call graph for this function:

◆ la_zcopy()

pure subroutine, public la_blas_level1::la_zcopy	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(in)	zx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(out)	zy,
		integer(ilp), intent(in)	incy )

ZCOPY: copies a vector, x, to a vector, y.

◆ la_zdotc()

pure complex(dp) function, public la_blas_level1::la_zdotc	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(in)	zx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(in)	zy,
		integer(ilp), intent(in)	incy )

ZDOTC: forms the dot product of two complex vectors ZDOTC = X^H * Y.

Here is the call graph for this function:

◆ la_zdotu()

pure complex(dp) function, public la_blas_level1::la_zdotu	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(in)	zx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(in)	zy,
		integer(ilp), intent(in)	incy )

ZDOTU: forms the dot product of two complex vectors ZDOTU = X^T * Y.

Here is the call graph for this function:

◆ la_zdrot()

pure subroutine, public la_blas_level1::la_zdrot	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(inout)	zx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(inout)	zy,
		integer(ilp), intent(in)	incy,
		real(dp), intent(in)	c,
		real(dp), intent(in)	s )

Applies a plane rotation, where the cos and sin (c and s) are real and the vectors cx and cy are complex. jack dongarra, linpack, 3/11/78.

◆ la_zdscal()

pure subroutine, public la_blas_level1::la_zdscal	(	integer(ilp), intent(in)	n,
		real(dp), intent(in)	da,
		complex(dp), dimension(*), intent(inout)	zx,
		integer(ilp), intent(in)	incx )

ZDSCAL: scales a vector by a constant.

◆ la_zrotg()

pure subroutine, public la_blas_level1::la_zrotg	(	complex(dp), intent(inout)	a,
		complex(dp), intent(in)	b,
		real(dp), intent(out)	c,
		complex(dp), intent(out)	s )

!

The computation uses the formulas |x| = sqrt( Re(x)**2 + Im(x)**2 ) sgn(x) = x / |x| if x /= 0 = 1 if x = 0 c = |a| / sqrt(|a|**2 + |b|**2) s = sgn(a) * conjg(b) / sqrt(|a|**2 + |b|**2) When a and b are real and r /= 0, the formulas simplify to r = sgn(a)*sqrt(|a|**2 + |b|**2) c = a / r s = b / r the same as in DROTG when |a| > |b|. When |b| >= |a|, the sign of c and s will be different from those computed by DROTG if the signs of a and b are not the same.

◆ la_zscal()

pure subroutine, public la_blas_level1::la_zscal	(	integer(ilp), intent(in)	n,
		complex(dp), intent(in)	za,
		complex(dp), dimension(*), intent(inout)	zx,
		integer(ilp), intent(in)	incx )

ZSCAL: scales a vector by a constant.

◆ la_zswap()

pure subroutine, public la_blas_level1::la_zswap	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(inout)	zx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(inout)	zy,
		integer(ilp), intent(in)	incy )

ZSWAP: interchanges two vectors.

Functions/Subroutines

Detailed Description

Function/Subroutine Documentation

◆ la_caxpy()

◆ la_ccopy()

◆ la_cdotc()

◆ la_cdotu()

◆ la_crotg()

◆ la_cscal()

◆ la_csrot()

◆ la_csscal()

◆ la_cswap()

◆ la_dasum()

◆ la_daxpy()

◆ la_dcopy()

◆ la_ddot()

◆ la_dnrm2()

◆ la_drot()

◆ la_drotg()

◆ la_drotm()

◆ la_drotmg()

◆ la_dscal()

◆ la_dsdot()

◆ la_dswap()

◆ la_dzasum()

◆ la_dznrm2()

◆ la_qasum()

◆ la_qaxpy()

◆ la_qcopy()

◆ la_qddot()

◆ la_qdot()

◆ la_qnrm2()

◆ la_qrot()

◆ la_qrotg()

◆ la_qrotm()

◆ la_qrotmg()

◆ la_qscal()

◆ la_qswap()

◆ la_qwasum()

◆ la_qwnrm2()

◆ la_sasum()

◆ la_saxpy()

◆ la_scasum()

◆ la_scnrm2()

◆ la_scopy()

◆ la_sdot()

◆ la_sdsdot()

◆ la_snrm2()

◆ la_srot()

◆ la_srotg()

◆ la_srotm()

◆ la_srotmg()

◆ la_sscal()

◆ la_sswap()

◆ la_waxpy()

◆ la_wcopy()

◆ la_wdotc()

◆ la_wdotu()

◆ la_wqrot()

◆ la_wqscal()

◆ la_wrotg()

◆ la_wscal()

◆ la_wswap()

◆ la_zaxpy()

◆ la_zcopy()

◆ la_zdotc()

◆ la_zdotu()

◆ la_zdrot()

◆ la_zdscal()

◆ la_zrotg()

◆ la_zscal()

◆ la_zswap()