hptrf(3)

NAME
hptrf - {hp,sp}trf: triangular factor

SYNOPSIS

  Functions

subroutine chptrf (uplo, n, ap, ipiv, info)
CHPTRF
subroutine csptrf (uplo, n, ap, ipiv, info)
CSPTRF
subroutine dsptrf (uplo, n, ap, ipiv, info)
DSPTRF
subroutine ssptrf (uplo, n, ap, ipiv, info)
SSPTRF
subroutine zhptrf (uplo, n, ap, ipiv, info)
ZHPTRF
subroutine zsptrf (uplo, n, ap, ipiv, info)
ZSPTRF

Detailed Description

Function Documentation

  subroutine chptrf (character uplo, integer n, complex, dimension( * ) ap, integer, dimension( * ) ipiv, integer info)

CHPTRF

Purpose:

    !>
    !> CHPTRF computes the factorization of a complex Hermitian packed
    !> matrix A using the Bunch-Kaufman diagonal pivoting method:
    !>
    !>    A = U*D*U**H  or  A = L*D*L**H
    !>
    !> where U (or L) is a product of permutation and unit upper (lower)
    !> triangular matrices, and D is Hermitian and block diagonal with
    !> 1-by-1 and 2-by-2 diagonal blocks.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored;
    !>          = 'L':  Lower triangle of A is stored.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    AP

    !>          AP is COMPLEX array, dimension (N*(N+1)/2)
    !>          On entry, the upper or lower triangle of the Hermitian 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).
    !>

    IPIV

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

    INFO

    !>          INFO is INTEGER
    !>          = 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.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  If UPLO = 'U', then A = U*D*U**H, 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 IPIV(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**H, 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 IPIV(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).
    !>

Contributors:
    J. Lewis, Boeing Computer Services Company

  subroutine csptrf (character uplo, integer n, complex, dimension( * ) ap, integer, dimension( * ) ipiv, integer info)

CSPTRF

Purpose:

    !>
    !> CSPTRF 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)
    !> triangular matrices, and D is symmetric and block diagonal with
    !> 1-by-1 and 2-by-2 diagonal blocks.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored;
    !>          = 'L':  Lower triangle of A is stored.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    AP

    !>          AP is 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).
    !>

    IPIV

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

    INFO

    !>          INFO is INTEGER
    !>          = 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.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  5-96 - Based on modifications by J. Lewis, Boeing Computer Services
    !>         Company
    !>
    !>  If UPLO = 'U', then A = U*D*U**T, 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 IPIV(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**T, 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 IPIV(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).
    !>

  subroutine dsptrf (character uplo, integer n, double precision, dimension( * ) ap, integer, dimension( * ) ipiv, integer info)

DSPTRF

Purpose:

    !>
    !> DSPTRF computes the factorization of a real 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)
    !> triangular matrices, and D is symmetric and block diagonal with
    !> 1-by-1 and 2-by-2 diagonal blocks.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored;
    !>          = 'L':  Lower triangle of A is stored.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    AP

    !>          AP is DOUBLE PRECISION 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).
    !>

    IPIV

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

    INFO

    !>          INFO is INTEGER
    !>          = 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.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  If UPLO = 'U', then A = U*D*U**T, 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 IPIV(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**T, 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 IPIV(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).
    !>

Contributors:
    J. Lewis, Boeing Computer Services Company

  subroutine ssptrf (character uplo, integer n, real, dimension( * ) ap, integer, dimension( * ) ipiv, integer info)

SSPTRF

Purpose:

    !>
    !> SSPTRF computes the factorization of a real 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)
    !> triangular matrices, and D is symmetric and block diagonal with
    !> 1-by-1 and 2-by-2 diagonal blocks.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored;
    !>          = 'L':  Lower triangle of A is stored.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    AP

    !>          AP is REAL 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).
    !>

    IPIV

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

    INFO

    !>          INFO is INTEGER
    !>          = 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.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  5-96 - Based on modifications by J. Lewis, Boeing Computer Services
    !>         Company
    !>
    !>  If UPLO = 'U', then A = U*D*U**T, 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 IPIV(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**T, 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 IPIV(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).
    !>

  subroutine zhptrf (character uplo, integer n, complex*16, dimension( * ) ap, integer, dimension( * ) ipiv, integer info)

ZHPTRF

Purpose:

    !>
    !> ZHPTRF computes the factorization of a complex Hermitian packed
    !> matrix A using the Bunch-Kaufman diagonal pivoting method:
    !>
    !>    A = U*D*U**H  or  A = L*D*L**H
    !>
    !> where U (or L) is a product of permutation and unit upper (lower)
    !> triangular matrices, and D is Hermitian and block diagonal with
    !> 1-by-1 and 2-by-2 diagonal blocks.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored;
    !>          = 'L':  Lower triangle of A is stored.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    AP

    !>          AP is COMPLEX*16 array, dimension (N*(N+1)/2)
    !>          On entry, the upper or lower triangle of the Hermitian 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).
    !>

    IPIV

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

    INFO

    !>          INFO is INTEGER
    !>          = 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.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  If UPLO = 'U', then A = U*D*U**H, 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 IPIV(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**H, 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 IPIV(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).
    !>

Contributors:
    J. Lewis, Boeing Computer Services Company

  subroutine zsptrf (character uplo, integer n, complex*16, dimension( * ) ap, integer, dimension( * ) ipiv, integer info)

ZSPTRF

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)
    !> triangular matrices, and D is symmetric and block diagonal with
    !> 1-by-1 and 2-by-2 diagonal blocks.
    !>

Parameters
    UPLO

    !>          UPLO is CHARACTER*1
    !>          = 'U':  Upper triangle of A is stored;
    !>          = 'L':  Lower triangle of A is stored.
    !>

    N

    !>          N is INTEGER
    !>          The order of the matrix A.  N >= 0.
    !>

    AP

    !>          AP is COMPLEX*16 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).
    !>

    IPIV

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

    INFO

    !>          INFO is INTEGER
    !>          = 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.
    !>

Author
    Univ. of Tennessee

    Univ. of California Berkeley

    Univ. of Colorado Denver

    NAG Ltd.

Further Details:

    !>
    !>  5-96 - Based on modifications by J. Lewis, Boeing Computer Services
    !>         Company
    !>
    !>  If UPLO = 'U', then A = U*D*U**T, 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 IPIV(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**T, 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 IPIV(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).
    !>

Author

Generated automatically by Doxygen for LAPACK from the source code.