00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #ifndef PPL_checked_int_inlines_hh
00024 #define PPL_checked_int_inlines_hh 1
00025
00026 #include "C_Integer.hh"
00027 #include <cerrno>
00028 #include <cstdlib>
00029 #include <climits>
00030 #include <string>
00031
00032 #if !PPL_HAVE_DECL_STRTOLL
00033 signed long long
00034 strtoll(const char* nptr, char** endptr, int base);
00035 #endif
00036
00037 #if !PPL_HAVE_DECL_STRTOULL
00038 unsigned long long
00039 strtoull(const char* nptr, char** endptr, int base);
00040 #endif
00041
00042 namespace Parma_Polyhedra_Library {
00043
00044 namespace Checked {
00045
00046 #ifndef PPL_HAVE_INT_FAST16_T
00047 typedef int16_t int_fast16_t;
00048 #endif
00049
00050 #ifndef PPL_HAVE_INT_FAST32_T
00051 typedef int32_t int_fast32_t;
00052 #endif
00053
00054 #ifndef PPL_HAVE_INT_FAST64_T
00055 typedef int64_t int_fast64_t;
00056 #endif
00057
00058 #ifndef PPL_HAVE_UINT_FAST16_T
00059 typedef uint16_t uint_fast16_t;
00060 #endif
00061
00062 #ifndef PPL_HAVE_UINT_FAST32_T
00063 typedef uint32_t uint_fast32_t;
00064 #endif
00065
00066 #ifndef PPL_HAVE_UINT_FAST64_T
00067 typedef uint64_t uint_fast64_t;
00068 #endif
00069
00070 template <typename Policy, typename Type>
00071 struct Extended_Int {
00072 static const Type plus_infinity = C_Integer<Type>::max;
00073 static const Type minus_infinity = (C_Integer<Type>::min >= 0
00074 ? C_Integer<Type>::max - 1
00075 : C_Integer<Type>::min);
00076 static const Type not_a_number = (C_Integer<Type>::min >= 0
00077 ? C_Integer<Type>::max - Policy::has_infinity * 2
00078 : C_Integer<Type>::min + Policy::has_infinity);
00079 static const Type min = (C_Integer<Type>::min
00080 + (C_Integer<Type>::min >= 0 ? 0
00081 : (Policy::has_infinity + Policy::has_nan)));
00082 static const Type max = (C_Integer<Type>::max
00083 - (C_Integer<Type>::min >= 0
00084 ? (2 * Policy::has_infinity + Policy::has_nan)
00085 : Policy::has_infinity));
00086 };
00087
00088 template <typename Policy, typename To>
00089 inline Result
00090 set_neg_overflow_int(To& to, Rounding_Dir dir) {
00091 if (round_up(dir)) {
00092 to = Extended_Int<Policy, To>::min;
00093 return V_LT;
00094 }
00095 else {
00096 if (Policy::has_infinity) {
00097 to = Extended_Int<Policy, To>::minus_infinity;
00098 return V_GT;
00099 }
00100 return V_NEG_OVERFLOW;
00101 }
00102 }
00103
00104 template <typename Policy, typename To>
00105 inline Result
00106 set_pos_overflow_int(To& to, Rounding_Dir dir) {
00107 if (round_down(dir)) {
00108 to = Extended_Int<Policy, To>::max;
00109 return V_GT;
00110 }
00111 else {
00112 if (Policy::has_infinity) {
00113 to = Extended_Int<Policy, To>::plus_infinity;
00114 return V_LT;
00115 }
00116 return V_POS_OVERFLOW;
00117 }
00118 }
00119
00120 template <typename Policy, typename To>
00121 inline Result
00122 round_lt_int_no_overflow(To& to, Rounding_Dir dir) {
00123 if (round_down(dir)) {
00124 --to;
00125 return V_GT;
00126 }
00127 return V_LT;
00128 }
00129
00130 template <typename Policy, typename To>
00131 inline Result
00132 round_gt_int_no_overflow(To& to, Rounding_Dir dir) {
00133 if (round_up(dir)) {
00134 ++to;
00135 return V_LT;
00136 }
00137 return V_GT;
00138 }
00139
00140 template <typename Policy, typename To>
00141 inline Result
00142 round_lt_int(To& to, Rounding_Dir dir) {
00143 if (round_down(dir)) {
00144 if (to == Extended_Int<Policy, To>::min) {
00145 if (Policy::has_infinity) {
00146 to = Extended_Int<Policy, To>::minus_infinity;
00147 return V_GT;
00148 }
00149 return V_NEG_OVERFLOW;
00150 }
00151 else {
00152 --to;
00153 return V_GT;
00154 }
00155 }
00156 return V_LT;
00157 }
00158
00159 template <typename Policy, typename To>
00160 inline Result
00161 round_gt_int(To& to, Rounding_Dir dir) {
00162 if (round_up(dir)) {
00163 if (to == Extended_Int<Policy, To>::max) {
00164 if (Policy::has_infinity) {
00165 to = Extended_Int<Policy, To>::plus_infinity;
00166 return V_LT;
00167 }
00168 return V_POS_OVERFLOW;
00169 }
00170 else {
00171 ++to;
00172 return V_LT;
00173 }
00174 }
00175 return V_GT;
00176 }
00177
00178 SPECIALIZE_COPY(copy_generic, signed char)
00179 SPECIALIZE_COPY(copy_generic, signed short)
00180 SPECIALIZE_COPY(copy_generic, signed int)
00181 SPECIALIZE_COPY(copy_generic, signed long)
00182 SPECIALIZE_COPY(copy_generic, signed long long)
00183 SPECIALIZE_COPY(copy_generic, unsigned char)
00184 SPECIALIZE_COPY(copy_generic, unsigned short)
00185 SPECIALIZE_COPY(copy_generic, unsigned int)
00186 SPECIALIZE_COPY(copy_generic, unsigned long)
00187 SPECIALIZE_COPY(copy_generic, unsigned long long)
00188
00189 template <typename Policy, typename Type>
00190 inline Result
00191 classify_int(const Type v, bool nan, bool inf, bool sign) {
00192 if (Policy::has_nan
00193 && (nan || sign)
00194 && v == Extended_Int<Policy, Type>::not_a_number)
00195 return VC_NAN;
00196 if (!inf & !sign)
00197 return VC_NORMAL;
00198 if (Policy::has_infinity) {
00199 if (v == Extended_Int<Policy, Type>::minus_infinity)
00200 return inf ? VC_MINUS_INFINITY : V_LT;
00201 if (v == Extended_Int<Policy, Type>::plus_infinity)
00202 return inf ? VC_PLUS_INFINITY : V_GT;
00203 }
00204 if (sign) {
00205 if (v < 0)
00206 return V_LT;
00207 if (v > 0)
00208 return V_GT;
00209 return V_EQ;
00210 }
00211 return VC_NORMAL;
00212 }
00213
00214 SPECIALIZE_CLASSIFY(classify_int, signed char)
00215 SPECIALIZE_CLASSIFY(classify_int, signed short)
00216 SPECIALIZE_CLASSIFY(classify_int, signed int)
00217 SPECIALIZE_CLASSIFY(classify_int, signed long)
00218 SPECIALIZE_CLASSIFY(classify_int, signed long long)
00219 SPECIALIZE_CLASSIFY(classify_int, unsigned char)
00220 SPECIALIZE_CLASSIFY(classify_int, unsigned short)
00221 SPECIALIZE_CLASSIFY(classify_int, unsigned int)
00222 SPECIALIZE_CLASSIFY(classify_int, unsigned long)
00223 SPECIALIZE_CLASSIFY(classify_int, unsigned long long)
00224
00225 template <typename Policy, typename Type>
00226 inline bool
00227 is_nan_int(const Type v) {
00228 return Policy::has_nan && v == Extended_Int<Policy, Type>::not_a_number;
00229 }
00230
00231 SPECIALIZE_IS_NAN(is_nan_int, signed char)
00232 SPECIALIZE_IS_NAN(is_nan_int, signed short)
00233 SPECIALIZE_IS_NAN(is_nan_int, signed int)
00234 SPECIALIZE_IS_NAN(is_nan_int, signed long)
00235 SPECIALIZE_IS_NAN(is_nan_int, signed long long)
00236 SPECIALIZE_IS_NAN(is_nan_int, unsigned char)
00237 SPECIALIZE_IS_NAN(is_nan_int, unsigned short)
00238 SPECIALIZE_IS_NAN(is_nan_int, unsigned int)
00239 SPECIALIZE_IS_NAN(is_nan_int, unsigned long)
00240 SPECIALIZE_IS_NAN(is_nan_int, unsigned long long)
00241
00242 template <typename Policy, typename Type>
00243 inline bool
00244 is_minf_int(const Type v) {
00245 return Policy::has_infinity
00246 && v == Extended_Int<Policy, Type>::minus_infinity;
00247 }
00248
00249 SPECIALIZE_IS_MINF(is_minf_int, signed char)
00250 SPECIALIZE_IS_MINF(is_minf_int, signed short)
00251 SPECIALIZE_IS_MINF(is_minf_int, signed int)
00252 SPECIALIZE_IS_MINF(is_minf_int, signed long)
00253 SPECIALIZE_IS_MINF(is_minf_int, signed long long)
00254 SPECIALIZE_IS_MINF(is_minf_int, unsigned char)
00255 SPECIALIZE_IS_MINF(is_minf_int, unsigned short)
00256 SPECIALIZE_IS_MINF(is_minf_int, unsigned int)
00257 SPECIALIZE_IS_MINF(is_minf_int, unsigned long)
00258 SPECIALIZE_IS_MINF(is_minf_int, unsigned long long)
00259
00260 template <typename Policy, typename Type>
00261 inline bool
00262 is_pinf_int(const Type v) {
00263 return Policy::has_infinity
00264 && v == Extended_Int<Policy, Type>::plus_infinity;
00265 }
00266
00267 SPECIALIZE_IS_PINF(is_pinf_int, signed char)
00268 SPECIALIZE_IS_PINF(is_pinf_int, signed short)
00269 SPECIALIZE_IS_PINF(is_pinf_int, signed int)
00270 SPECIALIZE_IS_PINF(is_pinf_int, signed long)
00271 SPECIALIZE_IS_PINF(is_pinf_int, signed long long)
00272 SPECIALIZE_IS_PINF(is_pinf_int, unsigned char)
00273 SPECIALIZE_IS_PINF(is_pinf_int, unsigned short)
00274 SPECIALIZE_IS_PINF(is_pinf_int, unsigned int)
00275 SPECIALIZE_IS_PINF(is_pinf_int, unsigned long)
00276 SPECIALIZE_IS_PINF(is_pinf_int, unsigned long long)
00277
00278 template <typename Policy, typename Type>
00279 inline bool
00280 is_int_int(const Type v) {
00281 return !is_nan<Policy>(v);
00282 }
00283
00284 SPECIALIZE_IS_INT(is_int_int, signed char)
00285 SPECIALIZE_IS_INT(is_int_int, signed short)
00286 SPECIALIZE_IS_INT(is_int_int, signed int)
00287 SPECIALIZE_IS_INT(is_int_int, signed long)
00288 SPECIALIZE_IS_INT(is_int_int, signed long long)
00289 SPECIALIZE_IS_INT(is_int_int, unsigned char)
00290 SPECIALIZE_IS_INT(is_int_int, unsigned short)
00291 SPECIALIZE_IS_INT(is_int_int, unsigned int)
00292 SPECIALIZE_IS_INT(is_int_int, unsigned long)
00293 SPECIALIZE_IS_INT(is_int_int, unsigned long long)
00294
00295 template <typename Policy, typename Type>
00296 inline Result
00297 assign_special_int(Type& v, Result r, Rounding_Dir dir) {
00298 Result t = classify(r);
00299 switch (t) {
00300 case VC_NAN:
00301 if (Policy::has_nan)
00302 v = Extended_Int<Policy, Type>::not_a_number;
00303 break;
00304 case VC_MINUS_INFINITY:
00305 if (Policy::has_infinity) {
00306 v = Extended_Int<Policy, Type>::minus_infinity;
00307 return V_EQ;
00308 }
00309 if (round_up(dir)) {
00310 v = Extended_Int<Policy, Type>::min;
00311 return V_LT;
00312 }
00313 break;
00314 case VC_PLUS_INFINITY:
00315 if (Policy::has_infinity) {
00316 v = Extended_Int<Policy, Type>::plus_infinity;
00317 return V_EQ;
00318 }
00319 if (round_down(dir)) {
00320 v = Extended_Int<Policy, Type>::max;
00321 return V_GT;
00322 }
00323 break;
00324 default:
00325 assert(0);
00326 break;
00327 }
00328 return r;
00329 }
00330
00331 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, signed char)
00332 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, signed short)
00333 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, signed int)
00334 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, signed long)
00335 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, signed long long)
00336 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, unsigned char)
00337 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, unsigned short)
00338 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, unsigned int)
00339 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, unsigned long)
00340 SPECIALIZE_ASSIGN_SPECIAL(assign_special_int, unsigned long long)
00341
00342 template <typename To_Policy, typename From_Policy, typename To, typename From>
00343 inline Result
00344 assign_signed_int_signed_int(To& to, const From from, Rounding_Dir dir) {
00345 if (sizeof(To) < sizeof(From)
00346 || (sizeof(To) == sizeof(From)
00347 && (Extended_Int<To_Policy, To>::min > Extended_Int<From_Policy, From>::min
00348 || Extended_Int<To_Policy, To>::max < Extended_Int<From_Policy, From>::max))) {
00349 if (CHECK_P(To_Policy::check_overflow,
00350 from < static_cast<From>(Extended_Int<To_Policy, To>::min)))
00351 return set_neg_overflow_int<To_Policy>(to, dir);
00352 if (CHECK_P(To_Policy::check_overflow,
00353 from > static_cast<From>(Extended_Int<To_Policy, To>::max)))
00354 return set_pos_overflow_int<To_Policy>(to, dir);
00355 }
00356 to = To(from);
00357 return V_EQ;
00358 }
00359
00360 template <typename To_Policy, typename From_Policy, typename To, typename From>
00361 inline Result
00362 assign_signed_int_unsigned_int(To& to, const From from, Rounding_Dir dir) {
00363 if (sizeof(To) <= sizeof(From)) {
00364 if (CHECK_P(To_Policy::check_overflow,
00365 from > static_cast<From>(Extended_Int<To_Policy, To>::max)))
00366 return set_pos_overflow_int<To_Policy>(to, dir);
00367 }
00368 to = To(from);
00369 return V_EQ;
00370 }
00371
00372 template <typename To_Policy, typename From_Policy, typename To, typename From>
00373 inline Result
00374 assign_unsigned_int_signed_int(To& to, const From from, Rounding_Dir dir) {
00375 if (CHECK_P(To_Policy::check_overflow, from < 0))
00376 return set_neg_overflow_int<To_Policy>(to, dir);
00377 if (sizeof(To) < sizeof(From)) {
00378 if (CHECK_P(To_Policy::check_overflow,
00379 from > static_cast<From>(Extended_Int<To_Policy, To>::max)))
00380 return set_pos_overflow_int<To_Policy>(to, dir);
00381 }
00382 to = To(from);
00383 return V_EQ;
00384 }
00385
00386 template <typename To_Policy, typename From_Policy, typename To, typename From>
00387 inline Result
00388 assign_unsigned_int_unsigned_int(To& to, const From from, Rounding_Dir dir) {
00389 if (sizeof(To) < sizeof(From)
00390 || (sizeof(To) == sizeof(From)
00391 && Extended_Int<To_Policy, To>::max < Extended_Int<From_Policy, From>::max)) {
00392 if (CHECK_P(To_Policy::check_overflow,
00393 from > static_cast<From>(Extended_Int<To_Policy, To>::max)))
00394 return set_pos_overflow_int<To_Policy>(to, dir);
00395 }
00396 to = To(from);
00397 return V_EQ;
00398 }
00399
00400
00401 #define ASSIGN2_SIGNED_SIGNED(Smaller, Larger) \
00402 SPECIALIZE_ASSIGN(assign_signed_int_signed_int, Smaller, Larger) \
00403 SPECIALIZE_ASSIGN(assign_signed_int_signed_int, Larger, Smaller)
00404
00405 #define ASSIGN2_UNSIGNED_UNSIGNED(Smaller, Larger) \
00406 SPECIALIZE_ASSIGN(assign_unsigned_int_unsigned_int, Smaller, Larger) \
00407 SPECIALIZE_ASSIGN(assign_unsigned_int_unsigned_int, Larger, Smaller)
00408
00409 #define ASSIGN2_UNSIGNED_SIGNED(Smaller, Larger) \
00410 SPECIALIZE_ASSIGN(assign_unsigned_int_signed_int, Smaller, Larger) \
00411 SPECIALIZE_ASSIGN(assign_signed_int_unsigned_int, Larger, Smaller)
00412
00413 #define ASSIGN2_SIGNED_UNSIGNED(Smaller, Larger) \
00414 SPECIALIZE_ASSIGN(assign_signed_int_unsigned_int, Smaller, Larger) \
00415 SPECIALIZE_ASSIGN(assign_unsigned_int_signed_int, Larger, Smaller)
00416
00417 #define ASSIGN_SIGNED(Type) \
00418 SPECIALIZE_ASSIGN(assign_signed_int_signed_int, Type, Type)
00419 #define ASSIGN_UNSIGNED(Type) \
00420 SPECIALIZE_ASSIGN(assign_unsigned_int_unsigned_int, Type, Type)
00421
00422 ASSIGN_SIGNED(signed char)
00423 ASSIGN_SIGNED(signed short)
00424 ASSIGN_SIGNED(signed int)
00425 ASSIGN_SIGNED(signed long)
00426 ASSIGN_SIGNED(signed long long)
00427 ASSIGN_UNSIGNED(unsigned char)
00428 ASSIGN_UNSIGNED(unsigned short)
00429 ASSIGN_UNSIGNED(unsigned int)
00430 ASSIGN_UNSIGNED(unsigned long)
00431 ASSIGN_UNSIGNED(unsigned long long)
00432
00433 ASSIGN2_SIGNED_SIGNED(signed char, signed short)
00434 ASSIGN2_SIGNED_SIGNED(signed char, signed int)
00435 ASSIGN2_SIGNED_SIGNED(signed char, signed long)
00436 ASSIGN2_SIGNED_SIGNED(signed char, signed long long)
00437 ASSIGN2_SIGNED_SIGNED(signed short, signed int)
00438 ASSIGN2_SIGNED_SIGNED(signed short, signed long)
00439 ASSIGN2_SIGNED_SIGNED(signed short, signed long long)
00440 ASSIGN2_SIGNED_SIGNED(signed int, signed long)
00441 ASSIGN2_SIGNED_SIGNED(signed int, signed long long)
00442 ASSIGN2_SIGNED_SIGNED(signed long, signed long long)
00443 ASSIGN2_UNSIGNED_UNSIGNED(unsigned char, unsigned short)
00444 ASSIGN2_UNSIGNED_UNSIGNED(unsigned char, unsigned int)
00445 ASSIGN2_UNSIGNED_UNSIGNED(unsigned char, unsigned long)
00446 ASSIGN2_UNSIGNED_UNSIGNED(unsigned char, unsigned long long)
00447 ASSIGN2_UNSIGNED_UNSIGNED(unsigned short, unsigned int)
00448 ASSIGN2_UNSIGNED_UNSIGNED(unsigned short, unsigned long)
00449 ASSIGN2_UNSIGNED_UNSIGNED(unsigned short, unsigned long long)
00450 ASSIGN2_UNSIGNED_UNSIGNED(unsigned int, unsigned long)
00451 ASSIGN2_UNSIGNED_UNSIGNED(unsigned int, unsigned long long)
00452 ASSIGN2_UNSIGNED_UNSIGNED(unsigned long, unsigned long long)
00453 ASSIGN2_UNSIGNED_SIGNED(unsigned char, signed short)
00454 ASSIGN2_UNSIGNED_SIGNED(unsigned char, signed int)
00455 ASSIGN2_UNSIGNED_SIGNED(unsigned char, signed long)
00456 ASSIGN2_UNSIGNED_SIGNED(unsigned char, signed long long)
00457 ASSIGN2_UNSIGNED_SIGNED(unsigned short, signed int)
00458 ASSIGN2_UNSIGNED_SIGNED(unsigned short, signed long)
00459 ASSIGN2_UNSIGNED_SIGNED(unsigned short, signed long long)
00460 ASSIGN2_UNSIGNED_SIGNED(unsigned int, signed long)
00461 ASSIGN2_UNSIGNED_SIGNED(unsigned int, signed long long)
00462 ASSIGN2_UNSIGNED_SIGNED(unsigned long, signed long long)
00463 ASSIGN2_SIGNED_UNSIGNED(signed char, unsigned char)
00464 ASSIGN2_SIGNED_UNSIGNED(signed char, unsigned short)
00465 ASSIGN2_SIGNED_UNSIGNED(signed char, unsigned int)
00466 ASSIGN2_SIGNED_UNSIGNED(signed char, unsigned long)
00467 ASSIGN2_SIGNED_UNSIGNED(signed char, unsigned long long)
00468 ASSIGN2_SIGNED_UNSIGNED(signed short, unsigned short)
00469 ASSIGN2_SIGNED_UNSIGNED(signed short, unsigned int)
00470 ASSIGN2_SIGNED_UNSIGNED(signed short, unsigned long)
00471 ASSIGN2_SIGNED_UNSIGNED(signed short, unsigned long long)
00472 ASSIGN2_SIGNED_UNSIGNED(signed int, unsigned int)
00473 ASSIGN2_SIGNED_UNSIGNED(signed int, unsigned long)
00474 ASSIGN2_SIGNED_UNSIGNED(signed int, unsigned long long)
00475 ASSIGN2_SIGNED_UNSIGNED(signed long, unsigned long)
00476 ASSIGN2_SIGNED_UNSIGNED(signed long, unsigned long long)
00477 ASSIGN2_SIGNED_UNSIGNED(signed long long, unsigned long long)
00478
00479 template <typename To_Policy, typename From_Policy, typename To, typename From>
00480 inline Result
00481 assign_int_float(To& to, const From from, Rounding_Dir dir) {
00482 if (is_nan<From_Policy>(from))
00483 return assign_special<To_Policy>(to, VC_NAN, ROUND_IGNORE);
00484 else if (is_minf<From_Policy>(from))
00485 return assign_special<To_Policy>(to, VC_MINUS_INFINITY, dir);
00486 else if (is_pinf<From_Policy>(from))
00487 return assign_special<To_Policy>(to, VC_PLUS_INFINITY, dir);
00488 if (CHECK_P(To_Policy::check_overflow, (from < Extended_Int<To_Policy, To>::min)))
00489 return set_neg_overflow_int<To_Policy>(to, dir);
00490 if (CHECK_P(To_Policy::check_overflow, (from > Extended_Int<To_Policy, To>::max)))
00491 return set_pos_overflow_int<To_Policy>(to, dir);
00492 to = static_cast<To>(from);
00493 if (round_ignore(dir))
00494 return V_LGE;
00495 if (from < to)
00496 return round_lt_int<To_Policy>(to, dir);
00497 else if (from > to)
00498 return round_gt_int<To_Policy>(to, dir);
00499 else
00500 return V_EQ;
00501 }
00502
00503 SPECIALIZE_ASSIGN(assign_int_float, signed char, float)
00504 SPECIALIZE_ASSIGN(assign_int_float, signed short, float)
00505 SPECIALIZE_ASSIGN(assign_int_float, signed int, float)
00506 SPECIALIZE_ASSIGN(assign_int_float, signed long, float)
00507 SPECIALIZE_ASSIGN(assign_int_float, signed long long, float)
00508 SPECIALIZE_ASSIGN(assign_int_float, unsigned char, float)
00509 SPECIALIZE_ASSIGN(assign_int_float, unsigned short, float)
00510 SPECIALIZE_ASSIGN(assign_int_float, unsigned int, float)
00511 SPECIALIZE_ASSIGN(assign_int_float, unsigned long, float)
00512 SPECIALIZE_ASSIGN(assign_int_float, unsigned long long, float)
00513
00514 SPECIALIZE_ASSIGN(assign_int_float, signed char, double)
00515 SPECIALIZE_ASSIGN(assign_int_float, signed short, double)
00516 SPECIALIZE_ASSIGN(assign_int_float, signed int, double)
00517 SPECIALIZE_ASSIGN(assign_int_float, signed long, double)
00518 SPECIALIZE_ASSIGN(assign_int_float, signed long long, double)
00519 SPECIALIZE_ASSIGN(assign_int_float, unsigned char, double)
00520 SPECIALIZE_ASSIGN(assign_int_float, unsigned short, double)
00521 SPECIALIZE_ASSIGN(assign_int_float, unsigned int, double)
00522 SPECIALIZE_ASSIGN(assign_int_float, unsigned long, double)
00523 SPECIALIZE_ASSIGN(assign_int_float, unsigned long long, double)
00524
00525 SPECIALIZE_ASSIGN(assign_int_float, signed char, long double)
00526 SPECIALIZE_ASSIGN(assign_int_float, signed short, long double)
00527 SPECIALIZE_ASSIGN(assign_int_float, signed int, long double)
00528 SPECIALIZE_ASSIGN(assign_int_float, signed long, long double)
00529 SPECIALIZE_ASSIGN(assign_int_float, signed long long, long double)
00530 SPECIALIZE_ASSIGN(assign_int_float, unsigned char, long double)
00531 SPECIALIZE_ASSIGN(assign_int_float, unsigned short, long double)
00532 SPECIALIZE_ASSIGN(assign_int_float, unsigned int, long double)
00533 SPECIALIZE_ASSIGN(assign_int_float, unsigned long, long double)
00534 SPECIALIZE_ASSIGN(assign_int_float, unsigned long long, long double)
00535
00536 #undef ASSIGN2_SIGNED_SIGNED
00537 #undef ASSIGN2_UNSIGNED_UNSIGNED
00538 #undef ASSIGN2_UNSIGNED_SIGNED
00539 #undef ASSIGN2_SIGNED_UNSIGNED
00540
00541 template <typename To_Policy, typename From_Policy, typename To>
00542 inline Result
00543 assign_signed_int_mpz(To& to, const mpz_class& from, Rounding_Dir dir) {
00544 if (sizeof(To) <= sizeof(signed long)) {
00545 if (!To_Policy::check_overflow) {
00546 to = from.get_si();
00547 return V_EQ;
00548 }
00549 if (from.fits_slong_p()) {
00550 signed long v = from.get_si();
00551 if (v < C_Integer<To>::min)
00552 return set_neg_overflow_int<To_Policy>(to, dir);
00553 if (v > C_Integer<To>::max)
00554 return set_pos_overflow_int<To_Policy>(to, dir);
00555 to = v;
00556 return V_EQ;
00557 }
00558 }
00559 else {
00560 mpz_srcptr m = from.get_mpz_t();
00561 size_t sz = mpz_size(m);
00562 if (sz <= sizeof(To) / sizeof(mp_limb_t)) {
00563 if (sz == 0) {
00564 to = 0;
00565 return V_EQ;
00566 }
00567 To v;
00568 mpz_export(&v, 0, -1, sizeof(To), 0, 0, m);
00569 if (v >= 0) {
00570 if (::sgn(from) < 0)
00571 return neg<To_Policy, To_Policy>(to, v, dir);
00572 to = v;
00573 return V_EQ;
00574 }
00575 }
00576 }
00577 return ::sgn(from) < 0
00578 ? set_neg_overflow_int<To_Policy>(to, dir)
00579 : set_pos_overflow_int<To_Policy>(to, dir);
00580 }
00581
00582 SPECIALIZE_ASSIGN(assign_signed_int_mpz, signed char, mpz_class)
00583 SPECIALIZE_ASSIGN(assign_signed_int_mpz, signed short, mpz_class)
00584 SPECIALIZE_ASSIGN(assign_signed_int_mpz, signed int, mpz_class)
00585 SPECIALIZE_ASSIGN(assign_signed_int_mpz, signed long, mpz_class)
00586 SPECIALIZE_ASSIGN(assign_signed_int_mpz, signed long long, mpz_class)
00587
00588 template <typename To_Policy, typename From_Policy, typename To>
00589 inline Result
00590 assign_unsigned_int_mpz(To& to, const mpz_class& from, Rounding_Dir dir) {
00591 if (CHECK_P(To_Policy::check_overflow, ::sgn(from) < 0))
00592 return set_neg_overflow_int<To_Policy>(to, dir);
00593 if (sizeof(To) <= sizeof(unsigned long)) {
00594 if (!To_Policy::check_overflow) {
00595 to = from.get_ui();
00596 return V_EQ;
00597 }
00598 if (from.fits_ulong_p()) {
00599 unsigned long v = from.get_ui();
00600 if (v > C_Integer<To>::max)
00601 return set_pos_overflow_int<To_Policy>(to, dir);
00602 to = v;
00603 return V_EQ;
00604 }
00605 }
00606 else {
00607 mpz_srcptr m = from.get_mpz_t();
00608 size_t sz = mpz_size(m);
00609 if (sz <= sizeof(To) / sizeof(mp_limb_t)) {
00610 if (sz == 0)
00611 to = 0;
00612 else
00613 mpz_export(&to, 0, -1, sizeof(To), 0, 0, m);
00614 return V_EQ;
00615 }
00616 }
00617 return set_pos_overflow_int<To_Policy>(to, dir);
00618 }
00619
00620 SPECIALIZE_ASSIGN(assign_unsigned_int_mpz, unsigned char, mpz_class)
00621 SPECIALIZE_ASSIGN(assign_unsigned_int_mpz, unsigned short, mpz_class)
00622 SPECIALIZE_ASSIGN(assign_unsigned_int_mpz, unsigned int, mpz_class)
00623 SPECIALIZE_ASSIGN(assign_unsigned_int_mpz, unsigned long, mpz_class)
00624 SPECIALIZE_ASSIGN(assign_unsigned_int_mpz, unsigned long long, mpz_class)
00625
00626 template <typename To_Policy, typename From_Policy, typename To>
00627 inline Result
00628 assign_int_mpq(To& to, const mpq_class& from, Rounding_Dir dir) {
00629 mpz_srcptr n = from.get_num().get_mpz_t();
00630 mpz_srcptr d = from.get_den().get_mpz_t();
00631 DIRTY_TEMP0(mpz_class, q);
00632 mpz_ptr _q = q.get_mpz_t();
00633 if (round_ignore(dir)) {
00634 mpz_tdiv_q(_q, n, d);
00635 Result r = assign<To_Policy, void>(to, q, dir);
00636 if (r != V_EQ)
00637 return r;
00638 return V_LGE;
00639 }
00640 mpz_t rem;
00641 int sign;
00642 mpz_init(rem);
00643 mpz_tdiv_qr(_q, rem, n, d);
00644 sign = mpz_sgn(rem);
00645 mpz_clear(rem);
00646 Result r = assign<To_Policy, void>(to, q, dir);
00647 if (r != V_EQ)
00648 return r;
00649 switch (sign) {
00650 case -1:
00651 return round_lt_int<To_Policy>(to, dir);
00652 case 1:
00653 return round_gt_int<To_Policy>(to, dir);
00654 default:
00655 return V_EQ;
00656 }
00657 }
00658
00659 SPECIALIZE_ASSIGN(assign_int_mpq, signed char, mpq_class)
00660 SPECIALIZE_ASSIGN(assign_int_mpq, signed short, mpq_class)
00661 SPECIALIZE_ASSIGN(assign_int_mpq, signed int, mpq_class)
00662 SPECIALIZE_ASSIGN(assign_int_mpq, signed long, mpq_class)
00663 SPECIALIZE_ASSIGN(assign_int_mpq, signed long long, mpq_class)
00664 SPECIALIZE_ASSIGN(assign_int_mpq, unsigned char, mpq_class)
00665 SPECIALIZE_ASSIGN(assign_int_mpq, unsigned short, mpq_class)
00666 SPECIALIZE_ASSIGN(assign_int_mpq, unsigned int, mpq_class)
00667 SPECIALIZE_ASSIGN(assign_int_mpq, unsigned long, mpq_class)
00668 SPECIALIZE_ASSIGN(assign_int_mpq, unsigned long long, mpq_class)
00669
00670 #if UCHAR_MAX == 0xff
00671 #define CHAR_BITS 8
00672 #else
00673 #error "Unexpected max for unsigned char"
00674 #endif
00675
00676 #if USHRT_MAX == 0xffff
00677 #define SHRT_BITS 16
00678 #else
00679 #error "Unexpected max for unsigned short"
00680 #endif
00681
00682 #if UINT_MAX == 0xffffffff
00683 #define INT_BITS 32
00684 #else
00685 #error "Unexpected max for unsigned int"
00686 #endif
00687
00688 #if ULONG_MAX == 0xffffffffUL
00689 #define LONG_BITS 32
00690 #elif ULONG_MAX == 0xffffffffffffffffULL
00691 #define LONG_BITS 64
00692 #else
00693 #error "Unexpected max for unsigned long"
00694 #endif
00695
00696 #if ULLONG_MAX == 0xffffffffffffffffULL
00697 #define LONG_LONG_BITS 64
00698 #else
00699 #error "Unexpected max for unsigned long long"
00700 #endif
00701
00702
00703 template <typename T>
00704 struct Larger;
00705
00706
00707
00708
00709
00710
00711
00712 template <>
00713 struct Larger<signed char> {
00714 const_bool_nodef(use_for_neg, true);
00715 const_bool_nodef(use_for_add, true);
00716 const_bool_nodef(use_for_sub, true);
00717 const_bool_nodef(use_for_mul, true);
00718 typedef int_fast16_t type_for_neg;
00719 typedef int_fast16_t type_for_add;
00720 typedef int_fast16_t type_for_sub;
00721 typedef int_fast16_t type_for_mul;
00722 };
00723
00724 template <>
00725 struct Larger<unsigned char> {
00726 const_bool_nodef(use_for_neg, true);
00727 const_bool_nodef(use_for_add, true);
00728 const_bool_nodef(use_for_sub, true);
00729 const_bool_nodef(use_for_mul, true);
00730 typedef int_fast16_t type_for_neg;
00731 typedef uint_fast16_t type_for_add;
00732 typedef int_fast16_t type_for_sub;
00733 typedef uint_fast16_t type_for_mul;
00734 };
00735
00736 template <>
00737 struct Larger<signed short> {
00738 const_bool_nodef(use_for_neg, true);
00739 const_bool_nodef(use_for_add, true);
00740 const_bool_nodef(use_for_sub, true);
00741 const_bool_nodef(use_for_mul, true);
00742 typedef int_fast32_t type_for_neg;
00743 typedef int_fast32_t type_for_add;
00744 typedef int_fast32_t type_for_sub;
00745 typedef int_fast32_t type_for_mul;
00746 };
00747
00748 template <>
00749 struct Larger<unsigned short> {
00750 const_bool_nodef(use_for_neg, true);
00751 const_bool_nodef(use_for_add, true);
00752 const_bool_nodef(use_for_sub, true);
00753 const_bool_nodef(use_for_mul, true);
00754 typedef int_fast32_t type_for_neg;
00755 typedef uint_fast32_t type_for_add;
00756 typedef int_fast32_t type_for_sub;
00757 typedef uint_fast32_t type_for_mul;
00758 };
00759
00760 template <>
00761 struct Larger<signed int> {
00762 const_bool_nodef(use_for_neg, (LONG_BITS == 64));
00763 const_bool_nodef(use_for_add, (LONG_BITS == 64));
00764 const_bool_nodef(use_for_sub, (LONG_BITS == 64));
00765 const_bool_nodef(use_for_mul, true);
00766 typedef int_fast64_t type_for_neg;
00767 typedef int_fast64_t type_for_add;
00768 typedef int_fast64_t type_for_sub;
00769 typedef int_fast64_t type_for_mul;
00770 };
00771
00772 template <>
00773 struct Larger<unsigned int> {
00774 const_bool_nodef(use_for_neg, (LONG_BITS == 64));
00775 const_bool_nodef(use_for_add, (LONG_BITS == 64));
00776 const_bool_nodef(use_for_sub, (LONG_BITS == 64));
00777 const_bool_nodef(use_for_mul, true);
00778 typedef int_fast64_t type_for_neg;
00779 typedef uint_fast64_t type_for_add;
00780 typedef int_fast64_t type_for_sub;
00781 typedef uint_fast64_t type_for_mul;
00782 };
00783
00784 template <>
00785 struct Larger<signed long> {
00786 const_bool_nodef(use_for_neg, false);
00787 const_bool_nodef(use_for_add, false);
00788 const_bool_nodef(use_for_sub, false);
00789 const_bool_nodef(use_for_mul, (LONG_BITS == 32));
00790 typedef int_fast64_t type_for_neg;
00791 typedef int_fast64_t type_for_add;
00792 typedef int_fast64_t type_for_sub;
00793 typedef int_fast64_t type_for_mul;
00794 };
00795
00796 template <>
00797 struct Larger<unsigned long> {
00798 const_bool_nodef(use_for_neg, false);
00799 const_bool_nodef(use_for_add, false);
00800 const_bool_nodef(use_for_sub, false);
00801 const_bool_nodef(use_for_mul, (LONG_BITS == 32));
00802 typedef int_fast64_t type_for_neg;
00803 typedef uint_fast64_t type_for_add;
00804 typedef int_fast64_t type_for_sub;
00805 typedef uint_fast64_t type_for_mul;
00806 };
00807
00808 template <>
00809 struct Larger<signed long long> {
00810 const_bool_nodef(use_for_neg, false);
00811 const_bool_nodef(use_for_add, false);
00812 const_bool_nodef(use_for_sub, false);
00813 const_bool_nodef(use_for_mul, false);
00814 typedef int_fast64_t type_for_neg;
00815 typedef int_fast64_t type_for_add;
00816 typedef int_fast64_t type_for_sub;
00817 typedef int_fast64_t type_for_mul;
00818 };
00819
00820 template <>
00821 struct Larger<unsigned long long> {
00822 const_bool_nodef(use_for_neg, false);
00823 const_bool_nodef(use_for_add, false);
00824 const_bool_nodef(use_for_sub, false);
00825 const_bool_nodef(use_for_mul, false);
00826 typedef int_fast64_t type_for_neg;
00827 typedef uint_fast64_t type_for_add;
00828 typedef int_fast64_t type_for_sub;
00829 typedef uint_fast64_t type_for_mul;
00830 };
00831
00832 template <typename To_Policy, typename From_Policy, typename Type>
00833 inline Result
00834 neg_int_larger(Type& to, const Type x, Rounding_Dir dir) {
00835 typename Larger<Type>::type_for_neg l = x;
00836 l = -l;
00837 return assign<To_Policy, To_Policy>(to, l, dir);
00838 }
00839
00840 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00841 inline Result
00842 add_int_larger(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00843 typename Larger<Type>::type_for_add l = x;
00844 l += y;
00845 return assign<To_Policy, To_Policy>(to, l, dir);
00846 }
00847
00848 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00849 inline Result
00850 sub_int_larger(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00851 typename Larger<Type>::type_for_sub l = x;
00852 l -= y;
00853 return assign<To_Policy, To_Policy>(to, l, dir);
00854 }
00855
00856 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00857 inline Result
00858 mul_int_larger(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00859 typename Larger<Type>::type_for_mul l = x;
00860 l *= y;
00861 return assign<To_Policy, To_Policy>(to, l, dir);
00862 }
00863
00864 template <typename To_Policy, typename From_Policy, typename Type>
00865 inline Result
00866 neg_signed_int(Type& to, const Type from, Rounding_Dir dir) {
00867 if (To_Policy::check_overflow && Larger<Type>::use_for_neg)
00868 return neg_int_larger<To_Policy, From_Policy>(to, from, dir);
00869 if (CHECK_P(To_Policy::check_overflow,
00870 (from < -Extended_Int<To_Policy, Type>::max)))
00871 return set_pos_overflow_int<To_Policy>(to, dir);
00872 to = -from;
00873 return V_EQ;
00874 }
00875
00876 template <typename To_Policy, typename From_Policy, typename Type>
00877 inline Result
00878 neg_unsigned_int(Type& to, const Type from, Rounding_Dir dir) {
00879 if (To_Policy::check_overflow && Larger<Type>::use_for_neg)
00880 return neg_int_larger<To_Policy, From_Policy>(to, from, dir);
00881 if (CHECK_P(To_Policy::check_overflow, from != 0))
00882 return set_neg_overflow_int<To_Policy>(to, dir);
00883 to = from;
00884 return V_EQ;
00885 }
00886
00887 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00888 inline Result
00889 add_signed_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00890 if (To_Policy::check_overflow && Larger<Type>::use_for_add)
00891 return add_int_larger<To_Policy, From1_Policy, From2_Policy>(to, x, y, dir);
00892 if (To_Policy::check_overflow) {
00893 if (y >= 0) {
00894 if (x > Extended_Int<To_Policy, Type>::max - y)
00895 return set_pos_overflow_int<To_Policy>(to, dir);
00896 }
00897 else if (x < Extended_Int<To_Policy, Type>::min - y)
00898 return set_neg_overflow_int<To_Policy>(to, dir);
00899 }
00900 to = x + y;
00901 return V_EQ;
00902 }
00903
00904 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00905 inline Result
00906 add_unsigned_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00907 if (To_Policy::check_overflow && Larger<Type>::use_for_add)
00908 return add_int_larger<To_Policy, From1_Policy, From2_Policy>(to, x, y, dir);
00909 if (CHECK_P(To_Policy::check_overflow,
00910 (x > Extended_Int<To_Policy, Type>::max - y)))
00911 return set_pos_overflow_int<To_Policy>(to, dir);
00912 to = x + y;
00913 return V_EQ;
00914 }
00915
00916 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00917 inline Result
00918 sub_signed_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00919 if (To_Policy::check_overflow && Larger<Type>::use_for_sub)
00920 return sub_int_larger<To_Policy, From1_Policy, From2_Policy>(to, x, y, dir);
00921 if (To_Policy::check_overflow) {
00922 if (y >= 0) {
00923 if (x < Extended_Int<To_Policy, Type>::min + y)
00924 return set_neg_overflow_int<To_Policy>(to, dir);
00925 }
00926 else if (x > Extended_Int<To_Policy, Type>::max + y)
00927 return set_pos_overflow_int<To_Policy>(to, dir);
00928 }
00929 to = x - y;
00930 return V_EQ;
00931 }
00932
00933 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00934 inline Result
00935 sub_unsigned_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00936 if (To_Policy::check_overflow && Larger<Type>::use_for_sub)
00937 return sub_int_larger<To_Policy, From1_Policy, From2_Policy>(to, x, y, dir);
00938 if (CHECK_P(To_Policy::check_overflow,
00939 (x < Extended_Int<To_Policy, Type>::min + y)))
00940 return set_neg_overflow_int<To_Policy>(to, dir);
00941 to = x - y;
00942 return V_EQ;
00943 }
00944
00945 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00946 inline Result
00947 mul_signed_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00948 if (To_Policy::check_overflow && Larger<Type>::use_for_mul)
00949 return mul_int_larger<To_Policy, From1_Policy, From2_Policy>(to, x, y, dir);
00950 if (!To_Policy::check_overflow) {
00951 to = x * y;
00952 return V_EQ;
00953 }
00954 if (y == 0) {
00955 to = 0;
00956 return V_EQ;
00957 }
00958 if (y == -1)
00959 return neg_signed_int<To_Policy, From1_Policy>(to, x, dir);
00960 if (x >= 0) {
00961 if (y > 0) {
00962 if (x > Extended_Int<To_Policy, Type>::max / y)
00963 return set_pos_overflow_int<To_Policy>(to, dir);
00964 }
00965 else {
00966 if (x > Extended_Int<To_Policy, Type>::min / y)
00967 return set_neg_overflow_int<To_Policy>(to, dir);
00968 }
00969 }
00970 else {
00971 if (y < 0) {
00972 if (x < Extended_Int<To_Policy, Type>::max / y)
00973 return set_pos_overflow_int<To_Policy>(to, dir);
00974 }
00975 else {
00976 if (x < Extended_Int<To_Policy, Type>::min / y)
00977 return set_neg_overflow_int<To_Policy>(to, dir);
00978 }
00979 }
00980 to = x * y;
00981 return V_EQ;
00982 }
00983
00984 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
00985 inline Result
00986 mul_unsigned_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
00987 if (To_Policy::check_overflow && Larger<Type>::use_for_mul)
00988 return mul_int_larger<To_Policy, From1_Policy, From2_Policy>(to, x, y, dir);
00989 if (!To_Policy::check_overflow) {
00990 to = x * y;
00991 return V_EQ;
00992 }
00993 if (y == 0) {
00994 to = 0;
00995 return V_EQ;
00996 }
00997 if (x > Extended_Int<To_Policy, Type>::max / y)
00998 return set_pos_overflow_int<To_Policy>(to, dir);
00999 to = x * y;
01000 return V_EQ;
01001 }
01002
01003 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01004 inline Result
01005 div_signed_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
01006 if (CHECK_P(To_Policy::check_div_zero, y == 0))
01007 return assign_special<To_Policy>(to, V_DIV_ZERO, ROUND_IGNORE);
01008 if (To_Policy::check_overflow && y == -1)
01009 return neg_signed_int<To_Policy, From1_Policy>(to, x, dir);
01010 to = x / y;
01011 if (round_ignore(dir))
01012 return V_LGE;
01013 Type m = x % y;
01014 if (m < 0)
01015 return round_lt_int_no_overflow<To_Policy>(to, dir);
01016 else if (m > 0)
01017 return round_gt_int_no_overflow<To_Policy>(to, dir);
01018 else
01019 return V_EQ;
01020 }
01021
01022 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01023 inline Result
01024 div_unsigned_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
01025 if (CHECK_P(To_Policy::check_div_zero, y == 0))
01026 return assign_special<To_Policy>(to, V_DIV_ZERO, ROUND_IGNORE);
01027 to = x / y;
01028 if (round_ignore(dir))
01029 return V_GE;
01030 Type m = x % y;
01031 if (m == 0)
01032 return V_EQ;
01033 return round_gt_int<To_Policy>(to, dir);
01034 }
01035
01036 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01037 inline Result
01038 idiv_signed_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
01039 if (CHECK_P(To_Policy::check_div_zero, y == 0))
01040 return assign_special<To_Policy>(to, V_DIV_ZERO, ROUND_IGNORE);
01041 if (To_Policy::check_overflow && y == -1)
01042 return neg_signed_int<To_Policy, From1_Policy>(to, x, dir);
01043 to = x / y;
01044 return V_EQ;
01045 }
01046
01047 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01048 inline Result
01049 idiv_unsigned_int(Type& to, const Type x, const Type y, Rounding_Dir) {
01050 if (CHECK_P(To_Policy::check_div_zero, y == 0))
01051 return assign_special<To_Policy>(to, V_DIV_ZERO, ROUND_IGNORE);
01052 to = x / y;
01053 return V_EQ;
01054 }
01055
01056 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01057 inline Result
01058 rem_signed_int(Type& to, const Type x, const Type y, Rounding_Dir) {
01059 if (CHECK_P(To_Policy::check_div_zero, y == 0))
01060 return assign_special<To_Policy>(to, V_MOD_ZERO, ROUND_IGNORE);
01061 to = x % y;
01062 return V_EQ;
01063 }
01064
01065 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01066 inline Result
01067 rem_unsigned_int(Type& to, const Type x, const Type y, Rounding_Dir) {
01068 if (CHECK_P(To_Policy::check_div_zero, y == 0))
01069 return assign_special<To_Policy>(to, V_MOD_ZERO, ROUND_IGNORE);
01070 to = x % y;
01071 return V_EQ;
01072 }
01073
01074 template <typename To_Policy, typename From_Policy, typename Type>
01075 inline Result
01076 div2exp_unsigned_int(Type& to, const Type x, int exp, Rounding_Dir dir) {
01077 if (exp < 0)
01078 return mul2exp<To_Policy, From_Policy>(to, x, -exp, dir);
01079 if (static_cast<unsigned int>(exp) >= sizeof(Type) * 8) {
01080 to = 0;
01081 if (round_ignore(dir))
01082 return V_GE;
01083 if (x == 0)
01084 return V_EQ;
01085 return round_gt_int_no_overflow<To_Policy>(to, dir);
01086 }
01087 to = x >> exp;
01088 if (round_ignore(dir))
01089 return V_GE;
01090 if (x & ((static_cast<Type>(1) << exp) - 1))
01091 return round_gt_int_no_overflow<To_Policy>(to, dir);
01092 else
01093 return V_EQ;
01094 }
01095
01096 template <typename To_Policy, typename From_Policy, typename Type>
01097 inline Result
01098 div2exp_signed_int(Type& to, const Type x, int exp, Rounding_Dir dir) {
01099 if (exp < 0)
01100 return mul2exp<To_Policy, From_Policy>(to, x, -exp, dir);
01101 if (static_cast<unsigned int>(exp) >= sizeof(Type) * 8) {
01102 zero:
01103 to = 0;
01104 if (round_ignore(dir))
01105 return V_LGE;
01106 if (x < 0)
01107 return round_lt_int_no_overflow<To_Policy>(to, dir);
01108 else if (x > 0)
01109 return round_gt_int_no_overflow<To_Policy>(to, dir);
01110 else
01111 return V_EQ;
01112 }
01113 if (static_cast<unsigned int>(exp) >= sizeof(Type) * 8 - 1) {
01114 if (x == C_Integer<Type>::min) {
01115 to = -1;
01116 return V_EQ;
01117 }
01118 goto zero;
01119 }
01120 #if 0
01121 to = x / (static_cast<Type>(1) << exp);
01122 if (round_ignore(dir))
01123 return V_GE;
01124 Type r = x % (static_cast<Type>(1) << exp);
01125 if (r < 0)
01126 return round_lt_int_no_overflow<To_Policy>(to, dir);
01127 else if (r > 0)
01128 return round_gt_int_no_overflow<To_Policy>(to, dir);
01129 else
01130 return V_EQ;
01131 #else
01132
01133 to = x >> exp;
01134 if (round_ignore(dir))
01135 return V_GE;
01136 if (x & ((static_cast<Type>(1) << exp) - 1))
01137 return round_gt_int_no_overflow<To_Policy>(to, dir);
01138 return V_EQ;
01139 #endif
01140 }
01141
01142 template <typename To_Policy, typename From_Policy, typename Type>
01143 inline Result
01144 mul2exp_unsigned_int(Type& to, const Type x, int exp, Rounding_Dir dir) {
01145 if (exp < 0)
01146 return div2exp<To_Policy, From_Policy>(to, x, -exp, dir);
01147 if (!To_Policy::check_overflow) {
01148 to = x << exp;
01149 return V_EQ;
01150 }
01151 if (static_cast<unsigned int>(exp) >= sizeof(Type) * 8) {
01152 if (x == 0) {
01153 to = 0;
01154 return V_EQ;
01155 }
01156 return set_pos_overflow_int<To_Policy>(to, dir);
01157 }
01158 if (x & (((static_cast<Type>(1) << exp) - 1) << (sizeof(Type) * 8 - exp)))
01159 return set_pos_overflow_int<To_Policy>(to, dir);
01160 Type n = x << exp;
01161 if (n > Extended_Int<To_Policy, Type>::max)
01162 return set_pos_overflow_int<To_Policy>(to, dir);
01163 to = n;
01164 return V_EQ;
01165 }
01166
01167 template <typename To_Policy, typename From_Policy, typename Type>
01168 inline Result
01169 mul2exp_signed_int(Type& to, const Type x, int exp, Rounding_Dir dir) {
01170 if (exp < 0)
01171 return div2exp<To_Policy, From_Policy>(to, x, -exp, dir);
01172 if (!To_Policy::check_overflow) {
01173 to = x << exp;
01174 return V_EQ;
01175 }
01176 if (static_cast<unsigned int>(exp) >= sizeof(Type) * 8 - 1) {
01177 if (x < 0)
01178 return set_neg_overflow_int<To_Policy>(to, dir);
01179 else if (x > 0)
01180 return set_pos_overflow_int<To_Policy>(to, dir);
01181 else {
01182 to = 0;
01183 return V_EQ;
01184 }
01185 }
01186 Type mask = ((static_cast<Type>(1) << exp) - 1)
01187 << (sizeof(Type) * 8 - 1 - exp);
01188 Type n;
01189 if (x < 0) {
01190 if ((x & mask) != mask)
01191 return set_neg_overflow_int<To_Policy>(to, dir);
01192 n = x << exp;
01193 if (n < Extended_Int<To_Policy, Type>::min)
01194 return set_neg_overflow_int<To_Policy>(to, dir);
01195 }
01196 else {
01197 if (x & mask)
01198 return set_pos_overflow_int<To_Policy>(to, dir);
01199 n = x << exp;
01200 if (n > Extended_Int<To_Policy, Type>::max)
01201 return set_pos_overflow_int<To_Policy>(to, dir);
01202 }
01203 to = n;
01204 return V_EQ;
01205 }
01206
01207 template <typename Type>
01208 inline void
01209 isqrtrem(Type& q, Type& r, const Type from) {
01210 q = 0;
01211 r = from;
01212 Type t(1);
01213 for (t <<= 8 * sizeof(Type) - 2; t != 0; t >>= 2) {
01214 Type s = q + t;
01215 if (s <= r) {
01216 r -= s;
01217 q = s + t;
01218 }
01219 q >>= 1;
01220 }
01221 }
01222
01223 template <typename To_Policy, typename From_Policy, typename Type>
01224 inline Result
01225 sqrt_unsigned_int(Type& to, const Type from, Rounding_Dir dir) {
01226 Type rem;
01227 isqrtrem(to, rem, from);
01228 if (round_ignore(dir))
01229 return V_GE;
01230 if (rem == 0)
01231 return V_EQ;
01232 return round_gt_int<To_Policy>(to, dir);
01233 }
01234
01235 template <typename To_Policy, typename From_Policy, typename Type>
01236 inline Result
01237 sqrt_signed_int(Type& to, const Type from, Rounding_Dir dir) {
01238 if (CHECK_P(To_Policy::check_sqrt_neg, from < 0))
01239 return assign_special<To_Policy>(to, V_SQRT_NEG, ROUND_IGNORE);
01240 return sqrt_unsigned_int<To_Policy, From_Policy>(to, from, dir);
01241 }
01242
01243 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01244 inline Result
01245 add_mul_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
01246 Type z;
01247 Result r = mul<To_Policy, From1_Policy, From2_Policy>(z, x, y, dir);
01248 switch (r) {
01249 case V_NEG_OVERFLOW:
01250 case V_LT:
01251 if (to <= 0) {
01252 to = z;
01253 return r;
01254 }
01255 return assign_special<To_Policy>(to, V_UNKNOWN_NEG_OVERFLOW, ROUND_IGNORE);
01256 case V_POS_OVERFLOW:
01257 case V_GT:
01258 if (to >= 0) {
01259 to = z;
01260 return r;
01261 }
01262 return assign_special<To_Policy>(to, V_UNKNOWN_POS_OVERFLOW, ROUND_IGNORE);
01263 default:
01264 return add<To_Policy, To_Policy, To_Policy>(to, to, z, dir);
01265 }
01266 }
01267
01268 template <typename To_Policy, typename From1_Policy, typename From2_Policy, typename Type>
01269 inline Result
01270 sub_mul_int(Type& to, const Type x, const Type y, Rounding_Dir dir) {
01271 Type z;
01272 Result r = mul<To_Policy, From1_Policy, From2_Policy>(z, x, y, dir);
01273 switch (r) {
01274 case V_NEG_OVERFLOW:
01275 case V_LT:
01276 if (to >= 0)
01277 return set_pos_overflow_int<To_Policy>(to, dir);
01278 return V_UNKNOWN_NEG_OVERFLOW;
01279 case V_POS_OVERFLOW:
01280 case V_GT:
01281 if (to <= 0)
01282 return set_neg_overflow_int<To_Policy>(to, dir);
01283 return V_UNKNOWN_POS_OVERFLOW;
01284 default:
01285 return sub<To_Policy, To_Policy, To_Policy>(to, to, z, dir);
01286 }
01287 }
01288
01289 template <typename Policy, typename Type>
01290 inline Result
01291 output_char(std::ostream& os, Type& from,
01292 const Numeric_Format&, Rounding_Dir) {
01293 os << static_cast<int>(from);
01294 return V_EQ;
01295 }
01296
01297 template <typename Policy, typename Type>
01298 inline Result
01299 output_int(std::ostream& os, Type& from, const Numeric_Format&, Rounding_Dir) {
01300 os << from;
01301 return V_EQ;
01302 }
01303
01304 SPECIALIZE_FLOOR(assign_signed_int_signed_int, signed char, signed char)
01305 SPECIALIZE_FLOOR(assign_signed_int_signed_int, signed short, signed short)
01306 SPECIALIZE_FLOOR(assign_signed_int_signed_int, signed int, signed int)
01307 SPECIALIZE_FLOOR(assign_signed_int_signed_int, signed long, signed long)
01308 SPECIALIZE_FLOOR(assign_signed_int_signed_int, signed long long, signed long long)
01309 SPECIALIZE_FLOOR(assign_unsigned_int_unsigned_int, unsigned char, unsigned char)
01310 SPECIALIZE_FLOOR(assign_unsigned_int_unsigned_int, unsigned short, unsigned short)
01311 SPECIALIZE_FLOOR(assign_unsigned_int_unsigned_int, unsigned int, unsigned int)
01312 SPECIALIZE_FLOOR(assign_unsigned_int_unsigned_int, unsigned long, unsigned long)
01313 SPECIALIZE_FLOOR(assign_unsigned_int_unsigned_int, unsigned long long, unsigned long long)
01314
01315 SPECIALIZE_CEIL(assign_signed_int_signed_int, signed char, signed char)
01316 SPECIALIZE_CEIL(assign_signed_int_signed_int, signed short, signed short)
01317 SPECIALIZE_CEIL(assign_signed_int_signed_int, signed int, signed int)
01318 SPECIALIZE_CEIL(assign_signed_int_signed_int, signed long, signed long)
01319 SPECIALIZE_CEIL(assign_signed_int_signed_int, signed long long, signed long long)
01320 SPECIALIZE_CEIL(assign_unsigned_int_unsigned_int, unsigned char, unsigned char)
01321 SPECIALIZE_CEIL(assign_unsigned_int_unsigned_int, unsigned short, unsigned short)
01322 SPECIALIZE_CEIL(assign_unsigned_int_unsigned_int, unsigned int, unsigned int)
01323 SPECIALIZE_CEIL(assign_unsigned_int_unsigned_int, unsigned long, unsigned long)
01324 SPECIALIZE_CEIL(assign_unsigned_int_unsigned_int, unsigned long long, unsigned long long)
01325
01326 SPECIALIZE_TRUNC(assign_signed_int_signed_int, signed char, signed char)
01327 SPECIALIZE_TRUNC(assign_signed_int_signed_int, signed short, signed short)
01328 SPECIALIZE_TRUNC(assign_signed_int_signed_int, signed int, signed int)
01329 SPECIALIZE_TRUNC(assign_signed_int_signed_int, signed long, signed long)
01330 SPECIALIZE_TRUNC(assign_signed_int_signed_int, signed long long, signed long long)
01331 SPECIALIZE_TRUNC(assign_unsigned_int_unsigned_int, unsigned char, unsigned char)
01332 SPECIALIZE_TRUNC(assign_unsigned_int_unsigned_int, unsigned short, unsigned short)
01333 SPECIALIZE_TRUNC(assign_unsigned_int_unsigned_int, unsigned int, unsigned int)
01334 SPECIALIZE_TRUNC(assign_unsigned_int_unsigned_int, unsigned long, unsigned long)
01335 SPECIALIZE_TRUNC(assign_unsigned_int_unsigned_int, unsigned long long, unsigned long long)
01336
01337 SPECIALIZE_NEG(neg_signed_int, signed char, signed char)
01338 SPECIALIZE_NEG(neg_signed_int, signed short, signed short)
01339 SPECIALIZE_NEG(neg_signed_int, signed int, signed int)
01340 SPECIALIZE_NEG(neg_signed_int, signed long, signed long)
01341 SPECIALIZE_NEG(neg_signed_int, signed long long, signed long long)
01342 SPECIALIZE_NEG(neg_unsigned_int, unsigned char, unsigned char)
01343 SPECIALIZE_NEG(neg_unsigned_int, unsigned short, unsigned short)
01344 SPECIALIZE_NEG(neg_unsigned_int, unsigned int, unsigned int)
01345 SPECIALIZE_NEG(neg_unsigned_int, unsigned long, unsigned long)
01346 SPECIALIZE_NEG(neg_unsigned_int, unsigned long long, unsigned long long)
01347
01348 SPECIALIZE_ADD(add_signed_int, signed char, signed char, signed char)
01349 SPECIALIZE_ADD(add_signed_int, signed short, signed short, signed short)
01350 SPECIALIZE_ADD(add_signed_int, signed int, signed int, signed int)
01351 SPECIALIZE_ADD(add_signed_int, signed long, signed long, signed long)
01352 SPECIALIZE_ADD(add_signed_int, signed long long, signed long long, signed long long)
01353 SPECIALIZE_ADD(add_unsigned_int, unsigned char, unsigned char, unsigned char)
01354 SPECIALIZE_ADD(add_unsigned_int, unsigned short, unsigned short, unsigned short)
01355 SPECIALIZE_ADD(add_unsigned_int, unsigned int, unsigned int, unsigned int)
01356 SPECIALIZE_ADD(add_unsigned_int, unsigned long, unsigned long, unsigned long)
01357 SPECIALIZE_ADD(add_unsigned_int, unsigned long long, unsigned long long, unsigned long long)
01358
01359 SPECIALIZE_SUB(sub_signed_int, signed char, signed char, signed char)
01360 SPECIALIZE_SUB(sub_signed_int, signed short, signed short, signed short)
01361 SPECIALIZE_SUB(sub_signed_int, signed int, signed int, signed int)
01362 SPECIALIZE_SUB(sub_signed_int, signed long, signed long, signed long)
01363 SPECIALIZE_SUB(sub_signed_int, signed long long, signed long long, signed long long)
01364 SPECIALIZE_SUB(sub_unsigned_int, unsigned char, unsigned char, unsigned char)
01365 SPECIALIZE_SUB(sub_unsigned_int, unsigned short, unsigned short, unsigned short)
01366 SPECIALIZE_SUB(sub_unsigned_int, unsigned int, unsigned int, unsigned int)
01367 SPECIALIZE_SUB(sub_unsigned_int, unsigned long, unsigned long, unsigned long)
01368 SPECIALIZE_SUB(sub_unsigned_int, unsigned long long, unsigned long long, unsigned long long)
01369
01370 SPECIALIZE_MUL(mul_signed_int, signed char, signed char, signed char)
01371 SPECIALIZE_MUL(mul_signed_int, signed short, signed short, signed short)
01372 SPECIALIZE_MUL(mul_signed_int, signed int, signed int, signed int)
01373 SPECIALIZE_MUL(mul_signed_int, signed long, signed long, signed long)
01374 SPECIALIZE_MUL(mul_signed_int, signed long long, signed long long, signed long long)
01375 SPECIALIZE_MUL(mul_unsigned_int, unsigned char, unsigned char, unsigned char)
01376 SPECIALIZE_MUL(mul_unsigned_int, unsigned short, unsigned short, unsigned short)
01377 SPECIALIZE_MUL(mul_unsigned_int, unsigned int, unsigned int, unsigned int)
01378 SPECIALIZE_MUL(mul_unsigned_int, unsigned long, unsigned long, unsigned long)
01379 SPECIALIZE_MUL(mul_unsigned_int, unsigned long long, unsigned long long, unsigned long long)
01380
01381 SPECIALIZE_DIV(div_signed_int, signed char, signed char, signed char)
01382 SPECIALIZE_DIV(div_signed_int, signed short, signed short, signed short)
01383 SPECIALIZE_DIV(div_signed_int, signed int, signed int, signed int)
01384 SPECIALIZE_DIV(div_signed_int, signed long, signed long, signed long)
01385 SPECIALIZE_DIV(div_signed_int, signed long long, signed long long, signed long long)
01386 SPECIALIZE_DIV(div_unsigned_int, unsigned char, unsigned char, unsigned char)
01387 SPECIALIZE_DIV(div_unsigned_int, unsigned short, unsigned short, unsigned short)
01388 SPECIALIZE_DIV(div_unsigned_int, unsigned int, unsigned int, unsigned int)
01389 SPECIALIZE_DIV(div_unsigned_int, unsigned long, unsigned long, unsigned long)
01390 SPECIALIZE_DIV(div_unsigned_int, unsigned long long, unsigned long long, unsigned long long)
01391
01392 SPECIALIZE_IDIV(idiv_signed_int, signed char, signed char, signed char)
01393 SPECIALIZE_IDIV(idiv_signed_int, signed short, signed short, signed short)
01394 SPECIALIZE_IDIV(idiv_signed_int, signed int, signed int, signed int)
01395 SPECIALIZE_IDIV(idiv_signed_int, signed long, signed long, signed long)
01396 SPECIALIZE_IDIV(idiv_signed_int, signed long long, signed long long, signed long long)
01397 SPECIALIZE_IDIV(idiv_unsigned_int, unsigned char, unsigned char, unsigned char)
01398 SPECIALIZE_IDIV(idiv_unsigned_int, unsigned short, unsigned short, unsigned short)
01399 SPECIALIZE_IDIV(idiv_unsigned_int, unsigned int, unsigned int, unsigned int)
01400 SPECIALIZE_IDIV(idiv_unsigned_int, unsigned long, unsigned long, unsigned long)
01401 SPECIALIZE_IDIV(idiv_unsigned_int, unsigned long long, unsigned long long, unsigned long long)
01402
01403 SPECIALIZE_REM(rem_signed_int, signed char, signed char, signed char)
01404 SPECIALIZE_REM(rem_signed_int, signed short, signed short, signed short)
01405 SPECIALIZE_REM(rem_signed_int, signed int, signed int, signed int)
01406 SPECIALIZE_REM(rem_signed_int, signed long, signed long, signed long)
01407 SPECIALIZE_REM(rem_signed_int, signed long long, signed long long, signed long long)
01408 SPECIALIZE_REM(rem_unsigned_int, unsigned char, unsigned char, unsigned char)
01409 SPECIALIZE_REM(rem_unsigned_int, unsigned short, unsigned short, unsigned short)
01410 SPECIALIZE_REM(rem_unsigned_int, unsigned int, unsigned int, unsigned int)
01411 SPECIALIZE_REM(rem_unsigned_int, unsigned long, unsigned long, unsigned long)
01412 SPECIALIZE_REM(rem_unsigned_int, unsigned long long, unsigned long long, unsigned long long)
01413
01414 SPECIALIZE_MUL2EXP(mul2exp_signed_int, signed char, signed char)
01415 SPECIALIZE_MUL2EXP(mul2exp_signed_int, signed short, signed short)
01416 SPECIALIZE_MUL2EXP(mul2exp_signed_int, signed int, signed int)
01417 SPECIALIZE_MUL2EXP(mul2exp_signed_int, signed long, signed long)
01418 SPECIALIZE_MUL2EXP(mul2exp_signed_int, signed long long, signed long long)
01419 SPECIALIZE_MUL2EXP(mul2exp_unsigned_int, unsigned char, unsigned char)
01420 SPECIALIZE_MUL2EXP(mul2exp_unsigned_int, unsigned short, unsigned short)
01421 SPECIALIZE_MUL2EXP(mul2exp_unsigned_int, unsigned int, unsigned int)
01422 SPECIALIZE_MUL2EXP(mul2exp_unsigned_int, unsigned long, unsigned long)
01423 SPECIALIZE_MUL2EXP(mul2exp_unsigned_int, unsigned long long, unsigned long long)
01424
01425 SPECIALIZE_DIV2EXP(div2exp_signed_int, signed char, signed char)
01426 SPECIALIZE_DIV2EXP(div2exp_signed_int, signed short, signed short)
01427 SPECIALIZE_DIV2EXP(div2exp_signed_int, signed int, signed int)
01428 SPECIALIZE_DIV2EXP(div2exp_signed_int, signed long, signed long)
01429 SPECIALIZE_DIV2EXP(div2exp_signed_int, signed long long, signed long long)
01430 SPECIALIZE_DIV2EXP(div2exp_unsigned_int, unsigned char, unsigned char)
01431 SPECIALIZE_DIV2EXP(div2exp_unsigned_int, unsigned short, unsigned short)
01432 SPECIALIZE_DIV2EXP(div2exp_unsigned_int, unsigned int, unsigned int)
01433 SPECIALIZE_DIV2EXP(div2exp_unsigned_int, unsigned long, unsigned long)
01434 SPECIALIZE_DIV2EXP(div2exp_unsigned_int, unsigned long long, unsigned long long)
01435
01436 SPECIALIZE_SQRT(sqrt_signed_int, signed char, signed char)
01437 SPECIALIZE_SQRT(sqrt_signed_int, signed short, signed short)
01438 SPECIALIZE_SQRT(sqrt_signed_int, signed int, signed int)
01439 SPECIALIZE_SQRT(sqrt_signed_int, signed long, signed long)
01440 SPECIALIZE_SQRT(sqrt_signed_int, signed long long, signed long long)
01441 SPECIALIZE_SQRT(sqrt_unsigned_int, unsigned char, unsigned char)
01442 SPECIALIZE_SQRT(sqrt_unsigned_int, unsigned short, unsigned short)
01443 SPECIALIZE_SQRT(sqrt_unsigned_int, unsigned int, unsigned int)
01444 SPECIALIZE_SQRT(sqrt_unsigned_int, unsigned long, unsigned long)
01445 SPECIALIZE_SQRT(sqrt_unsigned_int, unsigned long long, unsigned long long)
01446
01447 SPECIALIZE_ABS(abs_generic, signed char, signed char)
01448 SPECIALIZE_ABS(abs_generic, signed short, signed short)
01449 SPECIALIZE_ABS(abs_generic, signed int, signed int)
01450 SPECIALIZE_ABS(abs_generic, signed long, signed long)
01451 SPECIALIZE_ABS(abs_generic, signed long long, signed long long)
01452 SPECIALIZE_ABS(assign_unsigned_int_unsigned_int, unsigned char, unsigned char)
01453 SPECIALIZE_ABS(assign_unsigned_int_unsigned_int, unsigned short, unsigned short)
01454 SPECIALIZE_ABS(assign_unsigned_int_unsigned_int, unsigned int, unsigned int)
01455 SPECIALIZE_ABS(assign_unsigned_int_unsigned_int, unsigned long, unsigned long)
01456 SPECIALIZE_ABS(assign_unsigned_int_unsigned_int, unsigned long long, unsigned long long)
01457
01458 SPECIALIZE_GCD(gcd_exact, signed char, signed char, signed char)
01459 SPECIALIZE_GCD(gcd_exact, signed short, signed short, signed short)
01460 SPECIALIZE_GCD(gcd_exact, signed int, signed int, signed int)
01461 SPECIALIZE_GCD(gcd_exact, signed long, signed long, signed long)
01462 SPECIALIZE_GCD(gcd_exact, signed long long, signed long long, signed long long)
01463 SPECIALIZE_GCD(gcd_exact, unsigned char, unsigned char, unsigned char)
01464 SPECIALIZE_GCD(gcd_exact, unsigned short, unsigned short, unsigned short)
01465 SPECIALIZE_GCD(gcd_exact, unsigned int, unsigned int, unsigned int)
01466 SPECIALIZE_GCD(gcd_exact, unsigned long, unsigned long, unsigned long)
01467 SPECIALIZE_GCD(gcd_exact, unsigned long long, unsigned long long, unsigned long long)
01468
01469 SPECIALIZE_GCDEXT(gcdext_exact, signed char, signed char, signed char, signed char, signed char)
01470 SPECIALIZE_GCDEXT(gcdext_exact, signed short, signed short, signed short, signed short, signed short)
01471 SPECIALIZE_GCDEXT(gcdext_exact, signed int, signed int, signed int, signed int, signed int)
01472 SPECIALIZE_GCDEXT(gcdext_exact, signed long, signed long, signed long, signed long, signed long)
01473 SPECIALIZE_GCDEXT(gcdext_exact, signed long long, signed long long, signed long long, signed long long, signed long long)
01474 SPECIALIZE_GCDEXT(gcdext_exact, unsigned char, unsigned char, unsigned char, unsigned char, unsigned char)
01475 SPECIALIZE_GCDEXT(gcdext_exact, unsigned short, unsigned short, unsigned short, unsigned short, unsigned short)
01476 SPECIALIZE_GCDEXT(gcdext_exact, unsigned int, unsigned int, unsigned int, unsigned int, unsigned int)
01477 SPECIALIZE_GCDEXT(gcdext_exact, unsigned long, unsigned long, unsigned long, unsigned long, unsigned long)
01478 SPECIALIZE_GCDEXT(gcdext_exact, unsigned long long, unsigned long long, unsigned long long, unsigned long long, unsigned long long)
01479
01480 SPECIALIZE_LCM(lcm_gcd_exact, signed char, signed char, signed char)
01481 SPECIALIZE_LCM(lcm_gcd_exact, signed short, signed short, signed short)
01482 SPECIALIZE_LCM(lcm_gcd_exact, signed int, signed int, signed int)
01483 SPECIALIZE_LCM(lcm_gcd_exact, signed long, signed long, signed long)
01484 SPECIALIZE_LCM(lcm_gcd_exact, signed long long, signed long long, signed long long)
01485 SPECIALIZE_LCM(lcm_gcd_exact, unsigned char, unsigned char, unsigned char)
01486 SPECIALIZE_LCM(lcm_gcd_exact, unsigned short, unsigned short, unsigned short)
01487 SPECIALIZE_LCM(lcm_gcd_exact, unsigned int, unsigned int, unsigned int)
01488 SPECIALIZE_LCM(lcm_gcd_exact, unsigned long, unsigned long, unsigned long)
01489 SPECIALIZE_LCM(lcm_gcd_exact, unsigned long long, unsigned long long, unsigned long long)
01490
01491 SPECIALIZE_SGN(sgn_generic, signed char)
01492 SPECIALIZE_SGN(sgn_generic, signed short)
01493 SPECIALIZE_SGN(sgn_generic, signed int)
01494 SPECIALIZE_SGN(sgn_generic, signed long)
01495 SPECIALIZE_SGN(sgn_generic, signed long long)
01496 SPECIALIZE_SGN(sgn_generic, unsigned char)
01497 SPECIALIZE_SGN(sgn_generic, unsigned short)
01498 SPECIALIZE_SGN(sgn_generic, unsigned int)
01499 SPECIALIZE_SGN(sgn_generic, unsigned long)
01500 SPECIALIZE_SGN(sgn_generic, unsigned long long)
01501
01502 SPECIALIZE_CMP(cmp_generic, signed char, signed char)
01503 SPECIALIZE_CMP(cmp_generic, signed short, signed short)
01504 SPECIALIZE_CMP(cmp_generic, signed int, signed int)
01505 SPECIALIZE_CMP(cmp_generic, signed long, signed long)
01506 SPECIALIZE_CMP(cmp_generic, signed long long, signed long long)
01507 SPECIALIZE_CMP(cmp_generic, unsigned char, unsigned char)
01508 SPECIALIZE_CMP(cmp_generic, unsigned short, unsigned short)
01509 SPECIALIZE_CMP(cmp_generic, unsigned int, unsigned int)
01510 SPECIALIZE_CMP(cmp_generic, unsigned long, unsigned long)
01511 SPECIALIZE_CMP(cmp_generic, unsigned long long, unsigned long long)
01512
01513 SPECIALIZE_ADD_MUL(add_mul_int, signed char, signed char, signed char)
01514 SPECIALIZE_ADD_MUL(add_mul_int, signed short, signed short, signed short)
01515 SPECIALIZE_ADD_MUL(add_mul_int, signed int, signed int, signed int)
01516 SPECIALIZE_ADD_MUL(add_mul_int, signed long, signed long, signed long)
01517 SPECIALIZE_ADD_MUL(add_mul_int, signed long long, signed long long, signed long long)
01518 SPECIALIZE_ADD_MUL(add_mul_int, unsigned char, unsigned char, unsigned char)
01519 SPECIALIZE_ADD_MUL(add_mul_int, unsigned short, unsigned short, unsigned short)
01520 SPECIALIZE_ADD_MUL(add_mul_int, unsigned int, unsigned int, unsigned int)
01521 SPECIALIZE_ADD_MUL(add_mul_int, unsigned long, unsigned long, unsigned long)
01522 SPECIALIZE_ADD_MUL(add_mul_int, unsigned long long, unsigned long long, unsigned long long)
01523
01524 SPECIALIZE_SUB_MUL(sub_mul_int, signed char, signed char, signed char)
01525 SPECIALIZE_SUB_MUL(sub_mul_int, signed short, signed short, signed short)
01526 SPECIALIZE_SUB_MUL(sub_mul_int, signed int, signed int, signed int)
01527 SPECIALIZE_SUB_MUL(sub_mul_int, signed long, signed long, signed long)
01528 SPECIALIZE_SUB_MUL(sub_mul_int, signed long long, signed long long, signed long long)
01529 SPECIALIZE_SUB_MUL(sub_mul_int, unsigned char, unsigned char, unsigned char)
01530 SPECIALIZE_SUB_MUL(sub_mul_int, unsigned short, unsigned short, unsigned short)
01531 SPECIALIZE_SUB_MUL(sub_mul_int, unsigned int, unsigned int, unsigned int)
01532 SPECIALIZE_SUB_MUL(sub_mul_int, unsigned long, unsigned long, unsigned long)
01533 SPECIALIZE_SUB_MUL(sub_mul_int, unsigned long long, unsigned long long, unsigned long long)
01534
01535 SPECIALIZE_INPUT(input_generic, signed char)
01536 SPECIALIZE_INPUT(input_generic, signed short)
01537 SPECIALIZE_INPUT(input_generic, signed int)
01538 SPECIALIZE_INPUT(input_generic, signed long)
01539 SPECIALIZE_INPUT(input_generic, signed long long)
01540 SPECIALIZE_INPUT(input_generic, unsigned char)
01541 SPECIALIZE_INPUT(input_generic, unsigned short)
01542 SPECIALIZE_INPUT(input_generic, unsigned int)
01543 SPECIALIZE_INPUT(input_generic, unsigned long)
01544 SPECIALIZE_INPUT(input_generic, unsigned long long)
01545
01546 SPECIALIZE_OUTPUT(output_char, signed char)
01547 SPECIALIZE_OUTPUT(output_int, signed short)
01548 SPECIALIZE_OUTPUT(output_int, signed int)
01549 SPECIALIZE_OUTPUT(output_int, signed long)
01550 SPECIALIZE_OUTPUT(output_int, signed long long)
01551 SPECIALIZE_OUTPUT(output_char, unsigned char)
01552 SPECIALIZE_OUTPUT(output_int, unsigned short)
01553 SPECIALIZE_OUTPUT(output_int, unsigned int)
01554 SPECIALIZE_OUTPUT(output_int, unsigned long)
01555 SPECIALIZE_OUTPUT(output_int, unsigned long long)
01556
01557 }
01558
01559 }
01560
01561 #endif // !defined(PPL_checked_int_inlines_hh)