Debian Codegraph @

debian/patches/system-boost

raw
1 Index: gecode-6.2.0/Makefile.in
2 ===================================================================
3 --- gecode-6.2.0.orig/Makefile.in 2019-12-15 17:13:56.971198754 +0200
4 +++ gecode-6.2.0/Makefile.in 2019-12-15 17:13:56.967198885 +0200
5 @@ -998,8 +998,7 @@
6 numeric/interval.hpp \
7 LICENSE_1_0.txt \
8 limits.hpp non_type.hpp type.hpp
9 -THIRDHDR = \
10 - $(BOOSTHDR:%=gecode/third-party/boost/%)
11 +THIRDHDR =
12
13 #
14 # COLLECTING ALL
15 Index: gecode-6.2.0/gecode/float.hh
16 ===================================================================
17 --- gecode-6.2.0.orig/gecode/float.hh 2019-12-15 17:13:56.971198754 +0200
18 +++ gecode-6.2.0/gecode/float.hh 2019-12-15 17:14:23.462332109 +0200
19 @@ -77,7 +77,7 @@
20 #endif
21
22 // Include interval implementation
23 -#include <gecode/third-party/boost/numeric/interval.hpp>
24 +#include <boost/numeric/interval.hpp>
25
26 /**
27 * \namespace Gecode::Float
28 @@ -135,13 +135,13 @@
29 *
30 */
31 /// Rounding Base class (safe version)
32 - typedef gecode_boost::numeric::interval_lib::save_state< gecode_boost::numeric::interval_lib::rounded_arith_std<FloatNum> >
33 + typedef boost::numeric::interval_lib::save_state< boost::numeric::interval_lib::rounded_arith_std<FloatNum> >
34 RoundingBase;
35
36 #else
37
38 /// Rounding Base class (optimized version)
39 - typedef gecode_boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
40 + typedef boost::numeric::interval_lib::rounded_arith_opp<FloatNum>
41 RoundingBase;
42
43 #endif
44 @@ -413,13 +413,13 @@
45 friend FloatVal Float::hull(const FloatNum& x, const FloatNum& y);
46 protected:
47 /// Used rounding policies
48 - typedef gecode_boost::numeric::interval_lib::save_state<Float::Rounding> R;
49 + typedef boost::numeric::interval_lib::save_state<Float::Rounding> R;
50 /// Used checking policy
51 - typedef gecode_boost::numeric::interval_lib::checking_strict<FloatNum> P;
52 + typedef boost::numeric::interval_lib::checking_strict<FloatNum> P;
53 /// Implementation type for float value
54 - typedef gecode_boost::numeric::interval
55 + typedef boost::numeric::interval
56 <FloatNum,
57 - gecode_boost::numeric::interval_lib::policies<R, P> >
58 + boost::numeric::interval_lib::policies<R, P> >
59 FloatValImpType;
60 /// Implementation of float value
61 FloatValImpType x;
62 Index: gecode-6.2.0/gecode/float/num.hpp
63 ===================================================================
64 --- gecode-6.2.0.orig/gecode/float/num.hpp 2019-12-15 17:13:56.971198754 +0200
65 +++ gecode-6.2.0/gecode/float/num.hpp 2019-12-15 17:13:56.967198885 +0200
66 @@ -35,27 +35,27 @@
67
68 forceinline FloatNum
69 pi_half_lower(void) {
70 - return gecode_boost::numeric::interval_lib::constants::pi_half_lower<FloatNum>();
71 + return boost::numeric::interval_lib::constants::pi_half_lower<FloatNum>();
72 }
73 forceinline FloatNum
74 pi_half_upper(void) {
75 - return gecode_boost::numeric::interval_lib::constants::pi_half_upper<FloatNum>();
76 + return boost::numeric::interval_lib::constants::pi_half_upper<FloatNum>();
77 }
78 forceinline FloatNum
79 pi_lower(void) {
80 - return gecode_boost::numeric::interval_lib::constants::pi_lower<FloatNum>();
81 + return boost::numeric::interval_lib::constants::pi_lower<FloatNum>();
82 }
83 forceinline FloatNum
84 pi_upper(void) {
85 - return gecode_boost::numeric::interval_lib::constants::pi_upper<FloatNum>();
86 + return boost::numeric::interval_lib::constants::pi_upper<FloatNum>();
87 }
88 forceinline FloatNum
89 pi_twice_lower(void) {
90 - return gecode_boost::numeric::interval_lib::constants::pi_twice_lower<FloatNum>();
91 + return boost::numeric::interval_lib::constants::pi_twice_lower<FloatNum>();
92 }
93 forceinline FloatNum
94 pi_twice_upper(void) {
95 - return gecode_boost::numeric::interval_lib::constants::pi_twice_upper<FloatNum>();
96 + return boost::numeric::interval_lib::constants::pi_twice_upper<FloatNum>();
97 }
98 }
99
100 Index: gecode-6.2.0/gecode/float/val.hpp
101 ===================================================================
102 --- gecode-6.2.0.orig/gecode/float/val.hpp 2019-12-15 17:13:56.971198754 +0200
103 +++ gecode-6.2.0/gecode/float/val.hpp 2019-12-15 17:13:56.967198885 +0200
104 @@ -76,29 +76,29 @@
105 }
106 forceinline FloatNum
107 FloatVal::size(void) const {
108 - return gecode_boost::numeric::width(x);
109 + return boost::numeric::width(x);
110 }
111 forceinline FloatNum
112 FloatVal::med(void) const {
113 - return gecode_boost::numeric::median(x);
114 + return boost::numeric::median(x);
115 }
116
117 forceinline bool
118 FloatVal::tight(void) const {
119 - return (gecode_boost::numeric::singleton(x) ||
120 + return (boost::numeric::singleton(x) ||
121 (nextafter(x.lower(),x.upper()) == x.upper()));
122 }
123 forceinline bool
124 FloatVal::singleton(void) const {
125 - return gecode_boost::numeric::singleton(x);
126 + return boost::numeric::singleton(x);
127 }
128 forceinline bool
129 FloatVal::in(FloatNum n) const {
130 - return gecode_boost::numeric::in(n,x);
131 + return boost::numeric::in(n,x);
132 }
133 forceinline bool
134 FloatVal::zero_in(void) const {
135 - return gecode_boost::numeric::zero_in(x);
136 + return boost::numeric::zero_in(x);
137 }
138
139 forceinline FloatVal
140 @@ -107,17 +107,17 @@
141 }
142 forceinline FloatVal
143 FloatVal::pi_half(void) {
144 - FloatVal p(gecode_boost::numeric::interval_lib::pi_half<FloatValImpType>());
145 + FloatVal p(boost::numeric::interval_lib::pi_half<FloatValImpType>());
146 return p;
147 }
148 forceinline FloatVal
149 FloatVal::pi(void) {
150 - FloatVal p(gecode_boost::numeric::interval_lib::pi<FloatValImpType>());
151 + FloatVal p(boost::numeric::interval_lib::pi<FloatValImpType>());
152 return p;
153 }
154 forceinline FloatVal
155 FloatVal::pi_twice(void) {
156 - FloatVal p(gecode_boost::numeric::interval_lib::pi_twice<FloatValImpType>());
157 + FloatVal p(boost::numeric::interval_lib::pi_twice<FloatValImpType>());
158 return p;
159 }
160
161 @@ -226,7 +226,7 @@
162 operator <(const FloatVal& x, const FloatVal& y) {
163 try {
164 return x.x < y.x;
165 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
166 + } catch (boost::numeric::interval_lib::comparison_error&) {
167 return false;
168 }
169 }
170 @@ -234,7 +234,7 @@
171 operator <(const FloatVal& x, const FloatNum& y) {
172 try {
173 return x.x < y;
174 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
175 + } catch (boost::numeric::interval_lib::comparison_error&) {
176 return false;
177 }
178 }
179 @@ -243,7 +243,7 @@
180 operator <=(const FloatVal& x, const FloatVal& y) {
181 try {
182 return x.x <= y.x;
183 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
184 + } catch (boost::numeric::interval_lib::comparison_error&) {
185 return false;
186 }
187 }
188 @@ -251,7 +251,7 @@
189 operator <=(const FloatVal& x, const FloatNum& y) {
190 try {
191 return x.x <= y;
192 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
193 + } catch (boost::numeric::interval_lib::comparison_error&) {
194 return false;
195 }
196 }
197 @@ -260,7 +260,7 @@
198 operator >(const FloatVal& x, const FloatVal& y) {
199 try {
200 return x.x > y.x;
201 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
202 + } catch (boost::numeric::interval_lib::comparison_error&) {
203 return false;
204 }
205 }
206 @@ -268,7 +268,7 @@
207 operator >(const FloatVal& x, const FloatNum& y) {
208 try {
209 return x.x > y;
210 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
211 + } catch (boost::numeric::interval_lib::comparison_error&) {
212 return false;
213 }
214 }
215 @@ -277,7 +277,7 @@
216 operator >=(const FloatVal& x, const FloatVal& y) {
217 try {
218 return x.x >= y.x;
219 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
220 + } catch (boost::numeric::interval_lib::comparison_error&) {
221 return false;
222 }
223 }
224 @@ -285,7 +285,7 @@
225 operator >=(const FloatVal& x, const FloatNum& y) {
226 try {
227 return x.x >= y;
228 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
229 + } catch (boost::numeric::interval_lib::comparison_error&) {
230 return false;
231 }
232 }
233 @@ -294,13 +294,13 @@
234 operator ==(const FloatVal& x, const FloatVal& y) {
235 try {
236 return x.x == y.x;
237 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
238 + } catch (boost::numeric::interval_lib::comparison_error&) {
239 return false;
240 }
241 }
242 inline bool
243 operator ==(const FloatVal& x, const FloatNum& y) {
244 - if (!gecode_boost::numeric::interval_lib::checking_strict<FloatNum>
245 + if (!boost::numeric::interval_lib::checking_strict<FloatNum>
246 ::is_empty(x.x.lower(), x.x.upper())) {
247 if ((x.x.lower() == y) && (x.x.upper() == y))
248 return true;
249 @@ -317,7 +317,7 @@
250 operator !=(const FloatVal& x, const FloatVal& y) {
251 try {
252 return x.x != y.x;
253 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
254 + } catch (boost::numeric::interval_lib::comparison_error&) {
255 return false;
256 }
257 }
258 @@ -325,7 +325,7 @@
259 operator !=(const FloatVal& x, const FloatNum& y) {
260 try {
261 return x.x != y;
262 - } catch (gecode_boost::numeric::interval_lib::comparison_error&) {
263 + } catch (boost::numeric::interval_lib::comparison_error&) {
264 return false;
265 }
266 }