tgsyl#

stgsyl

Functions

void stgsyl(
    const char*          trans,
    const INT            ijob,
    const INT            m,
    const INT            n,
    const f32*  restrict A,
    const INT            lda,
    const f32*  restrict B,
    const INT            ldb,
          f32*  restrict C,
    const INT            ldc,
    const f32*  restrict D,
    const INT            ldd,
    const f32*  restrict E,
    const INT            lde,
          f32*  restrict F,
    const INT            ldf,
          f32*           scale,
          f32*           dif,
          f32*  restrict work,
    const INT            lwork,
          INT*  restrict iwork,
          INT*           info
);

void stgsyl(const char *trans, const INT ijob, const INT m, const INT n, const f32 *restrict A, const INT lda, const f32 *restrict B, const INT ldb, f32 *restrict C, const INT ldc, const f32 *restrict D, const INT ldd, const f32 *restrict E, const INT lde, f32 *restrict F, const INT ldf, f32 *scale, f32 *dif, f32 *restrict work, const INT lwork, INT *restrict iwork, INT *info)#

STGSYL solves the generalized Sylvester equation:

        A * R - L * B = scale * C                 (1)
        D * R - L * E = scale * F

where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular.

The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow.

In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as

       Z = [ kron(In, A)  -kron(B**T, Im) ]         (2)
           [ kron(In, D)  -kron(E**T, Im) ].

Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y.

If TRANS = ‘T’, STGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in

        A**T * R + D**T * L = scale * C           (3)
        R * B**T + L * E**T = scale * -F

This case (TRANS = ‘T’) is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using SLACON.

If IJOB >= 1, STGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information.

This is a level 3 BLAS algorithm.

Parameters

in

trans

‘N’: solve the generalized Sylvester equation (1). ‘T’: solve the ‘transposed’ system (3).

in

ijob

Specifies what kind of functionality to be performed. = 0: solve (1) only. = 1: The functionality of 0 and 3. = 2: The functionality of 0 and 4. = 3: Only an estimate of Dif[(A,D), (B,E)] is computed. (look ahead strategy IJOB = 1 is used). = 4: Only an estimate of Dif[(A,D), (B,E)] is computed. ( SGECON on sub-systems is used ). Not referenced if TRANS = ‘T’.

in

m

The order of the matrices A and D, and the row dimension of the matrices C, F, R and L.

in

n

The order of the matrices B and E, and the column dimension of the matrices C, F, R and L.

in

A

The upper quasi triangular matrix A. Array of dimension (lda, m).

in

lda

The leading dimension of the array A. lda >= max(1, m).

in

B

The upper quasi triangular matrix B. Array of dimension (ldb, n).

in

ldb

The leading dimension of the array B. ldb >= max(1, n).

inout

C

On entry, C contains the right-hand-side of the first matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, C has been overwritten by the solution R. If IJOB = 3 or 4 and TRANS = ‘N’, C holds R, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldc, n).

in

ldc

The leading dimension of the array C. ldc >= max(1, m).

in

D

The upper triangular matrix D. Array of dimension (ldd, m).

in

ldd

The leading dimension of the array D. ldd >= max(1, m).

in

E

The upper triangular matrix E. Array of dimension (lde, n).

in

lde

The leading dimension of the array E. lde >= max(1, n).

inout

F

On entry, F contains the right-hand-side of the second matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, F has been overwritten by the solution L. If IJOB = 3 or 4 and TRANS = ‘N’, F holds L, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldf, n).

in

ldf

The leading dimension of the array F. ldf >= max(1, m).

out

scale

On exit SCALE is the scaling factor in (1) or (3). If 0 < SCALE < 1, C and F hold the solutions R and L, resp., to a slightly perturbed system but the input matrices A, B, D and E have not been changed. If SCALE = 0, C and F hold the solutions R and L, respectively, to the homogeneous system with C = F = 0. Normally, SCALE = 1.

out

dif

On exit DIF is the reciprocal of a lower bound of the reciprocal of the Dif-function, i.e. DIF is an upper bound of Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2). IF IJOB = 0 or TRANS = ‘T’, DIF is not touched.

out

work

Array of dimension (max(1, lwork)). On exit, if INFO = 0, work[0] returns the optimal lwork.

in

lwork

The dimension of the array work. lwork >= 1. If IJOB = 1 or 2 and TRANS = ‘N’, lwork >= max(1,2*m*n). If lwork = -1, then a workspace query is assumed; the routine only calculates the optimal size of the work array, returns this value as the first entry of the work array, and no error message related to lwork is issued by XERBLA.

out

iwork

Integer array of dimension (m+n+6).

out

info

= 0: successful exit
< 0: If info = -i, the i-th argument had an illegal value.
> 0: (A, D) and (B, E) have common or close eigenvalues.

dtgsyl

Functions

void dtgsyl(
    const char*          trans,
    const INT            ijob,
    const INT            m,
    const INT            n,
    const f64*  restrict A,
    const INT            lda,
    const f64*  restrict B,
    const INT            ldb,
          f64*  restrict C,
    const INT            ldc,
    const f64*  restrict D,
    const INT            ldd,
    const f64*  restrict E,
    const INT            lde,
          f64*  restrict F,
    const INT            ldf,
          f64*           scale,
          f64*           dif,
          f64*  restrict work,
    const INT            lwork,
          INT*  restrict iwork,
          INT*           info
);

void dtgsyl(const char *trans, const INT ijob, const INT m, const INT n, const f64 *restrict A, const INT lda, const f64 *restrict B, const INT ldb, f64 *restrict C, const INT ldc, const f64 *restrict D, const INT ldd, const f64 *restrict E, const INT lde, f64 *restrict F, const INT ldf, f64 *scale, f64 *dif, f64 *restrict work, const INT lwork, INT *restrict iwork, INT *info)#

DTGSYL solves the generalized Sylvester equation:

        A * R - L * B = scale * C                 (1)
        D * R - L * E = scale * F

where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with real entries. (A, D) and (B, E) must be in generalized (real) Schur canonical form, i.e. A, B are upper quasi triangular and D, E are upper triangular.

The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow.

In matrix notation (1) is equivalent to solve Zx = scale b, where Z is defined as

       Z = [ kron(In, A)  -kron(B**T, Im) ]         (2)
           [ kron(In, D)  -kron(E**T, Im) ].

Here Ik is the identity matrix of size k and X**T is the transpose of X. kron(X, Y) is the Kronecker product between the matrices X and Y.

If TRANS = ‘T’, DTGSYL solves the transposed system Z**T*y = scale*b, which is equivalent to solve for R and L in

        A**T * R + D**T * L = scale * C           (3)
        R * B**T + L * E**T = scale * -F

This case (TRANS = ‘T’) is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using DLACON.

If IJOB >= 1, DTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z. See [1-2] for more information.

This is a level 3 BLAS algorithm.

Parameters

in

trans

‘N’: solve the generalized Sylvester equation (1). ‘T’: solve the ‘transposed’ system (3).

in

ijob

Specifies what kind of functionality to be performed. = 0: solve (1) only. = 1: The functionality of 0 and 3. = 2: The functionality of 0 and 4. = 3: Only an estimate of Dif[(A,D), (B,E)] is computed. (look ahead strategy IJOB = 1 is used). = 4: Only an estimate of Dif[(A,D), (B,E)] is computed. ( DGECON on sub-systems is used ). Not referenced if TRANS = ‘T’.

in

m

The order of the matrices A and D, and the row dimension of the matrices C, F, R and L.

in

n

The order of the matrices B and E, and the column dimension of the matrices C, F, R and L.

in

A

The upper quasi triangular matrix A. Array of dimension (lda, m).

in

lda

The leading dimension of the array A. lda >= max(1, m).

in

B

The upper quasi triangular matrix B. Array of dimension (ldb, n).

in

ldb

The leading dimension of the array B. ldb >= max(1, n).

inout

C

On entry, C contains the right-hand-side of the first matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, C has been overwritten by the solution R. If IJOB = 3 or 4 and TRANS = ‘N’, C holds R, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldc, n).

in

ldc

The leading dimension of the array C. ldc >= max(1, m).

in

D

The upper triangular matrix D. Array of dimension (ldd, m).

in

ldd

The leading dimension of the array D. ldd >= max(1, m).

in

E

The upper triangular matrix E. Array of dimension (lde, n).

in

lde

The leading dimension of the array E. lde >= max(1, n).

inout

F

On entry, F contains the right-hand-side of the second matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, F has been overwritten by the solution L. If IJOB = 3 or 4 and TRANS = ‘N’, F holds L, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldf, n).

in

ldf

The leading dimension of the array F. ldf >= max(1, m).

out

scale

On exit SCALE is the scaling factor in (1) or (3). If 0 < SCALE < 1, C and F hold the solutions R and L, resp., to a slightly perturbed system but the input matrices A, B, D and E have not been changed. If SCALE = 0, C and F hold the solutions R and L, respectively, to the homogeneous system with C = F = 0. Normally, SCALE = 1.

out

dif

On exit DIF is the reciprocal of a lower bound of the reciprocal of the Dif-function, i.e. DIF is an upper bound of Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2). IF IJOB = 0 or TRANS = ‘T’, DIF is not touched.

out

work

Array of dimension (max(1, lwork)). On exit, if INFO = 0, work[0] returns the optimal lwork.

in

lwork

The dimension of the array work. lwork >= 1. If IJOB = 1 or 2 and TRANS = ‘N’, lwork >= max(1,2*m*n). If lwork = -1, then a workspace query is assumed; the routine only calculates the optimal size of the work array, returns this value as the first entry of the work array, and no error message related to lwork is issued by XERBLA.

out

iwork

Integer array of dimension (m+n+6).

out

info

= 0: successful exit
< 0: If info = -i, the i-th argument had an illegal value.
> 0: (A, D) and (B, E) have common or close eigenvalues.

ctgsyl

Functions

void ctgsyl(
    const char* trans,
    const INT   ijob,
    const INT   m,
    const INT   n,
    const c64*  A,
    const INT   lda,
    const c64*  B,
    const INT   ldb,
          c64*  C,
    const INT   ldc,
    const c64*  D,
    const INT   ldd,
    const c64*  E,
    const INT   lde,
          c64*  F,
    const INT   ldf,
          f32*  scale,
          f32*  dif,
          c64*  work,
    const INT   lwork,
          INT*  iwork,
          INT*  info
);

void ctgsyl(const char *trans, const INT ijob, const INT m, const INT n, const c64 *A, const INT lda, const c64 *B, const INT ldb, c64 *C, const INT ldc, const c64 *D, const INT ldd, const c64 *E, const INT lde, c64 *F, const INT ldf, f32 *scale, f32 *dif, c64 *work, const INT lwork, INT *iwork, INT *info)#

CTGSYL solves the generalized Sylvester equation:

        A * R - L * B = scale * C            (1)
        D * R - L * E = scale * F

where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form).

The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow.

In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as

   Z = [ kron(In, A)  -kron(B**H, Im) ]        (2)
       [ kron(In, D)  -kron(E**H, Im) ],

Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y.

If TRANS = ‘C’, y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in

        A**H * R + D**H * L = scale * C           (3)
        R * B**H + L * E**H = scale * -F

This case (TRANS = ‘C’) is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using CLACON.

If IJOB >= 1, CTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z.

This is a level-3 BLAS algorithm.

Parameters

in

trans

‘N’: solve the generalized Sylvester equation (1). ‘C’: solve the conjugate transposed system (3).

in

ijob

Specifies what kind of functionality to be performed. = 0: solve (1) only. = 1: The functionality of 0 and 3. = 2: The functionality of 0 and 4. = 3: Only an estimate of Dif[(A,D), (B,E)] is computed. (look ahead strategy is used). = 4: Only an estimate of Dif[(A,D), (B,E)] is computed. (CGECON on sub-systems is used). Not referenced if TRANS = ‘C’.

in

m

The order of the matrices A and D, and the row dimension of the matrices C, F, R and L.

in

n

The order of the matrices B and E, and the column dimension of the matrices C, F, R and L.

in

A

The upper triangular matrix A. Array of dimension (lda, m).

in

lda

The leading dimension of the array A. lda >= max(1, m).

in

B

The upper triangular matrix B. Array of dimension (ldb, n).

in

ldb

The leading dimension of the array B. ldb >= max(1, n).

inout

C

On entry, C contains the right-hand-side of the first matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, C has been overwritten by the solution R. If IJOB = 3 or 4 and TRANS = ‘N’, C holds R, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldc, n).

in

ldc

The leading dimension of the array C. ldc >= max(1, m).

in

D

The upper triangular matrix D. Array of dimension (ldd, m).

in

ldd

The leading dimension of the array D. ldd >= max(1, m).

in

E

The upper triangular matrix E. Array of dimension (lde, n).

in

lde

The leading dimension of the array E. lde >= max(1, n).

inout

F

On entry, F contains the right-hand-side of the second matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, F has been overwritten by the solution L. If IJOB = 3 or 4 and TRANS = ‘N’, F holds L, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldf, n).

in

ldf

The leading dimension of the array F. ldf >= max(1, m).

out

scale

On exit SCALE is the scaling factor in (1) or (3). If 0 < SCALE < 1, C and F hold the solutions R and L, resp., to a slightly perturbed system but the input matrices A, B, D and E have not been changed. If SCALE = 0, C and F hold the solutions R and L, respectively, to the homogeneous system with C = F = 0. Normally, SCALE = 1.

out

dif

On exit DIF is the reciprocal of a lower bound of the reciprocal of the Dif-function, i.e. DIF is an upper bound of Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2). IF IJOB = 0 or TRANS = ‘C’, DIF is not referenced.

out

work

Array of dimension (max(1, lwork)). On exit, if INFO = 0, work[0] returns the optimal lwork.

in

lwork

The dimension of the array work. lwork >= 1. If IJOB = 1 or 2 and TRANS = ‘N’, lwork >= max(1,2*m*n). If lwork = -1, then a workspace query is assumed; the routine only calculates the optimal size of the work array, returns this value as the first entry of the work array, and no error message related to lwork is issued by XERBLA.

out

iwork

Integer array of dimension (m+n+2).

out

info

= 0: successful exit
< 0: If info = -i, the i-th argument had an illegal value.
> 0: (A, D) and (B, E) have common or very close eigenvalues.

ztgsyl

Functions

void ztgsyl(
    const char* trans,
    const INT   ijob,
    const INT   m,
    const INT   n,
    const c128* A,
    const INT   lda,
    const c128* B,
    const INT   ldb,
          c128* C,
    const INT   ldc,
    const c128* D,
    const INT   ldd,
    const c128* E,
    const INT   lde,
          c128* F,
    const INT   ldf,
          f64*  scale,
          f64*  dif,
          c128* work,
    const INT   lwork,
          INT*  iwork,
          INT*  info
);

void ztgsyl(const char *trans, const INT ijob, const INT m, const INT n, const c128 *A, const INT lda, const c128 *B, const INT ldb, c128 *C, const INT ldc, const c128 *D, const INT ldd, const c128 *E, const INT lde, c128 *F, const INT ldf, f64 *scale, f64 *dif, c128 *work, const INT lwork, INT *iwork, INT *info)#

ZTGSYL solves the generalized Sylvester equation:

        A * R - L * B = scale * C            (1)
        D * R - L * E = scale * F

where R and L are unknown m-by-n matrices, (A, D), (B, E) and (C, F) are given matrix pairs of size m-by-m, n-by-n and m-by-n, respectively, with complex entries. A, B, D and E are upper triangular (i.e., (A,D) and (B,E) in generalized Schur form).

The solution (R, L) overwrites (C, F). 0 <= SCALE <= 1 is an output scaling factor chosen to avoid overflow.

In matrix notation (1) is equivalent to solve Zx = scale*b, where Z is defined as

   Z = [ kron(In, A)  -kron(B**H, Im) ]        (2)
       [ kron(In, D)  -kron(E**H, Im) ],

Here Ix is the identity matrix of size x and X**H is the conjugate transpose of X. Kron(X, Y) is the Kronecker product between the matrices X and Y.

If TRANS = ‘C’, y in the conjugate transposed system Z**H *y = scale*b is solved for, which is equivalent to solve for R and L in

        A**H * R + D**H * L = scale * C           (3)
        R * B**H + L * E**H = scale * -F

This case (TRANS = ‘C’) is used to compute an one-norm-based estimate of Dif[(A,D), (B,E)], the separation between the matrix pairs (A,D) and (B,E), using ZLACON.

If IJOB >= 1, ZTGSYL computes a Frobenius norm-based estimate of Dif[(A,D),(B,E)]. That is, the reciprocal of a lower bound on the reciprocal of the smallest singular value of Z.

This is a level-3 BLAS algorithm.

Parameters

in

trans

‘N’: solve the generalized Sylvester equation (1). ‘C’: solve the conjugate transposed system (3).

in

ijob

Specifies what kind of functionality to be performed. = 0: solve (1) only. = 1: The functionality of 0 and 3. = 2: The functionality of 0 and 4. = 3: Only an estimate of Dif[(A,D), (B,E)] is computed. (look ahead strategy is used). = 4: Only an estimate of Dif[(A,D), (B,E)] is computed. (ZGECON on sub-systems is used). Not referenced if TRANS = ‘C’.

in

m

The order of the matrices A and D, and the row dimension of the matrices C, F, R and L.

in

n

The order of the matrices B and E, and the column dimension of the matrices C, F, R and L.

in

A

The upper triangular matrix A. Array of dimension (lda, m).

in

lda

The leading dimension of the array A. lda >= max(1, m).

in

B

The upper triangular matrix B. Array of dimension (ldb, n).

in

ldb

The leading dimension of the array B. ldb >= max(1, n).

inout

C

On entry, C contains the right-hand-side of the first matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, C has been overwritten by the solution R. If IJOB = 3 or 4 and TRANS = ‘N’, C holds R, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldc, n).

in

ldc

The leading dimension of the array C. ldc >= max(1, m).

in

D

The upper triangular matrix D. Array of dimension (ldd, m).

in

ldd

The leading dimension of the array D. ldd >= max(1, m).

in

E

The upper triangular matrix E. Array of dimension (lde, n).

in

lde

The leading dimension of the array E. lde >= max(1, n).

inout

F

On entry, F contains the right-hand-side of the second matrix equation in (1) or (3). On exit, if IJOB = 0, 1 or 2, F has been overwritten by the solution L. If IJOB = 3 or 4 and TRANS = ‘N’, F holds L, the solution achieved during the computation of the Dif-estimate. Array of dimension (ldf, n).

in

ldf

The leading dimension of the array F. ldf >= max(1, m).

out

scale

On exit SCALE is the scaling factor in (1) or (3). If 0 < SCALE < 1, C and F hold the solutions R and L, resp., to a slightly perturbed system but the input matrices A, B, D and E have not been changed. If SCALE = 0, C and F hold the solutions R and L, respectively, to the homogeneous system with C = F = 0. Normally, SCALE = 1.

out

dif

On exit DIF is the reciprocal of a lower bound of the reciprocal of the Dif-function, i.e. DIF is an upper bound of Dif[(A,D), (B,E)] = sigma_min(Z), where Z as in (2). IF IJOB = 0 or TRANS = ‘C’, DIF is not referenced.

out

work

Array of dimension (max(1, lwork)). On exit, if INFO = 0, work[0] returns the optimal lwork.

in

lwork

The dimension of the array work. lwork >= 1. If IJOB = 1 or 2 and TRANS = ‘N’, lwork >= max(1,2*m*n). If lwork = -1, then a workspace query is assumed; the routine only calculates the optimal size of the work array, returns this value as the first entry of the work array, and no error message related to lwork is issued by XERBLA.

out

iwork

Integer array of dimension (m+n+2).

out

info

= 0: successful exit
< 0: If info = -i, the i-th argument had an illegal value.
> 0: (A, D) and (B, E) have common or very close eigenvalues.

tgsyl#

This Page