Added (S,D,C,Z) (SY,HE) routines, drivers for new rook code

Close #82

Added routines for new factorization code for symmetric indefinite
( or Hermitian indefinite ) matrices with bounded Bunch-Kaufman
( rook ) pivoting algorithm.

New more efficient storage format for factors U ( or L ),
block-diagonal matrix D, and pivoting information stored in IPIV:

factor L is stored explicitly in lower triangle of A;
diagonal of D is stored on the diagonal of A;
subdiagonal elements of D are stored in array E;
IPIV format is the same as in *_ROOK routines, but differs
from SY Bunch-Kaufman routines (e.g. *SYTRF).
The factorization output of these new rook _RK routines is not
compatible
with the existing _ROOK routines and vice versa. This new factorization
format is designed in such a way, that there is a possibility in the
future
to write new Bunch-Kaufman routines that conform to this new
factorization format.
Then the future Bunch-Kaufman routines could share solver
*TRS_3,inversion *TRI_3
and condition estimator *CON_3.

To convert between the factorization formats in both ways the following
routines
are developed:

CONVERSION ROUTINES BETWEEN FACTORIZATION FORMATS

DOUBLE PRECISION (symmetric indefinite matrices):

new file:   SRC/dsyconvf.f
new file:   SRC/dsyconvf_rook.f
REAL (symmetric indefinite matrices):

new file:   SRC/csyconvf.f
new file:   SRC/csyconvf_rook.f
COMPLEX*16 (symmetric indefinite and Hermitian indefinite matrices):

new file:   SRC/zsyconvf.f
new file:   SRC/zsyconvf_rook.f
COMPLEX (symmetric indefinite and Hermitian indefinite matrices):

new file:   SRC/ssyconvf.f
new file:   SRC/ssyconvf_rook.f
*SYCONVF routine converts between old Bunch-Kaufman storage format (
denote (L1,D1,IPIV1) )
that is used by *SYTRF and new rook storage format ( denote (L2,D2,
IPIV2))
that is used by *SYTRF_RK

*SYCONVF_ROOK routine between old rook storage format ( denote
(L1,D1,IPIV2) )
that is used by *SYTRF_ROOK and new rook storage format ( denote
(L2,D2, IPIV2))
that is used by *SYTRF_RK

ROUTINES AND DRIVERS

DOUBLE PRECISION (symmetric indefinite matrices):

new file:   SRC/dsytf2_rk.f BLAS2 unblocked factorization
new file:   SRC/dlasyf_rk.f BLAS3 auxiliary blocked partial
factorization
new file:   SRC/dsytrf_rk.f BLAS3 blocked factorization
new file:   SRC/dsytrs_3.f BLAS3 solver
new file:   SRC/dsycon_3.f BLAS3 condition number estimator
new file:   SRC/dsytri_3.f BLAS3 inversion, sets the size of work array
and calls *sytri_3x
new file:   SRC/dsytri_3x.f BLAS3 auxiliary inversion, actually
computes blocked inversion
new file:   SRC/dsysv_rk.f BLAS3 solver driver
REAL (symmetric indefinite matrices):

new file:   SRC/ssytf2_rk.f BLAS2 unblocked factorization
new file:   SRC/slasyf_rk.f BLAS3 auxiliary blocked partial
factorization
new file:   SRC/ssytrf_rk.f BLAS3 blocked factorization
new file:   SRC/ssytrs_3.f BLAS3 solver
new file:   SRC/ssycon_3.f BLAS3 condition number estimator
new file:   SRC/ssytri_3.f BLAS3 inversion, sets the size of work array
and calls *sytri_3x
new file:   SRC/ssytri_3x.f BLAS3 auxiliary inversion, actually
computes blocked inversion
new file:   SRC/ssysv_rk.f BLAS3 solver driver
COMPLEX*16 (symmetric indefinite matrices):

new file:   SRC/zsytf2_rk.f BLAS2 unblocked factorization
new file:   SRC/zlasyf_rk.f BLAS3 auxiliary blocked partial
factorization
new file:   SRC/zsytrf_rk.f BLAS3 blocked factorization
new file:   SRC/zsytrs_3.f BLAS3 solver
new file:   SRC/zsycon_3.f BLAS3 condition number estimator
new file:   SRC/zsytri_3.f BLAS3 inversion, sets the size of work array
and calls *sytri_3x
new file:   SRC/zsytri_3x.f BLAS3 auxiliary inversion, actually
computes blocked inversion
new file:   SRC/zsysv_rk.f BLAS3 solver driver
COMPLEX*16 (Hermitian indefinite matrices):

new file:   SRC/zhetf2_rk.f BLAS2 unblocked factorization
new file:   SRC/zlahef_rk.f BLAS3 auxiliary blocked partial
factorization
new file:   SRC/zhetrf_rk.f BLAS3 blocked factorization
new file:   SRC/zhetrs_3.f BLAS3 solver
new file:   SRC/zhecon_3.f BLAS3 condition number estimator
new file:   SRC/zhetri_3.f BLAS3 inversion, sets the size of work array
and calls *sytri_3x
new file:   SRC/zhetri_3x.f BLAS3 auxiliary inversion, actually
computes blocked inversion
new file:   SRC/zhesv_rk.f BLAS3 solver driver
COMPLEX (symmetric indefinite matrices):

new file:   SRC/csytf2_rk.f BLAS2 unblocked factorization
new file:   SRC/clasyf_rk.f BLAS3 auxiliary blocked partial
factorization
new file:   SRC/csytrf_rk.f BLAS3 blocked factorization
new file:   SRC/csytrs_3.f BLAS3 solver
new file:   SRC/csycon_3.f BLAS3 condition number estimator
new file:   SRC/csytri_3.f BLAS3 inversion, sets the size of work array
and calls *sytri_3x
new file:   SRC/csytri_3x.f BLAS3 auxiliary inversion, actually
computes blocked inversion
new file:   SRC/csysv_rk.f BLAS3 solver driver
COMPLEX (Hermitian indefinite matrices):

new file:   SRC/chetf2_rk.f BLAS2 unblocked factorization
new file:   SRC/clahef_rk.f BLAS3 auxiliary blocked partial
factorization
new file:   SRC/chetrf_rk.f BLAS3 blocked factorization
new file:   SRC/chetrs_3.f BLAS3 solver
new file:   SRC/checon_3.f BLAS3 condition number estimator
new file:   SRC/chetri_3.f BLAS3 inversion, sets the size of work array
and calls *sytri_3x
new file:   SRC/chetri_3x.f BLAS3 auxiliary inversion, actually
computes blocked inversion
new file:   SRC/chesv_rk.f BLAS3 solver driver
MISC

modified:   SRC/CMakeLists.txt
modified:   SRC/Makefile
TEST CODE

modified:   TESTING/LIN/CMakeLists.txt
modified:   TESTING/LIN/Makefile

modified:   TESTING/LIN/aladhd.f
modified:   TESTING/LIN/alaerh.f
modified:   TESTING/LIN/alahd.f
DOUBLE PRECISION (symmetric indefinite matrices):

modified:   TESTING/LIN/dchkaa.f
modified:   TESTING/LIN/derrsy.f
modified:   TESTING/LIN/derrsyx.f
modified:   TESTING/LIN/derrvx.f
modified:   TESTING/LIN/derrvxx.f

modified:   TESTING/dtest.in

new file:   TESTING/LIN/dchksy_rk.f
new file:   TESTING/LIN/ddrvsy_rk.f
new file:   TESTING/LIN/dsyt01_3.f
REAL (symmetric indefinite matrices):

modified:   TESTING/LIN/schkaa.f
modified:   TESTING/LIN/serrsy.f
modified:   TESTING/LIN/serrsyx.f
modified:   TESTING/LIN/serrvx.f
modified:   TESTING/LIN/serrvxx.f

modified:   TESTING/stest.in

new file:   TESTING/LIN/schksy_rk.f
new file:   TESTING/LIN/sdrvsy_rk.f
new file:   TESTING/LIN/ssyt01_3.f
COMPLEX*16 (symmetric indefinite and Hermitian indefinite matrices):

modified:   TESTING/LIN/zchkaa.f
modified:   TESTING/LIN/zerrsy.f
modified:   TESTING/LIN/zerrsyx.f
modified:   TESTING/LIN/zerrhe.f
modified:   TESTING/LIN/zerrhex.f
modified:   TESTING/LIN/zerrvx.f
modified:   TESTING/LIN/zerrvxx.f

modified:   TESTING/ztest.in

new file:   TESTING/LIN/zchksy_rk.f
new file:   TESTING/LIN/zdrvsy_rk.f
new file:   TESTING/LIN/zsyt01_3.f
new file:   TESTING/LIN/zchkhe_rk.f
new file:   TESTING/LIN/zdrvhe_rk.f
new file:   TESTING/LIN/zhet01_3.f
COMPLEX (symmetric indefinite and Hermitian indefinite matrices):

modified:   TESTING/LIN/cchkaa.f
modified:   TESTING/LIN/cerrsy.f
modified:   TESTING/LIN/cerrsyx.f
modified:   TESTING/LIN/cerrhe.f
modified:   TESTING/LIN/cerrhex.f
modified:   TESTING/LIN/cerrvx.f
modified:   TESTING/LIN/cerrvxx.f

modified:   TESTING/ctest.in

new file:   TESTING/LIN/cchksy_rk.f
new file:   TESTING/LIN/cdrvsy_rk.f
new file:   TESTING/LIN/csyt01_3.f
new file:   TESTING/LIN/cchkhe_rk.f
new file:   TESTING/LIN/cdrvhe_rk.f
new file:   TESTING/LIN/chet01_3.f

1 files changed, 248 insertions, 0 deletions

diff --git a/TESTING/LIN/ssyt01_3.f b/TESTING/LIN/ssyt01_3.f
new file mode 100644
index 00000000..8364d021
--- /dev/null
+++ b/TESTING/LIN/ssyt01_3.f
@@ -0,0 +1,248 @@
+*> \brief \b SSYT01_3
+*
+*  =========== DOCUMENTATION ===========
+*
+* Online html documentation available at
+*            http://www.netlib.org/lapack/explore-html/
+*
+*  Definition:
+*  ===========
+*
+*       SUBROUTINE SSYT01_3( UPLO, N, A, LDA, AFAC, LDAFAC, E, IPIV, C,
+*                            LDC, RWORK, RESID )
+*
+*       .. Scalar Arguments ..
+*       CHARACTER          UPLO
+*       INTEGER            LDA, LDAFAC, LDC, N
+*       DOUBLE PRECISION   RESID
+*       ..
+*       .. Array Arguments ..
+*       INTEGER            IPIV( * )
+*       DOUBLE PRECISION   A( LDA, * ), AFAC( LDAFAC, * ), C( LDC, * ),
+*      $                   E( * ), RWORK( * )
+*       ..
+*
+*
+*> \par Purpose:
+*  =============
+*>
+*> \verbatim
+*>
+*> SSYT01_3 reconstructs a symmetric indefinite matrix A from its
+*> block L*D*L' or U*D*U' factorization computed by SSYTRF_RK
+*> (or SSYTRF_BK) and computes the residual
+*>    norm( C - A ) / ( N * norm(A) * EPS ),
+*> where C is the reconstructed matrix and EPS is the machine epsilon.
+*> \endverbatim
+*
+*  Arguments:
+*  ==========
+*
+*> \param[in] UPLO
+*> \verbatim
+*>          UPLO is CHARACTER*1
+*>          Specifies whether the upper or lower triangular part of the
+*>          symmetric matrix A is stored:
+*>          = 'U':  Upper triangular
+*>          = 'L':  Lower triangular
+*> \endverbatim
+*>
+*> \param[in] N
+*> \verbatim
+*>          N is INTEGER
+*>          The number of rows and columns of the matrix A.  N >= 0.
+*> \endverbatim
+*>
+*> \param[in] A
+*> \verbatim
+*>          A is DOUBLE PRECISION array, dimension (LDA,N)
+*>          The original symmetric matrix A.
+*> \endverbatim
+*>
+*> \param[in] LDA
+*> \verbatim
+*>          LDA is INTEGER
+*>          The leading dimension of the array A.  LDA >= max(1,N)
+*> \endverbatim
+*>
+*> \param[in] AFAC
+*> \verbatim
+*>          AFAC is DOUBLE PRECISION array, dimension (LDAFAC,N)
+*>          Diagonal of the block diagonal matrix D and factors U or L
+*>          as computed by SSYTRF_RK and SSYTRF_BK:
+*>            a) ONLY diagonal elements of the symmetric block diagonal
+*>               matrix D on the diagonal of A, i.e. D(k,k) = A(k,k);
+*>               (superdiagonal (or subdiagonal) elements of D
+*>                should be provided on entry in array E), and
+*>            b) If UPLO = 'U': factor U in the superdiagonal part of A.
+*>               If UPLO = 'L': factor L in the subdiagonal part of A.
+*> \endverbatim
+*>
+*> \param[in] LDAFAC
+*> \verbatim
+*>          LDAFAC is INTEGER
+*>          The leading dimension of the array AFAC.
+*>          LDAFAC >= max(1,N).
+*> \endverbatim
+*>
+*> \param[in] E
+*> \verbatim
+*>          E is DOUBLE PRECISION array, dimension (N)
+*>          On entry, contains the superdiagonal (or subdiagonal)
+*>          elements of the symmetric block diagonal matrix D
+*>          with 1-by-1 or 2-by-2 diagonal blocks, where
+*>          If UPLO = 'U': E(i) = D(i-1,i),i=2:N, E(1) not refernced;
+*>          If UPLO = 'L': E(i) = D(i+1,i),i=1:N-1, E(N) not referenced.
+*> \endverbatim
+*>
+*> \param[in] IPIV
+*> \verbatim
+*>          IPIV is INTEGER array, dimension (N)
+*>          The pivot indices from SSYTRF_RK (or SSYTRF_BK).
+*> \endverbatim
+*>
+*> \param[out] C
+*> \verbatim
+*>          C is DOUBLE PRECISION array, dimension (LDC,N)
+*> \endverbatim
+*>
+*> \param[in] LDC
+*> \verbatim
+*>          LDC is INTEGER
+*>          The leading dimension of the array C.  LDC >= max(1,N).
+*> \endverbatim
+*>
+*> \param[out] RWORK
+*> \verbatim
+*>          RWORK is DOUBLE PRECISION array, dimension (N)
+*> \endverbatim
+*>
+*> \param[out] RESID
+*> \verbatim
+*>          RESID is DOUBLE PRECISION
+*>          If UPLO = 'L', norm(L*D*L' - A) / ( N * norm(A) * EPS )
+*>          If UPLO = 'U', norm(U*D*U' - A) / ( N * norm(A) * EPS )
+*> \endverbatim
+*
+*  Authors:
+*  ========
+*
+*> \author Univ. of Tennessee
+*> \author Univ. of California Berkeley
+*> \author Univ. of Colorado Denver
+*> \author NAG Ltd.
+*
+*> \date November 2016
+*
+*> \ingroup single_lin
+*
+*  =====================================================================
+      SUBROUTINE SSYT01_3( UPLO, N, A, LDA, AFAC, LDAFAC, E, IPIV, C,
+     $                     LDC, RWORK, RESID )
+*
+*  -- LAPACK test routine (version 3.7.0) --
+*  -- LAPACK is a software package provided by Univ. of Tennessee,    --
+*  -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--
+*     November 2016
+*
+*     .. Scalar Arguments ..
+      CHARACTER          UPLO
+      INTEGER            LDA, LDAFAC, LDC, N
+      REAL               RESID
+*     ..
+*     .. Array Arguments ..
+      INTEGER            IPIV( * )
+      REAL               A( LDA, * ), AFAC( LDAFAC, * ), C( LDC, * ),
+     $                   E( * ), RWORK( * )
+*     ..
+*
+*  =====================================================================
+*
+*     .. Parameters ..
+      REAL               ZERO, ONE
+      PARAMETER          ( ZERO = 0.0E+0, ONE = 1.0E+0 )
+*     ..
+*     .. Local Scalars ..
+      INTEGER            I, INFO, J
+      REAL               ANORM, EPS
+*     ..
+*     .. External Functions ..
+      LOGICAL            LSAME
+      REAL               SLAMCH, SLANSY
+      EXTERNAL           LSAME, SLAMCH, SLANSY
+*     ..
+*     .. External Subroutines ..
+      EXTERNAL           SLASET, SLAVSY_ROOK, SSYCONVF_ROOK
+*     ..
+*     .. Intrinsic Functions ..
+      INTRINSIC          REAL
+*     ..
+*     .. Executable Statements ..
+*
+*     Quick exit if N = 0.
+*
+      IF( N.LE.0 ) THEN
+         RESID = ZERO
+         RETURN
+      END IF
+*
+*     a) Revert to multiplyers of L
+*
+      CALL SSYCONVF_ROOK( UPLO, 'R', N, AFAC, LDAFAC, E, IPIV, INFO )
+*
+*     1) Determine EPS and the norm of A.
+*
+      EPS = SLAMCH( 'Epsilon' )
+      ANORM = SLANSY( '1', UPLO, N, A, LDA, RWORK )
+*
+*     2) Initialize C to the identity matrix.
+*
+      CALL SLASET( 'Full', N, N, ZERO, ONE, C, LDC )
+*
+*     3) Call SLAVSY_ROOK to form the product D * U' (or D * L' ).
+*
+      CALL SLAVSY_ROOK( UPLO, 'Transpose', 'Non-unit', N, N, AFAC,
+     $                  LDAFAC, IPIV, C, LDC, INFO )
+*
+*     4) Call SLAVSY_ROOK again to multiply by U (or L ).
+*
+      CALL SLAVSY_ROOK( UPLO, 'No transpose', 'Unit', N, N, AFAC,
+     $                  LDAFAC, IPIV, C, LDC, INFO )
+*
+*     5) Compute the difference  C - A.
+*
+      IF( LSAME( UPLO, 'U' ) ) THEN
+         DO J = 1, N
+            DO I = 1, J
+               C( I, J ) = C( I, J ) - A( I, J )
+            END DO
+         END DO
+      ELSE
+         DO J = 1, N
+            DO I = J, N
+               C( I, J ) = C( I, J ) - A( I, J )
+            END DO
+         END DO
+      END IF
+*
+*     6) Compute norm( C - A ) / ( N * norm(A) * EPS )
+*
+      RESID = SLANSY( '1', UPLO, N, C, LDC, RWORK )
+*
+      IF( ANORM.LE.ZERO ) THEN
+         IF( RESID.NE.ZERO )
+     $      RESID = ONE / EPS
+      ELSE
+         RESID = ( ( RESID / REAL( N ) ) / ANORM ) / EPS
+      END IF
+
+*
+*     b) Convert to factor of L (or U)
+*
+      CALL SSYCONVF_ROOK( UPLO, 'C', N, AFAC, LDAFAC, E, IPIV, INFO )
+*
+      RETURN
+*
+*     End of SSYT01_3
+*
+      END