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 MLN_VALUE_INTERNAL_LIMITS_HH
00027 # define MLN_VALUE_INTERNAL_LIMITS_HH
00028
00032
00033 # if defined(__GNUC__) && __GNUC__ < 3
00034 # include <cfloat>
00035 # include <climits>
00036 # else
00037 # include <limits>
00038 # endif
00039
00040 namespace mln
00041 {
00042
00043 namespace value
00044 {
00045
00046 namespace internal
00047 {
00048
00049 template<typename T>
00050 struct limits
00051 # if !defined(__GNUC__) || __GNUC__ >= 3
00052 : std::numeric_limits<T>
00053 { };
00054 # else
00055 {
00056 static const bool is_specialized = false;
00057 };
00058
00059 template<>
00060 struct limits<bool>
00061 {
00062 static bool min() throw() { return false; }
00063 static bool max() throw() { return false; }
00064 static bool epsilon() throw()
00065 { return false; }
00066 };
00067
00068 template<>
00069 struct limits<char>
00070 {
00071 static char min() throw() { return CHAR_MIN; }
00072 static char max() throw() { return CHAR_MAX; }
00073 static char epsilon() throw()
00074 { return 0; }
00075 };
00076
00077 template<>
00078 struct limits<signed char>
00079 {
00080 static signed char min() throw() { return SCHAR_MIN; }
00081 static signed char max() throw() { return SCHAR_MAX; }
00082 static signed char epsilon() throw()
00083 { return 0; }
00084 };
00085
00086 template<>
00087 struct limits<unsigned char>
00088 {
00089 static unsigned char min() throw() { return 0; }
00090 static unsigned char max() throw() { return UCHAR_MAX; }
00091 static unsigned char epsilon() throw()
00092 { return 0; }
00093 };
00094
00095 template<>
00096 struct limits<short>
00097 {
00098 static short min() throw() { return SHRT_MIN; }
00099 static short max() throw() { return SHRT_MAX; }
00100 static short epsilon() throw()
00101 { return 0; }
00102 };
00103
00104 template<>
00105 struct limits<unsigned short>
00106 {
00107 static unsigned short min() throw() { return 0; }
00108 static unsigned short max() throw() { return USHRT_MAX; }
00109 static unsigned short epsilon() throw()
00110 { return 0; }
00111 };
00112
00113 template<>
00114 struct limits<int>
00115 {
00116 static int min() throw() { return INT_MIN; }
00117 static int max() throw() { return INT_MAX; }
00118 static int epsilon() throw()
00119 { return 0; }
00120 };
00121
00122 template<>
00123 struct limits<unsigned int>
00124 {
00125 static unsigned int min() throw() { return 0; }
00126 static unsigned int max() throw() { return UINT_MAX; }
00127 static unsigned int epsilon() throw()
00128 { return 0; }
00129 };
00130
00131 template<>
00132 struct limits<long>
00133 {
00134 static long min() throw() { return LONG_MIN; }
00135 static long max() throw() { return LONG_MAX; }
00136 static long epsilon() throw()
00137 { return 0; }
00138 };
00139
00140 template<>
00141 struct limits<unsigned long>
00142 {
00143 static unsigned long min() throw() { return 0; }
00144 static unsigned long max() throw() { return ULONG_MAX; }
00145 static unsigned long epsilon() throw()
00146 { return 0; }
00147 };
00148
00149
00150
00151
00152
00153
00154
00155 # if defined(HAVE_LONG_LONG) && !defined(LONGLONG_MIN)
00156 # define LONGLONG_MIN((long long) 0x8000000000000000LL)
00157 # define LONGLONG_MAX((long long) 0x7FFFFFFFFFFFFFFFLL)
00158 # endif
00159
00160
00161 # if defined(HAVE_LONG_LONG) && !defined(ULONGLONG_MAX)
00162
00163 # ifdef ULLONG_MAX
00164 # define ULONGLONG_MAX ULLONG_MAX
00165 # else
00166 # define ULONGLONG_MAX ((unsigned long long)(~0ULL))
00167 # endif
00168
00169 # endif
00170
00171
00172 # if defined(HAVE_LONG_LONG)
00173 template<>
00174 struct limits<long long>
00175 {
00176 static long long min() throw() { return LONGLONG_MIN; }
00177 static long long max() throw() { return LONGLONG_MAX; }
00178 static long long epsilon() throw()
00179 { return 0; }
00180 };
00181
00182 template<>
00183 struct limits<unsigned long long>
00184 {
00185 static unsigned long long min() throw() { return 0; }
00186 static unsigned long long max() throw() { return ULONGLONG_MAX; }
00187 static unsigned long long epsilon() throw()
00188 { return 0; }
00189 };
00190 # endif
00191
00192 template<>
00193 struct limits<float>
00194 {
00195 static float min() throw() { return FLT_MIN; }
00196 static float max() throw() { return FLT_MAX; }
00197 static float epsilon() throw()
00198 { return FLT_EPSILON; }
00199 };
00200
00201 template<>
00202 struct limits<double>
00203 {
00204 static float min() throw() { return DBL_MIN; }
00205 static float max() throw() { return DBL_MAX; }
00206 static float epsilon() throw()
00207 { return DBL_EPSILON; }
00208 };
00209
00210 # endif
00211 }
00212
00213 }
00214
00215 }
00216
00217 #endif // ! MLN_VALUE_INTERNAL_LIMITS_HH