diff options
Diffstat (limited to 'Eigen/src/Core/util')
-rw-r--r-- | Eigen/src/Core/util/CMakeLists.txt | 6 | ||||
-rw-r--r-- | Eigen/src/Core/util/ForwardDeclarations.h | 125 | ||||
-rw-r--r-- | Eigen/src/Core/util/Util.h | 273 |
3 files changed, 404 insertions, 0 deletions
diff --git a/Eigen/src/Core/util/CMakeLists.txt b/Eigen/src/Core/util/CMakeLists.txt new file mode 100644 index 000000000..9ab9fc8b0 --- /dev/null +++ b/Eigen/src/Core/util/CMakeLists.txt @@ -0,0 +1,6 @@ +FILE(GLOB Eigen_Core_util_SRCS "*.h") + +INSTALL(FILES + ${Eigen_Core_SRCS} + DESTINATION ${INCLUDE_INSTALL_DIR}/Eigen/src/Core/util + ) diff --git a/Eigen/src/Core/util/ForwardDeclarations.h b/Eigen/src/Core/util/ForwardDeclarations.h new file mode 100644 index 000000000..a7f269cb4 --- /dev/null +++ b/Eigen/src/Core/util/ForwardDeclarations.h @@ -0,0 +1,125 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. Eigen itself is part of the KDE project. +// +// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.fr> +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see <http://www.gnu.org/licenses/>. + +#ifndef EIGEN_FORWARDDECLARATIONS_H +#define EIGEN_FORWARDDECLARATIONS_H + +template<typename T> struct ei_traits; +template<typename Lhs, typename Rhs> struct ei_product_eval_mode; +template<typename T> struct NumTraits; + +template<typename _Scalar, int _Rows, int _Cols, unsigned int _Flags, int _MaxRows, int _MaxCols> class Matrix; +template<typename ExpressionType> class Lazy; +template<typename ExpressionType> class Temporary; +template<typename MatrixType> class Minor; +template<typename MatrixType, int BlockRows=Dynamic, int BlockCols=Dynamic> class Block; +template<typename MatrixType> class Transpose; +template<typename MatrixType> class Conjugate; +template<typename BinaryOp, typename Lhs, typename Rhs> class CwiseBinaryOp; +template<typename UnaryOp, typename MatrixType> class CwiseUnaryOp; +template<typename Lhs, typename Rhs, int EvalMode=ei_product_eval_mode<Lhs,Rhs>::value> class Product; +template<typename MatrixType> class Random; +template<typename MatrixType> class Zero; +template<typename MatrixType> class Ones; +template<typename CoeffsVectorType> class DiagonalMatrix; +template<typename MatrixType> class DiagonalCoeffs; +template<typename MatrixType> class Identity; +template<typename MatrixType> class Map; +template<typename Derived> class Eval; +template<typename Derived> class EvalOMP; +template<int Direction, typename UnaryOp, typename MatrixType> class PartialRedux; + +template<typename Scalar> struct ei_scalar_sum_op; +template<typename Scalar> struct ei_scalar_difference_op; +template<typename Scalar> struct ei_scalar_product_op; +template<typename Scalar> struct ei_scalar_quotient_op; +template<typename Scalar> struct ei_scalar_opposite_op; +template<typename Scalar> struct ei_scalar_conjugate_op; +template<typename Scalar> struct ei_scalar_abs_op; +template<typename Scalar> struct ei_scalar_abs2_op; +template<typename Scalar> struct ei_scalar_sqrt_op; +template<typename Scalar> struct ei_scalar_exp_op; +template<typename Scalar> struct ei_scalar_log_op; +template<typename Scalar> struct ei_scalar_cos_op; +template<typename Scalar> struct ei_scalar_sin_op; +template<typename Scalar> struct ei_scalar_pow_op; +template<typename Scalar, typename NewType> struct ei_scalar_cast_op; +template<typename Scalar, bool IsVectorizable> struct ei_scalar_multiple_op; +template<typename Scalar> struct ei_scalar_quotient1_op; +template<typename Scalar> struct ei_scalar_min_op; +template<typename Scalar> struct ei_scalar_max_op; + +template<typename T> struct ei_eval +{ + typedef Matrix<typename ei_traits<T>::Scalar, + ei_traits<T>::RowsAtCompileTime, + ei_traits<T>::ColsAtCompileTime, + ei_traits<T>::Flags & ~(EvalBeforeNestingBit | EvalBeforeAssigningBit), + ei_traits<T>::MaxRowsAtCompileTime, + ei_traits<T>::MaxColsAtCompileTime> type; +}; + +template<typename T> struct ei_unref { typedef T type; }; +template<typename T> struct ei_unref<T&> { typedef T type; }; + +template<typename T> struct ei_is_temporary +{ + enum { ret = 0 }; +}; + +template<typename T> struct ei_is_temporary<Temporary<T> > +{ + enum { ret = 1 }; +}; + +template<typename T, int n=1> struct ei_nested +{ + typedef typename ei_meta_if< + ei_is_temporary<T>::ret, + T, + typename ei_meta_if< + ei_traits<T>::Flags & EvalBeforeNestingBit + || (n+1) * NumTraits<typename ei_traits<T>::Scalar>::ReadCost < (n-1) * T::CoeffReadCost, + typename ei_eval<T>::type, + const T& + >::ret + >::ret type; +}; + +template<typename T> struct ei_functor_traits +{ + enum + { + Cost = 10, + IsVectorizable = false + }; +}; + +template<typename T> struct ei_packet_traits +{ + typedef T type; + enum {size=1}; +}; + +#endif // EIGEN_FORWARDDECLARATIONS_H diff --git a/Eigen/src/Core/util/Util.h b/Eigen/src/Core/util/Util.h new file mode 100644 index 000000000..de45927ce --- /dev/null +++ b/Eigen/src/Core/util/Util.h @@ -0,0 +1,273 @@ +// This file is part of Eigen, a lightweight C++ template library +// for linear algebra. Eigen itself is part of the KDE project. +// +// Copyright (C) 2008 Gael Guennebaud <g.gael@free.fr> +// Copyright (C) 2006-2008 Benoit Jacob <jacob@math.jussieu.fr> +// +// Eigen is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 3 of the License, or (at your option) any later version. +// +// Alternatively, you can redistribute it and/or +// modify it under the terms of the GNU General Public License as +// published by the Free Software Foundation; either version 2 of +// the License, or (at your option) any later version. +// +// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +// FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License or the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License and a copy of the GNU General Public License along with +// Eigen. If not, see <http://www.gnu.org/licenses/>. + +#ifndef EIGEN_UTIL_H +#define EIGEN_UTIL_H + +#ifdef EIGEN_VECTORIZE +#ifdef EIGEN_INTEL_PLATFORM +#include <emmintrin.h> +#include <xmmintrin.h> +#else +#undef EIGEN_VECTORIZE +#endif +#endif + +#ifdef EIGEN_DONT_USE_UNROLLED_LOOPS +#define EIGEN_UNROLLING_LIMIT 0 +#endif + +/** Defines the maximal loop size to enable meta unrolling of loops */ +#ifndef EIGEN_UNROLLING_LIMIT +#define EIGEN_UNROLLING_LIMIT 400 +#endif + +#ifdef EIGEN_DEFAULT_TO_ROW_MAJOR +#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER RowMajorBit +#else +#define EIGEN_DEFAULT_MATRIX_STORAGE_ORDER 0 +#endif + +#undef minor + +#define USING_PART_OF_NAMESPACE_EIGEN \ +EIGEN_USING_MATRIX_TYPEDEFS \ +using Eigen::Matrix; \ +using Eigen::MatrixBase; + +#ifdef NDEBUG +#define EIGEN_NO_DEBUG +#endif + +#ifndef ei_assert +#ifdef EIGEN_NO_DEBUG +#define ei_assert(x) +#else +#define ei_assert(x) assert(x) +#endif +#endif + +#ifdef EIGEN_INTERNAL_DEBUGGING +#define ei_internal_assert(x) ei_assert(x); +#else +#define ei_internal_assert(x) +#endif + +#ifdef EIGEN_NO_DEBUG +#define EIGEN_ONLY_USED_FOR_DEBUG(x) (void)x +#else +#define EIGEN_ONLY_USED_FOR_DEBUG(x) +#endif + +// FIXME with the always_inline attribute, +// gcc 3.4.x reports the following compilation error: +// Eval.h:91: sorry, unimplemented: inlining failed in call to 'const Eigen::Eval<Derived> Eigen::MatrixBase<Scalar, Derived>::eval() const' +// : function body not available +#if (defined __GNUC__) && (__GNUC__!=3) +#define EIGEN_ALWAYS_INLINE __attribute__((always_inline)) +#else +#define EIGEN_ALWAYS_INLINE +#endif + +#if (defined __GNUC__) +#define EIGEN_ALIGN_128 __attribute__ ((aligned(16))) +#else +#define EIGEN_ALIGN_128 +#endif + +#define EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \ +template<typename OtherDerived> \ +Derived& operator Op(const MatrixBase<OtherDerived>& other) \ +{ \ + return Eigen::MatrixBase<Derived>::operator Op(other); \ +} \ +Derived& operator Op(const Derived& other) \ +{ \ + return Eigen::MatrixBase<Derived>::operator Op(other); \ +} + +#define EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \ +template<typename Other> \ +Derived& operator Op(const Other& scalar) \ +{ \ + return Eigen::MatrixBase<Derived>::operator Op(scalar); \ +} + +#define EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Derived) \ +EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, =) \ +EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, +=) \ +EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, -=) \ +EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, *=) \ +EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=) + +#define _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, BaseClass) \ +typedef BaseClass Base; \ +typedef typename Eigen::ei_traits<Derived>::Scalar Scalar; \ +typedef typename Base::PacketScalar PacketScalar; \ +typedef typename Eigen::ei_nested<Derived>::type Nested; \ +typedef typename Eigen::ei_eval<Derived>::type Eval; \ +enum { RowsAtCompileTime = Base::RowsAtCompileTime, \ + ColsAtCompileTime = Base::ColsAtCompileTime, \ + MaxRowsAtCompileTime = Base::MaxRowsAtCompileTime, \ + MaxColsAtCompileTime = Base::MaxColsAtCompileTime, \ + SizeAtCompileTime = Base::SizeAtCompileTime, \ + MaxSizeAtCompileTime = Base::MaxSizeAtCompileTime, \ + IsVectorAtCompileTime = Base::IsVectorAtCompileTime, \ + Flags = Base::Flags, \ + CoeffReadCost = Base::CoeffReadCost }; + +#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \ +_EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, Eigen::MatrixBase<Derived>) \ +friend class Eigen::MatrixBase<Derived>; + +#define EIGEN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b) + +const int Dynamic = 10000; + +// matrix/expression flags +const unsigned int RowMajorBit = 0x1; +const unsigned int EvalBeforeNestingBit = 0x2; +const unsigned int EvalBeforeAssigningBit = 0x4; +const unsigned int LargeBit = 0x8; +#ifdef EIGEN_VECTORIZE +const unsigned int VectorizableBit = 0x10; +#else +const unsigned int VectorizableBit = 0x0; +#endif + + +enum { ConditionalJumpCost = 5 }; + +enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight }; + +enum DirectionType { Vertical, Horizontal }; + +enum ProductEvaluationMode { UnrolledDotProduct, CacheOptimal }; + +// just a workaround because GCC seems to not really like empty structs +#ifdef __GNUG__ + struct ei_empty_struct{char _ei_dummy_;}; + #define EIGEN_EMPTY_STRUCT : Eigen::ei_empty_struct +#else + #define EIGEN_EMPTY_STRUCT +#endif + +//classes inheriting ei_no_assignment_operator don't generate a default operator=. +class ei_no_assignment_operator +{ + private: + ei_no_assignment_operator& operator=(const ei_no_assignment_operator&); +}; + +template<int Value> class ei_int_if_dynamic EIGEN_EMPTY_STRUCT +{ + public: + ei_int_if_dynamic() {} + explicit ei_int_if_dynamic(int) {} + static int value() { return Value; } + void setValue(int) {} +}; + +template<> class ei_int_if_dynamic<Dynamic> +{ + int m_value; + ei_int_if_dynamic() {} + public: + explicit ei_int_if_dynamic(int value) : m_value(value) {} + int value() const { return m_value; } + void setValue(int value) { m_value = value; } +}; + + +template <bool Condition, class Then, class Else> +struct ei_meta_if { typedef Then ret; }; + +template <class Then, class Else> +struct ei_meta_if <false, Then, Else> { typedef Else ret; }; + +template<typename T, typename U> struct ei_is_same_type { enum { ret = 0 }; }; +template<typename T> struct ei_is_same_type<T,T> { enum { ret = 1 }; }; + + +/** \internal + * Convenient struct to get the result type of a unary or binary functor. + * + * It supports both the current STL mechanism (using the result_type member) as well as + * upcoming next STL generation (using a templated result member). + * If none of these members is provided, then the type of the first argument is returned. + */ +template<typename T> struct ei_result_of {}; + +struct ei_has_none {int a[1];}; +struct ei_has_std_result_type {int a[2];}; +struct ei_has_tr1_result {int a[3];}; + +template<typename Func, typename ArgType, int SizeOf=sizeof(ei_has_none)> +struct ei_unary_result_of_select {typedef ArgType type;}; + +template<typename Func, typename ArgType> +struct ei_unary_result_of_select<Func, ArgType, sizeof(ei_has_std_result_type)> {typedef typename Func::result_type type;}; + +template<typename Func, typename ArgType> +struct ei_unary_result_of_select<Func, ArgType, sizeof(ei_has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;}; + +template<typename Func, typename ArgType> +struct ei_result_of<Func(ArgType)> { + template<typename T> + static ei_has_std_result_type testFunctor(T const *, typename T::result_type const * = 0); + template<typename T> + static ei_has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0); + static ei_has_none testFunctor(...); + + // note that the following indirection is needed for gcc-3.3 + enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))}; + typedef typename ei_unary_result_of_select<Func, ArgType, FunctorType>::type type; +}; + +template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(ei_has_none)> +struct ei_binary_result_of_select {typedef ArgType0 type;}; + +template<typename Func, typename ArgType0, typename ArgType1> +struct ei_binary_result_of_select<Func, ArgType0, ArgType1, sizeof(ei_has_std_result_type)> +{typedef typename Func::result_type type;}; + +template<typename Func, typename ArgType0, typename ArgType1> +struct ei_binary_result_of_select<Func, ArgType0, ArgType1, sizeof(ei_has_tr1_result)> +{typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;}; + +template<typename Func, typename ArgType0, typename ArgType1> +struct ei_result_of<Func(ArgType0,ArgType1)> { + template<typename T> + static ei_has_std_result_type testFunctor(T const *, typename T::result_type const * = 0); + template<typename T> + static ei_has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0); + static ei_has_none testFunctor(...); + + // note that the following indirection is needed for gcc-3.3 + enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))}; + typedef typename ei_binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type; +}; + +#endif // EIGEN_UTIL_H |