LAPACK auxiliary: machine parameters, safe division, band scaling. More...

Functions/Subroutines
pure subroutine, public	la_slabad (small, large)
	SLABAD: takes as input the values computed by SLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by SLAMCH. This subroutine is needed because SLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

pure subroutine, public	la_dlabad (small, large)
	DLABAD: takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

pure subroutine, public	la_qlabad (small, large)
	QLABAD: takes as input the values computed by QLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by QLAMCH. This subroutine is needed because QLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

pure real(sp) function, public	la_sladiv2 (a, b, c, d, r, t)

pure real(dp) function, public	la_dladiv2 (a, b, c, d, r, t)

pure real(qp) function, public	la_qladiv2 (a, b, c, d, r, t)

pure real(sp) function, public	la_slamch (cmach)
	SLAMCH: determines single precision machine parameters.

pure real(dp) function, public	la_dlamch (cmach)
	DLAMCH: determines double precision machine parameters.

pure real(qp) function, public	la_qlamch (cmach)
	QLAMCH: determines quad precision machine parameters.

pure real(sp) function, public	la_slamc3 (a, b)

pure real(dp) function, public	la_dlamc3 (a, b)

pure real(qp) function, public	la_qlamc3 (a, b)

pure subroutine, public	la_slaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	SLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_dlaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	DLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_qlaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	QLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure real(sp) function, public	la_scsum1 (n, cx, incx)
	SCSUM1: takes the sum of the absolute values of a complex vector and returns a single precision result. Based on SCASUM from the Level 1 BLAS. The change is to use the 'genuine' absolute value.

pure real(dp) function, public	la_dzsum1 (n, cx, incx)
	DZSUM1: takes the sum of the absolute values of a complex vector and returns a double precision result. Based on DZASUM from the Level 1 BLAS. The change is to use the 'genuine' absolute value.

pure real(qp) function, public	la_qwsum1 (n, cx, incx)
	QWSUM1: takes the sum of the absolute values of a complex vector and returns a quad precision result. Based on QWASUM from the Level 1 BLAS. The change is to use the 'genuine' absolute value.

pure subroutine, public	la_sladiv1 (a, b, c, d, p, q)

pure subroutine, public	la_dladiv1 (a, b, c, d, p, q)

pure subroutine, public	la_qladiv1 (a, b, c, d, p, q)

pure subroutine, public	la_claqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	CLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_zlaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	ZLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_wlaqsb (uplo, n, kd, ab, ldab, s, scond, amax, equed)
	WLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

pure subroutine, public	la_crot (n, cx, incx, cy, incy, c, s)
	CROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

pure subroutine, public	la_zrot (n, cx, incx, cy, incy, c, s)
	ZROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

pure subroutine, public	la_wrot (n, cx, incx, cy, incy, c, s)
	WROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

Detailed Description

LAPACK auxiliary: machine parameters, safe division, band scaling.

Function/Subroutine Documentation

◆ la_claqsb()

pure subroutine, public la_lapack_auxiliary::la_claqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed )

CLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

Here is the call graph for this function:

◆ la_crot()

pure subroutine, public la_lapack_auxiliary::la_crot	(	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,
		complex(sp), intent(in)	s )

CROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

◆ la_dlabad()

pure subroutine, public la_lapack_auxiliary::la_dlabad	(	real(dp), intent(inout)	small,
		real(dp), intent(inout)	large )

DLABAD: takes as input the values computed by DLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by DLAMCH. This subroutine is needed because DLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

◆ la_dladiv1()

pure subroutine, public la_lapack_auxiliary::la_dladiv1	(	real(dp), intent(inout)	a,
		real(dp), intent(in)	b,
		real(dp), intent(in)	c,
		real(dp), intent(in)	d,
		real(dp), intent(out)	p,
		real(dp), intent(out)	q )

Here is the call graph for this function:

◆ la_dladiv2()

pure real(dp) function, public la_lapack_auxiliary::la_dladiv2	(	real(dp), intent(in)	a,
		real(dp), intent(in)	b,
		real(dp), intent(in)	c,
		real(dp), intent(in)	d,
		real(dp), intent(in)	r,
		real(dp), intent(in)	t )

Here is the call graph for this function:

◆ la_dlamc3()

pure real(dp) function, public la_lapack_auxiliary::la_dlamc3	(	real(dp), intent(in)	a,
		real(dp), intent(in)	b )

Here is the call graph for this function:

◆ la_dlamch()

pure real(dp) function, public la_lapack_auxiliary::la_dlamch ( character, intent(in) cmach )

DLAMCH: determines double precision machine parameters.

Here is the call graph for this function:

◆ la_dlaqsb()

pure subroutine, public la_lapack_auxiliary::la_dlaqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		real(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(dp), dimension(*), intent(in)	s,
		real(dp), intent(in)	scond,
		real(dp), intent(in)	amax,
		character, intent(out)	equed )

DLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

Here is the call graph for this function:

◆ la_dzsum1()

pure real(dp) function, public la_lapack_auxiliary::la_dzsum1	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx )

DZSUM1: takes the sum of the absolute values of a complex vector and returns a double precision result. Based on DZASUM from the Level 1 BLAS. The change is to use the 'genuine' absolute value.

Here is the call graph for this function:

◆ la_qlabad()

pure subroutine, public la_lapack_auxiliary::la_qlabad	(	real(qp), intent(inout)	small,
		real(qp), intent(inout)	large )

QLABAD: takes as input the values computed by QLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by QLAMCH. This subroutine is needed because QLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

◆ la_qladiv1()

pure subroutine, public la_lapack_auxiliary::la_qladiv1	(	real(qp), intent(inout)	a,
		real(qp), intent(in)	b,
		real(qp), intent(in)	c,
		real(qp), intent(in)	d,
		real(qp), intent(out)	p,
		real(qp), intent(out)	q )

Here is the call graph for this function:

◆ la_qladiv2()

pure real(qp) function, public la_lapack_auxiliary::la_qladiv2	(	real(qp), intent(in)	a,
		real(qp), intent(in)	b,
		real(qp), intent(in)	c,
		real(qp), intent(in)	d,
		real(qp), intent(in)	r,
		real(qp), intent(in)	t )

Here is the call graph for this function:

◆ la_qlamc3()

pure real(qp) function, public la_lapack_auxiliary::la_qlamc3	(	real(qp), intent(in)	a,
		real(qp), intent(in)	b )

Here is the call graph for this function:

◆ la_qlamch()

pure real(qp) function, public la_lapack_auxiliary::la_qlamch ( character, intent(in) cmach )

QLAMCH: determines quad precision machine parameters.

Here is the call graph for this function:

◆ la_qlaqsb()

pure subroutine, public la_lapack_auxiliary::la_qlaqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		real(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(qp), dimension(*), intent(in)	s,
		real(qp), intent(in)	scond,
		real(qp), intent(in)	amax,
		character, intent(out)	equed )

QLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

Here is the call graph for this function:

◆ la_qwsum1()

pure real(qp) function, public la_lapack_auxiliary::la_qwsum1	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx )

QWSUM1: takes the sum of the absolute values of a complex vector and returns a quad precision result. Based on QWASUM from the Level 1 BLAS. The change is to use the 'genuine' absolute value.

Here is the call graph for this function:

◆ la_scsum1()

pure real(sp) function, public la_lapack_auxiliary::la_scsum1	(	integer(ilp), intent(in)	n,
		complex(sp), dimension(*), intent(in)	cx,
		integer(ilp), intent(in)	incx )

SCSUM1: takes the sum of the absolute values of a complex vector and returns a single precision result. Based on SCASUM from the Level 1 BLAS. The change is to use the 'genuine' absolute value.

Here is the call graph for this function:

◆ la_slabad()

pure subroutine, public la_lapack_auxiliary::la_slabad	(	real(sp), intent(inout)	small,
		real(sp), intent(inout)	large )

SLABAD: takes as input the values computed by SLAMCH for underflow and overflow, and returns the square root of each of these values if the log of LARGE is sufficiently large. This subroutine is intended to identify machines with a large exponent range, such as the Crays, and redefine the underflow and overflow limits to be the square roots of the values computed by SLAMCH. This subroutine is needed because SLAMCH does not compensate for poor arithmetic in the upper half of the exponent range, as is found on a Cray.

◆ la_sladiv1()

pure subroutine, public la_lapack_auxiliary::la_sladiv1	(	real(sp), intent(inout)	a,
		real(sp), intent(in)	b,
		real(sp), intent(in)	c,
		real(sp), intent(in)	d,
		real(sp), intent(out)	p,
		real(sp), intent(out)	q )

Here is the call graph for this function:

◆ la_sladiv2()

pure real(sp) function, public la_lapack_auxiliary::la_sladiv2	(	real(sp), intent(in)	a,
		real(sp), intent(in)	b,
		real(sp), intent(in)	c,
		real(sp), intent(in)	d,
		real(sp), intent(in)	r,
		real(sp), intent(in)	t )

Here is the call graph for this function:

◆ la_slamc3()

pure real(sp) function, public la_lapack_auxiliary::la_slamc3	(	real(sp), intent(in)	a,
		real(sp), intent(in)	b )

Here is the call graph for this function:

◆ la_slamch()

pure real(sp) function, public la_lapack_auxiliary::la_slamch ( character, intent(in) cmach )

SLAMCH: determines single precision machine parameters.

Here is the call graph for this function:

◆ la_slaqsb()

pure subroutine, public la_lapack_auxiliary::la_slaqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		real(sp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(sp), dimension(*), intent(in)	s,
		real(sp), intent(in)	scond,
		real(sp), intent(in)	amax,
		character, intent(out)	equed )

SLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

Here is the call graph for this function:

◆ la_wlaqsb()

pure subroutine, public la_lapack_auxiliary::la_wlaqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(qp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(qp), dimension(*), intent(in)	s,
		real(qp), intent(in)	scond,
		real(qp), intent(in)	amax,
		character, intent(out)	equed )

WLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

Here is the call graph for this function:

◆ la_wrot()

pure subroutine, public la_lapack_auxiliary::la_wrot	(	integer(ilp), intent(in)	n,
		complex(qp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy,
		real(qp), intent(in)	c,
		complex(qp), intent(in)	s )

WROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

◆ la_zlaqsb()

pure subroutine, public la_lapack_auxiliary::la_zlaqsb	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		integer(ilp), intent(in)	kd,
		complex(dp), dimension(ldab,*), intent(inout)	ab,
		integer(ilp), intent(in)	ldab,
		real(dp), dimension(*), intent(in)	s,
		real(dp), intent(in)	scond,
		real(dp), intent(in)	amax,
		character, intent(out)	equed )

ZLAQSB: equilibrates a symmetric band matrix A using the scaling factors in the vector S.

Here is the call graph for this function:

◆ la_zrot()

pure subroutine, public la_lapack_auxiliary::la_zrot	(	integer(ilp), intent(in)	n,
		complex(dp), dimension(*), intent(inout)	cx,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(inout)	cy,
		integer(ilp), intent(in)	incy,
		real(dp), intent(in)	c,
		complex(dp), intent(in)	s )

ZROT: applies a plane rotation, where the cos (C) is real and the sin (S) is complex, and the vectors CX and CY are complex.

Functions/Subroutines

Detailed Description

Function/Subroutine Documentation

◆ la_claqsb()

◆ la_crot()

◆ la_dlabad()

◆ la_dladiv1()

◆ la_dladiv2()

◆ la_dlamc3()

◆ la_dlamch()

◆ la_dlaqsb()

◆ la_dzsum1()

◆ la_qlabad()

◆ la_qladiv1()

◆ la_qladiv2()

◆ la_qlamc3()

◆ la_qlamch()

◆ la_qlaqsb()

◆ la_qwsum1()

◆ la_scsum1()

◆ la_slabad()

◆ la_sladiv1()

◆ la_sladiv2()

◆ la_slamc3()

◆ la_slamch()

◆ la_slaqsb()

◆ la_wlaqsb()

◆ la_wrot()

◆ la_zlaqsb()

◆ la_zrot()