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
30namespace cxsc {
31
32
33// --------------------------------------------------------------------------
34// ------ Inline functions and operators related to type lx_interval --------
35// --------------------------------------------------------------------------
36
37inline int StagPrec(const lx_interval &a) noexcept
38{ return StagPrec(a.li); }
39
40inline real expo(const lx_interval &a) noexcept
41{ return (a.ex); }
42
43inline l_interval li_part(const lx_interval &a) noexcept
44{ return (a.li); }
45
46inline int Disjoint(const lx_interval& a, const lx_interval& b)
47{ return (Inf(a)>Sup(b) || Inf(b)>Sup(a)); }
48
49inline int in(const lx_interval& x, const lx_interval& y)
50{ return ( (Inf(y) < Inf(x)) && (Sup(x) < Sup(y)) ); }
51
52inline int in(const l_interval& x, const lx_interval& y)
53{ return ( (Inf(y) < Inf(x)) && (Sup(x) < Sup(y)) ); }
54
55inline int in(const interval& x, const lx_interval& y)
56{ return ( (Inf(y) < Inf(x)) && (Sup(x) < Sup(y)) ); }
57
58inline int in(const lx_real& x, const lx_interval& y )
59{ return ( (Inf(y) <= x) && (x <= Sup(y)) ); }
60
61inline int in(const l_real& x, const lx_interval& y )
62{ return ( (Inf(y) <= x) && (x <= Sup(y)) ); }
63
64inline int in(const real& x, const lx_interval& y )
65{ return ( (Inf(y) <= x) && (x <= Sup(y)) ); }
66
67inline lx_interval Blow(const lx_interval& a) noexcept
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
92inline 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
98inline 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
109inline 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
122inline lx_interval & lx_interval::operator = (const lx_interval &a) noexcept
123{
124 ex = a.ex;
125 li = a.li;
126 return *this;
127}
128
129inline lx_interval & lx_interval::operator = (const lx_real &a) noexcept
130{
131 ex = expo(a);
132 li = lr_part(a);
133 return *this;
134}
135
136inline lx_interval & lx_interval::operator = (const l_interval &a) noexcept
137{
138 ex = 0;
139 li = a;
140 return *this;
141}
142
143inline lx_interval & lx_interval::operator = (const l_real & a) noexcept
144{
145 ex = 0;
146 li = a;
147 return *this;
148}
149
150inline lx_interval & lx_interval::operator = (const real & a) noexcept
151{
152 ex = 0;
153 li = a;
154 return *this;
155}
156
157inline lx_interval & lx_interval::operator = (const interval & a) noexcept
158{
159 ex = 0;
160 li = a;
161 return *this;
162}
163
164inline lx_interval operator+(const lx_interval & a) noexcept { return a; }
165inline lx_interval operator-(const lx_interval & a) noexcept
166{ return lx_interval(a.ex,-a.li); }
167
168inline lx_interval operator + (const lx_interval &a, const l_interval &b) noexcept
169{ return a + lx_interval(b); }
170
171inline lx_interval operator + (const l_interval &a, const lx_interval &b) noexcept
172{ return lx_interval(a) + b; }
173
174inline lx_interval operator + (const lx_interval &a, const l_real &b) noexcept
175{ return a + lx_interval(b); }
176
177inline lx_interval operator + (const l_real &a, const lx_interval &b) noexcept
178{ return lx_interval(a) + b; }
179
180inline lx_interval operator + (const lx_interval &a, const lx_real &b) noexcept
181{ return a + lx_interval(b); }
182
183inline lx_interval operator + (const lx_real &a, const lx_interval &b) noexcept
184{ return lx_interval(a) + b; }
185
186inline lx_interval operator + (const lx_interval &a, const real &b) noexcept
187{ return a + lx_interval(b); }
188
189inline lx_interval operator + (const real &a, const lx_interval &b) noexcept
190{ return lx_interval(a) + b; }
191
192inline lx_interval operator + (const lx_interval &a, const interval &b) noexcept
193{ return a + lx_interval(b); }
194
195inline lx_interval operator + (const interval &a, const lx_interval &b) noexcept
196{ return lx_interval(a) + b; }
197
198inline lx_interval & operator +=(lx_interval &a, const lx_interval &b) noexcept
199{ return a = a+b; }
200
201inline lx_interval & operator +=(lx_interval &a, const l_interval &b) noexcept
202{ return a = a+b; }
203
204inline lx_interval & operator +=(lx_interval &a, const l_real &b) noexcept
205{ return a = a+b; }
206
207inline lx_interval & operator +=(lx_interval &a, const lx_real &b) noexcept
208{ return a = a+b; }
209
210inline lx_interval & operator +=(lx_interval &a, const real &b) noexcept
211{ return a = a+b; }
212
213inline lx_interval & operator +=(lx_interval &a, const interval &b) noexcept
214{ return a = a+b; }
215
216inline lx_interval operator - (const lx_interval &a, const lx_interval &b) noexcept
217{ return a + lx_interval(-b); }
218
219inline lx_interval operator - (const lx_interval &a, const l_interval &b) noexcept
220{ return a + lx_interval(-b); }
221
222inline lx_interval operator - (const l_interval &a, const lx_interval &b) noexcept
223{ return lx_interval(a) + (-b); }
224
225inline lx_interval operator - (const lx_interval &a, const l_real &b) noexcept
226{ return a + lx_interval(-b); }
227
228inline lx_interval operator - (const l_real &a, const lx_interval &b) noexcept
229{ return lx_interval(a) + (-b); }
230
231inline lx_interval operator - (const lx_interval &a, const lx_real &b) noexcept
232{ return a + lx_interval(-b); }
233
234inline lx_interval operator - (const lx_real &a, const lx_interval &b) noexcept
235{ return lx_interval(a) + (-b); }
236
237inline lx_interval operator - (const lx_interval &a, const real &b) noexcept
238{ return a + lx_interval(-b); }
239
240inline lx_interval operator - (const real &a, const lx_interval &b) noexcept
241{ return lx_interval(a) + (-b); }
242
243inline lx_interval operator - (const lx_interval &a, const interval &b) noexcept
244{ return a + lx_interval(-b); }
245
246inline lx_interval operator - (const interval &a, const lx_interval &b) noexcept
247{ return lx_interval(a) + (-b); }
248
249inline lx_interval & operator -=(lx_interval &a, const lx_interval &b) noexcept
250{ return a = a-b; }
251inline lx_interval & operator -=(lx_interval &a, const l_interval &b) noexcept
252{ return a = a-b; }
253inline lx_interval & operator -=(lx_interval &a, const l_real &b) noexcept
254{ return a = a-b; }
255inline lx_interval & operator -=(lx_interval &a, const lx_real &b) noexcept
256{ return a = a-b; }
257inline lx_interval & operator -=(lx_interval &a, const real &b) noexcept
258{ return a = a-b; }
259inline lx_interval & operator -=(lx_interval &a, const interval &b) noexcept
260{ return a = a-b; }
261
262inline lx_interval operator * (const lx_interval &a, const l_interval &b)
263 noexcept
264{ return a * lx_interval(b); }
265
266inline lx_interval operator * (const l_interval &a, const lx_interval &b)
267 noexcept
268{ return lx_interval(a) * b; }
269
270inline lx_interval operator * (const lx_interval &a, const l_real &b) noexcept
271{ return a * lx_interval(b); }
272
273inline lx_interval operator * (const l_real &a, const lx_interval &b) noexcept
274{ return lx_interval(a) * b; }
275
276inline lx_interval operator * (const lx_interval &a, const lx_real &b) noexcept
277{ return a * lx_interval(b); }
278
279inline lx_interval operator * (const lx_real &a, const lx_interval &b) noexcept
280{ return lx_interval(a) * b; }
281
282inline lx_interval operator * (const lx_interval &a, const real &b) noexcept
283{ return a * lx_interval(b); }
284
285inline lx_interval operator * (const real &a, const lx_interval &b) noexcept
286{ return lx_interval(a) * b; }
287
288inline lx_interval operator * (const lx_interval &a, const interval &b) noexcept
289{ return a * lx_interval(b); }
290
291inline lx_interval operator * (const interval &a, const lx_interval &b) noexcept
292{ return lx_interval(a) * b; }
293
294inline lx_interval & operator *=(lx_interval &a, const lx_interval &b) noexcept
295{ return a = a*b; }
296inline lx_interval & operator *=(lx_interval &a, const l_interval &b) noexcept
297{ return a = a*b; }
298inline lx_interval & operator *=(lx_interval &a, const l_real &b) noexcept
299{ return a = a*b; }
300inline lx_interval & operator *=(lx_interval &a, const lx_real &b) noexcept
301{ return a = a*b; }
302inline lx_interval & operator *=(lx_interval &a, const real &b) noexcept
303{ return a = a*b; }
304inline lx_interval & operator *=(lx_interval &a, const interval &b) noexcept
305{ return a = a*b; }
306
307inline lx_interval operator / (const lx_interval &a, const l_interval &b)
308
309{ return a / lx_interval(b); }
310
311inline lx_interval operator / (const l_interval &a, const lx_interval &b)
312
313{ return lx_interval(a) / b; }
314
315inline lx_interval operator / (const lx_interval &a, const l_real &b)
316
317{ return a / lx_interval(b); }
318
319inline lx_interval operator / (const l_real &a, const lx_interval &b)
320
321{ return lx_interval(a) / b; }
322
323inline lx_interval operator / (const lx_interval &a, const real &b)
324
325{ return a / lx_interval(b); }
326
327inline lx_interval operator / (const real &a, const lx_interval &b)
328
329{ return lx_interval(a) / b; }
330
331inline lx_interval operator / (const lx_interval &a, const interval &b)
332
333{ return a / lx_interval(b); }
334
335inline lx_interval operator / (const interval &a, const lx_interval &b)
336
337{ return lx_interval(a) / b; }
338
339inline lx_interval operator / (const lx_interval &a, const lx_real &b)
340
341{ return a / lx_interval(b); }
342
343inline lx_interval operator / (const lx_real &a, const lx_interval &b)
344
345{ return lx_interval(a) / b; }
346
347
348inline lx_interval & operator /=(lx_interval &a, const lx_interval &b) noexcept
349{ return a = a/b; }
350inline lx_interval & operator /=(lx_interval &a, const l_interval &b) noexcept
351{ return a = a/b; }
352inline lx_interval & operator /=(lx_interval &a, const l_real &b) noexcept
353{ return a = a/b; }
354inline lx_interval & operator /=(lx_interval &a, const real &b) noexcept
355{ return a = a/b; }
356inline lx_interval & operator /=(lx_interval &a, const interval &b) noexcept
357{ return a = a/b; }
358inline lx_interval & operator /=(lx_interval &a, const lx_real &b) noexcept
359{ return a = a/b; }
360
361// ------------------ Vergleichsoperatoren ----------------------------------
362
363inline bool operator ! (const lx_interval& a) noexcept
364{ return !a.li; }
365
366inline bool operator == (const lx_interval &a, const lx_interval &b) noexcept
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
393inline bool operator == (const lx_interval &a, const l_interval &b) noexcept
394{ return (a == lx_interval(b)); }
395
396inline bool operator == (const l_interval &a, const lx_interval &b) noexcept
397{ return ( lx_interval(a) == b); }
398
399inline bool operator == (const lx_interval &a, const interval &b) noexcept
400{ return (a == lx_interval(b)); }
401
402inline bool operator == (const interval &a, const lx_interval &b) noexcept
403{ return ( lx_interval(a) == b); }
404
405inline bool operator == (const lx_interval &a, const real &b) noexcept
406{ return ( a == lx_interval(b)); }
407
408inline bool operator == (const lx_interval &a, const l_real &b) noexcept
409{ return ( a == lx_interval(b)); }
410
411inline bool operator == (const real &a, const lx_interval &b) noexcept
412{ return ( lx_interval(a) == b); }
413
414inline bool operator == (const l_real &a, const lx_interval &b) noexcept
415{ return ( lx_interval(a) == b); }
416
417inline bool operator == (const lx_interval &a, const lx_real &b) noexcept
418{ return ( a == lx_interval(b)); }
419
420inline bool operator == (const lx_real &a, const lx_interval &b) noexcept
421{ return ( lx_interval(a) == b); }
422
423inline bool operator != (const lx_interval &a, const lx_interval &b) noexcept
424{ return !(a==b); }
425
426inline bool operator != (const lx_interval &a, const l_interval &b) noexcept
427{ return !(a==lx_interval(b)); }
428
429inline bool operator != (const l_interval &a, const lx_interval &b) noexcept
430{ return !(lx_interval(a) == b); }
431
432inline bool operator != (const lx_interval &a, const interval &b) noexcept
433{ return !(a==lx_interval(b)); }
434
435inline bool operator != (const interval &a, const lx_interval &b) noexcept
436{ return !(lx_interval(a) == b); }
437
438inline bool operator != (const lx_interval &a, const real &b) noexcept
439{ return !(a == lx_interval(b)); }
440
441inline bool operator != (const real &a, const lx_interval &b) noexcept
442{ return !(lx_interval(a) == b); }
443
444inline bool operator != (const lx_interval &a, const l_real &b) noexcept
445{ return !(a == lx_interval(b)); }
446
447inline bool operator != (const l_real &a, const lx_interval &b) noexcept
448{ return !(lx_interval(a) == b); }
449
450inline bool operator != (const lx_interval &a, const lx_real &b) noexcept
451{ return !(a == lx_interval(b)); }
452
453inline bool operator != (const lx_real &a, const lx_interval &b) noexcept
454{ return !(lx_interval(a) == b); }
455
456// ------------------------------------------------------------------------
457// --------------------------- set comparisons ----------------------------
458// ------------------------------------------------------------------------
459
460// ---- lx_interval--lx_interval
461inline bool operator < (const lx_interval &a, const lx_interval &b) noexcept
462{ return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
463inline bool operator <= (const lx_interval &a, const lx_interval &b) noexcept
464{ return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
465inline bool operator > (const lx_interval& a, const lx_interval& b) noexcept
466{ return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
467inline bool operator >= (const lx_interval& a, const lx_interval& b) noexcept
468{ return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
469
470// ---- lx_interval--l_interval
471inline bool operator < (const lx_interval &a, const l_interval &b) noexcept
472{ return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
473inline bool operator <= (const lx_interval &a, const l_interval &b) noexcept
474{ return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
475inline bool operator < (const l_interval &a, const lx_interval &b) noexcept
476{ return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
477inline bool operator <= (const l_interval &a, const lx_interval &b) noexcept
478{ return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
479inline bool operator > (const lx_interval& a, const l_interval& b) noexcept
480{ return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
481inline bool operator >= (const lx_interval& a, const l_interval& b) noexcept
482{ return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
483inline bool operator > (const l_interval& a, const lx_interval& b) noexcept
484{ return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
485inline bool operator >= (const l_interval& a, const lx_interval& b) noexcept
486{ return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
487
488// ---- lx_interval--interval
489inline bool operator < (const lx_interval &a, const interval &b) noexcept
490{ return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
491inline bool operator <= (const lx_interval &a, const interval &b) noexcept
492{ return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
493inline bool operator < (const interval &a, const lx_interval &b) noexcept
494{ return( Inf(a)>Inf(b) && Sup(a)<Sup(b) ); }
495inline bool operator <= (const interval &a, const lx_interval &b) noexcept
496{ return( Inf(a)>=Inf(b) && Sup(a)<=Sup(b) ); }
497inline bool operator > (const lx_interval& a, const interval& b) noexcept
498{ return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
499inline bool operator >= (const lx_interval& a, const interval& b) noexcept
500{ return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
501inline bool operator > (const interval& a, const lx_interval& b) noexcept
502{ return(Inf(a)<Inf(b) && Sup(a)>Sup(b)); }
503inline bool operator >= (const interval& a, const lx_interval& b) noexcept
504{ return(Inf(a)<=Inf(b) && Sup(a)>=Sup(b)); }
505
506// ---- lx_interval--real
507inline bool operator < (const real &a, const lx_interval &b) noexcept
508{ return( a>Inf(b) && a<Sup(b) ); }
509inline bool operator <= (const real &a, const lx_interval &b) noexcept
510{ return( a>=Inf(b) && a<=Sup(b) ); }
511inline bool operator > (const lx_interval &a, const real &b) noexcept
512{ return( b>Inf(a) && b<Sup(a) ); }
513inline bool operator >= (const lx_interval &a, const real &b) noexcept
514{ return( b>=Inf(a) && b<=Sup(a) ); }
515
516// ---- lx_interval--l_real
517inline bool operator < (const l_real &a, const lx_interval &b) noexcept
518{ return( a>Inf(b) && a<Sup(b) ); }
519inline bool operator <= (const l_real &a, const lx_interval &b) noexcept
520{ return( a>=Inf(b) && a<=Sup(b) ); }
521inline bool operator > (const lx_interval &a, const l_real &b) noexcept
522{ return( b>Inf(a) && b<Sup(a) ); }
523inline bool operator >= (const lx_interval &a, const l_real &b) noexcept
524{ return( b>=Inf(a) && b<=Sup(a) ); }
525
526// ---- lx_interval--lx_real
527inline bool operator < (const lx_real &a, const lx_interval &b) noexcept
528{ return( a>Inf(b) && a<Sup(b) ); }
529inline bool operator <= (const lx_real &a, const lx_interval &b) noexcept
530{ return( a>=Inf(b) && a<=Sup(b) ); }
531inline bool operator > (const lx_interval &a, const lx_real &b) noexcept
532{ return( b>Inf(a) && b<Sup(a) ); }
533inline bool operator >= (const lx_interval &a, const lx_real &b) noexcept
534{ return( b>=Inf(a) && b<=Sup(a) ); }
535
536
537inline lx_interval adjust(const lx_interval &a) noexcept
538{ return lx_interval(a.ex,adjust(a.li)); }
539
540inline lx_interval abs(const lx_interval &a) noexcept
541{ return lx_interval(a.ex,abs(a.li)); }
542
543inline bool point_intv(const lx_interval &a)
544{ return point_intv(a.li); }
545
546inline void times2pown(lx_interval &a, const real& n) noexcept
547{ a = lx_interval(add_real(n,a.ex),a.li); }
548
549inline void times2pown_neg(lx_interval& a, const real& n) noexcept
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
595inline lx_real Inf(const lx_interval &a) noexcept
596{ return lx_real(a.ex,Inf(a.li)); }
597
598inline lx_real Sup(const lx_interval &a) noexcept
599{ return lx_real(a.ex,Sup(a.li)); }
600
601inline 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
610inline lx_real diam(const lx_interval &a) noexcept
611{ return lx_real(a.ex,diam(a.li)); }
612
613inline lx_real mid(const lx_interval& a) noexcept
614{ return lx_real(a.ex,mid(a.li)); }
615
616inline bool IsEmpty(const lx_interval& a) noexcept
617{ return Inf(a.li) > Sup(a.li); }
618
619// ----------------------------- Convex hull -------------------------------
620
621inline lx_interval operator |(const lx_interval &a, const lx_interval &b) noexcept
622{
623 return lx_interval( (Inf(a)<Inf(b)) ? Inf(a) : Inf(b),
624 (Sup(a)>Sup(b)) ? Sup(a) : Sup(b) );
625}
626
627inline lx_interval operator |(const lx_interval &a, const l_interval &b) noexcept
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
634inline lx_interval operator |(const l_interval &a, const lx_interval &b) noexcept
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
641inline lx_interval operator |(const lx_interval &a, const interval &b) noexcept
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
648inline lx_interval operator |(const interval &a, const lx_interval &b) noexcept
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
655inline lx_interval & operator |= (lx_interval &a,const lx_interval &b) noexcept
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
661inline lx_interval & operator |= (lx_interval &a,const l_interval &b) noexcept
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
669inline lx_interval & operator |= (lx_interval &a,const interval &b) noexcept
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
677inline lx_interval operator | (const lx_real &a, const lx_interval &b) noexcept
678{
679 return lx_interval( (a<Inf(b)) ? a : Inf(b),
680 (a>Sup(b)) ? a : Sup(b) );
681}
682
683inline lx_interval operator | (const real &a, const lx_interval &b) noexcept
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
690inline lx_interval operator | (const l_real &a, const lx_interval &b) noexcept
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
697inline lx_interval operator | (const lx_interval &a, const lx_real &b) noexcept
698{
699 return lx_interval( (Inf(a)<b) ? Inf(a) : b,
700 (Sup(a)>b) ? Sup(a) : b );
701}
702
703inline lx_interval operator | (const lx_interval &a, const real &b) noexcept
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
710inline lx_interval operator | (const lx_interval &a, const l_real &b) noexcept
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
717inline lx_interval & operator |= (lx_interval &a, const real &b) noexcept
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
724inline lx_interval & operator |= (lx_interval &a, const l_real &b) noexcept
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
732inline lx_interval & operator |= (lx_interval &a, const lx_real &b) noexcept
733{
734 Inf(a) = (Inf(a)<b) ? Inf(a) : b, Sup(a) = (Sup(a)>b) ? Sup(a) : b;
735 return a;
736}
737
738inline lx_interval operator |(const lx_real &a, const lx_real &b) noexcept
739{
740 if(a>b) return lx_interval(b,a);
741 else return lx_interval(a,b);
742}
743
744// --------------------------- Intersection -----------------------------
745
746inline lx_interval operator & (const lx_interval &a, const lx_interval &b)
747
748{
749 return lx_interval( (Inf(a)>Inf(b)) ? Inf(a) : Inf(b),
750 (Sup(a)<Sup(b)) ? Sup(a) : Sup(b));
751}
752
753inline lx_interval operator & (const lx_interval &a, const l_interval &b)
754
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
761inline lx_interval & operator &= (lx_interval &a, const l_interval &b)
762
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
772inline lx_interval operator & (const l_interval &a, const lx_interval &b)
773
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
780inline lx_interval operator & (const lx_interval &a, const interval &b)
781
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
788inline lx_interval & operator &= (lx_interval &a, const interval &b)
789
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
799inline lx_interval operator & (const interval &a, const lx_interval &b)
800
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
807inline lx_interval & operator &= (lx_interval &a, const lx_interval &b)
808
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
816inline lx_interval operator & (const lx_interval &a, const lx_real &b)
817
818{
819 return lx_interval( (Inf(a)>b) ? Inf(a) : b,
820 (Sup(a)<b) ? Sup(a) : b );
821}
822
823inline lx_interval operator & (const lx_interval &a, const real &b)
824
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
831inline lx_interval operator & (const lx_interval &a, const l_real &b)
832
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
839inline lx_interval operator & (const lx_real &a, const lx_interval &b)
840
841{
842 return lx_interval( (a>Inf(b)) ? a : Inf(b),
843 (a<Sup(b)) ? a : Sup(b) );
844}
845
846inline lx_interval operator & (const real &a, const lx_interval &b)
847
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
854inline lx_interval operator & (const l_real &a, const lx_interval &b)
855
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
862inline lx_interval & operator &= (lx_interval &a,const lx_real &b)
863
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
871inline lx_interval & operator &= (lx_interval &a, const real &b)
872
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
881inline lx_interval & operator &= (lx_interval &a, const l_real &b)
882
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
893inline lx_interval & SetInf(lx_interval& a, const lx_real& b)
894
895{
896 return a = lx_interval(b,Sup(a));
897}
898
899inline lx_interval & SetInf(lx_interval& a, const l_real& b)
900
901{
902 return a = lx_interval(lx_real(0.0,b),Sup(a));
903}
904
905inline lx_interval & SetInf(lx_interval& a, const real& b)
906
907{
908 return a = lx_interval(lx_real(0.0,l_real(b)),Sup(a));
909}
910
911inline lx_interval & SetSup(lx_interval& a, const lx_real& b)
912
913{
914 return a = lx_interval(Inf(a),b);
915}
916
917inline lx_interval & SetSup(lx_interval& a, const l_real& b)
918
919{
920 return a = lx_interval(Inf(a),lx_real(0.0,b));
921}
922
923inline lx_interval & SetSup(lx_interval& a, const real& b)
924
925{
926 return a = lx_interval(Inf(a),lx_real(0.0,l_real(b)));
927}
928
929
930} // end namespace cxsc
The Scalar Type interval.
Definition interval.hpp:55
The Multiple-Precision Data Type l_interval.
The Multiple-Precision Data Type l_real.
Definition l_real.hpp:78
The Scalar Type real.
Definition real.hpp:114
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
const real MaxReal
Greatest representable floating-point number.
Definition real.cpp:65
int Disjoint(const interval &a, const interval &b)
Checks arguments for disjointness.
Definition interval.cpp:288
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
int expo_gr(const l_interval &x)
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
const real minreal
Smallest positive denormalized representable floating-point number.
Definition real.cpp:63
real RelDiam(const interval &x)
Computes the relative diameter .
Definition interval.cpp:316
int in(const cinterval &x, const cinterval &y)
Checks if first argument is part of second argument.
real add_real(const real &a, const real &b) noexcept
Returns a,b must be integers with .
Definition lx_real.inl:75
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
real AbsMax(const interval &x)
Computes the greatest absolute value .
Definition interval.cpp:303
ivector abs(const cimatrix_subv &mv) noexcept
Returns the absolute value of the matrix.
Definition cimatrix.inl:737
void times2pown(cinterval &x, int n) noexcept
Fast multiplication of reference parameter [z] with .
Definition cimath.cpp:2059
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
int Lb(const cimatrix &rm, const int &i) noexcept
Returns the lower bound index.
cinterval Blow(cinterval x, const real &eps)
Performs an epsilon inflation.
real AbsMin(const interval &x)
Computes the smallest absolute value .
Definition interval.cpp:293
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.