C-XSC - A C++ Class Library for Extended Scientific Computing 2.5.4
lx_cinterval.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_cinterval.inl,v 1.9 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// ------ Inline functions and operators related to type lx_cinterval -------
34// --------------------------------------------------------------------------
35
36// --------------------------------------------------------------------------
37// -------------------------- Constructors ----------------------------------
38// --------------------------------------------------------------------------
39
40inline lx_cinterval::lx_cinterval(const lx_interval & a,
41 const lx_interval & b) noexcept
42 : re(a), im(b) { }
43
44inline lx_cinterval::lx_cinterval(const l_interval & a,
45 const l_interval & b) noexcept
46 : re(a), im(b) { }
47
48inline lx_cinterval::lx_cinterval(const interval & a,
49 const interval & b) noexcept
50 : re(a), im(b) { }
51
52inline lx_cinterval::lx_cinterval(const l_real & a,
53 const l_real & b) noexcept
54 : re(a), im(b) { }
55
56inline lx_cinterval::lx_cinterval(const lx_real & a,
57 const lx_real & b) noexcept
58 : re(a), im(b) { }
59
60inline lx_cinterval::lx_cinterval(const real & a,
61 const real & b) noexcept
62 : re(a), im(b) { }
63
64inline lx_cinterval::lx_cinterval(const l_cinterval & a) noexcept
65 : re(Re(a)), im(Im(a)) { }
66
67inline lx_cinterval::lx_cinterval(const complex & a) noexcept
68 : re(Re(a)), im(Im(a)) { }
69
70inline lx_cinterval::lx_cinterval(const l_complex & a) noexcept
71 : re(Re(a)), im(Im(a)) { }
72
73inline lx_cinterval::lx_cinterval(const lx_complex & a) noexcept
74 : re(Re(a)), im(Im(a)) { }
75
76inline lx_cinterval::lx_cinterval(const lx_complex & a, const lx_complex & b)
77
78 : re(Re(a),Re(b)),
79 im(Im(a),Im(b))
80{
81 if(Inf(re)>Sup(re) || Inf(im)>Sup(im))
82 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("lx_cinterval::lx_cinterval(const lx_complex & a,const lx_complex & b)"));
83}
84
85inline lx_cinterval::lx_cinterval(const l_complex & a, const l_complex & b)
86
87 : re(Re(a),Re(b)),
88 im(Im(a),Im(b))
89{
90 if(Inf(re)>Sup(re) || Inf(im)>Sup(im))
91 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("lx_cinterval::lx_cinterval(const l_complex & a,const l_complex & b)"));
92}
93
94inline lx_cinterval::lx_cinterval(const complex & a, const complex & b)
95
96 : re(Re(a),Re(b)),
97 im(Im(a),Im(b))
98{
99 if(Inf(re)>Sup(re) || Inf(im)>Sup(im))
100 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("lx_cinterval::lx_cinterval(const complex & a,const complex & b)"));
101}
102
103inline lx_cinterval::lx_cinterval(const cinterval & a) noexcept
104 : re(Re(a)), im(Im(a)) { }
105
106inline lx_cinterval::lx_cinterval(const real& na, const l_interval &la,
107 const real& nb, const l_interval &lb)
108 noexcept : re(na,la), im(nb,lb) { }
109
110inline lx_cinterval::lx_cinterval(const real &n, const l_interval &a,
111 const lx_interval &b)
112 noexcept : re(n,a), im(b) { }
113
114inline lx_cinterval::lx_cinterval(const lx_interval &a,
115 const real &n, const l_interval &b)
116 noexcept : re(a), im(n,b) { }
117
118inline lx_cinterval::lx_cinterval(const real &nr, const string &sr,
119 const real &ni, const string &si)
120 noexcept : re(lx_interval(nr,sr)), im(lx_interval(ni,si)) { }
121
122inline lx_cinterval::lx_cinterval(const lx_interval & a) noexcept
123 : re(a), im(0) { }
124
125inline lx_cinterval::lx_cinterval(const l_interval & a) noexcept
126 : re(a), im(0) { }
127
128inline lx_cinterval::lx_cinterval(const interval & a) noexcept
129 : re(a), im(0) { }
130
131inline lx_cinterval::lx_cinterval(const lx_real & a) noexcept
132 : re(a), im(0) { }
133
134inline lx_cinterval::lx_cinterval(const l_real & a) noexcept
135 : re(a), im(0) { }
136
137inline lx_cinterval::lx_cinterval(const real & a) noexcept
138 : re(a), im(0) { }
139
140inline lx_cinterval::lx_cinterval(const real& n, const l_interval &a) noexcept
141 : re(n,a), im(0) { }
142
143
144
145// -----------------------------------------------------------------------
146// ------------------------------ Assignments ----------------------------
147// -----------------------------------------------------------------------
148
149inline lx_cinterval & lx_cinterval::operator = (const lx_cinterval & a) noexcept
150{
151 re = a.re;
152 im = a.im;
153 return *this;
154}
155
156inline lx_cinterval & lx_cinterval::operator = (const l_cinterval & a) noexcept
157{
158 re = Re(a);
159 im = Im(a);
160 return *this;
161}
162
163inline lx_cinterval & lx_cinterval::operator = (const cinterval & a) noexcept
164{
165 re = Re(a);
166 im = Im(a);
167 return *this;
168}
169
170inline lx_cinterval & lx_cinterval::operator = (const lx_interval & a) noexcept
171{
172 re = a;
173 im = 0.0;
174 return *this;
175}
176
177inline lx_cinterval & lx_cinterval::operator = (const l_interval & a) noexcept
178{
179 re = a;
180 im = 0.0;
181 return *this;
182}
183
184inline lx_cinterval & lx_cinterval::operator = (const interval & a) noexcept
185{
186 re = a;
187 im = 0.0;
188 return *this;
189}
190
191inline lx_cinterval & lx_cinterval::operator = (const lx_real & a) noexcept
192{
193 re = a;
194 im = 0.0;
195 return *this;
196}
197
198inline lx_cinterval & lx_cinterval::operator = (const l_real & a) noexcept
199{
200 re = a;
201 im = 0.0;
202 return *this;
203}
204
205inline lx_cinterval & lx_cinterval::operator = (const real & a) noexcept
206{
207 re = a;
208 im = 0.0;
209 return *this;
210}
211
212inline lx_cinterval & lx_cinterval::operator = (const lx_complex & a ) noexcept
213{
214 re = Re(a);
215 im = Im(a);
216 return *this;
217}
218
219inline lx_cinterval & lx_cinterval::operator = (const l_complex & a ) noexcept
220{
221 re = Re(a);
222 im = Im(a);
223 return *this;
224}
225
226inline lx_cinterval & lx_cinterval::operator = (const complex & a ) noexcept
227{
228 re = Re(a);
229 im = Im(a);
230 return *this;
231}
232
233
234
235// -----------------------------------------------------------------------
236// ---------------------------- Functions --------------------------------
237// -----------------------------------------------------------------------
238
239inline lx_complex Inf(const lx_cinterval &a) noexcept
240{ return lx_complex(Inf(a.re),Inf(a.im)); }
241
242inline lx_complex Sup(const lx_cinterval &a) noexcept
243{ return lx_complex(Sup(a.re),Sup(a.im)); }
244
245inline lx_interval Re(const lx_cinterval &a) noexcept
246{ return a.re; }
247
248inline lx_interval Im(const lx_cinterval &a) noexcept
249{ return a.im; }
250
251
252inline lx_cinterval & SetRe(lx_cinterval &a, const lx_interval &b)
253{ a.re=b; return a; }
254inline lx_cinterval & SetRe(lx_cinterval &a, const l_interval &b)
255{ a.re=b; return a; }
256inline lx_cinterval & SetRe(lx_cinterval &a, const interval &b)
257{ a.re=b; return a; }
258inline lx_cinterval & SetRe(lx_cinterval &a, const lx_real &b)
259{ a.re=b; return a; }
260inline lx_cinterval & SetRe(lx_cinterval &a, const l_real &b)
261{ a.re=b; return a; }
262inline lx_cinterval & SetRe(lx_cinterval &a, const real &b)
263{ a.re=b; return a; }
264
265inline lx_cinterval & SetIm(lx_cinterval &a, const lx_interval &b)
266{ a.im=b; return a; }
267inline lx_cinterval & SetIm(lx_cinterval &a, const l_interval &b)
268{ a.im=b; return a; }
269inline lx_cinterval & SetIm(lx_cinterval &a, const interval &b)
270{ a.im=b; return a; }
271inline lx_cinterval & SetIm(lx_cinterval &a, const lx_real &b)
272{ a.im=b; return a; }
273inline lx_cinterval & SetIm(lx_cinterval &a, const l_real &b)
274{ a.im=b; return a; }
275inline lx_cinterval & SetIm(lx_cinterval &a, const real &b)
276{ a.im=b; return a; }
277
278
279inline lx_real InfRe(const lx_cinterval &a) noexcept
280{ return Inf(a.re); }
281inline lx_real InfIm(const lx_cinterval &a) noexcept
282{ return Inf(a.im); }
283inline lx_real SupRe(const lx_cinterval &a) noexcept
284{ return Sup(a.re); }
285inline lx_real SupIm(const lx_cinterval &a) noexcept
286{ return Sup(a.im); }
287
288inline lx_complex mid(const lx_cinterval &a) noexcept
289{ return lx_complex(mid(a.re),mid(a.im)); }
290
291inline lx_complex diam(const lx_cinterval &a) noexcept
292{ return lx_complex(diam(a.re),diam(a.im)); }
293
294inline real expo_Re(const lx_cinterval &a) noexcept
295{ return expo(a.re); }
296
297inline real expo_Im(const lx_cinterval &a) noexcept
298{ return expo(a.im); }
299
300inline l_interval li_part_Re(const lx_cinterval &a) noexcept
301{ return li_part(a.re); }
302
303inline l_interval li_part_Im(const lx_cinterval &a) noexcept
304{ return li_part(a.im); }
305
306inline lx_cinterval adjust(const lx_cinterval &a) noexcept
307{ return lx_cinterval(adjust(a.re),adjust(a.im)); }
308
309inline lx_cinterval conj(const lx_cinterval &a) noexcept
310{ return lx_cinterval(a.re,-a.im); }
311
312inline void times2pown(lx_cinterval& x, const real &n) noexcept
313{
314 lx_interval a(x.re),b(x.im);
315 times2pown(a,n);
316 times2pown(b,n);
317 x = lx_cinterval(a,b);
318}
319
320inline lx_interval abs(const lx_cinterval &a) noexcept
321{
322 return sqrtx2y2(a.re,a.im);
323}
324
325// -----------------------------------------------------------------------
326// ------------------------ Monadic Operators ----------------------------
327// -----------------------------------------------------------------------
328
329inline lx_cinterval operator-(const lx_cinterval & a) noexcept
330{ return lx_cinterval(-a.re,-a.im); }
331
332inline lx_cinterval operator+(const lx_cinterval & a) noexcept
333{ return a; }
334
335
336// -----------------------------------------------------------------------
337// ----------------------- Arithmetic Operators --------------------------
338// -----------------------------------------------------------------------
339
340inline lx_cinterval operator + (const lx_cinterval &a, const lx_cinterval &b)
341 noexcept
342 { return lx_cinterval(a.re + b.re, a.im + b.im); }
343
344inline lx_cinterval operator + (const lx_cinterval &a, const l_cinterval &b)
345 noexcept
346 { return lx_cinterval(a.re + Re(b), a.im + Im(b)); }
347
348inline lx_cinterval operator + (const l_cinterval &a, const lx_cinterval &b)
349 noexcept
350 { return lx_cinterval(Re(a) + b.re, Im(a) + b.im); }
351
352inline lx_cinterval operator + (const lx_cinterval &a, const cinterval &b)
353 noexcept
354 { return lx_cinterval(a.re + Re(b), a.im + Im(b)); }
355
356inline lx_cinterval operator + (const cinterval &a, const lx_cinterval &b)
357 noexcept
358 { return lx_cinterval(Re(a) + b.re, Im(a) + b.im); }
359
360inline lx_cinterval operator + (const lx_cinterval &a, const lx_interval &b)
361 noexcept
362 { return lx_cinterval(a.re + b, a.im); }
363
364inline lx_cinterval operator + (const lx_interval &a, const lx_cinterval &b)
365 noexcept
366 { return lx_cinterval(a + b.re, b.im); }
367
368inline lx_cinterval operator + (const lx_cinterval &a, const l_interval &b)
369 noexcept
370 { return lx_cinterval(a.re + b, a.im); }
371
372inline lx_cinterval operator + (const l_interval &a, const lx_cinterval &b)
373 noexcept
374 { return lx_cinterval(a + b.re, b.im); }
375
376inline lx_cinterval operator + (const lx_cinterval &a, const lx_real &b) noexcept
377 { return lx_cinterval(a.re + b, a.im); }
378
379inline lx_cinterval operator + (const lx_real &a, const lx_cinterval &b) noexcept
380 { return lx_cinterval(a + b.re, b.im); }
381
382inline lx_cinterval operator + (const lx_cinterval &a, const l_real &b) noexcept
383 { return lx_cinterval(a.re + b, a.im); }
384
385inline lx_cinterval operator + (const l_real &a, const lx_cinterval &b) noexcept
386 { return lx_cinterval(a + b.re, b.im); }
387
388inline lx_cinterval operator + (const lx_cinterval &a, const real &b) noexcept
389 { return lx_cinterval(a.re + b, a.im); }
390
391inline lx_cinterval operator + (const real &a, const lx_cinterval &b) noexcept
392 { return lx_cinterval(a + b.re, b.im); }
393
394inline lx_cinterval operator + (const lx_cinterval &a, const complex &b) noexcept
395 { return lx_cinterval(a.re + Re(b), a.im + Im(b)); }
396inline lx_cinterval operator + (const complex &a, const lx_cinterval &b) noexcept
397 { return lx_cinterval(Re(a) + b.re, Im(a) + b.im); }
398
399inline lx_cinterval operator + (const lx_cinterval &a, const l_complex &b)
400 noexcept { return lx_cinterval(a.re + Re(b), a.im + Im(b)); }
401inline lx_cinterval operator + (const l_complex &a, const lx_cinterval &b)
402 noexcept { return lx_cinterval(Re(a) + b.re, Im(a) + b.im); }
403
404inline lx_cinterval operator + (const lx_cinterval &a, const lx_complex &b)
405 noexcept { return lx_cinterval(a.re + Re(b), a.im + Im(b)); }
406inline lx_cinterval operator + (const lx_complex &a, const lx_cinterval &b)
407 noexcept { return lx_cinterval(Re(a) + b.re, Im(a) + b.im); }
408
409
410inline lx_cinterval & operator +=(lx_cinterval &a, const lx_cinterval &b) noexcept
411{ return a = a+b; }
412
413inline lx_cinterval & operator +=(lx_cinterval &a, const lx_interval &b) noexcept
414{ return a = a+b; }
415
416inline lx_cinterval & operator +=(lx_cinterval &a, const l_interval &b) noexcept
417{ return a = a+b; }
418
419inline lx_cinterval & operator +=(lx_cinterval &a, const l_cinterval &b) noexcept
420{ return a = a+b; }
421
422inline lx_cinterval & operator +=(lx_cinterval &a, const l_real &b) noexcept
423{ return a = a+b; }
424
425inline lx_cinterval & operator +=(lx_cinterval &a, const lx_real &b) noexcept
426{ return a = a+b; }
427
428inline lx_cinterval & operator +=(lx_cinterval &a, const real &b) noexcept
429{ return a = a+b; }
430
431inline lx_cinterval & operator +=(lx_cinterval &a, const interval &b) noexcept
432{ return a = a+b; }
433
434inline lx_cinterval & operator +=(lx_cinterval &a, const cinterval &b) noexcept
435{ return a = a+b; }
436
437inline lx_cinterval & operator +=(lx_cinterval &a, const complex &b) noexcept
438{ return a = a+b; }
439
440inline lx_cinterval & operator +=(lx_cinterval &a, const l_complex &b) noexcept
441{ return a = a+b; }
442
443inline lx_cinterval & operator +=(lx_cinterval &a, const lx_complex &b) noexcept
444{ return a = a+b; }
445
446
447inline lx_cinterval operator - (const lx_cinterval &a, const lx_cinterval &b)
448 noexcept { return lx_cinterval(a.re - b.re, a.im - b.im); }
449
450inline lx_cinterval operator - (const lx_cinterval &a, const l_cinterval &b)
451 noexcept { return lx_cinterval(a.re - Re(b), a.im - Im(b)); }
452
453inline lx_cinterval operator - (const l_cinterval &a, const lx_cinterval &b)
454 noexcept { return lx_cinterval(Re(a) - b.re, Im(a) - b.im); }
455
456inline lx_cinterval operator - (const lx_cinterval &a, const cinterval &b)
457 noexcept { return lx_cinterval(a.re - Re(b), a.im - Im(b)); }
458
459inline lx_cinterval operator - (const cinterval &a, const lx_cinterval &b)
460 noexcept { return lx_cinterval(Re(a) - b.re, Im(a) - b.im); }
461
462inline lx_cinterval operator - (const lx_cinterval &a, const lx_interval &b)
463 noexcept { return lx_cinterval(a.re - b, a.im); }
464
465inline lx_cinterval operator - (const lx_interval &a, const lx_cinterval &b)
466 noexcept { return lx_cinterval(a - b.re, -b.im); }
467
468inline lx_cinterval operator - (const lx_cinterval &a, const l_interval &b)
469 noexcept { return lx_cinterval(a.re - b, a.im); }
470
471inline lx_cinterval operator - (const l_interval &a, const lx_cinterval &b)
472 noexcept { return lx_cinterval(a - b.re, -b.im); }
473
474inline lx_cinterval operator - (const lx_cinterval &a, const lx_real &b) noexcept
475{ return lx_cinterval(a.re - b, a.im); }
476
477inline lx_cinterval operator - (const lx_real &a, const lx_cinterval &b) noexcept
478{ return lx_cinterval(a - b.re, -b.im); }
479
480inline lx_cinterval operator - (const lx_cinterval &a, const l_real &b) noexcept
481{ return lx_cinterval(a.re - b, a.im); }
482
483inline lx_cinterval operator - (const l_real &a, const lx_cinterval &b) noexcept
484{ return lx_cinterval(a - b.re, -b.im); }
485
486inline lx_cinterval operator - (const lx_cinterval &a, const real &b) noexcept
487{ return lx_cinterval(a.re - b, a.im); }
488
489inline lx_cinterval operator - (const real &a, const lx_cinterval &b) noexcept
490{ return lx_cinterval(a - b.re, -b.im); }
491
492inline lx_cinterval operator - (const lx_cinterval &a, const complex &b) noexcept
493 { return lx_cinterval(a.re - Re(b), a.im - Im(b)); }
494inline lx_cinterval operator - (const complex &a, const lx_cinterval &b) noexcept
495 { return lx_cinterval(Re(a) - b.re, Im(a) - b.im); }
496inline lx_cinterval operator - (const lx_cinterval &a, const l_complex &b)
497 noexcept { return lx_cinterval(a.re - Re(b), a.im - Im(b)); }
498inline lx_cinterval operator - (const l_complex &a, const lx_cinterval &b)
499 noexcept { return lx_cinterval(Re(a) - b.re, Im(a) - b.im); }
500inline lx_cinterval operator - (const lx_cinterval &a, const lx_complex &b)
501 noexcept { return lx_cinterval(a.re - Re(b), a.im - Im(b)); }
502inline lx_cinterval operator - (const lx_complex &a, const lx_cinterval &b)
503 noexcept { return lx_cinterval(Re(a) - b.re, Im(a) - b.im); }
504
505
506inline lx_cinterval & operator -=(lx_cinterval &a, const lx_cinterval &b) noexcept
507{ return a = a-b; }
508
509inline lx_cinterval & operator -=(lx_cinterval &a, const lx_interval &b) noexcept
510{ return a = a-b; }
511
512inline lx_cinterval & operator -=(lx_cinterval &a, const l_interval &b) noexcept
513{ return a = a-b; }
514
515inline lx_cinterval & operator -=(lx_cinterval &a, const l_cinterval &b) noexcept
516{ return a = a-b; }
517
518inline lx_cinterval & operator -=(lx_cinterval &a, const l_real &b) noexcept
519{ return a = a-b; }
520
521inline lx_cinterval & operator -=(lx_cinterval &a, const lx_real &b) noexcept
522{ return a = a-b; }
523
524inline lx_cinterval & operator -=(lx_cinterval &a, const real &b) noexcept
525{ return a = a-b; }
526
527inline lx_cinterval & operator -=(lx_cinterval &a, const interval &b) noexcept
528{ return a = a-b; }
529
530inline lx_cinterval & operator -=(lx_cinterval &a, const cinterval &b) noexcept
531{ return a = a-b; }
532inline lx_cinterval & operator -=(lx_cinterval &a, const complex &b) noexcept
533{ return a = a-b; }
534inline lx_cinterval & operator -=(lx_cinterval &a, const l_complex &b) noexcept
535{ return a = a-b; }
536inline lx_cinterval & operator -=(lx_cinterval &a, const lx_complex &b) noexcept
537{ return a = a-b; }
538
539
540inline lx_cinterval operator * (const lx_cinterval &a,const lx_cinterval &b)
541noexcept
542{ return lx_cinterval(a.re*b.re - a.im*b.im, a.im*b.re + a.re*b.im); }
543
544inline lx_cinterval operator * (const lx_cinterval &a, const l_cinterval &b)
545noexcept
546{ return a * lx_cinterval(b); }
547
548inline lx_cinterval operator * (const l_cinterval &a, const lx_cinterval &b)
549noexcept
550{ return lx_cinterval(a) * b; }
551
552inline lx_cinterval operator * (const lx_cinterval &a, const cinterval &b)
553noexcept
554{ return a * lx_cinterval(b); }
555
556inline lx_cinterval operator * (const cinterval &a, const lx_cinterval &b)
557noexcept
558{ return lx_cinterval(a) * b; }
559
560
561inline lx_cinterval operator * (const lx_cinterval &a, const lx_interval &b)
562noexcept
563{ return lx_cinterval(a.re*b, a.im*b); }
564
565inline lx_cinterval operator * (const lx_interval &a, const lx_cinterval &b)
566noexcept
567{ return lx_cinterval(a*b.re, a*b.im); }
568
569inline lx_cinterval operator * (const lx_cinterval &a, const l_interval &b)
570noexcept
571{ return lx_cinterval(a.re*b, a.im*b); }
572
573inline lx_cinterval operator * (const l_interval &a, const lx_cinterval &b)
574noexcept
575{ return lx_cinterval(a*b.re, a*b.im); }
576
577inline lx_cinterval operator * (const lx_cinterval &a, const lx_real &b) noexcept
578{ return lx_cinterval(a.re*b, a.im*b); }
579
580inline lx_cinterval operator * (const lx_real &a, const lx_cinterval &b) noexcept
581{ return lx_cinterval(a*b.re, a*b.im); }
582
583inline lx_cinterval operator * (const lx_cinterval &a, const l_real &b) noexcept
584{ return lx_cinterval(a.re*b, a.im*b); }
585
586inline lx_cinterval operator * (const l_real &a, const lx_cinterval &b) noexcept
587{ return lx_cinterval(a*b.re, a*b.im); }
588
589inline lx_cinterval operator * (const lx_cinterval &a, const real &b) noexcept
590{ return lx_cinterval(a.re*b, a.im*b); }
591
592inline lx_cinterval operator * (const real &a, const lx_cinterval &b) noexcept
593{ return lx_cinterval(a*b.re, a*b.im); }
594
595inline lx_cinterval operator * (const lx_cinterval &a, const complex &b) noexcept
596{ return a * lx_cinterval(b); }
597inline lx_cinterval operator * (const complex &a, const lx_cinterval &b) noexcept
598{ return lx_cinterval(a) * b; }
599inline lx_cinterval operator * (const lx_cinterval &a, const l_complex &b)
600 noexcept { return a * lx_cinterval(b); }
601inline lx_cinterval operator * (const l_complex &a, const lx_cinterval &b)
602 noexcept { return lx_cinterval(a) * b; }
603inline lx_cinterval operator * (const lx_cinterval &a, const lx_complex &b)
604 noexcept { return a * lx_cinterval(b); }
605inline lx_cinterval operator * (const lx_complex &a, const lx_cinterval &b)
606 noexcept { return lx_cinterval(a) * b; }
607
608
609inline lx_cinterval & operator *=(lx_cinterval &a, const lx_cinterval &b) noexcept
610{ return a = a*b; }
611
612inline lx_cinterval & operator *=(lx_cinterval &a, const lx_interval &b) noexcept
613{ return a = a*b; }
614
615inline lx_cinterval & operator *=(lx_cinterval &a, const l_interval &b) noexcept
616{ return a = a*b; }
617
618inline lx_cinterval & operator *=(lx_cinterval &a, const l_cinterval &b) noexcept
619{ return a = a*b; }
620
621inline lx_cinterval & operator *=(lx_cinterval &a, const l_real &b) noexcept
622{ return a = a*b; }
623
624inline lx_cinterval & operator *=(lx_cinterval &a, const lx_real &b) noexcept
625{ return a = a*b; }
626
627inline lx_cinterval & operator *=(lx_cinterval &a, const real &b) noexcept
628{ return a = a*b; }
629
630inline lx_cinterval & operator *=(lx_cinterval &a, const interval &b) noexcept
631{ return a = a*b; }
632
633inline lx_cinterval & operator *=(lx_cinterval &a, const cinterval &b) noexcept
634{ return a = a*b; }
635
636inline lx_cinterval & operator *=(lx_cinterval &a, const complex &b) noexcept
637{ return a = a*b; }
638
639inline lx_cinterval & operator *=(lx_cinterval &a, const l_complex &b) noexcept
640{ return a = a*b; }
641
642inline lx_cinterval & operator *=(lx_cinterval &a, const lx_complex &b) noexcept
643{ return a = a*b; }
644
645
646inline lx_cinterval operator / (const lx_cinterval &a, const lx_cinterval &b)
647noexcept
648{
649 lx_interval Ne(sqr(b.re) + sqr(b.im));
650
651 return lx_cinterval( (a.re*b.re + a.im*b.im)/Ne,
652 (a.im*b.re - a.re*b.im)/Ne );
653}
654
655inline lx_cinterval operator / (const lx_cinterval &a, const l_cinterval &b)
656noexcept
657{ return a / lx_cinterval(b); }
658
659inline lx_cinterval operator / (const l_cinterval &a, const lx_cinterval &b)
660noexcept
661{ return lx_cinterval(a) / b; }
662
663inline lx_cinterval operator / (const lx_cinterval &a, const cinterval &b)
664noexcept
665{ return a / lx_cinterval(b); }
666
667inline lx_cinterval operator / (const cinterval &a, const lx_cinterval &b)
668noexcept
669{ return lx_cinterval(a) / b; }
670
671inline lx_cinterval operator / (const lx_cinterval &a, const lx_interval &b)
672noexcept
673{ return lx_cinterval(a.re/b, a.im/b); }
674
675inline lx_cinterval operator / (const lx_interval &a, const lx_cinterval &b)
676noexcept
677{ return lx_cinterval(a) / b; }
678
679inline lx_cinterval operator / (const lx_cinterval &a, const l_interval &b)
680noexcept
681{ return lx_cinterval(a.re/b, a.im/b); }
682
683inline lx_cinterval operator / (const l_interval &a, const lx_cinterval &b)
684noexcept
685{ return lx_cinterval(a) / b; }
686
687inline lx_cinterval operator / (const lx_cinterval &a, const l_real &b) noexcept
688{ return lx_cinterval(a.re/b, a.im/b); }
689
690inline lx_cinterval operator / (const l_real &a, const lx_cinterval &b) noexcept
691{ return lx_cinterval(a) / b; }
692
693inline lx_cinterval operator / (const lx_cinterval &a, const lx_real &b) noexcept
694{ return lx_cinterval(a.re/b, a.im/b); }
695
696inline lx_cinterval operator / (const lx_real &a, const lx_cinterval &b) noexcept
697{ return lx_cinterval(a) / b; }
698
699inline lx_cinterval operator / (const lx_cinterval &a, const real &b) noexcept
700{ return lx_cinterval(a.re/b, a.im/b); }
701
702inline lx_cinterval operator / (const real &a, const lx_cinterval &b) noexcept
703{ return lx_cinterval(a) / b; }
704
705inline lx_cinterval operator / (const lx_cinterval &a, const complex &b) noexcept
706{ return a / lx_cinterval(b); }
707inline lx_cinterval operator / (const complex &a, const lx_cinterval &b) noexcept
708{ return lx_cinterval(a) / b; }
709
710inline lx_cinterval operator / (const lx_cinterval &a, const l_complex &b)
711 noexcept { return a / lx_cinterval(b); }
712inline lx_cinterval operator / (const l_complex &a, const lx_cinterval &b)
713 noexcept { return lx_cinterval(a) / b; }
714
715inline lx_cinterval operator / (const lx_cinterval &a, const lx_complex &b)
716 noexcept { return a / lx_cinterval(b); }
717inline lx_cinterval operator / (const lx_complex &a, const lx_cinterval &b)
718 noexcept { return lx_cinterval(a) / b; }
719
720
721inline lx_cinterval & operator /=(lx_cinterval &a, const lx_cinterval &b) noexcept
722{ return a = a/b; }
723
724inline lx_cinterval & operator /=(lx_cinterval &a, const lx_interval &b) noexcept
725{ return a = a/b; }
726
727inline lx_cinterval & operator /=(lx_cinterval &a, const l_interval &b) noexcept
728{ return a = a/b; }
729
730inline lx_cinterval & operator /=(lx_cinterval &a, const l_cinterval &b) noexcept
731{ return a = a/b; }
732
733inline lx_cinterval & operator /=(lx_cinterval &a, const l_real &b) noexcept
734{ return a = a/b; }
735
736inline lx_cinterval & operator /=(lx_cinterval &a, const lx_real &b) noexcept
737{ return a = a/b; }
738
739inline lx_cinterval & operator /=(lx_cinterval &a, const real &b) noexcept
740{ return a = a/b; }
741
742inline lx_cinterval & operator /=(lx_cinterval &a, const interval &b) noexcept
743{ return a = a/b; }
744
745inline lx_cinterval & operator /=(lx_cinterval &a, const cinterval &b) noexcept
746{ return a = a/b; }
747
748inline lx_cinterval & operator /=(lx_cinterval &a, const complex &b) noexcept
749{ return a = a/b; }
750
751inline lx_cinterval & operator /=(lx_cinterval &a, const l_complex &b) noexcept
752{ return a = a/b; }
753
754inline lx_cinterval & operator /=(lx_cinterval &a, const lx_complex &b) noexcept
755{ return a = a/b; }
756
757
758
759inline bool operator ! (const lx_cinterval & a) noexcept
760{ return !a.re && !a.im; }
761
762
763inline bool operator == (const lx_cinterval &a, const lx_cinterval &b) noexcept
764{ return a.re == b.re && a.im == b.im; }
765
766inline bool operator == (const lx_cinterval &a, const l_cinterval &b) noexcept
767{ return a == lx_cinterval(b); }
768inline bool operator == (const l_cinterval &a, const lx_cinterval &b) noexcept
769{ return lx_cinterval(a) == b; }
770
771inline bool operator == (const lx_cinterval &a, const lx_interval &b) noexcept
772{ return a == lx_cinterval(b); }
773inline bool operator == (const lx_interval &a, const lx_cinterval &b) noexcept
774{ return lx_cinterval(a) == b; }
775
776inline bool operator == (const lx_cinterval &a, const l_interval &b) noexcept
777{ return a == lx_cinterval(b); }
778inline bool operator == (const l_interval &a, const lx_cinterval &b) noexcept
779{ return lx_cinterval(a) == b; }
780
781inline bool operator == (const lx_cinterval &a, const l_real &b) noexcept
782{ return a == lx_cinterval(b); }
783inline bool operator == (const l_real &a, const lx_cinterval &b) noexcept
784{ return lx_cinterval(a) == b; }
785
786inline bool operator == (const lx_cinterval &a, const lx_real &b) noexcept
787{ return a == lx_cinterval(b); }
788inline bool operator == (const lx_real &a, const lx_cinterval &b) noexcept
789{ return lx_cinterval(a) == b; }
790
791inline bool operator == (const lx_cinterval &a, const real &b) noexcept
792{ return a == lx_cinterval(b); }
793inline bool operator == (const real &a, const lx_cinterval &b) noexcept
794{ return lx_cinterval(a) == b; }
795
796inline bool operator == (const lx_cinterval &a, const interval &b) noexcept
797{ return a == lx_cinterval(b); }
798inline bool operator == (const interval &a, const lx_cinterval &b) noexcept
799{ return lx_cinterval(a) == b; }
800
801inline bool operator == (const lx_cinterval &a, const cinterval &b) noexcept
802{ return a == lx_cinterval(b); }
803inline bool operator == (const cinterval &a, const lx_cinterval &b) noexcept
804{ return lx_cinterval(a) == b; }
805
806inline bool operator == (const lx_cinterval &a, const complex &b) noexcept
807{ return a == lx_cinterval(b); }
808inline bool operator == (const complex &a, const lx_cinterval &b) noexcept
809{ return lx_cinterval(a) == b; }
810
811inline bool operator == (const lx_cinterval &a, const l_complex &b) noexcept
812{ return a == lx_cinterval(b); }
813inline bool operator == (const l_complex &a, const lx_cinterval &b) noexcept
814{ return lx_cinterval(a) == b; }
815
816inline bool operator == (const lx_cinterval &a, const lx_complex &b) noexcept
817{ return a == lx_cinterval(b); }
818inline bool operator == (const lx_complex &a, const lx_cinterval &b) noexcept
819{ return lx_cinterval(a) == b; }
820
821
822inline bool operator != (const lx_cinterval &a, const lx_cinterval &b) noexcept
823{ return a.re != b.re || a.im != b.im; }
824
825inline bool operator != (const lx_cinterval &a, const l_cinterval &b) noexcept
826{ return !(a == b); }
827inline bool operator != (const l_cinterval &a, const lx_cinterval &b) noexcept
828{ return !(a == b); }
829
830inline bool operator != (const lx_cinterval &a, const lx_interval &b) noexcept
831{ return !(a == b); }
832inline bool operator != (const lx_interval &a, const lx_cinterval &b) noexcept
833{ return !(a == b); }
834
835inline bool operator != (const lx_cinterval &a, const l_interval &b) noexcept
836{ return !(a == b); }
837inline bool operator != (const l_interval &a, const lx_cinterval &b) noexcept
838{ return !(a == b); }
839
840inline bool operator != (const lx_cinterval &a, const l_real &b) noexcept
841{ return !(a == b); }
842inline bool operator != (const l_real &a, const lx_cinterval &b) noexcept
843{ return !(a == b); }
844
845inline bool operator != (const lx_cinterval &a, const lx_real &b) noexcept
846{ return !(a == b); }
847inline bool operator != (const lx_real &a, const lx_cinterval &b) noexcept
848{ return !(a == b); }
849
850inline bool operator != (const lx_cinterval &a, const real &b) noexcept
851{ return !(a == b); }
852inline bool operator != (const real &a, const lx_cinterval &b) noexcept
853{ return !(a == b); }
854
855inline bool operator != (const lx_cinterval &a, const interval &b) noexcept
856{ return !(a == b); }
857inline bool operator != (const interval &a, const lx_cinterval &b) noexcept
858{ return !(a == b); }
859
860inline bool operator != (const lx_cinterval &a, const cinterval &b) noexcept
861{ return !(a == b); }
862inline bool operator != (const cinterval &a, const lx_cinterval &b) noexcept
863{ return !(a == b); }
864
865inline bool operator != (const lx_cinterval &a, const complex &b) noexcept
866{ return !(a == b); }
867inline bool operator != (const complex &a, const lx_cinterval &b) noexcept
868{ return !(a == b); }
869
870inline bool operator != (const lx_cinterval &a, const l_complex &b) noexcept
871{ return !(a == b); }
872inline bool operator != (const l_complex &a, const lx_cinterval &b) noexcept
873{ return !(a == b); }
874
875inline bool operator != (const lx_cinterval &a, const lx_complex &b) noexcept
876{ return !(a == b); }
877inline bool operator != (const lx_complex &a, const lx_cinterval &b) noexcept
878{ return !(a == b); }
879
880
881
882// ------------------------- Set Operators -----------------------------------
883
884inline bool operator < (const lx_cinterval & a, const lx_cinterval & b) noexcept
885{
886 if (Inf(a.re) <= Inf(b.re) || Sup(a.re) >= Sup(b.re))
887 return false;
888 if (Inf(a.im) <= Inf(b.im) || Sup(a.im) >= Sup(b.im))
889 return false;
890
891 return true;
892}
893
894inline bool operator > (const lx_cinterval & a, const lx_cinterval & b) noexcept
895{ return b < a; }
896
897inline bool operator <= (const lx_cinterval & a, const lx_cinterval & b) noexcept
898{
899 if (Inf(a.re) < Inf(b.re) || Sup(a.re) > Sup(b.re))
900 return false;
901 if (Inf(a.im) < Inf(b.im) || Sup(a.im) > Sup(b.im))
902 return false;
903
904 return true;
905}
906
907inline bool operator >= (const lx_cinterval & a, const lx_cinterval & b) noexcept
908{ return b <= a; }
909
910
911inline bool operator <(const l_cinterval & a, const lx_cinterval & b) noexcept
912 { return lx_cinterval(a) < b; }
913inline bool operator >(const l_cinterval & a, const lx_cinterval & b) noexcept
914 { return lx_cinterval(a) > b; }
915inline bool operator <=(const l_cinterval & a, const lx_cinterval & b) noexcept
916 { return lx_cinterval(a) <= b; }
917inline bool operator >=(const l_cinterval & a, const lx_cinterval & b) noexcept
918 { return lx_cinterval(a) >= b; }
919
920inline bool operator <(const lx_cinterval & a, const l_cinterval & b) noexcept
921 { return a < lx_cinterval(b); }
922inline bool operator >(const lx_cinterval & a, const l_cinterval & b) noexcept
923 { return a > lx_cinterval(b); }
924inline bool operator <=(const lx_cinterval & a, const l_cinterval & b) noexcept
925 { return a <= lx_cinterval(b); }
926inline bool operator >=(const lx_cinterval & a, const l_cinterval & b) noexcept
927 { return a >= lx_cinterval(b); }
928
929inline bool operator <(const cinterval & a, const lx_cinterval & b) noexcept
930 { return lx_cinterval(a) < b; }
931inline bool operator >(const cinterval & a, const lx_cinterval & b) noexcept
932 { return lx_cinterval(a) > b; }
933inline bool operator <=(const cinterval & a, const lx_cinterval & b) noexcept
934 { return lx_cinterval(a) <= b; }
935inline bool operator >=(const cinterval & a, const lx_cinterval & b) noexcept
936 { return lx_cinterval(a) >= b; }
937
938inline bool operator <(const lx_cinterval & a, const cinterval & b) noexcept
939 { return a < lx_cinterval(b); }
940inline bool operator >(const lx_cinterval & a, const cinterval & b) noexcept
941 { return a > lx_cinterval(b); }
942inline bool operator <=(const lx_cinterval & a, const cinterval & b) noexcept
943 { return a <= lx_cinterval(b); }
944inline bool operator >=(const lx_cinterval & a, const cinterval & b) noexcept
945 { return a >= lx_cinterval(b); }
946
947inline bool operator <(const lx_interval & a, const lx_cinterval & b) noexcept
948 { return lx_cinterval(a) < b; }
949inline bool operator >(const lx_interval & a, const lx_cinterval & b) noexcept
950 { return lx_cinterval(a) > b; }
951inline bool operator <=(const lx_interval & a, const lx_cinterval & b) noexcept
952 { return lx_cinterval(a) <= b; }
953inline bool operator >=(const lx_interval & a, const lx_cinterval & b) noexcept
954 { return lx_cinterval(a) >= b; }
955
956inline bool operator <(const lx_cinterval & a, const lx_interval & b) noexcept
957 { return a < lx_cinterval(b); }
958inline bool operator >(const lx_cinterval & a, const lx_interval & b) noexcept
959 { return a > lx_cinterval(b); }
960inline bool operator <=(const lx_cinterval & a, const lx_interval & b) noexcept
961 { return a <= lx_cinterval(b); }
962inline bool operator >=(const lx_cinterval & a, const lx_interval & b) noexcept
963 { return a >= lx_cinterval(b); }
964
965inline bool operator <(const l_interval & a, const lx_cinterval & b) noexcept
966 { return lx_cinterval(a) < b; }
967inline bool operator >(const l_interval & a, const lx_cinterval & b) noexcept
968 { return lx_cinterval(a) > b; }
969inline bool operator <=(const l_interval & a, const lx_cinterval & b) noexcept
970 { return lx_cinterval(a) <= b; }
971inline bool operator >=(const l_interval & a, const lx_cinterval & b) noexcept
972 { return lx_cinterval(a) >= b; }
973
974inline bool operator <(const lx_cinterval & a, const l_interval & b) noexcept
975 { return a < lx_cinterval(b); }
976inline bool operator >(const lx_cinterval & a, const l_interval & b) noexcept
977 { return a > lx_cinterval(b); }
978inline bool operator <=(const lx_cinterval & a, const l_interval & b) noexcept
979 { return a <= lx_cinterval(b); }
980inline bool operator >=(const lx_cinterval & a, const l_interval & b) noexcept
981 { return a >= lx_cinterval(b); }
982
983inline bool operator <(const interval & a, const lx_cinterval & b) noexcept
984 { return lx_cinterval(a) < b; }
985inline bool operator >(const interval & a, const lx_cinterval & b) noexcept
986 { return lx_cinterval(a) > b; }
987inline bool operator <=(const interval & a, const lx_cinterval & b) noexcept
988 { return lx_cinterval(a) <= b; }
989inline bool operator >=(const interval & a, const lx_cinterval & b) noexcept
990 { return lx_cinterval(a) >= b; }
991
992inline bool operator <(const lx_cinterval & a, const interval & b) noexcept
993 { return a < lx_cinterval(b); }
994inline bool operator >(const lx_cinterval & a, const interval & b) noexcept
995 { return a > lx_cinterval(b); }
996inline bool operator <=(const lx_cinterval & a, const interval & b) noexcept
997 { return a <= lx_cinterval(b); }
998inline bool operator >=(const lx_cinterval & a, const interval & b) noexcept
999 { return a >= lx_cinterval(b); }
1000
1001inline bool operator <(const lx_real & a, const lx_cinterval & b) noexcept
1002 { return lx_cinterval(a) < b; }
1003inline bool operator <=(const lx_real & a, const lx_cinterval & b) noexcept
1004 { return lx_cinterval(a) <= b; }
1005inline bool operator >(const lx_cinterval & a, const lx_real & b) noexcept
1006 { return a > lx_cinterval(b); }
1007inline bool operator >=(const lx_cinterval & a, const lx_real & b) noexcept
1008 { return a >= lx_cinterval(b); }
1009
1010inline bool operator <(const l_real & a, const lx_cinterval & b) noexcept
1011 { return lx_cinterval(a) < b; }
1012inline bool operator <=(const l_real & a, const lx_cinterval & b) noexcept
1013 { return lx_cinterval(a) <= b; }
1014inline bool operator >(const lx_cinterval & a, const l_real & b) noexcept
1015 { return a > lx_cinterval(b); }
1016inline bool operator >=(const lx_cinterval & a, const l_real & b) noexcept
1017 { return a >= lx_cinterval(b); }
1018
1019inline bool operator <(const real & a, const lx_cinterval & b) noexcept
1020 { return lx_cinterval(a) < b; }
1021inline bool operator <=(const real & a, const lx_cinterval & b) noexcept
1022 { return lx_cinterval(a) <= b; }
1023inline bool operator >(const lx_cinterval & a, const real & b) noexcept
1024 { return a > lx_cinterval(b); }
1025inline bool operator >=(const lx_cinterval & a, const real & b) noexcept
1026 { return a >= lx_cinterval(b); }
1027
1028inline bool operator <(const complex & a, const lx_cinterval & b) noexcept
1029 { return lx_cinterval(a) < b; }
1030inline bool operator <=(const complex & a, const lx_cinterval & b) noexcept
1031 { return lx_cinterval(a) <= b; }
1032inline bool operator >(const lx_cinterval & a, const complex & b) noexcept
1033 { return a > lx_cinterval(b); }
1034inline bool operator >=(const lx_cinterval & a, const complex & b) noexcept
1035 { return a >= lx_cinterval(b); }
1036
1037inline bool operator <(const l_complex & a, const lx_cinterval & b) noexcept
1038 { return lx_cinterval(a) < b; }
1039inline bool operator <=(const l_complex & a, const lx_cinterval & b) noexcept
1040 { return lx_cinterval(a) <= b; }
1041inline bool operator >(const lx_cinterval & a, const l_complex & b) noexcept
1042 { return a > lx_cinterval(b); }
1043inline bool operator >=(const lx_cinterval & a, const l_complex & b) noexcept
1044 { return a >= lx_cinterval(b); }
1045
1046inline bool operator <(const lx_complex & a, const lx_cinterval & b) noexcept
1047 { return lx_cinterval(a) < b; }
1048inline bool operator <=(const lx_complex & a, const lx_cinterval & b) noexcept
1049 { return lx_cinterval(a) <= b; }
1050inline bool operator >(const lx_cinterval & a, const lx_complex & b) noexcept
1051 { return a > lx_cinterval(b); }
1052inline bool operator >=(const lx_cinterval & a, const lx_complex & b) noexcept
1053 { return a >= lx_cinterval(b); }
1054
1055// ------------------------- Intersection ------------------------------------
1056
1057inline lx_cinterval operator & (const lx_cinterval& a,
1058 const lx_cinterval& b) noexcept
1059{
1060 lx_cinterval tmp = a;
1061 SetInf(tmp.re, max(Inf(a.re),Inf(b.re)));
1062 SetInf(tmp.im, max(Inf(a.im),Inf(b.im)));
1063 SetSup(tmp.re, min(Sup(a.re),Sup(b.re)));
1064 SetSup(tmp.im, min(Sup(a.im),Sup(b.im)));
1065 if (Inf(tmp.re) > Sup(tmp.re) || Inf(tmp.im) > Sup(tmp.im))
1066 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1067 "lx_cinterval operator &(const lx_cinterval& a,const lx_cinterval& b)"));
1068 return tmp;
1069}
1070
1071inline lx_cinterval & operator &= (lx_cinterval& a, const lx_cinterval& b)
1072 { return a = a&b; }
1073
1074inline lx_cinterval operator & (const lx_cinterval& a, const lx_real& b)
1075 noexcept { return a & lx_cinterval(b,lx_real(0.0)); }
1076inline lx_cinterval operator & (const lx_real& a, const lx_cinterval& b )
1077 noexcept { return lx_cinterval(a,lx_real(0.0)) & b; }
1078inline lx_cinterval & operator &= (lx_cinterval& a, const lx_real& b)
1079 noexcept { return a = a & lx_cinterval(b); }
1080inline lx_cinterval operator & (const lx_cinterval& a, const l_real& b)
1081 noexcept { return a & lx_cinterval(b); }
1082inline lx_cinterval operator & (const l_real& a, const lx_cinterval& b )
1083 noexcept { return lx_cinterval(a) & b; }
1084inline lx_cinterval & operator &= (lx_cinterval& a, const l_real& b)
1085 noexcept { return a = a & lx_cinterval(b); }
1086inline lx_cinterval operator & (const lx_cinterval& a, const real& b)
1087 noexcept { return a & lx_cinterval(b); }
1088inline lx_cinterval operator & (const real& a, const lx_cinterval& b )
1089 noexcept { return lx_cinterval(a) & b; }
1090inline lx_cinterval & operator &= (lx_cinterval& a, const real& b)
1091 noexcept { return a = a & lx_cinterval(b); }
1092inline lx_cinterval operator & (const lx_cinterval& a, const l_cinterval& b)
1093 noexcept { return a & lx_cinterval(b); }
1094inline lx_cinterval operator & (const l_cinterval& a, const lx_cinterval& b)
1095 noexcept { return lx_cinterval(a) & b; }
1096inline lx_cinterval & operator &= (lx_cinterval& a, const l_cinterval& b)
1097 noexcept { return a = a & lx_cinterval(b); }
1098inline lx_cinterval operator & (const lx_cinterval& a, const cinterval& b)
1099 noexcept { return a & lx_cinterval(b); }
1100inline lx_cinterval operator & (const cinterval& a, const lx_cinterval& b)
1101 noexcept { return lx_cinterval(a) & b; }
1102inline lx_cinterval & operator &= (lx_cinterval& a, const cinterval& b)
1103 noexcept { return a = a & lx_cinterval(b); }
1104inline lx_cinterval operator & (const lx_cinterval& a, const lx_interval& b)
1105 noexcept { return a & lx_cinterval(b); }
1106inline lx_cinterval operator & (const lx_interval& a, const lx_cinterval& b)
1107 noexcept { return lx_cinterval(a) & b; }
1108inline lx_cinterval & operator &= (lx_cinterval& a, const lx_interval& b)
1109 noexcept { return a = a & lx_cinterval(b); }
1110inline lx_cinterval operator & (const lx_cinterval& a, const l_interval& b)
1111 noexcept { return a & lx_cinterval(b); }
1112inline lx_cinterval operator & (const l_interval& a, const lx_cinterval& b)
1113 noexcept { return lx_cinterval(a) & b; }
1114inline lx_cinterval & operator &= (lx_cinterval& a, const l_interval& b)
1115 noexcept { return a = a & lx_cinterval(b); }
1116inline lx_cinterval operator & (const lx_cinterval& a, const interval& b)
1117 noexcept { return a & lx_cinterval(b); }
1118inline lx_cinterval operator & (const interval& a, const lx_cinterval& b)
1119 noexcept { return lx_cinterval(a) & b; }
1120inline lx_cinterval & operator &= (lx_cinterval& a, const interval& b)
1121 noexcept { return a = a & lx_cinterval(b); }
1122inline lx_cinterval operator & (const lx_cinterval& a, const lx_complex& b)
1123 noexcept { return a & lx_cinterval(b); }
1124inline lx_cinterval operator & (const lx_complex& a, const lx_cinterval& b)
1125 noexcept { return lx_cinterval(a) & b; }
1126inline lx_cinterval & operator &= (lx_cinterval& a, const lx_complex& b)
1127 noexcept { return a = a & lx_cinterval(b); }
1128inline lx_cinterval operator & (const lx_cinterval& a, const l_complex& b)
1129 noexcept { return a & lx_cinterval(b); }
1130inline lx_cinterval operator & (const l_complex& a, const lx_cinterval& b)
1131 noexcept { return lx_cinterval(a) & b; }
1132inline lx_cinterval & operator &= (lx_cinterval& a, const l_complex& b)
1133 noexcept { return a = a & lx_cinterval(b); }
1134inline lx_cinterval operator & (const lx_cinterval& a, const complex& b)
1135 noexcept { return a & lx_cinterval(b); }
1136inline lx_cinterval operator & (const complex& a, const lx_cinterval& b)
1137 noexcept { return lx_cinterval(a) & b; }
1138inline lx_cinterval & operator &= (lx_cinterval& a, const complex& b)
1139 noexcept { return a = a & lx_cinterval(b); }
1140
1141inline lx_cinterval operator & (const lx_interval& a, const complex& b)
1142 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1143inline lx_cinterval operator & ( const complex& a, const lx_interval& b)
1144 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1145inline lx_cinterval operator & (const lx_interval& a, const l_complex& b)
1146 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1147inline lx_cinterval operator & ( const l_complex& a, const lx_interval& b)
1148 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1149inline lx_cinterval operator & (const lx_interval& a, const lx_complex& b)
1150 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1151inline lx_cinterval operator & ( const lx_complex& a, const lx_interval& b)
1152 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1153inline lx_cinterval operator & (const lx_real& a, const cinterval& b)
1154 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1155inline lx_cinterval operator & (const cinterval& a, const lx_real& b)
1156 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1157inline lx_cinterval operator & (const lx_real& a, const l_cinterval& b)
1158 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1159inline lx_cinterval operator & (const l_cinterval& a, const lx_real& b)
1160 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1161inline lx_cinterval operator & (const lx_interval& a, const cinterval& b)
1162 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1163inline lx_cinterval operator & (const cinterval& a, const lx_interval& b)
1164 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1165inline lx_cinterval operator & (const lx_interval& a, const l_cinterval& b)
1166 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1167inline lx_cinterval operator & (const l_cinterval& a, const lx_interval& b)
1168 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1169
1170inline lx_cinterval operator & (const l_interval& a, const lx_complex& b)
1171 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1172inline lx_cinterval operator & ( const lx_complex& a, const l_interval& b)
1173 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1174inline lx_cinterval operator & (const l_cinterval& a, const lx_complex& b)
1175 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1176inline lx_cinterval operator & ( const lx_complex& a, const l_cinterval& b)
1177 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1178
1179inline lx_cinterval operator & (const interval& a, const lx_complex& b)
1180 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1181inline lx_cinterval operator & ( const lx_complex& a, const interval& b)
1182 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1183inline lx_cinterval operator & (const cinterval& a, const lx_complex& b)
1184 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1185inline lx_cinterval operator & ( const lx_complex& a, const cinterval& b)
1186 noexcept { return lx_cinterval(a) & lx_cinterval(b); }
1187
1188
1189// -------------------------- Convex Hull ------------------------------------
1190
1191inline lx_cinterval operator | (const lx_cinterval& a,
1192 const lx_cinterval& b) noexcept
1193{
1194 lx_cinterval tmp = a;
1195 SetInf(tmp.re, min(Inf(a.re), Inf(b.re)));
1196 SetInf(tmp.im, min(Inf(a.im), Inf(b.im)));
1197 SetSup(tmp.re, max(Sup(a.re), Sup(b.re)));
1198 SetSup(tmp.im, max(Sup(a.im), Sup(b.im)));
1199 return tmp;
1200}
1201
1202inline lx_cinterval & operator |= (lx_cinterval& a, const lx_cinterval& b)
1203 noexcept { return a = a|b; }
1204inline lx_cinterval operator | (const lx_cinterval& a, const lx_real& b)
1205 noexcept { return a | lx_cinterval(b); }
1206inline lx_cinterval operator | (const lx_real& a, const lx_cinterval& b)
1207 noexcept { return lx_cinterval(a) | b; }
1208inline lx_cinterval & operator |= (lx_cinterval& a, const lx_real& b)
1209 noexcept { return a = a|lx_cinterval(b); }
1210inline lx_cinterval operator | (const lx_cinterval& a, const l_real& b)
1211 noexcept { return a | lx_cinterval(b); }
1212inline lx_cinterval operator | (const l_real& a, const lx_cinterval& b)
1213 noexcept { return lx_cinterval(a) | b; }
1214inline lx_cinterval & operator |= (lx_cinterval& a, const l_real& b)
1215 noexcept { return a = a|lx_cinterval(b); }
1216inline lx_cinterval operator | (const lx_cinterval& a, const real& b)
1217 noexcept { return a | lx_cinterval(b); }
1218inline lx_cinterval operator | (const real& a, const lx_cinterval& b)
1219 noexcept { return lx_cinterval(a) | b; }
1220inline lx_cinterval & operator |= (lx_cinterval& a, const real& b)
1221 noexcept { return a = a|lx_cinterval(b); }
1222inline lx_cinterval operator | (const lx_cinterval& a, const l_cinterval& b)
1223 noexcept { return a | lx_cinterval(b); }
1224inline lx_cinterval operator | (const l_cinterval& a, const lx_cinterval& b)
1225 noexcept { return lx_cinterval(a) | b; }
1226inline lx_cinterval & operator |= (lx_cinterval& a, const l_cinterval& b)
1227 noexcept { return a = a|lx_cinterval(b); }
1228inline lx_cinterval operator | (const lx_cinterval& a, const cinterval& b)
1229 noexcept { return a | lx_cinterval(b); }
1230inline lx_cinterval operator | (const cinterval& a, const lx_cinterval& b)
1231 noexcept { return lx_cinterval(a) | b; }
1232inline lx_cinterval & operator |= (lx_cinterval& a, const cinterval& b)
1233 noexcept { return a = a | lx_cinterval(b); }
1234inline lx_cinterval operator | (const lx_cinterval& a, const lx_interval& b)
1235 noexcept { return a | lx_cinterval(b); }
1236inline lx_cinterval operator | (const lx_interval& a, const lx_cinterval& b)
1237 noexcept { return lx_cinterval(a) | b; }
1238inline lx_cinterval & operator |= (lx_cinterval& a, const lx_interval& b)
1239 noexcept { return a = a | lx_cinterval(b); }
1240inline lx_cinterval operator | (const lx_cinterval& a, const l_interval& b)
1241 noexcept { return a | lx_cinterval(b); }
1242inline lx_cinterval operator | (const l_interval& a, const lx_cinterval& b)
1243 noexcept { return lx_cinterval(a) | b; }
1244inline lx_cinterval & operator |= (lx_cinterval& a, const l_interval& b)
1245 noexcept { return a = a | lx_cinterval(b); }
1246inline lx_cinterval operator | (const lx_cinterval& a, const interval& b)
1247 noexcept { return a | lx_cinterval(b); }
1248inline lx_cinterval operator | (const interval& a, const lx_cinterval& b)
1249 noexcept { return lx_cinterval(a) | b; }
1250inline lx_cinterval & operator |= (lx_cinterval& a, const interval& b)
1251 noexcept { return a = a | lx_cinterval(b); }
1252inline lx_cinterval operator | (const lx_cinterval& a, const lx_complex& b)
1253 noexcept { return a | lx_cinterval(b); }
1254inline lx_cinterval operator | (const lx_complex& a, const lx_cinterval& b)
1255 noexcept { return lx_cinterval(a) | b; }
1256inline lx_cinterval & operator |= (lx_cinterval& a, const lx_complex& b)
1257 noexcept { return a = a | lx_cinterval(b); }
1258inline lx_cinterval operator | (const lx_cinterval& a, const l_complex& b)
1259 noexcept { return a | lx_cinterval(b); }
1260inline lx_cinterval operator | (const l_complex& a, const lx_cinterval& b)
1261 noexcept { return lx_cinterval(a) | b; }
1262inline lx_cinterval & operator |= (lx_cinterval& a, const l_complex& b)
1263 noexcept { return a = a | lx_cinterval(b); }
1264inline lx_cinterval operator | (const lx_cinterval& a, const complex& b)
1265 noexcept { return a | lx_cinterval(b); }
1266inline lx_cinterval operator | (const complex& a, const lx_cinterval& b)
1267 noexcept { return lx_cinterval(a) | b; }
1268inline lx_cinterval & operator |= (lx_cinterval& a, const complex& b)
1269 noexcept { return a = a | lx_cinterval(b); }
1270
1271inline lx_cinterval operator | (const lx_interval& a, const complex& b)
1272 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1273inline lx_cinterval operator | ( const complex& a, const lx_interval& b)
1274 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1275inline lx_cinterval operator | (const lx_interval& a, const l_complex& b)
1276 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1277inline lx_cinterval operator | ( const l_complex& a, const lx_interval& b)
1278 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1279inline lx_cinterval operator | (const lx_interval& a, const lx_complex& b)
1280 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1281inline lx_cinterval operator | ( const lx_complex& a, const lx_interval& b)
1282 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1283inline lx_cinterval operator | (const lx_real& a, const cinterval& b)
1284 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1285inline lx_cinterval operator | (const cinterval& a, const lx_real& b)
1286 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1287inline lx_cinterval operator | (const lx_real& a, const l_cinterval& b)
1288 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1289inline lx_cinterval operator | (const l_cinterval& a, const lx_real& b)
1290 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1291inline lx_cinterval operator | (const lx_interval& a, const cinterval& b)
1292 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1293inline lx_cinterval operator | (const cinterval& a, const lx_interval& b)
1294 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1295inline lx_cinterval operator | (const lx_interval& a, const l_cinterval& b)
1296 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1297inline lx_cinterval operator | (const l_cinterval& a, const lx_interval& b)
1298 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1299
1300
1301inline lx_cinterval operator | (const lx_real& a, const complex& b)
1302 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1303inline lx_cinterval operator | (const complex& a, const lx_real& b)
1304 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1305inline lx_cinterval operator | (const lx_real& a, const l_complex& b)
1306 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1307inline lx_cinterval operator | (const l_complex& a, const lx_real& b)
1308 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1309inline lx_cinterval operator | (const lx_real& a, const lx_complex& b)
1310 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1311inline lx_cinterval operator | (const lx_complex& a, const lx_real& b)
1312 noexcept { return lx_cinterval(a) | lx_cinterval(b); }
1313
1314
1315// ------------------------- Others --------------------------------------
1316
1317inline lx_cinterval & SetInf(lx_cinterval& a, const lx_complex& b)
1318
1319{
1320 Inf(a.re) = Re(b);
1321 Inf(a.im) = Im(b);
1322
1323 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1324 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("lx_cinterval & SetInf(lx_cinterval& a, const lx_complex& b)"));
1325
1326 return a;
1327}
1328
1329inline lx_cinterval & SetInf(lx_cinterval& a, const l_complex& b)
1330
1331{
1332 Inf(a.re) = Re(b);
1333 Inf(a.im) = Im(b);
1334
1335 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1336 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("lx_cinterval & SetInf(lx_cinterval& a, const l_complex& b)"));
1337
1338 return a;
1339}
1340
1341inline lx_cinterval & SetInf(lx_cinterval& a, const complex& b)
1342
1343{
1344 Inf(a.re) = Re(b);
1345 Inf(a.im) = Im(b);
1346
1347 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1348 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("lx_cinterval & SetInf(lx_cinterval& a, const complex& b)"));
1349
1350 return a;
1351}
1352
1353inline lx_cinterval & SetInf(lx_cinterval& a, const lx_real & b)
1354
1355{
1356 Inf(a.re)=b;
1357 Inf(a.im)=0.0;
1358
1359 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1360 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline lx_cinterval & SetInf(lx_cinterval& a,const lx_real & b)"));
1361
1362 return a;
1363}
1364
1365inline lx_cinterval & SetInf(lx_cinterval& a, const l_real & b)
1366
1367{
1368 Inf(a.re)=b;
1369 Inf(a.im)=0.0;
1370
1371 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1372 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1373 "inline lx_cinterval & SetInf(lx_cinterval& a,const l_real & b)"));
1374
1375 return a;
1376}
1377
1378inline lx_cinterval & SetInf(lx_cinterval& a, const real & b)
1379
1380{
1381 Inf(a.re)=b;
1382 Inf(a.im)=0.0;
1383
1384 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1385 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1386 "inline lx_cinterval & SetInf(lx_cinterval& a,const real & b)"));
1387
1388 return a;
1389}
1390
1391inline lx_cinterval & SetSup(lx_cinterval& a, const lx_complex& b)
1392
1393{
1394 Sup(a.re) = Re(b);
1395 Sup(a.im) = Im(b);
1396
1397 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1398 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1399 "inline lx_cinterval & SetSup(lx_cinterval& a, const lx_complex& b)"));
1400
1401 return a;
1402}
1403
1404
1405inline lx_cinterval & SetSup(lx_cinterval& a, const l_complex& b)
1406
1407{
1408 Sup(a.re) = Re(b);
1409 Sup(a.im) = Im(b);
1410
1411 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1412 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1413 "inline lx_cinterval & SetSup(lx_cinterval& a, const l_complex& b)"));
1414
1415 return a;
1416}
1417
1418inline lx_cinterval & SetSup(lx_cinterval& a, const complex& b)
1419
1420{
1421 Sup(a.re) = Re(b);
1422 Sup(a.im) = Im(b);
1423
1424 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1425 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1426 "inline lx_cinterval & SetSup(lx_cinterval& a, const complex& b)"));
1427
1428 return a;
1429}
1430
1431inline lx_cinterval & SetSup(lx_cinterval& a, const lx_real & b)
1432
1433{
1434 Sup(a.re) = b;
1435 Sup(a.im) = 0.0;
1436
1437 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1438 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1439 "inline lx_cinterval & SetSup(lx_cinterval& a, const lx_real& b)"));
1440
1441 return a;
1442}
1443
1444inline lx_cinterval & SetSup(lx_cinterval& a, const l_real & b)
1445
1446{
1447 Sup(a.re) = b;
1448 Sup(a.im) = 0.0;
1449
1450 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1451 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1452 "inline lx_cinterval & SetSup(lx_cinterval& a, const l_real& b)"));
1453
1454 return a;
1455}
1456
1457inline lx_cinterval & SetSup(lx_cinterval& a, const real & b)
1458
1459{
1460 Sup(a.re) = b;
1461 Sup(a.im) = 0.0;
1462
1463 if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1464 cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL(
1465 "inline lx_cinterval & SetSup(lx_cinterval& a, const real& b)"));
1466
1467 return a;
1468}
1469
1470inline bool IsEmpty(const lx_cinterval& a) noexcept
1471{ return (IsEmpty(a.re) || IsEmpty(a.im)); }
1472
1473
1474// -----------------------------------------------------------------------
1475// ----------------------- Output ----------------------------------------
1476// -----------------------------------------------------------------------
1477
1478inline std::ostream& operator << (std::ostream& s,const lx_cinterval& a)
1479 noexcept
1480// A value a of type lx_cinterval is written to the output channel.
1481{
1482 s << '('
1483 << a.re << ", "
1484 << a.im
1485 << ')';
1486 return s;
1487}
1488
1489inline std::string & operator << (std::string &s,const lx_cinterval& a)
1490 noexcept
1491// The value of a variable a of type lx_cinterval is copied to a string s.
1492// s has the form: {ex,li}
1493{
1494 string str;
1495 s+='(';
1496 s << a.re;
1497 s+=',';
1498 s << a.im;
1499 s+=')';
1500 return s;
1501}
1502
1503} // end namespace cxsc
The Scalar Type cinterval.
Definition cinterval.hpp:55
The Scalar Type complex.
Definition complex.hpp:50
The Scalar Type interval.
Definition interval.hpp:55
The Multiple-Precision Data Type l_cinterval.
The Multiple-Precision Data Type l_complex.
Definition l_complex.hpp:46
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
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
real expo_Re(const lx_cinterval &a) noexcept
Returns the exponent n of the real part of the complex interval.
real expo_Im(const lx_cinterval &a) noexcept
Returns the exponent n of the imaginary part of the complex interval.
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
cinterval sqr(const cinterval &z) noexcept
Calculates .
Definition cimath.cpp:3342
l_interval li_part_Re(const lx_cinterval &) noexcept
Returns the l_interval of the real part of the complex interval.
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
interval sqrtx2y2(const interval &x, const interval &y) noexcept
Calculates .
Definition imath.cpp:80
l_interval li_part_Im(const lx_cinterval &) noexcept
Returns the l_interval of the imaginary part of the complex interval.