Classes
class	Eigen::aligned_allocator< T >
	STL compatible allocator to use with with 16 byte aligned types. More...

class	Eigen::internal::aligned_stack_memory_handler< T >

struct	Eigen::aligned_allocator< T >::rebind< U >

struct	Eigen::internal::smart_copy_helper< T, UseMemcpy >

struct	Eigen::internal::smart_copy_helper< T, false >

struct	Eigen::internal::smart_copy_helper< T, true >

Namespaces
	Eigen
	iterative scaling algorithm to equilibrate rows and column norms in matrices

	Eigen::internal

Macros
#define	ei_declare_aligned_stack_constructed_variable(TYPE, NAME, SIZE, BUFFER)

#define	EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 0

#define	EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 0

#define	EIGEN_HAS_MM_MALLOC 0

#define	EIGEN_HAS_POSIX_MEMALIGN 0

#define	EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)

#define	EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign)

#define	EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE(Scalar, Size) EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0)))

#define	EIGEN_MALLOC_ALREADY_ALIGNED 0

Functions
template<typename T >
void	Eigen::internal::aligned_delete (T *ptr, size_t size)

void	Eigen::internal::aligned_free (void *ptr)

void *	Eigen::internal::aligned_malloc (std::size_t size)

void *	Eigen::internal::aligned_malloc (size_t size)

template<typename T >
T *	Eigen::internal::aligned_new (size_t size)

void *	Eigen::internal::aligned_realloc (void *ptr, size_t new_size, size_t old_size)

template<typename T >
EIGEN_ALWAYS_INLINE void	Eigen::internal::check_size_for_overflow (size_t size)

void	Eigen::internal::check_that_malloc_is_allowed ()

template<typename T , bool Align>
void	Eigen::internal::conditional_aligned_delete (T *ptr, size_t size)

template<typename T , bool Align>
void	Eigen::internal::conditional_aligned_delete_auto (T *ptr, size_t size)

template<bool Align>
void	Eigen::internal::conditional_aligned_free (void *ptr)

template<>
void	Eigen::internal::conditional_aligned_free< false > (void *ptr)

template<bool Align>
void *	Eigen::internal::conditional_aligned_malloc (size_t size)

template<>
void *	Eigen::internal::conditional_aligned_malloc< false > (size_t size)

template<typename T , bool Align>
T *	Eigen::internal::conditional_aligned_new (size_t size)

template<typename T , bool Align>
T *	Eigen::internal::conditional_aligned_new_auto (size_t size)

template<bool Align>
void *	Eigen::internal::conditional_aligned_realloc (void *ptr, size_t new_size, size_t old_size)

template<>
void *	Eigen::internal::conditional_aligned_realloc< false > (void *ptr, size_t new_size, size_t)

template<typename T , bool Align>
T *	Eigen::internal::conditional_aligned_realloc_new (T *pts, size_t new_size, size_t old_size)

template<typename T , bool Align>
T *	Eigen::internal::conditional_aligned_realloc_new_auto (T *pts, size_t new_size, size_t old_size)

template<typename T >
T *	Eigen::internal::construct_elements_of_array (T *ptr, size_t size)

template<typename T >
void	Eigen::internal::destruct_elements_of_array (T *ptr, size_t size)

template<typename Scalar , typename Index >
static Index	Eigen::internal::first_aligned (const Scalar *array, Index size)

template<typename Index >
static Index	Eigen::internal::first_multiple (Index size, Index base)

void *	Eigen::internal::generic_aligned_realloc (void *ptr, size_t size, size_t old_size)

void	Eigen::internal::handmade_aligned_free (void *ptr)

void *	Eigen::internal::handmade_aligned_malloc (std::size_t size)

void *	Eigen::internal::handmade_aligned_realloc (void *ptr, std::size_t size, std::size_t=0)

void	Eigen::internal::queryCacheSizes (int &l1, int &l2, int &l3)

int	Eigen::internal::queryL1CacheSize ()

int	Eigen::internal::queryTopLevelCacheSize ()

template<typename T >
void	Eigen::internal::smart_copy (const T start, const T end, T *target)

void	Eigen::internal::throw_std_bad_alloc ()

Macro Definition Documentation

#define ei_declare_aligned_stack_constructed_variable	(	TYPE,
		NAME,
		SIZE,
		BUFFER
	)

Value:

Eigen::internal::check_size_for_overflow<TYPE>(SIZE); \
    TYPE* NAME = (BUFFER)!=0 ? BUFFER : reinterpret_cast<TYPE*>(Eigen::internal::aligned_malloc(sizeof(TYPE)*SIZE));    \
    Eigen::internal::aligned_stack_memory_handler<TYPE> EIGEN_CAT(NAME,_stack_memory_destructor)((BUFFER)==0 ? NAME : 0,SIZE,true)

Definition at line 597 of file Core/util/Memory.h.

#define EIGEN_FREEBSD_MALLOC_ALREADY_ALIGNED 0

Definition at line 47 of file Core/util/Memory.h.

#define EIGEN_GLIBC_MALLOC_ALREADY_ALIGNED 0

Definition at line 37 of file Core/util/Memory.h.

#define EIGEN_HAS_MM_MALLOC 0

Definition at line 78 of file Core/util/Memory.h.

#define EIGEN_HAS_POSIX_MEMALIGN 0

Definition at line 72 of file Core/util/Memory.h.

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(true)

Definition at line 648 of file Core/util/Memory.h.

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF ( NeedsToAlign )

Definition at line 645 of file Core/util/Memory.h.

#define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF_VECTORIZABLE_FIXED_SIZE	(	Scalar,
		Size
	)	EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(bool(((Size)!=Eigen::Dynamic) && ((sizeof(Scalar)*(Size))%16==0)))

Definition at line 649 of file Core/util/Memory.h.

#define EIGEN_MALLOC_ALREADY_ALIGNED 0

Definition at line 56 of file Core/util/Memory.h.

Classes

Namespaces

Macros

Functions

Macro Definition Documentation