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
26namespace cxsc {
27
28
29// Inlined functions for l_cinterval.
30
31// ---- implicit constructors ------------------------------
32
33inline 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
44inline 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
53inline 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
64inline l_cinterval::l_cinterval(const real & a) noexcept : re(a,a), im(0,0) {}
65inline 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
82inline l_cinterval & l_cinterval::operator =(const real & a) noexcept
83{
84 re=a,im=0.0;
85 return *this;
86}
87
88inline l_cinterval & l_cinterval::operator =(const l_real & a) noexcept
89{
90 re=a,im=0.0;
91 return *this;
92}
93
94
95inline l_cinterval & l_cinterval::operator =(const interval & a) noexcept
96{
97 re=a,im=0.0;
98 return *this;
99}
100
101inline l_cinterval & l_cinterval::operator =(const l_interval & a) noexcept
102{
103 re=a,im=0.0;
104 return *this;
105}
106
107inline l_cinterval & l_cinterval::operator =(const complex & a) noexcept
108{
109 re=Re(a),im=Im(a);
110 return *this;
111}
112
113inline l_cinterval & l_cinterval::operator =(const l_complex & a) noexcept
114{
115 re=Re(a),im=Im(a);
116 return *this;
117}
118
119inline l_cinterval & l_cinterval::operator =(const cinterval & a) noexcept
120{
121 re = Re(a);
122 im = Im(a);
123 return *this;
124}
125
126inline l_cinterval & l_cinterval::operator =(const l_cinterval & a) noexcept
127{
128 re = a.re;
129 im = a.im;
130 return *this;
131}
132
133inline l_cinterval & l_cinterval::operator =(const dotprecision & a) noexcept
134{
135 return *this = l_cinterval(a);
136}
137
138inline l_cinterval & l_cinterval::operator =(const idotprecision & a) noexcept
139{
140 return *this = l_cinterval(a);
141}
142
143inline l_cinterval & l_cinterval::operator =(const cdotprecision & a) noexcept
144{
145 return *this = l_cinterval(a);
146}
147
148inline l_cinterval & l_cinterval::operator =(const cidotprecision & a) noexcept
149{
150 return *this = l_cinterval(a);
151}
152
153
154// ---- Std.Operators ---------------------------------------
155
156inline l_cinterval operator -(const l_cinterval & a) noexcept
157{
158 return l_cinterval(-a.re,-a.im);
159}
160
161inline l_cinterval operator +(const l_cinterval & a) noexcept
162{
163 return a;
164}
165
166inline bool operator! (const l_cinterval & a) noexcept
167{
168 return !a.re && !a.im;
169}
170
171inline 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
177inline 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
183inline 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
205inline 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; }
227inline 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; }
233inline l_cinterval & operator |=(l_cinterval & a, const l_cinterval & b)
234 noexcept { return a = a|b; }
235inline l_cinterval & operator &=(l_cinterval & a, const l_cinterval & b)
236 { return a = a&b; }
237
238// LCI <--> R
239
240inline l_cinterval operator +(const l_cinterval & a, const real & b) noexcept
241 { return a + l_cinterval(b); }
242inline l_cinterval operator +(const real & a, const l_cinterval & b) noexcept
243 { return l_cinterval(a) + b; }
244inline l_cinterval operator -(const l_cinterval & a, const real & b) noexcept
245 { return a - l_cinterval(b); }
246inline l_cinterval operator -(const real & a, const l_cinterval & b) noexcept
247 { return l_cinterval(a) - b; }
248inline l_cinterval operator *(const l_cinterval & a, const real & b) noexcept
249 { return l_cinterval(a.re*b, a.im*b); }
250inline l_cinterval operator *(const real & a, const l_cinterval & b) noexcept
251 { return l_cinterval(b.re*a, b.im*a); }
252inline l_cinterval operator /(const l_cinterval & a, const real & b) noexcept
253 { return l_cinterval(a.re/b, a.im/b); }
254inline l_cinterval operator /(const real & a, const l_cinterval & b) noexcept
255 { return l_cinterval(a) / b; }
256inline l_cinterval operator |(const l_cinterval & a, const real & b) noexcept
257 { return a|l_cinterval(b); }
258inline l_cinterval operator |(const real & a, const l_cinterval & b) noexcept
259 { return l_cinterval(a)|b; }
260inline l_cinterval operator &(const l_cinterval & a, const real & b) noexcept
261 { return a & l_cinterval(b); }
262inline l_cinterval operator &(const real & a, const l_cinterval & b) noexcept
263 { return l_cinterval(a) & b; }
264
265inline l_cinterval & operator +=(l_cinterval & a, const real & b) noexcept
266 { return a = a+l_cinterval(b); }
267inline l_cinterval & operator -=(l_cinterval & a, const real & b) noexcept
268 { return a = a -l_cinterval(b); }
269inline l_cinterval & operator *=(l_cinterval & a, const real & b) noexcept
270 { return a = a * b; }
271inline l_cinterval & operator /=(l_cinterval & a, const real & b) noexcept
272 { return a = a / b; }
273inline l_cinterval & operator |=(l_cinterval & a, const real & b) noexcept
274 { return a = a|l_cinterval(b); }
275inline l_cinterval & operator &=(l_cinterval & a, const real & b) noexcept
276 { return a = a&l_cinterval(b); }
277
278// LCI <--> LR
279
280inline l_cinterval operator +(const l_cinterval & a, const l_real & b) noexcept
281 { return a + l_cinterval(b); }
282inline l_cinterval operator +(const l_real & a, const l_cinterval & b) noexcept
283 { return l_cinterval(a) + b; }
284inline l_cinterval operator -(const l_cinterval & a, const l_real & b) noexcept
285 { return a - l_cinterval(b); }
286inline l_cinterval operator -(const l_real & a, const l_cinterval & b) noexcept
287 { return l_cinterval(a) - b; }
288inline l_cinterval operator *(const l_cinterval & a, const l_real & b) noexcept
289 { return l_cinterval(a.re*b, a.im*b); }
290inline l_cinterval operator *(const l_real & a, const l_cinterval & b) noexcept
291 { return l_cinterval(b.re*a, b.im*a); }
292inline l_cinterval operator /(const l_cinterval & a, const l_real & b) noexcept
293 { return l_cinterval(a.re/b, a.im/b); }
294inline l_cinterval operator /(const l_real & a, const l_cinterval & b) noexcept
295 { return l_cinterval(a) / b; }
296inline l_cinterval operator |(const l_cinterval & a, const l_real & b) noexcept
297 { return a|l_cinterval(b); }
298inline l_cinterval operator |(const l_real & a, const l_cinterval & b) noexcept
299 { return l_cinterval(a)|b; }
300inline l_cinterval operator &(const l_cinterval & a, const l_real & b) noexcept
301 { return a & l_cinterval(b); }
302inline l_cinterval operator &(const l_real & a, const l_cinterval & b) noexcept
303 { return l_cinterval(a) & b; }
304
305inline l_cinterval & operator +=(l_cinterval & a, const l_real & b) noexcept
306 { return a = a+l_cinterval(b); }
307inline l_cinterval & operator -=(l_cinterval & a, const l_real & b) noexcept
308 { return a = a -l_cinterval(b); }
309inline l_cinterval & operator *=(l_cinterval & a, const l_real & b) noexcept
310 { return a = a * b; }
311inline l_cinterval & operator /=(l_cinterval & a, const l_real & b) noexcept
312 { return a = a / b; }
313inline l_cinterval & operator |=(l_cinterval & a, const l_real & b) noexcept
314 { return a = a|l_cinterval(b); }
315inline 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
322inline l_cinterval operator +(const l_cinterval & a, const complex & b)
323 noexcept { return a + l_cinterval(b); }
324inline l_cinterval operator +(const complex & a, const l_cinterval & b)
325 noexcept { return l_cinterval(a) + b; }
326inline l_cinterval operator -(const l_cinterval & a, const complex & b)
327 noexcept { return a - l_cinterval(b); }
328inline l_cinterval operator -(const complex & a, const l_cinterval & b)
329 noexcept { return l_cinterval(a) - b; }
330inline l_cinterval operator *(const l_cinterval & a, const complex & b)
331 noexcept { return a * l_cinterval(b); }
332inline l_cinterval operator *(const complex & a, const l_cinterval & b)
333 noexcept { return l_cinterval(a) * b; }
334inline l_cinterval operator /(const l_cinterval & a, const complex & b)
335 noexcept { return a / l_cinterval(b); }
336inline l_cinterval operator /(const complex & a, const l_cinterval & b)
337 noexcept { return l_cinterval(a) / b; }
338inline l_cinterval operator |(const l_cinterval & a, const complex & b)
339 noexcept { return a | l_cinterval(b); }
340inline l_cinterval operator |(const complex & a, const l_cinterval & b)
341 noexcept { return l_cinterval(a) | b; }
342inline l_cinterval operator &(const l_cinterval & a, const complex & b)
343 noexcept { return a & l_cinterval(b); }
344inline l_cinterval operator &(const complex & a, const l_cinterval & b)
345 noexcept { return l_cinterval(a) & b; }
346
347inline l_cinterval & operator +=(l_cinterval & a, const complex & b) noexcept
348 { return a = a + l_cinterval(b); }
349inline l_cinterval & operator -=(l_cinterval & a, const complex & b) noexcept
350 { return a = a - l_cinterval(b); }
351inline l_cinterval & operator *=(l_cinterval & a, const complex & b) noexcept
352 { return a = a * l_cinterval(b); }
353inline l_cinterval & operator /=(l_cinterval & a, const complex & b) noexcept
354 { return a = a / l_cinterval(b); }
355inline l_cinterval & operator |=(l_cinterval & a, const complex & b) noexcept
356 { return a = a | l_cinterval(b); }
357inline l_cinterval & operator &=(l_cinterval & a, const complex & b) noexcept
358 { return a = a & l_cinterval(b); }
359
360
361// LCI <--> LC
362
363inline l_cinterval operator +(const l_cinterval & a, const l_complex & b)
364 noexcept { return a + l_cinterval(b); }
365inline l_cinterval operator +(const l_complex & a, const l_cinterval & b)
366 noexcept { return l_cinterval(a) + b; }
367inline l_cinterval operator -(const l_cinterval & a, const l_complex & b)
368 noexcept { return a - l_cinterval(b); }
369inline l_cinterval operator -(const l_complex & a, const l_cinterval & b)
370 noexcept { return l_cinterval(a) - b; }
371inline l_cinterval operator *(const l_cinterval & a, const l_complex & b)
372 noexcept { return a * l_cinterval(b); }
373inline l_cinterval operator *(const l_complex & a, const l_cinterval & b)
374 noexcept { return l_cinterval(a) * b; }
375inline l_cinterval operator /(const l_cinterval & a, const l_complex & b)
376 noexcept { return a / l_cinterval(b); }
377inline l_cinterval operator /(const l_complex & a, const l_cinterval & b)
378 noexcept { return l_cinterval(a) / b; }
379inline l_cinterval operator |(const l_cinterval & a, const l_complex & b)
380 noexcept { return a | l_cinterval(b); }
381inline l_cinterval operator |(const l_complex & a, const l_cinterval & b)
382 noexcept { return l_cinterval(a) | b; }
383inline l_cinterval operator &(const l_cinterval & a, const l_complex & b)
384 noexcept { return a & l_cinterval(b); }
385inline l_cinterval operator &(const l_complex & a, const l_cinterval & b)
386 noexcept { return l_cinterval(a) & b; }
387
388inline l_cinterval & operator +=(l_cinterval & a, const l_complex & b) noexcept
389 { return a = a + l_cinterval(b); }
390inline l_cinterval & operator -=(l_cinterval & a, const l_complex & b) noexcept
391 { return a = a - l_cinterval(b); }
392inline l_cinterval & operator *=(l_cinterval & a, const l_complex & b) noexcept
393 { return a = a * l_cinterval(b); }
394inline l_cinterval & operator /=(l_cinterval & a, const l_complex & b) noexcept
395 { return a = a / l_cinterval(b); }
396inline l_cinterval & operator |=(l_cinterval & a, const l_complex & b) noexcept
397 { return a = a | l_cinterval(b); }
398inline 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
405inline l_cinterval operator +(const l_cinterval & a,
406 const interval & b) noexcept
407 { return a + l_cinterval(b); }
408inline l_cinterval operator +(const interval & a,
409 const l_cinterval & b) noexcept
410 { return l_cinterval(a) + b; }
411inline l_cinterval operator -(const l_cinterval & a,
412 const interval & b) noexcept
413 { return a - l_cinterval(b); }
414inline 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); }
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); }
427 const l_cinterval & b) noexcept
428 { return l_cinterval(a) / b; }
429inline l_cinterval operator |(const l_cinterval & a,
430 const interval & b) noexcept
431 { return a | l_cinterval(b); }
432inline l_cinterval operator |(const interval & a,
433 const l_cinterval & b) noexcept
434 { return l_cinterval(a) | b; }
435inline l_cinterval operator &(const l_cinterval & a,
436 const interval & b) noexcept
437 { return a & l_cinterval(b); }
438inline l_cinterval operator &(const interval & a,
439 const l_cinterval & b) noexcept
440 { return l_cinterval(a) & b; }
441
443 noexcept { return a = a + l_cinterval(b); }
444inline l_cinterval & operator -=(l_cinterval & a, const interval & b)
445 noexcept { return a = a - l_cinterval(b); }
447 noexcept { return a = a * l_cinterval(b); }
449 noexcept { return a = a / l_cinterval(b); }
450inline l_cinterval & operator |=(l_cinterval & a, const interval & b)
451 noexcept { return a = a | l_cinterval(b); }
452inline l_cinterval & operator &=(l_cinterval & a, const interval & b)
453 noexcept { return a = a & l_cinterval(b); }
454
455// LCI <--> LI
456
457inline l_cinterval operator +(const l_cinterval & a,
458 const l_interval & b) noexcept
459 { return a + l_cinterval(b); }
460inline l_cinterval operator +(const l_interval & a,
461 const l_cinterval & b) noexcept
462 { return l_cinterval(a) + b; }
463inline l_cinterval operator -(const l_cinterval & a,
464 const l_interval & b) noexcept
465 { return a - l_cinterval(b); }
466inline 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; }
481inline l_cinterval operator |(const l_cinterval & a,
482 const l_interval & b) noexcept
483 { return a | l_cinterval(b); }
484inline l_cinterval operator |(const l_interval & a,
485 const l_cinterval & b) noexcept
486 { return l_cinterval(a) | b; }
487inline l_cinterval operator &(const l_cinterval & a,
488 const l_interval & b) noexcept
489 { return a & l_cinterval(b); }
490inline 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); }
496inline 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); }
502inline l_cinterval & operator |=(l_cinterval & a, const l_interval & b)
503 noexcept { return a = a | l_cinterval(b); }
504inline l_cinterval & operator &=(l_cinterval & a, const l_interval & b)
505 noexcept { return a = a & l_cinterval(b); }
506
507// LCI <--> CI
508
509inline l_cinterval operator +(const l_cinterval & a,
510 const cinterval & b) noexcept
511 { return a + l_cinterval(b); }
512inline l_cinterval operator +(const cinterval & a,
513 const l_cinterval & b) noexcept
514 { return l_cinterval(a) + b; }
515inline l_cinterval operator -(const l_cinterval & a,
516 const cinterval & b) noexcept
517 { return a - l_cinterval(b); }
518inline 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; }
533inline l_cinterval operator |(const l_cinterval & a,
534 const cinterval & b) noexcept
535 { return a | l_cinterval(b); }
536inline l_cinterval operator |(const cinterval & a,
537 const l_cinterval & b) noexcept
538 { return l_cinterval(a) | b; }
539inline l_cinterval operator &(const l_cinterval & a,
540 const cinterval & b) noexcept
541 { return a & l_cinterval(b); }
542inline l_cinterval operator &(const cinterval & a,
543 const l_cinterval & b) noexcept
544 { return l_cinterval(a) & b; }
545
547 noexcept { return a = a + l_cinterval(b); }
548inline l_cinterval & operator -=(l_cinterval & a, const cinterval & b)
549 noexcept { return a = a - l_cinterval(b); }
551 noexcept { return a = a * l_cinterval(b); }
553 noexcept { return a = a / l_cinterval(b); }
554inline l_cinterval & operator |=(l_cinterval & a, const cinterval & b)
555 noexcept { return a = a | l_cinterval(b); }
556inline l_cinterval & operator &=(l_cinterval & a, const cinterval & b)
557 noexcept { return a = a & l_cinterval(b); }
558
559// C-R
560
561inline l_cinterval operator |(const l_complex & a, const real & b) noexcept
562 { return l_cinterval(a) | l_cinterval(b); }
563inline l_cinterval operator |(const real & a, const l_complex & b) noexcept
564 { return l_cinterval(a) | l_cinterval(b); }
565inline l_cinterval operator |(const complex & a, const l_real & b) noexcept
566 { return l_cinterval(a) | l_cinterval(b); }
567inline l_cinterval operator |(const l_real & a, const complex & b) noexcept
568 { return l_cinterval(a) | l_cinterval(b); }
569inline l_cinterval operator |(const l_complex & a, const l_real & b) noexcept
570 { return l_cinterval(a) | l_cinterval(b); }
571inline l_cinterval operator |(const l_real & a, const l_complex & b) noexcept
572 { return l_cinterval(a) | l_cinterval(b); }
573inline l_cinterval operator |(const cinterval & a, const l_real & b) noexcept
574 { return l_cinterval(a) | l_cinterval(b); }
575inline l_cinterval operator |(const l_real & a, const cinterval & b) noexcept
576 { return l_cinterval(a) | l_cinterval(b); }
577inline l_cinterval operator |(const cinterval & a, const l_complex & b)
578 noexcept { return l_cinterval(a) | l_cinterval(b); }
579inline l_cinterval operator |(const l_complex & a, const cinterval & b)
580 noexcept { return l_cinterval(a) | l_cinterval(b); }
581
582// LC <--> I
583
584inline l_cinterval operator +(const l_complex & a, const interval & b) noexcept
585 { return l_cinterval(a) + l_cinterval(b); }
586inline l_cinterval operator +(const interval & a, const l_complex & b) noexcept
587 { return l_cinterval(a) + l_cinterval(b); }
588inline l_cinterval operator -(const l_complex & a, const interval & b) noexcept
589 { return l_cinterval(a) - l_cinterval(b); }
590inline l_cinterval operator -(const interval & a, const l_complex & b) noexcept
591 { return l_cinterval(a) - l_cinterval(b); }
592inline l_cinterval operator *(const l_complex & a, const interval & b) noexcept
593 { return l_cinterval(a) * b; }
594inline l_cinterval operator *(const interval & a, const l_complex & b) noexcept
595 { return l_cinterval(b) * a; }
596inline l_cinterval operator /(const l_complex & a, const interval & b) noexcept
597 { return l_cinterval(a) / b; }
598inline l_cinterval operator /(const interval & a, const l_complex & b) noexcept
599 { return l_cinterval(a) / l_cinterval(b); }
600inline l_cinterval operator |(const l_complex & a, const interval & b) noexcept
601 { return l_cinterval(a) | l_cinterval(b); }
602inline l_cinterval operator |(const interval & a, const l_complex & b) noexcept
603 { return l_cinterval(a) | l_cinterval(b); }
604inline l_cinterval operator &(const l_complex & a, const interval & b) noexcept
605 { return l_cinterval(a) & l_cinterval(b); }
606inline l_cinterval operator &(const interval & a, const l_complex & b) noexcept
607 { return l_cinterval(a) & l_cinterval(b); }
608
609// C <--> LI
610
611inline l_cinterval operator +(const complex & a, const l_interval & b) noexcept
612 { return l_cinterval(a) + l_cinterval(b); }
613inline l_cinterval operator +(const l_interval & a, const complex & b) noexcept
614 { return l_cinterval(a) + l_cinterval(b); }
615inline l_cinterval operator -(const complex & a, const l_interval & b) noexcept
616 { return l_cinterval(a) - l_cinterval(b); }
617inline l_cinterval operator -(const l_interval & a, const complex & b) noexcept
618 { return l_cinterval(a) - l_cinterval(b); }
619inline l_cinterval operator *(const complex & a, const l_interval & b) noexcept
620 { return l_cinterval(a) * b; }
621inline l_cinterval operator *(const l_interval & a, const complex & b) noexcept
622 { return l_cinterval(b) * a; }
623inline l_cinterval operator /(const complex & a, const l_interval & b) noexcept
624 { return l_cinterval(a) / b; }
625inline l_cinterval operator /(const l_interval & a, const complex & b) noexcept
626 { return l_cinterval(a) / l_cinterval(b); }
627inline l_cinterval operator |(const complex & a, const l_interval & b) noexcept
628 { return l_cinterval(a) | l_cinterval(b); }
629inline l_cinterval operator |(const l_interval & a, const complex & b) noexcept
630 { return l_cinterval(a) | l_cinterval(b); }
631inline l_cinterval operator &(const complex & a, const l_interval & b) noexcept
632 { return l_cinterval(a) & l_cinterval(b); }
633inline l_cinterval operator &(const l_interval & a, const complex & b) noexcept
634 { return l_cinterval(a) & l_cinterval(b); }
635
636// LC <--> LI
637
638inline l_cinterval operator +(const l_complex & a, const l_interval & b)
639 noexcept { return l_cinterval(a) + l_cinterval(b); }
640inline l_cinterval operator +(const l_interval & a, const l_complex & b)
641 noexcept { return l_cinterval(a) + l_cinterval(b); }
642inline l_cinterval operator -(const l_complex & a, const l_interval & b)
643 noexcept { return l_cinterval(a) - l_cinterval(b); }
644inline l_cinterval operator -(const l_interval & a, const l_complex & b)
645 noexcept { return l_cinterval(a) - l_cinterval(b); }
646inline l_cinterval operator *(const l_complex & a, const l_interval & b)
647 noexcept { return l_cinterval(a) * b; }
648inline l_cinterval operator *(const l_interval & a, const l_complex & b)
649 noexcept { return l_cinterval(b) * a; }
650inline l_cinterval operator /(const l_complex & a, const l_interval & b)
651 noexcept { return l_cinterval(a) / b; }
652inline l_cinterval operator /(const l_interval & a, const l_complex & b)
653 noexcept { return l_cinterval(a) / l_cinterval(b); }
654inline l_cinterval operator |(const l_complex & a, const l_interval & b)
655 noexcept { return l_cinterval(a) | l_cinterval(b); }
656inline l_cinterval operator |(const l_interval & a, const l_complex & b)
657 noexcept { return l_cinterval(a) | l_cinterval(b); }
658inline l_cinterval operator &(const l_complex & a, const l_interval & b)
659 noexcept { return l_cinterval(a) & l_cinterval(b); }
660inline 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
666inline l_cinterval operator |(const l_complex & a, const complex & b)
667 noexcept { return l_cinterval(a) | l_cinterval(b); }
668inline l_cinterval operator |(const complex & a, const l_complex & b)
669 noexcept { return l_cinterval(a) | l_cinterval(b); }
670inline 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
676inline bool operator== (const l_cinterval & a, const l_cinterval & b) noexcept
677{
678 return a.re==b.re && a.im==b.im;
679}
680inline 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
688inline bool operator== (const l_cinterval & a, const real & b) noexcept
689 { return a == l_cinterval(b); }
690inline bool operator== (const real & a, const l_cinterval & b) noexcept
691 { return l_cinterval(a) == b; }
692inline bool operator!= (const l_cinterval & a, const real & b) noexcept
693 { return a != l_cinterval(b); }
694inline bool operator!= (const real & a, const l_cinterval & b) noexcept
695 { return l_cinterval(a) != b; }
696
697// LCI-LR
698
699inline bool operator== (const l_cinterval & a, const l_real & b) noexcept
700 { return a == l_cinterval(b); }
701inline bool operator== (const l_real & a, const l_cinterval & b) noexcept
702 { return l_cinterval(a) == b; }
703inline bool operator!= (const l_cinterval & a, const l_real & b) noexcept
704 { return a != l_cinterval(b); }
705inline bool operator!= (const l_real & a, const l_cinterval & b) noexcept
706 { return l_cinterval(a) != b; }
707
708// LCI <--> I
709
710inline bool operator== (const l_cinterval & a, const interval & b) noexcept
711 { return a == l_cinterval(b); }
712inline bool operator== (const interval & a, const l_cinterval & b) noexcept
713 { return l_cinterval(a) == b; }
714inline bool operator!= (const l_cinterval & a, const interval & b) noexcept
715 { return a != l_cinterval(b); }
716inline bool operator!= (const interval & a, const l_cinterval & b) noexcept
717 { return l_cinterval(a) != b; }
718
719// LCI <--> LI
720
721inline bool operator== (const l_cinterval & a, const l_interval & b) noexcept
722 { return a == l_cinterval(b); }
723inline bool operator== (const l_interval & a, const l_cinterval & b) noexcept
724 { return l_cinterval(a) == b; }
725inline bool operator!= (const l_cinterval & a, const l_interval & b) noexcept
726 { return a != l_cinterval(b); }
727inline bool operator!= (const l_interval & a, const l_cinterval & b) noexcept
728 { return l_cinterval(a) != b; }
729
730// LCI <--> C
731
732inline bool operator== (const l_cinterval & a, const complex & b) noexcept
733 { return a == l_cinterval(b); }
734inline bool operator== (const complex & a, const l_cinterval & b) noexcept
735 { return l_cinterval(a) == b; }
736inline bool operator!= (const l_cinterval & a, const complex & b) noexcept
737 { return a != l_cinterval(b); }
738inline bool operator!= (const complex & a, const l_cinterval & b) noexcept
739 { return l_cinterval(a) != b; }
740
741// LCI <--> LC
742
743inline bool operator== (const l_cinterval & a, const l_complex & b) noexcept
744 { return a == l_cinterval(b); }
745inline bool operator== (const l_complex & a, const l_cinterval & b) noexcept
746 { return l_cinterval(a) == b; }
747inline bool operator!= (const l_cinterval & a, const l_complex & b) noexcept
748 { return a != l_cinterval(b); }
749inline bool operator!= (const l_complex & a, const l_cinterval & b) noexcept
750 { return l_cinterval(a) != b; }
751
752// LCI <--> CI
753
754inline bool operator== (const l_cinterval & a, const cinterval & b) noexcept
755 { return a == l_cinterval(b); }
756inline bool operator== (const cinterval & a, const l_cinterval & b) noexcept
757 { return l_cinterval(a) == b; }
758inline bool operator!= (const l_cinterval & a, const cinterval & b) noexcept
759 { return a != l_cinterval(b); }
760inline bool operator!= (const cinterval & a, const l_cinterval & b) noexcept
761 { return l_cinterval(a) != b; }
762
763
764// ---- Set Operators ----
765inline 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
775inline bool operator >(const l_cinterval & a, const l_cinterval & b) noexcept
776 { return b < a; }
777
778inline 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
788inline bool operator >= (const l_cinterval & a, const l_cinterval & b) noexcept
789 { return b <= a; }
790
791// lCI <--> R
792
793inline bool operator <(const real & a, const l_cinterval & b) noexcept
794 { return l_cinterval(a) < b; }
795inline bool operator >(const real & a, const l_cinterval & b) noexcept
796 { return l_cinterval(a) > b; }
797inline bool operator <=(const real & a, const l_cinterval & b) noexcept
798 { return l_cinterval(a) <= b; }
799inline bool operator >=(const real & a, const l_cinterval & b) noexcept
800 { return l_cinterval(a) >= b; }
801
802inline bool operator <(const l_cinterval & a, const real & b) noexcept
803 { return a < l_cinterval(b); }
804inline bool operator >(const l_cinterval & a, const real & b) noexcept
805 { return a > l_cinterval(b); }
806inline bool operator <=(const l_cinterval & a, const real & b) noexcept
807 { return a <= l_cinterval(b); }
808inline bool operator >=(const l_cinterval & a, const real & b) noexcept
809 { return a >= l_cinterval(b); }
810
811// lCI <--> LR
812
813inline bool operator <(const l_real & a, const l_cinterval & b) noexcept
814 { return l_cinterval(a) < b; }
815inline bool operator >(const l_real & a, const l_cinterval & b) noexcept
816 { return l_cinterval(a) > b; }
817inline bool operator <=(const l_real & a, const l_cinterval & b) noexcept
818 { return l_cinterval(a) <= b; }
819inline bool operator >=(const l_real & a, const l_cinterval & b) noexcept
820 { return l_cinterval(a) >= b; }
821
822inline bool operator <(const l_cinterval & a, const l_real & b) noexcept
823 { return a < l_cinterval(b); }
824inline bool operator >(const l_cinterval & a, const l_real & b) noexcept
825 { return a > l_cinterval(b); }
826inline bool operator <=(const l_cinterval & a, const l_real & b) noexcept
827 { return a <= l_cinterval(b); }
828inline bool operator >=(const l_cinterval & a, const l_real & b) noexcept
829 { return a >= l_cinterval(b); }
830
831// LCI <--> I
832
833inline bool operator <(const interval & a, const l_cinterval & b) noexcept
834 { return l_cinterval(a) < b; }
835inline bool operator >(const interval & a, const l_cinterval & b) noexcept
836 { return l_cinterval(a) > b; }
837inline bool operator <=(const interval & a, const l_cinterval & b) noexcept
838 { return l_cinterval(a) <= b; }
839inline bool operator >=(const interval & a, const l_cinterval & b) noexcept
840 { return l_cinterval(a) >= b; }
841
842inline bool operator <(const l_cinterval & a, const interval & b) noexcept
843 { return a < l_cinterval(b); }
844inline bool operator >(const l_cinterval & a, const interval & b) noexcept
845 { return a > l_cinterval(b); }
846inline bool operator <=(const l_cinterval & a, const interval & b) noexcept
847 { return a <= l_cinterval(b); }
848inline bool operator >=(const l_cinterval & a, const interval & b) noexcept
849 { return a >= l_cinterval(b); }
850
851// LCI <--> LI
852
853inline bool operator <(const l_interval & a, const l_cinterval & b) noexcept
854 { return l_cinterval(a) < b; }
855inline bool operator >(const l_interval & a, const l_cinterval & b) noexcept
856 { return l_cinterval(a) > b; }
857inline bool operator <=(const l_interval & a, const l_cinterval & b) noexcept
858 { return l_cinterval(a) <= b; }
859inline bool operator >=(const l_interval & a, const l_cinterval & b) noexcept
860 { return l_cinterval(a) >= b; }
861
862inline bool operator <(const l_cinterval & a, const l_interval & b) noexcept
863 { return a < l_cinterval(b); }
864inline bool operator >(const l_cinterval & a, const l_interval & b) noexcept
865 { return a > l_cinterval(b); }
866inline bool operator <=(const l_cinterval & a, const l_interval & b) noexcept
867 { return a <= l_cinterval(b); }
868inline bool operator >=(const l_cinterval & a, const l_interval & b) noexcept
869 { return a >= l_cinterval(b); }
870
871// LCI <--> C
872
873inline bool operator <(const complex & a, const l_cinterval & b) noexcept
874 { return l_cinterval(a) < b; }
875inline bool operator >(const complex & a, const l_cinterval & b) noexcept
876 { return l_cinterval(a) > b; }
877inline bool operator <=(const complex & a, const l_cinterval & b) noexcept
878 { return l_cinterval(a) <= b; }
879inline bool operator >=(const complex & a, const l_cinterval & b) noexcept
880 { return l_cinterval(a) >= b; }
881
882inline bool operator <(const l_cinterval & a, const complex & b) noexcept
883 { return a < l_cinterval(b); }
884inline bool operator >(const l_cinterval & a, const complex & b) noexcept
885 { return a > l_cinterval(b); }
886inline bool operator <=(const l_cinterval & a, const complex & b) noexcept
887 { return a <= l_cinterval(b); }
888inline bool operator >=(const l_cinterval & a, const complex & b) noexcept
889 { return a >= l_cinterval(b); }
890
891// LCI <--> LC
892
893inline bool operator <(const l_complex & a, const l_cinterval & b) noexcept
894 { return l_cinterval(a) < b; }
895inline bool operator >(const l_complex & a, const l_cinterval & b) noexcept
896 { return l_cinterval(a) > b; }
897inline bool operator <=(const l_complex & a, const l_cinterval & b) noexcept
898 { return l_cinterval(a) <= b; }
899inline bool operator >=(const l_complex & a, const l_cinterval & b) noexcept
900 { return l_cinterval(a) >= b; }
901
902inline bool operator <(const l_cinterval & a, const l_complex & b) noexcept
903 { return a < l_cinterval(b); }
904inline bool operator >(const l_cinterval & a, const l_complex & b) noexcept
905 { return a > l_cinterval(b); }
906inline bool operator <=(const l_cinterval & a, const l_complex & b) noexcept
907 { return a <= l_cinterval(b); }
908inline bool operator >=(const l_cinterval & a, const l_complex & b) noexcept
909 { return a >= l_cinterval(b); }
910
911// LCI <--> CI
912
913inline bool operator <(const cinterval & a, const l_cinterval & b) noexcept
914 { return l_cinterval(a) < b; }
915inline bool operator >(const cinterval & a, const l_cinterval & b) noexcept
916 { return l_cinterval(a) > b; }
917inline bool operator <=(const cinterval & a, const l_cinterval & b) noexcept
918 { return l_cinterval(a) <= b; }
919inline bool operator >=(const cinterval & a, const l_cinterval & b) noexcept
920 { return l_cinterval(a) >= b; }
921
922inline bool operator <(const l_cinterval & a, const cinterval & b) noexcept
923 { return a < l_cinterval(b); }
924inline bool operator >(const l_cinterval & a, const cinterval & b) noexcept
925 { return a > l_cinterval(b); }
926inline bool operator <=(const l_cinterval & a, const cinterval & b) noexcept
927 { return a <= l_cinterval(b); }
928inline bool operator >=(const l_cinterval & a, const cinterval & b) noexcept
929 { return a >= l_cinterval(b); }
930
931
932// ---- Others -------------------------------------------
933
934inline l_complex Inf(const l_cinterval & a) noexcept
935 { return l_complex(Inf(a.re),Inf(a.im)); }
936inline l_complex Sup(const l_cinterval & a) noexcept
937 { return l_complex(Sup(a.re),Sup(a.im)); }
938
939inline 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
951inline 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
963inline 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
975inline 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
987inline 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
999inline 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
1011inline 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
1023inline 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
1036inline 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
1044inline 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
1052inline 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
1060inline 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
1068inline 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
1076inline 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
1084inline 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
1092inline 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
1101inline l_cinterval conj(const l_cinterval & a) noexcept
1102{ return l_cinterval(a.re,-a.im); }
1103
1104inline l_complex mid(const l_cinterval &a) noexcept
1105{ return l_complex(mid(a.re), mid(a.im)); }
1106
1107inline l_complex diam(const l_cinterval &a) noexcept
1108{ return l_complex(diam(a.re),diam(a.im)); }
1109
1110inline 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
1117inline 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
1131inline 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
The Data Type cdotprecision.
Definition cdot.hpp:61
The Data Type cidotprecision.
Definition cidot.hpp:58
The Scalar Type cinterval.
Definition cinterval.hpp:55
The Scalar Type complex.
Definition complex.hpp:50
The Data Type dotprecision.
Definition dot.hpp:112
The Data Type idotprecision.
Definition idot.hpp:48
The Scalar Type interval.
Definition interval.hpp:55
The Multiple-Precision Data Type l_cinterval.
friend l_complex Inf(const l_cinterval &) noexcept
Returns the infimum of an interval.
friend l_complex Sup(const l_cinterval &) noexcept
Returns the supremum of an interval.
l_cinterval(void) noexcept
Constructor of class l_cinterval.
The Multiple-Precision Data Type l_complex.
Definition l_complex.hpp:46
The Multiple-Precision Data Type l_interval.
The Multiple-Precision Data Type l_real.
Definition l_real.hpp:78
The Scalar Type real.
Definition real.hpp:114
The namespace cxsc, providing all functionality of the class library C-XSC.
Definition cdot.cpp:29
cdotprecision & operator+=(cdotprecision &cd, const l_complex &lc) noexcept
Implementation of standard algebraic addition and allocation operation.
Definition cdot.inl:251
civector operator/(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of division operation.
Definition cimatrix.inl:730
cvector diam(const cimatrix_subv &mv) noexcept
Returns the diameter of the matrix.
Definition cimatrix.inl:738
cimatrix & operator*=(cimatrix &m, const cinterval &c) noexcept
Implementation of multiplication and allocation operation.
void times2pown(cinterval &x, int n) noexcept
Fast multiplication of reference parameter [z] with .
Definition cimath.cpp:2059
cvector mid(const cimatrix_subv &mv) noexcept
Returns the middle of the matrix.
Definition cimatrix.inl:739
civector operator*(const cimatrix_subv &rv, const cinterval &s) noexcept
Implementation of multiplication operation.
Definition cimatrix.inl:731
cimatrix & operator/=(cimatrix &m, const cinterval &c) noexcept
Implementation of division and allocation operation.