gemm< do_trans_A, do_trans_B, use_alpha, use_beta > Class Template Reference
[Gemm]

Wrapper for ATLAS/BLAS dgemm function, using template arguments to control the arguments passed to dgemm. Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes). More...

#include <gemm.hpp>

List of all members.

Static Public Member Functions

template<typename eT >
static void apply_blas_type (Mat< eT > &C, const Mat< eT > &A, const Mat< eT > &B, const eT alpha=eT(1), const eT beta=eT(0))
template<typename eT >
static void apply (Mat< eT > &C, const Mat< eT > &A, const Mat< eT > &B, const eT alpha=eT(1), const eT beta=eT(0))
 immediate multiplication of matrices A and B, storing the result in C
static void apply (Mat< float > &C, const Mat< float > &A, const Mat< float > &B, const float alpha=float(1), const float beta=float(0))
static void apply (Mat< double > &C, const Mat< double > &A, const Mat< double > &B, const double alpha=double(1), const double beta=double(0))
static void apply (Mat< std::complex< float > > &C, const Mat< std::complex< float > > &A, const Mat< std::complex< float > > &B, const std::complex< float > alpha=std::complex< float >(1), const std::complex< float > beta=std::complex< float >(0))
static void apply (Mat< std::complex< double > > &C, const Mat< std::complex< double > > &A, const Mat< std::complex< double > > &B, const std::complex< double > alpha=std::complex< double >(1), const std::complex< double > beta=std::complex< double >(0))


Detailed Description

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
class gemm< do_trans_A, do_trans_B, use_alpha, use_beta >

Wrapper for ATLAS/BLAS dgemm function, using template arguments to control the arguments passed to dgemm. Matrix 'C' is assumed to have been set to the correct size (i.e. taking into account transposes).

Definition at line 398 of file gemm.hpp.


Member Function Documentation

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
template<typename eT >
static void gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply_blas_type ( Mat< eT > &  C,
const Mat< eT > &  A,
const Mat< eT > &  B,
const eT  alpha = eT(1),
const eT  beta = eT(0) 
) [inline, static]

Definition at line 406 of file gemm.hpp.

References gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply(), Mat< eT >::mem, Mat< eT >::memptr(), Mat< eT >::n_cols, Mat< eT >::n_elem, and Mat< eT >::n_rows.

Referenced by gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply().

00407     {
00408     arma_extra_debug_sigprint();
00409     
00410     if( ((A.n_elem <= 64u) && (B.n_elem <= 64u)) )
00411       {
00412       gemm_emul_simple<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
00413       }
00414     else
00415       {
00416       #if defined(ARMA_USE_ATLAS)
00417         {
00418         arma_extra_debug_print("atlas::cblas_gemm()");
00419         
00420         atlas::cblas_gemm<eT>
00421           (
00422           atlas::CblasColMajor,
00423           (do_trans_A) ? atlas::CblasTrans : atlas::CblasNoTrans,
00424           (do_trans_B) ? atlas::CblasTrans : atlas::CblasNoTrans,
00425           C.n_rows,
00426           C.n_cols,
00427           (do_trans_A) ? A.n_rows : A.n_cols,
00428           (use_alpha) ? alpha : eT(1),
00429           A.mem,
00430           (do_trans_A) ? A.n_rows : C.n_rows,
00431           B.mem,
00432           (do_trans_B) ? C.n_cols : ( (do_trans_A) ? A.n_rows : A.n_cols ),
00433           (use_beta) ? beta : eT(0),
00434           C.memptr(),
00435           C.n_rows
00436           );
00437         }
00438       #elif defined(ARMA_USE_BLAS)
00439         {
00440         arma_extra_debug_print("blas::gemm_()");
00441         
00442         const char trans_A = (do_trans_A) ? 'T' : 'N';
00443         const char trans_B = (do_trans_B) ? 'T' : 'N';
00444         
00445         const int m   = C.n_rows;
00446         const int n   = C.n_cols;
00447         const int k   = (do_trans_A) ? A.n_rows : A.n_cols;
00448         
00449         const eT local_alpha = (use_alpha) ? alpha : eT(1);
00450         
00451         const int lda = (do_trans_A) ? k : m;
00452         const int ldb = (do_trans_B) ? n : k;
00453         
00454         const eT local_beta  = (use_beta) ? beta : eT(0);
00455         
00456         arma_extra_debug_print( arma_boost::format("blas::gemm_(): trans_A = %c") % trans_A );
00457         arma_extra_debug_print( arma_boost::format("blas::gemm_(): trans_B = %c") % trans_B );
00458         
00459         blas::gemm_<eT>
00460           (
00461           &trans_A,
00462           &trans_B,
00463           &m,
00464           &n,
00465           &k,
00466           &local_alpha,
00467           A.mem,
00468           &lda,
00469           B.mem,
00470           &ldb,
00471           &local_beta,
00472           C.memptr(),
00473           &m
00474           );
00475         }
00476       #else
00477         {
00478         gemm_emul_cache<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
00479         }
00480       #endif
00481       }
00482     }

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
template<typename eT >
static void gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply ( Mat< eT > &  C,
const Mat< eT > &  A,
const Mat< eT > &  B,
const eT  alpha = eT(1),
const eT  beta = eT(0) 
) [inline, static]

immediate multiplication of matrices A and B, storing the result in C

Definition at line 491 of file gemm.hpp.

References Mat< eT >::n_elem.

Referenced by gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply_blas_type().

00492     {
00493     if( (A.n_elem <= 64u) && (B.n_elem <= 64u) )
00494       {
00495       gemm_emul_simple<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
00496       }
00497     else
00498       {
00499       gemm_emul_cache<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
00500       }
00501     }

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
static void gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply ( Mat< float > &  C,
const Mat< float > &  A,
const Mat< float > &  B,
const float  alpha = float(1),
const float  beta = float(0) 
) [inline, static]

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
static void gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply ( Mat< double > &  C,
const Mat< double > &  A,
const Mat< double > &  B,
const double  alpha = double(1),
const double  beta = double(0) 
) [inline, static]

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
static void gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply ( Mat< std::complex< float > > &  C,
const Mat< std::complex< float > > &  A,
const Mat< std::complex< float > > &  B,
const std::complex< float >  alpha = std::complex<float>(1),
const std::complex< float >  beta = std::complex<float>(0) 
) [inline, static]

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
static void gemm< do_trans_A, do_trans_B, use_alpha, use_beta >::apply ( Mat< std::complex< double > > &  C,
const Mat< std::complex< double > > &  A,
const Mat< std::complex< double > > &  B,
const std::complex< double >  alpha = std::complex<double>(1),
const std::complex< double >  beta = std::complex<double>(0) 
) [inline, static]