Blaze 3.9
Accuracy.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_ACCURACY_H_
36#define _BLAZE_MATH_ACCURACY_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
44#include <blaze/util/Limits.h>
45
46
47namespace blaze {
48
49//=================================================================================================
50//
51// CLASS DEFINITION
52//
53//=================================================================================================
54
55//*************************************************************************************************
68template< typename A > // Positive accuracy type
70{
71 public:
72 //**Type definitions****************************************************************************
73 using PositiveType = A;
74 //**********************************************************************************************
75
76 private:
77 //**Constructors********************************************************************************
80 constexpr NegativeAccuracy();
81 NegativeAccuracy( const NegativeAccuracy& ) = default;
83 //**********************************************************************************************
84
85 public:
86 //**Destructor**********************************************************************************
89 ~NegativeAccuracy() = default;
91 //**********************************************************************************************
92
93 //**Unary plus/minus operators******************************************************************
96 constexpr const NegativeAccuracy& operator+() const;
97 constexpr const PositiveType operator-() const;
99 //**********************************************************************************************
100
101 //**Conversion operator*************************************************************************
104 template< typename T >
105 constexpr operator const T() const;
107 //**********************************************************************************************
108
109 //**Forbidden operations************************************************************************
112 NegativeAccuracy& operator=( const NegativeAccuracy& ) = delete;
113 void* operator&() const = delete;
115 //**********************************************************************************************
116
117 private:
118 //**Friend declarations*************************************************************************
120 friend class Accuracy;
122 //**********************************************************************************************
123};
124//*************************************************************************************************
125
126
127
128
129//=================================================================================================
130//
131// CONSTRUCTORS
132//
133//=================================================================================================
134
135//*************************************************************************************************
138template< typename A > // Positive accuracy type
140{}
141//*************************************************************************************************
142
143
144
145
146//=================================================================================================
147//
148// UNARY PLUS/MINUS OPERATORS
149//
150//=================================================================================================
151
152//*************************************************************************************************
157template< typename A > // Positive accuracy type
159{
160 return *this;
161}
162//*************************************************************************************************
163
164
165//*************************************************************************************************
170template< typename A > // Positive accuracy type
171constexpr const typename NegativeAccuracy<A>::PositiveType
173{
174 return PositiveType();
175}
176//*************************************************************************************************
177
178
179
180
181//=================================================================================================
182//
183// CONVERSION OPERATOR
184//
185//=================================================================================================
186
187//*************************************************************************************************
193template< typename A > // Positive accuracy type
194template< typename T > // Floating point data type
195constexpr NegativeAccuracy<A>::operator const T() const
196{
198 return -Limits<T>::accuracy();
199}
200//*************************************************************************************************
201
202
203
204
205//=================================================================================================
206//
207// GLOBAL OPERATORS
208//
209//=================================================================================================
210
211//*************************************************************************************************
214template< typename A, typename T >
215constexpr bool operator==( const NegativeAccuracy<A>& lhs, const T& rhs );
216
217template< typename A, typename T >
218constexpr bool operator==( const T& lhs, const NegativeAccuracy<A>& rhs );
219
220template< typename A, typename T >
221constexpr bool operator!=( const NegativeAccuracy<A>& lhs, const T& rhs );
222
223template< typename A, typename T >
224constexpr bool operator!=( const T& lhs, const NegativeAccuracy<A>& rhs );
225
226template< typename A, typename T >
227constexpr bool operator<( const NegativeAccuracy<A>& lhs, const T& rhs );
228
229template< typename A, typename T >
230constexpr bool operator<( const T& lhs, const NegativeAccuracy<A>& rhs );
231
232template< typename A, typename T >
233constexpr bool operator>( const NegativeAccuracy<A>& lhs, const T& rhs );
234
235template< typename A, typename T >
236constexpr bool operator>( const T& lhs, const NegativeAccuracy<A>& rhs );
238//*************************************************************************************************
239
240
241//*************************************************************************************************
251template< typename A // Positive accuracy type
252 , typename T > // Floating point data type
253constexpr bool operator==( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
254{
256 return -Limits<T>::accuracy() == rhs;
257}
258//*************************************************************************************************
259
260
261//*************************************************************************************************
271template< typename A // Positive accuracy type
272 , typename T > // Floating point data type
273constexpr bool operator==( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
274{
276 return lhs == -Limits<T>::accuracy();
277}
278//*************************************************************************************************
279
280
281//*************************************************************************************************
291template< typename A // Positive accuracy type
292 , typename T > // Floating point data type
293constexpr bool operator!=( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
294{
296 return -Limits<T>::accuracy() != rhs;
297}
298//*************************************************************************************************
299
300
301//*************************************************************************************************
311template< typename A // Positive accuracy type
312 , typename T > // Floating point data type
313constexpr bool operator!=( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
314{
316 return lhs != -Limits<T>::accuracy();
317}
318//*************************************************************************************************
319
320
321//*************************************************************************************************
330template< typename A // Positive accuracy type
331 , typename T > // Floating point data type
332constexpr bool operator<( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
333{
335 return -Limits<T>::accuracy() < rhs;
336}
337//*************************************************************************************************
338
339
340//*************************************************************************************************
349template< typename A // Positive accuracy type
350 , typename T > // Floating point data type
351constexpr bool operator<( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
352{
354 return lhs < -Limits<T>::accuracy();
355}
356//*************************************************************************************************
357
358
359//*************************************************************************************************
368template< typename A // Positive accuracy type
369 , typename T > // Floating point data type
370constexpr bool operator>( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
371{
373 return -Limits<T>::accuracy() > rhs;
374}
375//*************************************************************************************************
376
377
378//*************************************************************************************************
387template< typename A // Positive accuracy type
388 , typename T > // Floating point data type
389constexpr bool operator>( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
390{
392 return lhs > -Limits<T>::accuracy();
393}
394//*************************************************************************************************
395
396
397//*************************************************************************************************
406template< typename A // Positive accuracy type
407 , typename T > // Floating point data type
408constexpr bool operator<=( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
409{
411 return -Limits<T>::accuracy() <= rhs;
412}
413//*************************************************************************************************
414
415
416//*************************************************************************************************
425template< typename A // Positive accuracy type
426 , typename T > // Floating point data type
427constexpr bool operator<=( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
428{
430 return lhs <= -Limits<T>::accuracy();
431}
432//*************************************************************************************************
433
434
435//*************************************************************************************************
444template< typename A // Positive accuracy type
445 , typename T > // Floating point data type
446constexpr bool operator>=( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
447{
449 return -Limits<T>::accuracy() >= rhs;
450}
451//*************************************************************************************************
452
453
454//*************************************************************************************************
463template< typename A // Positive accuracy type
464 , typename T > // Floating point data type
465constexpr bool operator>=( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
466{
468 return lhs >= -Limits<T>::accuracy();
469}
470//*************************************************************************************************
471
472
473
474
475
476
477
478
479//=================================================================================================
480//
481// CLASS DEFINITION
482//
483//=================================================================================================
484
485//*************************************************************************************************
502{
503 public:
504 //**Type definitions****************************************************************************
506 //**********************************************************************************************
507
508 //**Constructors********************************************************************************
511 constexpr Accuracy();
512 Accuracy( const Accuracy& ) = default;
514 //**********************************************************************************************
515
516 //**Destructor**********************************************************************************
519 ~Accuracy() = default;
521 //**********************************************************************************************
522
523 //**Unary plus/minus operators******************************************************************
526 constexpr const Accuracy& operator+() const;
527 constexpr const NegativeType operator-() const;
529 //**********************************************************************************************
530
531 //**Conversion operator*************************************************************************
534 template< typename T >
535 constexpr operator const T() const;
537 //**********************************************************************************************
538
539 //**Forbidden operations************************************************************************
542 Accuracy& operator=( const Accuracy& ) = delete;
543 void* operator&() const = delete;
545 //**********************************************************************************************
546};
547//*************************************************************************************************
548
549
550
551
552//=================================================================================================
553//
554// CONSTRUCTORS
555//
556//=================================================================================================
557
558//*************************************************************************************************
562{}
563//*************************************************************************************************
564
565
566
567
568//=================================================================================================
569//
570// UNARY PLUS/MINUS OPERATORS
571//
572//=================================================================================================
573
574//*************************************************************************************************
579constexpr const Accuracy& Accuracy::operator+() const
580{
581 return *this;
582}
583//*************************************************************************************************
584
585
586//*************************************************************************************************
592{
593 return NegativeType();
594}
595//*************************************************************************************************
596
597
598
599
600//=================================================================================================
601//
602// CONVERSION OPERATOR
603//
604//=================================================================================================
605
606//*************************************************************************************************
612template< typename T > // Floating point data type
613constexpr Accuracy::operator const T() const
614{
616 return Limits<T>::accuracy();
617}
618//*************************************************************************************************
619
620
621
622
623//=================================================================================================
624//
625// GLOBAL OPERATORS
626//
627//=================================================================================================
628
629//*************************************************************************************************
632template< typename T >
633constexpr bool operator==( const Accuracy& lhs, const T& rhs );
634
635template< typename T >
636constexpr bool operator==( const T& lhs, const Accuracy& rhs );
637
638template< typename T >
639constexpr bool operator!=( const Accuracy& lhs, const T& rhs );
640
641template< typename T >
642constexpr bool operator!=( const T& lhs, const Accuracy& rhs );
643
644template< typename T >
645constexpr bool operator<( const Accuracy& lhs, const T& rhs );
646
647template< typename T >
648constexpr bool operator<( const T& lhs, const Accuracy& rhs );
649
650template< typename T >
651constexpr bool operator>( const Accuracy& lhs, const T& rhs );
652
653template< typename T >
654constexpr bool operator>( const T& lhs, const Accuracy& rhs );
655
656template< typename T >
657constexpr bool operator<=( const Accuracy& lhs, const T& rhs );
658
659template< typename T >
660constexpr bool operator<=( const T& lhs, const Accuracy& rhs );
661
662template< typename T >
663constexpr bool operator>=( const Accuracy& lhs, const T& rhs );
664
665template< typename T >
666constexpr bool operator>=( const T& lhs, const Accuracy& rhs );
668//*************************************************************************************************
669
670
671//*************************************************************************************************
681template< typename T > // Floating point data type
682constexpr bool operator==( const Accuracy& /*lhs*/, const T& rhs )
683{
685 return Limits<T>::accuracy() == rhs;
686}
687//*************************************************************************************************
688
689
690//*************************************************************************************************
700template< typename T > // Floating point data type
701constexpr bool operator==( const T& lhs, const Accuracy& /*rhs*/ )
702{
704 return lhs == Limits<T>::accuracy();
705}
706//*************************************************************************************************
707
708
709//*************************************************************************************************
719template< typename T > // Floating point data type
720constexpr bool operator!=( const Accuracy& /*lhs*/, const T& rhs )
721{
723 return Limits<T>::accuracy() != rhs;
724}
725//*************************************************************************************************
726
727
728//*************************************************************************************************
738template< typename T > // Floating point data type
739constexpr bool operator!=( const T& lhs, const Accuracy& /*rhs*/ )
740{
742 return lhs != Limits<T>::accuracy();
743}
744//*************************************************************************************************
745
746
747//*************************************************************************************************
756template< typename T > // Floating point data type
757constexpr bool operator<( const Accuracy& /*lhs*/, const T& rhs )
758{
760 return Limits<T>::accuracy() < rhs;
761}
762//*************************************************************************************************
763
764
765//*************************************************************************************************
774template< typename T > // Floating point data type
775constexpr bool operator<( const T& lhs, const Accuracy& /*rhs*/ )
776{
779}
780//*************************************************************************************************
781
782
783//*************************************************************************************************
792template< typename T > // Floating point data type
793constexpr bool operator>( const Accuracy& /*lhs*/, const T& rhs )
794{
796 return Limits<T>::accuracy() > rhs;
797}
798//*************************************************************************************************
799
800
801//*************************************************************************************************
810template< typename T > // Floating point data type
811constexpr bool operator>( const T& lhs, const Accuracy& /*rhs*/ )
812{
814 return lhs > Limits<T>::accuracy();
815}
816//*************************************************************************************************
817
818
819//*************************************************************************************************
828template< typename T > // Floating point data type
829constexpr bool operator<=( const Accuracy& /*lhs*/, const T& rhs )
830{
832 return Limits<T>::accuracy() <= rhs;
833}
834//*************************************************************************************************
835
836
837//*************************************************************************************************
846template< typename T > // Floating point data type
847constexpr bool operator<=( const T& lhs, const Accuracy& /*rhs*/ )
848{
851}
852//*************************************************************************************************
853
854
855//*************************************************************************************************
864template< typename T > // Floating point data type
865constexpr bool operator>=( const Accuracy& /*lhs*/, const T& rhs )
866{
868 return Limits<T>::accuracy() >= rhs;
869}
870//*************************************************************************************************
871
872
873//*************************************************************************************************
882template< typename T > // Floating point data type
883constexpr bool operator>=( const T& lhs, const Accuracy& /*rhs*/ )
884{
886 return lhs >= Limits<T>::accuracy();
887}
888//*************************************************************************************************
889
890
891
892
893//=================================================================================================
894//
895// GLOBAL ACCURACY VALUE
896//
897//=================================================================================================
898
899//*************************************************************************************************
908//*************************************************************************************************
909
910} // namespace blaze
911
912#endif
Constraint on the data type.
Numerical limits of built-in data types.
Computation accuracy for floating point data types.
Definition: Accuracy.h:502
constexpr const NegativeType operator-() const
Returns the negative computation accuracy for all floating point data types.
Definition: Accuracy.h:591
constexpr Accuracy()
The default constructor of the Accuracy class.
Definition: Accuracy.h:561
constexpr const Accuracy & operator+() const
Returns the positive computation accuracy for all floating point data types.
Definition: Accuracy.h:579
NegativeAccuracy< Accuracy > NegativeType
The negated accuracy type.
Definition: Accuracy.h:505
Negative computation accuracy for floating point data types.
Definition: Accuracy.h:70
A PositiveType
The positive accuracy type.
Definition: Accuracy.h:73
constexpr const PositiveType operator-() const
Returns the positive computation accuracy for all floating point data types.
Definition: Accuracy.h:172
constexpr NegativeAccuracy()
The default constructor of the NegativeAccuracy class.
Definition: Accuracy.h:139
constexpr const NegativeAccuracy & operator+() const
Returns the negative computation accuracy for all floating point data types.
Definition: Accuracy.h:158
#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE(T)
Constraint on the data type.
Definition: FloatingPoint.h:61
constexpr bool operator<=(const T &lhs, const Accuracy &rhs)
Less-or-equal-than comparison between a floating point value and an Accuracy object.
Definition: Accuracy.h:847
constexpr bool operator==(const T &lhs, const Accuracy &rhs)
Equality comparison between a floating point value and an Accuracy object.
Definition: Accuracy.h:701
constexpr bool operator>=(const T &lhs, const Accuracy &rhs)
Less-or-equal-than comparison between a floating point value and an Accuracy object.
Definition: Accuracy.h:883
constexpr bool operator>(const T &lhs, const Accuracy &rhs)
Greater-than comparison between a floating point value and an Accuracy object.
Definition: Accuracy.h:811
constexpr bool operator<(const T &lhs, const Accuracy &rhs)
Less-than comparison between a floating point value and an Accuracy object.
Definition: Accuracy.h:775
constexpr Accuracy accuracy
Global Accuracy instance.
Definition: Accuracy.h:907
constexpr bool operator!=(const T &lhs, const Accuracy &rhs)
Inequality comparison between a floating point value and an Accuracy object.
Definition: Accuracy.h:739