or/unmbr: Multiply by Q or P from bidiagonal reduction

Functions
magma_int_t	magma_cunmbr (magma_vect_t vect, magma_side_t side, magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t k, magmaFloatComplex *A, magma_int_t lda, magmaFloatComplex *tau, magmaFloatComplex *C, magma_int_t ldc, magmaFloatComplex *work, magma_int_t lwork, magma_int_t *info)
	CUNMBR multiplies by Q or P as part of the SVD decomposition. More...
magma_int_t	magma_dormbr (magma_vect_t vect, magma_side_t side, magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t k, double *A, magma_int_t lda, double *tau, double *C, magma_int_t ldc, double *work, magma_int_t lwork, magma_int_t *info)
	DORMBR multiplies by Q or P as part of the SVD decomposition. More...
magma_int_t	magma_sormbr (magma_vect_t vect, magma_side_t side, magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t k, float *A, magma_int_t lda, float *tau, float *C, magma_int_t ldc, float *work, magma_int_t lwork, magma_int_t *info)
	SORMBR multiplies by Q or P as part of the SVD decomposition. More...
magma_int_t	magma_zunmbr (magma_vect_t vect, magma_side_t side, magma_trans_t trans, magma_int_t m, magma_int_t n, magma_int_t k, magmaDoubleComplex *A, magma_int_t lda, magmaDoubleComplex *tau, magmaDoubleComplex *C, magma_int_t ldc, magmaDoubleComplex *work, magma_int_t lwork, magma_int_t *info)
	ZUNMBR multiplies by Q or P as part of the SVD decomposition. More...

Detailed Description

Function Documentation

magma_int_t magma_cunmbr	(	magma_vect_t	vect,
		magma_side_t	side,
		magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	k,
		magmaFloatComplex *	A,
		magma_int_t	lda,
		magmaFloatComplex *	tau,
		magmaFloatComplex *	C,
		magma_int_t	ldc,
		magmaFloatComplex *	work,
		magma_int_t	lwork,
		magma_int_t *	info
	)

CUNMBR multiplies by Q or P as part of the SVD decomposition.

If VECT = MagmaQ, CUNMBR overwrites the general complex M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q*C C*Q TRANS = Magma_ConjTrans: Q**H*C C*Q**H

If VECT = MagmaP, CUNMBR overwrites the general complex M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: P*C C*P TRANS = Magma_ConjTrans: P**H*C C*P**H

Here Q and P**H are the unitary matrices determined by CGEBRD when reducing A complex matrix A to bidiagonal form: A = Q*B * P**H. Q and P**H are defined as products of elementary reflectors H(i) and G(i) respectively.

Let nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Thus nq is the order of the unitary matrix Q or P**H that is applied.

If VECT = MagmaQ, A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1).

If VECT = MagmaP, A is assumed to have been A K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

Parameters

[in]	vect	magma_vect_t = MagmaQ: apply Q or Q**H; = MagmaP: apply P or P**H.
[in]	side	magma_side_t = MagmaLeft: apply Q, Q**H, P or P**H from the Left; = MagmaRight: apply Q, Q**H, P or P**H from the Right.
[in]	trans	magma_trans_t = MagmaNoTrans: No transpose, apply Q or P; = Magma_ConjTrans: Conjugate transpose, apply Q**H or P**H.
[in]	m	INTEGER The number of rows of the matrix C. M >= 0.
[in]	n	INTEGER The number of columns of the matrix C. N >= 0.
[in]	k	INTEGER If VECT = MagmaQ, the number of columns in the original matrix reduced by CGEBRD. If VECT = MagmaP, the number of rows in the original matrix reduced by CGEBRD. K >= 0.
[in]	A	COMPLEX array, dimension (LDA,min(nq,K)) if VECT = MagmaQ (LDA,nq) if VECT = MagmaP The vectors which define the elementary reflectors H(i) and G(i), whose products determine the matrices Q and P, as returned by CGEBRD.
[in]	lda	INTEGER The leading dimension of the array A. If VECT = MagmaQ, LDA >= max(1,nq); if VECT = MagmaP, LDA >= max(1,min(nq,K)).
[in]	tau	COMPLEX array, dimension (min(nq,K)) TAU(i) must contain the scalar factor of the elementary reflector H(i) or G(i) which determines Q or P, as returned by CGEBRD in the array argument TAUQ or TAUP.
[in,out]	C	COMPLEX array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q or P*C or P**H*C or C*P or C*P**H.
[in]	ldc	INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]	work	(workspace) COMPLEX array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M); if N = 0 or M = 0, LWORK >= 1. For optimum performance if SIDE = MagmaLeft, LWORK >= max(1,N*NB); if SIDE = MagmaRight, LWORK >= max(1,M*NB), where NB is the optimal blocksize. (NB = 0 if M = 0 or N = 0.) If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_dormbr	(	magma_vect_t	vect,
		magma_side_t	side,
		magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	k,
		double *	A,
		magma_int_t	lda,
		double *	tau,
		double *	C,
		magma_int_t	ldc,
		double *	work,
		magma_int_t	lwork,
		magma_int_t *	info
	)

DORMBR multiplies by Q or P as part of the SVD decomposition.

If VECT = MagmaQ, DORMBR overwrites the general real M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q*C C*Q TRANS = MagmaTrans: Q**H*C C*Q**H

If VECT = MagmaP, DORMBR overwrites the general real M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: P*C C*P TRANS = MagmaTrans: P**H*C C*P**H

Here Q and P**H are the orthogonal matrices determined by DGEBRD when reducing A real matrix A to bidiagonal form: A = Q*B * P**H. Q and P**H are defined as products of elementary reflectors H(i) and G(i) respectively.

Let nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Thus nq is the order of the orthogonal matrix Q or P**H that is applied.

If VECT = MagmaQ, A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1).

If VECT = MagmaP, A is assumed to have been A K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

Parameters

[in]	vect	magma_vect_t = MagmaQ: apply Q or Q**H; = MagmaP: apply P or P**H.
[in]	side	magma_side_t = MagmaLeft: apply Q, Q**H, P or P**H from the Left; = MagmaRight: apply Q, Q**H, P or P**H from the Right.
[in]	trans	magma_trans_t = MagmaNoTrans: No transpose, apply Q or P; = MagmaTrans: Conjugate transpose, apply Q**H or P**H.
[in]	m	INTEGER The number of rows of the matrix C. M >= 0.
[in]	n	INTEGER The number of columns of the matrix C. N >= 0.
[in]	k	INTEGER If VECT = MagmaQ, the number of columns in the original matrix reduced by DGEBRD. If VECT = MagmaP, the number of rows in the original matrix reduced by DGEBRD. K >= 0.
[in]	A	DOUBLE PRECISION array, dimension (LDA,min(nq,K)) if VECT = MagmaQ (LDA,nq) if VECT = MagmaP The vectors which define the elementary reflectors H(i) and G(i), whose products determine the matrices Q and P, as returned by DGEBRD.
[in]	lda	INTEGER The leading dimension of the array A. If VECT = MagmaQ, LDA >= max(1,nq); if VECT = MagmaP, LDA >= max(1,min(nq,K)).
[in]	tau	DOUBLE PRECISION array, dimension (min(nq,K)) TAU(i) must contain the scalar factor of the elementary reflector H(i) or G(i) which determines Q or P, as returned by DGEBRD in the array argument TAUQ or TAUP.
[in,out]	C	DOUBLE PRECISION array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q or P*C or P**H*C or C*P or C*P**H.
[in]	ldc	INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]	work	(workspace) DOUBLE PRECISION array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M); if N = 0 or M = 0, LWORK >= 1. For optimum performance if SIDE = MagmaLeft, LWORK >= max(1,N*NB); if SIDE = MagmaRight, LWORK >= max(1,M*NB), where NB is the optimal blocksize. (NB = 0 if M = 0 or N = 0.) If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_sormbr	(	magma_vect_t	vect,
		magma_side_t	side,
		magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	k,
		float *	A,
		magma_int_t	lda,
		float *	tau,
		float *	C,
		magma_int_t	ldc,
		float *	work,
		magma_int_t	lwork,
		magma_int_t *	info
	)

SORMBR multiplies by Q or P as part of the SVD decomposition.

If VECT = MagmaQ, SORMBR overwrites the general real M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q*C C*Q TRANS = MagmaTrans: Q**H*C C*Q**H

If VECT = MagmaP, SORMBR overwrites the general real M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: P*C C*P TRANS = MagmaTrans: P**H*C C*P**H

Here Q and P**H are the orthogonal matrices determined by SGEBRD when reducing A real matrix A to bidiagonal form: A = Q*B * P**H. Q and P**H are defined as products of elementary reflectors H(i) and G(i) respectively.

Let nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Thus nq is the order of the orthogonal matrix Q or P**H that is applied.

If VECT = MagmaQ, A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1).

If VECT = MagmaP, A is assumed to have been A K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

Parameters

[in]	vect	magma_vect_t = MagmaQ: apply Q or Q**H; = MagmaP: apply P or P**H.
[in]	side	magma_side_t = MagmaLeft: apply Q, Q**H, P or P**H from the Left; = MagmaRight: apply Q, Q**H, P or P**H from the Right.
[in]	trans	magma_trans_t = MagmaNoTrans: No transpose, apply Q or P; = MagmaTrans: Conjugate transpose, apply Q**H or P**H.
[in]	m	INTEGER The number of rows of the matrix C. M >= 0.
[in]	n	INTEGER The number of columns of the matrix C. N >= 0.
[in]	k	INTEGER If VECT = MagmaQ, the number of columns in the original matrix reduced by SGEBRD. If VECT = MagmaP, the number of rows in the original matrix reduced by SGEBRD. K >= 0.
[in]	A	REAL array, dimension (LDA,min(nq,K)) if VECT = MagmaQ (LDA,nq) if VECT = MagmaP The vectors which define the elementary reflectors H(i) and G(i), whose products determine the matrices Q and P, as returned by SGEBRD.
[in]	lda	INTEGER The leading dimension of the array A. If VECT = MagmaQ, LDA >= max(1,nq); if VECT = MagmaP, LDA >= max(1,min(nq,K)).
[in]	tau	REAL array, dimension (min(nq,K)) TAU(i) must contain the scalar factor of the elementary reflector H(i) or G(i) which determines Q or P, as returned by SGEBRD in the array argument TAUQ or TAUP.
[in,out]	C	REAL array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q or P*C or P**H*C or C*P or C*P**H.
[in]	ldc	INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]	work	(workspace) REAL array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M); if N = 0 or M = 0, LWORK >= 1. For optimum performance if SIDE = MagmaLeft, LWORK >= max(1,N*NB); if SIDE = MagmaRight, LWORK >= max(1,M*NB), where NB is the optimal blocksize. (NB = 0 if M = 0 or N = 0.) If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value

magma_int_t magma_zunmbr	(	magma_vect_t	vect,
		magma_side_t	side,
		magma_trans_t	trans,
		magma_int_t	m,
		magma_int_t	n,
		magma_int_t	k,
		magmaDoubleComplex *	A,
		magma_int_t	lda,
		magmaDoubleComplex *	tau,
		magmaDoubleComplex *	C,
		magma_int_t	ldc,
		magmaDoubleComplex *	work,
		magma_int_t	lwork,
		magma_int_t *	info
	)

ZUNMBR multiplies by Q or P as part of the SVD decomposition.

If VECT = MagmaQ, ZUNMBR overwrites the general complex M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: Q*C C*Q TRANS = Magma_ConjTrans: Q**H*C C*Q**H

If VECT = MagmaP, ZUNMBR overwrites the general complex M-by-N matrix C with SIDE = MagmaLeft SIDE = MagmaRight TRANS = MagmaNoTrans: P*C C*P TRANS = Magma_ConjTrans: P**H*C C*P**H

Here Q and P**H are the unitary matrices determined by ZGEBRD when reducing A complex matrix A to bidiagonal form: A = Q*B * P**H. Q and P**H are defined as products of elementary reflectors H(i) and G(i) respectively.

Let nq = m if SIDE = MagmaLeft and nq = n if SIDE = MagmaRight. Thus nq is the order of the unitary matrix Q or P**H that is applied.

If VECT = MagmaQ, A is assumed to have been an NQ-by-K matrix: if nq >= k, Q = H(1) H(2) . . . H(k); if nq < k, Q = H(1) H(2) . . . H(nq-1).

If VECT = MagmaP, A is assumed to have been A K-by-NQ matrix: if k < nq, P = G(1) G(2) . . . G(k); if k >= nq, P = G(1) G(2) . . . G(nq-1).

Parameters

[in]	vect	magma_vect_t = MagmaQ: apply Q or Q**H; = MagmaP: apply P or P**H.
[in]	side	magma_side_t = MagmaLeft: apply Q, Q**H, P or P**H from the Left; = MagmaRight: apply Q, Q**H, P or P**H from the Right.
[in]	trans	magma_trans_t = MagmaNoTrans: No transpose, apply Q or P; = Magma_ConjTrans: Conjugate transpose, apply Q**H or P**H.
[in]	m	INTEGER The number of rows of the matrix C. M >= 0.
[in]	n	INTEGER The number of columns of the matrix C. N >= 0.
[in]	k	INTEGER If VECT = MagmaQ, the number of columns in the original matrix reduced by ZGEBRD. If VECT = MagmaP, the number of rows in the original matrix reduced by ZGEBRD. K >= 0.
[in]	A	COMPLEX_16 array, dimension (LDA,min(nq,K)) if VECT = MagmaQ (LDA,nq) if VECT = MagmaP The vectors which define the elementary reflectors H(i) and G(i), whose products determine the matrices Q and P, as returned by ZGEBRD.
[in]	lda	INTEGER The leading dimension of the array A. If VECT = MagmaQ, LDA >= max(1,nq); if VECT = MagmaP, LDA >= max(1,min(nq,K)).
[in]	tau	COMPLEX_16 array, dimension (min(nq,K)) TAU(i) must contain the scalar factor of the elementary reflector H(i) or G(i) which determines Q or P, as returned by ZGEBRD in the array argument TAUQ or TAUP.
[in,out]	C	COMPLEX_16 array, dimension (LDC,N) On entry, the M-by-N matrix C. On exit, C is overwritten by Q*C or Q**H*C or C*Q**H or C*Q or P*C or P**H*C or C*P or C*P**H.
[in]	ldc	INTEGER The leading dimension of the array C. LDC >= max(1,M).
[out]	work	(workspace) COMPLEX_16 array, dimension (MAX(1,LWORK)) On exit, if INFO = 0, WORK[0] returns the optimal LWORK.
[in]	lwork	INTEGER The dimension of the array WORK. If SIDE = MagmaLeft, LWORK >= max(1,N); if SIDE = MagmaRight, LWORK >= max(1,M); if N = 0 or M = 0, LWORK >= 1. For optimum performance if SIDE = MagmaLeft, LWORK >= max(1,N*NB); if SIDE = MagmaRight, LWORK >= max(1,M*NB), where NB is the optimal blocksize. (NB = 0 if M = 0 or N = 0.) If LWORK = -1, then a workspace query is assumed; the routine only calculates the optimal size of the WORK array, returns this value as the first entry of the WORK array, and no error message related to LWORK is issued by XERBLA.
[out]	info	INTEGER = 0: successful exit < 0: if INFO = -i, the i-th argument had an illegal value