la_lapack_eigv_svd_drivers Module Reference

SVD drivers: QR iteration and the rank-revealing preconditioned variant. More...

Functions/Subroutines
subroutine, public	la_sgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)
	SGESVD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.
subroutine, public	la_dgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)
	DGESVD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.
subroutine, public	la_qgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, info)
	QGESVD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.
subroutine, public	la_sgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)
	SGESVDQ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
subroutine, public	la_dgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)
	DGESVDQ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
subroutine, public	la_qgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, work, lwork, rwork, lrwork, info)
	QGESVDQ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
subroutine, public	la_cgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)
	CGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.
subroutine, public	la_zgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)
	ZGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.
subroutine, public	la_wgesvd (jobu, jobvt, m, n, a, lda, s, u, ldu, vt, ldvt, work, lwork, rwork, info)
	WGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.
subroutine, public	la_cgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)
	CGESVDQ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
subroutine, public	la_zgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)
	ZCGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.
subroutine, public	la_wgesvdq (joba, jobp, jobr, jobu, jobv, m, n, a, lda, s, u, ldu, v, ldv, numrank, iwork, liwork, cwork, lcwork, rwork, lrwork, info)
	ZCGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Detailed Description

SVD drivers: QR iteration and the rank-revealing preconditioned variant.

Function/Subroutine Documentation

la_cgesvd()

subroutine, public la_lapack_eigv_svd_drivers::la_cgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		complex(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

CGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

Here is the call graph for this function:

la_cgesvdq()

subroutine, public la_lapack_eigv_svd_drivers::la_cgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		complex(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		complex(sp), dimension(*), intent(out)	cwork,
		integer(ilp), intent(inout)	lcwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

CGESVDQ: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

la_dgesvd()

subroutine, public la_lapack_eigv_svd_drivers::la_dgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(out)	s,
		real(dp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		real(dp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

DGESVD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.

Here is the call graph for this function:

la_dgesvdq()

subroutine, public la_lapack_eigv_svd_drivers::la_dgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(out)	s,
		real(dp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		real(dp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		real(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(inout)	lwork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

DGESVDQ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

la_qgesvd()

subroutine, public la_lapack_eigv_svd_drivers::la_qgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	s,
		real(qp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		real(qp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

QGESVD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.

Here is the call graph for this function:

la_qgesvdq()

subroutine, public la_lapack_eigv_svd_drivers::la_qgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	s,
		real(qp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		real(qp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		real(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(inout)	lwork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

QGESVDQ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

la_sgesvd()

subroutine, public la_lapack_eigv_svd_drivers::la_sgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		real(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		real(sp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		integer(ilp), intent(out)	info )

SGESVD: computes the singular value decomposition (SVD) of a real M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M orthogonal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**T, not V.

Here is the call graph for this function:

la_sgesvdq()

subroutine, public la_lapack_eigv_svd_drivers::la_sgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		real(sp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(sp), dimension(*), intent(out)	s,
		real(sp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		real(sp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		real(sp), dimension(*), intent(out)	work,
		integer(ilp), intent(inout)	lwork,
		real(sp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

SGESVDQ: computes the singular value decomposition (SVD) of a real M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N orthogonal matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

la_wgesvd()

subroutine, public la_lapack_eigv_svd_drivers::la_wgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	s,
		complex(qp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(qp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		complex(qp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

WGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

Here is the call graph for this function:

la_wgesvdq()

subroutine, public la_lapack_eigv_svd_drivers::la_wgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(qp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(qp), dimension(*), intent(out)	s,
		complex(qp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(qp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		complex(qp), dimension(*), intent(out)	cwork,
		integer(ilp), intent(inout)	lcwork,
		real(qp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

ZCGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function:

la_zgesvd()

subroutine, public la_lapack_eigv_svd_drivers::la_zgesvd	(	character, intent(in)	jobu,
		character, intent(in)	jobvt,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(out)	s,
		complex(dp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(dp), dimension(ldvt,*), intent(out)	vt,
		integer(ilp), intent(in)	ldvt,
		complex(dp), dimension(*), intent(out)	work,
		integer(ilp), intent(in)	lwork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(out)	info )

ZGESVD: computes the singular value decomposition (SVD) of a complex M-by-N matrix A, optionally computing the left and/or right singular vectors. The SVD is written A = U * SIGMA * conjugate-transpose(V) where SIGMA is an M-by-N matrix which is zero except for its min(m,n) diagonal elements, U is an M-by-M unitary matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A; they are real and non-negative, and are returned in descending order. The first min(m,n) columns of U and V are the left and right singular vectors of A. Note that the routine returns V**H, not V.

Here is the call graph for this function:

la_zgesvdq()

subroutine, public la_lapack_eigv_svd_drivers::la_zgesvdq	(	character, intent(in)	joba,
		character, intent(in)	jobp,
		character, intent(in)	jobr,
		character, intent(in)	jobu,
		character, intent(in)	jobv,
		integer(ilp), intent(in)	m,
		integer(ilp), intent(in)	n,
		complex(dp), dimension(lda,*), intent(inout)	a,
		integer(ilp), intent(in)	lda,
		real(dp), dimension(*), intent(out)	s,
		complex(dp), dimension(ldu,*), intent(out)	u,
		integer(ilp), intent(in)	ldu,
		complex(dp), dimension(ldv,*), intent(out)	v,
		integer(ilp), intent(in)	ldv,
		integer(ilp), intent(out)	numrank,
		integer(ilp), dimension(*), intent(out)	iwork,
		integer(ilp), intent(in)	liwork,
		complex(dp), dimension(*), intent(out)	cwork,
		integer(ilp), intent(inout)	lcwork,
		real(dp), dimension(*), intent(out)	rwork,
		integer(ilp), intent(in)	lrwork,
		integer(ilp), intent(out)	info )

ZCGESVDQ computes the singular value decomposition (SVD) of a complex M-by-N matrix A, where M >= N. The SVD of A is written as [++] [xx] [x0] [xx] A = U * SIGMA * V^*, [++] = [xx] * [ox] * [xx] [++] [xx] where SIGMA is an N-by-N diagonal matrix, U is an M-by-N orthonormal matrix, and V is an N-by-N unitary matrix. The diagonal elements of SIGMA are the singular values of A. The columns of U and V are the left and the right singular vectors of A, respectively.

Here is the call graph for this function: