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