Classes | Namespaces | Defines | Typedefs | Enumerations | Functions | Variables
Core File Reference
#include "src/Core/util/DisableStupidWarnings.h"
#include "src/Core/util/Macros.h"
#include <complex>
#include "src/Core/util/MKL_support.h"
#include <cerrno>
#include <cstddef>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <functional>
#include <iosfwd>
#include <cstring>
#include <string>
#include <limits>
#include <climits>
#include <algorithm>
#include "src/Core/util/Constants.h"
#include "src/Core/util/ForwardDeclarations.h"
#include "src/Core/util/Meta.h"
#include "src/Core/util/XprHelper.h"
#include "src/Core/util/StaticAssert.h"
#include "src/Core/util/Memory.h"
#include "src/Core/NumTraits.h"
#include "src/Core/MathFunctions.h"
#include "src/Core/GenericPacketMath.h"
#include "src/Core/arch/Default/Settings.h"
#include "src/Core/Functors.h"
#include "src/Core/DenseCoeffsBase.h"
#include "src/Core/DenseBase.h"
#include "src/Core/MatrixBase.h"
#include "src/Core/EigenBase.h"
#include "src/Core/util/BlasUtil.h"
#include "src/Core/DenseStorage.h"
#include "src/Core/NestByValue.h"
#include "src/Core/ForceAlignedAccess.h"
#include "src/Core/ReturnByValue.h"
#include "src/Core/NoAlias.h"
#include "src/Core/PlainObjectBase.h"
#include "src/Core/Matrix.h"
#include "src/Core/Array.h"
#include "src/Core/CwiseBinaryOp.h"
#include "src/Core/CwiseUnaryOp.h"
#include "src/Core/CwiseNullaryOp.h"
#include "src/Core/CwiseUnaryView.h"
#include "src/Core/SelfCwiseBinaryOp.h"
#include "src/Core/Dot.h"
#include "src/Core/StableNorm.h"
#include "src/Core/MapBase.h"
#include "src/Core/Stride.h"
#include "src/Core/Map.h"
#include "src/Core/Block.h"
#include "src/Core/VectorBlock.h"
#include "src/Core/Transpose.h"
#include "src/Core/DiagonalMatrix.h"
#include "src/Core/Diagonal.h"
#include "src/Core/DiagonalProduct.h"
#include "src/Core/PermutationMatrix.h"
#include "src/Core/Transpositions.h"
#include "src/Core/Redux.h"
#include "src/Core/Visitor.h"
#include "src/Core/Fuzzy.h"
#include "src/Core/IO.h"
#include "src/Core/Swap.h"
#include "src/Core/CommaInitializer.h"
#include "src/Core/Flagged.h"
#include "src/Core/ProductBase.h"
#include "src/Core/GeneralProduct.h"
#include "src/Core/TriangularMatrix.h"
#include "src/Core/SelfAdjointView.h"
#include "src/Core/SolveTriangular.h"
#include "src/Core/products/Parallelizer.h"
#include "src/Core/products/CoeffBasedProduct.h"
#include "src/Core/products/GeneralBlockPanelKernel.h"
#include "src/Core/products/GeneralMatrixVector.h"
#include "src/Core/products/GeneralMatrixMatrix.h"
#include "src/Core/products/GeneralMatrixMatrixTriangular.h"
#include "src/Core/products/SelfadjointMatrixVector.h"
#include "src/Core/products/SelfadjointMatrixMatrix.h"
#include "src/Core/products/SelfadjointProduct.h"
#include "src/Core/products/SelfadjointRank2Update.h"
#include "src/Core/products/TriangularMatrixVector.h"
#include "src/Core/products/TriangularMatrixMatrix.h"
#include "src/Core/products/TriangularSolverMatrix.h"
#include "src/Core/products/TriangularSolverVector.h"
#include "src/Core/BandMatrix.h"
#include "src/Core/BooleanRedux.h"
#include "src/Core/Select.h"
#include "src/Core/VectorwiseOp.h"
#include "src/Core/Random.h"
#include "src/Core/Replicate.h"
#include "src/Core/Reverse.h"
#include "src/Core/ArrayBase.h"
#include "src/Core/ArrayWrapper.h"
#include "src/Core/GlobalFunctions.h"
#include "src/Core/util/ReenableStupidWarnings.h"

Classes

class  aligned_allocator< T >
 STL compatible allocator to use with with 16 byte aligned types. More...
class  Array< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >
 General-purpose arrays with easy API for coefficient-wise operations. More...
class  ArrayBase< Derived >
 Base class for all 1D and 2D array, and related expressions. More...
class  ArrayWrapper< ExpressionType >
 Expression of a mathematical vector or matrix as an array object. More...
struct  ArrayXpr
class  Block< XprType, BlockRows, BlockCols, InnerPanel, HasDirectAccess >
 Expression of a fixed-size or dynamic-size block. More...
class  Block< XprType, BlockRows, BlockCols, InnerPanel, true >
class  CoeffBasedProduct< LhsNested, RhsNested, NestingFlags >
class  CommaInitializer< XprType >
 Helper class used by the comma initializer operator. More...
struct  MatrixBase< Derived >::ConstDiagonalIndexReturnType< Index >
struct  DenseBase< Derived >::ConstFixedSegmentReturnType< Size >
struct  MatrixBase< Derived >::ConstSelfAdjointViewReturnType< UpLo >
struct  MatrixBase< Derived >::ConstTriangularViewReturnType< Mode >
class  CwiseBinaryOp< BinaryOp, Lhs, Rhs >
 Generic expression where a coefficient-wise binary operator is applied to two expressions. More...
class  CwiseBinaryOpImpl< BinaryOp, Lhs, Rhs, Dense >
class  CwiseNullaryOp< NullaryOp, PlainObjectType >
 Generic expression of a matrix where all coefficients are defined by a functor. More...
class  CwiseUnaryOp< UnaryOp, XprType >
 Generic expression where a coefficient-wise unary operator is applied to an expression. More...
class  CwiseUnaryOpImpl< UnaryOp, XprType, Dense >
class  CwiseUnaryView< ViewOp, MatrixType >
 Generic lvalue expression of a coefficient-wise unary operator of a matrix or a vector. More...
class  CwiseUnaryViewImpl< ViewOp, MatrixType, Dense >
struct  Default_t
struct  Dense
class  DenseBase< Derived >
 Base class for all dense matrices, vectors, and arrays. More...
class  DenseCoeffsBase< Derived, DirectAccessors >
 Base class providing direct read-only coefficient access to matrices and arrays. More...
class  DenseCoeffsBase< Derived, DirectWriteAccessors >
 Base class providing direct read/write coefficient access to matrices and arrays. More...
class  DenseCoeffsBase< Derived, ReadOnlyAccessors >
 Base class providing read-only coefficient access to matrices and arrays. More...
class  DenseCoeffsBase< Derived, WriteAccessors >
 Base class providing read/write coefficient access to matrices and arrays. More...
class  DenseStorage< T, Size, _Rows, _Cols, _Options >
class  Diagonal< MatrixType, DiagIndex >
 Expression of a diagonal/subdiagonal/superdiagonal in a matrix. More...
struct  MatrixBase< Derived >::DiagonalIndexReturnType< Index >
class  DiagonalMatrix< _Scalar, SizeAtCompileTime, MaxSizeAtCompileTime >
 Represents a diagonal matrix with its storage. More...
class  DiagonalProduct< MatrixType, DiagonalType, ProductOrder >
class  DiagonalWrapper< _DiagonalVectorType >
 Expression of a diagonal matrix. More...
struct  EigenBase< Derived >
struct  VectorwiseOp< ExpressionType, Direction >::ExtendedType< OtherDerived >
struct  DenseBase< Derived >::FixedSegmentReturnType< Size >
class  ForceAlignedAccess< ExpressionType >
 Enforce aligned packet loads and stores regardless of what is requested. More...
class  GeneralProduct< Lhs, Rhs, GemmProduct >
class  GeneralProduct< Lhs, Rhs, GemvProduct >
class  GeneralProduct< Lhs, Rhs, InnerProduct >
class  GeneralProduct< Lhs, Rhs, OuterProduct >
struct  GenericNumTraits< T >
class  InnerStride< Value >
 Convenience specialization of Stride to specify only an inner stride See class Map for some examples. More...
class  IOFormat
 Stores a set of parameters controlling the way matrices are printed. More...
struct  LazyProductReturnType< Lhs, Rhs >
class  Map< PlainObjectType, MapOptions, StrideType >
 A matrix or vector expression mapping an existing array of data. More...
class  Map< PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, _PacketAccess >
class  Map< Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >, PacketAccess >
class  MapBase< Derived, ReadOnlyAccessors >
class  MapBase< Derived, WriteAccessors >
class  Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >
 The matrix class, also used for vectors and row-vectors. More...
class  MatrixBase< Derived >
 Base class for all dense matrices, vectors, and expressions. More...
class  MatrixWrapper< ExpressionType >
 Expression of an array as a mathematical vector or matrix. More...
struct  MatrixXpr
class  NestByValue< ExpressionType >
 Expression which must be nested by value. More...
class  NoAlias< ExpressionType, StorageBase >
 Pseudo expression providing an operator = assuming no aliasing. More...
struct  NoChange_t
class  NumTraits< T >
 Holds information about the various numeric (i.e. scalar) types allowed by Eigen. More...
struct  NumTraits< Array< Scalar, Rows, Cols, Options, MaxRows, MaxCols > >
struct  NumTraits< double >
struct  NumTraits< float >
struct  NumTraits< long double >
struct  NumTraits< std::complex< _Real > >
class  OuterStride< Value >
 Convenience specialization of Stride to specify only an outer stride See class Map for some examples. More...
class  PartialReduxExpr< MatrixType, MemberOp, Direction >
 Generic expression of a partially reduxed matrix. More...
class  PermutationBase< Derived >
 Base class for permutations. More...
class  PermutationMatrix< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >
 Permutation matrix. More...
struct  PermutationStorage
class  PermutationWrapper< _IndicesType >
 Class to view a vector of integers as a permutation matrix. More...
class  PlainObjectBase< Derived >
 Dense storage base class for matrices and arrays. More...
class  ProductBase< Derived, Lhs, Rhs >
class  ProductReturnType< Lhs, Rhs, ProductType >
 Helper class to get the correct and optimized returned type of operator*. More...
struct  ProductReturnType< Lhs, Rhs, CoeffBasedProductMode >
struct  ProductReturnType< Lhs, Rhs, LazyCoeffBasedProductMode >
struct  aligned_allocator< T >::rebind< U >
struct  VectorwiseOp< ExpressionType, Direction >::ReduxReturnType< BinaryOp >
class  Replicate< MatrixType, RowFactor, ColFactor >
 Expression of the multiple replication of a matrix or vector. More...
class  ReturnByValue< Derived >
struct  VectorwiseOp< ExpressionType, Direction >::ReturnType< Functor, Scalar >
class  Reverse< MatrixType, Direction >
 Expression of the reverse of a vector or matrix. More...
class  ScaledProduct< NestedProduct >
class  Select< ConditionMatrixType, ThenMatrixType, ElseMatrixType >
 Expression of a coefficient wise version of the C++ ternary operator ?: More...
struct  selfadjoint_product_selector< MatrixType, OtherType, UpLo, false >
struct  selfadjoint_product_selector< MatrixType, OtherType, UpLo, true >
struct  selfadjoint_rank1_update< Scalar, Index, ColMajor, UpLo, ConjLhs, ConjRhs >
struct  selfadjoint_rank1_update< Scalar, Index, RowMajor, UpLo, ConjLhs, ConjRhs >
struct  SelfadjointProductMatrix< Lhs, 0, true, Rhs, RhsMode, false >
struct  SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, 0, true >
struct  SelfadjointProductMatrix< Lhs, LhsMode, false, Rhs, RhsMode, false >
class  SelfAdjointView< MatrixType, UpLo >
 Expression of a selfadjoint matrix from a triangular part of a dense matrix. More...
struct  MatrixBase< Derived >::SelfAdjointViewReturnType< UpLo >
class  SelfCwiseBinaryOp< BinaryOp, Lhs, Rhs >
struct  Sequential_t
class  Stride< _OuterStrideAtCompileTime, _InnerStrideAtCompileTime >
 Holds strides information for Map. More...
struct  PlainObjectBase< Derived >::StridedAlignedMapType< StrideType >
struct  PlainObjectBase< Derived >::StridedConstAlignedMapType< StrideType >
struct  PlainObjectBase< Derived >::StridedConstMapType< StrideType >
struct  PlainObjectBase< Derived >::StridedMapType< StrideType >
class  SwapWrapper< ExpressionType >
class  Transpose< MatrixType >
 Expression of the transpose of a matrix. More...
class  Transpose< PermutationBase< Derived > >
class  Transpose< TranspositionsBase< TranspositionsDerived > >
class  TransposeImpl< MatrixType, Dense >
class  Transpositions< SizeAtCompileTime, MaxSizeAtCompileTime, IndexType >
 Represents a sequence of transpositions (row/column interchange) More...
class  TranspositionsBase< Derived >
class  TranspositionsWrapper< _IndicesType >
class  TriangularBase< Derived >
struct  TriangularProduct< Mode, false, Lhs, true, Rhs, false >
struct  TriangularProduct< Mode, LhsIsTriangular, Lhs, false, Rhs, false >
struct  TriangularProduct< Mode, true, Lhs, false, Rhs, true >
class  TriangularView< _MatrixType, _Mode >
 Base class for triangular part in a matrix. More...
struct  MatrixBase< Derived >::TriangularViewReturnType< Mode >
class  VectorBlock< VectorType, Size >
 Expression of a fixed-size or dynamic-size sub-vector. More...
class  VectorwiseOp< ExpressionType, Direction >
 Pseudo expression providing partial reduction operations. More...
class  WithFormat< ExpressionType >
 Pseudo expression providing matrix output with given format. More...

Namespaces

namespace  Eigen
 

Namespace containing all symbols from the Eigen library.


namespace  Eigen::Architecture
namespace  Eigen::internal

Defines

#define EIGEN2_SUPPORT_STAGE
#define EIGEN_CORE_H
#define EIGEN_DONT_VECTORIZE
#define EIGEN_HAS_ERRNO
#define STAGE10_FULL_EIGEN2_API
#define STAGE20_RESOLVE_API_CONFLICTS
#define STAGE30_FULL_EIGEN3_API
#define STAGE40_FULL_EIGEN3_STRICTNESS
#define STAGE99_NO_EIGEN2_SUPPORT

Typedefs

typedef
EIGEN_DEFAULT_DENSE_INDEX_TYPE 		DenseIndex
typedef Matrix< std::complex
< double >, 2, 2 > 		Matrix2cd
typedef Matrix< std::complex
< float >, 2, 2 > 		Matrix2cf
typedef Matrix< double, 2, 2 > Matrix2d
typedef Matrix< float, 2, 2 > Matrix2f
typedef Matrix< int, 2, 2 > Matrix2i
typedef Matrix< std::complex
< double >, 2, Dynamic > 		Matrix2Xcd
typedef Matrix< std::complex
< float >, 2, Dynamic > 		Matrix2Xcf
typedef Matrix< double,
2, Dynamic > 		Matrix2Xd
typedef Matrix< float, 2, Dynamic > Matrix2Xf
typedef Matrix< int, 2, Dynamic > Matrix2Xi
typedef Matrix< std::complex
< double >, 3, 3 > 		Matrix3cd
typedef Matrix< std::complex
< float >, 3, 3 > 		Matrix3cf
typedef Matrix< double, 3, 3 > Matrix3d
typedef Matrix< float, 3, 3 > Matrix3f
typedef Matrix< int, 3, 3 > Matrix3i
typedef Matrix< std::complex
< double >, 3, Dynamic > 		Matrix3Xcd
typedef Matrix< std::complex
< float >, 3, Dynamic > 		Matrix3Xcf
typedef Matrix< double,
3, Dynamic > 		Matrix3Xd
typedef Matrix< float, 3, Dynamic > Matrix3Xf
typedef Matrix< int, 3, Dynamic > Matrix3Xi
typedef Matrix< std::complex
< double >, 4, 4 > 		Matrix4cd
typedef Matrix< std::complex
< float >, 4, 4 > 		Matrix4cf
typedef Matrix< double, 4, 4 > Matrix4d
typedef Matrix< float, 4, 4 > Matrix4f
typedef Matrix< int, 4, 4 > Matrix4i
typedef Matrix< std::complex
< double >, 4, Dynamic > 		Matrix4Xcd
typedef Matrix< std::complex
< float >, 4, Dynamic > 		Matrix4Xcf
typedef Matrix< double,
4, Dynamic > 		Matrix4Xd
typedef Matrix< float, 4, Dynamic > Matrix4Xf
typedef Matrix< int, 4, Dynamic > Matrix4Xi
typedef Matrix< std::complex
< double >, Dynamic, 2 > 		MatrixX2cd
typedef Matrix< std::complex
< float >, Dynamic, 2 > 		MatrixX2cf
typedef Matrix< double,
Dynamic, 2 > 		MatrixX2d
typedef Matrix< float, Dynamic, 2 > MatrixX2f
typedef Matrix< int, Dynamic, 2 > MatrixX2i
typedef Matrix< std::complex
< double >, Dynamic, 3 > 		MatrixX3cd
typedef Matrix< std::complex
< float >, Dynamic, 3 > 		MatrixX3cf
typedef Matrix< double,
Dynamic, 3 > 		MatrixX3d
typedef Matrix< float, Dynamic, 3 > MatrixX3f
typedef Matrix< int, Dynamic, 3 > MatrixX3i
typedef Matrix< std::complex
< double >, Dynamic, 4 > 		MatrixX4cd
typedef Matrix< std::complex
< float >, Dynamic, 4 > 		MatrixX4cf
typedef Matrix< double,
Dynamic, 4 > 		MatrixX4d
typedef Matrix< float, Dynamic, 4 > MatrixX4f
typedef Matrix< int, Dynamic, 4 > MatrixX4i
typedef Matrix< std::complex
< double >, Dynamic, Dynamic > 		MatrixXcd
typedef Matrix< std::complex
< float >, Dynamic, Dynamic > 		MatrixXcf
typedef Matrix< double,
Dynamic, Dynamic > 		MatrixXd
typedef Matrix< float, Dynamic,
Dynamic > 		MatrixXf
typedef Matrix< int, Dynamic,
Dynamic > 		MatrixXi
typedef Matrix< std::complex
< double >, 1, 2 > 		RowVector2cd
typedef Matrix< std::complex
< float >, 1, 2 > 		RowVector2cf
typedef Matrix< double, 1, 2 > RowVector2d
typedef Matrix< float, 1, 2 > RowVector2f
typedef Matrix< int, 1, 2 > RowVector2i
typedef Matrix< std::complex
< double >, 1, 3 > 		RowVector3cd
typedef Matrix< std::complex
< float >, 1, 3 > 		RowVector3cf
typedef Matrix< double, 1, 3 > RowVector3d
typedef Matrix< float, 1, 3 > RowVector3f
typedef Matrix< int, 1, 3 > RowVector3i
typedef Matrix< std::complex
< double >, 1, 4 > 		RowVector4cd
typedef Matrix< std::complex
< float >, 1, 4 > 		RowVector4cf
typedef Matrix< double, 1, 4 > RowVector4d
typedef Matrix< float, 1, 4 > RowVector4f
typedef Matrix< int, 1, 4 > RowVector4i
typedef Matrix< std::complex
< double >, 1, Dynamic > 		RowVectorXcd
typedef Matrix< std::complex
< float >, 1, Dynamic > 		RowVectorXcf
typedef Matrix< double,
1, Dynamic > 		RowVectorXd
typedef Matrix< float, 1, Dynamic > RowVectorXf
typedef Matrix< int, 1, Dynamic > RowVectorXi
typedef Matrix< std::complex
< double >, 2, 1 > 		Vector2cd
typedef Matrix< std::complex
< float >, 2, 1 > 		Vector2cf
typedef Matrix< double, 2, 1 > Vector2d
typedef Matrix< float, 2, 1 > Vector2f
typedef Matrix< int, 2, 1 > Vector2i
typedef Matrix< std::complex
< double >, 3, 1 > 		Vector3cd
typedef Matrix< std::complex
< float >, 3, 1 > 		Vector3cf
typedef Matrix< double, 3, 1 > Vector3d
typedef Matrix< float, 3, 1 > Vector3f
typedef Matrix< int, 3, 1 > Vector3i
typedef Matrix< std::complex
< double >, 4, 1 > 		Vector4cd
typedef Matrix< std::complex
< float >, 4, 1 > 		Vector4cf
typedef Matrix< double, 4, 1 > Vector4d
typedef Matrix< float, 4, 1 > Vector4f
typedef Matrix< int, 4, 1 > Vector4i
typedef Matrix< std::complex
< double >, Dynamic, 1 > 		VectorXcd
typedef Matrix< std::complex
< float >, Dynamic, 1 > 		VectorXcf
typedef Matrix< double,
Dynamic, 1 > 		VectorXd
typedef Matrix< float, Dynamic, 1 > VectorXf
typedef Matrix< int, Dynamic, 1 > VectorXi

Enumerations

enum  {
  OnTheLeft,
  OnTheRight
}
enum  {
  IsDense,
  IsSparse
}
enum  {
  CoeffBasedProductMode,
  LazyCoeffBasedProductMode,
  OuterProduct,
  InnerProduct,
  GemvProduct,
  GemmProduct
}
enum  { DontAlignCols }
enum  {
  StreamPrecision,
  FullPrecision
}
enum  {
  Large,
  Small
}
enum  {
  Lower,
  Upper,
  UnitDiag,
  ZeroDiag,
  UnitLower,
  UnitUpper,
  StrictlyLower,
  StrictlyUpper,
  SelfAdjoint,
  Symmetric
}
enum  {
  Unaligned,
  Aligned
}
enum  {
  DefaultTraversal,
  LinearTraversal,
  InnerVectorizedTraversal,
  LinearVectorizedTraversal,
  SliceVectorizedTraversal,
  InvalidTraversal
}
enum  {
  floor_log2_terminate,
  floor_log2_move_up,
  floor_log2_move_down,
  floor_log2_bogus
}
enum  {
  NoUnrolling,
  InnerUnrolling,
  CompleteUnrolling
}
enum  {
  Specialized,
  BuiltIn
}
enum  {
  ColMajor,
  RowMajor,
  AutoAlign,
  DontAlign
}
enum  AccessorLevels {
  ReadOnlyAccessors,
  WriteAccessors,
  DirectAccessors,
  DirectWriteAccessors
}
enum  Action {
  GetAction,
  SetAction
}
enum  ComputationInfo {
  Success,
  NumericalIssue,
  NoConvergence,
  InvalidInput
}
enum  CornerType {
  TopLeft,
  TopRight,
  BottomLeft,
  BottomRight
}
enum  DecompositionOptions {
  Pivoting,
  NoPivoting,
  ComputeFullU,
  ComputeThinU,
  ComputeFullV,
  ComputeThinV,
  EigenvaluesOnly,
  ComputeEigenvectors,
  EigVecMask,
  Ax_lBx,
  ABx_lx,
  BAx_lx,
  GenEigMask
}
enum  DirectionType {
  Vertical,
  Horizontal,
  BothDirections
}
enum  PermPermProduct_t { PermPermProduct }
enum  QRPreconditioners {
  NoQRPreconditioner,
  HouseholderQRPreconditioner,
  ColPivHouseholderQRPreconditioner,
  FullPivHouseholderQRPreconditioner
}
enum  TransformTraits {
  Isometry,
  Affine,
  AffineCompact,
  Projective
}
enum  Type {
  Generic,
  SSE,
  AltiVec,
  Target
}

Functions

template<typename T >
void aligned_delete (T *ptr, size_t size)
void aligned_free (void *ptr)
void * aligned_malloc (size_t size)
template<typename T >
T * aligned_new (size_t size)
void * aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<typename OldType , typename NewType >
NewType cast (const OldType &x)
template<typename Index >
EIGEN_ALWAYS_INLINE void check_rows_cols_for_overflow (Index rows, Index cols)
template<typename T >
EIGEN_ALWAYS_INLINE void check_size_for_overflow (size_t size)
void check_that_malloc_is_allowed ()
template<typename LhsScalar , typename RhsScalar , int KcFactor>
void computeProductBlockingSizes (std::ptrdiff_t &k, std::ptrdiff_t &m, std::ptrdiff_t &n)
 Computes the blocking parameters for a m x k times k x n matrix product.
template<typename LhsScalar , typename RhsScalar >
void computeProductBlockingSizes (std::ptrdiff_t &k, std::ptrdiff_t &m, std::ptrdiff_t &n)
template<typename T , bool Align>
void conditional_aligned_delete (T *ptr, size_t size)
template<typename T , bool Align>
void conditional_aligned_delete_auto (T *ptr, size_t size)
template<bool Align>
void conditional_aligned_free (void *ptr)
template<>
void conditional_aligned_free< false > (void *ptr)
template<bool Align>
void * conditional_aligned_malloc (size_t size)
template<>
void * conditional_aligned_malloc< false > (size_t size)
template<typename T , bool Align>
T * conditional_aligned_new (size_t size)
template<typename T , bool Align>
T * conditional_aligned_new_auto (size_t size)
template<bool Align>
void * conditional_aligned_realloc (void *ptr, size_t new_size, size_t old_size)
template<>
void * conditional_aligned_realloc< false > (void *ptr, size_t new_size, size_t)
template<typename T , bool Align>
T * conditional_aligned_realloc_new (T *pts, size_t new_size, size_t old_size)
template<typename T , bool Align>
T * conditional_aligned_realloc_new_auto (T *pts, size_t new_size, size_t old_size)
template<typename T >
T * const_cast_ptr (const T *ptr)
template<typename T >
T * construct_elements_of_array (T *ptr, size_t size)
template<typename T >
void destruct_elements_of_array (T *ptr, size_t size)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (real, Scalar) real(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (imag, Scalar) imag(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (real_ref, Scalar) real_ref(Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (imag_ref, Scalar) imag_ref(Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (conj, Scalar) conj(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (abs, Scalar) abs(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (abs2, Scalar) abs2(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (norm1, Scalar) norm1(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (hypot, Scalar) hypot(const Scalar &x
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (sqrt, Scalar) sqrt(const Scalar &x)
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (atan2, Scalar) atan2(const Scalar &x
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (pow, Scalar) pow(const Scalar &x
template<typename Scalar >
 EIGEN_MATHFUNC_RETVAL (random, Scalar) random(const Scalar &x
 EIGEN_MEMBER_FUNCTOR (sum,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (mean,(Size-1)*NumTraits< Scalar >::AddCost+NumTraits< Scalar >::MulCost)
 EIGEN_MEMBER_FUNCTOR (minCoeff,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (all,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (any,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (count,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (maxCoeff,(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (prod,(Size-1)*NumTraits< Scalar >::MulCost)
 EIGEN_MEMBER_FUNCTOR (hypotNorm,(Size-1)*functor_traits< scalar_hypot_op< Scalar > >::Cost)
 EIGEN_MEMBER_FUNCTOR (squaredNorm, Size *NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (norm,(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (stableNorm,(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
 EIGEN_MEMBER_FUNCTOR (blueNorm,(Size+5)*NumTraits< Scalar >::MulCost+(Size-1)*NumTraits< Scalar >::AddCost)
template<typename T >
const T::Scalar * extract_data (const T &m)
template<typename CJ , typename A , typename B , typename C , typename T >
void gebp_madd (const CJ &cj, A &a, B &b, C &c, T &t)
void * generic_aligned_realloc (void *ptr, size_t size, size_t old_size)
void handmade_aligned_free (void *ptr)
void * handmade_aligned_malloc (size_t size)
void * handmade_aligned_realloc (void *ptr, size_t size, size_t=0)
template<typename Scalar >
add_const_on_value_type
< EIGEN_MATHFUNC_RETVAL(imag_ref,
Scalar) >::type 		imag_ref (const Scalar &x)
template<typename Scalar >
bool isApprox (const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename Scalar >
bool isApproxOrLessThan (const Scalar &x, const Scalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
template<typename T >
bool isfinite (const T &x)
template<typename Scalar , typename OtherScalar >
bool isMuchSmallerThan (const Scalar &x, const OtherScalar &y, typename NumTraits< Scalar >::Real precision=NumTraits< Scalar >::dummy_precision())
std::ptrdiff_t l1CacheSize ()
std::ptrdiff_t l2CacheSize ()
void manage_caching_sizes (Action action, std::ptrdiff_t *l1=0, std::ptrdiff_t *l2=0)
std::ptrdiff_t manage_caching_sizes_helper (std::ptrdiff_t a, std::ptrdiff_t b)
void manage_multi_threading (Action action, int *v)
int nbThreads ()
template<typename Derived , typename Lhs , typename Rhs >
const ScaledProduct< Derived > operator* (typename Derived::Scalar x, const ProductBase< Derived, Lhs, Rhs > &prod)
template<typename Derived , typename TranspositionDerived >
const
internal::transposition_matrix_product_retval
< TranspositionDerived,
Derived, OnTheLeft > 		operator* (const TranspositionsBase< TranspositionDerived > &transpositions, const MatrixBase< Derived > &matrix)
template<typename Derived , typename PermutationDerived >
const
internal::permut_matrix_product_retval
< PermutationDerived, Derived,
OnTheLeft > 		operator* (const PermutationBase< PermutationDerived > &permutation, const MatrixBase< Derived > &matrix)
template<typename Derived , typename PermutationDerived >
const
internal::permut_matrix_product_retval
< PermutationDerived, Derived,
OnTheRight > 		operator* (const MatrixBase< Derived > &matrix, const PermutationBase< PermutationDerived > &permutation)
template<typename Derived , typename TranspositionsDerived >
const
internal::transposition_matrix_product_retval
< TranspositionsDerived,
Derived, OnTheRight > 		operator* (const MatrixBase< Derived > &matrix, const TranspositionsBase< TranspositionsDerived > &transpositions)
template<typename Derived , typename Lhs , typename Rhs >
const ScaledProduct< Derived > operator* (const ProductBase< Derived, Lhs, Rhs > &prod, typename Derived::Scalar x)
template<typename Derived , typename Lhs , typename Rhs >
internal::enable_if
<!internal::is_same< typename
Derived::Scalar, typename
Derived::RealScalar >::value,
const ScaledProduct< Derived >
>::type 		operator* (const ProductBase< Derived, Lhs, Rhs > &prod, typename Derived::RealScalar x)
template<typename Derived , typename Lhs , typename Rhs >
internal::enable_if
<!internal::is_same< typename
Derived::Scalar, typename
Derived::RealScalar >::value,
const ScaledProduct< Derived >
>::type 		operator* (typename Derived::RealScalar x, const ProductBase< Derived, Lhs, Rhs > &prod)
template<typename Packet >
Packet pabs (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		pacos (const Packet &a)
template<typename Packet >
Packet padd (const Packet &a, const Packet &b)
template<int Offset, typename PacketType >
void palign (PacketType &first, const PacketType &second)
template<typename Packet >
Packet pand (const Packet &a, const Packet &b)
template<typename Packet >
Packet pandnot (const Packet &a, const Packet &b)
template<bool Condition, typename Functor , typename Index >
void parallelize_gemm (const Functor &func, Index rows, Index cols, bool transpose)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		pasin (const Packet &a)
template<typename Packet >
Packet pconj (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		pcos (const Packet &a)
template<typename Packet >
Packet pcplxflip (const Packet &a)
template<typename Packet >
Packet pdiv (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		pexp (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type pfirst (const Packet &a)
template<typename Packet >
Packet pload (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
Packet ploaddup (const typename unpacket_traits< Packet >::type *from)
template<typename Packet , int LoadMode>
Packet ploadt (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
Packet ploadu (const typename unpacket_traits< Packet >::type *from)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		plog (const Packet &a)
template<typename Scalar >
packet_traits< Scalar >::type plset (const Scalar &a)
template<typename Packet >
Packet pmadd (const Packet &a, const Packet &b, const Packet &c)
template<typename Packet >
Packet pmax (const Packet &a, const Packet &b)
template<typename Packet >
Packet pmin (const Packet &a, const Packet &b)
template<typename Packet >
Packet pmul (const Packet &a, const Packet &b)
template<>
std::complex< float > pmul (const std::complex< float > &a, const std::complex< float > &b)
template<>
std::complex< double > pmul (const std::complex< double > &a, const std::complex< double > &b)
template<typename Packet >
Packet pnegate (const Packet &a)
template<typename Packet >
Packet por (const Packet &a, const Packet &b)
template<typename Packet >
unpacket_traits< Packet >::type predux (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type predux_max (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type predux_min (const Packet &a)
template<typename Packet >
unpacket_traits< Packet >::type predux_mul (const Packet &a)
template<typename Packet >
Packet preduxp (const Packet *vecs)
template<typename Scalar >
void prefetch (const Scalar *addr)
template<typename Packet >
Packet preverse (const Packet &a)
template<typename Derived >
std::ostream & print_matrix (std::ostream &s, const Derived &_m, const IOFormat &fmt)
template<typename Packet >
Packet pset1 (const typename unpacket_traits< Packet >::type &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		psin (const Packet &a)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		psqrt (const Packet &a)
template<typename Scalar , typename Packet >
void pstore (Scalar *to, const Packet &from)
template<typename Packet >
void pstore1 (typename unpacket_traits< Packet >::type *to, const typename unpacket_traits< Packet >::type &a)
template<typename Scalar , typename Packet , int LoadMode>
void pstoret (Scalar *to, const Packet &from)
template<typename Scalar , typename Packet >
void pstoreu (Scalar *to, const Packet &from)
template<typename Packet >
Packet psub (const Packet &a, const Packet &b)
template<typename Packet >
EIGEN_DECLARE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS
Packet 		ptan (const Packet &a)
template<typename Packet >
Packet pxor (const Packet &a, const Packet &b)
void queryCacheSizes (int &l1, int &l2, int &l3)
int queryL1CacheSize ()
int queryTopLevelCacheSize ()
template<typename Scalar >
add_const_on_value_type
< EIGEN_MATHFUNC_RETVAL(real_ref,
Scalar) >::type 		real_ref (const Scalar &x)
void setCpuCacheSizes (std::ptrdiff_t l1, std::ptrdiff_t l2)
void setNbThreads (int v)
template<typename T >
void smart_copy (const T *start, const T *end, T *target)
template<typename ExpressionType , typename Scalar >
void stable_norm_kernel (const ExpressionType &bl, Scalar &ssq, Scalar &scale, Scalar &invScale)
void throw_std_bad_alloc ()

Variables

const unsigned int ActualPacketAccessBit
const unsigned int AlignedBit
const unsigned int DirectAccessBit
const int Dynamic
const unsigned int EvalBeforeAssigningBit
const unsigned int EvalBeforeNestingBit
const unsigned int HereditaryBits
const int Infinity
bool IsComplex
const unsigned int LinearAccessBit
const unsigned int LvalueBit
const unsigned int NestByRefBit
const unsigned int PacketAccessBit
const unsigned int RowMajorBit
const Scalar & y

Define Documentation

#define EIGEN2_SUPPORT_STAGE
#define EIGEN_CORE_H
#define EIGEN_DONT_VECTORIZE
#define EIGEN_HAS_ERRNO
#define STAGE10_FULL_EIGEN2_API
#define STAGE20_RESOLVE_API_CONFLICTS
#define STAGE30_FULL_EIGEN3_API
#define STAGE40_FULL_EIGEN3_STRICTNESS
#define STAGE99_NO_EIGEN2_SUPPORT
Generated on Fri Mar 16 2012 20:20:51 for Eigen by  doxygen 1.7.4