1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
/* Boost interval/rounded_arith.hpp template implementation file
*
* Copyright 2002-2003 Hervé Brönnimann, Guillaume Melquiond, Sylvain Pion
*
* Distributed under the Boost Software License, Version 1.0.
* (See accompanying file LICENSE_1_0.txt or
* copy at http://www.boost.org/LICENSE_1_0.txt)
*/
#ifndef BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
#define BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
#include <boost/numeric/interval/rounding.hpp>
#include <boost/numeric/interval/detail/bugs.hpp>
#include <boost/config/no_tr1/cmath.hpp>
namespace boost {
namespace numeric {
namespace interval_lib {
/*
* Three classes of rounding: exact, std, opp
* See documentation for details.
*/
template<class T, class Rounding>
struct rounded_arith_exact: Rounding {
void init() { }
template<class U> T conv_down(U const &v) { return v; }
template<class U> T conv_up (U const &v) { return v; }
T add_down (const T& x, const T& y) { return x + y; }
T add_up (const T& x, const T& y) { return x + y; }
T sub_down (const T& x, const T& y) { return x - y; }
T sub_up (const T& x, const T& y) { return x - y; }
T mul_down (const T& x, const T& y) { return x * y; }
T mul_up (const T& x, const T& y) { return x * y; }
T div_down (const T& x, const T& y) { return x / y; }
T div_up (const T& x, const T& y) { return x / y; }
T median (const T& x, const T& y) { return (x + y) / 2; }
T sqrt_down(const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); return sqrt(x); }
T sqrt_up (const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); return sqrt(x); }
T int_down (const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(floor); return floor(x); }
T int_up (const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(ceil); return ceil(x); }
};
template<class T, class Rounding>
struct rounded_arith_std: Rounding {
# define BOOST_DN(EXPR) this->downward(); return this->force_rounding(EXPR)
# define BOOST_NR(EXPR) this->to_nearest(); return this->force_rounding(EXPR)
# define BOOST_UP(EXPR) this->upward(); return this->force_rounding(EXPR)
void init() { }
template<class U> T conv_down(U const &v) { BOOST_DN(v); }
template<class U> T conv_up (U const &v) { BOOST_UP(v); }
T add_down(const T& x, const T& y) { BOOST_DN(x + y); }
T sub_down(const T& x, const T& y) { BOOST_DN(x - y); }
T mul_down(const T& x, const T& y) { BOOST_DN(x * y); }
T div_down(const T& x, const T& y) { BOOST_DN(x / y); }
T add_up (const T& x, const T& y) { BOOST_UP(x + y); }
T sub_up (const T& x, const T& y) { BOOST_UP(x - y); }
T mul_up (const T& x, const T& y) { BOOST_UP(x * y); }
T div_up (const T& x, const T& y) { BOOST_UP(x / y); }
T median(const T& x, const T& y) { BOOST_NR((x + y) / 2); }
T sqrt_down(const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_DN(sqrt(x)); }
T sqrt_up (const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_UP(sqrt(x)); }
T int_down(const T& x) { this->downward(); return to_int(x); }
T int_up (const T& x) { this->upward(); return to_int(x); }
# undef BOOST_DN
# undef BOOST_NR
# undef BOOST_UP
};
template<class T, class Rounding>
struct rounded_arith_opp: Rounding {
void init() { this->upward(); }
# define BOOST_DN(EXPR) \
this->downward(); \
T r = this->force_rounding(EXPR); \
this->upward(); \
return r
# define BOOST_NR(EXPR) \
this->to_nearest(); \
T r = this->force_rounding(EXPR); \
this->upward(); \
return r
# define BOOST_UP(EXPR) return this->force_rounding(EXPR)
# define BOOST_UP_NEG(EXPR) return -this->force_rounding(EXPR)
template<class U> T conv_down(U const &v) { BOOST_UP_NEG(-v); }
template<class U> T conv_up (U const &v) { BOOST_UP(v); }
T add_down(const T& x, const T& y) { BOOST_UP_NEG((-x) - y); }
T sub_down(const T& x, const T& y) { BOOST_UP_NEG(y - x); }
T mul_down(const T& x, const T& y) { BOOST_UP_NEG(x * (-y)); }
T div_down(const T& x, const T& y) { BOOST_UP_NEG(x / (-y)); }
T add_up (const T& x, const T& y) { BOOST_UP(x + y); }
T sub_up (const T& x, const T& y) { BOOST_UP(x - y); }
T mul_up (const T& x, const T& y) { BOOST_UP(x * y); }
T div_up (const T& x, const T& y) { BOOST_UP(x / y); }
T median (const T& x, const T& y) { BOOST_NR((x + y) / 2); }
T sqrt_down(const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_DN(sqrt(x)); }
T sqrt_up (const T& x)
{ BOOST_NUMERIC_INTERVAL_using_math(sqrt); BOOST_UP(sqrt(x)); }
T int_down(const T& x) { return -to_int(-x); }
T int_up (const T& x) { return to_int(x); }
# undef BOOST_DN
# undef BOOST_NR
# undef BOOST_UP
# undef BOOST_UP_NEG
};
} // namespace interval_lib
} // namespace numeric
} // namespace boost
#endif // BOOST_NUMERIC_INTERVAL_ROUNDED_ARITH_HPP
|
