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 arma_inline void apply (Mat< float > &C, const Mat< float > &A, const Mat< float > &B, const float alpha=float(1), const float beta=float(0))
static arma_inline void apply (Mat< double > &C, const Mat< double > &A, const Mat< double > &B, const double alpha=double(1), const double beta=double(0))
static arma_inline 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 arma_inline 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 401 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 409 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().

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

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 494 of file gemm.hpp.

References Mat< eT >::n_elem.

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

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

template<const bool do_trans_A = false, const bool do_trans_B = false, const bool use_alpha = false, const bool use_beta = false>
static arma_inline 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 arma_inline 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 arma_inline 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 arma_inline 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]