GeneralMatrixMatrixTriangular_BLAS.h File Reference

#include "../InternalHeaderCheck.h"

Go to the source code of this file.

Classes
struct	Eigen::internal::general_matrix_matrix_rankupdate< Index, Scalar, AStorageOrder, ConjugateA, ResStorageOrder, UpLo >

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_RANKUPDATE_SPECIALIZE(Scalar)
#define	EIGEN_BLAS_RANKUPDATE_R(EIGTYPE, BLASTYPE, BLASFUNC)
#define	EIGEN_BLAS_RANKUPDATE_C(EIGTYPE, BLASTYPE, RTYPE, BLASFUNC)

Macro Definition Documentation

EIGEN_BLAS_RANKUPDATE_C

#define EIGEN_BLAS_RANKUPDATE_C	(		EIGTYPE,
			BLASTYPE,
			RTYPE,
			BLASFUNC
	)

EIGEN_BLAS_RANKUPDATE_R

#define EIGEN_BLAS_RANKUPDATE_R	(		EIGTYPE,
			BLASTYPE,
			BLASFUNC
	)

Value:

  template <typename Index, int AStorageOrder, bool ConjugateA, int UpLo>                                           \
  struct general_matrix_matrix_rankupdate<Index, EIGTYPE, AStorageOrder, ConjugateA, ColMajor, UpLo> {              \
    enum {                                                                                                          \
      IsLower = (UpLo & Lower) == Lower,                                                                            \
      LowUp = IsLower ? Lower : Upper,                                                                              \
      conjA = ((AStorageOrder == ColMajor) && ConjugateA) ? 1 : 0                                                   \
    };                                                                                                              \
    static EIGEN_STRONG_INLINE void run(Index size, Index depth, const EIGTYPE* lhs, Index lhsStride,               \
                                        const EIGTYPE* /*rhs*/, Index /*rhsStride*/, EIGTYPE* res, Index resStride, \
                                        EIGTYPE alpha, level3_blocking<EIGTYPE, EIGTYPE>& /*blocking*/) {           \
      /* typedef Matrix<EIGTYPE, Dynamic, Dynamic, RhsStorageOrder> MatrixRhs;*/                                    \
      if (size == 0 || depth == 0) return;                                                                          \
      BlasIndex lda = convert_index<BlasIndex>(lhsStride), ldc = convert_index<BlasIndex>(resStride),               \
                n = convert_index<BlasIndex>(size), k = convert_index<BlasIndex>(depth);                            \
      char uplo = ((IsLower) ? 'L' : 'U'), trans = ((AStorageOrder == RowMajor) ? 'T' : 'N');                       \
      EIGTYPE beta(1);                                                                                              \
      BLASFUNC(&uplo, &trans, &n, &k, (const BLASTYPE*)&numext::real_ref(alpha), lhs, &lda,                         \
               (const BLASTYPE*)&numext::real_ref(beta), res, &ldc);                                                \
    }                                                                                                               \
  };

EIGEN_BLAS_RANKUPDATE_SPECIALIZE

#define EIGEN_BLAS_RANKUPDATE_SPECIALIZE

(

Scalar

)

Value:

  template <typename Index, int LhsStorageOrder, bool ConjugateLhs, int RhsStorageOrder, bool ConjugateRhs, int UpLo> \
  struct general_matrix_matrix_triangular_product<Index, Scalar, LhsStorageOrder, ConjugateLhs, Scalar,               \
                                                  RhsStorageOrder, ConjugateRhs, ColMajor, 1, UpLo, Specialized> {    \
    static EIGEN_STRONG_INLINE void run(Index size, Index depth, const Scalar* lhs, Index lhsStride,                  \
                                        const Scalar* rhs, Index rhsStride, Scalar* res, Index resIncr,               \
                                        Index resStride, Scalar alpha, level3_blocking<Scalar, Scalar>& blocking) {   \
      if (lhs == rhs && ((UpLo & (Lower | Upper)) == UpLo)) {                                                         \
        general_matrix_matrix_rankupdate<Index, Scalar, LhsStorageOrder, ConjugateLhs, ColMajor, UpLo>::run(          \
            size, depth, lhs, lhsStride, rhs, rhsStride, res, resStride, alpha, blocking);                            \
      } else {                                                                                                        \
        general_matrix_matrix_triangular_product<Index, Scalar, LhsStorageOrder, ConjugateLhs, Scalar,                \
                                                 RhsStorageOrder, ConjugateRhs, ColMajor, 1, UpLo,                    \
                                                 BuiltIn>::run(size, depth, lhs, lhsStride, rhs, rhsStride, res,      \
                                                               resIncr, resStride, alpha, blocking);                  \
      }                                                                                                               \
    }                                                                                                                 \
  };