C-XSC - A C++ Class Library for Extended Scientific Computing  2.5.4
cidot.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: cidot.inl,v 1.28 2014/01/30 17:23:43 cxsc Exp $ */
25 
26 namespace cxsc {
27 inline cidotprecision _cidotprecision(const complex &,const complex &) noexcept;
28 inline cidotprecision _cidotprecision(const complex &,const real &) noexcept;
29 inline cidotprecision _cidotprecision(const real &,const complex &) noexcept;
30 inline cidotprecision _cidotprecision(const interval &,const interval &) noexcept;
31 inline cidotprecision _cidotprecision(const interval &,const real &) noexcept;
32 inline cidotprecision _cidotprecision(const real &,const interval &) noexcept;
33 inline cidotprecision _cidotprecision(const real &) noexcept;
34 inline cidotprecision _cidotprecision(const complex &) noexcept;
35 inline cidotprecision _cidotprecision(const interval &) noexcept;
36 inline cidotprecision _cidotprecision(const cinterval &) noexcept;
37 
38 inline cidotprecision _cidotprecision(const idotprecision &,const idotprecision &) noexcept;
39 inline cidotprecision _cidotprecision(const cdotprecision &,const cdotprecision &);
40 inline cidotprecision _cidotprecision(const idotprecision &,const dotprecision &) noexcept;
41 inline cidotprecision _cidotprecision(const cdotprecision &,const dotprecision &);
42 inline cidotprecision _cidotprecision(const dotprecision &,const idotprecision &) noexcept;
43 inline cidotprecision _cidotprecision(const dotprecision &,const cdotprecision&);
44 inline cidotprecision _cidotprecision(const cdotprecision &) noexcept;
45 inline cidotprecision _cidotprecision(const idotprecision &) noexcept;
46 inline cidotprecision _cidotprecision(const dotprecision &) noexcept;
47 
48 inline cidotprecision::cidotprecision(const real & a) noexcept
49  : reinf(a), resup(reinf),
50  iminf(0), imsup(iminf), k(0)
51 {
52 }
53 
54 inline cidotprecision::cidotprecision(const dotprecision & a) noexcept
55  : reinf(a), resup(reinf),
56  iminf(0), imsup(iminf)
57 {
58  set_k(0);
59 }
60 
61 inline cidotprecision::cidotprecision(const complex & a) noexcept
62  : reinf(Re(a)), resup(reinf),
63  iminf(Im(a)), imsup(iminf), k(0)
64 {
65 }
66 
68  : reinf(Re(a)), resup(reinf),
69  iminf(Im(a)), imsup(iminf)
70 {
71  set_k(0);
72 }
73 
74 inline cidotprecision::cidotprecision(const interval & a) noexcept
75  : reinf(Inf(a)), resup(Sup(a)),
76  iminf(0), imsup(iminf), k(0)
77 {
78 }
79 
81  : reinf(Inf(a)), resup(Sup(a)),
82  iminf(0), imsup(iminf)
83 {
84  set_k(0);
85 }
86 
87 inline cidotprecision::cidotprecision(const cinterval & a) noexcept
88  : reinf(InfRe(a)), resup(SupRe(a)),
89  iminf(InfIm(a)), imsup(SupIm(a)), k(0)
90 {
91 }
92 
94  : reinf(a.reinf), resup(a.resup),
95  iminf(a.iminf), imsup(a.imsup)
96 {
97  set_k(a.get_k());
98 }
99 
100 inline cidotprecision::cidotprecision(const idotprecision & a, const idotprecision & b) noexcept
101  : reinf(Inf(a)), resup(Sup(a)),
102  iminf(Inf(b)), imsup(Sup(b))
103 {
104  set_k(0);
105 }
106 
107 // ---- Typwandlungen ----
113 inline cidotprecision _cidotprecision(const complex & a,const complex & b) noexcept
114 {
115  return _cidotprecision(_cinterval(a,b));
116 }
117 
123 inline cidotprecision _cidotprecision(const complex & a,const real & b) noexcept
124 {
125  return _cidotprecision(_cinterval(a,b));
126 }
127 
133 inline cidotprecision _cidotprecision(const real & a,const complex & b) noexcept
134 {
135  return _cidotprecision(_cinterval(a,b));
136 }
137 
143 inline cidotprecision _cidotprecision(const interval & a,const interval & b) noexcept
144 {
145  return _cidotprecision(_cinterval(a,b));
146 }
147 
153 inline cidotprecision _cidotprecision(const interval & a,const real &b) noexcept
154 {
155  return _cidotprecision(_cinterval(a,b));
156 }
157 
163 inline cidotprecision _cidotprecision(const real & a,const interval & b) noexcept
164 {
165  return _cidotprecision(_cinterval(a,b));
166 }
167 
173 inline cidotprecision _cidotprecision(const real & a) noexcept
174 {
175  return _cidotprecision(_cinterval(a));
176 }
177 
183 inline cidotprecision _cidotprecision(const complex & a) noexcept
184 {
185  return _cidotprecision(_cinterval(a));
186 }
187 
193 inline cidotprecision _cidotprecision(const interval & a) noexcept
194 {
195  return _cidotprecision(_cinterval(a));
196 }
197 
203 inline cidotprecision _cidotprecision(const cinterval & a) noexcept
204 {
205  cidotprecision tmp;
206  tmp.reinf=Inf(Re(a));
207  tmp.resup=Sup(Re(a));
208  tmp.iminf=Inf(Im(a));
209  tmp.imsup=Sup(Im(a));
210  return tmp;
211 }
212 
218 inline cidotprecision _cidotprecision(const idotprecision & a,const idotprecision & b) noexcept
219 {
220  cidotprecision tmp;
221  tmp.reinf=Inf(a);
222  tmp.resup=Sup(a);
223  tmp.iminf=Inf(b);
224  tmp.imsup=Sup(b);
225  return tmp;
226 }
227 
234 {
235  cidotprecision tmp;
236  tmp.reinf=Re(a);
237  tmp.resup=Re(b);
238  tmp.iminf=Im(a);
239  tmp.imsup=Im(b);
240  if(tmp.reinf>tmp.resup || tmp.iminf>tmp.imsup)
241  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision _cidotprecision(const cdotprecision & a,const cdotprecision & b)"));
242  return tmp;
243 }
244 
250 inline cidotprecision _cidotprecision(const idotprecision & a,const dotprecision & b) noexcept
251 {
252  cidotprecision tmp;
253  tmp.reinf=Inf(a);
254  tmp.resup=Sup(a);
255  tmp.iminf=tmp.imsup=b;
256  return tmp;
257 }
258 
265 {
266  cidotprecision tmp;
267  tmp.reinf=Re(a);
268  tmp.iminf=Re(a);
269  tmp.resup=b;
270  tmp.imsup=0.0;
271  if(tmp.reinf>tmp.resup || tmp.iminf>tmp.imsup)
272  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision _cidotprecision(const cdotprecision & a,const dotprecision & b)"));
273  return tmp;
274 }
275 
281 inline cidotprecision _cidotprecision(const dotprecision & a,const idotprecision & b) noexcept
282 {
283  cidotprecision tmp;
284  tmp.reinf=tmp.resup=a;
285  tmp.iminf=Inf(b);
286  tmp.imsup=Sup(b);
287  return tmp;
288 }
289 
296 {
297  cidotprecision tmp;
298  tmp.reinf=a;
299  tmp.iminf=0.0;
300  tmp.resup=Re(b);
301  tmp.imsup=Im(b);
302  if(tmp.reinf>tmp.resup || tmp.iminf>tmp.imsup)
303  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision _cidotprecision(const dotprecision & a,const cdotprecision & b)"));
304  return tmp;
305 }
306 
312 inline cidotprecision _cidotprecision(const cdotprecision & a) noexcept
313 {
314  cidotprecision tmp;
315  tmp.reinf=tmp.resup=Re(a);
316  tmp.iminf=tmp.imsup=Im(a);
317  return tmp;
318 }
319 
325 inline cidotprecision _cidotprecision(const idotprecision & a) noexcept
326 {
327  cidotprecision tmp;
328  tmp.reinf=Inf(a);
329  tmp.resup=Sup(a);
330  tmp.iminf=tmp.imsup=0.0;
331  return tmp;
332 }
333 
339 inline cidotprecision _cidotprecision(const dotprecision & a) noexcept
340 {
341  cidotprecision tmp;
342  tmp.reinf=tmp.resup=a;
343  tmp.iminf=tmp.imsup=0.0;
344  return tmp;
345 }
346 
352 inline cidotprecision _unchecked_cidotprecision(const complex & a,const complex & b) noexcept
353 {
354  cidotprecision tmp;
355  tmp.reinf=Re(a);
356  tmp.resup=Re(b);
357  tmp.iminf=Im(a);
358  tmp.imsup=Im(b);
359  return tmp;
360 }
361 
367 inline cidotprecision _unchecked_cidotprecision(const complex & a,const real & b) noexcept
368 {
369  cidotprecision tmp;
370  tmp.reinf=Re(a);
371  tmp.iminf=Re(a);
372  tmp.resup=b;
373  tmp.imsup=0.0;
374  return tmp;
375 }
376 
382 inline cidotprecision _unchecked_cidotprecision(const real & a,const complex & b) noexcept
383 {
384  cidotprecision tmp;
385  tmp.reinf=a;
386  tmp.iminf=0.0;
387  tmp.resup=Re(b);
388  tmp.imsup=Im(b);
389  return tmp;
390 }
391 
398 {
399  cidotprecision tmp;
400  tmp.reinf=Re(a);
401  tmp.resup=Re(b);
402  tmp.iminf=Im(a);
403  tmp.imsup=Im(b);
404  return tmp;
405 }
406 
413 {
414  cidotprecision tmp;
415  tmp.reinf=Re(a);
416  tmp.iminf=Re(a);
417  tmp.resup=b;
418  tmp.imsup=0.0;
419  return tmp;
420 }
421 
428 {
429  cidotprecision tmp;
430  tmp.reinf=a;
431  tmp.iminf=0.0;
432  tmp.resup=Re(b);
433  tmp.imsup=Im(b);
434  return tmp;
435 }
436 
437 
438 
439 // ---- Standardfunkt ---- (arithmetische Operatoren)
440 inline cidotprecision operator -(cidotprecision a) noexcept
441 {
442  dotprecision save=-a.reinf;
443  a.reinf=-a.resup;
444  a.resup=save;
445 
446  save=-a.iminf;
447  a.iminf=-a.imsup;
448  a.imsup=save;
449 
450  return a;
451 }
452 
453 inline cidotprecision operator +(const cidotprecision &a) noexcept
454 {
455  return a;
456 }
457 
458 inline cidotprecision operator +(const cidotprecision & a,const cidotprecision & b) noexcept
459 {
460  cidotprecision tmp(a);
461  tmp.reinf+=b.reinf;
462  tmp.resup+=b.resup;
463  tmp.iminf+=b.iminf;
464  tmp.imsup+=b.imsup;
465  return tmp;
466 }
467 
468 inline cidotprecision operator -(const cidotprecision & a,const cidotprecision & b) noexcept
469 {
470  cidotprecision tmp(a);
471  tmp.reinf-=b.resup;
472  tmp.resup-=b.reinf;
473  tmp.iminf-=b.imsup;
474  tmp.imsup-=b.iminf;
475  return tmp;
476 }
477 
478 inline cidotprecision operator |(const cidotprecision & a,const cidotprecision & b) noexcept
479 {
480  cidotprecision tmp(a);
481  if(tmp.reinf>b.reinf)
482  tmp.reinf=b.reinf;
483  if(tmp.iminf>b.iminf)
484  tmp.iminf=b.iminf;
485  if(tmp.resup<b.resup)
486  tmp.resup=b.resup;
487  if(tmp.imsup<b.imsup)
488  tmp.imsup=b.imsup;
489  return tmp;
490 }
491 
492 inline cidotprecision operator &(const cidotprecision & a,const cidotprecision & b)
493 {
494  cidotprecision tmp(a);
495  if(tmp.reinf<b.reinf)
496  tmp.reinf=b.reinf;
497  if(tmp.iminf<b.iminf)
498  tmp.iminf=b.iminf;
499  if(tmp.resup>b.resup)
500  tmp.resup=b.resup;
501  if(tmp.imsup>b.imsup)
502  tmp.imsup=b.imsup;
503 
504  if (tmp.reinf >tmp.resup || tmp.iminf > tmp.imsup)
505  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision operator &(const cidotprecision & a,const cidotprecision & b)"));
506 
507  return tmp;
508 }
509 
510 inline cidotprecision & operator +=(cidotprecision & a, const cidotprecision & b) noexcept
511 {
512  a.reinf+=b.reinf;
513  a.resup+=b.resup;
514  a.iminf+=b.iminf;
515  a.imsup+=b.imsup;
516  return a;
517 }
518 
519 inline cidotprecision & operator -=(cidotprecision & a, const cidotprecision & b) noexcept
520 {
521  a.reinf-=b.resup;
522  a.resup-=b.reinf;
523  a.iminf-=b.imsup;
524  a.imsup-=b.iminf;
525  return a;
526 }
527 
528 inline cidotprecision & operator |=(cidotprecision & a, const cidotprecision & b) noexcept
529 {
530  if(a.reinf>b.reinf)
531  a.reinf=b.reinf;
532  if(a.resup<b.resup)
533  a.resup=b.resup;
534  if(a.iminf>b.iminf)
535  a.iminf=b.iminf;
536  if(a.imsup<b.imsup)
537  a.imsup=b.imsup;
538  return a;
539 }
540 
541 inline cidotprecision & operator &=(cidotprecision & a, const cidotprecision & b)
542 {
543  if(a.reinf<b.reinf)
544  a.reinf=b.reinf;
545  if(a.resup>b.resup)
546  a.resup=b.resup;
547  if(a.iminf<b.iminf)
548  a.iminf=b.iminf;
549  if(a.imsup>b.imsup)
550  a.imsup=b.imsup;
551 
552  if (a.reinf >a.resup || a.iminf > a.imsup)
553  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision operator &=(cidotprecision & a,const cidotprecision & b)"));
554 
555  return a;
556 }
557 
558 
559 // CID-R
560 
561 inline cidotprecision operator +(const cidotprecision & a,const real & b) noexcept
562 {
563  cidotprecision tmp(a);
564  return tmp+=b;
565 }
566 
567 inline cidotprecision operator +(const real & a,const cidotprecision & b) noexcept
568 {
569  cidotprecision tmp(b);
570  return tmp+=a;
571 }
572 
573 inline cidotprecision operator -(const cidotprecision & a,const real & b) noexcept
574 {
575  cidotprecision tmp(a);
576  return tmp-=b;
577 }
578 
579 inline cidotprecision operator -(const real & a,const cidotprecision & b) noexcept
580 {
581  cidotprecision tmp(-b);
582  return tmp+=a;
583 }
584 
585 inline cidotprecision operator |(const cidotprecision & a,const real & b) noexcept
586 {
587  cidotprecision tmp(a);
588  return tmp|=_cinterval(b);
589 }
590 
591 inline cidotprecision operator |(const real & a,const cidotprecision & b) noexcept
592 {
593  cidotprecision tmp(b);
594  return tmp|=_cinterval(a);
595 }
596 
597 inline cidotprecision operator &(const cidotprecision & a,const real & b)
598 {
599  cidotprecision tmp(a);
600  return tmp&=_cinterval(b);
601 }
602 
603 inline cidotprecision operator &(const real & a,const cidotprecision & b)
604 {
605  cidotprecision tmp(b);
606  return tmp&=_cinterval(a);
607 }
608 
609 inline cidotprecision & operator +=(cidotprecision & a, const real & b) noexcept
610 {
611  a.reinf+=b;
612  a.resup+=b;
613  return a;
614 }
615 
616 inline cidotprecision & operator -=(cidotprecision & a, const real & b) noexcept
617 {
618  a.reinf-=b;
619  a.resup-=b;
620  return a;
621 }
622 
623 inline cidotprecision & operator |=(cidotprecision & a, const real & b) noexcept
624 {
625  return a|=_cinterval(b);
626 }
627 
628 inline cidotprecision & operator &=(cidotprecision & a, const real & b)
629 {
630  return a&=_cinterval(b);
631 }
632 
633 // CID-C
634 
635 inline cidotprecision operator +(const cidotprecision & a,const complex & b) noexcept
636 {
637  cidotprecision tmp(a);
638  return tmp+=b;
639 }
640 
641 inline cidotprecision operator +(const complex & a,const cidotprecision & b) noexcept
642 {
643  cidotprecision tmp(b);
644  return tmp+=a;
645 }
646 
647 inline cidotprecision operator -(const cidotprecision & a,const complex & b) noexcept
648 {
649  cidotprecision tmp(a);
650  return tmp-=b;
651 }
652 
653 inline cidotprecision operator -(const complex & a,const cidotprecision & b) noexcept
654 {
655  cidotprecision tmp(-b);
656  return tmp+=a;
657 }
658 
659 inline cidotprecision operator |(const cidotprecision & a,const complex & b) noexcept
660 {
661  cidotprecision tmp(a);
662  return tmp|=_cinterval(b);
663 }
664 
665 inline cidotprecision operator |(const complex & a,const cidotprecision & b) noexcept
666 {
667  cidotprecision tmp(b);
668  return tmp|=_cinterval(a);
669 }
670 
671 inline cidotprecision operator &(const cidotprecision & a,const complex & b)
672 {
673  cidotprecision tmp(a);
674  return tmp&=_cinterval(b);
675 }
676 
677 inline cidotprecision operator &(const complex & a,const cidotprecision & b)
678 {
679  cidotprecision tmp(b);
680  return tmp&=_cinterval(a);
681 }
682 
683 inline cidotprecision & operator +=(cidotprecision & a, const complex & b) noexcept
684 {
685  a.reinf+=Re(b);
686  a.resup+=Re(b);
687  a.iminf+=Im(b);
688  a.imsup+=Im(b);
689  return a;
690 }
691 
692 inline cidotprecision & operator -=(cidotprecision & a, const complex & b) noexcept
693 {
694  a.reinf-=Re(b);
695  a.resup-=Re(b);
696  a.iminf-=Im(b);
697  a.iminf-=Im(b);
698  return a;
699 }
700 
701 inline cidotprecision & operator |=(cidotprecision & a, const complex & b) noexcept
702 {
703  return a|=_cinterval(b);
704 }
705 
706 inline cidotprecision & operator &=(cidotprecision & a, const complex & b)
707 {
708  return a&=_cinterval(b);
709 }
710 
711 // CID-I
712 
713 inline cidotprecision operator +(const cidotprecision & a,const interval & b) noexcept
714 {
715  cidotprecision tmp(a);
716  return tmp+=b;
717 }
718 
719 inline cidotprecision operator +(const interval & a,const cidotprecision & b) noexcept
720 {
721  cidotprecision tmp(b);
722  return tmp+=a;
723 }
724 
725 inline cidotprecision operator -(const cidotprecision & a,const interval & b) noexcept
726 {
727  cidotprecision tmp(a);
728  return tmp-=b;
729 }
730 
731 inline cidotprecision operator -(const interval & a,const cidotprecision & b) noexcept
732 {
733  cidotprecision tmp(-b);
734  return tmp+=a;
735 }
736 
737 inline cidotprecision operator |(const cidotprecision & a,const interval & b) noexcept
738 {
739  cidotprecision tmp(a);
740  return tmp|=_cinterval(b);
741 }
742 
743 inline cidotprecision operator |(const interval & a,const cidotprecision & b) noexcept
744 {
745  cidotprecision tmp(b);
746  return tmp|=_cinterval(a);
747 }
748 
749 inline cidotprecision operator &(const cidotprecision & a,const interval & b)
750 {
751  cidotprecision tmp(a);
752  return tmp&=_cinterval(b);
753 }
754 
755 inline cidotprecision operator &(const interval & a,const cidotprecision & b)
756 {
757  cidotprecision tmp(b);
758  return tmp&=_cinterval(a);
759 }
760 
761 inline cidotprecision & operator +=(cidotprecision & a, const interval & b) noexcept
762 {
763  a.reinf+=Inf(b);
764  a.resup+=Sup(b);
765  return a;
766 }
767 
768 inline cidotprecision & operator -=(cidotprecision & a, const interval & b) noexcept
769 {
770  a.reinf-=Sup(b);
771  a.resup-=Inf(b);
772  return a;
773 }
774 
775 inline cidotprecision & operator |=(cidotprecision & a, const interval & b) noexcept
776 {
777  return a|=_cinterval(b);
778 }
779 
780 inline cidotprecision & operator &=(cidotprecision & a, const interval & b)
781 {
782  return a&=_cinterval(b);
783 }
784 
785 // CID-CI
786 
787 inline cidotprecision operator +(const cidotprecision & a,const cinterval & b) noexcept
788 {
789  cidotprecision tmp(a);
790  return tmp+=b;
791 }
792 
793 inline cidotprecision operator +(const cinterval & a,const cidotprecision & b) noexcept
794 {
795  cidotprecision tmp(b);
796  return tmp+=a;
797 }
798 
799 inline cidotprecision operator -(const cidotprecision & a,const cinterval & b) noexcept
800 {
801  cidotprecision tmp(a);
802  return tmp-=b;
803 }
804 
805 inline cidotprecision operator -(const cinterval & a,const cidotprecision & b) noexcept
806 {
807  cidotprecision tmp(-b);
808  return tmp+=a;
809 }
810 
811 inline cidotprecision operator |(const cidotprecision & a,const cinterval & b) noexcept
812 {
813  cidotprecision tmp(a);
814  return tmp|=b;
815 }
816 
817 inline cidotprecision operator |(const cinterval & a,const cidotprecision & b) noexcept
818 {
819  cidotprecision tmp(b);
820  return tmp|=a;
821 }
822 
823 inline cidotprecision operator &(const cidotprecision & a,const cinterval & b)
824 {
825  cidotprecision tmp(a);
826  return tmp&=b;
827 }
828 
829 inline cidotprecision operator &(const cinterval & a,const cidotprecision & b)
830 {
831  cidotprecision tmp(b);
832  return tmp&=a;
833 }
834 
835 inline cidotprecision & operator +=(cidotprecision & a, const cinterval & b) noexcept
836 {
837  a.reinf+=Inf(Re(b));
838  a.resup+=Sup(Re(b));
839  a.iminf+=Inf(Im(b));
840  a.imsup+=Sup(Im(b));
841  return a;
842 }
843 
844 inline cidotprecision & operator -=(cidotprecision & a, const cinterval & b) noexcept
845 {
846  a.reinf-=Sup(Re(b));
847  a.resup-=Inf(Re(b));
848  a.iminf-=Sup(Im(b));
849  a.imsup-=Inf(Im(b));
850  return a;
851 }
852 
853 inline cidotprecision & operator |=(cidotprecision & a, const cinterval & b) noexcept
854 {
855  if(Sup(Re(b))>a.resup)
856  a.resup=Sup(Re(b));
857  if(Inf(Re(b))<a.reinf)
858  a.reinf=Inf(Re(b));
859  if(Sup(Im(b))>a.imsup)
860  a.imsup=Sup(Im(b));
861  if(Inf(Im(b))<a.iminf)
862  a.iminf=Inf(Im(b));
863  return a;
864 }
865 
866 inline cidotprecision & operator &=(cidotprecision & a, const cinterval & b)
867 {
868  if(Sup(Re(b))<a.resup)
869  a.resup=Sup(Re(b));
870  if(Inf(Re(b))>a.reinf)
871  a.reinf=Inf(Re(b));
872  if(Sup(Im(b))<a.imsup)
873  a.imsup=Sup(Im(b));
874  if(Inf(Im(b))>a.iminf)
875  a.iminf=Inf(Im(b));
876 
877  if (a.reinf >a.resup || a.iminf > a.imsup)
878  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision operator &=(cidotprecision & a,const cinterval & b)"));
879 
880  return a;
881 }
882 
883 // CID-D
884 
885 inline cidotprecision operator +(const cidotprecision & a,const dotprecision & b) noexcept
886 {
887  cidotprecision tmp(a);
888  return tmp+=b;
889 }
890 
891 inline cidotprecision operator +(const dotprecision & a,const cidotprecision & b) noexcept
892 {
893  cidotprecision tmp(b);
894  return tmp+=a;
895 }
896 
897 inline cidotprecision operator -(const cidotprecision & a,const dotprecision & b) noexcept
898 {
899  cidotprecision tmp(a);
900  return tmp-=b;
901 }
902 
903 inline cidotprecision operator -(const dotprecision & a,const cidotprecision & b) noexcept
904 {
905  cidotprecision tmp(-b);
906  return tmp+=a;
907 }
908 
909 inline cidotprecision operator |(const cidotprecision & a,const dotprecision & b) noexcept
910 {
911  cidotprecision tmp(a);
912  return tmp|=b;
913 }
914 
915 inline cidotprecision operator |(const dotprecision & a,const cidotprecision & b) noexcept
916 {
917  cidotprecision tmp(b);
918  return tmp|=a;
919 }
920 
921 inline cidotprecision operator &(const cidotprecision & a,const dotprecision & b)
922 {
923  cidotprecision tmp(a);
924  return tmp&=b;
925 }
926 
927 inline cidotprecision operator &(const dotprecision & a,const cidotprecision & b)
928 {
929  cidotprecision tmp(b);
930  return tmp&=a;
931 }
932 
933 inline cidotprecision & operator +=(cidotprecision & a, const dotprecision & b) noexcept
934 {
935  a.reinf+=b;
936  a.resup+=b;
937  return a;
938 }
939 
940 inline cidotprecision & operator -=(cidotprecision & a, const dotprecision & b) noexcept
941 {
942  a.reinf-=b;
943  a.resup-=b;
944  return a;
945 }
946 
947 inline cidotprecision & operator |=(cidotprecision & a, const dotprecision & b) noexcept
948 {
949  if(b<a.reinf)
950  a.reinf=b;
951  if(b>a.resup)
952  a.resup=b;
953  if(0.<a.iminf)
954  a.reinf=0.;
955  if(0.>a.imsup)
956  a.imsup=0.;
957  return a;
958 }
959 
960 inline cidotprecision & operator &=(cidotprecision & a, const dotprecision & b)
961 {
962  if(b>a.reinf)
963  a.reinf=b;
964  if(b<a.resup)
965  a.resup=b;
966  if(0.>a.iminf)
967  a.reinf=0.;
968  if(0.<a.imsup)
969  a.imsup=0.;
970 
971  if (a.reinf >a.resup || a.iminf > a.imsup)
972  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision operator &=(cidotprecision & a,const dotprecision & b)"));
973 
974  return a;
975 }
976 
977 // CID-CD
978 
979 inline cidotprecision operator +(const cidotprecision & a,const cdotprecision & b) noexcept
980 {
981  cidotprecision tmp(a);
982  return tmp+=b;
983 }
984 
985 inline cidotprecision operator +(const cdotprecision & a,const cidotprecision & b) noexcept
986 {
987  cidotprecision tmp(b);
988  return tmp+=a;
989 }
990 
991 inline cidotprecision operator -(const cidotprecision & a,const cdotprecision & b) noexcept
992 {
993  cidotprecision tmp(a);
994  return tmp-=b;
995 }
996 
997 inline cidotprecision operator -(const cdotprecision & a,const cidotprecision & b) noexcept
998 {
999  cidotprecision tmp(-b);
1000  return tmp+=a;
1001 }
1002 
1003 inline cidotprecision operator |(const cidotprecision & a,const cdotprecision & b) noexcept
1004 {
1005  cidotprecision tmp(a);
1006  return tmp|=b;
1007 }
1008 
1009 inline cidotprecision operator |(const cdotprecision & a,const cidotprecision & b) noexcept
1010 {
1011  cidotprecision tmp(b);
1012  return tmp|=a;
1013 }
1014 
1015 inline cidotprecision operator &(const cidotprecision & a,const cdotprecision & b)
1016 {
1017  cidotprecision tmp(a);
1018  return tmp&=b;
1019 }
1020 
1021 inline cidotprecision operator &(const cdotprecision & a,const cidotprecision & b)
1022 {
1023  cidotprecision tmp(b);
1024  return tmp&=a;
1025 }
1026 
1027 inline cidotprecision & operator +=(cidotprecision & a, const cdotprecision & b) noexcept
1028 {
1029  a.reinf+=Re(b);
1030  a.resup+=Re(b);
1031  a.iminf+=Im(b);
1032  a.imsup+=Im(b);
1033  return a;
1034 }
1035 
1036 inline cidotprecision & operator -=(cidotprecision & a, const cdotprecision & b) noexcept
1037 {
1038  a.reinf-=Re(b);
1039  a.resup-=Re(b);
1040  a.iminf-=Im(b);
1041  a.imsup-=Im(b);
1042  return a;
1043 }
1044 
1045 inline cidotprecision & operator |=(cidotprecision & a, const cdotprecision & b) noexcept
1046 {
1047  if(Re(b)<a.reinf)
1048  a.reinf=Re(b);
1049  if(Re(b)>a.resup)
1050  a.resup=Re(b);
1051  if(Im(b)<a.iminf)
1052  a.reinf=Im(b);
1053  if(Im(b)>a.imsup)
1054  a.imsup=Im(b);
1055  return a;
1056 }
1057 
1058 inline cidotprecision & operator &=(cidotprecision & a, const cdotprecision & b)
1059 {
1060  if(Re(b)>a.reinf)
1061  a.reinf=Re(b);
1062  if(Re(b)<a.resup)
1063  a.resup=Re(b);
1064  if(Im(b)>a.iminf)
1065  a.reinf=Im(b);
1066  if(Im(b)<a.imsup)
1067  a.imsup=Im(b);
1068 
1069  if (a.reinf >a.resup || a.iminf > a.imsup)
1070  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision operator &=(cidotprecision & a,const cdotprecision & b)"));
1071 
1072  return a;
1073 }
1074 
1075 
1076 // CID-ID
1077 
1078 inline cidotprecision operator +(const cidotprecision & a,const idotprecision & b) noexcept
1079 {
1080  cidotprecision tmp(a);
1081  return tmp+=b;
1082 }
1083 
1084 inline cidotprecision operator +(const idotprecision & a,const cidotprecision & b) noexcept
1085 {
1086  cidotprecision tmp(b);
1087  return tmp+=a;
1088 }
1089 
1090 inline cidotprecision operator -(const cidotprecision & a,const idotprecision & b) noexcept
1091 {
1092  cidotprecision tmp(a);
1093  return tmp-=b;
1094 }
1095 
1096 inline cidotprecision operator -(const idotprecision & a,const cidotprecision & b) noexcept
1097 {
1098  cidotprecision tmp(-b);
1099  return tmp+=a;
1100 }
1101 
1102 inline cidotprecision operator |(const cidotprecision & a,const idotprecision & b) noexcept
1103 {
1104  cidotprecision tmp(a);
1105  return tmp|=b;
1106 }
1107 
1108 inline cidotprecision operator |(const idotprecision & a,const cidotprecision & b) noexcept
1109 {
1110  cidotprecision tmp(b);
1111  return tmp|=a;
1112 }
1113 
1114 inline cidotprecision operator &(const cidotprecision & a,const idotprecision & b)
1115 {
1116  cidotprecision tmp(a);
1117  return tmp&=b;
1118 }
1119 
1120 inline cidotprecision operator &(const idotprecision & a,const cidotprecision & b)
1121 {
1122  cidotprecision tmp(b);
1123  return tmp&=a;
1124 }
1125 
1126 inline cidotprecision & operator +=(cidotprecision & a, const idotprecision & b) noexcept
1127 {
1128  a.reinf+=Inf(b);
1129  a.resup+=Sup(b);
1130  return a;
1131 }
1132 
1133 inline cidotprecision & operator -=(cidotprecision & a, const idotprecision & b) noexcept
1134 {
1135  a.reinf-=Sup(b);
1136  a.resup-=Inf(b);
1137  return a;
1138 }
1139 
1140 inline cidotprecision & operator |=(cidotprecision & a, const idotprecision & b) noexcept
1141 {
1142  if(Inf(b)<a.reinf)
1143  a.reinf=Inf(b);
1144  if(Sup(b)>a.resup)
1145  a.resup=Sup(b);
1146  if(0.<a.iminf)
1147  a.reinf=0.;
1148  if(0.>a.imsup)
1149  a.imsup=0.;
1150  return a;
1151 }
1152 
1153 inline cidotprecision & operator &=(cidotprecision & a, const idotprecision & b)
1154 {
1155  if(Inf(b)>a.reinf)
1156  a.reinf=Inf(b);
1157  if(Sup(b)<a.resup)
1158  a.resup=Sup(b);
1159  if(0.>a.iminf)
1160  a.reinf=0.;
1161  if(0.<a.imsup)
1162  a.imsup=0.;
1163 
1164  if (a.reinf >a.resup || a.iminf > a.imsup)
1165  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision operator &=(cidotprecision & a,const idotprecision & b)"));
1166 
1167  return a;
1168 }
1169 
1170 
1171 // ---- Vergleichsop. ----
1172 inline bool operator !(const cidotprecision & a) noexcept
1173 {
1174  return a.reinf<=0. && a.resup>=0. && a.iminf<=0. && a.imsup>=0.;
1175 }
1176 
1177 /*inline cidotprecision::operator void *() const noexcept
1178 {
1179  if(reinf>0. || resup<0. || iminf>0. || imsup<0.)
1180  return (void *)1;
1181 
1182  return (void *)0;
1183 }*/
1184 
1185 inline bool operator ==(const cidotprecision & a,const cidotprecision & b) noexcept
1186 {
1187  return a.reinf==b.reinf && a.resup==b.resup && a.iminf==b.iminf && a.imsup==b.imsup;
1188 }
1189 
1190 inline bool operator !=(const cidotprecision & a,const cidotprecision & b) noexcept
1191 {
1192  return a.reinf!=b.reinf || a.resup!=b.resup || a.iminf!=b.iminf || a.imsup!=b.imsup;
1193 }
1194 
1195 // CID-R
1196 
1197 inline bool operator== (const cidotprecision & a, const real & b) noexcept
1198 {
1199  return a.reinf==b && a.resup==b && a.iminf==0. && a.imsup==0.;
1200 }
1201 
1202 inline bool operator== (const real & a, const cidotprecision & b) noexcept
1203 {
1204  return b.reinf==a && b.resup==a && b.iminf==0. && b.imsup==0.;
1205 }
1206 
1207 inline bool operator!= (const cidotprecision & a, const real & b) noexcept
1208 {
1209  return a.reinf!=b || a.resup!=b || a.iminf!=0. || a.imsup!=0.;
1210 }
1211 
1212 inline bool operator!= (const real & a, const cidotprecision & b) noexcept
1213 {
1214  return b.reinf!=a || b.resup!=a || b.iminf!=0. || b.imsup!=0.;
1215 }
1216 
1217 // CID-C
1218 
1219 inline bool operator== (const cidotprecision & a, const complex & b) noexcept
1220 {
1221  return a.reinf==Re(b) && a.resup==Re(b) && a.iminf==Im(b) && a.imsup==Im(b);
1222 }
1223 
1224 inline bool operator== (const complex & a, const cidotprecision & b) noexcept
1225 {
1226  return b.reinf==Re(a) && b.resup==Re(a) && b.iminf==Im(a) && b.imsup==Im(a);
1227 }
1228 
1229 inline bool operator!= (const cidotprecision & a, const complex & b) noexcept
1230 {
1231  return a.reinf!=Re(b) || a.resup!=Re(b) || a.iminf!=Im(a) || a.imsup!=Im(a);
1232 }
1233 
1234 inline bool operator!= (const complex & a, const cidotprecision & b) noexcept
1235 {
1236  return b.reinf!=Re(a) || b.resup!=Re(a) || b.iminf!=Im(a) || b.imsup!=Im(a);
1237 }
1238 
1239 // CID-I
1240 
1241 inline bool operator== (const cidotprecision & a, const interval & b) noexcept
1242 {
1243  return a.reinf==Inf(b) && a.resup==Sup(b) && a.iminf==0. && a.imsup==0.;
1244 }
1245 
1246 inline bool operator== (const interval & a, const cidotprecision & b) noexcept
1247 {
1248  return b.reinf==Inf(a) && b.resup==Sup(a) && b.iminf==0. && b.imsup==0.;
1249 }
1250 
1251 inline bool operator!= (const cidotprecision & a, const interval & b) noexcept
1252 {
1253  return a.reinf!=Inf(b) || a.resup!=Sup(b) || a.iminf!=0. || a.imsup!=0.;
1254 }
1255 
1256 inline bool operator!= (const interval & a, const cidotprecision & b) noexcept
1257 {
1258  return b.reinf!=Inf(a) || b.resup!=Sup(b) || b.iminf!=0. || b.imsup!=0.;
1259 }
1260 
1261 // CID-CI
1262 
1263 inline bool operator== (const cidotprecision & a, const cinterval & b) noexcept
1264 {
1265  return a.reinf==Inf(Re(b)) && a.resup==Sup(Re(b)) && a.iminf==Inf(Im(b)) && a.imsup==Sup(Im(b));
1266 }
1267 
1268 inline bool operator== (const cinterval & a, const cidotprecision & b) noexcept
1269 {
1270  return b.reinf==Inf(Re(a)) && b.resup==Sup(Re(a)) && b.iminf==Inf(Im(a)) && b.imsup==Sup(Im(a));
1271 }
1272 
1273 inline bool operator!= (const cidotprecision & a, const cinterval & b) noexcept
1274 {
1275  return a.reinf!=Inf(Re(b)) || a.resup!=Sup(Re(b)) || a.iminf!=Inf(Im(a)) || a.imsup!=Sup(Im(a));
1276 }
1277 
1278 inline bool operator!= (const cinterval & a, const cidotprecision & b) noexcept
1279 {
1280  return b.reinf!=Inf(Re(a)) || b.resup!=Sup(Re(b)) || b.iminf!=Inf(Im(a)) || b.imsup!=Sup(Im(a));
1281 }
1282 
1283 // CID-D
1284 
1285 inline bool operator== (const cidotprecision & a, const dotprecision & b) noexcept
1286 {
1287  return a.reinf==b && a.resup==b && a.iminf==0. && a.imsup==0.;
1288 }
1289 
1290 inline bool operator== (const dotprecision & a, const cidotprecision & b) noexcept
1291 {
1292  return b.reinf==a && b.resup==a && b.iminf==0. && b.imsup==0.;
1293 }
1294 
1295 inline bool operator!= (const cidotprecision & a, const dotprecision & b) noexcept
1296 {
1297  return a.reinf!=b || a.resup!=b || a.iminf!=0. || a.imsup!=0.;
1298 }
1299 
1300 inline bool operator!= (const dotprecision & a, const cidotprecision & b) noexcept
1301 {
1302  return b.reinf!=a || b.resup!=b || b.iminf!=0. || b.imsup!=0.;
1303 }
1304 
1305 
1306 // CID-CD
1307 
1308 inline bool operator== (const cidotprecision & a, const cdotprecision & b) noexcept
1309 {
1310  return a.reinf==Re(b) && a.resup==Re(b) && a.iminf==Im(b) && a.imsup==Im(b);
1311 }
1312 
1313 inline bool operator== (const cdotprecision & a, const cidotprecision & b) noexcept
1314 {
1315  return b.reinf==Re(a) && b.resup==Re(a) && b.iminf==Im(a) && b.imsup==Im(a);
1316 }
1317 
1318 inline bool operator!= (const cidotprecision & a, const cdotprecision & b) noexcept
1319 {
1320  return a.reinf!=Re(b) || a.resup!=Re(b) || a.iminf!=Im(a) || a.imsup!=Im(a);
1321 }
1322 
1323 inline bool operator!= (const cdotprecision & a, const cidotprecision & b) noexcept
1324 {
1325  return b.reinf!=Re(a) || b.resup!=Re(b) || b.iminf!=Im(a) || b.imsup!=Im(a);
1326 }
1327 
1328 // CID-ID
1329 
1330 inline bool operator== (const cidotprecision & a, const idotprecision & b) noexcept
1331 {
1332  return a.reinf==Inf(b) && a.resup==Sup(b) && a.iminf==0. && a.imsup==0.;
1333 }
1334 
1335 inline bool operator== (const idotprecision & a, const cidotprecision & b) noexcept
1336 {
1337  return b.reinf==Inf(a) && b.resup==Sup(a) && b.iminf==0. && b.imsup==0.;
1338 }
1339 
1340 inline bool operator!= (const cidotprecision & a, const idotprecision & b) noexcept
1341 {
1342  return a.reinf!=Inf(b) || a.resup!=Sup(b) || a.iminf!=0. || a.imsup!=0.;
1343 }
1344 
1345 inline bool operator!= (const idotprecision & a, const cidotprecision & b) noexcept
1346 {
1347  return b.reinf!=Inf(a) || b.resup!=Sup(b) || b.iminf!=0. || b.imsup!=0.;
1348 }
1349 
1350 // ---- Set Operators ----
1351 inline bool operator <(const cidotprecision & a,const cidotprecision & b) noexcept
1352 {
1353  return a.reinf>b.reinf && a.resup<b.resup && a.iminf>b.iminf && a.imsup<b.imsup;
1354 }
1355 
1356 inline bool operator >(const cidotprecision & a,const cidotprecision & b) noexcept
1357 {
1358  return a.reinf<b.reinf && a.resup>b.resup && a.iminf<b.iminf && a.imsup>b.imsup;
1359 }
1360 
1361 inline bool operator <=(const cidotprecision & a,const cidotprecision & b) noexcept
1362 {
1363  return a.reinf>=b.reinf && a.resup<=b.resup && a.iminf>=b.iminf && a.imsup<=b.imsup;
1364 }
1365 
1366 inline bool operator >=(const cidotprecision & a,const cidotprecision & b) noexcept
1367 {
1368  return a.reinf<=b.reinf && a.resup>=b.resup && a.iminf<=b.iminf && a.imsup>=b.imsup;
1369 }
1370 
1371 // CID-R
1372 
1373 inline bool operator <(const real & a,const cidotprecision & b) noexcept { return b>_cinterval(a); }
1374 inline bool operator >(const real & a,const cidotprecision & b) noexcept { return false; }
1375 inline bool operator <=(const real & a,const cidotprecision & b) noexcept { return b>=_cinterval(a); }
1376 inline bool operator >=(const real & a,const cidotprecision & b) noexcept { return b<=_cinterval(a); }
1377 
1378 inline bool operator <(const cidotprecision & a,const real & b) noexcept { return false; }
1379 inline bool operator >(const cidotprecision & a,const real & b) noexcept { return a>_cinterval(b); }
1380 inline bool operator <=(const cidotprecision & a,const real & b) noexcept { return a<=_cinterval(b); }
1381 inline bool operator >=(const cidotprecision & a,const real & b) noexcept { return a>=_cinterval(b); }
1382 
1383 // CID-C
1384 
1385 inline bool operator <(const complex & a,const cidotprecision & b) noexcept { return b>_cinterval(a); }
1386 inline bool operator >(const complex & a,const cidotprecision & b) noexcept { return false; }
1387 inline bool operator <=(const complex & a,const cidotprecision & b) noexcept { return b>=_cinterval(a); }
1388 inline bool operator >=(const complex & a,const cidotprecision & b) noexcept { return b<=_cinterval(a); }
1389 
1390 inline bool operator <(const cidotprecision & a,const complex & b) noexcept { return false; }
1391 inline bool operator >(const cidotprecision & a,const complex & b) noexcept { return a>_cinterval(b); }
1392 inline bool operator <=(const cidotprecision & a,const complex & b) noexcept { return a<=_cinterval(b); }
1393 inline bool operator >=(const cidotprecision & a,const complex & b) noexcept { return a>=_cinterval(b); }
1394 
1395 // CID-I
1396 
1397 inline bool operator <(const interval & a,const cidotprecision & b) noexcept { return b>_cinterval(a); }
1398 inline bool operator >(const interval & a,const cidotprecision & b) noexcept { return false; }
1399 inline bool operator <=(const interval & a,const cidotprecision & b) noexcept { return b>=_cinterval(a); }
1400 inline bool operator >=(const interval & a,const cidotprecision & b) noexcept { return b<=_cinterval(a); }
1401 
1402 inline bool operator <(const cidotprecision & a,const interval & b) noexcept { return false; }
1403 inline bool operator >(const cidotprecision & a,const interval & b) noexcept { return a>_cinterval(b); }
1404 inline bool operator <=(const cidotprecision & a,const interval & b) noexcept { return a<=_cinterval(b); }
1405 inline bool operator >=(const cidotprecision & a,const interval & b) noexcept { return a>=_cinterval(b); }
1406 
1407 // CID-CI
1408 
1409 inline bool operator <(const cinterval & a,const cidotprecision & b) noexcept
1410 {
1411  return Inf(Re(a))>b.reinf && Sup(Re(a))<b.resup && Inf(Im(a))>b.iminf && Sup(Im(a))<b.imsup;
1412 }
1413 
1414 inline bool operator >(const cinterval & a,const cidotprecision & b) noexcept
1415 {
1416  return Inf(Re(a))<b.reinf && Sup(Re(a))>b.resup && Inf(Im(a))<b.iminf && Sup(Im(a))>b.imsup;
1417 }
1418 
1419 inline bool operator <=(const cinterval & a,const cidotprecision & b) noexcept
1420 {
1421  return Inf(Re(a))>=b.reinf && Sup(Re(a))<=b.resup && Inf(Im(a))>=b.iminf && Sup(Im(a))<=b.imsup;
1422 }
1423 
1424 inline bool operator >=(const cinterval & a,const cidotprecision & b) noexcept
1425 {
1426  return Inf(Re(a))<=b.reinf && Sup(Re(a))>=b.resup && Inf(Im(a))<=b.iminf && Sup(Im(a))>=b.imsup;
1427 }
1428 
1429 inline bool operator <(const cidotprecision & a,const cinterval & b) noexcept
1430 {
1431  return Inf(Re(b))<a.reinf && Sup(Re(b))>a.resup && Inf(Im(b))<a.iminf && Sup(Im(b))>a.imsup;
1432 }
1433 
1434 inline bool operator >(const cidotprecision & a,const cinterval & b) noexcept
1435 {
1436  return Inf(Re(b))>a.reinf && Sup(Re(b))<a.resup && Inf(Im(b))>a.iminf && Sup(Im(b))<a.imsup;
1437 }
1438 
1439 inline bool operator <=(const cidotprecision & a,const cinterval & b) noexcept
1440 {
1441  return Inf(Re(b))<=a.reinf && Sup(Re(b))>=a.resup && Inf(Im(b))<=a.iminf && Sup(Im(b))>=a.imsup;
1442 }
1443 
1444 inline bool operator >=(const cidotprecision & a,const cinterval & b) noexcept
1445 {
1446  return Inf(Re(b))>=a.reinf && Sup(Re(b))<=a.resup && Inf(Im(b))>=a.iminf && Sup(Im(b))<=a.imsup;
1447 }
1448 
1449 // CID-D
1450 
1451 inline bool operator <(const dotprecision & a,const cidotprecision & b) noexcept
1452 {
1453  return a>b.reinf && a<b.resup && 0.>b.iminf && 0.<b.imsup;
1454 }
1455 
1456 inline bool operator >(const dotprecision & a,const cidotprecision & b) noexcept
1457 {
1458  return false;
1459 }
1460 
1461 inline bool operator <=(const dotprecision & a,const cidotprecision & b) noexcept
1462 {
1463  return a>=b.reinf && a<=b.resup && 0.>=b.iminf && 0.<=b.imsup;
1464 }
1465 
1466 inline bool operator >=(const dotprecision & a,const cidotprecision & b) noexcept
1467 {
1468  return a==b;
1469 }
1470 
1471 inline bool operator <(const cidotprecision & a,const dotprecision & b) noexcept
1472 {
1473  return false;
1474 }
1475 
1476 inline bool operator >(const cidotprecision & a,const dotprecision & b) noexcept
1477 {
1478  return b>a.reinf && b<a.resup && 0.>a.iminf && 0.<a.imsup;
1479 }
1480 
1481 inline bool operator <=(const cidotprecision & a,const dotprecision & b) noexcept
1482 {
1483  return a==b;
1484 }
1485 
1486 inline bool operator >=(const cidotprecision & a,const dotprecision & b) noexcept
1487 {
1488  return b>=a.reinf && b<=a.resup && 0.>=a.iminf && 0.<=a.imsup;
1489 }
1490 
1491 
1492 // CID-CD
1493 
1494 inline bool operator <(const cdotprecision & a,const cidotprecision & b) noexcept
1495 {
1496  return Re(a)>b.reinf && Re(a)<b.resup && Im(a)>b.iminf && Im(a)<b.imsup;
1497 }
1498 
1499 inline bool operator >(const cdotprecision & a,const cidotprecision & b) noexcept
1500 {
1501  return false;
1502 }
1503 
1504 inline bool operator <=(const cdotprecision & a,const cidotprecision & b) noexcept
1505 {
1506  return Re(a)>=b.reinf && Re(a)<=b.resup && Im(a)>=b.iminf && Im(a)<=b.imsup;
1507 }
1508 
1509 inline bool operator >=(const cdotprecision & a,const cidotprecision & b) noexcept
1510 {
1511  return a==b;
1512 }
1513 
1514 inline bool operator <(const cidotprecision & a,const cdotprecision & b) noexcept
1515 {
1516  return false;
1517 }
1518 
1519 inline bool operator >(const cidotprecision & a,const cdotprecision & b) noexcept
1520 {
1521  return Re(b)>a.reinf && Re(b)<a.resup && Im(b)>a.iminf && Im(b)<a.imsup;
1522 }
1523 
1524 inline bool operator <=(const cidotprecision & a,const cdotprecision & b) noexcept
1525 {
1526  return a==b;
1527 }
1528 
1529 inline bool operator >=(const cidotprecision & a,const cdotprecision & b) noexcept
1530 {
1531  return Re(b)>=a.reinf && Re(b)<=a.resup && Im(a)>=a.iminf && Im(a)<=a.imsup;
1532 }
1533 
1534 // CID-ID
1535 
1536 inline bool operator <(const idotprecision & a,const cidotprecision & b) noexcept
1537 {
1538  return Inf(a)>b.reinf && Sup(a)<b.resup && 0.>b.iminf && 0.<b.imsup;
1539 }
1540 
1541 inline bool operator >(const idotprecision & a,const cidotprecision & b) noexcept
1542 {
1543  return false;
1544 }
1545 
1546 inline bool operator <=(const idotprecision & a,const cidotprecision & b) noexcept
1547 {
1548  return Inf(a)>=b.reinf && Sup(a)<=b.resup && 0.>=b.iminf && 0.<=b.imsup;
1549 }
1550 
1551 inline bool operator >=(const idotprecision & a,const cidotprecision & b) noexcept
1552 {
1553  return Inf(a)<=b.reinf && Sup(a)>=b.resup && b.iminf==0. && b.imsup==0.;
1554 }
1555 
1556 inline bool operator <(const cidotprecision & a,const idotprecision & b) noexcept
1557 {
1558  return false;
1559 }
1560 
1561 inline bool operator >(const cidotprecision & a,const idotprecision & b) noexcept
1562 {
1563  return Inf(b)>a.reinf && Sup(b)<a.resup && 0.>a.iminf && 0.<a.imsup;
1564 }
1565 
1566 inline bool operator <=(const cidotprecision & a,const idotprecision & b) noexcept
1567 {
1568  return Inf(b)<=a.reinf && Sup(b)>=a.resup && a.iminf==0. && a.imsup==0.;
1569 }
1570 
1571 inline bool operator >=(const cidotprecision & a,const idotprecision & b) noexcept
1572 {
1573  return Inf(b)>=a.reinf && Sup(b)<=a.resup && 0.>=a.iminf && 0.<=a.imsup;
1574 }
1575 
1576 // ---- Funktionen ----
1577 
1578 cdotprecision Inf(const cidotprecision & a) noexcept { return cdotprecision(a.reinf,a.iminf); }
1579 cdotprecision Sup(const cidotprecision & a) noexcept { return cdotprecision(a.resup,a.imsup); }
1580 
1582 {
1583  a.reinf=Re(b);
1584  a.iminf=Im(b);
1585 
1586  if (a.reinf >a.resup || a.iminf > a.imsup)
1587  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetInf(cidotprecision & a,const cdotprecision & b)"));
1588 
1589  return a;
1590 }
1591 
1593 {
1594  a.resup=Re(b);
1595  a.imsup=Im(b);
1596 
1597  if (a.reinf >a.resup || a.iminf > a.imsup)
1598  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetSup(cidotprecision & a,const cdotprecision & b)"));
1599 
1600  return a;
1601 }
1602 
1604 {
1605  a.reinf=b;
1606  a.iminf=b;
1607 
1608  if (a.reinf >a.resup || a.iminf > a.imsup)
1609  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetInf(cidotprecision & a,const dotprecision & b)"));
1610 
1611  return a;
1612 }
1613 
1615 {
1616  a.resup=b;
1617  a.imsup=b;
1618 
1619  if (a.reinf >a.resup || a.iminf > a.imsup)
1620  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetInf(cidotprecision & a,const dotprecision & b)"));
1621 
1622  return a;
1623 }
1624 
1625 cidotprecision & SetInf(cidotprecision & a, const complex & b)
1626 {
1627  a.reinf=Re(b);
1628  a.iminf=Im(b);
1629 
1630  if (a.reinf >a.resup || a.iminf > a.imsup)
1631  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetInf(cidotprecision & a,const complex & b)"));
1632 
1633  return a;
1634 }
1635 
1636 cidotprecision & SetSup(cidotprecision & a, const complex & b)
1637 {
1638  a.resup=Re(b);
1639  a.imsup=Im(b);
1640 
1641  if (a.reinf >a.resup || a.iminf > a.imsup)
1642  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetSup(cidotprecision & a,const complex & b)"));
1643 
1644  return a;
1645 }
1646 
1647 cidotprecision & SetInf(cidotprecision & a, const real & b)
1648 {
1649  a.reinf=b;
1650  a.iminf=b;
1651 
1652  if (a.reinf >a.resup || a.iminf > a.imsup)
1653  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetInf(cidotprecision & a,const real & b)"));
1654 
1655  return a;
1656 }
1657 
1658 cidotprecision & SetSup(cidotprecision & a, const real & b)
1659 {
1660  a.resup=b;
1661  a.imsup=b;
1662 
1663  if (a.reinf >a.resup || a.iminf > a.imsup)
1664  cxscthrow(ERROR_CIDOTPRECISION_EMPTY_INTERVAL("inline cidotprecision & SetInf(cidotprecision & a,const real & b)"));
1665 
1666  return a;
1667 }
1668 
1669 cidotprecision & UncheckedSetInf(cidotprecision & a, const cdotprecision & b) noexcept
1670 {
1671  a.reinf=Re(b);
1672  a.iminf=Im(b);
1673  return a;
1674 }
1675 
1676 cidotprecision & UncheckedSetSup(cidotprecision & a, const cdotprecision & b) noexcept
1677 {
1678  a.resup=Re(b);
1679  a.imsup=Im(b);
1680  return a;
1681 }
1682 
1683 cidotprecision & UncheckedSetInf(cidotprecision & a, const dotprecision & b) noexcept
1684 {
1685  a.reinf=b;
1686  a.iminf=b;
1687  return a;
1688 }
1689 
1690 cidotprecision & UncheckedSetSup(cidotprecision & a, const dotprecision & b) noexcept
1691 {
1692  a.resup=b;
1693  a.imsup=b;
1694  return a;
1695 }
1696 
1697 cidotprecision & UncheckedSetInf(cidotprecision & a, const complex & b) noexcept
1698 {
1699  a.reinf=Re(b);
1700  a.iminf=Im(b);
1701  return a;
1702 }
1703 
1704 cidotprecision & UncheckedSetSup(cidotprecision & a, const complex & b) noexcept
1705 {
1706  a.resup=Re(b);
1707  a.imsup=Im(b);
1708  return a;
1709 }
1710 
1711 cidotprecision & UncheckedSetInf(cidotprecision & a, const real & b) noexcept
1712 {
1713  a.reinf=b;
1714  a.iminf=b;
1715  return a;
1716 }
1717 
1718 cidotprecision & UncheckedSetSup(cidotprecision & a, const real & b) noexcept
1719 {
1720  a.resup=b;
1721  a.imsup=b;
1722  return a;
1723 }
1724 
1725 idotprecision Re(const cidotprecision & a) noexcept { return idotprecision(a.reinf,a.resup); }
1726 idotprecision Im(const cidotprecision & a) noexcept { return idotprecision(a.iminf,a.imsup); }
1727 
1728 inline const dotprecision & InfRe(const cidotprecision & a) noexcept { return a.reinf; }
1729 inline const dotprecision & InfIm(const cidotprecision & a) noexcept { return a.iminf; }
1730 inline const dotprecision & SupRe(const cidotprecision & a) noexcept { return a.resup; }
1731 inline const dotprecision & SupIm(const cidotprecision & a) noexcept { return a.imsup; }
1732 
1733 inline dotprecision & InfRe(cidotprecision & a) noexcept { return a.reinf; }
1734 inline dotprecision & InfIm(cidotprecision & a) noexcept { return a.iminf; }
1735 inline dotprecision & SupRe(cidotprecision & a) noexcept { return a.resup; }
1736 inline dotprecision & SupIm(cidotprecision & a) noexcept { return a.imsup; }
1737 
1738 cidotprecision & SetRe(cidotprecision & a, const idotprecision & b) noexcept
1739 {
1740  a.reinf=Inf(b);
1741  a.resup=Sup(b);
1742  return a;
1743 }
1744 
1745 cidotprecision & SetIm(cidotprecision & a, const idotprecision & b) noexcept
1746 {
1747  a.iminf=Inf(b);
1748  a.imsup=Sup(b);
1749  return a;
1750 }
1751 
1752 cidotprecision & SetRe(cidotprecision & a, const dotprecision & b) noexcept
1753 {
1754  a.reinf=b;
1755  a.resup=b;
1756  return a;
1757 }
1758 
1759 cidotprecision & SetIm(cidotprecision & a, const dotprecision & b) noexcept
1760 {
1761  a.iminf=b;
1762  a.imsup=b;
1763  return a;
1764 }
1765 
1766 cidotprecision & SetRe(cidotprecision & a, const interval & b) noexcept
1767 {
1768  a.reinf=Inf(b);
1769  a.resup=Sup(b);
1770  return a;
1771 }
1772 
1773 cidotprecision & SetIm(cidotprecision & a, const interval & b) noexcept
1774 {
1775  a.iminf=Inf(b);
1776  a.imsup=Sup(b);
1777  return a;
1778 }
1779 
1780 cidotprecision & SetRe(cidotprecision & a, const real & b) noexcept
1781 {
1782  a.reinf=b;
1783  a.resup=b;
1784  return a;
1785 }
1786 
1787 cidotprecision & SetIm(cidotprecision & a, const real & b) noexcept
1788 {
1789  a.iminf=b;
1790  a.imsup=b;
1791  return a;
1792 }
1793 
1794 void rnd(const cidotprecision & a,cinterval & b) noexcept
1795 {
1796  complex c;
1797  SetRe(c,rnd(a.reinf,RND_DOWN));
1798  SetIm(c,rnd(a.iminf,RND_DOWN));
1799  UncheckedSetInf(b,c);
1800  SetRe(c,rnd(a.resup,RND_UP));
1801  SetIm(c,rnd(a.imsup,RND_UP));
1802  UncheckedSetSup(b,c);
1803 }
1804 
1805 cinterval rnd(const cidotprecision & a) noexcept
1806 {
1807  cinterval tmp;
1808  rnd(a,tmp);
1809  return tmp;
1810 }
1811 
1812 inline void accumulate (cidotprecision & a, const cinterval & b, const interval & c) noexcept
1813 {
1814  accumulate(a,b,cinterval(c));
1815 }
1816 
1817 inline void accumulate (cidotprecision & a, const cinterval & b, const complex & c) noexcept
1818 {
1819  accumulate(a,b,cinterval(c));
1820 }
1821 
1822 inline void accumulate (cidotprecision & a, const cinterval & b, const real & c) noexcept
1823 {
1824  accumulate(a,b,cinterval(c));
1825 }
1826 
1827 inline void accumulate (cidotprecision & a, const interval & b,const cinterval & c) noexcept
1828 {
1829  accumulate(a,cinterval(b),c);
1830 }
1831 
1832 inline void accumulate (cidotprecision & a, const complex & b,const cinterval & c) noexcept
1833 {
1834  accumulate(a,cinterval(b),c);
1835 }
1836 
1837 inline void accumulate (cidotprecision & a, const real & b,const cinterval & c) noexcept
1838 {
1839  accumulate(a,cinterval(b),c);
1840 }
1841 
1842 inline void accumulate (cidotprecision & a, const complex & b,const interval & c) noexcept
1843 {
1844  accumulate(a,cinterval(b),cinterval(c));
1845 }
1846 
1847 inline void accumulate (cidotprecision & a, const interval & b,const complex & c) noexcept
1848 {
1849  accumulate(a,cinterval(b),cinterval(c));
1850 }
1851 
1852 inline void accumulate (cidotprecision & a, const interval & b,const interval & c) noexcept
1853 {
1854  accumulate(a,cinterval(b),cinterval(c));
1855 }
1856 
1857 inline void accumulate (cidotprecision & a, const interval & b,const real & c) noexcept
1858 {
1859  accumulate(a,cinterval(b),cinterval(c));
1860 }
1861 
1862 inline void accumulate (cidotprecision & a, const real & b,const interval & c) noexcept
1863 {
1864  accumulate(a,cinterval(b),cinterval(c));
1865 }
1866 
1867 inline void accumulate (cidotprecision & a, const complex & b,const complex & c) noexcept
1868 {
1869  accumulate(a,cinterval(b),cinterval(c));
1870 }
1871 
1872 inline void accumulate (cidotprecision & a, const real & b,const complex & c) noexcept
1873 {
1874  accumulate(a,cinterval(b),cinterval(c));
1875 }
1876 
1877 inline void accumulate (cidotprecision & a, const complex & b,const real & c) noexcept
1878 {
1879  accumulate(a,cinterval(b),cinterval(c));
1880 }
1881 
1882 inline void accumulate (cidotprecision & a, const real & b,const real & c) noexcept
1883 {
1884  accumulate(a,cinterval(b),cinterval(c));
1885 }
1886 
1887 } // namespace cxsc
1888 
cxsc::cidotprecision::cidotprecision
cidotprecision()
Constructor of class cidotprecision.
Definition: cidot.hpp:67
cxsc::_cinterval
cinterval _cinterval(const real &a) noexcept
Definition: cinterval.inl:105
cxsc::_cidotprecision
cidotprecision _cidotprecision(const complex &, const complex &) noexcept
Definition: cidot.inl:113
cxsc::interval
The Scalar Type interval.
Definition: interval.hpp:55
cxsc::idotprecision
The Data Type idotprecision.
Definition: idot.hpp:48
cxsc::_unchecked_cidotprecision
cidotprecision _unchecked_cidotprecision(const complex &a, const complex &b) noexcept
Definition: cidot.inl:352
cxsc::dotprecision
The Data Type dotprecision.
Definition: dot.hpp:112
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::cdotprecision
The Data Type cdotprecision.
Definition: cdot.hpp:61
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