ddss_dgemm.c File Reference

LASs-DDSs ddss_dgemm routine. More...

#include "../include/lass.h"

Include dependency graph for ddss_dgemm.c:

Go to the source code of this file.

Functions
int	ddss_dgemm (enum DDSS_TRANS TRANS_A, enum DDSS_TRANS TRANS_B, int M, int N, int K, double ALPHA, double *A, int LDA, double *B, int LDB, double BETA, double *C, int LDC)

Detailed Description

LASs-DDSs ddss_dgemm routine.

LASs-DDSs is a software package provided by: Barcelona Supercomputing Center - Centro Nacional de Supercomputacion

Author

Pedro Valero-Lara pedro.nosp@m..val.nosp@m.ero@b.nosp@m.sc.e.nosp@m.s

Date

2017-01-02

Definition in file ddss_dgemm.c.

Function Documentation

int ddss_dgemm	(	enum DDSS_TRANS	TRANS_A,
		enum DDSS_TRANS	TRANS_B,
		int	M,
		int	N,
		int	K,
		double	ALPHA,
		double *	A,
		int	LDA,
		double *	B,
		int	LDB,
		double	BETA,
		double *	C,
		int	LDC
	)

Performs the matrix-matrix operation:

C = ALPHA * op( A ) * op( B ) + BETA * C

where op( X ) is one of:

op( X ) = X      or
op( X ) = X**T 

ALPHA and BETA are scalars, and A, B and C are matrices, with op( A ) an M by K matrix, op( B ) a K by N matrix and C an M by N matrix.

Parameters

[in]	TRANS_A	enum DDSS_TRANS. TRANS_A specifies the form of op( A ) to be used in the matrix multiplication as follows: NoTrans: op( A ) = A. Trans: op( A ) = A**T.
[in]	TRANS_B	enum DDSS_TRANS. TRANS_B specifies the form of op( B ) to be used in the matrix multiplication as follows: NoTrans: op( B ) = B. Trans: op( B ) = B**T.
[in]	M	int. M specifies the number of rows of the matrix A and the number of rows of the matrix C. M must be greater than zero.
[in]	N	int. N specifies the number of columns of the matrix B and the number of columns of the matrix C. N must be greater than zero.
[in]	K	int. K specifies the number of columns of the matrix A and the number of rows of the matrix B. K must be greater than zero.
[in]	ALPHA	double.
[in]	A	double *. A is a pointer to a matrix of dimension Ma ( rows ) by Ka ( columns ), where Ma is M and Ka is K when TRANS_A = NoTrans, and Ma is K and Ka is M otherwise.
[in]	LDA	int. LDA specifies the number of columns of A ( row-major order ). When TRANS_A = NoTrans then LDA must be at least max( 1, K ), otherwise LDA must be at least max( 1, M ).
[in]	B	double *. B is a pointer to a matrix of dimension Kb ( rows ) by Nb ( columns ), where Kb is K and Nb is N when TRANS_B = NoTrans, and Kb is N and Nb is K otherwise.
[in]	LDB	int. LDB specifies the number of columns of B ( row-major order ). When TRANS_B = NoTrans then LDB must be at least max( 1, N ), otherwise LDB must be at least max( 1, K ).
[in]	BETA	double.
[in,out]	C	double *. C is a pointer to a matrix of dimension M by N. On exit, C is overwritten by the M by N matrix ( ALPHA*op( A )*op( B ) + BETA*C ).
[in]	LDC	int. LDC specifies the number of columns of C ( row-major order ). LDC must be at least max( 1, N ).

Return values

Success	successful exit
NoSuccess	unsuccessful exit

See also

kdgemm

Definition at line 128 of file ddss_dgemm.c.

References kdgemm().

{
    
    // Local variables
    int An, Bn;  
    
    // Argument checking
    if ( ( TRANS_A != NoTrans ) && ( TRANS_A != Trans ) )
    {
        fprintf( stderr, "Illegal value of TRANS_A, in ddss_dgemm code\n" );
        return NoSuccess;
    }

    if ( ( TRANS_B != NoTrans ) && ( TRANS_B != Trans ) )
    {
        fprintf( stderr, "Illegal value of TRANS_B, in ddss_dgemm code\n" );
        return NoSuccess;
    }

    if ( M < 0 )
    {
        fprintf( stderr, "Illegal value of M, in ddss_dgemm code\n" );
        return NoSuccess;
    }
    
    if ( N < 0 )
    {
        fprintf( stderr, "Illegal value of N, in ddss_dgemm code\n" );
        return NoSuccess;
    }
    
    if ( K < 0 )
    {
        fprintf( stderr, "Illegal value of K, in ddss_dgemm code\n" );
        return NoSuccess;
    }
    
    if ( TRANS_A == NoTrans )
    {
        An = K;
    }   
    else
    {
        An = M;
    }

    if ( LDA < MAX( 1, An ) )
    {
        fprintf( stderr, "Illegal value of LDA, in ddss_dgemm code\n" );    
        return NoSuccess;
    }

    if ( TRANS_B == NoTrans )
    {
        Bn = N;
    }   
    else
    {
        Bn = K;
    }

    if ( LDB < MAX( 1, Bn ) )
    {
        fprintf( stderr, "Illegal value of LDB, in ddss_dgemm code\n" );    
        return NoSuccess;
    }

    if ( LDC < MAX( 1, N ) )
    {
        fprintf( stderr, "Illegal value of LDC, in ddss_dgemm code\n" );    
        return NoSuccess;
    }

    // Quick return
    if ( M == 0 || N == 0 || ( ( ALPHA == 0.0 || K == 0 ) && BETA == 1.0 ) )
    {
        return Success;
    }   

    return kdgemm( TRANS_A, TRANS_B, M, N, K, 
                    (const double) ALPHA, A, LDA, 
                                          B, LDB, 
                    (const double)  BETA, C, LDC );
    
}