C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
lx_interval.inl
1 /*
2 ** CXSC is a C++ library for eXtended Scientific Computing (V 2.5.4)
3 **
4 ** Copyright (C) 1990-2000 Institut fuer Angewandte Mathematik,
5 ** Universitaet Karlsruhe, Germany
6 ** (C) 2000-2014 Wiss. Rechnen/Softwaretechnologie
7 ** Universitaet Wuppertal, Germany
8 **
9 ** This library is free software; you can redistribute it and/or
10 ** modify it under the terms of the GNU Library General Public
11 ** License as published by the Free Software Foundation; either
12 ** version 2 of the License, or (at your option) any later version.
13 **
14 ** This library is distributed in the hope that it will be useful,
15 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
16 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 ** Library General Public License for more details.
18 **
19 ** You should have received a copy of the GNU Library General Public
20 ** License along with this library; if not, write to the Free
21 ** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23 
24 /* CVS $Id: lx_interval.inl,v 1.8 2014/01/30 17:23:47 cxsc Exp $ */
25 
26 /*
27 ** F. Blomquist, University of Wuppertal, 19.09.2007;
28 */
29 
30 namespace cxsc {
31 
32 
33 // --------------------------------------------------------------------------
34 // ------ Inline functions and operators related to type lx_interval --------
35 // --------------------------------------------------------------------------
36 
37 inline int StagPrec(const lx_interval &a) throw()
38 { return StagPrec(a.li); }
39 
40 inline real expo(const lx_interval &a) throw()
41 { return (a.ex); }
42 
43 inline l_interval li_part(const lx_interval &a) throw()
44 { return (a.li); }
45 
46 inline int Disjoint(const lx_interval& a, const lx_interval& b)
47 { return (Inf(a)>Sup(b) || Inf(b)>Sup(a)); }
48 
49 inline int in(const lx_interval& x, const lx_interval& y)
50 { return ( (Inf(y) < Inf(x)) && (Sup(x) < Sup(y)) ); }
51 
52 inline int in(const l_interval& x, const lx_interval& y)
53 { return ( (Inf(y) < Inf(x)) && (Sup(x) < Sup(y)) ); }
54 
55 inline int in(const interval& x, const lx_interval& y)
56 { return ( (Inf(y) < Inf(x)) && (Sup(x) < Sup(y)) ); }
57 
58 inline int in(const lx_real& x, const lx_interval& y )
59 { return ( (Inf(y) <= x) && (x <= Sup(y)) ); }
60 
61 inline int in(const l_real& x, const lx_interval& y )
62 { return ( (Inf(y) <= x) && (x <= Sup(y)) ); }
63 
64 inline int in(const real& x, const lx_interval& y )
65 { return ( (Inf(y) <= x) && (x <= Sup(y)) ); }
66 
67 inline lx_interval Blow(const lx_interval& a) throw()
68 // This function returns an inflated interval res,
69 // if the following condition is complied:
70 // expo(a) < -Max_Int_R + 2100 = Max_Int_N;
71 // After the inflation it holds:
72 // expo(a) = -Max_Int_R + 2100;
73 // a = [0,0] is not modified.
74 // Blomquist, 31.01.2008;
75 {
76  lx_interval res(a);
77  l_interval al(a.li);
78 
79  if (a.ex<Max_Int_N)
80  {
81  if (Inf(al)>0)
82  SetInf(al,0.0);
83  else
84  if (Sup(al)<0)
85  SetSup(al,0.0);
86  res = lx_interval(Max_Int_N,al);
87  }
88 
89  return res;
90 }
91 
92 inline lx_interval Blow( const lx_interval& x, const real& eps )
93 {
94  l_interval y(li_part(x));
95  return lx_interval( expo(x), Blow(y,eps) );
96 }
97 
98 inline lx_real AbsMin (const lx_interval &x)
99 {
100  if ( in(0.0,x) ) return lx_real(0.0);
101  else
102  {
103  lx_real y(Inf(x));
104  if (y > 0.0) return y;
105  else return -Sup(x);
106  }
107 }
108 
109 inline lx_real AbsMax (const lx_interval &x)
110 {
111  lx_real a, b;
112 
113  a = abs(Inf(x));
114  b = abs(Sup(x));
115 
116  if (a > b)
117  return a;
118  else
119  return b;
120 }
121 
122 inline lx_interval & lx_interval::operator = (const lx_interval &a) throw()
123 {
124  ex = a.ex;
125  li = a.li;
126  return *this;
127 }
128 
129 inline lx_interval & lx_interval::operator = (const lx_real &a) throw()
130 {
131  ex = expo(a);
132  li = lr_part(a);
133  return *this;
134 }
135 
136 inline lx_interval & lx_interval::operator = (const l_interval &a) throw()
137 {
138  ex = 0;
139  li = a;
140  return *this;
141 }
142 
143 inline lx_interval & lx_interval::operator = (const l_real & a) throw()
144 {
145  ex = 0;
146  li = a;
147  return *this;
148 }
149 
150 inline lx_interval & lx_interval::operator = (const real & a) throw()
151 {
152  ex = 0;
153  li = a;
154  return *this;
155 }
156 
157 inline lx_interval & lx_interval::operator = (const interval & a) throw()
158 {
159  ex = 0;
160  li = a;
161  return *this;
162 }
163 
164 inline lx_interval operator+(const lx_interval & a) throw() { return a; }
165 inline lx_interval operator-(const lx_interval & a) throw()
166 { return lx_interval(a.ex,-a.li); }
167 
168 inline lx_interval operator + (const lx_interval &a, const l_interval &b) throw()
169 { return a + lx_interval(b); }
170 
171 inline lx_interval operator + (const l_interval &a, const lx_interval &b) throw()
172 { return lx_interval(a) + b; }
173 
174 inline lx_interval operator + (const lx_interval &a, const l_real &b) throw()
175 { return a + lx_interval(b); }
176 
177 inline lx_interval operator + (const l_real &a, const lx_interval &b) throw()
178 { return lx_interval(a) + b; }
179 
180 inline lx_interval operator + (const lx_interval &a, const lx_real &b) throw()
181 { return a + lx_interval(b); }
182 
183 inline lx_interval operator + (const lx_real &a, const lx_interval &b) throw()
184 { return lx_interval(a) + b; }
185 
186 inline lx_interval operator + (const lx_interval &a, const real &b) throw()
187 { return a + lx_interval(b); }
188 
189 inline lx_interval operator + (const real &a, const lx_interval &b) throw()
190 { return lx_interval(a) + b; }
191 
192 inline lx_interval operator + (const lx_interval &a, const interval &b) throw()
193 { return a + lx_interval(b); }
194 
195 inline lx_interval operator + (const interval &a, const lx_interval &b) throw()
196 { return lx_interval(a) + b; }
197 
198 inline lx_interval & operator +=(lx_interval &a, const lx_interval &b) throw()
199 { return a = a+b; }
200 
201 inline lx_interval & operator +=(lx_interval &a, const l_interval &b) throw()
202 { return a = a+b; }
203 
204 inline lx_interval & operator +=(lx_interval &a, const l_real &b) throw()
205 { return a = a+b; }
206 
207 inline lx_interval & operator +=(lx_interval &a, const lx_real &b) throw()
208 { return a = a+b; }
209 
210 inline lx_interval & operator +=(lx_interval &a, const real &b) throw()
211 { return a = a+b; }
212 
213 inline lx_interval & operator +=(lx_interval &a, const interval &b) throw()
214 { return a = a+b; }
215 
216 inline lx_interval operator - (const lx_interval &a, const lx_interval &b) throw()
217 { return a + lx_interval(-b); }
218 
219 inline lx_interval operator - (const lx_interval &a, const l_interval &b) throw()
220 { return a + lx_interval(-b); }
221 
222 inline lx_interval operator - (const l_interval &a, const lx_interval &b) throw()
223 { return lx_interval(a) + (-b); }
224 
225 inline lx_interval operator - (const lx_interval &a, const l_real &b) throw()
226 { return a + lx_interval(-b); }
227 
228 inline lx_interval operator - (const l_real &a, const lx_interval &b) throw()
229 { return lx_interval(a) + (-b); }
230 
231 inline lx_interval operator - (const lx_interval &a, const lx_real &b) throw()
232 { return a + lx_interval(-b); }
233 
234 inline lx_interval operator - (const lx_real &a, const lx_interval &b) throw()
235 { return lx_interval(a) + (-b); }
236 
237 inline lx_interval operator - (const lx_interval &a, const real &b) throw()
238 { return a + lx_interval(-b); }
239 
240 inline lx_interval operator - (const real &a, const lx_interval &b) throw()
241 { return lx_interval(a) + (-b); }
242 
243 inline lx_interval operator - (const lx_interval &a, const interval &b) throw()
244 { return a + lx_interval(-b); }
245 
246 inline lx_interval operator - (const interval &a, const lx_interval &b) throw()
247 { return lx_interval(a) + (-b); }
248 
249 inline lx_interval & operator -=(lx_interval &a, const lx_interval &b) throw()
250 { return a = a-b; }
251 inline lx_interval & operator -=(lx_interval &a, const l_interval &b) throw()
252 { return a = a-b; }
253 inline lx_interval & operator -=(lx_interval &a, const l_real &b) throw()
254 { return a = a-b; }
255 inline lx_interval & operator -=(lx_interval &a, const lx_real &b) throw()
256 { return a = a-b; }
257 inline lx_interval & operator -=(lx_interval &a, const real &b) throw()
258 { return a = a-b; }
259 inline lx_interval & operator -=(lx_interval &a, const interval &b) throw()
260 { return a = a-b; }
261 
262 inline lx_interval operator * (const lx_interval &a, const l_interval &b)
263  throw()
264 { return a * lx_interval(b); }
265 
266 inline lx_interval operator * (const l_interval &a, const lx_interval &b)
267  throw()
268 { return lx_interval(a) * b; }
269 
270 inline lx_interval operator * (const lx_interval &a, const l_real &b) throw()
271 { return a * lx_interval(b); }
272 
273 inline lx_interval operator * (const l_real &a, const lx_interval &b) throw()
274 { return lx_interval(a) * b; }
275 
276 inline lx_interval operator * (const lx_interval &a, const lx_real &b) throw()
277 { return a * lx_interval(b); }
278 
279 inline lx_interval operator * (const lx_real &a, const lx_interval &b) throw()
280 { return lx_interval(a) * b; }
281 
282 inline lx_interval operator * (const lx_interval &a, const real &b) throw()
283 { return a * lx_interval(b); }
284 
285 inline lx_interval operator * (const real &a, const lx_interval &b) throw()
286 { return lx_interval(a) * b; }
287 
288 inline lx_interval operator * (const lx_interval &a, const interval &b) throw()
289 { return a * lx_interval(b); }
290 
291 inline lx_interval operator * (const interval &a, const lx_interval &b) throw()
292 { return lx_interval(a) * b; }
293 
294 inline lx_interval & operator *=(lx_interval &a, const lx_interval &b) throw()
295 { return a = a*b; }
296 inline lx_interval & operator *=(lx_interval &a, const l_interval &b) throw()
297 { return a = a*b; }
298 inline lx_interval & operator *=(lx_interval &a, const l_real &b) throw()
299 { return a = a*b; }
300 inline lx_interval & operator *=(lx_interval &a, const lx_real &b) throw()
301 { return a = a*b; }
302 inline lx_interval & operator *=(lx_interval &a, const real &b) throw()
303 { return a = a*b; }
304 inline lx_interval & operator *=(lx_interval &a, const interval &b) throw()
305 { return a = a*b; }
306 
307 inline lx_interval operator / (const lx_interval &a, const l_interval &b)
308  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
309 { return a / lx_interval(b); }
310 
311 inline lx_interval operator / (const l_interval &a, const lx_interval &b)
312  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
313 { return lx_interval(a) / b; }
314 
315 inline lx_interval operator / (const lx_interval &a, const l_real &b)
316  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
317 { return a / lx_interval(b); }
318 
319 inline lx_interval operator / (const l_real &a, const lx_interval &b)
320  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
321 { return lx_interval(a) / b; }
322 
323 inline lx_interval operator / (const lx_interval &a, const real &b)
324  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
325 { return a / lx_interval(b); }
326 
327 inline lx_interval operator / (const real &a, const lx_interval &b)
328  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
329 { return lx_interval(a) / b; }
330 
331 inline lx_interval operator / (const lx_interval &a, const interval &b)
332  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
333 { return a / lx_interval(b); }
334 
335 inline lx_interval operator / (const interval &a, const lx_interval &b)
336  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
337 { return lx_interval(a) / b; }
338 
339 inline lx_interval operator / (const lx_interval &a, const lx_real &b)
340  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
341 { return a / lx_interval(b); }
342 
343 inline lx_interval operator / (const lx_real &a, const lx_interval &b)
344  throw(ERROR_LINTERVAL_DIV_BY_ZERO)
345 { return lx_interval(a) / b; }
346 
347 
348 inline lx_interval & operator /=(lx_interval &a, const lx_interval &b) throw()
349 { return a = a/b; }
350 inline lx_interval & operator /=(lx_interval &a, const l_interval &b) throw()
351 { return a = a/b; }
352 inline lx_interval & operator /=(lx_interval &a, const l_real &b) throw()
353 { return a = a/b; }
354 inline lx_interval & operator /=(lx_interval &a, const real &b) throw()
355 { return a = a/b; }
356 inline lx_interval & operator /=(lx_interval &a, const interval &b) throw()
357 { return a = a/b; }
358 inline lx_interval & operator /=(lx_interval &a, const lx_real &b) throw()
359 { return a = a/b; }
360 
361 // ------------------ Vergleichsoperatoren ----------------------------------
362 
363 inline bool operator ! (const lx_interval& a) throw()
364 { return !a.li; }
365 
366 inline bool operator == (const lx_interval &a, const lx_interval &b) throw()
367 {
368  l_interval al(li_part(a)), bl(li_part(b));
369  int exa(expo_gr(al)), exb(expo_gr(bl));
370  real na(expo(a)), nb(expo(b)), d;
371  bool a_0(exa<-100000), b_0(exb<-100000), res;
372 
373  if (a_0 || b_0) res = (a_0 == b_0);
374  else // a,b <> 0:
375  {
376  d = exa-exb;
377  if (d>0)
378  { // bl nach oben skalieren:
379  Times2pown(bl,d);
380  d = nb - d;
381  nb = (abs(d) > Max_Int_R)? MaxReal : d; // b = 2^nb * bl;
382  } else // d<=0:
383  { // al nach oben skalieren:
384  Times2pown(al,-d);
385  d = na + d;
386  na = (abs(d) > Max_Int_R)? MaxReal : d; // a = 2^na * al;
387  }
388  res = (na==nb && al==bl);
389  }
390  return res;
391 }
392 
393 inline bool operator == (const lx_interval &a, const l_interval &b) throw()
394 { return (a == lx_interval(b)); }
395 
396 inline bool operator == (const l_interval &a, const lx_interval &b) throw()
397 { return ( lx_interval(a) == b); }
398 
399 inline bool operator == (const lx_interval &a, const interval &b) throw()
400 { return (a == lx_interval(b)); }
401 
402 inline bool operator == (const interval &a, const lx_interval &b) throw()
403 { return ( lx_interval(a) == b); }
404 
405 inline bool operator == (const lx_interval &a, const real &b) throw()
406 { return ( a == lx_interval(b)); }
407 
408 inline bool operator == (const lx_interval &a, const l_real &b) throw()
409 { return ( a == lx_interval(b)); }
410 
411 inline bool operator == (const real &a, const lx_interval &b) throw()
412 { return ( lx_interval(a) == b); }
413 
414 inline bool operator == (const l_real &a, const lx_interval &b) throw()
415 { return ( lx_interval(a) == b); }
416 
417 inline bool operator == (const lx_interval &a, const lx_real &b) throw()
418 { return ( a == lx_interval(b)); }
419 
420 inline bool operator == (const lx_real &a, const lx_interval &b) throw()
421 { return ( lx_interval(a) == b); }
422 
423 inline bool operator != (const lx_interval &a, const lx_interval &b) throw()
424 { return !(a==b); }
425 
426 inline bool operator != (const lx_interval &a, const l_interval &b) throw()
427 { return !(a==lx_interval(b)); }
428 
429 inline bool operator != (const l_interval &a, const lx_interval &b) throw()
430 { return !(lx_interval(a) == b); }
431 
432 inline bool operator != (const lx_interval &a, const interval &b) throw()
433 { return !(a==lx_interval(b)); }
434 
435 inline bool operator != (const interval &a, const lx_interval &b) throw()
436 { return !(lx_interval(a) == b); }
437 
438 inline bool operator != (const lx_interval &a, const real &b) throw()
439 { return !(a == lx_interval(b)); }
440 
441 inline bool operator != (const real &a, const lx_interval &b) throw()
442 { return !(lx_interval(a) == b); }
443 
444 inline bool operator != (const lx_interval &a, const l_real &b) throw()
445 { return !(a == lx_interval(b)); }
446 
447 inline bool operator != (const l_real &a, const lx_interval &b) throw()
448 { return !(lx_interval(a) == b); }
449 
450 inline bool operator != (const lx_interval &a, const lx_real &b) throw()
451 { return !(a == lx_interval(b)); }
452 
453 inline bool operator != (const lx_real &a, const lx_interval &b) throw()
454 { return !(lx_interval(a) == b); }
455 
456 // ------------------------------------------------------------------------
457 // --------------------------- set comparisons ----------------------------
458 // ------------------------------------------------------------------------
459 
460 // ---- lx_interval--lx_interval
461 inline bool operator < (const lx_interval &a, const lx_interval &b) throw()
462 { return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
463 inline bool operator <= (const lx_interval &a, const lx_interval &b) throw()
464 { return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
465 inline bool operator > (const lx_interval& a, const lx_interval& b) throw()
466 { return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
467 inline bool operator >= (const lx_interval& a, const lx_interval& b) throw()
468 { return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
469 
470 // ---- lx_interval--l_interval
471 inline bool operator < (const lx_interval &a, const l_interval &b) throw()
472 { return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
473 inline bool operator <= (const lx_interval &a, const l_interval &b) throw()
474 { return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
475 inline bool operator < (const l_interval &a, const lx_interval &b) throw()
476 { return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
477 inline bool operator <= (const l_interval &a, const lx_interval &b) throw()
478 { return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
479 inline bool operator > (const lx_interval& a, const l_interval& b) throw()
480 { return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
481 inline bool operator >= (const lx_interval& a, const l_interval& b) throw()
482 { return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
483 inline bool operator > (const l_interval& a, const lx_interval& b) throw()
484 { return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
485 inline bool operator >= (const l_interval& a, const lx_interval& b) throw()
486 { return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
487 
488 // ---- lx_interval--interval
489 inline bool operator < (const lx_interval &a, const interval &b) throw()
490 { return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
491 inline bool operator <= (const lx_interval &a, const interval &b) throw()
492 { return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
493 inline bool operator < (const interval &a, const lx_interval &b) throw()
494 { return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
495 inline bool operator <= (const interval &a, const lx_interval &b) throw()
496 { return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
497 inline bool operator > (const lx_interval& a, const interval& b) throw()
498 { return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
499 inline bool operator >= (const lx_interval& a, const interval& b) throw()
500 { return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
501 inline bool operator > (const interval& a, const lx_interval& b) throw()
502 { return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
503 inline bool operator >= (const interval& a, const lx_interval& b) throw()
504 { return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
505 
506 // ---- lx_interval--real
507 inline bool operator < (const real &a, const lx_interval &b) throw()
508 { return( a>Inf(b) && a<Sup(b) ); }
509 inline bool operator <= (const real &a, const lx_interval &b) throw()
510 { return( a>=Inf(b) && a<=Sup(b) ); }
511 inline bool operator > (const lx_interval &a, const real &b) throw()
512 { return( b>Inf(a) && b<Sup(a) ); }
513 inline bool operator >= (const lx_interval &a, const real &b) throw()
514 { return( b>=Inf(a) && b<=Sup(a) ); }
515 
516 // ---- lx_interval--l_real
517 inline bool operator < (const l_real &a, const lx_interval &b) throw()
518 { return( a>Inf(b) && a<Sup(b) ); }
519 inline bool operator <= (const l_real &a, const lx_interval &b) throw()
520 { return( a>=Inf(b) && a<=Sup(b) ); }
521 inline bool operator > (const lx_interval &a, const l_real &b) throw()
522 { return( b>Inf(a) && b<Sup(a) ); }
523 inline bool operator >= (const lx_interval &a, const l_real &b) throw()
524 { return( b>=Inf(a) && b<=Sup(a) ); }
525 
526 // ---- lx_interval--lx_real
527 inline bool operator < (const lx_real &a, const lx_interval &b) throw()
528 { return( a>Inf(b) && a<Sup(b) ); }
529 inline bool operator <= (const lx_real &a, const lx_interval &b) throw()
530 { return( a>=Inf(b) && a<=Sup(b) ); }
531 inline bool operator > (const lx_interval &a, const lx_real &b) throw()
532 { return( b>Inf(a) && b<Sup(a) ); }
533 inline bool operator >= (const lx_interval &a, const lx_real &b) throw()
534 { return( b>=Inf(a) && b<=Sup(a) ); }
535 
536 
537 inline lx_interval adjust(const lx_interval &a) throw()
538 { return lx_interval(a.ex,adjust(a.li)); }
539 
540 inline lx_interval abs(const lx_interval &a) throw()
541 { return lx_interval(a.ex,abs(a.li)); }
542 
543 inline bool point_intv(const lx_interval &a)
544 { return point_intv(a.li); }
545 
546 inline void times2pown(lx_interval &a, const real& n) throw()
547 { a = lx_interval(add_real(n,a.ex),a.li); }
548 
549 inline void times2pown_neg(lx_interval& a, const real& n) throw()
550 // Calculating an inclusion of a*2^n, n = 0,-1,-2,...,-9007199254740991.0;
551 // n MUST be an integer and n MUST not be positive!
552 // These conditions are not tested in this function!
553 // Blomquist, 09.06.2008;
554 {
555  int exal(expo_gr(a.li));
556  real exa,d,n_d;
557  l_interval lia(a.li);
558  int k;
559 
560  if (exal>-100000) // a != [0,0]
561  {
562  exa = a.ex;
563  if (exa < -Max_Int_R - n) // exa+n < -9007199254740991;
564  { // It holds: -Max_Int_R - n in {-Max_Int_R, ...,-1,0},
565  // Thus, -Max_Int_R - n is always in integer value.
566  // Furthermore it holds: exa in {-Max_Int_R,...,-2,-1}.
567  d = -Max_Int_R - exa; // d in {-Max_Int_R+1,..., -1,0}
568  n_d = n-d;
569  // With exa+n < -Max_Int_R and with exa+d = -Max_Int_R
570  // it follows: n-d < 0, and:
571  // n-d in {-Max_Int_R,-Max_Int_R+1, ... , -1};
572  // Thus, n-d is a negative and integer value.
573  if (n_d < -2147483647)
574  {
575  if (Inf(lia)>=0)
576  lia = l_interval(0,minreal);
577  else
578  if (Sup(lia)<=0)
579  lia = l_interval(-minreal,0);
580  else lia = l_interval(-minreal,minreal);
581  }
582  else // n_d >=-2147483647:
583  {
584  k = (int) _double(n_d);
585  Times2pown(lia,k);
586  }
587  a = lx_interval(-Max_Int_R,lia);
588  }
589  else // n+a.ex >= -9007199254740991, so an integer overflow
590  // is not possible here!
591  a = lx_interval(n+a.ex,lia);
592  }
593 } // times2pown_neg(...)
594 
595 inline lx_real Inf(const lx_interval &a) throw()
596 { return lx_real(a.ex,Inf(a.li)); }
597 
598 inline lx_real Sup(const lx_interval &a) throw()
599 { return lx_real(a.ex,Sup(a.li)); }
600 
601 inline lx_real RelDiam( const lx_interval &a )
602 {
603  lx_real x;
604  if (0<=a.li)
605  x = lx_real(a.ex,RelDiam(a.li));
606  else x = RelDiam(a.li);
607  return x;
608 }
609 
610 inline lx_real diam(const lx_interval &a) throw()
611 { return lx_real(a.ex,diam(a.li)); }
612 
613 inline lx_real mid(const lx_interval& a) throw()
614 { return lx_real(a.ex,mid(a.li)); }
615 
616 inline bool IsEmpty(const lx_interval& a) throw()
617 { return Inf(a.li) > Sup(a.li); }
618 
619 // ----------------------------- Convex hull -------------------------------
620 
621 inline lx_interval operator |(const lx_interval &a, const lx_interval &b) throw()
622 {
623  return lx_interval( (Inf(a)<Inf(b)) ? Inf(a) : Inf(b),
624  (Sup(a)>Sup(b)) ? Sup(a) : Sup(b) );
625 }
626 
627 inline lx_interval operator |(const lx_interval &a, const l_interval &b) throw()
628 {
629  lx_interval Lb(0.0,b);
630  return lx_interval( (Inf(a)<Inf(Lb)) ? Inf(a) : Inf(Lb),
631  (Sup(a)>Sup(Lb)) ? Sup(a) : Sup(Lb) );
632 }
633 
634 inline lx_interval operator |(const l_interval &a, const lx_interval &b) throw()
635 {
636  lx_interval La(0.0,a);
637  return lx_interval( (Inf(La)<Inf(b)) ? Inf(La) : Inf(b),
638  (Sup(La)>Sup(b)) ? Sup(La) : Sup(b) );
639 }
640 
641 inline lx_interval operator |(const lx_interval &a, const interval &b) throw()
642 {
643  lx_interval Lb(0.0,l_interval(b));
644  return lx_interval( (Inf(a)<Inf(Lb)) ? Inf(a) : Inf(Lb),
645  (Sup(a)>Sup(Lb)) ? Sup(a) : Sup(Lb) );
646 }
647 
648 inline lx_interval operator |(const interval &a, const lx_interval &b) throw()
649 {
650  lx_interval La(0.0,l_interval(a));
651  return lx_interval( (Inf(La)<Inf(b)) ? Inf(La) : Inf(b),
652  (Sup(La)>Sup(b)) ? Sup(La) : Sup(b) );
653 }
654 
655 inline lx_interval & operator |= (lx_interval &a,const lx_interval &b) throw()
656 {
657  Inf(a)=(Inf(a)<Inf(b))?Inf(a):Inf(b),Sup(a)=(Sup(a)>Sup(b))?Sup(a):Sup(b);
658  return a;
659 }
660 
661 inline lx_interval & operator |= (lx_interval &a,const l_interval &b) throw()
662 {
663  lx_interval Lb(0,b);
664  Inf(a) = (Inf(a)<Inf(Lb)) ? Inf(a) : Inf(Lb),
665  Sup(a) = (Sup(a)>Sup(Lb)) ? Sup(a) : Sup(Lb);
666  return a;
667 }
668 
669 inline lx_interval & operator |= (lx_interval &a,const interval &b) throw()
670 {
671  lx_interval Lb(0,l_interval(b));
672  Inf(a) = (Inf(a)<Inf(Lb)) ? Inf(a) : Inf(Lb),
673  Sup(a) = (Sup(a)>Sup(Lb)) ? Sup(a) : Sup(Lb);
674  return a;
675 }
676 
677 inline lx_interval operator | (const lx_real &a, const lx_interval &b) throw()
678 {
679  return lx_interval( (a<Inf(b)) ? a : Inf(b),
680  (a>Sup(b)) ? a : Sup(b) );
681 }
682 
683 inline lx_interval operator | (const real &a, const lx_interval &b) throw()
684 {
685  lx_real La(a);
686  return lx_interval( (La<Inf(b)) ? La : Inf(b),
687  (La>Sup(b)) ? La : Sup(b) );
688 }
689 
690 inline lx_interval operator | (const l_real &a, const lx_interval &b) throw()
691 {
692  lx_real La(0,a);
693  return lx_interval( (La<Inf(b)) ? La : Inf(b),
694  (La>Sup(b)) ? La : Sup(b) );
695 }
696 
697 inline lx_interval operator | (const lx_interval &a, const lx_real &b) throw()
698 {
699  return lx_interval( (Inf(a)<b) ? Inf(a) : b,
700  (Sup(a)>b) ? Sup(a) : b );
701 }
702 
703 inline lx_interval operator | (const lx_interval &a, const real &b) throw()
704 {
705  lx_real Lb(b);
706  return lx_interval( (Inf(a)<Lb) ? Inf(a) : Lb,
707  (Sup(a)>Lb) ? Sup(a) : Lb );
708 }
709 
710 inline lx_interval operator | (const lx_interval &a, const l_real &b) throw()
711 {
712  lx_real Lb(0.0,b);
713  return lx_interval( (Inf(a)<Lb) ? Inf(a) : Lb,
714  (Sup(a)>Lb) ? Sup(a) : Lb );
715 }
716 
717 inline lx_interval & operator |= (lx_interval &a, const real &b) throw()
718 {
719  lx_real Lb(b);
720  Inf(a) = (Inf(a)<Lb) ? Inf(a) : Lb, Sup(a) = (Sup(a)>Lb) ? Sup(a) : Lb;
721  return a;
722 }
723 
724 inline lx_interval & operator |= (lx_interval &a, const l_real &b) throw()
725 {
726  lx_real Lb(0.0,b);
727  Inf(a) = (Inf(a)<Lb) ? Inf(a) : Lb, Sup(a) = (Sup(a)>Lb) ? Sup(a) : Lb;
728  return a;
729 }
730 
731 
732 inline lx_interval & operator |= (lx_interval &a, const lx_real &b) throw()
733 {
734  Inf(a) = (Inf(a)<b) ? Inf(a) : b, Sup(a) = (Sup(a)>b) ? Sup(a) : b;
735  return a;
736 }
737 
738 inline lx_interval operator |(const lx_real &a, const lx_real &b) throw()
739 {
740  if(a>b) return lx_interval(b,a);
741  else return lx_interval(a,b);
742 }
743 
744 // --------------------------- Intersection -----------------------------
745 
746 inline lx_interval operator & (const lx_interval &a, const lx_interval &b)
747  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
748 {
749  return lx_interval( (Inf(a)>Inf(b)) ? Inf(a) : Inf(b),
750  (Sup(a)<Sup(b)) ? Sup(a) : Sup(b));
751 }
752 
753 inline lx_interval operator & (const lx_interval &a, const l_interval &b)
754  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
755 {
756  lx_interval Lb(0.0,b);
757  return lx_interval( (Inf(a)>Inf(Lb)) ? Inf(a) : Inf(Lb),
758  (Sup(a)<Sup(Lb)) ? Sup(a) : Sup(Lb));
759 }
760 
761 inline lx_interval & operator &= (lx_interval &a, const l_interval &b)
762  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
763 {
764  lx_interval Lb(0.0,b);
765  Inf(a) = (Inf(a)>Inf(Lb)) ? Inf(a) : Inf(Lb),
766  Sup(a) = (Sup(a)<Sup(Lb)) ? Sup(a) : Sup(Lb);
767  if (Inf(a)>Sup(a))
768  cxscthrow(ERROR_LINTERVAL_EMPTY_INTERVAL("lx_interval & operator &=(lx_interval &a,const l_interval &b)"));
769  return a;
770 }
771 
772 inline lx_interval operator & (const l_interval &a, const lx_interval &b)
773  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
774 {
775  lx_interval La(0.0,a);
776  return lx_interval( (Inf(La)>Inf(b)) ? Inf(La) : Inf(b),
777  (Sup(La)<Sup(b)) ? Sup(La) : Sup(b));
778 }
779 
780 inline lx_interval operator & (const lx_interval &a, const interval &b)
781  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
782 {
783  lx_interval Lb(0.0,l_interval(b));
784  return lx_interval( (Inf(a)>Inf(Lb)) ? Inf(a) : Inf(Lb),
785  (Sup(a)<Sup(Lb)) ? Sup(a) : Sup(Lb));
786 }
787 
788 inline lx_interval & operator &= (lx_interval &a, const interval &b)
789  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
790 {
791  lx_interval Lb(0.0,l_interval(b));
792  Inf(a) = (Inf(a)>Inf(Lb)) ? Inf(a) : Inf(Lb),
793  Sup(a) = (Sup(a)<Sup(Lb)) ? Sup(a) : Sup(Lb);
794  if (Inf(a)>Sup(a))
795  cxscthrow(ERROR_LINTERVAL_EMPTY_INTERVAL("lx_interval & operator &=(lx_interval &a,const interval &b)"));
796  return a;
797 }
798 
799 inline lx_interval operator & (const interval &a, const lx_interval &b)
800  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
801 {
802  lx_interval La(0.0,l_interval(a));
803  return lx_interval( (Inf(La)>Inf(b)) ? Inf(La) : Inf(b),
804  (Sup(La)<Sup(b)) ? Sup(La) : Sup(b));
805 }
806 
807 inline lx_interval & operator &= (lx_interval &a, const lx_interval &b)
808  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
809 {
810  Inf(a)=(Inf(a)>Inf(b))?Inf(a):Inf(b),Sup(a)=(Sup(a)<Sup(b))?Sup(a):Sup(b);
811  if (Inf(a)>Sup(a))
812  cxscthrow(ERROR_LINTERVAL_EMPTY_INTERVAL("lx_interval & operator &=(lx_interval &a,const lx_interval &b)"));
813  return a;
814 }
815 
816 inline lx_interval operator & (const lx_interval &a, const lx_real &b)
817  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
818 {
819  return lx_interval( (Inf(a)>b) ? Inf(a) : b,
820  (Sup(a)<b) ? Sup(a) : b );
821 }
822 
823 inline lx_interval operator & (const lx_interval &a, const real &b)
824  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
825 {
826  lx_real Lb(b);
827  return lx_interval( (Inf(a)>Lb) ? Inf(a) : Lb,
828  (Sup(a)<Lb) ? Sup(a) : Lb );
829 }
830 
831 inline lx_interval operator & (const lx_interval &a, const l_real &b)
832  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
833 {
834  lx_real Lb(0.0,b);
835  return lx_interval( (Inf(a)>Lb) ? Inf(a) : Lb,
836  (Sup(a)<Lb) ? Sup(a) : Lb );
837 }
838 
839 inline lx_interval operator & (const lx_real &a, const lx_interval &b)
840  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
841 {
842  return lx_interval( (a>Inf(b)) ? a : Inf(b),
843  (a<Sup(b)) ? a : Sup(b) );
844 }
845 
846 inline lx_interval operator & (const real &a, const lx_interval &b)
847  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
848 {
849  lx_real La(a);
850  return lx_interval( (La>Inf(b)) ? La : Inf(b),
851  (La<Sup(b)) ? La : Sup(b) );
852 }
853 
854 inline lx_interval operator & (const l_real &a, const lx_interval &b)
855  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
856 {
857  lx_real La(0.0,a);
858  return lx_interval( (La>Inf(b)) ? La : Inf(b),
859  (La<Sup(b)) ? La : Sup(b) );
860 }
861 
862 inline lx_interval & operator &= (lx_interval &a,const lx_real &b)
863  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
864 {
865  Inf(a) = (Inf(a)>b) ? Inf(a) : b, Sup(a) = (Sup(a)<b) ? Sup(a) : b;
866  if(Inf(a)>Sup(a))
867  cxscthrow(ERROR_LINTERVAL_EMPTY_INTERVAL("lx_interval & operator &=(lx_interval &a,const lx_real &b)"));
868  return a;
869 }
870 
871 inline lx_interval & operator &= (lx_interval &a, const real &b)
872  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
873 {
874  lx_real Lb(b);
875  Inf(a) = (Inf(a)>Lb) ? Inf(a) : Lb, Sup(a) = (Sup(a)<Lb) ? Sup(a) : Lb;
876  if(Inf(a)>Sup(a))
877  cxscthrow(ERROR_LINTERVAL_EMPTY_INTERVAL("lx_interval & operator &=(lx_interval &a,const real &b)"));
878  return a;
879 }
880 
881 inline lx_interval & operator &= (lx_interval &a, const l_real &b)
882  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
883 {
884  lx_real Lb(0.0,b);
885  Inf(a) = (Inf(a)>Lb) ? Inf(a) : Lb, Sup(a) = (Sup(a)<Lb) ? Sup(a) : Lb;
886  if(Inf(a)>Sup(a))
887  cxscthrow(ERROR_LINTERVAL_EMPTY_INTERVAL("lx_interval & operator &=(lx_interval &a,const l_real &b)"));
888  return a;
889 }
890 
891 // ------------------------- SetInf, SetSup -----------------------------
892 
893 inline lx_interval & SetInf(lx_interval& a, const lx_real& b)
894  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
895 {
896  return a = lx_interval(b,Sup(a));
897 }
898 
899 inline lx_interval & SetInf(lx_interval& a, const l_real& b)
900  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
901 {
902  return a = lx_interval(lx_real(0.0,b),Sup(a));
903 }
904 
905 inline lx_interval & SetInf(lx_interval& a, const real& b)
906  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
907 {
908  return a = lx_interval(lx_real(0.0,l_real(b)),Sup(a));
909 }
910 
911 inline lx_interval & SetSup(lx_interval& a, const lx_real& b)
912  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
913 {
914  return a = lx_interval(Inf(a),b);
915 }
916 
917 inline lx_interval & SetSup(lx_interval& a, const l_real& b)
918  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
919 {
920  return a = lx_interval(Inf(a),lx_real(0.0,b));
921 }
922 
923 inline lx_interval & SetSup(lx_interval& a, const real& b)
924  throw(ERROR_LINTERVAL_EMPTY_INTERVAL)
925 {
926  return a = lx_interval(Inf(a),lx_real(0.0,l_real(b)));
927 }
928 
929 
930 } // end namespace cxsc
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
Definition: cinterval.cpp:665
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:71
cimatrix & operator/=(cimatrix &m, const cinterval &c)
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:77
int Lb(const cimatrix &rm, const int &i)
Returns the lower bound index.
Definition: cimatrix.inl:1156
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
civector operator*(const cimatrix_subv &rv, const cinterval &s)
Implementation of multiplication operation.
Definition: cimatrix.inl:731
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
Definition: cinterval.cpp:654
cvector mid(const cimatrix_subv &mv)
Returns the middle of the matrix.
Definition: cimatrix.inl:739
The Scalar Type interval.
Definition: interval.hpp:54
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition: interval.cpp:293
real RelDiam(const interval &x)
Computes the relative diameter .
Definition: interval.cpp:316
real add_real(const real &a, const real &b)
Returns a,b must be integers with .
Definition: lx_real.inl:75
const real MaxReal
Greatest representable floating-point number.
Definition: real.cpp:65
cvector diam(const cimatrix_subv &mv)
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
int Disjoint(const interval &a, const interval &b)
Checks arguments for disjointness.
Definition: interval.cpp:288
real AbsMax(const interval &x)
Computes the greatest absolute value .
Definition: interval.cpp:303
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc)
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
void times2pown(cinterval &x, int n)
Fast multiplication of reference parameter [z] with .
Definition: cimath.cpp:2059
int expo_gr(const l_interval &x)
Definition: l_interval.inl:522
const real minreal
Smallest positive denormalized representable floating-point number.
Definition: real.cpp:63
civector operator/(const cimatrix_subv &rv, const cinterval &s)
Implementation of division operation.
Definition: cimatrix.inl:730
cimatrix & operator*=(cimatrix &m, const cinterval &c)
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
The Scalar Type real.
Definition: real.hpp:113
ivector abs(const cimatrix_subv &mv)
Returns the absolute value of the matrix.
Definition: cimatrix.inl:737