---
name: "sget23.f"
section: "3"
platform: "linux"
package: "lapack-doc"
version: "3.12.1-2"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/sget23.f"
---

# sget23.f(3)

## NAME

TESTING/EIG/sget23.f

## SYNOPSIS

### Functions/Subroutines

subroutine **sget23** (comp, balanc, jtype, thresh, iseed, nounit, n, a, lda, h, wr, wi, wr1, wi1, vl, ldvl, vr, ldvr, lre, ldlre, rcondv, rcndv1, rcdvin, rconde, rcnde1, rcdein, scale, scale1, result, work, lwork, iwork, info)\
 **SGET23**

## Function/Subroutine Documentation

### subroutine sget23 (logical comp, character balanc, integer jtype, real thresh, integer, dimension( 4 ) iseed, integer nounit, integer n, real, dimension( lda, \* ) a, integer lda, real, dimension( lda, \* ) h, real, dimension( \* ) wr, real, dimension( \* ) wi, real, dimension( \* ) wr1, real, dimension( \* ) wi1, real, dimension( ldvl, \* ) vl, integer ldvl, real, dimension( ldvr, \* ) vr, integer ldvr, real, dimension( ldlre, \* ) lre, integer ldlre, real, dimension( \* ) rcondv, real, dimension( \* ) rcndv1, real, dimension( \* ) rcdvin, real, dimension( \* ) rconde, real, dimension( \* ) rcnde1, real, dimension( \* ) rcdein, real, dimension( \* ) scale, real, dimension( \* ) scale1, real, dimension( 11 ) result, real, dimension( \* ) work, integer lwork, integer, dimension( \* ) iwork, integer info)

**SGET23**

**Purpose:**

```
!>
!>    SGET23  checks the nonsymmetric eigenvalue problem driver SGEEVX.
!>    If COMP = .FALSE., the first 8 of the following tests will be
!>    performed on the input matrix A, and also test 9 if LWORK is
!>    sufficiently large.
!>    if COMP is .TRUE. all 11 tests will be performed.
!>
!>    (1)     | A * VR - VR * W | / ( n |A| ulp )
!>
!>      Here VR is the matrix of unit right eigenvectors.
!>      W is a block diagonal matrix, with a 1x1 block for each
!>      real eigenvalue and a 2x2 block for each complex conjugate
!>      pair.  If eigenvalues j and j+1 are a complex conjugate pair,
!>      so WR(j) = WR(j+1) = wr and WI(j) = - WI(j+1) = wi, then the
!>      2 x 2 block corresponding to the pair will be:
!>
!>              (  wr  wi  )
!>              ( -wi  wr  )
!>
!>      Such a block multiplying an n x 2 matrix  ( ur ui ) on the
!>      right will be the same as multiplying  ur + i*ui  by  wr + i*wi.
!>
!>    (2)     | A**H * VL - VL * W**H | / ( n |A| ulp )
!>
!>      Here VL is the matrix of unit left eigenvectors, A**H is the
!>      conjugate transpose of A, and W is as above.
!>
!>    (3)     | |VR(i)| - 1 | / ulp and largest component real
!>
!>      VR(i) denotes the i-th column of VR.
!>
!>    (4)     | |VL(i)| - 1 | / ulp and largest component real
!>
!>      VL(i) denotes the i-th column of VL.
!>
!>    (5)     0 if W(full) = W(partial), 1/ulp otherwise
!>
!>      W(full) denotes the eigenvalues computed when VR, VL, RCONDV
!>      and RCONDE are also computed, and W(partial) denotes the
!>      eigenvalues computed when only some of VR, VL, RCONDV, and
!>      RCONDE are computed.
!>
!>    (6)     0 if VR(full) = VR(partial), 1/ulp otherwise
!>
!>      VR(full) denotes the right eigenvectors computed when VL, RCONDV
!>      and RCONDE are computed, and VR(partial) denotes the result
!>      when only some of VL and RCONDV are computed.
!>
!>    (7)     0 if VL(full) = VL(partial), 1/ulp otherwise
!>
!>      VL(full) denotes the left eigenvectors computed when VR, RCONDV
!>      and RCONDE are computed, and VL(partial) denotes the result
!>      when only some of VR and RCONDV are computed.
!>
!>    (8)     0 if SCALE, ILO, IHI, ABNRM (full) =
!>                 SCALE, ILO, IHI, ABNRM (partial)
!>            1/ulp otherwise
!>
!>      SCALE, ILO, IHI and ABNRM describe how the matrix is balanced.
!>      (full) is when VR, VL, RCONDE and RCONDV are also computed, and
!>      (partial) is when some are not computed.
!>
!>    (9)     0 if RCONDV(full) = RCONDV(partial), 1/ulp otherwise
!>
!>      RCONDV(full) denotes the reciprocal condition numbers of the
!>      right eigenvectors computed when VR, VL and RCONDE are also
!>      computed. RCONDV(partial) denotes the reciprocal condition
!>      numbers when only some of VR, VL and RCONDE are computed.
!>
!>   (10)     |RCONDV - RCDVIN| / cond(RCONDV)
!>
!>      RCONDV is the reciprocal right eigenvector condition number
!>      computed by SGEEVX and RCDVIN (the precomputed true value)
!>      is supplied as input. cond(RCONDV) is the condition number of
!>      RCONDV, and takes errors in computing RCONDV into account, so
!>      that the resulting quantity should be O(ULP). cond(RCONDV) is
!>      essentially given by norm(A)/RCONDE.
!>
!>   (11)     |RCONDE - RCDEIN| / cond(RCONDE)
!>
!>      RCONDE is the reciprocal eigenvalue condition number
!>      computed by SGEEVX and RCDEIN (the precomputed true value)
!>      is supplied as input.  cond(RCONDE) is the condition number
!>      of RCONDE, and takes errors in computing RCONDE into account,
!>      so that the resulting quantity should be O(ULP). cond(RCONDE)
!>      is essentially given by norm(A)/RCONDV.
!>
```

**Parameters**

*COMP*

```
!>          COMP is LOGICAL
!>          COMP describes which input tests to perform:
!>            = .FALSE. if the computed condition numbers are not to
!>                      be tested against RCDVIN and RCDEIN
!>            = .TRUE.  if they are to be compared
!>
```

*BALANC*

```
!>          BALANC is CHARACTER
!>          Describes the balancing option to be tested.
!>            = 'N' for no permuting or diagonal scaling
!>            = 'P' for permuting but no diagonal scaling
!>            = 'S' for no permuting but diagonal scaling
!>            = 'B' for permuting and diagonal scaling
!>
```

*JTYPE*

```
!>          JTYPE is INTEGER
!>          Type of input matrix. Used to label output if error occurs.
!>
```

*THRESH*

```
!>          THRESH is REAL
!>          A test will count as  if the , computed as
!>          described above, exceeds THRESH.  Note that the error
!>          is scaled to be O(1), so THRESH should be a reasonably
!>          small multiple of 1, e.g., 10 or 100.  In particular,
!>          it should not depend on the precision (single vs. double)
!>          or the size of the matrix.  It must be at least zero.
!>
```

*ISEED*

```
!>          ISEED is INTEGER array, dimension (4)
!>          If COMP = .FALSE., the random number generator seed
!>          used to produce matrix.
!>          If COMP = .TRUE., ISEED(1) = the number of the example.
!>          Used to label output if error occurs.
!>
```

*NOUNIT*

```
!>          NOUNIT is INTEGER
!>          The FORTRAN unit number for printing out error messages
!>          (e.g., if a routine returns INFO not equal to 0.)
!>
```

*N*

```
!>          N is INTEGER
!>          The dimension of A. N must be at least 0.
!>
```

*A*

```
!>          A is REAL array, dimension (LDA,N)
!>          Used to hold the matrix whose eigenvalues are to be
!>          computed.
!>
```

*LDA*

```
!>          LDA is INTEGER
!>          The leading dimension of A, and H. LDA must be at
!>          least 1 and at least N.
!>
```

*H*

```
!>          H is REAL array, dimension (LDA,N)
!>          Another copy of the test matrix A, modified by SGEEVX.
!>
```

*WR*

```
!>          WR is REAL array, dimension (N)
!>
```

*WI*

```
!>          WI is REAL array, dimension (N)
!>
!>          The real and imaginary parts of the eigenvalues of A.
!>          On exit, WR + WI*i are the eigenvalues of the matrix in A.
!>
```

*WR1*

```
!>          WR1 is REAL array, dimension (N)
!>
```

*WI1*

```
!>          WI1 is REAL array, dimension (N)
!>
!>          Like WR, WI, these arrays contain the eigenvalues of A,
!>          but those computed when SGEEVX only computes a partial
!>          eigendecomposition, i.e. not the eigenvalues and left
!>          and right eigenvectors.
!>
```

*VL*

```
!>          VL is REAL array, dimension (LDVL,N)
!>          VL holds the computed left eigenvectors.
!>
```

*LDVL*

```
!>          LDVL is INTEGER
!>          Leading dimension of VL. Must be at least max(1,N).
!>
```

*VR*

```
!>          VR is REAL array, dimension (LDVR,N)
!>          VR holds the computed right eigenvectors.
!>
```

*LDVR*

```
!>          LDVR is INTEGER
!>          Leading dimension of VR. Must be at least max(1,N).
!>
```

*LRE*

```
!>          LRE is REAL array, dimension (LDLRE,N)
!>          LRE holds the computed right or left eigenvectors.
!>
```

*LDLRE*

```
!>          LDLRE is INTEGER
!>          Leading dimension of LRE. Must be at least max(1,N).
!>
```

*RCONDV*

```
!>          RCONDV is REAL array, dimension (N)
!>          RCONDV holds the computed reciprocal condition numbers
!>          for eigenvectors.
!>
```

*RCNDV1*

```
!>          RCNDV1 is REAL array, dimension (N)
!>          RCNDV1 holds more computed reciprocal condition numbers
!>          for eigenvectors.
!>
```

*RCDVIN*

```
!>          RCDVIN is REAL array, dimension (N)
!>          When COMP = .TRUE. RCDVIN holds the precomputed reciprocal
!>          condition numbers for eigenvectors to be compared with
!>          RCONDV.
!>
```

*RCONDE*

```
!>          RCONDE is REAL array, dimension (N)
!>          RCONDE holds the computed reciprocal condition numbers
!>          for eigenvalues.
!>
```

*RCNDE1*

```
!>          RCNDE1 is REAL array, dimension (N)
!>          RCNDE1 holds more computed reciprocal condition numbers
!>          for eigenvalues.
!>
```

*RCDEIN*

```
!>          RCDEIN is REAL array, dimension (N)
!>          When COMP = .TRUE. RCDEIN holds the precomputed reciprocal
!>          condition numbers for eigenvalues to be compared with
!>          RCONDE.
!>
```

*SCALE*

```
!>          SCALE is REAL array, dimension (N)
!>          Holds information describing balancing of matrix.
!>
```

*SCALE1*

```
!>          SCALE1 is REAL array, dimension (N)
!>          Holds information describing balancing of matrix.
!>
```

*RESULT*

```
!>          RESULT is REAL array, dimension (11)
!>          The values computed by the 11 tests described above.
!>          The values are currently limited to 1/ulp, to avoid
!>          overflow.
!>
```

*WORK*

```
!>          WORK is REAL array, dimension (LWORK)
!>
```

*LWORK*

```
!>          LWORK is INTEGER
!>          The number of entries in WORK.  This must be at least
!>          3*N, and 6*N+N**2 if tests 9, 10 or 11 are to be performed.
!>
```

*IWORK*

```
!>          IWORK is INTEGER array, dimension (2*N)
!>
```

*INFO*

```
!>          INFO is INTEGER
!>          If 0,  successful exit.
!>          If <0, input parameter -INFO had an incorrect value.
!>          If >0, SGEEVX returned an error code, the absolute
!>                 value of which is returned.
!>
```

**Author**

Univ. of Tennessee

Univ. of California Berkeley

Univ. of Colorado Denver

NAG Ltd.

Definition at line **373** of file **sget23.f**.

## Author

Generated automatically by Doxygen for LAPACK from the source code.