## MB03SD

### Eigenvalues of a square-reduced Hamiltonian matrix

[Specification] [Arguments] [Method] [References] [Comments] [Example]

Purpose

```  To compute the eigenvalues of an N-by-N square-reduced Hamiltonian
matrix

( A'   G'  )
H'  =  (        T ).                                       (1)
( Q'  -A'  )

Here, A' is an N-by-N matrix, and G' and Q' are symmetric N-by-N
matrices.  It is assumed without a check that H' is square-
reduced, i.e., that

2    ( A''   G'' )
H'  =  (         T )    with A'' upper Hessenberg.         (2)
( 0    A''  )

T                2
(Equivalently, Q'A'- A' Q' = 0, A'' = A' + G'Q', and for i > j+1,
A''(i,j) = 0.)  Ordinarily, H' is the output from SLICOT Library
routine MB04ZD. The eigenvalues of H' are computed as the square
roots of the eigenvalues of A''.

```
Specification
```      SUBROUTINE MB03SD( JOBSCL, N, A, LDA, QG, LDQG, WR, WI, DWORK,
\$                   LDWORK, INFO )
C     .. Scalar Arguments ..
INTEGER           INFO, LDA, LDQG, LDWORK, N
CHARACTER         JOBSCL
C     .. Array Arguments ..
DOUBLE PRECISION  A(LDA,*), DWORK(*), QG(LDQG,*), WI(*), WR(*)

```
Arguments

Mode Parameters

```  JOBSCL  CHARACTER*1
Specifies whether or not balancing operations should
be performed by the LAPACK subroutine DGEBAL on the
Hessenberg matrix A'' in (2), as follows:
= 'N':  do not use balancing;
= 'S':  do scaling in order to equilibrate the rows
and columns of A''.
See LAPACK subroutine DGEBAL and Section METHOD below.

```
Input/Output Parameters
```  N       (input) INTEGER
The order of the matrices A, G, and Q.  N >= 0.

A       (input) DOUBLE PRECISION array, dimension (LDA,N)
The leading N-by-N part of this array must contain the
upper left block A' of the square-reduced Hamiltonian
matrix H' in (1), as produced by SLICOT Library routine
MB04ZD.

LDA     INTEGER
The leading dimension of the array A.  LDA >= MAX(1,N).

QG      (input) DOUBLE PRECISION array, dimension (LDQG,N+1)
The leading N-by-N lower triangular part of this array
must contain the lower triangle of the lower left
symmetric block Q' of the square-reduced Hamiltonian
matrix H' in (1), and the N-by-N upper triangular part of
the submatrix in the columns 2 to N+1 of this array must
contain the upper triangle of the upper right symmetric
block G' of the square-reduced Hamiltonian matrix H'
in (1), as produced by SLICOT Library routine MB04ZD.
So, if i >= j, then Q'(i,j) is stored in QG(i,j) and
G'(i,j) is stored in QG(j,i+1).

LDQG    INTEGER
The leading dimension of the array QG.  LDQG >= MAX(1,N).

WR      (output) DOUBLE PRECISION array, dimension (N)
WI      (output) DOUBLE PRECISION array, dimension (N)
The arrays WR and WI contain the real and imaginary parts,
respectively, of the N eigenvalues of H' with non-negative
real part.  The remaining N eigenvalues are the negatives
of these eigenvalues.
Eigenvalues are stored in WR and WI in decreasing order of
magnitude of the real parts, i.e., WR(I) >= WR(I+1).
(In particular, an eigenvalue closest to the imaginary
axis is WR(N)+WI(N)i.)
In addition, eigenvalues with zero real part are sorted in
decreasing order of magnitude of imaginary parts.  Note
that non-real eigenvalues with non-zero real part appear
in complex conjugate pairs, but eigenvalues with zero real
part do not, in general, appear in complex conjugate
pairs.

```
Workspace
```  DWORK   DOUBLE PRECISION array, dimension (LDWORK)
On exit, if INFO = 0, DWORK(1) returns the optimal value
of LDWORK.

LDWORK  INTEGER
The dimension of the array DWORK.
LDWORK >= MAX(1,N*(N+1)).
For good performance, LDWORK should be larger.

```
Error Indicator
```  INFO    INTEGER
= 0:  successful exit;
< 0:  if INFO = -i, then the i-th argument had an illegal
value;
> 0:  if INFO =  i, i <= N, then LAPACK subroutine DHSEQR
failed to converge while computing the i-th
eigenvalue.

```
Method
```  The routine forms the upper Hessenberg matrix A'' in (2) and calls
LAPACK subroutines to calculate its eigenvalues.  The eigenvalues
of H' are the square roots of the eigenvalues of A''.

```
References
```   Van Loan, C. F.
A Symplectic Method for Approximating All the Eigenvalues of
a Hamiltonian Matrix.
Linear Algebra and its Applications, 61, pp. 233-251, 1984.

 Byers, R.
Hamiltonian and Symplectic Algorithms for the Algebraic
Riccati Equation.
Ph. D. Thesis, Cornell University, Ithaca, NY, January 1983.

 Benner, P., Byers, R., and Barth, E.
Fortran 77 Subroutines for Computing the Eigenvalues of
Hamiltonian Matrices. I: The Square-Reduced Method.
ACM Trans. Math. Software, 26, 1, pp. 49-77, 2000.

```
Numerical Aspects
```  The algorithm requires (32/3)*N**3 + O(N**2) floating point
operations.
Eigenvalues computed by this subroutine are exact eigenvalues
of a perturbed Hamiltonian matrix  H' + E  where

|| E || <= c sqrt(eps) || H' ||,

c is a modest constant depending on the dimension N and eps is the
machine precision. Moreover, if the norm of H' and an eigenvalue
are of roughly the same magnitude, the computed eigenvalue is
essentially as accurate as the computed eigenvalue obtained by
traditional methods. See  or .

```
```  None
```
Example

Program Text

```*     MB03SD EXAMPLE PROGRAM TEXT.
*     Copyright (c) 2002-2017 NICONET e.V.
*
*     .. Parameters ..
INTEGER          NIN, NOUT
PARAMETER        ( NIN = 5, NOUT = 6 )
INTEGER          NMAX
PARAMETER        ( NMAX = 20 )
INTEGER          LDA, LDQG
PARAMETER        ( LDA = NMAX, LDQG = NMAX )
INTEGER          LDWORK
PARAMETER        ( LDWORK = NMAX*( NMAX+1 ) )
*     .. Local Scalars ..
INTEGER          I, INFO, J, N
CHARACTER*1      JOBSCL
*     .. Local Arrays ..
DOUBLE PRECISION A(LDA,NMAX), DWORK(LDWORK), QG(LDQG,NMAX+1),
\$                 WI(NMAX), WR(NMAX)
*     .. External Subroutines ..
EXTERNAL         MB03SD
*     .. Executable Statements ..
*
WRITE ( NOUT, FMT = 99999 )
*     Skip the heading in the data file and read the data.
*     NOTE: input must define a square-reduced Hamiltonian matrix.
READ ( NIN, FMT = '()' )
READ ( NIN, FMT = * ) N, JOBSCL
IF ( N.LT.0 .OR. N.GT.NMAX ) THEN
WRITE ( NOUT, FMT = 99998 ) N
ELSE
READ ( NIN, FMT = * ) ( ( A(I,J),    J = 1,N ), I = 1,N )
READ ( NIN, FMT = * ) ( ( QG(J,I+1), I = J,N ), J = 1,N )
READ ( NIN, FMT = * ) ( ( QG(I,J),   I = J,N ), J = 1,N )
*        Compute the eigenvalues.
CALL MB03SD( JOBSCL, N, A, LDA, QG, LDQG, WR, WI, DWORK,
\$                LDWORK, INFO )
*
IF ( INFO.NE.0 ) THEN
WRITE ( NOUT, FMT = 99997 ) INFO
ELSE
*           Show the computed eigenvalues.
WRITE ( NOUT, FMT = 99996 )
DO 10 I = 1, N
WRITE ( NOUT, FMT = 99995 )  WR(I), ' + (',  WI(I), ')i'
10          CONTINUE
DO 20 I = N, 1, -1
WRITE ( NOUT, FMT = 99995 ) -WR(I), ' + (', -WI(I), ')i'
20          CONTINUE
END IF
END IF
STOP
*
99999 FORMAT (' MB03SD EXAMPLE PROGRAM RESULTS',/1X)
99998 FORMAT (/' N is out of range.',/' N = ',I5)
99997 FORMAT (' INFO on exit from MB03SD = ',I2)
99996 FORMAT (/' The eigenvalues are ')
99995 FORMAT (1X,F8.4,A,F8.4,A)
END
```
Program Data
```MB03SD EXAMPLE PROGRAM DATA
3 S
2.0  0.0  0.0
0.0  1.0  2.0
0.0 -1.0  3.0
1.0  0.0  0.0  2.0  3.0  4.0
-2.0  0.0  0.0  0.0  0.0  0.0
```
Program Results
``` MB03SD EXAMPLE PROGRAM RESULTS

The eigenvalues are
2.0000 + (  1.0000)i
2.0000 + ( -1.0000)i
1.4142 + (  0.0000)i
-1.4142 + (  0.0000)i
-2.0000 + (  1.0000)i
-2.0000 + ( -1.0000)i
```