atlas Namespace Reference

namespace for ATLAS functions (imported from the global namespace) More...


Functions

template<typename eT >
static const eT & tmp_real (const eT &X)
template<typename T >
static const T & tmp_real (const std::complex< T > &X)
template<typename eT >
void cblas_gemv (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const int M, const int N, const eT alpha, const eT *A, const int lda, const eT *X, const int incX, const eT beta, eT *Y, const int incY)
template<typename eT >
void cblas_gemm (const enum CBLAS_ORDER Order, const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_TRANSPOSE TransB, const int M, const int N, const int K, const eT alpha, const eT *A, const int lda, const eT *B, const int ldb, const eT beta, eT *C, const int ldc)
template<typename eT >
int clapack_getrf (const enum CBLAS_ORDER Order, const int M, const int N, eT *A, const int lda, int *ipiv)
template<typename eT >
int clapack_getri (const enum CBLAS_ORDER Order, const int N, eT *A, const int lda, const int *ipiv)


Detailed Description

namespace for ATLAS functions (imported from the global namespace)


Function Documentation

template<typename eT >
static const eT& atlas::tmp_real ( const eT &  X  )  [inline, static]

Definition at line 53 of file atlas_proto.hpp.

Referenced by cblas_gemm(), and cblas_gemv().

00053 { return X; }

template<typename T >
static const T& atlas::tmp_real ( const std::complex< T > &  X  )  [inline, static]

Definition at line 56 of file atlas_proto.hpp.

00056 { return X.real(); }

template<typename eT >
void atlas::cblas_gemv ( const enum CBLAS_ORDER  Order,
const enum CBLAS_TRANSPOSE  TransA,
const int  M,
const int  N,
const eT  alpha,
const eT *  A,
const int  lda,
const eT *  X,
const int  incX,
const eT  beta,
eT *  Y,
const int  incY 
) [inline]

Definition at line 97 of file atlas_proto.hpp.

References tmp_real().

00106     {
00107     arma_type_check<is_supported_blas_type<eT>::value == false>::apply();
00108     
00109     if(is_float<eT>::value == true)
00110       {
00111       typedef float T;
00112       cblas_sgemv(Order, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY);
00113       }
00114     else
00115     if(is_double<eT>::value == true)
00116       {
00117       typedef double T;
00118       cblas_dgemv(Order, TransA, M, N, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)X, incX, (const T)tmp_real(beta), (T*)Y, incY);
00119       }
00120     else
00121     if(is_supported_complex_float<eT>::value == true)
00122       {
00123       typedef std::complex<float> T;
00124       cblas_cgemv(Order, TransA, M, N, (const T*)&alpha, (const T*)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY);
00125       }
00126     else
00127     if(is_supported_complex_double<eT>::value == true)
00128       {
00129       typedef std::complex<double> T;
00130       cblas_zgemv(Order, TransA, M, N, (const T*)&alpha, (const T*)A, lda, (const T*)X, incX, (const T*)&beta, (T*)Y, incY);
00131       }
00132     }

template<typename eT >
void atlas::cblas_gemm ( const enum CBLAS_ORDER  Order,
const enum CBLAS_TRANSPOSE  TransA,
const enum CBLAS_TRANSPOSE  TransB,
const int  M,
const int  N,
const int  K,
const eT  alpha,
const eT *  A,
const int  lda,
const eT *  B,
const int  ldb,
const eT  beta,
eT *  C,
const int  ldc 
) [inline]

Definition at line 140 of file atlas_proto.hpp.

References tmp_real().

00147     {
00148     arma_type_check<is_supported_blas_type<eT>::value == false>::apply();
00149     
00150     if(is_float<eT>::value == true)
00151       {
00152       typedef float T;
00153       cblas_sgemm(Order, TransA, TransB, M, N, K, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, ldc);
00154       }
00155     else
00156     if(is_double<eT>::value == true)
00157       {
00158       typedef double T;
00159       cblas_dgemm(Order, TransA, TransB, M, N, K, (const T)tmp_real(alpha), (const T*)A, lda, (const T*)B, ldb, (const T)tmp_real(beta), (T*)C, ldc);
00160       }
00161     else
00162     if(is_supported_complex_float<eT>::value == true)
00163       {
00164       typedef std::complex<float> T;
00165       cblas_cgemm(Order, TransA, TransB, M, N, K, (const T*)&alpha, (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc);
00166       }
00167     else
00168     if(is_supported_complex_double<eT>::value == true)
00169       {
00170       typedef std::complex<double> T;
00171       cblas_zgemm(Order, TransA, TransB, M, N, K, (const T*)&alpha, (const T*)A, lda, (const T*)B, ldb, (const T*)&beta, (T*)C, ldc);
00172       }
00173     }

template<typename eT >
int atlas::clapack_getrf ( const enum CBLAS_ORDER  Order,
const int  M,
const int  N,
eT *  A,
const int  lda,
int *  ipiv 
) [inline]

Definition at line 181 of file atlas_proto.hpp.

Referenced by auxlib::det(), auxlib::inv_inplace(), auxlib::inv_noalias(), and auxlib::lu().

00185     {
00186     arma_type_check<is_supported_blas_type<eT>::value == false>::apply();
00187     
00188     if(is_float<eT>::value == true)
00189       {
00190       typedef float T;
00191       return clapack_sgetrf(Order, M, N, (T*)A, lda, ipiv);
00192       }
00193     else
00194     if(is_double<eT>::value == true)
00195       {
00196       typedef double T;
00197       return clapack_dgetrf(Order, M, N, (T*)A, lda, ipiv);
00198       }
00199     else
00200     if(is_supported_complex_float<eT>::value == true)
00201       {
00202       typedef std::complex<float> T;
00203       return clapack_cgetrf(Order, M, N, (T*)A, lda, ipiv);
00204       }
00205     else
00206     if(is_supported_complex_double<eT>::value == true)
00207       {
00208       typedef std::complex<double> T;
00209       return clapack_zgetrf(Order, M, N, (T*)A, lda, ipiv);
00210       }
00211     else
00212       {
00213       return -1;
00214       }
00215     }

template<typename eT >
int atlas::clapack_getri ( const enum CBLAS_ORDER  Order,
const int  N,
eT *  A,
const int  lda,
const int *  ipiv 
) [inline]

Definition at line 223 of file atlas_proto.hpp.

Referenced by auxlib::inv_inplace(), and auxlib::inv_noalias().

00227     {
00228     arma_type_check<is_supported_blas_type<eT>::value == false>::apply();
00229     
00230     if(is_float<eT>::value == true)
00231       {
00232       typedef float T;
00233       return clapack_sgetri(Order, N, (T*)A, lda, ipiv);
00234       }
00235     else
00236     if(is_double<eT>::value == true)
00237       {
00238       typedef double T;
00239       return clapack_dgetri(Order, N, (T*)A, lda, ipiv);
00240       }
00241     else
00242     if(is_supported_complex_float<eT>::value == true)
00243       {
00244       typedef std::complex<float> T;
00245       return clapack_cgetri(Order, N, (T*)A, lda, ipiv);
00246       }
00247     else
00248     if(is_supported_complex_double<eT>::value == true)
00249       {
00250       typedef std::complex<double> T;
00251       return clapack_zgetri(Order, N, (T*)A, lda, ipiv);
00252       }
00253     else
00254       {
00255       return -1;
00256       }
00257     }