strsm (3p)

Name

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

Synopsis

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

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

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

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




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

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

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

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




C INTERFACE
#include <sunperf.h>

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

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

Description

Oracle Solaris Studio Performance Library                            strsm(3P)



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


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

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

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

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




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

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

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

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




   C INTERFACE
       #include <sunperf.h>

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

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



PURPOSE
       strsm  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'.

       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 ) = 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)
                 REAL             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 one.
                 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)
                 REAL              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 overwrit-
                 ten by the solution matrix  X.


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




                                  7 Nov 2015                         strsm(3P)