void ATL_rherkLN
(
RC3_HERK_T * RTYP,
const int N,
const int K,
const void * ALPHA,
const void * A,
const int LDA,
const void * BETA,
void * C,
const int LDC,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rherkLN performs the following Hermitian rank-k operation
*
* C := alpha * A * conjg( A' ) + beta * C,
*
* where alpha and beta are real scalars, C is an n by n (lower) Hermi-
* tian matrix and A is an n by k matrix.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
if( ( n1 = N - RB ) <= 0 )
{ RTYP->Therk( N, K, ALPHA, A, LDA, BETA, C, LDC ); return; }
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rherkLN( RTYP, n1, K, ALPHA, A, LDA, BETA, C, LDC, RB );
RTYP->Tgemm( n2, n1, K, ALPHA, Mrc3( A, n1, 0, LDA, size ), LDA,
A, LDA, BETA, Mrc3( C, n1, 0, LDC, size ), LDC );
ATL_rherkLN( RTYP, n2, K, ALPHA, Mrc3( A, n1, 0, LDA, size ), LDA,
BETA, Mrc3( C, n1, n1, LDC, size ), LDC, RB );
/*
* End of ATL_rherkLN
*/
}
void ATL_rsyrkUT
(
RC3_SYRK_T * RTYP,
const int N,
const int K,
const void * ALPHA,
const void * A,
const int LDA,
const void * BETA,
void * C,
const int LDC,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rsyrkUT performs the following symmetric rank-k operation
*
* C := alpha * A' * A + beta * C,
*
* where alpha and beta are scalars, C is an n by n (upper) symmetric
* matrix and A is an k by n matrix.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
if( ( n1 = N - RB ) <= 0 )
{ RTYP->Tsyrk( N, K, ALPHA, A, LDA, BETA, C, LDC ); return; }
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rsyrkUT( RTYP, n1, K, ALPHA, A, LDA, BETA, C, LDC, RB );
RTYP->Tgemm( n1, n2, K, ALPHA, A, LDA, Mrc3( A, 0, n1, LDA, size ),
LDA, BETA, Mrc3( C, 0, n1, LDC, size ), LDC );
ATL_rsyrkUT( RTYP, n2, K, ALPHA, Mrc3( A, 0, n1, LDA, size ), LDA,
BETA, Mrc3( C, n1, n1, LDC, size ), LDC, RB );
/*
* End of ATL_rsyrkUT
*/
}
void ATL_rtrmmRLC
(
RC3_TRMM_T * RTYP,
const int M,
const int N,
const void * ALPHA,
const void * A,
const int LDA,
void * B,
const int LDB,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rtrmmRLC performs the following matrix-matrix operation
*
* B := alpha * B * conjg( A' ),
*
* where alpha is a scalar, B is an m by n matrix, A is a unit, or non-
* unit, lower triangular matrix.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
if( ( n1 = N - RB ) <= 0 )
{ RTYP->Ttrmm( M, N, ALPHA, A, LDA, B, LDB ); return; }
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rtrmmRLC( RTYP, M, n2, ALPHA, Mrc3( A, n1, n1, LDA, size ),
LDA, Mrc3( B, 0, n1, LDB, size ), LDB, RB );
RTYP->Tgemm( M, n2, n1, ALPHA, B, LDB, Mrc3( A, n1, 0, LDA, size ),
LDA, RTYP->one, Mrc3( B, 0, n1, LDB, size ), LDB );
ATL_rtrmmRLC( RTYP, M, n1, ALPHA, A, LDA, B, LDB, RB );
/*
* End of ATL_rtrmmRLC
*/
}
void ATL_rtrsmLUT
(
RC3_TRSM_T * RTYP,
const int M,
const int N,
const void * ALPHA,
const void * A,
const int LDA,
void * B,
const int LDB,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rtrsmLUT solves the matrix equation
*
* A' * X = alpha * B,
*
* where alpha is a scalar, X and B are m by n matrices, A is a unit, or
* non-unit, upper triangular matrix. The matrix X is overwritten on B.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int m1, m2;
/* ..
* .. Executable Statements ..
*
*/
if( ( m1 = M - RB ) <= 0 )
{ RTYP->Ttrsm( M, N, ALPHA, A, LDA, B, LDB ); return; }
m2 = M - ( m1 = RB + ( m1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rtrsmLUT( RTYP, m1, N, ALPHA, A, LDA, B, LDB, RB );
RTYP->Tgemm( m2, N, m1, RTYP->negone, Mrc3( A, 0, m1, LDA, size ),
LDA, B, LDB, ALPHA, Mrc3( B, m1, 0, LDB, size ), LDB );
ATL_rtrsmLUT( RTYP, m2, N, RTYP->one, Mrc3( A, m1, m1, LDA, size ),
LDA, Mrc3( B, m1, 0, LDB, size ), LDB, RB );
/*
* End of ATL_rtrsmLUT
*/
}
void ATL_rtrsmRLT
(
RC3_TRSM_T * RTYP,
const int M,
const int N,
const void * ALPHA,
const void * A,
const int LDA,
void * B,
const int LDB,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rtrsmRLT solves the matrix equation
*
* X * A' = alpha * B,
*
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
if( ( n1 = N - RB ) <= 0 )
{ RTYP->Ttrsm( M, N, ALPHA, A, LDA, B, LDB ); return; }
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rtrsmRLT( RTYP, M, n1, ALPHA, A, LDA, B, LDB, RB );
RTYP->Tgemm( M, n2, n1, RTYP->negone, B, LDB, Mrc3( A, n1, 0, LDA,
size ), LDA, ALPHA, Mrc3( B, 0, n1, LDB, size ), LDB );
ATL_rtrsmRLT( RTYP, M, n2, RTYP->one, Mrc3( A, n1, n1, LDA, size ),
LDA, Mrc3( B, 0, n1, LDB, size ), LDB, RB );
/*
* End of ATL_rtrsmRLT
*/
}
void ATL_rtrsmRLN
(
RC3_TRSM_T * RTYP,
const int M,
const int N,
const void * ALPHA,
const void * A,
const int LDA,
void * B,
const int LDB,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rtrsmRLN solves the matrix equation
*
* X * A = alpha * B,
*
* where alpha is a scalar, X and B are m by n matrices, A is a unit, or
* non-unit, lower triangular matrix. The matrix X is overwritten on B.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
if( ( n1 = N - RB ) <= 0 )
{ RTYP->Ttrsm( M, N, ALPHA, A, LDA, B, LDB ); return; }
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rtrsmRLN( RTYP, M, n2, ALPHA, Mrc3( A, n1, n1, LDA, size ),
LDA, Mrc3( B, 0, n1, LDB, size ), LDB, RB );
RTYP->Tgemm( M, n1, n2, RTYP->negone, Mrc3( B, 0, n1, LDB, size ),
LDB, Mrc3( A, n1, 0, LDA, size ), LDA, ALPHA, B, LDB );
ATL_rtrsmRLN( RTYP, M, n1, RTYP->one, A, LDA, B, LDB, RB );
/*
* End of ATL_rtrsmRLN
*/
}
void ATL_rhemmLL
(
RC3_HEMM_T * RTYP,
const int M,
const int N,
const void * ALPHA,
const void * A,
const int LDA,
const void * B,
const int LDB,
const void * BETA,
void * C,
const int LDC,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rhemmLL performs the following matrix-matrix operation
*
* C := alpha * A * B + beta * C,
*
* where alpha and beta are scalars, A is a (lower) Hermitian matrix and
* B and C are m by n matrices.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int m1, m2;
/* ..
* .. Executable Statements ..
*
*/
if( ( m1 = M - RB ) <= 0 )
{ RTYP->Themm( M, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC ); return; }
m2 = M - ( m1 = RB + ( m1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rhemmLL( RTYP, m1, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC, RB );
RTYP->TgemmNN( m2, N, m1, ALPHA, Mrc3( A, m1, 0, LDA, size ), LDA, B,
LDB, BETA, Mrc3( C, m1, 0, LDC, size ), LDC );
RTYP->Tgemm( m1, N, m2, ALPHA, Mrc3( A, m1, 0, LDA, size ), LDA,
Mrc3( B, m1, 0, LDB, size ), LDB, RTYP->one, C, LDC );
ATL_rhemmLL( RTYP, m2, N, ALPHA, Mrc3( A, m1, m1, LDA, size ), LDA,
Mrc3( B, m1, 0, LDB, size ), LDB, RTYP->one, Mrc3( C,
m1, 0, LDC, size ), LDC, RB );
/*
* End of ATL_rhemmLL
*/
}
void ATL_rsymmRU
(
RC3_SYMM_T * RTYP,
const int M,
const int N,
const void * ALPHA,
const void * A,
const int LDA,
const void * B,
const int LDB,
const void * BETA,
void * C,
const int LDC,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rsymmRU performs the following matrix-matrix operation
*
* C := alpha * B * A + beta * C,
*
* where alpha and beta are scalars, A is a (upper) symmetric matrix and
* B and C are m by n matrices.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
if( ( n1 = N - RB ) <= 0 )
{ RTYP->Tsymm( M, N, ALPHA, A, LDA, B, LDB, BETA, C, LDC ); return; }
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rsymmRU( RTYP, M, n1, ALPHA, A, LDA, B, LDB, BETA, C, LDC, RB );
RTYP->TgemmNN( M, n2, n1, ALPHA, B, LDB, Mrc3( A, 0, n1, LDA, size ),
LDA, BETA, Mrc3( C, 0, n1, LDC, size ), LDC );
RTYP->Tgemm( M, n1, n2, ALPHA, Mrc3( B, 0, n1, LDB, size ), LDB,
Mrc3( A, 0, n1, LDA, size ), LDA, RTYP->one, C, LDC );
ATL_rsymmRU( RTYP, M, n2, ALPHA, Mrc3( A, n1, n1, LDA, size ), LDA,
Mrc3( B, 0, n1, LDB, size ), LDB, RTYP->one, Mrc3( C,
0, n1, LDC, size ), LDC, RB );
/*
* End of ATL_rsymmRU
*/
}
void ATL_rsyr2kUN
(
RC3_SYR2K_T * RTYP,
const int N,
const int K,
const void * ALPHA,
const void * A,
const int LDA,
const void * B,
const int LDB,
const void * BETA,
void * C,
const int LDC,
const int RB
)
{
/*
* Purpose
* =======
*
* ATL_rsyr2kUN performs the following symmetric rank-2k operation
*
* C := alpha * A * B' + alpha * B * A' + beta * C,
*
* where alpha and beta are scalars, C is an n by n (upper) symmetric
* matrix and A and B are n by k matrices.
*
* This is a type-less recursive version of the algorithm.
*
* ---------------------------------------------------------------------
*/
/*
* .. Local Variables ..
*/
size_t size;
int n1, n2;
/* ..
* .. Executable Statements ..
*
*/
#ifndef SYR2K_REC
if( !RTYP->Tsyr2k( N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC ) ) return;
#endif
if( ( n1 = N - RB ) <= 0 )
{
ATL_assert( RTYP->Tsyr2k( N, K, ALPHA, A, LDA, B, LDB, BETA,
C, LDC ) == 0 );
return;
}
n2 = N - ( n1 = RB + ( n1 / ( RB << 1 ) ) * RB ); size = RTYP->size;
ATL_rsyr2kUN( RTYP, n1, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC, RB );
RTYP->Tgemm( n1, n2, K, ALPHA, A, LDA, Mrc3( B, n1, 0, LDB, size ),
LDB, BETA, Mrc3( C, 0, n1, LDC, size ), LDC );
RTYP->Tgemm( n1, n2, K, ALPHA, B, LDB, Mrc3( A, n1, 0, LDA, size ),
LDA, RTYP->one, Mrc3( C, 0, n1, LDC, size ), LDC );
ATL_rsyr2kUN( RTYP, n2, K, ALPHA, Mrc3( A, n1, 0, LDA, size ), LDA,
Mrc3( B, n1, 0, LDB, size ), LDB, BETA, Mrc3( C, n1,
n1, LDC, size ), LDC, RB );
/*
* End of ATL_rsyr2kUN
*/
}
