C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
l_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: l_cinterval.inl,v 1.14 2014/01/30 17:23:46 cxsc Exp $ */
25 
26 namespace cxsc {
27 
28 
29 // Inlined functions for l_cinterval.
30 
31 // ---- implicit constructors ------------------------------
32 
33 inline l_cinterval::l_cinterval(const interval & a,const interval & b) noexcept
34  : re(a), im(b)
35 {
36 }
37 
39  const l_interval & b) noexcept
40  : re(a), im(b)
41 {
42 }
43 
44 inline l_cinterval::l_cinterval(const complex & a, const complex & b)
45 
46  : re(Re(a),Re(b)),
47  im(Im(a),Im(b))
48 {
49  if(Inf(re)>Sup(re) || Inf(im)>Sup(im))
50  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("l_cinterval::l_cinterval(const complex & a,const complex & b)"));
51 }
52 
53 inline l_cinterval::l_cinterval(const l_complex & a, const l_complex & b)
54 
55  : re(Re(a),Re(b)),
56  im(Im(a),Im(b))
57 {
58  if(Inf(re)>Sup(re) || Inf(im)>Sup(im))
59  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("l_cinterval::l_cinterval(const complex & a,const complex & b)"));
60 }
61 
62 // ---- explicit constructors ------------------------------
63 
64 inline l_cinterval::l_cinterval(const real & a) noexcept : re(a,a), im(0,0) {}
65 inline l_cinterval::l_cinterval(const l_real & a) noexcept : re(a,a), im(0,0) {}
66 
67 
69  noexcept : re(a), im(0,0) {}
71  noexcept : re(a), im(0,0) {}
73  noexcept : re(Re(a),Re(a)),im(Im(a),Im(a)) {}
75  noexcept : re(Re(a),Re(a)),im(Im(a),Im(a)) {}
77  noexcept : re(Inf(Re(a)),Sup(Re(a))),im(Inf(Im(a)),Sup(Im(a))) {}
78 
79 
80 // ---- assignments -----------------------------------------
81 
82 inline l_cinterval & l_cinterval::operator =(const real & a) noexcept
83 {
84  re=a,im=0.0;
85  return *this;
86 }
87 
88 inline l_cinterval & l_cinterval::operator =(const l_real & a) noexcept
89 {
90  re=a,im=0.0;
91  return *this;
92 }
93 
94 
95 inline l_cinterval & l_cinterval::operator =(const interval & a) noexcept
96 {
97  re=a,im=0.0;
98  return *this;
99 }
100 
101 inline l_cinterval & l_cinterval::operator =(const l_interval & a) noexcept
102 {
103  re=a,im=0.0;
104  return *this;
105 }
106 
107 inline l_cinterval & l_cinterval::operator =(const complex & a) noexcept
108 {
109  re=Re(a),im=Im(a);
110  return *this;
111 }
112 
113 inline l_cinterval & l_cinterval::operator =(const l_complex & a) noexcept
114 {
115  re=Re(a),im=Im(a);
116  return *this;
117 }
118 
119 inline l_cinterval & l_cinterval::operator =(const cinterval & a) noexcept
120 {
121  re = Re(a);
122  im = Im(a);
123  return *this;
124 }
125 
126 inline l_cinterval & l_cinterval::operator =(const l_cinterval & a) noexcept
127 {
128  re = a.re;
129  im = a.im;
130  return *this;
131 }
132 
134 {
135  return *this = l_cinterval(a);
136 }
137 
139 {
140  return *this = l_cinterval(a);
141 }
142 
144 {
145  return *this = l_cinterval(a);
146 }
147 
149 {
150  return *this = l_cinterval(a);
151 }
152 
153 
154 // ---- Std.Operators ---------------------------------------
155 
156 inline l_cinterval operator -(const l_cinterval & a) noexcept
157 {
158  return l_cinterval(-a.re,-a.im);
159 }
160 
161 inline l_cinterval operator +(const l_cinterval & a) noexcept
162 {
163  return a;
164 }
165 
166 inline bool operator! (const l_cinterval & a) noexcept
167 {
168  return !a.re && !a.im;
169 }
170 
171 inline l_cinterval operator +(const l_cinterval & a,
172  const l_cinterval & b) noexcept
173 {
174  return l_cinterval(a.re + b.re, a.im + b.im);
175 }
176 
177 inline l_cinterval operator -(const l_cinterval & a,
178  const l_cinterval & b) noexcept
179 {
180  return l_cinterval(a.re - b.re, a.im - b.im);
181 }
182 
183 inline l_cinterval operator &(const l_cinterval & a, const l_cinterval & b)
184 
185 {
186  l_cinterval tmp = a;
187  l_real x,y;
188  y = Inf(a.re); x = Inf(b.re);
189  if (x>y) y = x; // y = max(Inf(a.re), Inf(b.re))
190  SetInf(tmp.re, y);
191  y = Inf(a.im); x = Inf(b.im);
192  if (x>y) y = x; // y = max(Inf(a.im), Inf(b.im))
193  SetInf(tmp.im, y);
194  y = Sup(a.re); x = Sup(b.re);
195  if (x<y) y = x; // y = min(Sup(a.re), Sup(b.re))
196  SetSup(tmp.re, y);
197  y = Sup(a.im); x = Sup(b.im);
198  if (x<y) y = x; // y = min(Sup(a.im), Sup(b.im))
199  SetSup(tmp.im, y);
200  if (Inf(tmp.re) > Sup(tmp.re) || Inf(tmp.im) > Sup(tmp.im))
201  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval operator &(const l_cinterval & a,const l_cinterval & b)"));
202  return tmp;
203 }
204 
205 inline l_cinterval operator |(const l_cinterval & a, const l_cinterval & b)
206  noexcept
207 {
208  l_cinterval tmp = a;
209  l_real x,y;
210  y = Inf(a.re); x = Inf(b.re);
211  if (x<y) y = x; // y = min(Inf(a.re), Inf(b.re))
212  SetInf(tmp.re, y);
213  y = Inf(a.im); x = Inf(b.im);
214  if (x<y) y = x; // y = min(Inf(a.im), Inf(b.im))
215  SetInf(tmp.im, y);
216  y = Sup(a.re); x = Sup(b.re);
217  if (x>y) y = x; // y = max(Sup(a.re), Sup(b.re))
218  SetSup(tmp.re, y);
219  y = Sup(a.im); x = Sup(b.im);
220  if (x>y) y = x; // y = max(Sup(a.im), Sup(b.im))
221  SetSup(tmp.im, y);
222  return tmp;
223 }
224 
226  noexcept { return a = a+b; }
227 inline l_cinterval & operator -=(l_cinterval & a, const l_cinterval & b)
228  noexcept { return a = a-b; }
230  noexcept { return a = a*b; }
232  noexcept { return a = a/b; }
233 inline l_cinterval & operator |=(l_cinterval & a, const l_cinterval & b)
234  noexcept { return a = a|b; }
235 inline l_cinterval & operator &=(l_cinterval & a, const l_cinterval & b)
236  { return a = a&b; }
237 
238 // LCI <--> R
239 
240 inline l_cinterval operator +(const l_cinterval & a, const real & b) noexcept
241  { return a + l_cinterval(b); }
242 inline l_cinterval operator +(const real & a, const l_cinterval & b) noexcept
243  { return l_cinterval(a) + b; }
244 inline l_cinterval operator -(const l_cinterval & a, const real & b) noexcept
245  { return a - l_cinterval(b); }
246 inline l_cinterval operator -(const real & a, const l_cinterval & b) noexcept
247  { return l_cinterval(a) - b; }
248 inline l_cinterval operator *(const l_cinterval & a, const real & b) noexcept
249  { return l_cinterval(a.re*b, a.im*b); }
250 inline l_cinterval operator *(const real & a, const l_cinterval & b) noexcept
251  { return l_cinterval(b.re*a, b.im*a); }
252 inline l_cinterval operator /(const l_cinterval & a, const real & b) noexcept
253  { return l_cinterval(a.re/b, a.im/b); }
254 inline l_cinterval operator /(const real & a, const l_cinterval & b) noexcept
255  { return l_cinterval(a) / b; }
256 inline l_cinterval operator |(const l_cinterval & a, const real & b) noexcept
257  { return a|l_cinterval(b); }
258 inline l_cinterval operator |(const real & a, const l_cinterval & b) noexcept
259  { return l_cinterval(a)|b; }
260 inline l_cinterval operator &(const l_cinterval & a, const real & b) noexcept
261  { return a & l_cinterval(b); }
262 inline l_cinterval operator &(const real & a, const l_cinterval & b) noexcept
263  { return l_cinterval(a) & b; }
264 
265 inline l_cinterval & operator +=(l_cinterval & a, const real & b) noexcept
266  { return a = a+l_cinterval(b); }
267 inline l_cinterval & operator -=(l_cinterval & a, const real & b) noexcept
268  { return a = a -l_cinterval(b); }
269 inline l_cinterval & operator *=(l_cinterval & a, const real & b) noexcept
270  { return a = a * b; }
271 inline l_cinterval & operator /=(l_cinterval & a, const real & b) noexcept
272  { return a = a / b; }
273 inline l_cinterval & operator |=(l_cinterval & a, const real & b) noexcept
274  { return a = a|l_cinterval(b); }
275 inline l_cinterval & operator &=(l_cinterval & a, const real & b) noexcept
276  { return a = a&l_cinterval(b); }
277 
278 // LCI <--> LR
279 
280 inline l_cinterval operator +(const l_cinterval & a, const l_real & b) noexcept
281  { return a + l_cinterval(b); }
282 inline l_cinterval operator +(const l_real & a, const l_cinterval & b) noexcept
283  { return l_cinterval(a) + b; }
284 inline l_cinterval operator -(const l_cinterval & a, const l_real & b) noexcept
285  { return a - l_cinterval(b); }
286 inline l_cinterval operator -(const l_real & a, const l_cinterval & b) noexcept
287  { return l_cinterval(a) - b; }
288 inline l_cinterval operator *(const l_cinterval & a, const l_real & b) noexcept
289  { return l_cinterval(a.re*b, a.im*b); }
290 inline l_cinterval operator *(const l_real & a, const l_cinterval & b) noexcept
291  { return l_cinterval(b.re*a, b.im*a); }
292 inline l_cinterval operator /(const l_cinterval & a, const l_real & b) noexcept
293  { return l_cinterval(a.re/b, a.im/b); }
294 inline l_cinterval operator /(const l_real & a, const l_cinterval & b) noexcept
295  { return l_cinterval(a) / b; }
296 inline l_cinterval operator |(const l_cinterval & a, const l_real & b) noexcept
297  { return a|l_cinterval(b); }
298 inline l_cinterval operator |(const l_real & a, const l_cinterval & b) noexcept
299  { return l_cinterval(a)|b; }
300 inline l_cinterval operator &(const l_cinterval & a, const l_real & b) noexcept
301  { return a & l_cinterval(b); }
302 inline l_cinterval operator &(const l_real & a, const l_cinterval & b) noexcept
303  { return l_cinterval(a) & b; }
304 
305 inline l_cinterval & operator +=(l_cinterval & a, const l_real & b) noexcept
306  { return a = a+l_cinterval(b); }
307 inline l_cinterval & operator -=(l_cinterval & a, const l_real & b) noexcept
308  { return a = a -l_cinterval(b); }
309 inline l_cinterval & operator *=(l_cinterval & a, const l_real & b) noexcept
310  { return a = a * b; }
311 inline l_cinterval & operator /=(l_cinterval & a, const l_real & b) noexcept
312  { return a = a / b; }
313 inline l_cinterval & operator |=(l_cinterval & a, const l_real & b) noexcept
314  { return a = a|l_cinterval(b); }
315 inline l_cinterval & operator &=(l_cinterval & a, const l_real & b) noexcept
316  { return a = a&l_cinterval(b); }
317 
318 
319 
320 // LCI <--> C
321 
322 inline l_cinterval operator +(const l_cinterval & a, const complex & b)
323  noexcept { return a + l_cinterval(b); }
324 inline l_cinterval operator +(const complex & a, const l_cinterval & b)
325  noexcept { return l_cinterval(a) + b; }
326 inline l_cinterval operator -(const l_cinterval & a, const complex & b)
327  noexcept { return a - l_cinterval(b); }
328 inline l_cinterval operator -(const complex & a, const l_cinterval & b)
329  noexcept { return l_cinterval(a) - b; }
330 inline l_cinterval operator *(const l_cinterval & a, const complex & b)
331  noexcept { return a * l_cinterval(b); }
332 inline l_cinterval operator *(const complex & a, const l_cinterval & b)
333  noexcept { return l_cinterval(a) * b; }
334 inline l_cinterval operator /(const l_cinterval & a, const complex & b)
335  noexcept { return a / l_cinterval(b); }
336 inline l_cinterval operator /(const complex & a, const l_cinterval & b)
337  noexcept { return l_cinterval(a) / b; }
338 inline l_cinterval operator |(const l_cinterval & a, const complex & b)
339  noexcept { return a | l_cinterval(b); }
340 inline l_cinterval operator |(const complex & a, const l_cinterval & b)
341  noexcept { return l_cinterval(a) | b; }
342 inline l_cinterval operator &(const l_cinterval & a, const complex & b)
343  noexcept { return a & l_cinterval(b); }
344 inline l_cinterval operator &(const complex & a, const l_cinterval & b)
345  noexcept { return l_cinterval(a) & b; }
346 
347 inline l_cinterval & operator +=(l_cinterval & a, const complex & b) noexcept
348  { return a = a + l_cinterval(b); }
349 inline l_cinterval & operator -=(l_cinterval & a, const complex & b) noexcept
350  { return a = a - l_cinterval(b); }
351 inline l_cinterval & operator *=(l_cinterval & a, const complex & b) noexcept
352  { return a = a * l_cinterval(b); }
353 inline l_cinterval & operator /=(l_cinterval & a, const complex & b) noexcept
354  { return a = a / l_cinterval(b); }
355 inline l_cinterval & operator |=(l_cinterval & a, const complex & b) noexcept
356  { return a = a | l_cinterval(b); }
357 inline l_cinterval & operator &=(l_cinterval & a, const complex & b) noexcept
358  { return a = a & l_cinterval(b); }
359 
360 
361 // LCI <--> LC
362 
363 inline l_cinterval operator +(const l_cinterval & a, const l_complex & b)
364  noexcept { return a + l_cinterval(b); }
365 inline l_cinterval operator +(const l_complex & a, const l_cinterval & b)
366  noexcept { return l_cinterval(a) + b; }
367 inline l_cinterval operator -(const l_cinterval & a, const l_complex & b)
368  noexcept { return a - l_cinterval(b); }
369 inline l_cinterval operator -(const l_complex & a, const l_cinterval & b)
370  noexcept { return l_cinterval(a) - b; }
371 inline l_cinterval operator *(const l_cinterval & a, const l_complex & b)
372  noexcept { return a * l_cinterval(b); }
373 inline l_cinterval operator *(const l_complex & a, const l_cinterval & b)
374  noexcept { return l_cinterval(a) * b; }
375 inline l_cinterval operator /(const l_cinterval & a, const l_complex & b)
376  noexcept { return a / l_cinterval(b); }
377 inline l_cinterval operator /(const l_complex & a, const l_cinterval & b)
378  noexcept { return l_cinterval(a) / b; }
379 inline l_cinterval operator |(const l_cinterval & a, const l_complex & b)
380  noexcept { return a | l_cinterval(b); }
381 inline l_cinterval operator |(const l_complex & a, const l_cinterval & b)
382  noexcept { return l_cinterval(a) | b; }
383 inline l_cinterval operator &(const l_cinterval & a, const l_complex & b)
384  noexcept { return a & l_cinterval(b); }
385 inline l_cinterval operator &(const l_complex & a, const l_cinterval & b)
386  noexcept { return l_cinterval(a) & b; }
387 
388 inline l_cinterval & operator +=(l_cinterval & a, const l_complex & b) noexcept
389  { return a = a + l_cinterval(b); }
390 inline l_cinterval & operator -=(l_cinterval & a, const l_complex & b) noexcept
391  { return a = a - l_cinterval(b); }
392 inline l_cinterval & operator *=(l_cinterval & a, const l_complex & b) noexcept
393  { return a = a * l_cinterval(b); }
394 inline l_cinterval & operator /=(l_cinterval & a, const l_complex & b) noexcept
395  { return a = a / l_cinterval(b); }
396 inline l_cinterval & operator |=(l_cinterval & a, const l_complex & b) noexcept
397  { return a = a | l_cinterval(b); }
398 inline l_cinterval & operator &=(l_cinterval & a, const l_complex & b) noexcept
399  { return a = a & l_cinterval(b); }
400 
401 
402 
403 // LCI <--> I
404 
405 inline l_cinterval operator +(const l_cinterval & a,
406  const interval & b) noexcept
407  { return a + l_cinterval(b); }
408 inline l_cinterval operator +(const interval & a,
409  const l_cinterval & b) noexcept
410  { return l_cinterval(a) + b; }
411 inline l_cinterval operator -(const l_cinterval & a,
412  const interval & b) noexcept
413  { return a - l_cinterval(b); }
414 inline l_cinterval operator -(const interval & a,
415  const l_cinterval & b) noexcept
416  { return l_cinterval(a) - b; }
418  const interval & b) noexcept
419  { return l_cinterval(a.re*b, a.im*b); }
420 inline l_cinterval operator *(const interval & a,
421  const l_cinterval & b) noexcept
422  { return l_cinterval(b.re*a, b.im*a); }
424  const interval & b) noexcept
425  { return l_cinterval(a.re/b, a.im/b); }
426 inline l_cinterval operator /(const interval & a,
427  const l_cinterval & b) noexcept
428  { return l_cinterval(a) / b; }
429 inline l_cinterval operator |(const l_cinterval & a,
430  const interval & b) noexcept
431  { return a | l_cinterval(b); }
432 inline l_cinterval operator |(const interval & a,
433  const l_cinterval & b) noexcept
434  { return l_cinterval(a) | b; }
435 inline l_cinterval operator &(const l_cinterval & a,
436  const interval & b) noexcept
437  { return a & l_cinterval(b); }
438 inline l_cinterval operator &(const interval & a,
439  const l_cinterval & b) noexcept
440  { return l_cinterval(a) & b; }
441 
442 inline l_cinterval & operator +=(l_cinterval & a, const interval & b)
443  noexcept { return a = a + l_cinterval(b); }
444 inline l_cinterval & operator -=(l_cinterval & a, const interval & b)
445  noexcept { return a = a - l_cinterval(b); }
446 inline l_cinterval & operator *=(l_cinterval & a, const interval & b)
447  noexcept { return a = a * l_cinterval(b); }
448 inline l_cinterval & operator /=(l_cinterval & a, const interval & b)
449  noexcept { return a = a / l_cinterval(b); }
450 inline l_cinterval & operator |=(l_cinterval & a, const interval & b)
451  noexcept { return a = a | l_cinterval(b); }
452 inline l_cinterval & operator &=(l_cinterval & a, const interval & b)
453  noexcept { return a = a & l_cinterval(b); }
454 
455 // LCI <--> LI
456 
457 inline l_cinterval operator +(const l_cinterval & a,
458  const l_interval & b) noexcept
459  { return a + l_cinterval(b); }
460 inline l_cinterval operator +(const l_interval & a,
461  const l_cinterval & b) noexcept
462  { return l_cinterval(a) + b; }
463 inline l_cinterval operator -(const l_cinterval & a,
464  const l_interval & b) noexcept
465  { return a - l_cinterval(b); }
466 inline l_cinterval operator -(const l_interval & a,
467  const l_cinterval & b) noexcept
468  { return l_cinterval(a) - b; }
470  const l_interval & b) noexcept
471  { return l_cinterval(a.re*b, a.im*b); }
473  const l_cinterval & b) noexcept
474  { return l_cinterval(b.re*a, b.im*a); }
476  const l_interval & b) noexcept
477  { return l_cinterval(a.re/b, a.im/b); }
479  const l_cinterval & b) noexcept
480  { return l_cinterval(a) / b; }
481 inline l_cinterval operator |(const l_cinterval & a,
482  const l_interval & b) noexcept
483  { return a | l_cinterval(b); }
484 inline l_cinterval operator |(const l_interval & a,
485  const l_cinterval & b) noexcept
486  { return l_cinterval(a) | b; }
487 inline l_cinterval operator &(const l_cinterval & a,
488  const l_interval & b) noexcept
489  { return a & l_cinterval(b); }
490 inline l_cinterval operator &(const l_interval & a,
491  const l_cinterval & b) noexcept
492  { return l_cinterval(a) & b; }
493 
495  noexcept { return a = a + l_cinterval(b); }
496 inline l_cinterval & operator -=(l_cinterval & a, const l_interval & b)
497  noexcept { return a = a - l_cinterval(b); }
499  noexcept { return a = a * l_cinterval(b); }
501  noexcept { return a = a / l_cinterval(b); }
502 inline l_cinterval & operator |=(l_cinterval & a, const l_interval & b)
503  noexcept { return a = a | l_cinterval(b); }
504 inline l_cinterval & operator &=(l_cinterval & a, const l_interval & b)
505  noexcept { return a = a & l_cinterval(b); }
506 
507 // LCI <--> CI
508 
509 inline l_cinterval operator +(const l_cinterval & a,
510  const cinterval & b) noexcept
511  { return a + l_cinterval(b); }
512 inline l_cinterval operator +(const cinterval & a,
513  const l_cinterval & b) noexcept
514  { return l_cinterval(a) + b; }
515 inline l_cinterval operator -(const l_cinterval & a,
516  const cinterval & b) noexcept
517  { return a - l_cinterval(b); }
518 inline l_cinterval operator -(const cinterval & a,
519  const l_cinterval & b) noexcept
520  { return l_cinterval(a) - b; }
522  const cinterval & b) noexcept
523  { return a * l_cinterval(b); }
525  const l_cinterval & b) noexcept
526  { return l_cinterval(a) * b; }
528  const cinterval & b) noexcept
529  { return a / l_cinterval(b); }
531  const l_cinterval & b) noexcept
532  { return l_cinterval(a) / b; }
533 inline l_cinterval operator |(const l_cinterval & a,
534  const cinterval & b) noexcept
535  { return a | l_cinterval(b); }
536 inline l_cinterval operator |(const cinterval & a,
537  const l_cinterval & b) noexcept
538  { return l_cinterval(a) | b; }
539 inline l_cinterval operator &(const l_cinterval & a,
540  const cinterval & b) noexcept
541  { return a & l_cinterval(b); }
542 inline l_cinterval operator &(const cinterval & a,
543  const l_cinterval & b) noexcept
544  { return l_cinterval(a) & b; }
545 
546 inline l_cinterval & operator +=(l_cinterval & a, const cinterval & b)
547  noexcept { return a = a + l_cinterval(b); }
548 inline l_cinterval & operator -=(l_cinterval & a, const cinterval & b)
549  noexcept { return a = a - l_cinterval(b); }
550 inline l_cinterval & operator *=(l_cinterval & a, const cinterval & b)
551  noexcept { return a = a * l_cinterval(b); }
552 inline l_cinterval & operator /=(l_cinterval & a, const cinterval & b)
553  noexcept { return a = a / l_cinterval(b); }
554 inline l_cinterval & operator |=(l_cinterval & a, const cinterval & b)
555  noexcept { return a = a | l_cinterval(b); }
556 inline l_cinterval & operator &=(l_cinterval & a, const cinterval & b)
557  noexcept { return a = a & l_cinterval(b); }
558 
559 // C-R
560 
561 inline l_cinterval operator |(const l_complex & a, const real & b) noexcept
562  { return l_cinterval(a) | l_cinterval(b); }
563 inline l_cinterval operator |(const real & a, const l_complex & b) noexcept
564  { return l_cinterval(a) | l_cinterval(b); }
565 inline l_cinterval operator |(const complex & a, const l_real & b) noexcept
566  { return l_cinterval(a) | l_cinterval(b); }
567 inline l_cinterval operator |(const l_real & a, const complex & b) noexcept
568  { return l_cinterval(a) | l_cinterval(b); }
569 inline l_cinterval operator |(const l_complex & a, const l_real & b) noexcept
570  { return l_cinterval(a) | l_cinterval(b); }
571 inline l_cinterval operator |(const l_real & a, const l_complex & b) noexcept
572  { return l_cinterval(a) | l_cinterval(b); }
573 inline l_cinterval operator |(const cinterval & a, const l_real & b) noexcept
574  { return l_cinterval(a) | l_cinterval(b); }
575 inline l_cinterval operator |(const l_real & a, const cinterval & b) noexcept
576  { return l_cinterval(a) | l_cinterval(b); }
577 inline l_cinterval operator |(const cinterval & a, const l_complex & b)
578  noexcept { return l_cinterval(a) | l_cinterval(b); }
579 inline l_cinterval operator |(const l_complex & a, const cinterval & b)
580  noexcept { return l_cinterval(a) | l_cinterval(b); }
581 
582 // LC <--> I
583 
584 inline l_cinterval operator +(const l_complex & a, const interval & b) noexcept
585  { return l_cinterval(a) + l_cinterval(b); }
586 inline l_cinterval operator +(const interval & a, const l_complex & b) noexcept
587  { return l_cinterval(a) + l_cinterval(b); }
588 inline l_cinterval operator -(const l_complex & a, const interval & b) noexcept
589  { return l_cinterval(a) - l_cinterval(b); }
590 inline l_cinterval operator -(const interval & a, const l_complex & b) noexcept
591  { return l_cinterval(a) - l_cinterval(b); }
592 inline l_cinterval operator *(const l_complex & a, const interval & b) noexcept
593  { return l_cinterval(a) * b; }
594 inline l_cinterval operator *(const interval & a, const l_complex & b) noexcept
595  { return l_cinterval(b) * a; }
596 inline l_cinterval operator /(const l_complex & a, const interval & b) noexcept
597  { return l_cinterval(a) / b; }
598 inline l_cinterval operator /(const interval & a, const l_complex & b) noexcept
599  { return l_cinterval(a) / l_cinterval(b); }
600 inline l_cinterval operator |(const l_complex & a, const interval & b) noexcept
601  { return l_cinterval(a) | l_cinterval(b); }
602 inline l_cinterval operator |(const interval & a, const l_complex & b) noexcept
603  { return l_cinterval(a) | l_cinterval(b); }
604 inline l_cinterval operator &(const l_complex & a, const interval & b) noexcept
605  { return l_cinterval(a) & l_cinterval(b); }
606 inline l_cinterval operator &(const interval & a, const l_complex & b) noexcept
607  { return l_cinterval(a) & l_cinterval(b); }
608 
609 // C <--> LI
610 
611 inline l_cinterval operator +(const complex & a, const l_interval & b) noexcept
612  { return l_cinterval(a) + l_cinterval(b); }
613 inline l_cinterval operator +(const l_interval & a, const complex & b) noexcept
614  { return l_cinterval(a) + l_cinterval(b); }
615 inline l_cinterval operator -(const complex & a, const l_interval & b) noexcept
616  { return l_cinterval(a) - l_cinterval(b); }
617 inline l_cinterval operator -(const l_interval & a, const complex & b) noexcept
618  { return l_cinterval(a) - l_cinterval(b); }
619 inline l_cinterval operator *(const complex & a, const l_interval & b) noexcept
620  { return l_cinterval(a) * b; }
621 inline l_cinterval operator *(const l_interval & a, const complex & b) noexcept
622  { return l_cinterval(b) * a; }
623 inline l_cinterval operator /(const complex & a, const l_interval & b) noexcept
624  { return l_cinterval(a) / b; }
625 inline l_cinterval operator /(const l_interval & a, const complex & b) noexcept
626  { return l_cinterval(a) / l_cinterval(b); }
627 inline l_cinterval operator |(const complex & a, const l_interval & b) noexcept
628  { return l_cinterval(a) | l_cinterval(b); }
629 inline l_cinterval operator |(const l_interval & a, const complex & b) noexcept
630  { return l_cinterval(a) | l_cinterval(b); }
631 inline l_cinterval operator &(const complex & a, const l_interval & b) noexcept
632  { return l_cinterval(a) & l_cinterval(b); }
633 inline l_cinterval operator &(const l_interval & a, const complex & b) noexcept
634  { return l_cinterval(a) & l_cinterval(b); }
635 
636 // LC <--> LI
637 
638 inline l_cinterval operator +(const l_complex & a, const l_interval & b)
639  noexcept { return l_cinterval(a) + l_cinterval(b); }
640 inline l_cinterval operator +(const l_interval & a, const l_complex & b)
641  noexcept { return l_cinterval(a) + l_cinterval(b); }
642 inline l_cinterval operator -(const l_complex & a, const l_interval & b)
643  noexcept { return l_cinterval(a) - l_cinterval(b); }
644 inline l_cinterval operator -(const l_interval & a, const l_complex & b)
645  noexcept { return l_cinterval(a) - l_cinterval(b); }
646 inline l_cinterval operator *(const l_complex & a, const l_interval & b)
647  noexcept { return l_cinterval(a) * b; }
648 inline l_cinterval operator *(const l_interval & a, const l_complex & b)
649  noexcept { return l_cinterval(b) * a; }
650 inline l_cinterval operator /(const l_complex & a, const l_interval & b)
651  noexcept { return l_cinterval(a) / b; }
652 inline l_cinterval operator /(const l_interval & a, const l_complex & b)
653  noexcept { return l_cinterval(a) / l_cinterval(b); }
654 inline l_cinterval operator |(const l_complex & a, const l_interval & b)
655  noexcept { return l_cinterval(a) | l_cinterval(b); }
656 inline l_cinterval operator |(const l_interval & a, const l_complex & b)
657  noexcept { return l_cinterval(a) | l_cinterval(b); }
658 inline l_cinterval operator &(const l_complex & a, const l_interval & b)
659  noexcept { return l_cinterval(a) & l_cinterval(b); }
660 inline l_cinterval operator &(const l_interval & a, const l_complex & b)
661  noexcept { return l_cinterval(a) & l_cinterval(b); }
662 
663 
664 // LC <--> C
665 
666 inline l_cinterval operator |(const l_complex & a, const complex & b)
667  noexcept { return l_cinterval(a) | l_cinterval(b); }
668 inline l_cinterval operator |(const complex & a, const l_complex & b)
669  noexcept { return l_cinterval(a) | l_cinterval(b); }
670 inline l_cinterval operator |(const l_complex & a, const l_complex & b)
671  noexcept { return l_cinterval(a) | l_cinterval(b); }
672 
673 
674 // ---- Comp.Operat. ---------------------------------------
675 
676 inline bool operator== (const l_cinterval & a, const l_cinterval & b) noexcept
677 {
678  return a.re==b.re && a.im==b.im;
679 }
680 inline bool operator!= (const l_cinterval & a, const l_cinterval & b) noexcept
681 {
682  return a.re!=b.re || a.im!=b.im;
683 }
684 
685 
686 // LCI-R
687 
688 inline bool operator== (const l_cinterval & a, const real & b) noexcept
689  { return a == l_cinterval(b); }
690 inline bool operator== (const real & a, const l_cinterval & b) noexcept
691  { return l_cinterval(a) == b; }
692 inline bool operator!= (const l_cinterval & a, const real & b) noexcept
693  { return a != l_cinterval(b); }
694 inline bool operator!= (const real & a, const l_cinterval & b) noexcept
695  { return l_cinterval(a) != b; }
696 
697 // LCI-LR
698 
699 inline bool operator== (const l_cinterval & a, const l_real & b) noexcept
700  { return a == l_cinterval(b); }
701 inline bool operator== (const l_real & a, const l_cinterval & b) noexcept
702  { return l_cinterval(a) == b; }
703 inline bool operator!= (const l_cinterval & a, const l_real & b) noexcept
704  { return a != l_cinterval(b); }
705 inline bool operator!= (const l_real & a, const l_cinterval & b) noexcept
706  { return l_cinterval(a) != b; }
707 
708 // LCI <--> I
709 
710 inline bool operator== (const l_cinterval & a, const interval & b) noexcept
711  { return a == l_cinterval(b); }
712 inline bool operator== (const interval & a, const l_cinterval & b) noexcept
713  { return l_cinterval(a) == b; }
714 inline bool operator!= (const l_cinterval & a, const interval & b) noexcept
715  { return a != l_cinterval(b); }
716 inline bool operator!= (const interval & a, const l_cinterval & b) noexcept
717  { return l_cinterval(a) != b; }
718 
719 // LCI <--> LI
720 
721 inline bool operator== (const l_cinterval & a, const l_interval & b) noexcept
722  { return a == l_cinterval(b); }
723 inline bool operator== (const l_interval & a, const l_cinterval & b) noexcept
724  { return l_cinterval(a) == b; }
725 inline bool operator!= (const l_cinterval & a, const l_interval & b) noexcept
726  { return a != l_cinterval(b); }
727 inline bool operator!= (const l_interval & a, const l_cinterval & b) noexcept
728  { return l_cinterval(a) != b; }
729 
730 // LCI <--> C
731 
732 inline bool operator== (const l_cinterval & a, const complex & b) noexcept
733  { return a == l_cinterval(b); }
734 inline bool operator== (const complex & a, const l_cinterval & b) noexcept
735  { return l_cinterval(a) == b; }
736 inline bool operator!= (const l_cinterval & a, const complex & b) noexcept
737  { return a != l_cinterval(b); }
738 inline bool operator!= (const complex & a, const l_cinterval & b) noexcept
739  { return l_cinterval(a) != b; }
740 
741 // LCI <--> LC
742 
743 inline bool operator== (const l_cinterval & a, const l_complex & b) noexcept
744  { return a == l_cinterval(b); }
745 inline bool operator== (const l_complex & a, const l_cinterval & b) noexcept
746  { return l_cinterval(a) == b; }
747 inline bool operator!= (const l_cinterval & a, const l_complex & b) noexcept
748  { return a != l_cinterval(b); }
749 inline bool operator!= (const l_complex & a, const l_cinterval & b) noexcept
750  { return l_cinterval(a) != b; }
751 
752 // LCI <--> CI
753 
754 inline bool operator== (const l_cinterval & a, const cinterval & b) noexcept
755  { return a == l_cinterval(b); }
756 inline bool operator== (const cinterval & a, const l_cinterval & b) noexcept
757  { return l_cinterval(a) == b; }
758 inline bool operator!= (const l_cinterval & a, const cinterval & b) noexcept
759  { return a != l_cinterval(b); }
760 inline bool operator!= (const cinterval & a, const l_cinterval & b) noexcept
761  { return l_cinterval(a) != b; }
762 
763 
764 // ---- Set Operators ----
765 inline bool operator <(const l_cinterval & a, const l_cinterval & b) noexcept
766 {
767  if (Inf(a.re) <= Inf(b.re) || Sup(a.re) >= Sup(b.re))
768  return false;
769  if (Inf(a.im) <= Inf(b.im) || Sup(a.im) >= Sup(b.im))
770  return false;
771 
772  return true;
773 }
774 
775 inline bool operator >(const l_cinterval & a, const l_cinterval & b) noexcept
776  { return b < a; }
777 
778 inline bool operator <=(const l_cinterval & a, const l_cinterval & b) noexcept
779 {
780  if (Inf(a.re) < Inf(b.re) || Sup(a.re) > Sup(b.re))
781  return false;
782  if (Inf(a.im) < Inf(b.im) || Sup(a.im) > Sup(b.im))
783  return false;
784 
785  return true;
786 }
787 
788 inline bool operator >= (const l_cinterval & a, const l_cinterval & b) noexcept
789  { return b <= a; }
790 
791 // lCI <--> R
792 
793 inline bool operator <(const real & a, const l_cinterval & b) noexcept
794  { return l_cinterval(a) < b; }
795 inline bool operator >(const real & a, const l_cinterval & b) noexcept
796  { return l_cinterval(a) > b; }
797 inline bool operator <=(const real & a, const l_cinterval & b) noexcept
798  { return l_cinterval(a) <= b; }
799 inline bool operator >=(const real & a, const l_cinterval & b) noexcept
800  { return l_cinterval(a) >= b; }
801 
802 inline bool operator <(const l_cinterval & a, const real & b) noexcept
803  { return a < l_cinterval(b); }
804 inline bool operator >(const l_cinterval & a, const real & b) noexcept
805  { return a > l_cinterval(b); }
806 inline bool operator <=(const l_cinterval & a, const real & b) noexcept
807  { return a <= l_cinterval(b); }
808 inline bool operator >=(const l_cinterval & a, const real & b) noexcept
809  { return a >= l_cinterval(b); }
810 
811 // lCI <--> LR
812 
813 inline bool operator <(const l_real & a, const l_cinterval & b) noexcept
814  { return l_cinterval(a) < b; }
815 inline bool operator >(const l_real & a, const l_cinterval & b) noexcept
816  { return l_cinterval(a) > b; }
817 inline bool operator <=(const l_real & a, const l_cinterval & b) noexcept
818  { return l_cinterval(a) <= b; }
819 inline bool operator >=(const l_real & a, const l_cinterval & b) noexcept
820  { return l_cinterval(a) >= b; }
821 
822 inline bool operator <(const l_cinterval & a, const l_real & b) noexcept
823  { return a < l_cinterval(b); }
824 inline bool operator >(const l_cinterval & a, const l_real & b) noexcept
825  { return a > l_cinterval(b); }
826 inline bool operator <=(const l_cinterval & a, const l_real & b) noexcept
827  { return a <= l_cinterval(b); }
828 inline bool operator >=(const l_cinterval & a, const l_real & b) noexcept
829  { return a >= l_cinterval(b); }
830 
831 // LCI <--> I
832 
833 inline bool operator <(const interval & a, const l_cinterval & b) noexcept
834  { return l_cinterval(a) < b; }
835 inline bool operator >(const interval & a, const l_cinterval & b) noexcept
836  { return l_cinterval(a) > b; }
837 inline bool operator <=(const interval & a, const l_cinterval & b) noexcept
838  { return l_cinterval(a) <= b; }
839 inline bool operator >=(const interval & a, const l_cinterval & b) noexcept
840  { return l_cinterval(a) >= b; }
841 
842 inline bool operator <(const l_cinterval & a, const interval & b) noexcept
843  { return a < l_cinterval(b); }
844 inline bool operator >(const l_cinterval & a, const interval & b) noexcept
845  { return a > l_cinterval(b); }
846 inline bool operator <=(const l_cinterval & a, const interval & b) noexcept
847  { return a <= l_cinterval(b); }
848 inline bool operator >=(const l_cinterval & a, const interval & b) noexcept
849  { return a >= l_cinterval(b); }
850 
851 // LCI <--> LI
852 
853 inline bool operator <(const l_interval & a, const l_cinterval & b) noexcept
854  { return l_cinterval(a) < b; }
855 inline bool operator >(const l_interval & a, const l_cinterval & b) noexcept
856  { return l_cinterval(a) > b; }
857 inline bool operator <=(const l_interval & a, const l_cinterval & b) noexcept
858  { return l_cinterval(a) <= b; }
859 inline bool operator >=(const l_interval & a, const l_cinterval & b) noexcept
860  { return l_cinterval(a) >= b; }
861 
862 inline bool operator <(const l_cinterval & a, const l_interval & b) noexcept
863  { return a < l_cinterval(b); }
864 inline bool operator >(const l_cinterval & a, const l_interval & b) noexcept
865  { return a > l_cinterval(b); }
866 inline bool operator <=(const l_cinterval & a, const l_interval & b) noexcept
867  { return a <= l_cinterval(b); }
868 inline bool operator >=(const l_cinterval & a, const l_interval & b) noexcept
869  { return a >= l_cinterval(b); }
870 
871 // LCI <--> C
872 
873 inline bool operator <(const complex & a, const l_cinterval & b) noexcept
874  { return l_cinterval(a) < b; }
875 inline bool operator >(const complex & a, const l_cinterval & b) noexcept
876  { return l_cinterval(a) > b; }
877 inline bool operator <=(const complex & a, const l_cinterval & b) noexcept
878  { return l_cinterval(a) <= b; }
879 inline bool operator >=(const complex & a, const l_cinterval & b) noexcept
880  { return l_cinterval(a) >= b; }
881 
882 inline bool operator <(const l_cinterval & a, const complex & b) noexcept
883  { return a < l_cinterval(b); }
884 inline bool operator >(const l_cinterval & a, const complex & b) noexcept
885  { return a > l_cinterval(b); }
886 inline bool operator <=(const l_cinterval & a, const complex & b) noexcept
887  { return a <= l_cinterval(b); }
888 inline bool operator >=(const l_cinterval & a, const complex & b) noexcept
889  { return a >= l_cinterval(b); }
890 
891 // LCI <--> LC
892 
893 inline bool operator <(const l_complex & a, const l_cinterval & b) noexcept
894  { return l_cinterval(a) < b; }
895 inline bool operator >(const l_complex & a, const l_cinterval & b) noexcept
896  { return l_cinterval(a) > b; }
897 inline bool operator <=(const l_complex & a, const l_cinterval & b) noexcept
898  { return l_cinterval(a) <= b; }
899 inline bool operator >=(const l_complex & a, const l_cinterval & b) noexcept
900  { return l_cinterval(a) >= b; }
901 
902 inline bool operator <(const l_cinterval & a, const l_complex & b) noexcept
903  { return a < l_cinterval(b); }
904 inline bool operator >(const l_cinterval & a, const l_complex & b) noexcept
905  { return a > l_cinterval(b); }
906 inline bool operator <=(const l_cinterval & a, const l_complex & b) noexcept
907  { return a <= l_cinterval(b); }
908 inline bool operator >=(const l_cinterval & a, const l_complex & b) noexcept
909  { return a >= l_cinterval(b); }
910 
911 // LCI <--> CI
912 
913 inline bool operator <(const cinterval & a, const l_cinterval & b) noexcept
914  { return l_cinterval(a) < b; }
915 inline bool operator >(const cinterval & a, const l_cinterval & b) noexcept
916  { return l_cinterval(a) > b; }
917 inline bool operator <=(const cinterval & a, const l_cinterval & b) noexcept
918  { return l_cinterval(a) <= b; }
919 inline bool operator >=(const cinterval & a, const l_cinterval & b) noexcept
920  { return l_cinterval(a) >= b; }
921 
922 inline bool operator <(const l_cinterval & a, const cinterval & b) noexcept
923  { return a < l_cinterval(b); }
924 inline bool operator >(const l_cinterval & a, const cinterval & b) noexcept
925  { return a > l_cinterval(b); }
926 inline bool operator <=(const l_cinterval & a, const cinterval & b) noexcept
927  { return a <= l_cinterval(b); }
928 inline bool operator >=(const l_cinterval & a, const cinterval & b) noexcept
929  { return a >= l_cinterval(b); }
930 
931 
932 // ---- Others -------------------------------------------
933 
934 inline l_complex Inf(const l_cinterval & a) noexcept
935  { return l_complex(Inf(a.re),Inf(a.im)); }
936 inline l_complex Sup(const l_cinterval & a) noexcept
937  { return l_complex(Sup(a.re),Sup(a.im)); }
938 
939 inline l_cinterval & SetInf(l_cinterval & a, const complex & b)
940 
941 {
942  Inf(a.re) = Re(b);
943  Inf(a.im) = Im(b);
944 
945  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
946  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetInf(l_cinterval & a, const complex & b)"));
947 
948  return a;
949 }
950 
951 inline l_cinterval & SetSup(l_cinterval & a, const complex & b)
952 
953 {
954  Sup(a.re)=Re(b);
955  Sup(a.im)=Im(b);
956 
957  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
958  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetSup(l_cinterval & a, const complex & b)"));
959 
960  return a;
961 }
962 
963 inline l_cinterval & SetInf(l_cinterval & a, const l_complex & b)
964 
965 {
966  Inf(a.re) = Re(b);
967  Inf(a.im) = Im(b);
968 
969  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
970  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetInf(l_cinterval & a, const l_complex & b)"));
971 
972  return a;
973 }
974 
975 inline l_cinterval & SetSup(l_cinterval & a, const l_complex & b)
976 
977 {
978  Sup(a.re)=Re(b);
979  Sup(a.im)=Im(b);
980 
981  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
982  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetSup(l_cinterval & a, const l_complex & b)"));
983 
984  return a;
985 }
986 
987 inline l_cinterval & SetInf(l_cinterval & a, const real & b)
988 
989 {
990  Inf(a.re)=b;
991  Inf(a.im)=0.0;
992 
993  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
994  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetSup(l_cinterval & a, const real & b)"));
995 
996  return a;
997 }
998 
999 inline l_cinterval & SetSup(l_cinterval & a, const real & b)
1000 
1001 {
1002  Sup(a.re)=b;
1003  Sup(a.im)=0.0;
1004 
1005  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1006  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetSup(l_cinterval & a, const real & b)"));
1007 
1008  return a;
1009 }
1010 
1011 inline l_cinterval & SetInf(l_cinterval & a, const l_real & b)
1012 
1013 {
1014  Inf(a.re)=b;
1015  Inf(a.im)=0.0;
1016 
1017  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1018  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetSup(l_cinterval & a, const l_real & b)"));
1019 
1020  return a;
1021 }
1022 
1023 inline l_cinterval & SetSup(l_cinterval & a, const l_real & b)
1024 
1025 {
1026  Sup(a.re)=b;
1027  Sup(a.im)=0.0;
1028 
1029  if (Inf(a.re) > Sup(a.re) || Inf(a.im) > Sup(a.im))
1030  cxscthrow(ERROR_CINTERVAL_EMPTY_INTERVAL("inline l_cinterval & SetSup(l_cinterval & a, const l_real & b)"));
1031 
1032  return a;
1033 }
1034 
1035 
1036 inline l_cinterval & UncheckedSetInf(l_cinterval & a, const complex & b)
1037  noexcept
1038 {
1039  Inf(a.re)=Re(b);
1040  Inf(a.im)=Im(b);
1041  return a;
1042 }
1043 
1044 inline l_cinterval & UncheckedSetInf(l_cinterval & a, const real & b)
1045  noexcept
1046 {
1047  Inf(a.re)=b;
1048  Inf(a.im)=0.0;
1049  return a;
1050 }
1051 
1052 inline l_cinterval & UncheckedSetSup(l_cinterval & a, const complex & b)
1053  noexcept
1054 {
1055  Sup(a.re)=Re(b);
1056  Sup(a.im)=Im(b);
1057  return a;
1058 }
1059 
1060 inline l_cinterval & UncheckedSetSup(l_cinterval & a, const real & b)
1061  noexcept
1062 {
1063  Sup(a.re)=b;
1064  Sup(a.im)=0.0;
1065  return a;
1066 }
1067 
1068 inline l_cinterval & UncheckedSetInf(l_cinterval & a, const l_complex & b)
1069  noexcept
1070 {
1071  Inf(a.re)=Re(b);
1072  Inf(a.im)=Im(b);
1073  return a;
1074 }
1075 
1076 inline l_cinterval & UncheckedSetInf(l_cinterval & a, const l_real & b)
1077  noexcept
1078 {
1079  Inf(a.re)=b;
1080  Inf(a.im)=0.0;
1081  return a;
1082 }
1083 
1084 inline l_cinterval & UncheckedSetSup(l_cinterval & a, const l_complex & b)
1085  noexcept
1086 {
1087  Sup(a.re)=Re(b);
1088  Sup(a.im)=Im(b);
1089  return a;
1090 }
1091 
1092 inline l_cinterval & UncheckedSetSup(l_cinterval & a, const l_real & b)
1093  noexcept
1094 {
1095  Sup(a.re)=b;
1096  Sup(a.im)=0.0;
1097  return a;
1098 }
1099 
1100 
1101 inline l_cinterval conj(const l_cinterval & a) noexcept
1102 { return l_cinterval(a.re,-a.im); }
1103 
1104 inline l_complex mid(const l_cinterval &a) noexcept
1105 { return l_complex(mid(a.re), mid(a.im)); }
1106 
1107 inline l_complex diam(const l_cinterval &a) noexcept
1108 { return l_complex(diam(a.re),diam(a.im)); }
1109 
1110 inline l_cinterval adjust(const l_cinterval & a) noexcept
1111 {
1112  return l_cinterval(adjust(Re(a)),adjust(Im(a)));
1113 
1114 // return l_cinterval(a.re,-a.im);
1115 }
1116 
1117 inline void times2pown(l_cinterval& x, const int& n) noexcept
1118 // Blomquist, 08.03.07;
1119 {
1120  if ( n<-1074 || n>1023 )
1121  { std::cerr << "Error in: "
1122  << "times2pown(l_cinterval& x, const int& n): " << std::endl
1123  << " -1074 <= n <= +1023 not fulfilled" << std::endl; exit(0);
1124  }
1125  l_interval u(Re(x)),v(Im(x));
1126  times2pown(u,n);
1127  times2pown(v,n);
1128  x = l_cinterval(u,v);
1129 }
1130 
1131 inline void Times2pown(l_cinterval& x, const int& n) noexcept
1132 // Blomquist, 28.03.07;
1133 {
1134 
1135  l_interval u(Re(x)),v(Im(x));
1136  Times2pown(u,n);
1137  Times2pown(v,n);
1138  x = l_cinterval(u,v);
1139 }
1140 
1141 
1142 } // namespace cxsc
1143 
1144 
1145 
1146 
cxsc::mid
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition: cimatrix.inl:739
cxsc::l_cinterval::l_cinterval
l_cinterval(void) noexcept
Constructor of class l_cinterval.
Definition: l_cinterval.hpp:63
cxsc::l_cinterval::Inf
friend l_complex Inf(const l_cinterval &) noexcept
Returns the infimum of an interval.
Definition: l_cinterval.inl:934
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::operator*=
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
Definition: cimatrix.inl:1605
cxsc::operator/
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition: cimatrix.inl:730
cxsc::l_cinterval::operator=
l_cinterval & operator=(const real &) noexcept
Implementation of standard assigning operator.
Definition: l_cinterval.inl:82
cxsc::operator/=
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.
Definition: cimatrix.inl:1623
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::operator*
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition: cimatrix.inl:731
cxsc::l_complex
The Multiple-Precision Data Type l_complex.
Definition: l_complex.hpp:46
cxsc::l_cinterval::Sup
friend l_complex Sup(const l_cinterval &) noexcept
Returns the supremum of an interval.
Definition: l_cinterval.inl:936
cxsc::dotprecision
The Data Type dotprecision.
Definition: dot.hpp:112
cxsc::l_interval
The Multiple-Precision Data Type l_interval.
Definition: l_interval.hpp:72
cxsc::cidotprecision
The Data Type cidotprecision.
Definition: cidot.hpp:58
cxsc
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition: cdot.cpp:29
cxsc::operator+=
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition: cdot.inl:251
cxsc::l_real
The Multiple-Precision Data Type l_real.
Definition: l_real.hpp:78
cxsc::diam
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition: cimatrix.inl:738
cxsc::l_cinterval
The Multiple-Precision Data Type l_cinterval.
Definition: l_cinterval.hpp:54
cxsc::cdotprecision
The Data Type cdotprecision.
Definition: cdot.hpp:61
cxsc::times2pown
void times2pown(cinterval &x, int n) noexcept
Fast multiplication of reference parameter [z] with .
Definition: cimath.cpp:2059
cxsc::cinterval
The Scalar Type cinterval.
Definition: cinterval.hpp:55
cxsc::complex
The Scalar Type complex.
Definition: complex.hpp:50
cxsc::real
The Scalar Type real.
Definition: real.hpp:114