Loading...
Searching...
No Matches
or/unmbr: Multiply by Q or P from bidiagonal reduction
Dense LA » Singular Value Decomposition (SVD)

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

## Detailed Description

## Function Documentation

## magma_cunmbr()

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

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

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

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