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
26namespace cxsc {
27inline cidotprecision _cidotprecision(const complex &,const complex &) noexcept;
28inline cidotprecision _cidotprecision(const complex &,const real &) noexcept;
29inline cidotprecision _cidotprecision(const real &,const complex &) noexcept;
30inline cidotprecision _cidotprecision(const interval &,const interval &) noexcept;
31inline cidotprecision _cidotprecision(const interval &,const real &) noexcept;
32inline cidotprecision _cidotprecision(const real &,const interval &) noexcept;
33inline cidotprecision _cidotprecision(const real &) noexcept;
34inline cidotprecision _cidotprecision(const complex &) noexcept;
35inline cidotprecision _cidotprecision(const interval &) noexcept;
36inline cidotprecision _cidotprecision(const cinterval &) noexcept;
37
38inline cidotprecision _cidotprecision(const idotprecision &,const idotprecision &) noexcept;
39inline cidotprecision _cidotprecision(const cdotprecision &,const cdotprecision &);
40inline cidotprecision _cidotprecision(const idotprecision &,const dotprecision &) noexcept;
41inline cidotprecision _cidotprecision(const cdotprecision &,const dotprecision &);
42inline cidotprecision _cidotprecision(const dotprecision &,const idotprecision &) noexcept;
43inline cidotprecision _cidotprecision(const dotprecision &,const cdotprecision&);
44inline cidotprecision _cidotprecision(const cdotprecision &) noexcept;
45inline cidotprecision _cidotprecision(const idotprecision &) noexcept;
46inline cidotprecision _cidotprecision(const dotprecision &) noexcept;
47
48inline cidotprecision::cidotprecision(const real & a) noexcept
49 : reinf(a), resup(reinf),
50 iminf(0), imsup(iminf), k(0)
51{
52}
53
55 : reinf(a), resup(reinf),
56 iminf(0), imsup(iminf)
57{
58 set_k(0);
59}
60
61inline 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
74inline 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
87inline 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
100inline 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 ----
113inline cidotprecision _cidotprecision(const complex & a,const complex & b) noexcept
114{
115 return _cidotprecision(_cinterval(a,b));
116}
117
123inline cidotprecision _cidotprecision(const complex & a,const real & b) noexcept
124{
125 return _cidotprecision(_cinterval(a,b));
126}
127
133inline cidotprecision _cidotprecision(const real & a,const complex & b) noexcept
134{
135 return _cidotprecision(_cinterval(a,b));
136}
137
143inline cidotprecision _cidotprecision(const interval & a,const interval & b) noexcept
144{
145 return _cidotprecision(_cinterval(a,b));
146}
147
153inline cidotprecision _cidotprecision(const interval & a,const real &b) noexcept
154{
155 return _cidotprecision(_cinterval(a,b));
156}
157
163inline cidotprecision _cidotprecision(const real & a,const interval & b) noexcept
164{
165 return _cidotprecision(_cinterval(a,b));
166}
167
173inline cidotprecision _cidotprecision(const real & a) noexcept
174{
175 return _cidotprecision(_cinterval(a));
176}
177
183inline cidotprecision _cidotprecision(const complex & a) noexcept
184{
185 return _cidotprecision(_cinterval(a));
186}
187
193inline cidotprecision _cidotprecision(const interval & a) noexcept
194{
195 return _cidotprecision(_cinterval(a));
196}
197
203inline 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
218inline 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
250inline 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
281inline 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
313{
314 cidotprecision tmp;
315 tmp.reinf=tmp.resup=Re(a);
316 tmp.iminf=tmp.imsup=Im(a);
317 return tmp;
318}
319
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
340{
341 cidotprecision tmp;
342 tmp.reinf=tmp.resup=a;
343 tmp.iminf=tmp.imsup=0.0;
344 return tmp;
345}
346
352inline 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
367inline 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
382inline 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)
440inline 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
453inline cidotprecision operator +(const cidotprecision &a) noexcept
454{
455 return a;
456}
457
458inline 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
468inline 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
478inline 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
492inline 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
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
519inline 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
528inline 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
541inline 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
561inline cidotprecision operator +(const cidotprecision & a,const real & b) noexcept
562{
563 cidotprecision tmp(a);
564 return tmp+=b;
565}
566
567inline cidotprecision operator +(const real & a,const cidotprecision & b) noexcept
568{
569 cidotprecision tmp(b);
570 return tmp+=a;
571}
572
573inline cidotprecision operator -(const cidotprecision & a,const real & b) noexcept
574{
575 cidotprecision tmp(a);
576 return tmp-=b;
577}
578
579inline cidotprecision operator -(const real & a,const cidotprecision & b) noexcept
580{
581 cidotprecision tmp(-b);
582 return tmp+=a;
583}
584
585inline cidotprecision operator |(const cidotprecision & a,const real & b) noexcept
586{
587 cidotprecision tmp(a);
588 return tmp|=_cinterval(b);
589}
590
591inline cidotprecision operator |(const real & a,const cidotprecision & b) noexcept
592{
593 cidotprecision tmp(b);
594 return tmp|=_cinterval(a);
595}
596
597inline cidotprecision operator &(const cidotprecision & a,const real & b)
598{
599 cidotprecision tmp(a);
600 return tmp&=_cinterval(b);
601}
602
603inline cidotprecision operator &(const real & a,const cidotprecision & b)
604{
605 cidotprecision tmp(b);
606 return tmp&=_cinterval(a);
607}
608
609inline cidotprecision & operator +=(cidotprecision & a, const real & b) noexcept
610{
611 a.reinf+=b;
612 a.resup+=b;
613 return a;
614}
615
616inline cidotprecision & operator -=(cidotprecision & a, const real & b) noexcept
617{
618 a.reinf-=b;
619 a.resup-=b;
620 return a;
621}
622
623inline cidotprecision & operator |=(cidotprecision & a, const real & b) noexcept
624{
625 return a|=_cinterval(b);
626}
627
628inline cidotprecision & operator &=(cidotprecision & a, const real & b)
629{
630 return a&=_cinterval(b);
631}
632
633// CID-C
634
635inline cidotprecision operator +(const cidotprecision & a,const complex & b) noexcept
636{
637 cidotprecision tmp(a);
638 return tmp+=b;
639}
640
641inline cidotprecision operator +(const complex & a,const cidotprecision & b) noexcept
642{
643 cidotprecision tmp(b);
644 return tmp+=a;
645}
646
647inline cidotprecision operator -(const cidotprecision & a,const complex & b) noexcept
648{
649 cidotprecision tmp(a);
650 return tmp-=b;
651}
652
653inline cidotprecision operator -(const complex & a,const cidotprecision & b) noexcept
654{
655 cidotprecision tmp(-b);
656 return tmp+=a;
657}
658
659inline cidotprecision operator |(const cidotprecision & a,const complex & b) noexcept
660{
661 cidotprecision tmp(a);
662 return tmp|=_cinterval(b);
663}
664
665inline cidotprecision operator |(const complex & a,const cidotprecision & b) noexcept
666{
667 cidotprecision tmp(b);
668 return tmp|=_cinterval(a);
669}
670
671inline cidotprecision operator &(const cidotprecision & a,const complex & b)
672{
673 cidotprecision tmp(a);
674 return tmp&=_cinterval(b);
675}
676
677inline cidotprecision operator &(const complex & a,const cidotprecision & b)
678{
679 cidotprecision tmp(b);
680 return tmp&=_cinterval(a);
681}
682
683inline 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
692inline 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
701inline cidotprecision & operator |=(cidotprecision & a, const complex & b) noexcept
702{
703 return a|=_cinterval(b);
704}
705
706inline cidotprecision & operator &=(cidotprecision & a, const complex & b)
707{
708 return a&=_cinterval(b);
709}
710
711// CID-I
712
713inline cidotprecision operator +(const cidotprecision & a,const interval & b) noexcept
714{
715 cidotprecision tmp(a);
716 return tmp+=b;
717}
718
719inline cidotprecision operator +(const interval & a,const cidotprecision & b) noexcept
720{
721 cidotprecision tmp(b);
722 return tmp+=a;
723}
724
725inline cidotprecision operator -(const cidotprecision & a,const interval & b) noexcept
726{
727 cidotprecision tmp(a);
728 return tmp-=b;
729}
730
731inline cidotprecision operator -(const interval & a,const cidotprecision & b) noexcept
732{
733 cidotprecision tmp(-b);
734 return tmp+=a;
735}
736
737inline cidotprecision operator |(const cidotprecision & a,const interval & b) noexcept
738{
739 cidotprecision tmp(a);
740 return tmp|=_cinterval(b);
741}
742
743inline cidotprecision operator |(const interval & a,const cidotprecision & b) noexcept
744{
745 cidotprecision tmp(b);
746 return tmp|=_cinterval(a);
747}
748
749inline cidotprecision operator &(const cidotprecision & a,const interval & b)
750{
751 cidotprecision tmp(a);
752 return tmp&=_cinterval(b);
753}
754
755inline cidotprecision operator &(const interval & a,const cidotprecision & b)
756{
757 cidotprecision tmp(b);
758 return tmp&=_cinterval(a);
759}
760
761inline cidotprecision & operator +=(cidotprecision & a, const interval & b) noexcept
762{
763 a.reinf+=Inf(b);
764 a.resup+=Sup(b);
765 return a;
766}
767
768inline cidotprecision & operator -=(cidotprecision & a, const interval & b) noexcept
769{
770 a.reinf-=Sup(b);
771 a.resup-=Inf(b);
772 return a;
773}
774
775inline cidotprecision & operator |=(cidotprecision & a, const interval & b) noexcept
776{
777 return a|=_cinterval(b);
778}
779
780inline cidotprecision & operator &=(cidotprecision & a, const interval & b)
781{
782 return a&=_cinterval(b);
783}
784
785// CID-CI
786
787inline cidotprecision operator +(const cidotprecision & a,const cinterval & b) noexcept
788{
789 cidotprecision tmp(a);
790 return tmp+=b;
791}
792
793inline cidotprecision operator +(const cinterval & a,const cidotprecision & b) noexcept
794{
795 cidotprecision tmp(b);
796 return tmp+=a;
797}
798
799inline cidotprecision operator -(const cidotprecision & a,const cinterval & b) noexcept
800{
801 cidotprecision tmp(a);
802 return tmp-=b;
803}
804
805inline cidotprecision operator -(const cinterval & a,const cidotprecision & b) noexcept
806{
807 cidotprecision tmp(-b);
808 return tmp+=a;
809}
810
811inline cidotprecision operator |(const cidotprecision & a,const cinterval & b) noexcept
812{
813 cidotprecision tmp(a);
814 return tmp|=b;
815}
816
817inline cidotprecision operator |(const cinterval & a,const cidotprecision & b) noexcept
818{
819 cidotprecision tmp(b);
820 return tmp|=a;
821}
822
823inline cidotprecision operator &(const cidotprecision & a,const cinterval & b)
824{
825 cidotprecision tmp(a);
826 return tmp&=b;
827}
828
829inline cidotprecision operator &(const cinterval & a,const cidotprecision & b)
830{
831 cidotprecision tmp(b);
832 return tmp&=a;
833}
834
835inline 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
844inline 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
853inline 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
866inline 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
885inline cidotprecision operator +(const cidotprecision & a,const dotprecision & b) noexcept
886{
887 cidotprecision tmp(a);
888 return tmp+=b;
889}
890
891inline cidotprecision operator +(const dotprecision & a,const cidotprecision & b) noexcept
892{
893 cidotprecision tmp(b);
894 return tmp+=a;
895}
896
897inline cidotprecision operator -(const cidotprecision & a,const dotprecision & b) noexcept
898{
899 cidotprecision tmp(a);
900 return tmp-=b;
901}
902
903inline cidotprecision operator -(const dotprecision & a,const cidotprecision & b) noexcept
904{
905 cidotprecision tmp(-b);
906 return tmp+=a;
907}
908
909inline cidotprecision operator |(const cidotprecision & a,const dotprecision & b) noexcept
910{
911 cidotprecision tmp(a);
912 return tmp|=b;
913}
914
915inline cidotprecision operator |(const dotprecision & a,const cidotprecision & b) noexcept
916{
917 cidotprecision tmp(b);
918 return tmp|=a;
919}
920
921inline cidotprecision operator &(const cidotprecision & a,const dotprecision & b)
922{
923 cidotprecision tmp(a);
924 return tmp&=b;
925}
926
927inline cidotprecision operator &(const dotprecision & a,const cidotprecision & b)
928{
929 cidotprecision tmp(b);
930 return tmp&=a;
931}
932
933inline cidotprecision & operator +=(cidotprecision & a, const dotprecision & b) noexcept
934{
935 a.reinf+=b;
936 a.resup+=b;
937 return a;
938}
939
940inline cidotprecision & operator -=(cidotprecision & a, const dotprecision & b) noexcept
941{
942 a.reinf-=b;
943 a.resup-=b;
944 return a;
945}
946
947inline 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
960inline 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
979inline cidotprecision operator +(const cidotprecision & a,const cdotprecision & b) noexcept
980{
981 cidotprecision tmp(a);
982 return tmp+=b;
983}
984
985inline cidotprecision operator +(const cdotprecision & a,const cidotprecision & b) noexcept
986{
987 cidotprecision tmp(b);
988 return tmp+=a;
989}
990
991inline cidotprecision operator -(const cidotprecision & a,const cdotprecision & b) noexcept
992{
993 cidotprecision tmp(a);
994 return tmp-=b;
995}
996
997inline cidotprecision operator -(const cdotprecision & a,const cidotprecision & b) noexcept
998{
999 cidotprecision tmp(-b);
1000 return tmp+=a;
1001}
1002
1003inline cidotprecision operator |(const cidotprecision & a,const cdotprecision & b) noexcept
1004{
1005 cidotprecision tmp(a);
1006 return tmp|=b;
1007}
1008
1009inline cidotprecision operator |(const cdotprecision & a,const cidotprecision & b) noexcept
1010{
1011 cidotprecision tmp(b);
1012 return tmp|=a;
1013}
1014
1015inline cidotprecision operator &(const cidotprecision & a,const cdotprecision & b)
1016{
1017 cidotprecision tmp(a);
1018 return tmp&=b;
1019}
1020
1021inline cidotprecision operator &(const cdotprecision & a,const cidotprecision & b)
1022{
1023 cidotprecision tmp(b);
1024 return tmp&=a;
1025}
1026
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
1036inline 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
1045inline 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
1058inline 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
1078inline cidotprecision operator +(const cidotprecision & a,const idotprecision & b) noexcept
1079{
1080 cidotprecision tmp(a);
1081 return tmp+=b;
1082}
1083
1084inline cidotprecision operator +(const idotprecision & a,const cidotprecision & b) noexcept
1085{
1086 cidotprecision tmp(b);
1087 return tmp+=a;
1088}
1089
1090inline cidotprecision operator -(const cidotprecision & a,const idotprecision & b) noexcept
1091{
1092 cidotprecision tmp(a);
1093 return tmp-=b;
1094}
1095
1096inline cidotprecision operator -(const idotprecision & a,const cidotprecision & b) noexcept
1097{
1098 cidotprecision tmp(-b);
1099 return tmp+=a;
1100}
1101
1102inline cidotprecision operator |(const cidotprecision & a,const idotprecision & b) noexcept
1103{
1104 cidotprecision tmp(a);
1105 return tmp|=b;
1106}
1107
1108inline cidotprecision operator |(const idotprecision & a,const cidotprecision & b) noexcept
1109{
1110 cidotprecision tmp(b);
1111 return tmp|=a;
1112}
1113
1114inline cidotprecision operator &(const cidotprecision & a,const idotprecision & b)
1115{
1116 cidotprecision tmp(a);
1117 return tmp&=b;
1118}
1119
1120inline cidotprecision operator &(const idotprecision & a,const cidotprecision & b)
1121{
1122 cidotprecision tmp(b);
1123 return tmp&=a;
1124}
1125
1127{
1128 a.reinf+=Inf(b);
1129 a.resup+=Sup(b);
1130 return a;
1131}
1132
1133inline cidotprecision & operator -=(cidotprecision & a, const idotprecision & b) noexcept
1134{
1135 a.reinf-=Sup(b);
1136 a.resup-=Inf(b);
1137 return a;
1138}
1139
1140inline 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
1153inline 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. ----
1172inline 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
1185inline 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
1190inline 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
1197inline 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
1202inline 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
1207inline 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
1212inline 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
1219inline 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
1224inline 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
1229inline 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
1234inline 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
1241inline 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
1246inline 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
1251inline 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
1256inline 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
1263inline 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
1268inline 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
1273inline 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
1278inline 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
1285inline 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
1290inline 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
1295inline 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
1300inline 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
1308inline 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
1313inline 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
1318inline 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
1323inline 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
1330inline 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
1335inline 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
1340inline 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
1345inline 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 ----
1351inline 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
1356inline 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
1361inline 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
1366inline 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
1373inline bool operator <(const real & a,const cidotprecision & b) noexcept { return b>_cinterval(a); }
1374inline bool operator >(const real & a,const cidotprecision & b) noexcept { return false; }
1375inline bool operator <=(const real & a,const cidotprecision & b) noexcept { return b>=_cinterval(a); }
1376inline bool operator >=(const real & a,const cidotprecision & b) noexcept { return b<=_cinterval(a); }
1377
1378inline bool operator <(const cidotprecision & a,const real & b) noexcept { return false; }
1379inline bool operator >(const cidotprecision & a,const real & b) noexcept { return a>_cinterval(b); }
1380inline bool operator <=(const cidotprecision & a,const real & b) noexcept { return a<=_cinterval(b); }
1381inline bool operator >=(const cidotprecision & a,const real & b) noexcept { return a>=_cinterval(b); }
1382
1383// CID-C
1384
1385inline bool operator <(const complex & a,const cidotprecision & b) noexcept { return b>_cinterval(a); }
1386inline bool operator >(const complex & a,const cidotprecision & b) noexcept { return false; }
1387inline bool operator <=(const complex & a,const cidotprecision & b) noexcept { return b>=_cinterval(a); }
1388inline bool operator >=(const complex & a,const cidotprecision & b) noexcept { return b<=_cinterval(a); }
1389
1390inline bool operator <(const cidotprecision & a,const complex & b) noexcept { return false; }
1391inline bool operator >(const cidotprecision & a,const complex & b) noexcept { return a>_cinterval(b); }
1392inline bool operator <=(const cidotprecision & a,const complex & b) noexcept { return a<=_cinterval(b); }
1393inline bool operator >=(const cidotprecision & a,const complex & b) noexcept { return a>=_cinterval(b); }
1394
1395// CID-I
1396
1397inline bool operator <(const interval & a,const cidotprecision & b) noexcept { return b>_cinterval(a); }
1398inline bool operator >(const interval & a,const cidotprecision & b) noexcept { return false; }
1399inline bool operator <=(const interval & a,const cidotprecision & b) noexcept { return b>=_cinterval(a); }
1400inline bool operator >=(const interval & a,const cidotprecision & b) noexcept { return b<=_cinterval(a); }
1401
1402inline bool operator <(const cidotprecision & a,const interval & b) noexcept { return false; }
1403inline bool operator >(const cidotprecision & a,const interval & b) noexcept { return a>_cinterval(b); }
1404inline bool operator <=(const cidotprecision & a,const interval & b) noexcept { return a<=_cinterval(b); }
1405inline bool operator >=(const cidotprecision & a,const interval & b) noexcept { return a>=_cinterval(b); }
1406
1407// CID-CI
1408
1409inline 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
1414inline 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
1419inline 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
1424inline 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
1429inline 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
1434inline 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
1439inline 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
1444inline 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
1451inline 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
1456inline bool operator >(const dotprecision & a,const cidotprecision & b) noexcept
1457{
1458 return false;
1459}
1460
1461inline 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
1466inline bool operator >=(const dotprecision & a,const cidotprecision & b) noexcept
1467{
1468 return a==b;
1469}
1470
1471inline bool operator <(const cidotprecision & a,const dotprecision & b) noexcept
1472{
1473 return false;
1474}
1475
1476inline 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
1481inline bool operator <=(const cidotprecision & a,const dotprecision & b) noexcept
1482{
1483 return a==b;
1484}
1485
1486inline 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
1494inline 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
1499inline bool operator >(const cdotprecision & a,const cidotprecision & b) noexcept
1500{
1501 return false;
1502}
1503
1504inline 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
1509inline bool operator >=(const cdotprecision & a,const cidotprecision & b) noexcept
1510{
1511 return a==b;
1512}
1513
1514inline bool operator <(const cidotprecision & a,const cdotprecision & b) noexcept
1515{
1516 return false;
1517}
1518
1519inline 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
1524inline bool operator <=(const cidotprecision & a,const cdotprecision & b) noexcept
1525{
1526 return a==b;
1527}
1528
1529inline 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
1536inline 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
1541inline bool operator >(const idotprecision & a,const cidotprecision & b) noexcept
1542{
1543 return false;
1544}
1545
1546inline 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
1551inline 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
1556inline bool operator <(const cidotprecision & a,const idotprecision & b) noexcept
1557{
1558 return false;
1559}
1560
1561inline 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
1566inline 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
1571inline 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
1578cdotprecision Inf(const cidotprecision & a) noexcept { return cdotprecision(a.reinf,a.iminf); }
1579cdotprecision 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
1625cidotprecision & 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
1636cidotprecision & 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
1647cidotprecision & 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
1658cidotprecision & 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
1669cidotprecision & UncheckedSetInf(cidotprecision & a, const cdotprecision & b) noexcept
1670{
1671 a.reinf=Re(b);
1672 a.iminf=Im(b);
1673 return a;
1674}
1675
1676cidotprecision & UncheckedSetSup(cidotprecision & a, const cdotprecision & b) noexcept
1677{
1678 a.resup=Re(b);
1679 a.imsup=Im(b);
1680 return a;
1681}
1682
1683cidotprecision & UncheckedSetInf(cidotprecision & a, const dotprecision & b) noexcept
1684{
1685 a.reinf=b;
1686 a.iminf=b;
1687 return a;
1688}
1689
1690cidotprecision & UncheckedSetSup(cidotprecision & a, const dotprecision & b) noexcept
1691{
1692 a.resup=b;
1693 a.imsup=b;
1694 return a;
1695}
1696
1697cidotprecision & UncheckedSetInf(cidotprecision & a, const complex & b) noexcept
1698{
1699 a.reinf=Re(b);
1700 a.iminf=Im(b);
1701 return a;
1702}
1703
1704cidotprecision & UncheckedSetSup(cidotprecision & a, const complex & b) noexcept
1705{
1706 a.resup=Re(b);
1707 a.imsup=Im(b);
1708 return a;
1709}
1710
1711cidotprecision & UncheckedSetInf(cidotprecision & a, const real & b) noexcept
1712{
1713 a.reinf=b;
1714 a.iminf=b;
1715 return a;
1716}
1717
1718cidotprecision & UncheckedSetSup(cidotprecision & a, const real & b) noexcept
1719{
1720 a.resup=b;
1721 a.imsup=b;
1722 return a;
1723}
1724
1725idotprecision Re(const cidotprecision & a) noexcept { return idotprecision(a.reinf,a.resup); }
1726idotprecision Im(const cidotprecision & a) noexcept { return idotprecision(a.iminf,a.imsup); }
1727
1728inline const dotprecision & InfRe(const cidotprecision & a) noexcept { return a.reinf; }
1729inline const dotprecision & InfIm(const cidotprecision & a) noexcept { return a.iminf; }
1730inline const dotprecision & SupRe(const cidotprecision & a) noexcept { return a.resup; }
1731inline const dotprecision & SupIm(const cidotprecision & a) noexcept { return a.imsup; }
1732
1733inline dotprecision & InfRe(cidotprecision & a) noexcept { return a.reinf; }
1734inline dotprecision & InfIm(cidotprecision & a) noexcept { return a.iminf; }
1735inline dotprecision & SupRe(cidotprecision & a) noexcept { return a.resup; }
1736inline dotprecision & SupIm(cidotprecision & a) noexcept { return a.imsup; }
1737
1738cidotprecision & SetRe(cidotprecision & a, const idotprecision & b) noexcept
1739{
1740 a.reinf=Inf(b);
1741 a.resup=Sup(b);
1742 return a;
1743}
1744
1745cidotprecision & SetIm(cidotprecision & a, const idotprecision & b) noexcept
1746{
1747 a.iminf=Inf(b);
1748 a.imsup=Sup(b);
1749 return a;
1750}
1751
1752cidotprecision & SetRe(cidotprecision & a, const dotprecision & b) noexcept
1753{
1754 a.reinf=b;
1755 a.resup=b;
1756 return a;
1757}
1758
1759cidotprecision & SetIm(cidotprecision & a, const dotprecision & b) noexcept
1760{
1761 a.iminf=b;
1762 a.imsup=b;
1763 return a;
1764}
1765
1766cidotprecision & SetRe(cidotprecision & a, const interval & b) noexcept
1767{
1768 a.reinf=Inf(b);
1769 a.resup=Sup(b);
1770 return a;
1771}
1772
1773cidotprecision & SetIm(cidotprecision & a, const interval & b) noexcept
1774{
1775 a.iminf=Inf(b);
1776 a.imsup=Sup(b);
1777 return a;
1778}
1779
1780cidotprecision & SetRe(cidotprecision & a, const real & b) noexcept
1781{
1782 a.reinf=b;
1783 a.resup=b;
1784 return a;
1785}
1786
1787cidotprecision & SetIm(cidotprecision & a, const real & b) noexcept
1788{
1789 a.iminf=b;
1790 a.imsup=b;
1791 return a;
1792}
1793
1794void 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
1805cinterval rnd(const cidotprecision & a) noexcept
1806{
1807 cinterval tmp;
1808 rnd(a,tmp);
1809 return tmp;
1810}
1811
1812inline void accumulate (cidotprecision & a, const cinterval & b, const interval & c) noexcept
1813{
1814 accumulate(a,b,cinterval(c));
1815}
1816
1817inline void accumulate (cidotprecision & a, const cinterval & b, const complex & c) noexcept
1818{
1819 accumulate(a,b,cinterval(c));
1820}
1821
1822inline void accumulate (cidotprecision & a, const cinterval & b, const real & c) noexcept
1823{
1824 accumulate(a,b,cinterval(c));
1825}
1826
1827inline void accumulate (cidotprecision & a, const interval & b,const cinterval & c) noexcept
1828{
1829 accumulate(a,cinterval(b),c);
1830}
1831
1832inline void accumulate (cidotprecision & a, const complex & b,const cinterval & c) noexcept
1833{
1834 accumulate(a,cinterval(b),c);
1835}
1836
1837inline void accumulate (cidotprecision & a, const real & b,const cinterval & c) noexcept
1838{
1839 accumulate(a,cinterval(b),c);
1840}
1841
1842inline void accumulate (cidotprecision & a, const complex & b,const interval & c) noexcept
1843{
1844 accumulate(a,cinterval(b),cinterval(c));
1845}
1846
1847inline void accumulate (cidotprecision & a, const interval & b,const complex & c) noexcept
1848{
1849 accumulate(a,cinterval(b),cinterval(c));
1850}
1851
1852inline void accumulate (cidotprecision & a, const interval & b,const interval & c) noexcept
1853{
1854 accumulate(a,cinterval(b),cinterval(c));
1855}
1856
1857inline void accumulate (cidotprecision & a, const interval & b,const real & c) noexcept
1858{
1859 accumulate(a,cinterval(b),cinterval(c));
1860}
1861
1862inline void accumulate (cidotprecision & a, const real & b,const interval & c) noexcept
1863{
1864 accumulate(a,cinterval(b),cinterval(c));
1865}
1866
1867inline void accumulate (cidotprecision & a, const complex & b,const complex & c) noexcept
1868{
1869 accumulate(a,cinterval(b),cinterval(c));
1870}
1871
1872inline void accumulate (cidotprecision & a, const real & b,const complex & c) noexcept
1873{
1874 accumulate(a,cinterval(b),cinterval(c));
1875}
1876
1877inline void accumulate (cidotprecision & a, const complex & b,const real & c) noexcept
1878{
1879 accumulate(a,cinterval(b),cinterval(c));
1880}
1881
1882inline 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
The Data Type cdotprecision.
Definition cdot.hpp:61
The Data Type cidotprecision.
Definition cidot.hpp:58
cidotprecision()
Constructor of class cidotprecision.
Definition cidot.hpp:67
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 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
cidotprecision _unchecked_cidotprecision(const complex &a, const complex &b) noexcept
Definition cidot.inl:352
cidotprecision _cidotprecision(const complex &, const complex &) noexcept
Definition cidot.inl:113
cinterval _cinterval(const real &a) noexcept