SelfadjointMatrixVector_BLAS.h File Reference

#include "../InternalHeaderCheck.h"

Go to the source code of this file.

Classes
struct	Eigen::internal::selfadjoint_matrix_vector_product_symv< Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs >

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_SYMV_SPECIALIZE(Scalar)
#define	EIGEN_BLAS_SYMV_SPECIALIZATION(EIGTYPE, BLASTYPE, BLASFUNC)

Macro Definition Documentation

EIGEN_BLAS_SYMV_SPECIALIZATION

#define EIGEN_BLAS_SYMV_SPECIALIZATION	(		EIGTYPE,
			BLASTYPE,
			BLASFUNC
	)

Value:

  template <typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs>                      \
  struct selfadjoint_matrix_vector_product_symv<EIGTYPE, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs> {  \
    typedef Matrix<EIGTYPE, Dynamic, 1, ColMajor> SYMVVector;                                                      \
                                                                                                                   \
    static void run(Index size, const EIGTYPE* lhs, Index lhsStride, const EIGTYPE* _rhs, EIGTYPE* res,            \
                    EIGTYPE alpha) {                                                                               \
      if (size == 0) return;                                                                                       \
      enum { IsRowMajor = StorageOrder == RowMajor ? 1 : 0, IsLower = UpLo == Lower ? 1 : 0 };                     \
      BlasIndex n = convert_index<BlasIndex>(size), lda = convert_index<BlasIndex>(lhsStride), incx = 1, incy = 1; \
      EIGTYPE beta(1);                                                                                             \
      const EIGTYPE* x_ptr;                                                                                        \
      char uplo = (IsRowMajor) ? (IsLower ? 'U' : 'L') : (IsLower ? 'L' : 'U');                                    \
      SYMVVector x_tmp;                                                                                            \
      if (ConjugateRhs) {                                                                                          \
        Map<const SYMVVector, 0> map_x(_rhs, size, 1);                                                             \
        x_tmp = map_x.conjugate();                                                                                 \
        x_ptr = x_tmp.data();                                                                                      \
      } else                                                                                                       \
        x_ptr = _rhs;                                                                                              \
      BLASFUNC(&uplo, &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_SYMV_SPECIALIZE

#define EIGEN_BLAS_SYMV_SPECIALIZE

(

Scalar

)

Value:

  template <typename Index, int StorageOrder, int UpLo, bool ConjugateLhs, bool ConjugateRhs>                        \
  struct selfadjoint_matrix_vector_product<Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs,            \
                                           Specialized> {                                                            \
    static void run(Index size, const Scalar* lhs, Index lhsStride, const Scalar* _rhs, Scalar* res, Scalar alpha) { \
      enum { IsColMajor = StorageOrder == ColMajor };                                                                \
      if (IsColMajor == ConjugateLhs) {                                                                              \
        selfadjoint_matrix_vector_product<Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs,             \
                                          BuiltIn>::run(size, lhs, lhsStride, _rhs, res, alpha);                     \
      } else {                                                                                                       \
        selfadjoint_matrix_vector_product_symv<Scalar, Index, StorageOrder, UpLo, ConjugateLhs, ConjugateRhs>::run(  \
            size, lhs, lhsStride, _rhs, res, alpha);                                                                 \
      }                                                                                                              \
    }                                                                                                                \
  };