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 
47 namespace blaze {
48 
49 //=================================================================================================
50 //
51 // CLASS DEFINITION
52 //
53 //=================================================================================================
54 
55 //*************************************************************************************************
68 template< typename A > // Positive accuracy type
70 {
71  public:
72  //**Type definitions****************************************************************************
73  using PositiveType = A;
74  //**********************************************************************************************
75 
76  private:
77  //**Constructors********************************************************************************
80  explicit inline constexpr NegativeAccuracy();
81  NegativeAccuracy( const NegativeAccuracy& ) = default;
83  //**********************************************************************************************
84 
85  public:
86  //**Destructor**********************************************************************************
89  ~NegativeAccuracy() = default;
91  //**********************************************************************************************
92 
93  //**Unary plus/minus operators******************************************************************
96  inline constexpr const NegativeAccuracy& operator+() const;
97  inline constexpr const PositiveType operator-() const;
99  //**********************************************************************************************
100 
101  //**Conversion operator*************************************************************************
104  template< typename T >
105  inline 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 //*************************************************************************************************
138 template< typename A > // Positive accuracy type
140 {}
141 //*************************************************************************************************
142 
143 
144 
145 
146 //=================================================================================================
147 //
148 // UNARY PLUS/MINUS OPERATORS
149 //
150 //=================================================================================================
151 
152 //*************************************************************************************************
157 template< typename A > // Positive accuracy type
159 {
160  return *this;
161 }
162 //*************************************************************************************************
163 
164 
165 //*************************************************************************************************
170 template< typename A > // Positive accuracy type
171 inline constexpr const typename NegativeAccuracy<A>::PositiveType
173 {
174  return PositiveType();
175 }
176 //*************************************************************************************************
177 
178 
179 
180 
181 //=================================================================================================
182 //
183 // CONVERSION OPERATOR
184 //
185 //=================================================================================================
186 
187 //*************************************************************************************************
193 template< typename A > // Positive accuracy type
194 template< typename T > // Floating point data type
195 inline constexpr 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 //*************************************************************************************************
214 template< typename A, typename T >
215 constexpr bool operator==( const NegativeAccuracy<A>& lhs, const T& rhs );
216 
217 template< typename A, typename T >
218 constexpr bool operator==( const T& lhs, const NegativeAccuracy<A>& rhs );
219 
220 template< typename A, typename T >
221 constexpr bool operator!=( const NegativeAccuracy<A>& lhs, const T& rhs );
222 
223 template< typename A, typename T >
224 constexpr bool operator!=( const T& lhs, const NegativeAccuracy<A>& rhs );
225 
226 template< typename A, typename T >
227 constexpr bool operator<( const NegativeAccuracy<A>& lhs, const T& rhs );
228 
229 template< typename A, typename T >
230 constexpr bool operator<( const T& lhs, const NegativeAccuracy<A>& rhs );
231 
232 template< typename A, typename T >
233 constexpr bool operator>( const NegativeAccuracy<A>& lhs, const T& rhs );
234 
235 template< typename A, typename T >
236 constexpr bool operator>( const T& lhs, const NegativeAccuracy<A>& rhs );
238 //*************************************************************************************************
239 
240 
241 //*************************************************************************************************
251 template< typename A // Positive accuracy type
252  , typename T > // Floating point data type
253 inline constexpr bool operator==( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
254 {
256  return -Limits<T>::accuracy() == rhs;
257 }
258 //*************************************************************************************************
259 
260 
261 //*************************************************************************************************
271 template< typename A // Positive accuracy type
272  , typename T > // Floating point data type
273 inline constexpr bool operator==( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
274 {
276  return lhs == -Limits<T>::accuracy();
277 }
278 //*************************************************************************************************
279 
280 
281 //*************************************************************************************************
291 template< typename A // Positive accuracy type
292  , typename T > // Floating point data type
293 inline constexpr bool operator!=( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
294 {
296  return -Limits<T>::accuracy() != rhs;
297 }
298 //*************************************************************************************************
299 
300 
301 //*************************************************************************************************
311 template< typename A // Positive accuracy type
312  , typename T > // Floating point data type
313 inline constexpr bool operator!=( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
314 {
316  return lhs != -Limits<T>::accuracy();
317 }
318 //*************************************************************************************************
319 
320 
321 //*************************************************************************************************
330 template< typename A // Positive accuracy type
331  , typename T > // Floating point data type
332 inline constexpr bool operator<( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
333 {
335  return -Limits<T>::accuracy() < rhs;
336 }
337 //*************************************************************************************************
338 
339 
340 //*************************************************************************************************
349 template< typename A // Positive accuracy type
350  , typename T > // Floating point data type
351 inline constexpr bool operator<( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
352 {
354  return lhs < -Limits<T>::accuracy();
355 }
356 //*************************************************************************************************
357 
358 
359 //*************************************************************************************************
368 template< typename A // Positive accuracy type
369  , typename T > // Floating point data type
370 inline constexpr bool operator>( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
371 {
373  return -Limits<T>::accuracy() > rhs;
374 }
375 //*************************************************************************************************
376 
377 
378 //*************************************************************************************************
387 template< typename A // Positive accuracy type
388  , typename T > // Floating point data type
389 inline constexpr bool operator>( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
390 {
392  return lhs > -Limits<T>::accuracy();
393 }
394 //*************************************************************************************************
395 
396 
397 //*************************************************************************************************
406 template< typename A // Positive accuracy type
407  , typename T > // Floating point data type
408 inline constexpr bool operator<=( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
409 {
411  return -Limits<T>::accuracy() <= rhs;
412 }
413 //*************************************************************************************************
414 
415 
416 //*************************************************************************************************
425 template< typename A // Positive accuracy type
426  , typename T > // Floating point data type
427 inline constexpr bool operator<=( const T& lhs, const NegativeAccuracy<A>& /*rhs*/ )
428 {
430  return lhs <= -Limits<T>::accuracy();
431 }
432 //*************************************************************************************************
433 
434 
435 //*************************************************************************************************
444 template< typename A // Positive accuracy type
445  , typename T > // Floating point data type
446 inline constexpr bool operator>=( const NegativeAccuracy<A>& /*lhs*/, const T& rhs )
447 {
449  return -Limits<T>::accuracy() >= rhs;
450 }
451 //*************************************************************************************************
452 
453 
454 //*************************************************************************************************
463 template< typename A // Positive accuracy type
464  , typename T > // Floating point data type
465 inline constexpr 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 //*************************************************************************************************
501 class Accuracy
502 {
503  public:
504  //**Type definitions****************************************************************************
506  //**********************************************************************************************
507 
508  //**Constructors********************************************************************************
511  explicit inline constexpr Accuracy();
512  Accuracy( const Accuracy& ) = default;
514  //**********************************************************************************************
515 
516  //**Destructor**********************************************************************************
519  ~Accuracy() = default;
521  //**********************************************************************************************
522 
523  //**Unary plus/minus operators******************************************************************
526  inline constexpr const Accuracy& operator+() const;
527  inline constexpr const NegativeType operator-() const;
529  //**********************************************************************************************
530 
531  //**Conversion operator*************************************************************************
534  template< typename T >
535  inline 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 //*************************************************************************************************
561 inline constexpr Accuracy::Accuracy()
562 {}
563 //*************************************************************************************************
564 
565 
566 
567 
568 //=================================================================================================
569 //
570 // UNARY PLUS/MINUS OPERATORS
571 //
572 //=================================================================================================
573 
574 //*************************************************************************************************
579 inline constexpr const Accuracy& Accuracy::operator+() const
580 {
581  return *this;
582 }
583 //*************************************************************************************************
584 
585 
586 //*************************************************************************************************
591 inline constexpr const Accuracy::NegativeType Accuracy::operator-() const
592 {
593  return NegativeType();
594 }
595 //*************************************************************************************************
596 
597 
598 
599 
600 //=================================================================================================
601 //
602 // CONVERSION OPERATOR
603 //
604 //=================================================================================================
605 
606 //*************************************************************************************************
612 template< typename T > // Floating point data type
613 inline constexpr 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 //*************************************************************************************************
632 template< typename T >
633 constexpr bool operator==( const Accuracy& lhs, const T& rhs );
634 
635 template< typename T >
636 constexpr bool operator==( const T& lhs, const Accuracy& rhs );
637 
638 template< typename T >
639 constexpr bool operator!=( const Accuracy& lhs, const T& rhs );
640 
641 template< typename T >
642 constexpr bool operator!=( const T& lhs, const Accuracy& rhs );
643 
644 template< typename T >
645 constexpr bool operator<( const Accuracy& lhs, const T& rhs );
646 
647 template< typename T >
648 constexpr bool operator<( const T& lhs, const Accuracy& rhs );
649 
650 template< typename T >
651 constexpr bool operator>( const Accuracy& lhs, const T& rhs );
652 
653 template< typename T >
654 constexpr bool operator>( const T& lhs, const Accuracy& rhs );
655 
656 template< typename T >
657 constexpr bool operator<=( const Accuracy& lhs, const T& rhs );
658 
659 template< typename T >
660 constexpr bool operator<=( const T& lhs, const Accuracy& rhs );
661 
662 template< typename T >
663 constexpr bool operator>=( const Accuracy& lhs, const T& rhs );
664 
665 template< typename T >
666 constexpr bool operator>=( const T& lhs, const Accuracy& rhs );
668 //*************************************************************************************************
669 
670 
671 //*************************************************************************************************
681 template< typename T > // Floating point data type
682 inline constexpr bool operator==( const Accuracy& /*lhs*/, const T& rhs )
683 {
685  return Limits<T>::accuracy() == rhs;
686 }
687 //*************************************************************************************************
688 
689 
690 //*************************************************************************************************
700 template< typename T > // Floating point data type
701 inline constexpr bool operator==( const T& lhs, const Accuracy& /*rhs*/ )
702 {
704  return lhs == Limits<T>::accuracy();
705 }
706 //*************************************************************************************************
707 
708 
709 //*************************************************************************************************
719 template< typename T > // Floating point data type
720 inline constexpr bool operator!=( const Accuracy& /*lhs*/, const T& rhs )
721 {
723  return Limits<T>::accuracy() != rhs;
724 }
725 //*************************************************************************************************
726 
727 
728 //*************************************************************************************************
738 template< typename T > // Floating point data type
739 inline constexpr bool operator!=( const T& lhs, const Accuracy& /*rhs*/ )
740 {
742  return lhs != Limits<T>::accuracy();
743 }
744 //*************************************************************************************************
745 
746 
747 //*************************************************************************************************
756 template< typename T > // Floating point data type
757 inline constexpr bool operator<( const Accuracy& /*lhs*/, const T& rhs )
758 {
760  return Limits<T>::accuracy() < rhs;
761 }
762 //*************************************************************************************************
763 
764 
765 //*************************************************************************************************
774 template< typename T > // Floating point data type
775 inline constexpr bool operator<( const T& lhs, const Accuracy& /*rhs*/ )
776 {
778  return lhs < Limits<T>::accuracy();
779 }
780 //*************************************************************************************************
781 
782 
783 //*************************************************************************************************
792 template< typename T > // Floating point data type
793 inline constexpr bool operator>( const Accuracy& /*lhs*/, const T& rhs )
794 {
796  return Limits<T>::accuracy() > rhs;
797 }
798 //*************************************************************************************************
799 
800 
801 //*************************************************************************************************
810 template< typename T > // Floating point data type
811 inline constexpr bool operator>( const T& lhs, const Accuracy& /*rhs*/ )
812 {
814  return lhs > Limits<T>::accuracy();
815 }
816 //*************************************************************************************************
817 
818 
819 //*************************************************************************************************
828 template< typename T > // Floating point data type
829 inline constexpr bool operator<=( const Accuracy& /*lhs*/, const T& rhs )
830 {
832  return Limits<T>::accuracy() <= rhs;
833 }
834 //*************************************************************************************************
835 
836 
837 //*************************************************************************************************
846 template< typename T > // Floating point data type
847 inline constexpr bool operator<=( const T& lhs, const Accuracy& /*rhs*/ )
848 {
851 }
852 //*************************************************************************************************
853 
854 
855 //*************************************************************************************************
864 template< typename T > // Floating point data type
865 inline constexpr bool operator>=( const Accuracy& /*lhs*/, const T& rhs )
866 {
868  return Limits<T>::accuracy() >= rhs;
869 }
870 //*************************************************************************************************
871 
872 
873 //*************************************************************************************************
882 template< typename T > // Floating point data type
883 inline constexpr 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 //*************************************************************************************************
907 constexpr Accuracy accuracy;
908 //*************************************************************************************************
909 
910 } // namespace blaze
911 
912 #endif
Numerical limits of built-in data types.
constexpr const PositiveType operator-() const
Returns the positive computation accuracy for all floating point data types.
Definition: Accuracy.h:172
constexpr Accuracy()
The default constructor of the Accuracy class.
Definition: Accuracy.h:561
constexpr bool operator<(const NegativeAccuracy< A > &lhs, const T &rhs)
Less-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:332
NegativeAccuracy< Accuracy > NegativeType
The negated accuracy type.
Definition: Accuracy.h:505
Computation accuracy for floating point data types.The Accuracy class is a wrapper class around the f...
Definition: Accuracy.h:501
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
Negative computation accuracy for floating point data types.The NegativeAccuracy class is a wrapper c...
Definition: Accuracy.h:69
constexpr bool operator>(const NegativeAccuracy< A > &lhs, const T &rhs)
Greater-than comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:370
constexpr bool operator>=(const NegativeAccuracy< A > &, const T &rhs)
Greater-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:446
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value. ...
Definition: Accuracy.h:253
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:293
constexpr const NegativeType operator-() const
Returns the negative computation accuracy for all floating point data types.
Definition: Accuracy.h:591
Constraint on the data type.
A PositiveType
The positive accuracy type.
Definition: Accuracy.h:73
constexpr bool operator<=(const NegativeAccuracy< A > &, const T &rhs)
Less-or-equal-than comparison between a NegativeAccuracy object and a floating point value...
Definition: Accuracy.h:408
constexpr const NegativeAccuracy & operator+() const
Returns the negative computation accuracy for all floating point data types.
Definition: Accuracy.h:158
constexpr NegativeAccuracy()
The default constructor of the NegativeAccuracy class.
Definition: Accuracy.h:139
constexpr const Accuracy & operator+() const
Returns the positive computation accuracy for all floating point data types.
Definition: Accuracy.h:579
constexpr Accuracy accuracy
Global Accuracy instance.The blaze::accuracy instance can be used wherever a floating point data type...
Definition: Accuracy.h:907
#define BLAZE_CONSTRAINT_MUST_BE_FLOATING_POINT_TYPE(T)
Constraint on the data type.In case the given data type T is not a floating point data type...
Definition: FloatingPoint.h:61