SLICOT periodic system utilities

mb03vd!(n::Integer, p::Integer, ilo::Integer, ihi::Integer, A::Array{Float64, 3}, tau::AbstractMatrix{Float64}) -> info::Int64

Reduce a product of p real general matrices A = A_1*A_2*...*A_p to upper Hessenberg form, H = H_1*H_2*...*H_p, where H_1 is upper Hessenberg, and H_2, ..., H_p are upper triangular, by using orthogonal similarity transformations on A,

    Q_1' * A_1 * Q_2 = H_1,
    Q_2' * A_2 * Q_3 = H_2,
           ...
    Q_p' * A_p * Q_1 = H_p.

The matrices A_1, A_2, ..., A_p are contained in the 3-dimensional array A. The resulting H_1, H_2, ..., H_p and Q_1, Q_2, ..., Q_p overwrite A_1, A_2, ..., A_p in A and the array tau.

See the SLICOT documentation of MB03VD for details.

 mb03vy!(n::Integer, p::Integer, ilo::Integer, ihi::Integer, A::Array{Float64, 3}, tau::AbstractMatrix{Float64}) -> info::Int64

Generate the real orthogonal matrices Q_1, Q_2, ..., Q_p, which are defined as the product of ihi-ilo elementary reflectors of order n, as returned in A_1, A_2, ..., A_p by mb03vd!:

 Q_j = H_j(ilo) H_j(ilo+1) . . . H_j(ihi-1).

The 3-dimensional arrays A and tau contains the information on the employed elementary reflectors. The resulting Q_1, Q_2, ..., Q_p overwrite A_1, A_2, ..., A_p.

See the SLICOT documentation of MB03VY for details.

mb03wd!(job::AbstractChar, compz::AbstractChar, n::Integer, p::Integer, 
        ilo::Integer, ihi::Integer, iloz::Integer, ihiz::Integer,  h::Array{Float64, 3}, z::Array{Float64, 3}, 
        wr::AbstractVector{Float64}, wi::AbstractVector{Float64}, ldwork::Integer) -> info::Int64

Compute the Schur decomposition and the eigenvalues of a product of matrices, H = H_1H_2...*H_p, with H_1 an upper Hessenberg matrix and H_2, ..., H_p upper triangular matrices, without evaluating the product. Specifically, the matrices Z_i are computed, such that

    `Z_1' * H_1 * Z_2 = T_1,`
    `Z_2' * H_2 * Z_3 = T_2,`
           `...`
    `Z_p' * H_p * Z_1 = T_p,`

where T_1 is in real Schur form, and T_2, ..., T_p are upper triangular.

The routine works primarily with the Hessenberg and triangular submatrices in rows and columns ILO to IHI, but optionally applies the transformations to all the rows and columns of the matrices H_i, i = 1,...,p. The transformations can be optionally accumulated.

See the SLICOT documentation of MB03WD for details.

mb03vw!(compq::AbstractChar, triu::AbstractChar, qind::AbstractVector{Int64}, k::Integer, n::Integer, h::Integer, 
        ilo::Integer, ihi::Integer, s::AbstractVector{Int64}, a::Array{Float64, 3}, q::Array{Float64, 3}, 
        liwork::Integer, ldwork::Integer) -> info::Int64
        
mb03vw!(compq::AbstractChar, triu::AbstractChar, qind::AbstractVector{Int64}, k::Integer, n::Integer, h::Integer, 
        ilo::Integer, ihi::Integer, s::AbstractVector{Int64}, a::Array{Float64, 3}, q::Array{Float64, 3}, 
        iwork::AbstractVector{Int64}, dwork::AbstractVector{Float64}) -> info::Int64

Reduce the generalized matrix product

          s[1]           s[2]                 s[k]
  A[:,:,1]     * A[:,:,2]     * ... * A[:,:,k]

to upper Hessenberg-triangular form, where A is N-by-N-by-K and S is the signature array with values 1 or -1. The H-th matrix of A is reduced to upper Hessenberg form while the other matrices are triangularized.

If compq = 'U' or compq = 'I', then the orthogonal factors are computed and stored in the array Q so that for s[i] = 1,

                T
    Q[:,:,i](in)   A[:,:,i](in)   Q[:,:,mod(i,k)+1](in)
                                                        T 
=   Q[:,:,i](out)  A[:,:,i](out)  Q[:,:,mod(i,k)+1](out),

and for s[i] = -1,

                         T
    Q[:,:,mod(i,k)+1](in)   A[:,:,i](in)   Q[:,:,i](in)
                                                        T 
=   Q[:,:,mod(i,k)+1](out)  A[:,:,i](out)  Q[:,:,i](out).

A partial generation of the orthogonal factors can be realized via the array qind.

If triu = 'N' only matrices with negative signature are reduced to upper triangular form in the first stage of the algorithm. If triu = 'A' all possible n-1 matrices with negative signature are reduced.

See the SLICOT documentation of MB03VW for details.

mb03bd!(job::AbstractChar, defl::AbstractChar, compq::AbstractChar, qind::AbstractVector{Int64}, k::Integer, n::Integer, h::Integer, 
        ilo::Integer, ihi::Integer, s::AbstractVector{Int64}, a::Array{Float64, 3}, q::Array{Float64, 3}, alphar::AbstractVector{Float64}, 
        alphai::AbstractVector{Float64}, beta::AbstractVector{Float64}, scal::AbstractVector{Int64}, 
        liwork::Integer, ldwork::Integer) -> (info::Int64, iwarn::Int64)

mb03bd!(job::AbstractChar, defl::AbstractChar, compq::AbstractChar, qind::AbstractVector{Int64}, k::Integer, n::Integer, h::Integer, 
        ilo::Integer, ihi::Integer, s::AbstractVector{Int64}, a::Array{Float64, 3}, q::Array{Float64, 3}, alphar::AbstractVector{Float64}, 
        alphai::AbstractVector{Float64}, beta::AbstractVector{Float64}, scal::AbstractVector{Int64}, 
        iwork::AbstractVector{Int64}, dwork::AbstractVector{Float64}) -> (info::Int64, iwarn::Int64)

Find the eigenvalues of the generalized matrix product

          s[1]           s[2]                 s[k]
  A[:,:,1]     * A[:,:,2]     * ... * A[:,:,k]

where A[:,:,h] is upper Hessenberg and A[:,:,i], i <> h, is upper triangular, using a double-shift version of the periodic QZ method. In addition, A may be reduced to periodic Schur form: A[:,:,h] is upper quasi-triangular and all the other factors A[:,:,i] are upper triangular. Optionally, the 2-by-2 triangular matrices corresponding to 2-by-2 diagonal blocks in A[:,:,h] are so reduced that their product is a 2-by-2 diagonal matrix.

If compq = 'U' or compq = 'I', then the orthogonal factors are computed and stored in the array Q so that for s[i] = 1,

                T
    Q[:,:,i](in)   A[:,:,i](in)   Q[:,:,mod(i,k)+1](in)
                                                        T 
=   Q[:,:,i](out)  A[:,:,i](out)  Q[:,:,mod(i,k)+1](out),

and for s[i] = -1,

                         T
    Q[:,:,mod(i,k)+1](in)   A[:,:,i](in)   Q[:,:,i](in)
                                                        T 
=   Q[:,:,mod(i,k)+1](out)  A[:,:,i](out)  Q[:,:,i](out).

A partial generation of the orthogonal factors can be realized via the array qind.

See the SLICOT documentation of MB03BD for details.

mb03kd!(compq::AbstractChar, strong::AbstractChar, k::Integer, nc::Integer, kschur::Integer, n::AbstractVector{Int64}, ni::AbstractVector{Int64}, 
        s::AbstractVector{Int64}, select::AbstractVector{BlasInt}, t::AbstractVector{Float64}, ldt::AbstractVector{Int64}, ixt::AbstractVector{Int64}, 
        q::AbstractVector{Float64}, ldq::AbstractVector{Int64}, ixq::AbstractVector{Int64}, tol::Float64, ldwork::Integer) -> (m::Int64, info::Int64)

Reorder the diagonal blocks of the formal matrix product

 T22_k^s[k] * T22_k-1^s[k-1] * ... * T22_1^s[1],                (1)

of length k, in the generalized periodic Schur form,

          [  T11_i  T12_i  T13_i  ]
    T_i = [    0    T22_i  T23_i  ],    i = 1, ..., k,          (2)
          [    0      0    T33_i  ]

where

• the submatrices T11_i are ni(i+1)-by-ni(i), if s[i] = 1, or ni(i)-by-ni(i+1), if s[i] = -1, and contain dimension-induced infinite eigenvalues,

• the submatrices T22_i are nc-by-nc and contain core eigenvalues, which are generically neither zero nor infinite,

• the submatrices T33_i contain dimension-induced zero eigenvalues,

such that the m selected eigenvalues pointed to by the integer vector select end up in the leading part of the matrix sequence T22_i.

Given that n[i] = n[i+1] for all i where s[i] = -1, the T11_i are void and the first m columns of the updated orthogonal transformation matrix sequence Q_1, ..., Q_k span a periodic deflating subspace corresponding to the same eigenvalues.

If compq = 'U' or compq = 'I', then the orthogonal factors are computed and stored in the array Q so that for s[i] = 1,

           T
    Q_i(in)  T_i(in) Q_(mod(i,k)+1)(in)
                                          T 
=   Q_i(out) T_i(out)  Q_(mod(i,k)+1)(out),

and for s[i] = -1,

                      T
    Q_(mod(i,k)+1)(in)   T_i(in)   Q_i(in)
                                           T 
=   Q_(mod(i,k)+1)(out)  T_i(out)  Q_i(out).

See the SLICOT documentation of MB03KD for details.