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_Number_defs_hh
00024 #define PPL_Checked_Number_defs_hh 1
00025
00026 #include "Checked_Number.types.hh"
00027 #include "checked.defs.hh"
00028 #include "meta_programming.hh"
00029 #include "Slow_Copy.hh"
00030 #include <iosfwd>
00031
00032 namespace Parma_Polyhedra_Library {
00033
00034 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00035
00036 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00037 struct Checked_Number_Default_Policy {
00038 const_bool_nodef(check_overflow, true);
00039 const_bool_nodef(check_inf_add_inf, false);
00040 const_bool_nodef(check_inf_sub_inf, false);
00041 const_bool_nodef(check_inf_mul_zero, false);
00042 const_bool_nodef(check_div_zero, false);
00043 const_bool_nodef(check_inf_div_inf, false);
00044 const_bool_nodef(check_inf_mod, false);
00045 const_bool_nodef(check_sqrt_neg, false);
00046 const_bool_nodef(has_nan, false);
00047 const_bool_nodef(has_infinity, false);
00048 const_bool_nodef(convertible, true);
00049 const_bool_nodef(fpu_check_inexact, true);
00050 const_bool_nodef(check_nan_result, true);
00051 static const Rounding_Dir ROUND_DEFAULT_CONSTRUCTOR = ROUND_NATIVE;
00052 static const Rounding_Dir ROUND_DEFAULT_OPERATOR = ROUND_NATIVE;
00053 static const Rounding_Dir ROUND_DEFAULT_FUNCTION = ROUND_NATIVE;
00054 static const Rounding_Dir ROUND_DEFAULT_INPUT = ROUND_NATIVE;
00055 static const Rounding_Dir ROUND_DEFAULT_OUTPUT = ROUND_NATIVE;
00056 static void handle_result(Result r);
00057 };
00058
00059 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00060
00061 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00062 struct Extended_Number_Policy {
00063 const_bool_nodef(check_overflow, true);
00064 const_bool_nodef(check_inf_add_inf, false);
00065 const_bool_nodef(check_inf_sub_inf, false);
00066 const_bool_nodef(check_inf_mul_zero, false);
00067 const_bool_nodef(check_div_zero, false);
00068 const_bool_nodef(check_inf_div_inf, false);
00069 const_bool_nodef(check_inf_mod, false);
00070 const_bool_nodef(check_sqrt_neg, false);
00071 const_bool_nodef(has_nan, true);
00072 const_bool_nodef(has_infinity, true);
00073
00074
00075
00076 const_bool_nodef(fpu_check_inexact, true);
00077 const_bool_nodef(check_nan_result, true);
00078
00079
00080
00081
00082
00083
00084
00085 static void handle_result(Result r);
00086 };
00087
00088 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00089
00090 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00091 struct WRD_Extended_Number_Policy {
00092 const_bool_nodef(check_overflow, true);
00093 const_bool_nodef(check_inf_add_inf, false);
00094 const_bool_nodef(check_inf_sub_inf, false);
00095 const_bool_nodef(check_inf_mul_zero, false);
00096 const_bool_nodef(check_div_zero, false);
00097 const_bool_nodef(check_inf_div_inf, false);
00098 const_bool_nodef(check_inf_mod, false);
00099 const_bool_nodef(check_sqrt_neg, false);
00100 const_bool_nodef(has_nan, true);
00101 const_bool_nodef(has_infinity, true);
00102
00103
00104
00105 const_bool_nodef(fpu_check_inexact, true);
00106 const_bool_nodef(check_nan_result, false);
00107
00108
00109
00110
00111
00112
00113
00114 static void handle_result(Result r);
00115 };
00116
00117 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00119
00120 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00121 template <typename T>
00122 struct Check_Overflow_Policy {
00123 const_bool_nodef(check_overflow, true);
00124 const_bool_nodef(check_inf_add_inf, false);
00125 const_bool_nodef(check_inf_sub_inf, false);
00126 const_bool_nodef(check_inf_mul_zero, false);
00127 const_bool_nodef(check_div_zero, false);
00128 const_bool_nodef(check_inf_div_inf, false);
00129 const_bool_nodef(check_inf_mod, false);
00130 const_bool_nodef(check_sqrt_neg, false);
00131 const_bool_nodef(has_nan, std::numeric_limits<T>::has_quiet_NaN);
00132 const_bool_nodef(has_infinity, std::numeric_limits<T>::has_infinity);
00133 const_bool_nodef(convertible, true);
00134 const_bool_nodef(fpu_check_inexact, true);
00135 const_bool_nodef(check_nan_result, true);
00136 };
00137
00138 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00139
00140 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00141 template <typename T, typename Enable = void>
00142 struct Native_Checked_From_Wrapper;
00143
00144 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00145
00146 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00147 template <typename T>
00148 struct Native_Checked_From_Wrapper<T, typename Enable_If<Is_Native<T>::value>::type> {
00149 typedef Checked_Number_Transparent_Policy<T> Policy;
00150 static const T& raw_value(const T& v) {
00151 return v;
00152 }
00153 };
00154
00155 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00156
00157 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00158 template <typename T, typename P>
00159 struct Native_Checked_From_Wrapper<Checked_Number<T, P> > {
00160 typedef P Policy;
00161 static const T& raw_value(const Checked_Number<T, P>& v) {
00162 return v.raw_value();
00163 }
00164 };
00165
00166 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00167
00168 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00169 template <typename T, typename Enable = void>
00170 struct Native_Checked_To_Wrapper;
00171
00172 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00173
00174 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00175 template <typename T>
00176 struct Native_Checked_To_Wrapper<T, typename Enable_If<Is_Native<T>::value>::type> {
00177 typedef Check_Overflow_Policy<T> Policy;
00178 static T& raw_value(T& v) {
00179 return v;
00180 }
00181 };
00182
00183 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00184
00185 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00186 template <typename T, typename P>
00187 struct Native_Checked_To_Wrapper<Checked_Number<T, P> > {
00188 typedef P Policy;
00189 static T& raw_value(Checked_Number<T, P>& v) {
00190 return v.raw_value();
00191 }
00192 };
00193
00195 template <typename T>
00196 struct Is_Checked : public False { };
00197
00199 template <typename T, typename P>
00200 struct Is_Checked<Checked_Number<T, P> > : public True { };
00201
00203 template <typename T>
00204 struct Is_Native_Or_Checked
00205 : public Bool<Is_Native<T>::value || Is_Checked<T>::value> { };
00206
00208
00215 template <typename T, typename Policy>
00216 class Checked_Number {
00217 public:
00218
00220
00221
00223 Checked_Number();
00224
00226 Checked_Number(const Checked_Number& y);
00227
00229 template <typename From, typename From_Policy>
00230 Checked_Number(const Checked_Number<From, From_Policy>& y, Rounding_Dir dir);
00231
00233 Checked_Number(signed char y, Rounding_Dir dir);
00234
00236 Checked_Number(signed short y, Rounding_Dir dir);
00237
00239 Checked_Number(signed int y, Rounding_Dir dir);
00240
00242 Checked_Number(signed long y, Rounding_Dir dir);
00243
00245 Checked_Number(signed long long y, Rounding_Dir dir);
00246
00248 Checked_Number(unsigned char y, Rounding_Dir dir);
00249
00251 Checked_Number(unsigned short y, Rounding_Dir dir);
00252
00254 Checked_Number(unsigned int y, Rounding_Dir dir);
00255
00257 Checked_Number(unsigned long y, Rounding_Dir dir);
00258
00260 Checked_Number(unsigned long long y, Rounding_Dir dir);
00261
00262 #if PPL_SUPPORTED_FLOAT
00264 Checked_Number(float y, Rounding_Dir dir);
00265 #endif
00266
00267 #if PPL_SUPPORTED_DOUBLE
00269 Checked_Number(double y, Rounding_Dir dir);
00270 #endif
00271
00272 #if PPL_SUPPORTED_LONG_DOUBLE
00274 Checked_Number(long double y, Rounding_Dir dir);
00275 #endif
00276
00278 Checked_Number(const mpq_class& y, Rounding_Dir dir);
00279
00281 Checked_Number(const mpz_class& y, Rounding_Dir dir);
00282
00284 Checked_Number(const char* y, Rounding_Dir dir);
00285
00287 template <typename From>
00288 Checked_Number(const From&, Rounding_Dir dir, typename Enable_If<Is_Special<From>::value, bool>::type ignored = false);
00289
00291 template <typename From, typename From_Policy>
00292 explicit Checked_Number(const Checked_Number<From, From_Policy>& y);
00293
00295 Checked_Number(signed char y);
00296
00298 Checked_Number(signed short y);
00299
00301 Checked_Number(signed int y);
00302
00304 Checked_Number(signed long y);
00305
00307 Checked_Number(signed long long y);
00308
00310 Checked_Number(unsigned char y);
00311
00313 Checked_Number(unsigned short y);
00314
00316 Checked_Number(unsigned int y);
00317
00319 Checked_Number(unsigned long y);
00320
00322 Checked_Number(unsigned long long y);
00323
00325 Checked_Number(float y);
00326
00328 Checked_Number(double y);
00329
00331 Checked_Number(long double y);
00332
00334 Checked_Number(const mpq_class& y);
00335
00337 Checked_Number(const mpz_class& y);
00338
00340 Checked_Number(const char* y);
00341
00343 template <typename From>
00344 Checked_Number(const From&, typename Enable_If<Is_Special<From>::value, bool>::type ignored = false);
00345
00346
00348
00350
00351
00353 operator T() const;
00354
00356 T& raw_value();
00357
00359 const T& raw_value() const;
00360
00362
00364 bool OK() const;
00365
00367
00376 Result classify(bool nan = true, bool inf = true, bool sign = true) const;
00377
00379
00380
00382 Checked_Number& operator=(const Checked_Number& y);
00383
00385 template <typename From>
00386 Checked_Number& operator=(const From& y);
00387
00389 template <typename From_Policy>
00390 Checked_Number& operator+=(const Checked_Number<T, From_Policy>& y);
00391
00393 Checked_Number& operator+=(const T& y);
00394
00396 template <typename From>
00397 typename Enable_If<Is_Native_Or_Checked<From>::value,
00398 Checked_Number<T, Policy>&>::type
00399 operator+=(const From& y);
00400
00402 template <typename From_Policy>
00403 Checked_Number& operator-=(const Checked_Number<T, From_Policy>& y);
00404
00406 Checked_Number& operator-=(const T& y);
00407
00409 template <typename From>
00410 typename Enable_If<Is_Native_Or_Checked<From>::value,
00411 Checked_Number<T, Policy>&>::type
00412 operator-=(const From& y);
00413
00415 template <typename From_Policy>
00416 Checked_Number& operator*=(const Checked_Number<T, From_Policy>& y);
00417
00419 Checked_Number& operator*=(const T& y);
00420
00422 template <typename From>
00423 typename Enable_If<Is_Native_Or_Checked<From>::value,
00424 Checked_Number<T, Policy>&>::type
00425 operator*=(const From& y);
00426
00428 template <typename From_Policy>
00429 Checked_Number& operator/=(const Checked_Number<T, From_Policy>& y);
00430
00432 Checked_Number& operator/=(const T& y);
00433
00435 template <typename From>
00436 typename Enable_If<Is_Native_Or_Checked<From>::value,
00437 Checked_Number<T, Policy>&>::type
00438 operator/=(const From& y);
00439
00441 template <typename From_Policy>
00442 Checked_Number& operator%=(const Checked_Number<T, From_Policy>& y);
00443
00445 Checked_Number& operator%=(const T& y);
00446
00448 template <typename From>
00449 typename Enable_If<Is_Native_Or_Checked<From>::value,
00450 Checked_Number<T, Policy>& >::type
00451 operator%=(const From& y);
00452
00454
00455
00457
00458
00460 Checked_Number& operator++();
00461
00463 Checked_Number operator++(int);
00464
00466 Checked_Number& operator--();
00467
00469 Checked_Number operator--(int);
00470
00472
00473 private:
00475 T v;
00476 };
00477
00478 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00479
00480 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00481 template <typename T, typename P>
00482 struct Slow_Copy<Checked_Number<T, P> > : public Bool<Slow_Copy<T>::value> {};
00483
00485 template <typename T>
00486 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00487 is_not_a_number(const T& x);
00488
00490 template <typename T>
00491 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00492 is_minus_infinity(const T& x);
00493
00495 template <typename T>
00496 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00497 is_plus_infinity(const T& x);
00498
00500 template <typename T>
00501 typename Enable_If<Is_Native_Or_Checked<T>::value, int>::type
00502 is_infinity(const T& x);
00503
00505 template <typename T>
00506 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00507 is_integer(const T& x);
00508
00510 template <typename To, typename From>
00511 typename Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type
00512 construct(To& to, const From& x, Rounding_Dir dir);
00513
00515 template <typename To, typename From>
00516 typename Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type
00517 assign_r(To& to, const From& x, Rounding_Dir dir);
00518
00520 template <typename To>
00521 typename Enable_If<Is_Native_Or_Checked<To>::value, Result>::type
00522 assign_r(To& to, const char* x, Rounding_Dir dir);
00523
00525 template <typename To, typename To_Policy>
00526 typename Enable_If<Is_Native_Or_Checked<To>::value, Result>::type
00527 assign_r(To& to, char* x, Rounding_Dir dir);
00528
00529 #define FUNC1(name) \
00530 template <typename To, typename From> \
00531 typename Enable_If<Is_Native_Or_Checked<To>::value \
00532 && Is_Native_Or_Checked<From>::value, \
00533 Result>::type \
00534 name(To& to, const From& x, Rounding_Dir dir);
00535
00536 FUNC1(assign_r)
00537 FUNC1(floor_assign_r)
00538 FUNC1(ceil_assign_r)
00539 FUNC1(trunc_assign_r)
00540 FUNC1(neg_assign_r)
00541 FUNC1(abs_assign_r)
00542 FUNC1(sqrt_assign_r)
00543
00544 #undef FUNC1
00545
00546 #define FUNC1(name) \
00547 template <typename To, typename From> \
00548 typename Enable_If<Is_Native_Or_Checked<To>::value \
00549 && Is_Native_Or_Checked<From>::value, \
00550 Result>::type \
00551 name(To& to, const From& x, int exp, Rounding_Dir dir);
00552
00553 FUNC1(mul2exp_assign_r)
00554 FUNC1(div2exp_assign_r)
00555
00556 #undef FUNC1
00557
00558 #define FUNC2(name) \
00559 template <typename To, typename From1, typename From2> \
00560 typename Enable_If<Is_Native_Or_Checked<To>::value \
00561 && Is_Native_Or_Checked<From1>::value \
00562 && Is_Native_Or_Checked<From2>::value, \
00563 Result>::type \
00564 name(To& to, const From1& x, const From2& y, Rounding_Dir dir);
00565
00566 FUNC2(add_assign_r)
00567 FUNC2(sub_assign_r)
00568 FUNC2(mul_assign_r)
00569 FUNC2(div_assign_r)
00570 FUNC2(idiv_assign_r)
00571 FUNC2(rem_assign_r)
00572 FUNC2(gcd_assign_r)
00573 FUNC2(lcm_assign_r)
00574 FUNC2(add_mul_assign_r)
00575 FUNC2(sub_mul_assign_r)
00576
00577 #undef FUNC2
00578
00579 #define FUNC4(name) \
00580 template <typename To1, typename To2, typename To3, \
00581 typename From1, typename From2> \
00582 typename Enable_If<Is_Native_Or_Checked<To1>::value \
00583 && Is_Native_Or_Checked<To2>::value \
00584 && Is_Native_Or_Checked<To3>::value \
00585 && Is_Native_Or_Checked<From1>::value \
00586 && Is_Native_Or_Checked<From2>::value, \
00587 Result>::type \
00588 name(To1& to, To2& s, To3& t, \
00589 const From1& x, const From2& y, \
00590 Rounding_Dir dir);
00591
00592 FUNC4(gcdext_assign_r)
00593
00594 #undef FUNC4
00595
00597
00598
00600
00602
00603
00605
00606 template <typename T, typename Policy>
00607 size_t
00608 total_memory_in_bytes(const Checked_Number<T, Policy>& x);
00609
00611
00612 template <typename T, typename Policy>
00613 memory_size_type
00614 external_memory_in_bytes(const Checked_Number<T, Policy>& x);
00615
00617
00619
00620
00622
00623 template <typename T, typename Policy>
00624 Checked_Number<T, Policy>
00625 operator+(const Checked_Number<T, Policy>& x);
00626
00628
00629 template <typename T, typename Policy>
00630 Checked_Number<T, Policy>
00631 operator-(const Checked_Number<T, Policy>& x);
00632
00634
00635 template <typename T, typename Policy>
00636 void
00637 floor_assign(Checked_Number<T, Policy>& x);
00638
00640
00641 template <typename T, typename Policy>
00642 void
00643 floor_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00644
00646
00647 template <typename T, typename Policy>
00648 void
00649 ceil_assign(Checked_Number<T, Policy>& x);
00650
00652
00653 template <typename T, typename Policy>
00654 void
00655 ceil_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00656
00658
00659 template <typename T, typename Policy>
00660 void
00661 trunc_assign(Checked_Number<T, Policy>& x);
00662
00664
00665 template <typename T, typename Policy>
00666 void
00667 trunc_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00668
00670
00671 template <typename T, typename Policy>
00672 void
00673 neg_assign(Checked_Number<T, Policy>& x);
00674
00676
00677 template <typename T, typename Policy>
00678 void
00679 neg_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00680
00682
00683 template <typename T, typename Policy>
00684 void
00685 abs_assign(Checked_Number<T, Policy>& x);
00686
00688
00689 template <typename T, typename Policy>
00690 void
00691 abs_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00692
00694
00695 template <typename T, typename Policy>
00696 void
00697 add_mul_assign(Checked_Number<T, Policy>& x,
00698 const Checked_Number<T, Policy>& y,
00699 const Checked_Number<T, Policy>& z);
00700
00702
00703 template <typename T, typename Policy>
00704 void
00705 sub_mul_assign(Checked_Number<T, Policy>& x,
00706 const Checked_Number<T, Policy>& y,
00707 const Checked_Number<T, Policy>& z);
00708
00710
00711 template <typename T, typename Policy>
00712 void
00713 gcd_assign(Checked_Number<T, Policy>& x,
00714 const Checked_Number<T, Policy>& y,
00715 const Checked_Number<T, Policy>& z);
00716
00722 template <typename T, typename Policy>
00723 void
00724 gcdext_assign(Checked_Number<T, Policy>& x,
00725 Checked_Number<T, Policy>& s,
00726 Checked_Number<T, Policy>& t,
00727 const Checked_Number<T, Policy>& y,
00728 const Checked_Number<T, Policy>& z);
00729
00731
00732 template <typename T, typename Policy>
00733 void
00734 lcm_assign(Checked_Number<T, Policy>& x,
00735 const Checked_Number<T, Policy>& y,
00736 const Checked_Number<T, Policy>& z);
00737
00745 template <typename T, typename Policy>
00746 void
00747 exact_div_assign(Checked_Number<T, Policy>& x,
00748 const Checked_Number<T, Policy>& y,
00749 const Checked_Number<T, Policy>& z);
00750
00752
00753 template <typename T, typename Policy>
00754 void sqrt_assign(Checked_Number<T, Policy>& x,
00755 const Checked_Number<T, Policy>& y);
00756
00758
00759
00761
00762
00764
00765 template <typename T1, typename T2>
00766 inline
00767 typename Enable_If<Is_Native_Or_Checked<T1>::value
00768 && Is_Native_Or_Checked<T2>::value
00769 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00770 bool>::type
00771 operator==(const T1& x, const T2& y);
00772
00773 template <typename T1, typename T2>
00774 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00775 && Is_Native_Or_Checked<T2>::value,
00776 bool>::type
00777 equal(const T1& x, const T2& y);
00778
00780
00781 template <typename T1, typename T2>
00782 inline
00783 typename Enable_If<Is_Native_Or_Checked<T1>::value
00784 && Is_Native_Or_Checked<T2>::value
00785 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00786 bool>::type
00787 operator!=(const T1& x, const T2& y);
00788
00789 template <typename T1, typename T2>
00790 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00791 && Is_Native_Or_Checked<T2>::value,
00792 bool>::type
00793 not_equal(const T1& x, const T2& y);
00794
00796
00797 template <typename T1, typename T2>
00798 inline
00799 typename Enable_If<Is_Native_Or_Checked<T1>::value
00800 && Is_Native_Or_Checked<T2>::value
00801 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00802 bool>::type
00803 operator>=(const T1& x, const T2& y);
00804
00805 template <typename T1, typename T2>
00806 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00807 && Is_Native_Or_Checked<T2>::value,
00808 bool>::type
00809 greater_or_equal(const T1& x, const T2& y);
00810
00812
00813 template <typename T1, typename T2>
00814 inline
00815 typename Enable_If<Is_Native_Or_Checked<T1>::value
00816 && Is_Native_Or_Checked<T2>::value
00817 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00818 bool>::type
00819 operator>(const T1& x, const T2& y);
00820
00821 template <typename T1, typename T2>
00822 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00823 && Is_Native_Or_Checked<T2>::value,
00824 bool>::type
00825 greater_than(const T1& x, const T2& y);
00826
00828
00829 template <typename T1, typename T2>
00830 inline
00831 typename Enable_If<Is_Native_Or_Checked<T1>::value
00832 && Is_Native_Or_Checked<T2>::value
00833 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00834 bool>::type
00835 operator<=(const T1& x, const T2& y);
00836
00837 template <typename T1, typename T2>
00838 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00839 && Is_Native_Or_Checked<T2>::value,
00840 bool>::type
00841 less_or_equal(const T1& x, const T2& y);
00842
00844
00845 template <typename T1, typename T2>
00846 inline
00847 typename Enable_If<Is_Native_Or_Checked<T1>::value
00848 && Is_Native_Or_Checked<T2>::value
00849 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00850 bool>::type
00851 operator<(const T1& x, const T2& y);
00852
00853 template <typename T1, typename T2>
00854 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00855 && Is_Native_Or_Checked<T2>::value,
00856 bool>::type
00857 less_than(const T1& x, const T2& y);
00858
00865 template <typename From>
00866 inline typename Enable_If<Is_Native_Or_Checked<From>::value, int>::type \
00867 sgn(const From& x);
00868
00875 template <typename From1, typename From2>
00876 inline typename Enable_If<Is_Native_Or_Checked<From1>::value
00877 && Is_Native_Or_Checked<From2>::value,
00878 int>::type
00879 cmp(const From1& x, const From2& y);
00880
00882
00884
00885
00887 template <typename T>
00888 typename Enable_If<Is_Native_Or_Checked<T>::value, Result>::type
00889 output(std::ostream& os,
00890 const T& x,
00891 const Numeric_Format& fmt,
00892 Rounding_Dir dir);
00893
00895
00896 template <typename T, typename Policy>
00897 std::ostream&
00898 operator<<(std::ostream& os, const Checked_Number<T, Policy>& x);
00899
00901 template <typename T>
00902 typename Enable_If<Is_Native_Or_Checked<T>::value, void>::type
00903 ascii_dump(std::ostream& s, const T& t);
00904
00906
01026 template <typename T>
01027 typename Enable_If<Is_Native_Or_Checked<T>::value, Result>::type
01028 input(T& x, std::istream& is, Rounding_Dir dir);
01029
01031
01032 template <typename T, typename Policy>
01033 std::istream&
01034 operator>>(std::istream& is, Checked_Number<T, Policy>& x);
01035
01037 template <typename T>
01038 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
01039 ascii_load(std::ostream& s, T& t);
01040
01042
01043 void throw_result_exception(Result r);
01044
01045 template <typename T>
01046 T
01047 plus_infinity();
01048
01049 template <typename T>
01050 T
01051 minus_infinity();
01052
01053 template <typename T>
01054 T
01055 not_a_number();
01056
01058
01059 template <typename T, typename Policy>
01060 void swap(Checked_Number<T, Policy>& x, Checked_Number<T, Policy>& y);
01061
01062 template <typename T, typename Policy>
01063 struct FPU_Related<Checked_Number<T, Policy> > : public FPU_Related<T> {};
01064
01065 template <typename T>
01066 void maybe_reset_fpu_inexact();
01067
01068 template <typename T>
01069 int maybe_check_fpu_inexact();
01070
01071 }
01072
01073 #include "Checked_Number.inlines.hh"
01074 #include "checked_numeric_limits.hh"
01075 #include "Checked_Number.templates.hh"
01076
01077 #endif // !defined(PPL_Checked_Number_defs_hh)