Static Public Member Functions

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().

    {
    arma_extra_debug_sigprint();
    
    if( ((A.n_elem <= 64u) && (B.n_elem <= 64u)) )
      {
      gemm_emul_simple<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
      }
    else
      {
      #if defined(ARMA_USE_ATLAS)
        {
        arma_extra_debug_print("atlas::cblas_gemm()");
        
        atlas::cblas_gemm<eT>
          (
          atlas::CblasColMajor,
          (do_trans_A) ? atlas::CblasTrans : atlas::CblasNoTrans,
          (do_trans_B) ? atlas::CblasTrans : atlas::CblasNoTrans,
          C.n_rows,
          C.n_cols,
          (do_trans_A) ? A.n_rows : A.n_cols,
          (use_alpha) ? alpha : eT(1),
          A.mem,
          (do_trans_A) ? A.n_rows : C.n_rows,
          B.mem,
          (do_trans_B) ? C.n_cols : ( (do_trans_A) ? A.n_rows : A.n_cols ),
          (use_beta) ? beta : eT(0),
          C.memptr(),
          C.n_rows
          );
        }
      #elif defined(ARMA_USE_BLAS)
        {
        arma_extra_debug_print("blas::gemm_()");
        
        const char trans_A = (do_trans_A) ? 'T' : 'N';
        const char trans_B = (do_trans_B) ? 'T' : 'N';
        
        const int m   = C.n_rows;
        const int n   = C.n_cols;
        const int k   = (do_trans_A) ? A.n_rows : A.n_cols;
        
        const eT local_alpha = (use_alpha) ? alpha : eT(1);
        
        const int lda = (do_trans_A) ? k : m;
        const int ldb = (do_trans_B) ? n : k;
        
        const eT local_beta  = (use_beta) ? beta : eT(0);
        
        arma_extra_debug_print( arma_boost::format("blas::gemm_(): trans_A = %c") % trans_A );
        arma_extra_debug_print( arma_boost::format("blas::gemm_(): trans_B = %c") % trans_B );
        
        blas::gemm_<eT>
          (
          &trans_A,
          &trans_B,
          &m,
          &n,
          &k,
          &local_alpha,
          A.mem,
          &lda,
          B.mem,
          &ldb,
          &local_beta,
          C.memptr(),
          &m
          );
        }
      #else
        {
        gemm_emul_cache<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
        }
      #endif
      }
    }

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().

    {
    if( (A.n_elem <= 64u) && (B.n_elem <= 64u) )
      {
      gemm_emul_simple<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
      }
    else
      {
      gemm_emul_cache<do_trans_A, do_trans_B, use_alpha, use_beta>::apply(C,A,B,alpha,beta);
      }
    }

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]

Definition at line 512 of file gemm.hpp.

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

    {
    gemm<do_trans_A, do_trans_B, use_alpha, use_beta>::apply_blas_type(C,A,B,alpha,beta);
    }

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]

Definition at line 529 of file gemm.hpp.

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

    {
    gemm<do_trans_A, do_trans_B, use_alpha, use_beta>::apply_blas_type(C,A,B,alpha,beta);
    }

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]

Definition at line 546 of file gemm.hpp.

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

    {
    gemm<do_trans_A, do_trans_B, use_alpha, use_beta>::apply_blas_type(C,A,B,alpha,beta);
    }

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]

Definition at line 563 of file gemm.hpp.

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

    {
    gemm<do_trans_A, do_trans_B, use_alpha, use_beta>::apply_blas_type(C,A,B,alpha,beta);
    }