Go to main content
Oracle Developer Studio 12.5 Man Pages

Exit Print View

Updated: June 2017
 
 

zsptrf (3p)

Name

zsptrf - compute the factorization of a complex symmetric matrix A stored in packed format using the Bunch-Kaufman diagonal pivoting method

Synopsis

SUBROUTINE ZSPTRF(UPLO, N, AP, IPIVOT, INFO)

CHARACTER*1 UPLO
DOUBLE COMPLEX AP(*)
INTEGER N, INFO
INTEGER IPIVOT(*)

SUBROUTINE ZSPTRF_64(UPLO, N, AP, IPIVOT, INFO)

CHARACTER*1 UPLO
DOUBLE COMPLEX AP(*)
INTEGER*8 N, INFO
INTEGER*8 IPIVOT(*)




F95 INTERFACE
SUBROUTINE SPTRF(UPLO, N, AP, IPIVOT, INFO)

CHARACTER(LEN=1) :: UPLO
COMPLEX(8), DIMENSION(:) :: AP
INTEGER :: N, INFO
INTEGER, DIMENSION(:) :: IPIVOT

SUBROUTINE SPTRF_64(UPLO, N, AP, IPIVOT, INFO)

CHARACTER(LEN=1) :: UPLO
COMPLEX(8), DIMENSION(:) :: AP
INTEGER(8) :: N, INFO
INTEGER(8), DIMENSION(:) :: IPIVOT




C INTERFACE
#include <sunperf.h>

void  zsptrf(char  uplo,  int  n,  doublecomplex  *ap, int *ipivot, int
*info);

void zsptrf_64(char uplo, long n, doublecomplex *ap, long *ipivot, long
*info);

Description

Oracle Solaris Studio Performance Library                           zsptrf(3P)



NAME
       zsptrf  -  compute  the  factorization  of a complex symmetric matrix A
       stored in packed  format  using  the  Bunch-Kaufman  diagonal  pivoting
       method


SYNOPSIS
       SUBROUTINE ZSPTRF(UPLO, N, AP, IPIVOT, INFO)

       CHARACTER*1 UPLO
       DOUBLE COMPLEX AP(*)
       INTEGER N, INFO
       INTEGER IPIVOT(*)

       SUBROUTINE ZSPTRF_64(UPLO, N, AP, IPIVOT, INFO)

       CHARACTER*1 UPLO
       DOUBLE COMPLEX AP(*)
       INTEGER*8 N, INFO
       INTEGER*8 IPIVOT(*)




   F95 INTERFACE
       SUBROUTINE SPTRF(UPLO, N, AP, IPIVOT, INFO)

       CHARACTER(LEN=1) :: UPLO
       COMPLEX(8), DIMENSION(:) :: AP
       INTEGER :: N, INFO
       INTEGER, DIMENSION(:) :: IPIVOT

       SUBROUTINE SPTRF_64(UPLO, N, AP, IPIVOT, INFO)

       CHARACTER(LEN=1) :: UPLO
       COMPLEX(8), DIMENSION(:) :: AP
       INTEGER(8) :: N, INFO
       INTEGER(8), DIMENSION(:) :: IPIVOT




   C INTERFACE
       #include <sunperf.h>

       void  zsptrf(char  uplo,  int  n,  doublecomplex  *ap, int *ipivot, int
                 *info);

       void zsptrf_64(char uplo, long n, doublecomplex *ap, long *ipivot, long
                 *info);



PURPOSE
       zsptrf  computes  the  factorization  of  a  complex symmetric matrix A
       stored in packed  format  using  the  Bunch-Kaufman  diagonal  pivoting
       method:

          A = U*D*U**T  or  A = L*D*L**T

       where  U (or L) is a product of permutation and unit upper (lower) tri-
       angular matrices, and D is symmetric and block diagonal with 1-by-1 and
       2-by-2 diagonal blocks.


ARGUMENTS
       UPLO (input)
                 = 'U':  Upper triangle of A is stored;
                 = 'L':  Lower triangle of A is stored.


       N (input) The order of the matrix A.  N >= 0.


       AP (input/output)
                 Double  complex  array,  dimension  (N*(N+1)/2) On entry, the
                 upper or lower triangle of the  symmetric  matrix  A,  packed
                 columnwise in a linear array.  The j-th column of A is stored
                 in the array AP as follows: if UPLO = 'U', AP(i +  (j-1)*j/2)
                 = A(i,j) for 1<=i<=j; if UPLO = 'L', AP(i + (j-1)*(2n-j)/2) =
                 A(i,j) for j<=i<=n.

                 On exit, the block diagonal matrix D and the multipliers used
                 to  obtain  the  factor U or L, stored as a packed triangular
                 matrix overwriting A (see below for further details).


       IPIVOT (output)
                 Integer array, dimension (N) Details of the interchanges  and
                 the  block  structure  of D.  If IPIVOT(k) > 0, then rows and
                 columns k and IPIVOT(k) were interchanged  and  D(k,k)  is  a
                 1-by-1  diagonal  block.   If  UPLO  =  'U'  and  IPIVOT(k) =
                 IPIVOT(k-1) < 0, then rows and  columns  k-1  and  -IPIVOT(k)
                 were  interchanged  and  D(k-1:k,k-1:k)  is a 2-by-2 diagonal
                 block.  If UPLO = 'L' and IPIVOT(k) = IPIVOT(k+1) <  0,  then
                 rows  and  columns  k+1  and -IPIVOT(k) were interchanged and
                 D(k:k+1,k:k+1) is a 2-by-2 diagonal block.


       INFO (output)
                 = 0: successful exit
                 < 0: if INFO = -i, the i-th argument had an illegal value
                 > 0: if INFO = i, D(i,i) is exactly zero.  The  factorization
                 has  been  completed,  but  the  block  diagonal  matrix D is
                 exactly singular, and division by zero will occur  if  it  is
                 used to solve a system of equations.

FURTHER DETAILS
       5-96 - Based on modifications by J. Lewis, Boeing Computer Services
              Company

       If UPLO = 'U', then A = U*D*U', where
          U = P(n)*U(n)* ... *P(k)U(k)* ...,
       i.e.,  U is a product of terms P(k)*U(k), where k decreases from n to 1
       in steps of 1 or 2, and D is a block diagonal matrix  with  1-by-1  and
       2-by-2  diagonal  blocks D(k).  P(k) is a permutation matrix as defined
       by IPIVOT(k), and U(k) is a unit upper triangular matrix, such that  if
       the diagonal block D(k) is of order s (s = 1 or 2), then

                  (   I    v    0   )   k-s
          U(k) =  (   0    I    0   )   s
                  (   0    0    I   )   n-k
                     k-s   s   n-k

       If  s = 1, D(k) overwrites A(k,k), and v overwrites A(1:k-1,k).  If s =
       2, the upper triangle of  D(k)  overwrites  A(k-1,k-1),  A(k-1,k),  and
       A(k,k), and v overwrites A(1:k-2,k-1:k).

       If UPLO = 'L', then A = L*D*L', where
          L = P(1)*L(1)* ... *P(k)*L(k)* ...,
       i.e.,  L is a product of terms P(k)*L(k), where k increases from 1 to n
       in steps of 1 or 2, and D is a block diagonal matrix  with  1-by-1  and
       2-by-2  diagonal  blocks D(k).  P(k) is a permutation matrix as defined
       by IPIVOT(k), and L(k) is a unit lower triangular matrix, such that  if
       the diagonal block D(k) is of order s (s = 1 or 2), then

                  (   I    0     0   )  k-1
          L(k) =  (   0    I     0   )  s
                  (   0    v     I   )  n-k-s+1
                     k-1   s  n-k-s+1

       If  s = 1, D(k) overwrites A(k,k), and v overwrites A(k+1:n,k).  If s =
       2,  the  lower  triangle  of  D(k)  overwrites  A(k,k),  A(k+1,k),  and
       A(k+1,k+1), and v overwrites A(k+2:n,k:k+1).




                                  7 Nov 2015                        zsptrf(3P)