00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef EIGEN_META_H
00027 #define EIGEN_META_H
00028
00029 namespace Eigen {
00030
00031 namespace internal {
00032
00040 struct true_type { enum { value = 1 }; };
00041 struct false_type { enum { value = 0 }; };
00042
00043 template<bool Condition, typename Then, typename Else>
00044 struct conditional { typedef Then type; };
00045
00046 template<typename Then, typename Else>
00047 struct conditional <false, Then, Else> { typedef Else type; };
00048
00049 template<typename T, typename U> struct is_same { enum { value = 0 }; };
00050 template<typename T> struct is_same<T,T> { enum { value = 1 }; };
00051
00052 template<typename T> struct remove_reference { typedef T type; };
00053 template<typename T> struct remove_reference<T&> { typedef T type; };
00054
00055 template<typename T> struct remove_pointer { typedef T type; };
00056 template<typename T> struct remove_pointer<T*> { typedef T type; };
00057 template<typename T> struct remove_pointer<T*const> { typedef T type; };
00058
00059 template <class T> struct remove_const { typedef T type; };
00060 template <class T> struct remove_const<const T> { typedef T type; };
00061 template <class T> struct remove_const<const T[]> { typedef T type[]; };
00062 template <class T, unsigned int Size> struct remove_const<const T[Size]> { typedef T type[Size]; };
00063
00064 template<typename T> struct remove_all { typedef T type; };
00065 template<typename T> struct remove_all<const T> { typedef typename remove_all<T>::type type; };
00066 template<typename T> struct remove_all<T const&> { typedef typename remove_all<T>::type type; };
00067 template<typename T> struct remove_all<T&> { typedef typename remove_all<T>::type type; };
00068 template<typename T> struct remove_all<T const*> { typedef typename remove_all<T>::type type; };
00069 template<typename T> struct remove_all<T*> { typedef typename remove_all<T>::type type; };
00070
00071 template<typename T> struct is_arithmetic { enum { value = false }; };
00072 template<> struct is_arithmetic<float> { enum { value = true }; };
00073 template<> struct is_arithmetic<double> { enum { value = true }; };
00074 template<> struct is_arithmetic<long double> { enum { value = true }; };
00075 template<> struct is_arithmetic<bool> { enum { value = true }; };
00076 template<> struct is_arithmetic<char> { enum { value = true }; };
00077 template<> struct is_arithmetic<signed char> { enum { value = true }; };
00078 template<> struct is_arithmetic<unsigned char> { enum { value = true }; };
00079 template<> struct is_arithmetic<signed short> { enum { value = true }; };
00080 template<> struct is_arithmetic<unsigned short>{ enum { value = true }; };
00081 template<> struct is_arithmetic<signed int> { enum { value = true }; };
00082 template<> struct is_arithmetic<unsigned int> { enum { value = true }; };
00083 template<> struct is_arithmetic<signed long> { enum { value = true }; };
00084 template<> struct is_arithmetic<unsigned long> { enum { value = true }; };
00085
00086 template <typename T> struct add_const { typedef const T type; };
00087 template <typename T> struct add_const<T&> { typedef T& type; };
00088
00089 template <typename T> struct is_const { enum { value = 0 }; };
00090 template <typename T> struct is_const<T const> { enum { value = 1 }; };
00091
00092 template<typename T> struct add_const_on_value_type { typedef const T type; };
00093 template<typename T> struct add_const_on_value_type<T&> { typedef T const& type; };
00094 template<typename T> struct add_const_on_value_type<T*> { typedef T const* type; };
00095 template<typename T> struct add_const_on_value_type<T* const> { typedef T const* const type; };
00096 template<typename T> struct add_const_on_value_type<T const* const> { typedef T const* const type; };
00097
00101 template<bool Condition, typename T> struct enable_if;
00102
00103 template<typename T> struct enable_if<true,T>
00104 { typedef T type; };
00105
00106
00107
00111 class noncopyable
00112 {
00113 noncopyable(const noncopyable&);
00114 const noncopyable& operator=(const noncopyable&);
00115 protected:
00116 noncopyable() {}
00117 ~noncopyable() {}
00118 };
00119
00120
00128 template<typename T> struct result_of {};
00129
00130 struct has_none {int a[1];};
00131 struct has_std_result_type {int a[2];};
00132 struct has_tr1_result {int a[3];};
00133
00134 template<typename Func, typename ArgType, int SizeOf=sizeof(has_none)>
00135 struct unary_result_of_select {typedef ArgType type;};
00136
00137 template<typename Func, typename ArgType>
00138 struct unary_result_of_select<Func, ArgType, sizeof(has_std_result_type)> {typedef typename Func::result_type type;};
00139
00140 template<typename Func, typename ArgType>
00141 struct unary_result_of_select<Func, ArgType, sizeof(has_tr1_result)> {typedef typename Func::template result<Func(ArgType)>::type type;};
00142
00143 template<typename Func, typename ArgType>
00144 struct result_of<Func(ArgType)> {
00145 template<typename T>
00146 static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0);
00147 template<typename T>
00148 static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType)>::type const * = 0);
00149 static has_none testFunctor(...);
00150
00151
00152 enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
00153 typedef typename unary_result_of_select<Func, ArgType, FunctorType>::type type;
00154 };
00155
00156 template<typename Func, typename ArgType0, typename ArgType1, int SizeOf=sizeof(has_none)>
00157 struct binary_result_of_select {typedef ArgType0 type;};
00158
00159 template<typename Func, typename ArgType0, typename ArgType1>
00160 struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_std_result_type)>
00161 {typedef typename Func::result_type type;};
00162
00163 template<typename Func, typename ArgType0, typename ArgType1>
00164 struct binary_result_of_select<Func, ArgType0, ArgType1, sizeof(has_tr1_result)>
00165 {typedef typename Func::template result<Func(ArgType0,ArgType1)>::type type;};
00166
00167 template<typename Func, typename ArgType0, typename ArgType1>
00168 struct result_of<Func(ArgType0,ArgType1)> {
00169 template<typename T>
00170 static has_std_result_type testFunctor(T const *, typename T::result_type const * = 0);
00171 template<typename T>
00172 static has_tr1_result testFunctor(T const *, typename T::template result<T(ArgType0,ArgType1)>::type const * = 0);
00173 static has_none testFunctor(...);
00174
00175
00176 enum {FunctorType = sizeof(testFunctor(static_cast<Func*>(0)))};
00177 typedef typename binary_result_of_select<Func, ArgType0, ArgType1, FunctorType>::type type;
00178 };
00179
00183 template<int Y,
00184 int InfX = 0,
00185 int SupX = ((Y==1) ? 1 : Y/2),
00186 bool Done = ((SupX-InfX)<=1 ? true : ((SupX*SupX <= Y) && ((SupX+1)*(SupX+1) > Y))) >
00187
00188 class meta_sqrt
00189 {
00190 enum {
00191 MidX = (InfX+SupX)/2,
00192 TakeInf = MidX*MidX > Y ? 1 : 0,
00193 NewInf = int(TakeInf) ? InfX : int(MidX),
00194 NewSup = int(TakeInf) ? int(MidX) : SupX
00195 };
00196 public:
00197 enum { ret = meta_sqrt<Y,NewInf,NewSup>::ret };
00198 };
00199
00200 template<int Y, int InfX, int SupX>
00201 class meta_sqrt<Y, InfX, SupX, true> { public: enum { ret = (SupX*SupX <= Y) ? SupX : InfX }; };
00202
00204 template<typename T, typename U> struct scalar_product_traits;
00205
00206 template<typename T> struct scalar_product_traits<T,T>
00207 {
00208
00209 typedef T ReturnType;
00210 };
00211
00212 template<typename T> struct scalar_product_traits<T,std::complex<T> >
00213 {
00214
00215 typedef std::complex<T> ReturnType;
00216 };
00217
00218 template<typename T> struct scalar_product_traits<std::complex<T>, T>
00219 {
00220
00221 typedef std::complex<T> ReturnType;
00222 };
00223
00224
00225
00226
00227
00228
00229
00230 template<typename T> struct is_diagonal
00231 { enum { ret = false }; };
00232
00233 template<typename T> struct is_diagonal<DiagonalBase<T> >
00234 { enum { ret = true }; };
00235
00236 template<typename T> struct is_diagonal<DiagonalWrapper<T> >
00237 { enum { ret = true }; };
00238
00239 template<typename T, int S> struct is_diagonal<DiagonalMatrix<T,S> >
00240 { enum { ret = true }; };
00241
00242 }
00243
00244 }
00245
00246 #endif // EIGEN_META_H