zungbr (3p)

Name

zungbr - mined by ZGEBRD when reducing a complex matrix A to bidiagonal form

Synopsis

SUBROUTINE ZUNGBR(VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO)

CHARACTER*1 VECT
DOUBLE COMPLEX A(LDA,*), TAU(*), WORK(*)
INTEGER M, N, K, LDA, LWORK, INFO

SUBROUTINE ZUNGBR_64(VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO)

CHARACTER*1 VECT
DOUBLE COMPLEX A(LDA,*), TAU(*), WORK(*)
INTEGER*8 M, N, K, LDA, LWORK, INFO




F95 INTERFACE
SUBROUTINE UNGBR(VECT, M, N, K, A, LDA, TAU, WORK, LWORK,
INFO)

CHARACTER(LEN=1) :: VECT
COMPLEX(8), DIMENSION(:) :: TAU, WORK
COMPLEX(8), DIMENSION(:,:) :: A
INTEGER :: M, N, K, LDA, LWORK, INFO

SUBROUTINE UNGBR_64(VECT, M, N, K, A, LDA, TAU, WORK, LWORK,
INFO)

CHARACTER(LEN=1) :: VECT
COMPLEX(8), DIMENSION(:) :: TAU, WORK
COMPLEX(8), DIMENSION(:,:) :: A
INTEGER(8) :: M, N, K, LDA, LWORK, INFO




C INTERFACE
#include <sunperf.h>

void zungbr(char vect, int m, int n, int k, doublecomplex *a, int  lda,
doublecomplex *tau, int *info);

void  zungbr_64(char  vect,  long  m, long n, long k, doublecomplex *a,
long lda, doublecomplex *tau, long *info);

Description

Oracle Solaris Studio Performance Library                           zungbr(3P)



NAME
       zungbr  - generate one of the complex unitary matrices Q or P**H deter-
       mined by ZGEBRD when reducing a complex matrix A to bidiagonal form


SYNOPSIS
       SUBROUTINE ZUNGBR(VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO)

       CHARACTER*1 VECT
       DOUBLE COMPLEX A(LDA,*), TAU(*), WORK(*)
       INTEGER M, N, K, LDA, LWORK, INFO

       SUBROUTINE ZUNGBR_64(VECT, M, N, K, A, LDA, TAU, WORK, LWORK, INFO)

       CHARACTER*1 VECT
       DOUBLE COMPLEX A(LDA,*), TAU(*), WORK(*)
       INTEGER*8 M, N, K, LDA, LWORK, INFO




   F95 INTERFACE
       SUBROUTINE UNGBR(VECT, M, N, K, A, LDA, TAU, WORK, LWORK,
              INFO)

       CHARACTER(LEN=1) :: VECT
       COMPLEX(8), DIMENSION(:) :: TAU, WORK
       COMPLEX(8), DIMENSION(:,:) :: A
       INTEGER :: M, N, K, LDA, LWORK, INFO

       SUBROUTINE UNGBR_64(VECT, M, N, K, A, LDA, TAU, WORK, LWORK,
              INFO)

       CHARACTER(LEN=1) :: VECT
       COMPLEX(8), DIMENSION(:) :: TAU, WORK
       COMPLEX(8), DIMENSION(:,:) :: A
       INTEGER(8) :: M, N, K, LDA, LWORK, INFO




   C INTERFACE
       #include <sunperf.h>

       void zungbr(char vect, int m, int n, int k, doublecomplex *a, int  lda,
                 doublecomplex *tau, int *info);

       void  zungbr_64(char  vect,  long  m, long n, long k, doublecomplex *a,
                 long lda, doublecomplex *tau, long *info);



PURPOSE
       zungbr generates one of the complex unitary matrices Q or  P**H  deter-
       mined  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) or G(i) respectively.

       If  VECT = 'Q', A is assumed to have been an M-by-K matrix, and Q is of
       order M:
       if m >= k, Q = H(1) H(2) . . . H(k) and ZUNGBR returns the first n col-
       umns of Q, where m >= n >= k;
       if  m < k, Q = H(1) H(2) . . . H(m-1) and ZUNGBR returns Q as an M-by-M
       matrix.

       If VECT = 'P', A is assumed to have been a K-by-N matrix, and  P**H  is
       of order N:
       if  k  <  n, P**H = G(k) . . . G(2) G(1) and ZUNGBR returns the first m
       rows of P**H, where n >= m >= k;
       if k >= n, P**H = G(n-1) . . . G(2) G(1) and ZUNGBR returns P**H as  an
       N-by-N matrix.


ARGUMENTS
       VECT (input)
                 Specifies  whether  the  matrix  Q  or  the  matrix  P**H  is
                 required, as defined in the transformation applied by ZGEBRD:
                 = 'Q':  generate Q;
                 = 'P':  generate P**H.


       M (input) The number of rows of the matrix Q or P**H to be returned.  M
                 >= 0.


       N (input) The number of columns of the matrix Q or P**H to be returned.
                 N  >= 0.  If VECT = 'Q', M >= N >= min(M,K); if VECT = 'P', N
                 >= M >= min(N,K).


       K (input) If VECT = 'Q', the number of columns in the  original  M-by-K
                 matrix  reduced by ZGEBRD.  If VECT = 'P', the number of rows
                 in the original K-by-N matrix reduced by ZGEBRD.  K >= 0.


       A (input/output)
                 On entry, the vectors which define the elementary reflectors,
                 as returned by ZGEBRD.  On exit, the M-by-N matrix Q or P**H.


       LDA (input)
                 The leading dimension of the array A. LDA >= M.


       TAU (input)
                 (min(M,K)) if VECT = 'Q' (min(N,K)) if VECT = 'P' TAU(i) must
                 contain the scalar factor of the elementary reflector H(i) or
                 G(i), which determines Q or P**H, as returned  by  ZGEBRD  in
                 its array argument TAUQ or TAUP.


       WORK (workspace)
                 On exit, if INFO = 0, WORK(1) returns the optimal LWORK.


       LWORK (input)
                 The  dimension  of  the array WORK. LWORK >= max(1,min(M,N)).
                 For optimum performance LWORK >= min(M,N)*NB, where NB is the
                 optimal blocksize.

                 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.


       INFO (output)
                 = 0:  successful exit;
                 < 0:  if INFO = -i, the i-th argument had an illegal value.




                                  7 Nov 2015                        zungbr(3P)