[ новости /+++ | форум | теги | ]

NAME
     zungbr - generate one of the complex unitary matrices  Q  or
     P**H  determined  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 VECT

     INTEGER INFO, K, LDA, LWORK, M, N

     COMPLEX*16 A( LDA, * ), TAU( * ), WORK( LWORK )



     #include <sunperf.h>

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

PURPOSE
     ZUNGBR generates one of the complex unitary  matrices  Q  or
     P**H  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) 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 columns 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) CHARACTER*1
               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) INTEGER
               The number of rows of the matrix Q or P**H  to  be
               returned.  M >= 0.

     N         (input) INTEGER
               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) INTEGER
               If VECT = 'Q', the number of columns in the origi-
               nal  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) COMPLEX*16 array, dimension (LDA,N)
               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) INTEGER
               The leading dimension of the array A. LDA >= M.

     TAU       (input) COMPLEX*16 array, dimension
               (min(M,K)) if VECT = 'Q' (min(N,K)) if VECT =  'P'
               TAU(i)  must contain the scalar factor of the ele-
               mentary reflector H(i) or G(i), which determines Q
               or  P**H, as returned by ZGEBRD in its array argu-
               ment TAUQ or TAUP.

     WORK      (workspace/output)  COMPLEX*16  array,   dimension
               (LWORK)
               On exit, if INFO = 0, WORK(1) returns the  optimal
               LWORK.

     LWORK     (input) INTEGER
               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.

     INFO      (output) INTEGER
               = 0:  successful exit
               < 0:  if INFO = -i, the i-th argument had an ille-
               gal value

Партнёры:

Хостинг: