# ?laexc

Swaps adjacent diagonal blocks of a real upper quasi-triangular matrix in Schur canonical form, by an orthogonal similarity transformation.

## Syntax

call slaexc( wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info )

call dlaexc( wantq, n, t, ldt, q, ldq, j1, n1, n2, work, info )

## Include Files

• Fortran: mkl.fi
• C: mkl.h

## Description

The routine swaps adjacent diagonal blocks T11 and T22 of order 1 or 2 in an upper quasi-triangular matrix T by an orthogonal similarity transformation.

T must be in Schur canonical form, that is, block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each 2-by-2 diagonal block has its diagonal elements equal and its off-diagonal elements of opposite sign.

## Input Parameters

wantq

LOGICAL.

If `wantq = .TRUE.`, accumulate the transformation in the matrix Q;

If `wantq = .FALSE.`, do not accumulate the transformation.

n

INTEGER. The order of the matrix T (`n ≥ 0`).

t, q

REAL for slaexc

DOUBLE PRECISION for dlaexc

Arrays:

`t(ldt,*)` contains on entry the upper quasi-triangular matrix T, in Schur canonical form.

The second dimension of t must be at least `max(1, n)`.

`q(ldq,*)` contains on entry, if `wantq = .TRUE.`, the orthogonal matrix Q. If `wantq = .FALSE.`, q is not referenced. The second dimension of q must be at least `max(1, n)`.

ldt

INTEGER. The leading dimension of t; at least `max(1, n)`.

ldq

INTEGER. The leading dimension of q;

If `wantq = .FALSE.`, then `ldq ≥ 1`.

If `wantq = .TRUE.`, then `ldq ≥ max(1,n)`.

j1

INTEGER. The index of the first row of the first block T11.

n1

INTEGER. The order of the first block T11

(`n1 = 0, 1, or 2`).

n2

INTEGER. The order of the second block T22

(`n2 = 0, 1, or 2`).

work

REAL for slaexc;

DOUBLE PRECISION for dlaexc.

Workspace array, DIMENSION (n).

## Output Parameters

t

On exit, the updated matrix T, again in Schur canonical form.

q

On exit, if `wantq = .TRUE.`, the updated matrix Q.

info

INTEGER.

If `info = 0`, the execution is successful.

If `info = 1`, the transformed matrix T would be too far from Schur form; the blocks are not swapped and T and Q are unchanged.

For more complete information about compiler optimizations, see our Optimization Notice.