GeneralMatrixVector_BLAS.h File Reference

#include "../InternalHeaderCheck.h"

Go to the source code of this file.

Namespaces
	Eigen
	Namespace containing all symbols from the Eigen library.
	Eigen::internal
	Namespace containing low-level routines from the Eigen library.

Macros
#define	EIGEN_BLAS_GEMV_SPECIALIZE(Scalar)
#define	EIGEN_BLAS_GEMV_SPECIALIZATION(EIGTYPE, BLASTYPE, BLASFUNC)

Macro Definition Documentation

EIGEN_BLAS_GEMV_SPECIALIZATION

#define EIGEN_BLAS_GEMV_SPECIALIZATION	(		EIGTYPE,
			BLASTYPE,
			BLASFUNC
	)

Value:

  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, bool ConjugateRhs>                              \
  struct general_matrix_vector_product_gemv<Index, EIGTYPE, LhsStorageOrder, ConjugateLhs, EIGTYPE, ConjugateRhs> { \
    typedef Matrix<EIGTYPE, Dynamic, 1, ColMajor> GEMVVector;                                                       \
                                                                                                                    \
    static void run(Index rows, Index cols, const EIGTYPE* lhs, Index lhsStride, const EIGTYPE* rhs, Index rhsIncr, \
                    EIGTYPE* res, Index resIncr, EIGTYPE alpha) {                                                   \
      if (rows == 0 || cols == 0) return;                                                                           \
      BlasIndex m = convert_index<BlasIndex>(rows), n = convert_index<BlasIndex>(cols),                             \
                lda = convert_index<BlasIndex>(lhsStride), incx = convert_index<BlasIndex>(rhsIncr),                \
                incy = convert_index<BlasIndex>(resIncr);                                                           \
      const EIGTYPE beta(1);                                                                                        \
      const EIGTYPE* x_ptr;                                                                                         \
      char trans = (LhsStorageOrder == ColMajor) ? 'N' : (ConjugateLhs) ? 'C' : 'T';                                \
      if (LhsStorageOrder == RowMajor) {                                                                            \
        m = convert_index<BlasIndex>(cols);                                                                         \
        n = convert_index<BlasIndex>(rows);                                                                         \
      }                                                                                                             \
      GEMVVector x_tmp;                                                                                             \
      if (ConjugateRhs) {                                                                                           \
        Map<const GEMVVector, 0, InnerStride<> > map_x(rhs, cols, 1, InnerStride<>(incx));                          \
        x_tmp = map_x.conjugate();                                                                                  \
        x_ptr = x_tmp.data();                                                                                       \
        incx = 1;                                                                                                   \
      } else {                                                                                                      \
        x_ptr = rhs;                                                                                                \
      }                                                                                                             \
      BLASFUNC(&trans, &m, &n, (const BLASTYPE*)&numext::real_ref(alpha), (const BLASTYPE*)lhs, &lda,               \
               (const BLASTYPE*)x_ptr, &incx, (const BLASTYPE*)&numext::real_ref(beta), (BLASTYPE*)res, &incy);     \
    }                                                                                                               \
  };

EIGEN_BLAS_GEMV_SPECIALIZE

#define EIGEN_BLAS_GEMV_SPECIALIZE

(

Scalar

)

Value:

  template <typename Index, bool ConjugateLhs, bool ConjugateRhs>                                                \
  struct general_matrix_vector_product<Index, Scalar, const_blas_data_mapper<Scalar, Index, ColMajor>, ColMajor, \
                                       ConjugateLhs, Scalar, const_blas_data_mapper<Scalar, Index, RowMajor>,    \
                                       ConjugateRhs, Specialized> {                                              \
    static void run(Index rows, Index cols, const const_blas_data_mapper<Scalar, Index, ColMajor>& lhs,          \
                    const const_blas_data_mapper<Scalar, Index, RowMajor>& rhs, Scalar* res, Index resIncr,      \
                    Scalar alpha) {                                                                              \
      if (ConjugateLhs) {                                                                                        \
        general_matrix_vector_product<Index, Scalar, const_blas_data_mapper<Scalar, Index, ColMajor>, ColMajor,  \
                                      ConjugateLhs, Scalar, const_blas_data_mapper<Scalar, Index, RowMajor>,     \
                                      ConjugateRhs, BuiltIn>::run(rows, cols, lhs, rhs, res, resIncr, alpha);    \
      } else {                                                                                                   \
        general_matrix_vector_product_gemv<Index, Scalar, ColMajor, ConjugateLhs, Scalar, ConjugateRhs>::run(    \
            rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha);                \
      }                                                                                                          \
    }                                                                                                            \
  };                                                                                                             \
  template <typename Index, bool ConjugateLhs, bool ConjugateRhs>                                                \
  struct general_matrix_vector_product<Index, Scalar, const_blas_data_mapper<Scalar, Index, RowMajor>, RowMajor, \
                                       ConjugateLhs, Scalar, const_blas_data_mapper<Scalar, Index, ColMajor>,    \
                                       ConjugateRhs, Specialized> {                                              \
    static void run(Index rows, Index cols, const const_blas_data_mapper<Scalar, Index, RowMajor>& lhs,          \
                    const const_blas_data_mapper<Scalar, Index, ColMajor>& rhs, Scalar* res, Index resIncr,      \
                    Scalar alpha) {                                                                              \
      general_matrix_vector_product_gemv<Index, Scalar, RowMajor, ConjugateLhs, Scalar, ConjugateRhs>::run(      \
          rows, cols, lhs.data(), lhs.stride(), rhs.data(), rhs.stride(), res, resIncr, alpha);                  \
    }                                                                                                            \
  };