la_blas_level2_gen Module Reference

BLAS level 2: general matrix-vector operations and rank updates. More...

Functions/Subroutines
pure subroutine, public	la_sgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	SGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
pure subroutine, public	la_dgemv (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_qgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	QGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.
pure subroutine, public	la_sger (m, n, alpha, x, incx, y, incy, a, lda)
	SGER: performs the rank 1 operation A := alpha*x*y**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.
pure subroutine, public	la_dger (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 subroutine, public	la_qger (m, n, alpha, x, incx, y, incy, a, lda)
	QGER: 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 subroutine, public	la_cgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	CGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*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_zgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	ZGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*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_wgemv (trans, m, n, alpha, a, lda, x, incx, beta, y, incy)
	WGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*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_cgerc (m, n, alpha, x, incx, y, incy, a, lda)
	CGERC: performs the rank 1 operation A := alpha*x*y**H + 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 subroutine, public	la_zgerc (m, n, alpha, x, incx, y, incy, a, lda)
	ZGERC: performs the rank 1 operation A := alpha*x*y**H + 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 subroutine, public	la_wgerc (m, n, alpha, x, incx, y, incy, a, lda)
	WGERC: performs the rank 1 operation A := alpha*x*y**H + 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 subroutine, public	la_cgeru (m, n, alpha, x, incx, y, incy, a, lda)
	CGERU: 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 subroutine, public	la_zgeru (m, n, alpha, x, incx, y, incy, a, lda)
	ZGERU: 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 subroutine, public	la_wgeru (m, n, alpha, x, incx, y, incy, a, lda)
	WGERU: 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 subroutine, public	la_chemv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	CHEMV: 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 hermitian matrix.
pure subroutine, public	la_zhemv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	ZHEMV: 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 hermitian matrix.
pure subroutine, public	la_whemv (uplo, n, alpha, a, lda, x, incx, beta, y, incy)
	WHEMV: 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 hermitian matrix.
pure subroutine, public	la_cher (uplo, n, alpha, x, incx, a, lda)
	CHER: performs the hermitian rank 1 operation A := alpha*x*x**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.
pure subroutine, public	la_zher (uplo, n, alpha, x, incx, a, lda)
	ZHER: performs the hermitian rank 1 operation A := alpha*x*x**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.
pure subroutine, public	la_wher (uplo, n, alpha, x, incx, a, lda)
	WHER: performs the hermitian rank 1 operation A := alpha*x*x**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.
pure subroutine, public	la_cher2 (uplo, n, alpha, x, incx, y, incy, a, lda)
	CHER2: performs the hermitian rank 2 operation A := alpha*x*y**H + conjg( alpha )*y*x**H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.
pure subroutine, public	la_zher2 (uplo, n, alpha, x, incx, y, incy, a, lda)
	ZHER2: performs the hermitian rank 2 operation A := alpha*x*y**H + conjg( alpha )*y*x**H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.
pure subroutine, public	la_wher2 (uplo, n, alpha, x, incx, y, incy, a, lda)
	WHER2: performs the hermitian rank 2 operation A := alpha*x*y**H + conjg( alpha )*y*x**H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.

Detailed Description

BLAS level 2: general matrix-vector operations and rank updates.

Function/Subroutine Documentation

la_cgemv()

pure subroutine, public la_blas_level2_gen::la_cgemv	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), intent(in)	beta,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

CGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*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_cgerc()

pure subroutine, public la_blas_level2_gen::la_cgerc	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

CGERC: performs the rank 1 operation A := alpha*x*y**H + 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_cgeru()

pure subroutine, public la_blas_level2_gen::la_cgeru	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

CGERU: 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_chemv()

pure subroutine, public la_blas_level2_gen::la_chemv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), intent(in)	beta,
		complex(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

CHEMV: 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 hermitian matrix.

Here is the call graph for this function:

la_cher()

pure subroutine, public la_blas_level2_gen::la_cher	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

CHER: performs the hermitian rank 1 operation A := alpha*x*x**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.

Here is the call graph for this function:

la_cher2()

pure subroutine, public la_blas_level2_gen::la_cher2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(sp), intent(in)	alpha,
		complex(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(sp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

CHER2: performs the hermitian rank 2 operation A := alpha*x*y**H + conjg( alpha )*y*x**H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.

Here is the call graph for this function:

la_dgemv()

pure subroutine, public la_blas_level2_gen::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_level2_gen::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_qgemv()

pure subroutine, public la_blas_level2_gen::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 )

QGEMV: 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_qger()

pure subroutine, public la_blas_level2_gen::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 )

QGER: 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_sgemv()

pure subroutine, public la_blas_level2_gen::la_sgemv	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		real(sp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), intent(in)	beta,
		real(sp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

SGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, where alpha and beta are scalars, x and y are vectors and A is an m by n matrix.

Here is the call graph for this function:

la_sger()

pure subroutine, public la_blas_level2_gen::la_sger	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), intent(in)	alpha,
		real(sp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		real(sp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

SGER: performs the rank 1 operation A := alpha*x*y**T + A, where alpha is a scalar, x is an m element vector, y is an n element vector and A is an m by n matrix.

Here is the call graph for this function:

la_wgemv()

pure subroutine, public la_blas_level2_gen::la_wgemv	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(qp), intent(in)	beta,
		complex(qp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

WGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*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_wgerc()

pure subroutine, public la_blas_level2_gen::la_wgerc	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

WGERC: performs the rank 1 operation A := alpha*x*y**H + 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_wgeru()

pure subroutine, public la_blas_level2_gen::la_wgeru	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

WGERU: 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_whemv()

pure subroutine, public la_blas_level2_gen::la_whemv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(qp), intent(in)	beta,
		complex(qp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

WHEMV: 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 hermitian matrix.

Here is the call graph for this function:

la_wher()

pure subroutine, public la_blas_level2_gen::la_wher	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(qp), intent(in)	alpha,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

WHER: performs the hermitian rank 1 operation A := alpha*x*x**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.

Here is the call graph for this function:

la_wher2()

pure subroutine, public la_blas_level2_gen::la_wher2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(qp), intent(in)	alpha,
		complex(qp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(qp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

WHER2: performs the hermitian rank 2 operation A := alpha*x*y**H + conjg( alpha )*y*x**H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.

Here is the call graph for this function:

la_zgemv()

pure subroutine, public la_blas_level2_gen::la_zgemv	(	character, intent(in)	trans,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(dp), intent(in)	beta,
		complex(dp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

ZGEMV: performs one of the matrix-vector operations y := alpha*A*x + beta*y, or y := alpha*A**T*x + beta*y, or y := alpha*A**H*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_zgerc()

pure subroutine, public la_blas_level2_gen::la_zgerc	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

ZGERC: performs the rank 1 operation A := alpha*x*y**H + 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_zgeru()

pure subroutine, public la_blas_level2_gen::la_zgeru	(	integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

ZGERU: 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_zhemv()

pure subroutine, public la_blas_level2_gen::la_zhemv	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), dimension(lda,*), intent(in)	a,
		integer(ilp), intent(in)	lda,
		complex(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(dp), intent(in)	beta,
		complex(dp), dimension(*), intent(inout)	y,
		integer(ilp), intent(in)	incy )

ZHEMV: 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 hermitian matrix.

Here is the call graph for this function:

la_zher()

pure subroutine, public la_blas_level2_gen::la_zher	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		real(dp), intent(in)	alpha,
		complex(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

ZHER: performs the hermitian rank 1 operation A := alpha*x*x**H + A, where alpha is a real scalar, x is an n element vector and A is an n by n hermitian matrix.

Here is the call graph for this function:

la_zher2()

pure subroutine, public la_blas_level2_gen::la_zher2	(	character, intent(in)	uplo,
		integer(ilp), intent(in)	n,
		complex(dp), intent(in)	alpha,
		complex(dp), dimension(*), intent(in)	x,
		integer(ilp), intent(in)	incx,
		complex(dp), dimension(*), intent(in)	y,
		integer(ilp), intent(in)	incy,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda )

ZHER2: performs the hermitian rank 2 operation A := alpha*x*y**H + conjg( alpha )*y*x**H + A, where alpha is a scalar, x and y are n element vectors and A is an n by n hermitian matrix.

Here is the call graph for this function: