00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024 #ifndef PPL_Checked_Number_defs_hh
00025 #define PPL_Checked_Number_defs_hh 1
00026
00027 #include "Checked_Number.types.hh"
00028 #include "checked.defs.hh"
00029 #include "meta_programming.hh"
00030 #include "Slow_Copy.hh"
00031 #include <iosfwd>
00032
00033 namespace Parma_Polyhedra_Library {
00034
00035 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00036
00037 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00038 struct Extended_Number_Policy {
00039 const_bool_nodef(check_overflow, true);
00040 const_bool_nodef(check_inf_add_inf, false);
00041 const_bool_nodef(check_inf_sub_inf, false);
00042 const_bool_nodef(check_inf_mul_zero, false);
00043 const_bool_nodef(check_div_zero, false);
00044 const_bool_nodef(check_inf_div_inf, false);
00045 const_bool_nodef(check_inf_mod, false);
00046 const_bool_nodef(check_sqrt_neg, false);
00047 const_bool_nodef(has_nan, true);
00048 const_bool_nodef(has_infinity, true);
00049
00050
00051
00052 const_bool_nodef(fpu_check_inexact, true);
00053 const_bool_nodef(fpu_check_nan_result, true);
00054
00055
00056
00057
00058
00059
00060
00061 static void handle_result(Result r);
00062 };
00063
00064 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00065
00066
00067 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00068 template <typename T>
00069 struct Check_Overflow_Policy {
00070 const_bool_nodef(check_overflow, true);
00071 const_bool_nodef(check_inf_add_inf, false);
00072 const_bool_nodef(check_inf_sub_inf, false);
00073 const_bool_nodef(check_inf_mul_zero, false);
00074 const_bool_nodef(check_div_zero, false);
00075 const_bool_nodef(check_inf_div_inf, false);
00076 const_bool_nodef(check_inf_mod, false);
00077 const_bool_nodef(check_sqrt_neg, false);
00078 const_bool_nodef(has_nan, std::numeric_limits<T>::has_quiet_NaN);
00079 const_bool_nodef(has_infinity, std::numeric_limits<T>::has_infinity);
00080 const_bool_nodef(convertible, true);
00081 const_bool_nodef(fpu_check_inexact, true);
00082 const_bool_nodef(fpu_check_nan_result, true);
00083 };
00084
00085 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00086
00087 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00088 template <typename T, typename Enable = void>
00089 struct Native_Checked_From_Wrapper;
00090
00091 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00092
00093 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00094 template <typename T>
00095 struct Native_Checked_From_Wrapper<T, typename Enable_If<Is_Native<T>::value>::type> {
00096 typedef Checked_Number_Transparent_Policy<T> Policy;
00097 static const T& raw_value(const T& v) {
00098 return v;
00099 }
00100 };
00101
00102 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00103
00104 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00105 template <typename T, typename P>
00106 struct Native_Checked_From_Wrapper<Checked_Number<T, P> > {
00107 typedef P Policy;
00108 static const T& raw_value(const Checked_Number<T, P>& v) {
00109 return v.raw_value();
00110 }
00111 };
00112
00113 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00114
00115 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00116 template <typename T, typename Enable = void>
00117 struct Native_Checked_To_Wrapper;
00118
00119 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00120
00121 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00122 template <typename T>
00123 struct Native_Checked_To_Wrapper<T, typename Enable_If<Is_Native<T>::value>::type> {
00124 typedef Check_Overflow_Policy<T> Policy;
00125 static T& raw_value(T& v) {
00126 return v;
00127 }
00128 };
00129
00130 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00131
00132 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00133 template <typename T, typename P>
00134 struct Native_Checked_To_Wrapper<Checked_Number<T, P> > {
00135 typedef P Policy;
00136 static T& raw_value(Checked_Number<T, P>& v) {
00137 return v.raw_value();
00138 }
00139 };
00140
00142 template <typename T>
00143 struct Is_Checked : public False { };
00144
00146 template <typename T, typename P>
00147 struct Is_Checked<Checked_Number<T, P> > : public True { };
00148
00150 template <typename T>
00151 struct Is_Native_Or_Checked
00152 : public Bool<Is_Native<T>::value || Is_Checked<T>::value> { };
00153
00155
00162 template <typename T, typename Policy>
00163 class Checked_Number {
00164 public:
00165
00167
00168
00170 Checked_Number();
00171
00173 Checked_Number(const Checked_Number& y);
00174
00176 template <typename From, typename From_Policy>
00177 Checked_Number(const Checked_Number<From, From_Policy>& y, Rounding_Dir dir);
00178
00180 Checked_Number(char y, Rounding_Dir dir);
00181
00183 Checked_Number(signed char y, Rounding_Dir dir);
00184
00186 Checked_Number(signed short y, Rounding_Dir dir);
00187
00189 Checked_Number(signed int y, Rounding_Dir dir);
00190
00192 Checked_Number(signed long y, Rounding_Dir dir);
00193
00195 Checked_Number(signed long long y, Rounding_Dir dir);
00196
00198 Checked_Number(unsigned char y, Rounding_Dir dir);
00199
00201 Checked_Number(unsigned short y, Rounding_Dir dir);
00202
00204 Checked_Number(unsigned int y, Rounding_Dir dir);
00205
00207 Checked_Number(unsigned long y, Rounding_Dir dir);
00208
00210 Checked_Number(unsigned long long y, Rounding_Dir dir);
00211
00212 #if PPL_SUPPORTED_FLOAT
00213
00214 Checked_Number(float y, Rounding_Dir dir);
00215 #endif
00216
00217 #if PPL_SUPPORTED_DOUBLE
00218
00219 Checked_Number(double y, Rounding_Dir dir);
00220 #endif
00221
00222 #if PPL_SUPPORTED_LONG_DOUBLE
00223
00224 Checked_Number(long double y, Rounding_Dir dir);
00225 #endif
00226
00228 Checked_Number(const mpq_class& y, Rounding_Dir dir);
00229
00231 Checked_Number(const mpz_class& y, Rounding_Dir dir);
00232
00234 Checked_Number(const char* y, Rounding_Dir dir);
00235
00237 template <typename From>
00238 Checked_Number(const From&, Rounding_Dir dir, typename Enable_If<Is_Special<From>::value, bool>::type ignored = false);
00239
00241 template <typename From, typename From_Policy>
00242 explicit Checked_Number(const Checked_Number<From, From_Policy>& y);
00243
00245 Checked_Number(char y);
00246
00248 Checked_Number(signed char y);
00249
00251 Checked_Number(signed short y);
00252
00254 Checked_Number(signed int y);
00255
00257 Checked_Number(signed long y);
00258
00260 Checked_Number(signed long long y);
00261
00263 Checked_Number(unsigned char y);
00264
00266 Checked_Number(unsigned short y);
00267
00269 Checked_Number(unsigned int y);
00270
00272 Checked_Number(unsigned long y);
00273
00275 Checked_Number(unsigned long long y);
00276
00278 Checked_Number(float y);
00279
00281 Checked_Number(double y);
00282
00284 Checked_Number(long double y);
00285
00287 Checked_Number(const mpq_class& y);
00288
00290 Checked_Number(const mpz_class& y);
00291
00293 Checked_Number(const char* y);
00294
00296 template <typename From>
00297 Checked_Number(const From&, typename Enable_If<Is_Special<From>::value, bool>::type ignored = false);
00298
00299
00301
00303
00304
00306 operator T() const;
00307
00309 T& raw_value();
00310
00312 const T& raw_value() const;
00313
00315
00317 bool OK() const;
00318
00320
00329 Result classify(bool nan = true, bool inf = true, bool sign = true) const;
00330
00332
00333
00335 Checked_Number& operator=(const Checked_Number& y);
00336
00338 template <typename From>
00339 Checked_Number& operator=(const From& y);
00340
00342 template <typename From_Policy>
00343 Checked_Number& operator+=(const Checked_Number<T, From_Policy>& y);
00344
00346 Checked_Number& operator+=(const T& y);
00347
00349 template <typename From>
00350 typename Enable_If<Is_Native_Or_Checked<From>::value,
00351 Checked_Number<T, Policy>&>::type
00352 operator+=(const From& y);
00353
00355 template <typename From_Policy>
00356 Checked_Number& operator-=(const Checked_Number<T, From_Policy>& y);
00357
00359 Checked_Number& operator-=(const T& y);
00360
00362 template <typename From>
00363 typename Enable_If<Is_Native_Or_Checked<From>::value,
00364 Checked_Number<T, Policy>&>::type
00365 operator-=(const From& y);
00366
00368 template <typename From_Policy>
00369 Checked_Number& operator*=(const Checked_Number<T, From_Policy>& y);
00370
00372 Checked_Number& operator*=(const T& y);
00373
00375 template <typename From>
00376 typename Enable_If<Is_Native_Or_Checked<From>::value,
00377 Checked_Number<T, Policy>&>::type
00378 operator*=(const From& y);
00379
00381 template <typename From_Policy>
00382 Checked_Number& operator/=(const Checked_Number<T, From_Policy>& y);
00383
00385 Checked_Number& operator/=(const T& y);
00386
00388 template <typename From>
00389 typename Enable_If<Is_Native_Or_Checked<From>::value,
00390 Checked_Number<T, Policy>&>::type
00391 operator/=(const From& y);
00392
00394 template <typename From_Policy>
00395 Checked_Number& operator%=(const Checked_Number<T, From_Policy>& y);
00396
00398 Checked_Number& operator%=(const T& y);
00399
00401 template <typename From>
00402 typename Enable_If<Is_Native_Or_Checked<From>::value,
00403 Checked_Number<T, Policy>& >::type
00404 operator%=(const From& y);
00405
00407
00408
00410
00411
00413 Checked_Number& operator++();
00414
00416 Checked_Number operator++(int);
00417
00419 Checked_Number& operator--();
00420
00422 Checked_Number operator--(int);
00423
00425
00426 private:
00428 T v;
00429 };
00430
00431 #ifdef PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS
00432
00433 #endif // defined(PPL_DOXYGEN_INCLUDE_IMPLEMENTATION_DETAILS)
00434 template <typename T, typename P>
00435 struct Slow_Copy<Checked_Number<T, P> > : public Bool<Slow_Copy<T>::value> {};
00436
00438 template <typename T>
00439 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00440 is_not_a_number(const T& x);
00441
00443 template <typename T>
00444 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00445 is_minus_infinity(const T& x);
00446
00448 template <typename T>
00449 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00450 is_plus_infinity(const T& x);
00451
00453 template <typename T>
00454 typename Enable_If<Is_Native_Or_Checked<T>::value, int>::type
00455 is_infinity(const T& x);
00456
00458 template <typename T>
00459 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
00460 is_integer(const T& x);
00461
00463 template <typename To, typename From>
00464 typename Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type
00465 construct(To& to, const From& x, Rounding_Dir dir);
00466
00468 template <typename To, typename From>
00469 typename Enable_If<Is_Native_Or_Checked<To>::value && Is_Special<From>::value, Result>::type
00470 assign_r(To& to, const From& x, Rounding_Dir dir);
00471
00473 template <typename To>
00474 typename Enable_If<Is_Native_Or_Checked<To>::value, Result>::type
00475 assign_r(To& to, const char* x, Rounding_Dir dir);
00476
00478 template <typename To, typename To_Policy>
00479 typename Enable_If<Is_Native_Or_Checked<To>::value, Result>::type
00480 assign_r(To& to, char* x, Rounding_Dir dir);
00481
00482 #define PPL_DECLARE_FUNC1_A(name) \
00483 template <typename To, typename From> \
00484 typename Enable_If<Is_Native_Or_Checked<To>::value \
00485 && Is_Native_Or_Checked<From>::value, \
00486 Result>::type \
00487 name(To& to, const From& x, Rounding_Dir dir);
00488
00489 PPL_DECLARE_FUNC1_A(assign_r)
00490 PPL_DECLARE_FUNC1_A(floor_assign_r)
00491 PPL_DECLARE_FUNC1_A(ceil_assign_r)
00492 PPL_DECLARE_FUNC1_A(trunc_assign_r)
00493 PPL_DECLARE_FUNC1_A(neg_assign_r)
00494 PPL_DECLARE_FUNC1_A(abs_assign_r)
00495 PPL_DECLARE_FUNC1_A(sqrt_assign_r)
00496
00497 #undef PPL_DECLARE_FUNC1_A
00498
00499 #define PPL_DECLARE_FUNC1_B(name) \
00500 template <typename To, typename From> \
00501 typename Enable_If<Is_Native_Or_Checked<To>::value \
00502 && Is_Native_Or_Checked<From>::value, \
00503 Result>::type \
00504 name(To& to, const From& x, int exp, Rounding_Dir dir);
00505
00506 PPL_DECLARE_FUNC1_B(add_2exp_assign_r)
00507 PPL_DECLARE_FUNC1_B(sub_2exp_assign_r)
00508 PPL_DECLARE_FUNC1_B(mul_2exp_assign_r)
00509 PPL_DECLARE_FUNC1_B(div_2exp_assign_r)
00510 PPL_DECLARE_FUNC1_B(smod_2exp_assign_r)
00511 PPL_DECLARE_FUNC1_B(umod_2exp_assign_r)
00512
00513 #undef PPL_DECLARE_FUNC1_B
00514
00515 #define PPL_DECLARE_FUNC2(name) \
00516 template <typename To, typename From1, typename From2> \
00517 typename Enable_If<Is_Native_Or_Checked<To>::value \
00518 && Is_Native_Or_Checked<From1>::value \
00519 && Is_Native_Or_Checked<From2>::value, \
00520 Result>::type \
00521 name(To& to, const From1& x, const From2& y, Rounding_Dir dir);
00522
00523 PPL_DECLARE_FUNC2(add_assign_r)
00524 PPL_DECLARE_FUNC2(sub_assign_r)
00525 PPL_DECLARE_FUNC2(mul_assign_r)
00526 PPL_DECLARE_FUNC2(div_assign_r)
00527 PPL_DECLARE_FUNC2(idiv_assign_r)
00528 PPL_DECLARE_FUNC2(rem_assign_r)
00529 PPL_DECLARE_FUNC2(gcd_assign_r)
00530 PPL_DECLARE_FUNC2(lcm_assign_r)
00531 PPL_DECLARE_FUNC2(add_mul_assign_r)
00532 PPL_DECLARE_FUNC2(sub_mul_assign_r)
00533
00534 #undef PPL_DECLARE_FUNC2
00535
00536 #define PPL_DECLARE_FUNC4(name) \
00537 template <typename To1, typename To2, typename To3, \
00538 typename From1, typename From2> \
00539 typename Enable_If<Is_Native_Or_Checked<To1>::value \
00540 && Is_Native_Or_Checked<To2>::value \
00541 && Is_Native_Or_Checked<To3>::value \
00542 && Is_Native_Or_Checked<From1>::value \
00543 && Is_Native_Or_Checked<From2>::value, \
00544 Result>::type \
00545 name(To1& to, To2& s, To3& t, \
00546 const From1& x, const From2& y, \
00547 Rounding_Dir dir);
00548
00549 PPL_DECLARE_FUNC4(gcdext_assign_r)
00550
00551 #undef PPL_DECLARE_FUNC4
00552
00554
00555
00557
00559
00560
00562
00563 template <typename T, typename Policy>
00564 size_t
00565 total_memory_in_bytes(const Checked_Number<T, Policy>& x);
00566
00568
00569 template <typename T, typename Policy>
00570 memory_size_type
00571 external_memory_in_bytes(const Checked_Number<T, Policy>& x);
00572
00574
00576
00577
00579
00580 template <typename T, typename Policy>
00581 Checked_Number<T, Policy>
00582 operator+(const Checked_Number<T, Policy>& x);
00583
00585
00586 template <typename T, typename Policy>
00587 Checked_Number<T, Policy>
00588 operator-(const Checked_Number<T, Policy>& x);
00589
00591
00592 template <typename T, typename Policy>
00593 void
00594 floor_assign(Checked_Number<T, Policy>& x);
00595
00597
00598 template <typename T, typename Policy>
00599 void
00600 floor_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00601
00603
00604 template <typename T, typename Policy>
00605 void
00606 ceil_assign(Checked_Number<T, Policy>& x);
00607
00609
00610 template <typename T, typename Policy>
00611 void
00612 ceil_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00613
00615
00616 template <typename T, typename Policy>
00617 void
00618 trunc_assign(Checked_Number<T, Policy>& x);
00619
00621
00622 template <typename T, typename Policy>
00623 void
00624 trunc_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00625
00627
00628 template <typename T, typename Policy>
00629 void
00630 neg_assign(Checked_Number<T, Policy>& x);
00631
00633
00634 template <typename T, typename Policy>
00635 void
00636 neg_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00637
00639
00640 template <typename T, typename Policy>
00641 void
00642 abs_assign(Checked_Number<T, Policy>& x);
00643
00645
00646 template <typename T, typename Policy>
00647 void
00648 abs_assign(Checked_Number<T, Policy>& x, const Checked_Number<T, Policy>& y);
00649
00651
00652 template <typename T, typename Policy>
00653 void
00654 add_mul_assign(Checked_Number<T, Policy>& x,
00655 const Checked_Number<T, Policy>& y,
00656 const Checked_Number<T, Policy>& z);
00657
00659
00660 template <typename T, typename Policy>
00661 void
00662 sub_mul_assign(Checked_Number<T, Policy>& x,
00663 const Checked_Number<T, Policy>& y,
00664 const Checked_Number<T, Policy>& z);
00665
00667
00668 template <typename T, typename Policy>
00669 void
00670 gcd_assign(Checked_Number<T, Policy>& x,
00671 const Checked_Number<T, Policy>& y,
00672 const Checked_Number<T, Policy>& z);
00673
00679 template <typename T, typename Policy>
00680 void
00681 gcdext_assign(Checked_Number<T, Policy>& x,
00682 Checked_Number<T, Policy>& s,
00683 Checked_Number<T, Policy>& t,
00684 const Checked_Number<T, Policy>& y,
00685 const Checked_Number<T, Policy>& z);
00686
00688
00689 template <typename T, typename Policy>
00690 void
00691 lcm_assign(Checked_Number<T, Policy>& x,
00692 const Checked_Number<T, Policy>& y,
00693 const Checked_Number<T, Policy>& z);
00694
00696
00697 template <typename T, typename Policy>
00698 void
00699 mul_2exp_assign(Checked_Number<T, Policy>& x,
00700 const Checked_Number<T, Policy>& y,
00701 unsigned int exp);
00702
00704
00705 template <typename T, typename Policy>
00706 void
00707 div_2exp_assign(Checked_Number<T, Policy>& x,
00708 const Checked_Number<T, Policy>& y,
00709 unsigned int exp);
00710
00718 template <typename T, typename Policy>
00719 void
00720 exact_div_assign(Checked_Number<T, Policy>& x,
00721 const Checked_Number<T, Policy>& y,
00722 const Checked_Number<T, Policy>& z);
00723
00725
00726 template <typename T, typename Policy>
00727 void sqrt_assign(Checked_Number<T, Policy>& x,
00728 const Checked_Number<T, Policy>& y);
00729
00731
00732
00734
00735
00737
00738 template <typename T1, typename T2>
00739 inline
00740 typename Enable_If<Is_Native_Or_Checked<T1>::value
00741 && Is_Native_Or_Checked<T2>::value
00742 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00743 bool>::type
00744 operator==(const T1& x, const T2& y);
00745
00746 template <typename T1, typename T2>
00747 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00748 && Is_Native_Or_Checked<T2>::value,
00749 bool>::type
00750 equal(const T1& x, const T2& y);
00751
00753
00754 template <typename T1, typename T2>
00755 inline
00756 typename Enable_If<Is_Native_Or_Checked<T1>::value
00757 && Is_Native_Or_Checked<T2>::value
00758 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00759 bool>::type
00760 operator!=(const T1& x, const T2& y);
00761
00762 template <typename T1, typename T2>
00763 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00764 && Is_Native_Or_Checked<T2>::value,
00765 bool>::type
00766 not_equal(const T1& x, const T2& y);
00767
00769
00770 template <typename T1, typename T2>
00771 inline
00772 typename Enable_If<Is_Native_Or_Checked<T1>::value
00773 && Is_Native_Or_Checked<T2>::value
00774 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00775 bool>::type
00776 operator>=(const T1& x, const T2& y);
00777
00778 template <typename T1, typename T2>
00779 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00780 && Is_Native_Or_Checked<T2>::value,
00781 bool>::type
00782 greater_or_equal(const T1& x, const T2& y);
00783
00785
00786 template <typename T1, typename T2>
00787 inline
00788 typename Enable_If<Is_Native_Or_Checked<T1>::value
00789 && Is_Native_Or_Checked<T2>::value
00790 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00791 bool>::type
00792 operator>(const T1& x, const T2& y);
00793
00794 template <typename T1, typename T2>
00795 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00796 && Is_Native_Or_Checked<T2>::value,
00797 bool>::type
00798 greater_than(const T1& x, const T2& y);
00799
00801
00802 template <typename T1, typename T2>
00803 inline
00804 typename Enable_If<Is_Native_Or_Checked<T1>::value
00805 && Is_Native_Or_Checked<T2>::value
00806 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00807 bool>::type
00808 operator<=(const T1& x, const T2& y);
00809
00810 template <typename T1, typename T2>
00811 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00812 && Is_Native_Or_Checked<T2>::value,
00813 bool>::type
00814 less_or_equal(const T1& x, const T2& y);
00815
00817
00818 template <typename T1, typename T2>
00819 inline
00820 typename Enable_If<Is_Native_Or_Checked<T1>::value
00821 && Is_Native_Or_Checked<T2>::value
00822 && (Is_Checked<T1>::value || Is_Checked<T2>::value),
00823 bool>::type
00824 operator<(const T1& x, const T2& y);
00825
00826 template <typename T1, typename T2>
00827 inline typename Enable_If<Is_Native_Or_Checked<T1>::value
00828 && Is_Native_Or_Checked<T2>::value,
00829 bool>::type
00830 less_than(const T1& x, const T2& y);
00831
00838 template <typename From>
00839 inline typename Enable_If<Is_Native_Or_Checked<From>::value, int>::type \
00840 sgn(const From& x);
00841
00848 template <typename From1, typename From2>
00849 inline typename Enable_If<Is_Native_Or_Checked<From1>::value
00850 && Is_Native_Or_Checked<From2>::value,
00851 int>::type
00852 cmp(const From1& x, const From2& y);
00853
00855
00857
00858
00860 template <typename T>
00861 typename Enable_If<Is_Native_Or_Checked<T>::value, Result>::type
00862 output(std::ostream& os,
00863 const T& x,
00864 const Numeric_Format& fmt,
00865 Rounding_Dir dir);
00866
00868
00869 template <typename T, typename Policy>
00870 std::ostream&
00871 operator<<(std::ostream& os, const Checked_Number<T, Policy>& x);
00872
00874 template <typename T>
00875 typename Enable_If<Is_Native_Or_Checked<T>::value, void>::type
00876 ascii_dump(std::ostream& s, const T& t);
00877
00879
01003 template <typename T>
01004 typename Enable_If<Is_Native_Or_Checked<T>::value, Result>::type
01005 input(T& x, std::istream& is, Rounding_Dir dir);
01006
01008
01009 template <typename T, typename Policy>
01010 std::istream&
01011 operator>>(std::istream& is, Checked_Number<T, Policy>& x);
01012
01014 template <typename T>
01015 typename Enable_If<Is_Native_Or_Checked<T>::value, bool>::type
01016 ascii_load(std::ostream& s, T& t);
01017
01019
01020 void throw_result_exception(Result r);
01021
01022 template <typename T>
01023 T
01024 plus_infinity();
01025
01026 template <typename T>
01027 T
01028 minus_infinity();
01029
01030 template <typename T>
01031 T
01032 not_a_number();
01033
01035
01036 template <typename T, typename Policy>
01037 void swap(Checked_Number<T, Policy>& x, Checked_Number<T, Policy>& y);
01038
01039 template <typename T, typename Policy>
01040 struct FPU_Related<Checked_Number<T, Policy> > : public FPU_Related<T> {};
01041
01042 template <typename T>
01043 void maybe_reset_fpu_inexact();
01044
01045 template <typename T>
01046 int maybe_check_fpu_inexact();
01047
01048 }
01049
01050 #include "Checked_Number.inlines.hh"
01051 #include "checked_numeric_limits.hh"
01052 #include "Checked_Number.templates.hh"
01053
01054 #endif // !defined(PPL_Checked_Number_defs_hh)