## `linalg::jordanForm` -- Jordan normal form of a matrix

#### Introduction

`linalg::jordanForm``(A)` returns the Jordan normal form J of the matrix A.

#### Call(s)

`linalg::jordanForm(A <, All>)`

#### Parameters

`A` | - | a square matrix of a domain of category `Cat::Matrix`

#### Options

`All` | - | returns the list `[J, P]` with the Jordan normal form J of `A` and the corresponding transformation matrix P such that A = P * J * 1/P.

#### Returns

either a matrix of the same domain type as `A`, the list `[J, P]` when the option All is given, or the value `FAIL`.

#### Related Functions

`linalg::eigenvalues`, `linalg::frobeniusForm`, `linalg::smithForm`, `linalg::hermiteForm`

#### Details

- `linalg::jordanForm` computes a nonsingular transformation matrix P and a matrix J such that A = P * J * 1/P with J = diag( J[1],...,J[r] ) and Jordan matrices J[1],...,J[r].
- The Jordan normal form of a square matrix A over a field F exists if the characteristic polynomial of A splits over F into linear factors. If this is not the case for the matrix `A`, then `linalg::jordanForm` returns `FAIL`.

  The Jordan normal form is unique up to permutations of the Jordan matrices J[1],...,J[r].

- The implemented method computes the eigenvalues of `A`. It returns `FAIL` if this is not possible (see `linalg::eigenvalues`).
- The component ring of `A` must be a field, i.e., a domain of category `Cat::Field`.

#### Example 1

The Jordan normal form of the matrix:

    >> A := Dom::Matrix(Dom::Complex)([[1, 2], [4, 5]])

                                    +-      -+
                                    |  1, 2  |
                                    |        |
                                    |  4, 5  |
                                    +-      -+

is the following matrix:

    >> J := linalg::jordanForm(A)

                          +-                          -+
                          |       1/2                  |
                          |  - 2 3    + 3,      0      |
                          |                            |
                          |                   1/2      |
                          |        0,      2 3    + 3  |
                          +-                          -+

The corresponding transformation matrix P can be obtained from the result `[J, P]` of `linalg::jordanForm` with the option All:

    >> P := linalg::jordanForm(A, All)[2]

                          +-                          -+
                          |   1/2           1/2        |
                          |  3             3           |
                          |  ---- + 1/2, - ---- + 1/2  |
                          |   6             6          |
                          |                            |
                          |       1/2         1/2      |
                          |      3           3         |
                          |    - ----,       ----      |
                          |       3           3        |
                          +-                          -+

We check the result:

    >> map(P * J * P^(-1), radsimp)

                                    +-      -+
                                    |  1, 2  |
                                    |        |
                                    |  4, 5  |
                                    +-      -+

To get this result we must apply the function `radsimp` to each component of the matrix that is returned by the matrix product P * J * P(-1).

Do you have questions or comments?
Copyright © SciFace Software GmbH & Co. KG 2000