qrupdate-ng 1.2.0
Loading...
Searching...
No Matches
Cholesky Decomposition

Routines for the Cholesky factorization of symmetric positive definite matrices and their updates. More...

Functions

subroutine cch1dn (n, r, ldr, u, rw, info)
 Downdates a Cholesky factorization after a rank-1 modification.
subroutine cch1up (n, r, ldr, u, w)
 Updates a Cholesky factorization after a rank-1 modification.
subroutine cchdex (n, r, ldr, j, rw)
 Updates a Cholesky factorization after deleting a row and column.
subroutine cchinx (n, r, ldr, j, u, rw, info)
 Updates a Cholesky factorization after inserting a row and column.
subroutine cchshx (n, r, ldr, i, j, w, rw)
 Updates a Cholesky factorization after a symmetric shift of rows and columns.
subroutine dch1dn (n, r, ldr, u, w, info)
 Downdates a Cholesky factorization after a rank-1 modification.
subroutine dch1up (n, r, ldr, u, w)
 Updates a Cholesky factorization after a rank-1 modification.
subroutine dchdex (n, r, ldr, j, w)
 Updates a Cholesky factorization after deleting a row and column.
subroutine dchinx (n, r, ldr, j, u, w, info)
 Updates a Cholesky factorization after inserting a row and column.
subroutine dchshx (n, r, ldr, i, j, w)
 Updates a Cholesky factorization after a symmetric shift of rows and columns.
subroutine sch1dn (n, r, ldr, u, w, info)
 Downdates a Cholesky factorization after a rank-1 modification.
subroutine sch1up (n, r, ldr, u, w)
 Updates a Cholesky factorization after a rank-1 modification.
subroutine schdex (n, r, ldr, j, w)
 Updates a Cholesky factorization after deleting a row and column.
subroutine schinx (n, r, ldr, j, u, w, info)
 Updates a Cholesky factorization after inserting a row and column.
subroutine schshx (n, r, ldr, i, j, w)
 Updates a Cholesky factorization after a symmetric shift of rows and columns.
subroutine zch1dn (n, r, ldr, u, rw, info)
 Downdates a Cholesky factorization after a rank-1 modification.
subroutine zch1up (n, r, ldr, u, w)
 Updates a Cholesky factorization after a rank-1 modification.
subroutine zchdex (n, r, ldr, j, rw)
 Updates a Cholesky factorization after deleting a row and column.
subroutine zchinx (n, r, ldr, j, u, rw, info)
 Updates a Cholesky factorization after inserting a row and column.
subroutine zchshx (n, r, ldr, i, j, w, rw)
 Updates a Cholesky factorization after a symmetric shift of rows and columns.

Detailed Description

Routines for the Cholesky factorization of symmetric positive definite matrices and their updates.

This group implements methods to update the Cholesky factorization after matrix modifications, including rank-1 updates, downdates, and symmetric updates for column/row insertion, deletion, and circular shifts. The updates use Givens rotations to restore the upper triangular form of the factor.

Function Documentation

◆ cch1dn()

subroutine cch1dn ( integer, intent(in) n,
complex(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
complex(real32), dimension(*), intent(inout) u,
real(real32), dimension(*), intent(out) rw,
integer, intent(out) info )

Downdates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine cch1dn(n,R,ldr,u,rw,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       complex            R(ldr,*), u(*)
!>       real               rw(*)
!>       ..
!>
Purpose:
!>
!> CCH1DN downdates the Cholesky factorization of a hermitian
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R'*R, where R' denotes the conjugate transpose of R, this
!> CCH1DN downdates R -> R1 so that R1'*R1 = A - u*u', where u
!> is a given vector.
!>
!> The downdate is performed by applying a sequence of hyperbolic
!> rotations to restore the upper triangular structure of R.  On
!> exit, u contains the rotation sines and rw contains the rotation
!> cosines used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A - u*u'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is COMPLEX array, dimension (n)
!>          On entry, the vector determining the rank-1 downdate.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]rw
!>          rw is REAL array, dimension (n)
!>          On exit, rw contains the cosine parts of the
!>          rotations used to transform R to R1.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>

Definition at line 97 of file cch1dn.f90.

◆ cch1up()

subroutine cch1up ( integer, intent(in) n,
complex(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
complex(real32), dimension(*), intent(inout) u,
real(real32), dimension(*), intent(out) w )

Updates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine cch1up(n,R,ldr,u,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr
!>       ..
!>       .. Array Arguments ..
!>       complex            R(ldr,*), u(*)
!>       real               w(*)
!>       ..
!>
Purpose:
!>
!> CCH1UP updates the Cholesky factorization of a hermitian
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R'*R, where R' denotes the conjugate transpose of R, this
!> CCH1UP updates R -> R1 so that R1'*R1 = A + u*u', where u is
!> a given vector.
!>
!> The update is performed by applying a sequence of Givens rotations
!> to restore the upper triangular structure of R.  On exit, u
!> contains the rotation sines and w contains the rotation cosines
!> used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A + u*u'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is COMPLEX array, dimension (n)
!>          On entry, the vector determining the rank-1 update.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]w
!>          w is REAL array, dimension (n)
!>          On exit, w contains the cosine parts of the Givens
!>          rotations used to transform R to R1.
!>

Definition at line 89 of file cch1up.f90.

◆ cchdex()

subroutine cchdex ( integer, intent(in) n,
complex(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
real(real32), dimension(*), intent(out) rw )

Updates a Cholesky factorization after deleting a row and column.

Definition:
!>       subroutine cchdex(n,R,ldr,j,rw)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, j
!>       ..
!>       .. Array Arguments ..
!>       complex            R(ldr,*)
!>       real               rw(*)
!>       ..
!>
Purpose:
!>
!> CCHDEX updates the Cholesky factorization of a hermitian
!> positive definite matrix A after deleting a row/column.
!> Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R'*R, where R' denotes the conjugate
!> transpose of R, CCHDEX updates R -> R1 so that
!> R1'*R1 = A(jj,jj), where jj = [1:j-1, j+1:n+1].
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(jj,jj).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]j
!>          j is INTEGER
!>          The position of the deleted row/column.
!>
[out]rw
!>          rw is REAL array, dimension (n)
!>          A workspace vector.
!>

Definition at line 81 of file cchdex.f90.

◆ cchinx()

subroutine cchinx ( integer, intent(in) n,
complex(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
complex(real32), dimension(*), intent(inout) u,
real(real32), dimension(*), intent(out) rw,
integer, intent(out) info )

Updates a Cholesky factorization after inserting a row and column.

Definition:
!>       subroutine cchinx(n,R,ldr,j,u,rw,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, j, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       complex            R(ldr,*), u(*), rw(*)
!>       ..
!>
Purpose:
!>
!> CCHINX updates the Cholesky factorization of a hermitian
!> positive definite matrix A after inserting a row and column.
!> Given an upper triangular matrix R that is a Cholesky factor of
!> A, i.e., A = R'*R, where R' denotes the conjugate transpose of
!> R, CCHINX updates R -> R1 so that R1'*R1 = A1, where
!> A1(jj,jj) = A, A1(j,:) = u', A1(:,j) = u, and
!> jj = [1:j-1, j+1:n+1].
!>
!> On exit, u is destroyed and R is extended by one row and column.
!> The insertion is performed by first solving R'*u = v, checking
!> positive definiteness, and then retriangularizing.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX array, dimension (ldr,n+1)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A1.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n+1.
!>
[in]j
!>          j is INTEGER
!>          The position of the inserted row and column.
!>          1 <= j <= n+1.
!>
[in,out]u
!>          u is COMPLEX array, dimension (n+1)
!>          On entry, the vector defining the inserted row/column.
!>          On exit, u is destroyed.
!>
[out]rw
!>          rw is REAL array, dimension (n+1)
!>          Workspace vector used to store rotation cosines during
!>          the retriangularization.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>          = 3:  the diagonal element of u is not real
!>

Definition at line 103 of file cchinx.f90.

◆ cchshx()

subroutine cchshx ( integer, intent(in) n,
complex(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) i,
integer, intent(in) j,
complex(real32), dimension(*), intent(out) w,
real(real32), dimension(*), intent(out) rw )

Updates a Cholesky factorization after a symmetric shift of rows and columns.

Definition:
!>       subroutine cchshx(n,R,ldr,i,j,w,rw)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, i, j
!>       ..
!>       .. Array Arguments ..
!>       complex            R(ldr,*), w(*)
!>       real               rw(*)
!>       ..
!>
Purpose:
!>
!> CCHSHX updates the Cholesky factorization of a hermitian
!> positive definite matrix A after a symmetric shift of rows and
!> columns.  Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R'*R, where R' denotes the conjugate
!> transpose of R, CCHSHX updates R -> R1 so that
!> R1'*R1 = A(p,p), where p is the permutation
!> [1:i-1, shift(i:j,-1), j+1:n] if i < j, or
!> [1:j-1, shift(j:i,+1), i+1:n] if j < i.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(p,p).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]i
!>          i is INTEGER
!>          The first index determining the range of the shift.
!>          1 <= i <= n.
!>
[in]j
!>          j is INTEGER
!>          The second index determining the range of the shift.
!>          1 <= j <= n.
!>
[out]w
!>          w is COMPLEX array, dimension (n)
!>          Workspace vector used to store rotation sines during
!>          the retriangularization.
!>
[out]rw
!>          rw is REAL array, dimension (n)
!>          Workspace vector used to store rotation cosines during
!>          the retriangularization.
!>

Definition at line 99 of file cchshx.f90.

◆ dch1dn()

subroutine dch1dn ( integer, intent(in) n,
real(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
real(real64), dimension(*), intent(inout) u,
real(real64), dimension(*), intent(out) w,
integer, intent(out) info )

Downdates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine dch1dn(n,R,ldr,u,w,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       double precision   R(ldr,*), u(*), w(*)
!>       ..
!>
Purpose:
!>
!> DCH1DN downdates the Cholesky factorization of a symmetric
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R.'*R, where R.' denotes the transpose of R, DCH1DN
!> downdates R -> R1 so that R1.'*R1 = A - u*u.', where u is a
!> given vector.
!>
!> The downdate is performed by applying a sequence of hyperbolic
!> rotations to restore the upper triangular structure of R.  On
!> exit, u contains the rotation sines and w contains the rotation
!> cosines used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is DOUBLE PRECISION array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A - u*u.'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is DOUBLE PRECISION array, dimension (n)
!>          On entry, the vector determining the rank-1 downdate.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]w
!>          w is DOUBLE PRECISION array, dimension (n)
!>          On exit, w contains the cosine parts of the
!>          rotations used to transform R to R1.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>

Definition at line 96 of file dch1dn.f90.

◆ dch1up()

subroutine dch1up ( integer, intent(in) n,
real(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
real(real64), dimension(*), intent(inout) u,
real(real64), dimension(*), intent(out) w )

Updates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine dch1up(n,R,ldr,u,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr
!>       ..
!>       .. Array Arguments ..
!>       double precision   R(ldr,*), u(*), w(*)
!>       ..
!>
Purpose:
!>
!> DCH1UP updates the Cholesky factorization of a symmetric
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R.'*R, where R.' denotes the transpose of R, DCH1UP
!> updates R -> R1 so that R1.'*R1 = A + u*u.', where u is a given
!> vector.
!>
!> The update is performed by applying a sequence of Givens rotations
!> to restore the upper triangular structure of R.  On exit, u
!> contains the rotation sines and w contains the rotation cosines
!> used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is DOUBLE PRECISION array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A + u*u.'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is DOUBLE PRECISION array, dimension (n)
!>          On entry, the vector determining the rank-1 update.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]w
!>          w is DOUBLE PRECISION array, dimension (n)
!>          On exit, w contains the cosine parts of the Givens
!>          rotations used to transform R to R1.
!>

Definition at line 88 of file dch1up.f90.

◆ dchdex()

subroutine dchdex ( integer, intent(in) n,
real(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
real(real64), dimension(*), intent(out) w )

Updates a Cholesky factorization after deleting a row and column.

Definition:
!>       subroutine dchdex(n,R,ldr,j,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, j
!>       ..
!>       .. Array Arguments ..
!>       double precision   R(ldr,*), w(*)
!>       ..
!>
Purpose:
!>
!> DCHDEX updates the Cholesky factorization of a symmetric
!> positive definite matrix A after deleting a row/column.
!> Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R.'*R, where R.' denotes the
!> transpose of R, DCHDEX updates R -> R1 so that
!> R1.'*R1 = A(jj,jj), where jj = [1:j-1, j+1:n+1].
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is DOUBLE PRECISION array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(jj,jj).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]j
!>          j is INTEGER
!>          The position of the deleted row/column.
!>
[out]w
!>          w is DOUBLE PRECISION array, dimension (n)
!>          A workspace vector.
!>

Definition at line 80 of file dchdex.f90.

◆ dchinx()

subroutine dchinx ( integer, intent(in) n,
real(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
real(real64), dimension(*), intent(inout) u,
real(real64), dimension(*), intent(out) w,
integer, intent(out) info )

Updates a Cholesky factorization after inserting a row and column.

Definition:
!>       subroutine dchinx(n,R,ldr,j,u,w,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, j, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       double precision   R(ldr,*), u(*), w(*)
!>       ..
!>
Purpose:
!>
!> DCHINX updates the Cholesky factorization of a symmetric
!> positive definite matrix A after inserting a row and column.
!> Given an upper triangular matrix R that is a Cholesky factor of
!> A, i.e., A = R.'*R, where R.' denotes the transpose of R, this
!> DCHINX updates R -> R1 so that R1.'*R1 = A1, where
!> A1(jj,jj) = A, A1(j,:) = u.', A1(:,j) = u, and
!> jj = [1:j-1, j+1:n+1].
!>
!> On exit, u is destroyed and R is extended by one row and column.
!> The insertion is performed by first solving R.'*u = v, checking
!> positive definiteness, and then retriangularizing.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is DOUBLE PRECISION array, dimension (ldr,n+1)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A1.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n+1.
!>
[in]j
!>          j is INTEGER
!>          The position of the inserted row and column.
!>          1 <= j <= n+1.
!>
[in,out]u
!>          u is DOUBLE PRECISION array, dimension (n+1)
!>          On entry, the vector defining the inserted row/column.
!>          On exit, u is destroyed.
!>
[out]w
!>          w is DOUBLE PRECISION array, dimension (n+1)
!>          Workspace vector used during the retriangularization.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>

Definition at line 101 of file dchinx.f90.

◆ dchshx()

subroutine dchshx ( integer, intent(in) n,
real(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) i,
integer, intent(in) j,
real(real64), dimension(*), intent(out) w )

Updates a Cholesky factorization after a symmetric shift of rows and columns.

Definition:
!>       subroutine dchshx(n,R,ldr,i,j,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, i, j
!>       ..
!>       .. Array Arguments ..
!>       double precision   R(ldr,*), w(*)
!>       ..
!>
Purpose:
!>
!> DCHSHX updates the Cholesky factorization of a symmetric
!> positive definite matrix A after a symmetric shift of rows and
!> columns.  Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R.'*R, where R.' denotes the transpose
!> of R, DCHSHX updates R -> R1 so that
!> R1.'*R1 = A(p,p), where p is the permutation
!> [1:i-1, shift(i:j,-1), j+1:n] if i < j, or
!> [1:j-1, shift(j:i,+1), i+1:n] if j < i.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is DOUBLE PRECISION array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(p,p).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]i
!>          i is INTEGER
!>          The first index determining the range of the shift.
!>          1 <= i <= n.
!>
[in]j
!>          j is INTEGER
!>          The second index determining the range of the shift.
!>          1 <= j <= n.
!>
[out]w
!>          w is DOUBLE PRECISION array, dimension (2*n)
!>          Workspace vector used during the retriangularization.
!>

Definition at line 90 of file dchshx.f90.

◆ sch1dn()

subroutine sch1dn ( integer, intent(in) n,
real(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
real(real32), dimension(*), intent(inout) u,
real(real32), dimension(*), intent(out) w,
integer, intent(out) info )

Downdates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine sch1dn(n,R,ldr,u,w,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       real               R(ldr,*), u(*), w(*)
!>       ..
!>
Purpose:
!>
!> SCH1DN downdates the Cholesky factorization of a symmetric
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R.'*R, where R.' denotes the transpose of R, SCH1DN
!> downdates R -> R1 so that R1.'*R1 = A - u*u.', where u is a
!> given vector.
!>
!> The downdate is performed by applying a sequence of hyperbolic
!> rotations to restore the upper triangular structure of R.  On
!> exit, u contains the rotation sines and w contains the rotation
!> cosines used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is REAL array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A - u*u.'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is REAL array, dimension (n)
!>          On entry, the vector determining the rank-1 downdate.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]w
!>          w is REAL array, dimension (n)
!>          On exit, w contains the cosine parts of the
!>          rotations used to transform R to R1.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>

Definition at line 96 of file sch1dn.f90.

◆ sch1up()

subroutine sch1up ( integer, intent(in) n,
real(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
real(real32), dimension(*), intent(inout) u,
real(real32), dimension(*), intent(out) w )

Updates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine sch1up(n,R,ldr,u,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr
!>       ..
!>       .. Array Arguments ..
!>       real               R(ldr,*), u(*), w(*)
!>       ..
!>
Purpose:
!>
!> SCH1UP updates the Cholesky factorization of a symmetric
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R.'*R, where R.' denotes the transpose of R, SCH1UP
!> updates R -> R1 so that R1.'*R1 = A + u*u.', where u is a given
!> vector.
!>
!> The update is performed by applying a sequence of Givens rotations
!> to restore the upper triangular structure of R.  On exit, u
!> contains the rotation sines and w contains the rotation cosines
!> used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is REAL array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A + u*u.'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is REAL array, dimension (n)
!>          On entry, the vector determining the rank-1 update.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]w
!>          w is REAL array, dimension (n)
!>          On exit, w contains the cosine parts of the Givens
!>          rotations used to transform R to R1.
!>

Definition at line 88 of file sch1up.f90.

◆ schdex()

subroutine schdex ( integer, intent(in) n,
real(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
real(real32), dimension(*), intent(out) w )

Updates a Cholesky factorization after deleting a row and column.

Definition:
!>       subroutine schdex(n,R,ldr,j,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, j
!>       ..
!>       .. Array Arguments ..
!>       real               R(ldr,*), w(*)
!>       ..
!>
Purpose:
!>
!> SCHDEX updates the Cholesky factorization of a symmetric
!> positive definite matrix A after deleting a row/column.
!> Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R.'*R, where R.' denotes the
!> transpose of R, SCHDEX updates R -> R1 so that
!> R1.'*R1 = A(jj,jj), where jj = [1:j-1, j+1:n+1].
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is REAL array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(jj,jj).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]j
!>          j is INTEGER
!>          The position of the deleted row/column.
!>
[out]w
!>          w is REAL array, dimension (n)
!>          A workspace vector.
!>

Definition at line 80 of file schdex.f90.

◆ schinx()

subroutine schinx ( integer, intent(in) n,
real(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
real(real32), dimension(*), intent(inout) u,
real(real32), dimension(*), intent(out) w,
integer, intent(out) info )

Updates a Cholesky factorization after inserting a row and column.

Definition:
!>       subroutine schinx(n,R,ldr,j,u,w,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, j, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       real               R(ldr,*), u(*), w(*)
!>       ..
!>
Purpose:
!>
!> SCHINX updates the Cholesky factorization of a symmetric
!> positive definite matrix A after inserting a row and column.
!> Given an upper triangular matrix R that is a Cholesky factor of
!> A, i.e., A = R.'*R, where R.' denotes the transpose of R, this
!> SCHINX updates R -> R1 so that R1.'*R1 = A1, where
!> A1(jj,jj) = A, A1(j,:) = u.', A1(:,j) = u, and
!> jj = [1:j-1, j+1:n+1].
!>
!> On exit, u is destroyed and R is extended by one row and column.
!> The insertion is performed by first solving R.'*u = v, checking
!> positive definiteness, and then retriangularizing.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is REAL array, dimension (ldr,n+1)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A1.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n+1.
!>
[in]j
!>          j is INTEGER
!>          The position of the inserted row and column.
!>          1 <= j <= n+1.
!>
[in,out]u
!>          u is REAL array, dimension (n+1)
!>          On entry, the vector defining the inserted row/column.
!>          On exit, u is destroyed.
!>
[out]w
!>          w is REAL array, dimension (n+1)
!>          Workspace vector used during the retriangularization.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>

Definition at line 101 of file schinx.f90.

◆ schshx()

subroutine schshx ( integer, intent(in) n,
real(real32), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) i,
integer, intent(in) j,
real(real32), dimension(*), intent(out) w )

Updates a Cholesky factorization after a symmetric shift of rows and columns.

Definition:
!>       subroutine schshx(n,R,ldr,i,j,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, i, j
!>       ..
!>       .. Array Arguments ..
!>       real               R(ldr,*), w(*)
!>       ..
!>
Purpose:
!>
!> SCHSHX updates the Cholesky factorization of a symmetric
!> positive definite matrix A after a symmetric shift of rows and
!> columns.  Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R.'*R, where R.' denotes the transpose
!> of R, SCHSHX updates R -> R1 so that
!> R1.'*R1 = A(p,p), where p is the permutation
!> [1:i-1, shift(i:j,-1), j+1:n] if i < j, or
!> [1:j-1, shift(j:i,+1), i+1:n] if j < i.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is REAL array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(p,p).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]i
!>          i is INTEGER
!>          The first index determining the range of the shift.
!>          1 <= i <= n.
!>
[in]j
!>          j is INTEGER
!>          The second index determining the range of the shift.
!>          1 <= j <= n.
!>
[out]w
!>          w is REAL array, dimension (2*n)
!>          Workspace vector used during the retriangularization.
!>

Definition at line 90 of file schshx.f90.

◆ zch1dn()

subroutine zch1dn ( integer, intent(in) n,
complex(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
complex(real64), dimension(*), intent(inout) u,
real(real64), dimension(*), intent(out) rw,
integer, intent(out) info )

Downdates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine zch1dn(n,R,ldr,u,rw,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       double complex     R(ldr,*), u(*)
!>       double precision   rw(*)
!>       ..
!>
Purpose:
!>
!> ZCH1DN downdates the Cholesky factorization of a hermitian
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R'*R, where R' denotes the conjugate transpose of R, this
!> ZCH1DN downdates R -> R1 so that R1'*R1 = A - u*u', where u
!> is a given vector.
!>
!> The downdate is performed by applying a sequence of hyperbolic
!> rotations to restore the upper triangular structure of R.  On
!> exit, u contains the rotation sines and rw contains the rotation
!> cosines used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX*16 array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A - u*u'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is COMPLEX*16 array, dimension (n)
!>          On entry, the vector determining the rank-1 downdate.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]rw
!>          rw is DOUBLE PRECISION array, dimension (n)
!>          On exit, rw contains the cosine parts of the
!>          rotations used to transform R to R1.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>

Definition at line 97 of file zch1dn.f90.

◆ zch1up()

subroutine zch1up ( integer, intent(in) n,
complex(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
complex(real64), dimension(*), intent(inout) u,
real(real64), dimension(*), intent(out) w )

Updates a Cholesky factorization after a rank-1 modification.

Definition:
!>       subroutine zch1up(n,R,ldr,u,w)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr
!>       ..
!>       .. Array Arguments ..
!>       double complex     R(ldr,*), u(*)
!>       double precision   w(*)
!>       ..
!>
Purpose:
!>
!> ZCH1UP updates the Cholesky factorization of a hermitian
!> positive definite matrix A after a rank-1 modification.  Given an
!> upper triangular matrix R that is a Cholesky factor of A, i.e.,
!> A = R'*R, where R' denotes the conjugate transpose of R, this
!> ZCH1UP updates R -> R1 so that R1'*R1 = A + u*u', where u is
!> a given vector.
!>
!> The update is performed by applying a sequence of Givens rotations
!> to restore the upper triangular structure of R.  On exit, u
!> contains the rotation sines and w contains the rotation cosines
!> used in the transformation.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX*16 array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A + u*u'.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in,out]u
!>          u is COMPLEX*16 array, dimension (n)
!>          On entry, the vector determining the rank-1 update.
!>          On exit, u contains the rotation sines used to
!>          transform R to R1.
!>
[out]w
!>          w is DOUBLE PRECISION array, dimension (n)
!>          On exit, w contains the cosine parts of the Givens
!>          rotations used to transform R to R1.
!>

Definition at line 89 of file zch1up.f90.

◆ zchdex()

subroutine zchdex ( integer, intent(in) n,
complex(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
real(real64), dimension(*), intent(out) rw )

Updates a Cholesky factorization after deleting a row and column.

Definition:
!>       subroutine zchdex(n,R,ldr,j,rw)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, j
!>       ..
!>       .. Array Arguments ..
!>       double complex     R(ldr,*)
!>       double precision   rw(*)
!>       ..
!>
Purpose:
!>
!> ZCHDEX updates the Cholesky factorization of a hermitian
!> positive definite matrix A after deleting a row/column.
!> Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R'*R, where R' denotes the conjugate
!> transpose of R, ZCHDEX updates R -> R1 so that
!> R1'*R1 = A(jj,jj), where jj = [1:j-1, j+1:n+1].
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX*16 array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(jj,jj).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]j
!>          j is INTEGER
!>          The position of the deleted row/column.
!>
[out]rw
!>          rw is DOUBLE PRECISION array, dimension (n)
!>          A workspace vector.
!>

Definition at line 81 of file zchdex.f90.

◆ zchinx()

subroutine zchinx ( integer, intent(in) n,
complex(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) j,
complex(real64), dimension(*), intent(inout) u,
real(real64), dimension(*), intent(out) rw,
integer, intent(out) info )

Updates a Cholesky factorization after inserting a row and column.

Definition:
!>       subroutine zchinx(n,R,ldr,j,u,rw,info)
!>
!>       .. Scalar Arguments ..
!>       integer            n, j, ldr, info
!>       ..
!>       .. Array Arguments ..
!>       double complex     R(ldr,*), u(*), rw(*)
!>       ..
!>
Purpose:
!>
!> ZCHINX updates the Cholesky factorization of a hermitian
!> positive definite matrix A after inserting a row and column.
!> Given an upper triangular matrix R that is a Cholesky factor of
!> A, i.e., A = R'*R, where R' denotes the conjugate transpose of
!> R, ZCHINX updates R -> R1 so that R1'*R1 = A1, where
!> A1(jj,jj) = A, A1(j,:) = u', A1(:,j) = u, and
!> jj = [1:j-1, j+1:n+1].
!>
!> On exit, u is destroyed and R is extended by one row and column.
!> The insertion is performed by first solving R'*u = v, checking
!> positive definiteness, and then retriangularizing.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX*16 array, dimension (ldr,n+1)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A1.
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n+1.
!>
[in]j
!>          j is INTEGER
!>          The position of the inserted row and column.
!>          1 <= j <= n+1.
!>
[in,out]u
!>          u is COMPLEX*16 array, dimension (n+1)
!>          On entry, the vector defining the inserted row/column.
!>          On exit, u is destroyed.
!>
[out]rw
!>          rw is DOUBLE PRECISION array, dimension (n+1)
!>          Workspace vector used to store rotation cosines during
!>          the retriangularization.
!>
[out]info
!>          info is INTEGER
!>          = 0:  successful exit
!>          = 1:  the update would violate positive-definiteness
!>          = 2:  R is singular
!>          = 3:  the diagonal element of u is not real
!>

Definition at line 103 of file zchinx.f90.

◆ zchshx()

subroutine zchshx ( integer, intent(in) n,
complex(real64), dimension(ldr,*), intent(inout) r,
integer, intent(in) ldr,
integer, intent(in) i,
integer, intent(in) j,
complex(real64), dimension(*), intent(out) w,
real(real64), dimension(*), intent(out) rw )

Updates a Cholesky factorization after a symmetric shift of rows and columns.

Definition:
!>       subroutine zchshx(n,R,ldr,i,j,w,rw)
!>
!>       .. Scalar Arguments ..
!>       integer            n, ldr, i, j
!>       ..
!>       .. Array Arguments ..
!>       double complex     R(ldr,*), w(*)
!>       double precision   rw(*)
!>       ..
!>
Purpose:
!>
!> ZCHSHX updates the Cholesky factorization of a hermitian
!> positive definite matrix A after a symmetric shift of rows and
!> columns.  Given an upper triangular matrix R that is a Cholesky
!> factor of A, i.e., A = R'*R, where R' denotes the conjugate
!> transpose of R, ZCHSHX updates R -> R1 so that
!> R1'*R1 = A(p,p), where p is the permutation
!> [1:i-1, shift(i:j,-1), j+1:n] if i < j, or
!> [1:j-1, shift(j:i,+1), i+1:n] if j < i.
!>
Parameters
[in]n
!>          n is INTEGER
!>          The order of matrix R.  n >= 0.
!>
[in,out]R
!>          R is COMPLEX*16 array, dimension (ldr,n)
!>          On entry, the upper triangular matrix R, the Cholesky
!>          factor of A.  On exit, the updated upper triangular
!>          matrix R1, the Cholesky factor of A(p,p).
!>
[in]ldr
!>          ldr is INTEGER
!>          The leading dimension of the array R.  ldr >= n.
!>
[in]i
!>          i is INTEGER
!>          The first index determining the range of the shift.
!>          1 <= i <= n.
!>
[in]j
!>          j is INTEGER
!>          The second index determining the range of the shift.
!>          1 <= j <= n.
!>
[out]w
!>          w is COMPLEX*16 array, dimension (n)
!>          Workspace vector used to store rotation sines during
!>          the retriangularization.
!>
[out]rw
!>          rw is DOUBLE PRECISION array, dimension (n)
!>          Workspace vector used to store rotation cosines during
!>          the retriangularization.
!>

Definition at line 99 of file zchshx.f90.