The OpenNET Project / Index page

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

Интерактивная система просмотра системных руководств (man-ов)

 ТемаНаборКатегория 
 
 [Cписок руководств | Печать]

zgesvd (3)
  • >> zgesvd (3) ( Solaris man: Библиотечные вызовы )
  • 
    NAME
         zgesvd - compute the singular value decomposition (SVD) of a
         complex  M-by-N  matrix  A,  optionally  computing  the left
         and/or right singular vectors
    
    SYNOPSIS
         SUBROUTINE ZGESVD( JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT,
                   LDVT, WORK, LWORK, RWORK, INFO )
    
         CHARACTER JOBU, JOBVT
    
         INTEGER INFO, LDA, LDU, LDVT, LWORK, M, N
    
         DOUBLE PRECISION RWORK( * ), S( * )
    
         COMPLEX*16 A( LDA, * ), U( LDU, * ), VT( LDVT, * ), WORK(  *
                   )
    
    
    
         #include <sunperf.h>
    
         void zgesvd(char jobu, char jobvt, int m, int n,  doublecom-
                   plex  *za,  int lda, double *s, doublecomplex *zu,
                   int ldu, doublecomplex *zvt, int ldvt, int *info);
    
    PURPOSE
         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.
    
    
    ARGUMENTS
         JOBU      (input) CHARACTER*1
                   Specifies options for computing all or part of the
                   matrix U:
                   = 'A':  all M columns of U are returned  in  array
                   U:
                   = 'S':  the first min(m,n) columns of U (the  left
                   singular  vectors)  are returned in the array U; =
                   'O':  the first min(m,n) columns of  U  (the  left
                   singular  vectors) are overwritten on the array A;
                   = 'N':  no columns of U (no left singular vectors)
                   are computed.
    
         JOBVT     (input) CHARACTER*1
                   Specifies options for computing all or part of the
                   matrix V**H:
                   = 'A':  all N rows of V**H  are  returned  in  the
                   array VT;
                   = 'S':  the first min(m,n) rows of V**H (the right
                   singular  vectors) are returned in the array VT; =
                   'O':  the first min(m,n) rows of V**H  (the  right
                   singular  vectors) are overwritten on the array A;
                   = 'N':  no rows of V**H (no  right  singular  vec-
                   tors) are computed.
    
                   JOBVT and JOBU cannot both be 'O'.
    
         M         (input) INTEGER
                   The number of rows of the input matrix A.  M >= 0.
    
         N         (input) INTEGER
                   The number of columns of the input matrix A.  N >=
                   0.
    
         A         (input/output) COMPLEX*16 array, dimension (LDA,N)
                   On entry, the M-by-N matrix A.  On exit, if JOBU =
                   'O',   A  is  overwritten  with the first min(m,n)
                   columns of U (the left  singular  vectors,  stored
                   columnwise); if JOBVT = 'O', A is overwritten with
                   the first min(m,n) rows of V**H (the right  singu-
                   lar vectors, stored rowwise); if JOBU .ne. 'O' and
                   JOBVT .ne. 'O', the contents of A are destroyed.
    
         LDA       (input) INTEGER
                   The leading dimension of  the  array  A.   LDA  >=
                   max(1,M).
    
         S         (output)   DOUBLE   PRECISION   array,   dimension
                   (min(M,N))
                   The singular values of A, sorted so that  S(i)  >=
                   S(i+1).
    
         U         (output) COMPLEX*16 array, dimension (LDU,UCOL)
                   (LDU,M) if JOBU = 'A' or (LDU,min(M,N)) if JOBU  =
                   'S'.  If JOBU = 'A', U contains the M-by-M unitary
                   matrix U; if JOBU =  'S',  U  contains  the  first
                   min(m,n)  columns of U (the left singular vectors,
                   stored columnwise); if JOBU = 'N' or 'O', U is not
                   referenced.
    
         LDU       (input) INTEGER
                   The leading dimension of the array U.  LDU  >=  1;
                   if JOBU = 'S' or 'A', LDU >= M.
    
         VT        (output) COMPLEX*16 array, dimension (LDVT,N)
                   If JOBVT = 'A', VT  contains  the  N-by-N  unitary
                   matrix V**H; if JOBVT = 'S', VT contains the first
                   min(m,n) rows of V**H (the right singular vectors,
                   stored  rowwise); if JOBVT = 'N' or 'O', VT is not
                   referenced.
    
         LDVT      (input) INTEGER
                   The leading dimension of the array VT.  LDVT >= 1;
                   if JOBVT = 'A', LDVT >= N; if JOBVT = 'S', LDVT >=
                   min(M,N).
    
         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  >=  1.
                   LWORK  >=   2*MIN(M,N)+MAX(M,N).  For good perfor-
                   mance, LWORK should generally be larger.
    
         RWORK     (workspace) DOUBLE PRECISION array, dimension
                   (max(3*min(M,N),5*min(M,N)-4)) On exit, if INFO  >
                   0,  RWORK(1:MIN(M,N)-1)  contains  the unconverged
                   superdiagonal  elements  of  an  upper  bidiagonal
                   matrix  B  whose diagonal is in S (not necessarily
                   sorted).  B satisfies A = U * B * VT,  so  it  has
                   the  same  singular values as A, and singular vec-
                   tors related by U and VT.
    
         INFO      (output) INTEGER
                   = 0:  successful exit.
                   < 0:  if INFO = -i, the i-th argument had an ille-
                   gal value.
                   > 0:  if ZBDSQR did not converge,  INFO  specifies
                   how many superdiagonals of an intermediate bidiag-
                   onal form B did not  converge  to  zero.  See  the
                   description of RWORK above for details.
    
    
    
    


    Поиск по тексту MAN-ов: 




    Партнёры:
    PostgresPro
    Inferno Solutions
    Hosting by Hoster.ru
    Хостинг:

    Закладки на сайте
    Проследить за страницей
    Created 1996-2024 by Maxim Chirkov
    Добавить, Поддержать, Вебмастеру