ctgsja man page on OpenIndiana

Man page or keyword search:  
man Server   20441 pages
apropos Keyword Search (all sections)
Output format
OpenIndiana logo
[printable version]

ctgsja(3P)		    Sun Performance Library		    ctgsja(3P)

NAME
       ctgsja - compute the generalized singular value decomposition (GSVD) of
       two complex upper triangular (or trapezoidal) matrices A and B

SYNOPSIS
       SUBROUTINE CTGSJA(JOBU, JOBV, JOBQ, M, P, N, K, L, A, LDA, B, LDB,
	     TOLA, TOLB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, WORK, NCYCLE,
	     INFO)

       CHARACTER * 1 JOBU, JOBV, JOBQ
       COMPLEX A(LDA,*), B(LDB,*), U(LDU,*), V(LDV,*), Q(LDQ,*), WORK(*)
       INTEGER M, P, N, K, L, LDA, LDB, LDU, LDV, LDQ, NCYCLE, INFO
       REAL TOLA, TOLB
       REAL ALPHA(*), BETA(*)

       SUBROUTINE CTGSJA_64(JOBU, JOBV, JOBQ, M, P, N, K, L, A, LDA, B, LDB,
	     TOLA, TOLB, ALPHA, BETA, U, LDU, V, LDV, Q, LDQ, WORK, NCYCLE,
	     INFO)

       CHARACTER * 1 JOBU, JOBV, JOBQ
       COMPLEX A(LDA,*), B(LDB,*), U(LDU,*), V(LDV,*), Q(LDQ,*), WORK(*)
       INTEGER*8 M, P, N, K, L, LDA, LDB, LDU, LDV, LDQ, NCYCLE, INFO
       REAL TOLA, TOLB
       REAL ALPHA(*), BETA(*)

   F95 INTERFACE
       SUBROUTINE TGSJA(JOBU, JOBV, JOBQ, [M], [P], [N], K, L, A, [LDA], B,
	      [LDB], TOLA, TOLB, ALPHA, BETA, U, [LDU], V, [LDV], Q, [LDQ],
	      [WORK], NCYCLE, [INFO])

       CHARACTER(LEN=1) :: JOBU, JOBV, JOBQ
       COMPLEX, DIMENSION(:) :: WORK
       COMPLEX, DIMENSION(:,:) :: A, B, U, V, Q
       INTEGER :: M, P, N, K, L, LDA, LDB, LDU, LDV, LDQ, NCYCLE, INFO
       REAL :: TOLA, TOLB
       REAL, DIMENSION(:) :: ALPHA, BETA

       SUBROUTINE TGSJA_64(JOBU, JOBV, JOBQ, [M], [P], [N], K, L, A, [LDA],
	      B, [LDB], TOLA, TOLB, ALPHA, BETA, U, [LDU], V, [LDV], Q, [LDQ],
	      [WORK], NCYCLE, [INFO])

       CHARACTER(LEN=1) :: JOBU, JOBV, JOBQ
       COMPLEX, DIMENSION(:) :: WORK
       COMPLEX, DIMENSION(:,:) :: A, B, U, V, Q
       INTEGER(8) :: M, P, N, K, L, LDA, LDB, LDU, LDV, LDQ, NCYCLE, INFO
       REAL :: TOLA, TOLB
       REAL, DIMENSION(:) :: ALPHA, BETA

   C INTERFACE
       #include <sunperf.h>

       void ctgsja(char jobu, char jobv, char jobq, int m, int p, int  n,  int
		 k,  int  l,  complex  *a, int lda, complex *b, int ldb, float
		 tola, float tolb, float *alpha, float *beta, complex *u,  int
		 ldu,  complex	*v, int ldv, complex *q, int ldq, int *ncycle,
		 int *info);

       void ctgsja_64(char jobu, char jobv, char jobq, long m, long p, long n,
		 long  k,  long l, complex *a, long lda, complex *b, long ldb,
		 float tola, float tolb, float *alpha,	float  *beta,  complex
		 *u,  long  ldu,  complex  *v, long ldv, complex *q, long ldq,
		 long *ncycle, long *info);

PURPOSE
       ctgsja computes the generalized singular value decomposition (GSVD)  of
       two complex upper triangular (or trapezoidal) matrices A and B.

       On entry, it is assumed that matrices A and B have the following forms,
       which may be obtained by the preprocessing  subroutine  CGGSVP  from  a
       general M-by-N matrix A and P-by-N matrix B:

		    N-K-L  K	L
	  A =	 K ( 0	  A12  A13 ) if M-K-L >= 0;
		 L ( 0	   0   A23 )
	     M-K-L ( 0	   0	0  )

		  N-K-L	 K    L
	  A =  K ( 0	A12  A13 ) if M-K-L < 0;
	     M-K ( 0	 0   A23 )

		  N-K-L	 K    L
	  B =  L ( 0	 0   B13 )
	     P-L ( 0	 0    0	 )

       where the K-by-K matrix A12 and L-by-L matrix B13 are nonsingular upper
       triangular; A23 is L-by-L upper triangular if M-K-L >= 0, otherwise A23
       is (M-K)-by-L upper trapezoidal.

       On exit,

	      U'*A*Q = D1*( 0 R ),    V'*B*Q = D2*( 0 R ),

       where  U, V and Q are unitary matrices, Z' denotes the conjugate trans‐
       pose of Z, R is a nonsingular upper triangular matrix, and  D1  and  D2
       are ``diagonal'' matrices, which are of the following structures:

       If M-K-L >= 0,

			   K  L
	      D1 =     K ( I  0 )
		       L ( 0  C )
		   M-K-L ( 0  0 )

			  K  L
	      D2 = L   ( 0  S )
		   P-L ( 0  0 )

		      N-K-L  K	  L
	 ( 0 R ) = K (	0   R11	 R12 ) K
		   L (	0    0	 R22 ) L

       where

	 C = diag( ALPHA(K+1), ... , ALPHA(K+L) ),
	 S = diag( BETA(K+1),  ... , BETA(K+L) ),
	 C**2 + S**2 = I.

	 R is stored in A(1:K+L,N-K-L+1:N) on exit.

       If M-K-L < 0,

		      K M-K K+L-M
	   D1 =	  K ( I	 0    0	  )
		M-K ( 0	 C    0	  )

			K M-K K+L-M
	   D2 =	  M-K ( 0  S	0   )
		K+L-M ( 0  0	I   )
		  P-L ( 0  0	0   )

		      N-K-L  K	 M-K  K+L-M

		 M-K ( 0     0	 R22  R23  )
	       K+L-M ( 0     0	  0   R33  )

       where
       C = diag( ALPHA(K+1), ... , ALPHA(M) ),
       S = diag( BETA(K+1),  ... , BETA(M) ),
       C**2 + S**2 = I.

       R = ( R11 R12 R13 ) is stored in A(1:M, N-K-L+1:N) and R33 is stored
	   (  0	 R22 R23 )
       in B(M-K+1:L,N+M-K-L+1:N) on exit.

       The  computation	 of  the  unitary transformation matrices U, V or Q is
       optional.  These matrices may either be formed explicitly, or they  may
       be postmultiplied into input matrices U1, V1, or Q1.

       CTGSJA  essentially  uses a variant of Kogbetliantz algorithm to reduce
       min(L,M-K)-by-L triangular  (or	trapezoidal)  matrix  A23  and	L-by-L
       matrix B13 to the form:
	  U1'*A13*Q1 = C1*R1; V1'*B13*Q1 = S1*R1,
       where  U1, V1 and Q1 are unitary matrix, and Z' is the conjugate trans‐
       pose of Z.  C1 and S1 are diagonal matrices satisfying
	  C1**2 + S1**2 = I,
       and R1 is an L-by-L nonsingular upper triangular matrix.

ARGUMENTS
       JOBU (input)
		 = 'U':	 U must contain a unitary matrix U1 on entry, and  the
		 product  U1*U	is  returned;  = 'I':  U is initialized to the
		 unit matrix, and the unitary matrix U is returned; = 'N':   U
		 is not computed.

       JOBV (input)
		 =  'V':  V must contain a unitary matrix V1 on entry, and the
		 product V1*V is returned; = 'I':  V  is  initialized  to  the
		 unit  matrix, and the unitary matrix V is returned; = 'N':  V
		 is not computed.

       JOBQ (input)
		 = 'Q':	 Q must contain a unitary matrix Q1 on entry, and  the
		 product  Q1*Q	is  returned;  = 'I':  Q is initialized to the
		 unit matrix, and the unitary matrix Q is returned; = 'N':   Q
		 is not computed.

       M (input) The number of rows of the matrix A.  M >= 0.

       P (input) The number of rows of the matrix B.  P >= 0.

       N (input) The number of columns of the matrices A and B.	 N >= 0.

       K (input) K and L specify the subblocks in the input matrices A and B:
		 A23  = A(K+1:MIN(K+L,M),N-L+1:N) and B13 = B(1:L,,N-L+1:N) of
		 A and B, whose GSVD is going to be computed by	 CTGSJA.   See
		 the Further Details section below.

       L (input) See the description of K.

       A (input/output)
		 On   entry,   the   M-by-N   matrix   A.    On	  exit,	  A(N-
		 K+1:N,1:MIN(K+L,M) ) contains the triangular matrix R or part
		 of R.	See Purpose for details.

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

       B (input/output)
		 On  entry,  the P-by-N matrix B.  On exit, if necessary, B(M-
		 K+1:L,N+M-K-L+1:N) contains a part of	R.   See  Purpose  for
		 details.

       LDB (input)
		 The leading dimension of the array B. LDB >= max(1,P).

       TOLA (input)
		 TOLA  and  TOLB  are the convergence criteria for the Jacobi-
		 Kogbetliantz iteration procedure.  Generally,	they  are  the
		 same	as   used  in  the  preprocessing  step,  say  TOLA  =
		 MAX(M,N)*norm(A)*MACHEPS, TOLB = MAX(P,N)*norm(B)*MACHEPS.

       TOLB (input)
		 See the description of TOLA.

       ALPHA (output)
		 On exit, ALPHA and  BETA  contain  the	 generalized  singular
		 value pairs of A and B; ALPHA(1:K) = 1,
		 BETA(1:K)  = 0, and if M-K-L >= 0, ALPHA(K+1:K+L) = diag(C),
		 BETA(K+1:K+L)	 =  diag(S), or if M-K-L < 0, ALPHA(K+1:M)= C,
		 ALPHA(M+1:K+L)= 0
		 BETA(K+1:M) = S, BETA(M+1:K+L) = 1.  Furthermore, if K+L < N,
		 ALPHA(K+L+1:N) = 0
		 BETA(K+L+1:N)	= 0.

       BETA (output)
		 See the description of ALPHA.

       U (input) On  entry, if JOBU = 'U', U must contain a matrix U1 (usually
		 the unitary matrix returned by CGGSVP).  On exit, if  JOBU  =
		 'I',  U  contains the unitary matrix U; if JOBU = 'U', U con‐
		 tains the product U1*U.  If JOBU = 'N', U is not referenced.

       LDU (input)
		 The leading dimension of the array U. LDU >= max(1,M) if JOBU
		 = 'U'; LDU >= 1 otherwise.

       V (input) On  entry, if JOBV = 'V', V must contain a matrix V1 (usually
		 the unitary matrix returned by CGGSVP).  On exit, if  JOBV  =
		 'I',  V  contains the unitary matrix V; if JOBV = 'V', V con‐
		 tains the product V1*V.  If JOBV = 'N', V is not referenced.

       LDV (input)
		 The leading dimension of the array V. LDV >= max(1,P) if JOBV
		 = 'V'; LDV >= 1 otherwise.

       Q (input) On  entry, if JOBQ = 'Q', Q must contain a matrix Q1 (usually
		 the unitary matrix returned by CGGSVP).  On exit, if  JOBQ  =
		 'I',  Q  contains the unitary matrix Q; if JOBQ = 'Q', Q con‐
		 tains the product Q1*Q.  If JOBQ = 'N', Q is not referenced.

       LDQ (input)
		 The leading dimension of the array Q. LDQ >= max(1,N) if JOBQ
		 = 'Q'; LDQ >= 1 otherwise.

       WORK (workspace)
		 dimension(2*N)

       NCYCLE (output)
		 The number of cycles required for convergence.

       INFO (output)
		 = 0:  successful exit
		 < 0:  if INFO = -i, the i-th argument had an illegal value.
		 = 1:  the procedure does not converge after MAXIT cycles.

				  6 Mar 2009			    ctgsja(3P)
[top]

List of man pages available for OpenIndiana

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net