ctrsm (3p)

Name

ctrsm - solve one of the matrix equations op( A )*X = alpha*B, or X*op( A ) = alpha*B

Synopsis

SUBROUTINE CTRSM(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B,
LDB)

CHARACTER*1 SIDE, UPLO, TRANSA, DIAG
COMPLEX ALPHA
COMPLEX A(LDA,*), B(LDB,*)
INTEGER M, N, LDA, LDB

SUBROUTINE CTRSM_64(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B,
LDB)

CHARACTER*1 SIDE, UPLO, TRANSA, DIAG
COMPLEX ALPHA
COMPLEX A(LDA,*), B(LDB,*)
INTEGER*8 M, N, LDA, LDB




F95 INTERFACE
SUBROUTINE TRSM(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA,
B, LDB)

CHARACTER(LEN=1) :: SIDE, UPLO, TRANSA, DIAG
COMPLEX :: ALPHA
COMPLEX, DIMENSION(:,:) :: A, B
INTEGER :: M, N, LDA, LDB

SUBROUTINE TRSM_64(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A,
LDA, B, LDB)

CHARACTER(LEN=1) :: SIDE, UPLO, TRANSA, DIAG
COMPLEX :: ALPHA
COMPLEX, DIMENSION(:,:) :: A, B
INTEGER(8) :: M, N, LDA, LDB




C INTERFACE
#include <sunperf.h>

void ctrsm(char side, char uplo, char transa, char diag, int m, int  n,
complex *alpha, complex *a, int lda, complex *b, int ldb);

void  ctrsm_64(char  side,  char  uplo, char transa, char diag, long m,
long n, complex *alpha, complex *a,  long  lda,  complex  *b,
long ldb);

Description

Oracle Solaris Studio Performance Library                            ctrsm(3P)



NAME
       ctrsm - solve one of the matrix equations op( A )*X = alpha*B, or X*op(
       A ) = alpha*B


SYNOPSIS
       SUBROUTINE CTRSM(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B,
             LDB)

       CHARACTER*1 SIDE, UPLO, TRANSA, DIAG
       COMPLEX ALPHA
       COMPLEX A(LDA,*), B(LDB,*)
       INTEGER M, N, LDA, LDB

       SUBROUTINE CTRSM_64(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA, B,
             LDB)

       CHARACTER*1 SIDE, UPLO, TRANSA, DIAG
       COMPLEX ALPHA
       COMPLEX A(LDA,*), B(LDB,*)
       INTEGER*8 M, N, LDA, LDB




   F95 INTERFACE
       SUBROUTINE TRSM(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A, LDA,
              B, LDB)

       CHARACTER(LEN=1) :: SIDE, UPLO, TRANSA, DIAG
       COMPLEX :: ALPHA
       COMPLEX, DIMENSION(:,:) :: A, B
       INTEGER :: M, N, LDA, LDB

       SUBROUTINE TRSM_64(SIDE, UPLO, TRANSA, DIAG, M, N, ALPHA, A,
              LDA, B, LDB)

       CHARACTER(LEN=1) :: SIDE, UPLO, TRANSA, DIAG
       COMPLEX :: ALPHA
       COMPLEX, DIMENSION(:,:) :: A, B
       INTEGER(8) :: M, N, LDA, LDB




   C INTERFACE
       #include <sunperf.h>

       void ctrsm(char side, char uplo, char transa, char diag, int m, int  n,
                 complex *alpha, complex *a, int lda, complex *b, int ldb);

       void  ctrsm_64(char  side,  char  uplo, char transa, char diag, long m,
                 long n, complex *alpha, complex *a,  long  lda,  complex  *b,
                 long ldb);



PURPOSE
       ctrsm  solves one of the matrix equations op( A )*X = alpha*B, or X*op(
       A ) = alpha*B where alpha is a scalar, X and B are m by n  matrices,  A
       is a unit, or non-unit,  upper or lower triangular matrix  and  op( A )
       is one  of

          op( A ) = A   or   op( A ) = A'   or   op( A ) = conjg( A' ).

       The matrix X is overwritten on B.


ARGUMENTS
       SIDE (input)
                 On entry, SIDE specifies whether op( A ) appears on the  left
                 or right of X as follows:

                 SIDE = 'L' or 'l'   op( A )*X = alpha*B.

                 SIDE = 'R' or 'r'   X*op( A ) = alpha*B.

                 Unchanged on exit.


       UPLO (input)
                 On  entry, UPLO specifies whether the matrix A is an upper or
                 lower triangular matrix as follows:

                 UPLO = 'U' or 'u'   A is an upper triangular matrix.

                 UPLO = 'L' or 'l'   A is a lower triangular matrix.

                 Unchanged on exit.


       TRANSA (input)
                 On entry, TRANSA specifies the form of op( A ) to be used  in
                 the matrix multiplication as follows:

                 TRANSA = 'N' or 'n'   op( A ) = A.

                 TRANSA = 'T' or 't'   op( A ) = A'.

                 TRANSA = 'C' or 'c'   op( A ) = conjg( A' ).

                 Unchanged on exit.


       DIAG (input)
                 On  entry, DIAG specifies whether or not A is unit triangular
                 as follows:

                 DIAG = 'U' or 'u'   A is assumed to be unit triangular.

                 DIAG = 'N' or 'n'   A is not assumed to be unit triangular.

                 Unchanged on exit.


       M (input)
                 On entry, M specifies the number  of  rows  of  B.  M  >=  0.
                 Unchanged on exit.


       N (input)
                 On  entry,  N  specifies the number of columns of B.  N >= 0.
                 Unchanged on exit.


       ALPHA (input)
                 On entry,  ALPHA specifies the scalar  alpha. When  alpha  is
                 zero  then  A is not referenced and  B need not be set before
                 entry.  Unchanged on exit.


       A (input)
                 COMPLEX          array of DIMENSION ( LDA, k ), where k is  m
                 when   SIDE = 'L' or 'l'  and is  n  when  SIDE = 'R' or 'r'.

                 Before entry  with  UPLO = 'U' or 'u',  the  leading  k by  k
                 upper  triangular part of the array  A must contain the upper
                 triangular matrix  and the strictly lower triangular part  of
                 A is not referenced.

                 Before  entry  with  UPLO = 'L' or 'l',  the  leading  k by k
                 lower triangular part of the array  A must contain the  lower
                 triangular  matrix  and the strictly upper triangular part of
                 A is not referenced.

                 Note that when DIAG = 'U' or 'u', the diagonal elements of  A
                 are not referenced either, but are assumed to be unity.

                 Unchanged on exit.


       LDA (input)
                 On  entry, LDA specifies the first dimension of A as declared
                 in the calling (sub) program.  When  SIDE = 'L' or 'l'   then
                 LDA >= max(1,M), when SIDE = 'R' or 'r' then LDA >= max(1,N).
                 Unchanged on exit.


       B (input/output)
                 COMPLEX          array of  DIMENSION  (  LDB,  n  ).   Before
                 entry,  the  leading  M by N part of the array B must contain
                 the right-hand side  matrix B, and on exit is overwritten  by
                 the solution matrix X.


       LDB (input)
                 On  entry, LDB specifies the first dimension of B as declared
                 in the calling subprogram.  LDB >=  max(1,M).   Unchanged  on
                 exit.




                                  7 Nov 2015                         ctrsm(3P)