ITK  5.4.0
Insight Toolkit
itkMath.h
Go to the documentation of this file.
1 /*=========================================================================
2  *
3  * Copyright NumFOCUS
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at
8  *
9  * https://www.apache.org/licenses/LICENSE-2.0.txt
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  *
17  *=========================================================================*/
18 /*=========================================================================
19  *
20  * Portions of this file are subject to the VTK Toolkit Version 3 copyright.
21  *
22  * Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
23  *
24  * For complete copyright, license and disclaimer of warranty information
25  * please refer to the NOTICE file at the top of the ITK source tree.
26  *
27  *=========================================================================*/
28 #ifndef itkMath_h
29 #define itkMath_h
30 
31 #include <cassert>
32 #include <cmath>
33 #include "itkMathDetail.h"
34 #include "itkConceptChecking.h"
35 #include <vnl/vnl_math.h>
36 
37 /* Only maintain backwards compatibility with old versions
38  * of VXL back to the point where vnl_math:: was introduced
39  * versions of VXL where only vnl_math_ was available are not
40  * supported.
41  */
42 #include <vxl_version.h>
43 
44 
45 namespace itk
46 {
47 namespace Math
48 {
49 // These constants originate from VXL's vnl_math.h. They have been
50 // moved here to improve visibility, and to ensure that the constants
51 // are available during compile time ( as opposed to static ITK_CONSTEXPR
52 // member variables ).
53 
54 
56 static constexpr double e = vnl_math::e;
58 static constexpr double log2e = vnl_math::log2e;
60 static constexpr double log10e = vnl_math::log10e;
62 static constexpr double ln2 = vnl_math::ln2;
64 static constexpr double ln10 = vnl_math::ln10;
66 static constexpr double pi = vnl_math::pi;
68 static constexpr double twopi = vnl_math::twopi;
70 static constexpr double pi_over_2 = vnl_math::pi_over_2;
72 static constexpr double pi_over_4 = vnl_math::pi_over_4;
74 static constexpr double pi_over_180 = vnl_math::pi_over_180;
76 static constexpr double one_over_pi = vnl_math::one_over_pi;
78 static constexpr double two_over_pi = vnl_math::two_over_pi;
80 static constexpr double deg_per_rad = vnl_math::deg_per_rad;
82 static constexpr double sqrt2pi = vnl_math::sqrt2pi;
84 static constexpr double two_over_sqrtpi = vnl_math::two_over_sqrtpi;
86 static constexpr double one_over_sqrt2pi = vnl_math::one_over_sqrt2pi;
88 static constexpr double sqrt2 = vnl_math::sqrt2;
90 static constexpr double sqrt1_2 = vnl_math::sqrt1_2;
92 static constexpr double sqrt1_3 = vnl_math::sqrt1_3;
94 static constexpr double euler = vnl_math::euler;
95 
96 //: IEEE double machine precision
97 static constexpr double eps = vnl_math::eps;
98 static constexpr double sqrteps = vnl_math::sqrteps;
99 //: IEEE single machine precision
100 static constexpr float float_eps = vnl_math::float_eps;
101 static constexpr float float_sqrteps = vnl_math::float_sqrteps;
102 
106 #define itkTemplateFloatingToIntegerMacro(name) \
107  template <typename TReturn, typename TInput> \
108  inline TReturn name(TInput x) \
109  { \
110  if constexpr (sizeof(TReturn) <= 4) \
111  { \
112  return static_cast<TReturn>(Detail::name##_32(x)); \
113  } \
114  else if constexpr (sizeof(TReturn) <= 8) \
115  { \
116  return static_cast<TReturn>(Detail::name##_64(x)); \
117  } \
118  else \
119  { \
120  return static_cast<TReturn>(Detail::name##_base<TReturn, TInput>(x)); \
121  } \
122  }
123 
145 
169 
177 template <typename TReturn, typename TInput>
178 inline TReturn
179 Round(TInput x)
180 {
181  return RoundHalfIntegerUp<TReturn, TInput>(x);
182 }
183 
197 
209 
210 #undef itkTemplateFloatingToIntegerMacro
211 
212 template <typename TReturn, typename TInput>
213 inline TReturn
215 {
216 #ifdef ITK_USE_CONCEPT_CHECKING
217  itkConceptMacro(OnlyDefinedForIntegerTypes1, (itk::Concept::IsInteger<TReturn>));
218  itkConceptMacro(OnlyDefinedForIntegerTypes2, (itk::Concept::IsInteger<TInput>));
219 #endif // ITK_USE_CONCEPT_CHECKING
220 
221  auto ret = static_cast<TReturn>(x);
222  if constexpr (sizeof(TReturn) > sizeof(TInput) &&
224  {
225  // if the output type is bigger and we are not converting a signed
226  // integer to an unsigned integer then we have no problems
227  return ret;
228  }
229  else if constexpr (sizeof(TReturn) >= sizeof(TInput))
230  {
232  {
233  itk::RangeError _e(__FILE__, __LINE__);
234  throw _e;
235  }
236  }
237  else if (static_cast<TInput>(ret) != x ||
239  {
240  itk::RangeError _e(__FILE__, __LINE__);
241  throw _e;
242  }
243  return ret;
244 }
245 
253 template <typename T>
254 inline typename Detail::FloatIEEE<T>::IntType
256 {
257  Detail::FloatIEEE<T> x1f(x1);
258  Detail::FloatIEEE<T> x2f(x2);
259  return x1f.AsULP() - x2f.AsULP();
260 }
261 
269 template <typename T>
270 inline T
272 {
273  Detail::FloatIEEE<T> representInput(x);
274  Detail::FloatIEEE<T> representOutput(representInput.asInt + ulps);
275  return representOutput.asFloat;
276 }
277 
308 template <typename T>
309 inline bool
311  T x2,
312  typename Detail::FloatIEEE<T>::IntType maxUlps = 4,
313  typename Detail::FloatIEEE<T>::FloatType maxAbsoluteDifference = 0.1 *
315 {
316  // Check if the numbers are really close -- needed
317  // when comparing numbers near zero.
318  const T absDifference = std::abs(x1 - x2);
319  if (absDifference <= maxAbsoluteDifference)
320  {
321  return true;
322  }
323 
324  // This check for different signs is necessary for several reasons, see the blog link above.
325  // Subtracting the signed-magnitude representation of floats using twos-complement
326  // math isn't particularly meaningful, and the subtraction would produce a 33-bit
327  // result and overflow an int.
328  if (std::signbit(x1) != std::signbit(x2))
329  {
330  return false;
331  }
332 
333  typename Detail::FloatIEEE<T>::IntType ulps = FloatDifferenceULP(x1, x2);
334  if (ulps < 0)
335  {
336  ulps = -ulps;
337  }
338  return ulps <= maxUlps;
339 }
340 
341 // The following code cannot be moved to the itkMathDetail.h file without introducing circular dependencies
342 namespace Detail // The Detail namespace holds the templates used by AlmostEquals
343 {
344 // The following structs and templates are used to choose
345 // which version of the AlmostEquals function
346 // should be implemented base on input parameter types
347 
348 // Structs for choosing AlmostEquals function
349 
351 {
352  template <typename TFloatType1, typename TFloatType2>
353  static bool
354  AlmostEqualsFunction(TFloatType1 x1, TFloatType2 x2)
355  {
356  return FloatAlmostEqual<double>(x1, x2);
357  }
358 
359  template <typename TFloatType1, typename TFloatType2>
360  static bool
361  AlmostEqualsFunction(double x1, double x2)
362  {
363  return FloatAlmostEqual<double>(x1, x2);
364  }
365 
366  template <typename TFloatType1, typename TFloatType2>
367  static bool
368  AlmostEqualsFunction(double x1, float x2)
369  {
370  return FloatAlmostEqual<float>(x1, x2);
371  }
372 
373  template <typename TFloatType1, typename TFloatType2>
374  static bool
375  AlmostEqualsFunction(float x1, double x2)
376  {
377  return FloatAlmostEqual<float>(x1, x2);
378  }
379 
380  template <typename TFloatType1, typename TFloatType2>
381  static bool
382  AlmostEqualsFunction(float x1, float x2)
383  {
384  return FloatAlmostEqual<float>(x1, x2);
385  }
386 };
387 
389 {
390  template <typename TFloatType, typename TIntType>
391  static bool
392  AlmostEqualsFunction(TFloatType floatingVariable, TIntType integerVariable)
393  {
394  return FloatAlmostEqual<TFloatType>(floatingVariable, integerVariable);
395  }
396 };
397 
399 {
400  template <typename TIntType, typename TFloatType>
401  static bool
402  AlmostEqualsFunction(TIntType integerVariable, TFloatType floatingVariable)
403  {
404  return AlmostEqualsFloatVsInteger::AlmostEqualsFunction(floatingVariable, integerVariable);
405  }
406 };
407 
409 {
410  template <typename TSignedInt, typename TUnsignedInt>
411  static bool
412  AlmostEqualsFunction(TSignedInt signedVariable, TUnsignedInt unsignedVariable)
413  {
414  if (signedVariable < 0)
415  {
416  return false;
417  }
418  if (unsignedVariable > static_cast<size_t>(itk::NumericTraits<TSignedInt>::max()))
419  {
420  return false;
421  }
422  return signedVariable == static_cast<TSignedInt>(unsignedVariable);
423  }
424 };
425 
427 {
428  template <typename TUnsignedInt, typename TSignedInt>
429  static bool
430  AlmostEqualsFunction(TUnsignedInt unsignedVariable, TSignedInt signedVariable)
431  {
432  return AlmostEqualsSignedVsUnsigned::AlmostEqualsFunction(signedVariable, unsignedVariable);
433  }
434 };
435 
437 {
438  template <typename TIntegerType1, typename TIntegerType2>
439  static bool
440  AlmostEqualsFunction(TIntegerType1 x1, TIntegerType2 x2)
441  {
442  return x1 == x2;
443  }
444 };
445 // end of structs that choose the specific AlmostEquals function
446 
447 // Selector structs, these select the correct case based on its types
448 // input1 is int? input 1 is signed? input2 is int? input 2 is signed?
449 template <bool TInput1IsIntger, bool TInput1IsSigned, bool TInput2IsInteger, bool TInput2IsSigned>
451 { // default case
453 };
454 
456 template <>
457 struct AlmostEqualsFunctionSelector<false, true, false, true>
458 // floating type v floating type
459 {
461 };
462 
463 template <>
464 struct AlmostEqualsFunctionSelector<false, true, true, true>
465 // float vs int
466 {
467  using SelectedVersion = AlmostEqualsFloatVsInteger;
468 };
469 
470 template <>
471 struct AlmostEqualsFunctionSelector<false, true, true, false>
472 // float vs unsigned int
473 {
474  using SelectedVersion = AlmostEqualsFloatVsInteger;
475 };
476 
477 template <>
478 struct AlmostEqualsFunctionSelector<true, false, false, true>
479 // unsigned int vs float
480 {
481  using SelectedVersion = AlmostEqualsIntegerVsFloat;
482 };
483 
484 template <>
485 struct AlmostEqualsFunctionSelector<true, true, false, true>
486 // int vs float
487 {
488  using SelectedVersion = AlmostEqualsIntegerVsFloat;
489 };
490 
491 template <>
492 struct AlmostEqualsFunctionSelector<true, true, true, false>
493 // signed vs unsigned
494 {
495  using SelectedVersion = AlmostEqualsSignedVsUnsigned;
496 };
497 
498 template <>
499 struct AlmostEqualsFunctionSelector<true, false, true, true>
500 // unsigned vs signed
501 {
502  using SelectedVersion = AlmostEqualsUnsignedVsSigned;
503 };
504 
505 template <>
506 struct AlmostEqualsFunctionSelector<true, true, true, true>
507 // signed vs signed
508 {
509  using SelectedVersion = AlmostEqualsPlainOldEquals;
510 };
511 
512 template <>
513 struct AlmostEqualsFunctionSelector<true, false, true, false>
514 // unsigned vs unsigned
515 {
516  using SelectedVersion = AlmostEqualsPlainOldEquals;
517 };
518 // end of AlmostEqualsFunctionSelector structs
519 
520 // The implementor tells the selector what to do
521 template <typename TInputType1, typename TInputType2>
522 struct AlmostEqualsScalarImplementer
523 {
524  static constexpr bool TInputType1IsInteger = std::is_integral_v<TInputType1>;
525  static constexpr bool TInputType1IsSigned = std::is_signed_v<TInputType1>;
526  static constexpr bool TInputType2IsInteger = std::is_integral_v<TInputType2>;
527  static constexpr bool TInputType2IsSigned = std::is_signed_v<TInputType2>;
528 
529  using SelectedVersion = typename AlmostEqualsFunctionSelector<TInputType1IsInteger,
530  TInputType1IsSigned,
531  TInputType2IsInteger,
532  TInputType2IsSigned>::SelectedVersion;
533 };
534 
535 // The AlmostEqualsScalarComparer returns the result of an
536 // approximate comparison between two scalar values of
537 // potentially different data types.
538 template <typename TScalarType1, typename TScalarType2>
539 inline bool
540 AlmostEqualsScalarComparer(TScalarType1 x1, TScalarType2 x2)
541 {
542  return AlmostEqualsScalarImplementer<TScalarType1, TScalarType2>::SelectedVersion::
543  template AlmostEqualsFunction<TScalarType1, TScalarType2>(x1, x2);
544 }
545 
546 // The following structs are used to evaluate approximate comparisons between
547 // complex and scalar values of potentially different types.
548 
549 // Comparisons between scalar types use the AlmostEqualsScalarComparer function.
550 struct AlmostEqualsScalarVsScalar
551 {
552  template <typename TScalarType1, typename TScalarType2>
553  static bool
554  AlmostEqualsFunction(TScalarType1 x1, TScalarType2 x2)
555  {
556  return AlmostEqualsScalarComparer(x1, x2);
557  }
558 };
559 
560 // Comparisons between two complex values compare the real and imaginary components
561 // separately with the AlmostEqualsScalarComparer function.
562 struct AlmostEqualsComplexVsComplex
563 {
564  template <typename TComplexType1, typename TComplexType2>
565  static bool
566  AlmostEqualsFunction(TComplexType1 x1, TComplexType2 x2)
567  {
568  return AlmostEqualsScalarComparer(x1.real(), x2.real()) && AlmostEqualsScalarComparer(x1.imag(), x2.imag());
569  }
570 };
571 
572 // Comparisons between complex and scalar values first check to see if the imaginary component
573 // of the complex value is approximately 0. Then a ScalarComparison is done between the real
574 // part of the complex number and the scalar value.
575 struct AlmostEqualsScalarVsComplex
576 {
577  template <typename TScalarType, typename TComplexType>
578  static bool
579  AlmostEqualsFunction(TScalarType scalarVariable, TComplexType complexVariable)
580  {
581  if (!AlmostEqualsScalarComparer(complexVariable.imag(), typename itk::NumericTraits<TComplexType>::ValueType{}))
582  {
583  return false;
584  }
585  return AlmostEqualsScalarComparer(scalarVariable, complexVariable.real());
586  }
587 };
588 
589 struct AlmostEqualsComplexVsScalar
590 {
591  template <typename TComplexType, typename TScalarType>
592  static bool
593  AlmostEqualsFunction(TComplexType complexVariable, TScalarType scalarVariable)
594  {
595  return AlmostEqualsScalarVsComplex::AlmostEqualsFunction(scalarVariable, complexVariable);
596  }
597 };
598 
599 // The AlmostEqualsComplexChooser structs choose the correct case
600 // from the input parameter types' IsComplex property
601 // The default case is scalar vs scalar
602 template <bool T1IsComplex, bool T2IsComplex> // Default is false, false
603 struct AlmostEqualsComplexChooser
604 {
605  using ChosenVersion = AlmostEqualsScalarVsScalar;
606 };
607 
608 template <>
609 struct AlmostEqualsComplexChooser<true, true>
610 {
611  using ChosenVersion = AlmostEqualsComplexVsComplex;
612 };
613 
614 template <>
615 struct AlmostEqualsComplexChooser<false, true>
616 {
617  using ChosenVersion = AlmostEqualsScalarVsComplex;
618 };
619 
620 template <>
621 struct AlmostEqualsComplexChooser<true, false>
622 {
623  using ChosenVersion = AlmostEqualsComplexVsScalar;
624 };
625 // End of AlmostEqualsComplexChooser structs.
626 
627 // The AlmostEqualsComplexImplementer determines which of the input
628 // parameters are complex and which are real, and sends that information
629 // to the AlmostEqualsComplexChooser structs to determine the proper
630 // type of evaluation.
631 template <typename T1, typename T2>
632 struct AlmostEqualsComplexImplementer
633 {
634  static constexpr bool T1IsComplex = NumericTraits<T1>::IsComplex;
635  static constexpr bool T2IsComplex = NumericTraits<T2>::IsComplex;
636 
637  using ChosenVersion = typename AlmostEqualsComplexChooser<T1IsComplex, T2IsComplex>::ChosenVersion;
638 };
640 
641 } // end namespace Detail
642 
685 // The AlmostEquals function
686 template <typename T1, typename T2>
687 inline bool
688 AlmostEquals(T1 x1, T2 x2)
689 {
690  return Detail::AlmostEqualsComplexImplementer<T1, T2>::ChosenVersion::AlmostEqualsFunction(x1, x2);
691 }
692 
693 // The NotAlmostEquals function
694 template <typename T1, typename T2>
695 inline bool
696 NotAlmostEquals(T1 x1, T2 x2)
697 {
698  return !AlmostEquals(x1, x2);
699 }
700 
701 
723 // The ExactlyEquals function
724 template <typename TInput1, typename TInput2>
725 inline bool
726 ExactlyEquals(const TInput1 & x1, const TInput2 & x2)
727 {
728  CLANG_PRAGMA_PUSH
729  CLANG_SUPPRESS_Wfloat_equal return x1 == x2;
730  CLANG_PRAGMA_POP
731 }
732 
733 // The NotExactlyEquals function
734 template <typename TInput1, typename TInput2>
735 inline bool
736 NotExactlyEquals(const TInput1 & x1, const TInput2 & x2)
737 {
738  return !ExactlyEquals(x1, x2);
739 }
740 
741 
746 ITKCommon_EXPORT bool
747 IsPrime(unsigned short n);
748 ITKCommon_EXPORT bool
749 IsPrime(unsigned int n);
750 ITKCommon_EXPORT bool
751 IsPrime(unsigned long n);
752 ITKCommon_EXPORT bool
753 IsPrime(unsigned long long n);
758 ITKCommon_EXPORT unsigned short
759 GreatestPrimeFactor(unsigned short n);
760 ITKCommon_EXPORT unsigned int
761 GreatestPrimeFactor(unsigned int n);
762 ITKCommon_EXPORT unsigned long
763 GreatestPrimeFactor(unsigned long n);
764 ITKCommon_EXPORT unsigned long long
765 GreatestPrimeFactor(unsigned long long n);
772 template <typename TReturnType = uintmax_t>
773 constexpr TReturnType
774 UnsignedProduct(const uintmax_t a, const uintmax_t b) noexcept
775 {
776  static_assert(std::is_unsigned_v<TReturnType>, "UnsignedProduct only supports unsigned return types");
777 
778  // Note that numeric overflow is not "undefined behavior", for unsigned numbers.
779  // This function checks if the result of a*b is mathematically correct.
780  return (a == 0) || (b == 0) ||
781  (((static_cast<TReturnType>(a * b) / a) == b) && ((static_cast<TReturnType>(a * b) / b) == a))
782  ? static_cast<TReturnType>(a * b)
783  : (assert(!"UnsignedProduct overflow!"), 0);
784 }
785 
786 
794 template <typename TReturnType = uintmax_t>
795 constexpr TReturnType
796 UnsignedPower(const uintmax_t base, const uintmax_t exponent) noexcept
797 {
798  static_assert(std::is_unsigned_v<TReturnType>, "UnsignedPower only supports unsigned return types");
799 
800  // Uses recursive function calls because C++11 does not support other ways of
801  // iterations for a constexpr function.
802  return (exponent == 0)
803  ? (assert(base > 0), 1)
804  : (exponent == 1) ? base
805  : UnsignedProduct<TReturnType>(UnsignedPower<TReturnType>(base, exponent / 2),
806  UnsignedPower<TReturnType>(base, (exponent + 1) / 2));
807 }
808 
809 
810 /*==========================================
811  * Alias the vnl_math functions in the itk::Math
812  * namespace. If possible, use the std:: equivalents
813  */
814 using std::isnan;
815 using std::isinf;
816 using std::isfinite;
817 using std::isnormal;
818 using std::cbrt;
819 using std::hypot;
820 using vnl_math::angle_0_to_2pi;
821 using vnl_math::angle_minuspi_to_pi;
822 using vnl_math::rnd_halfinttoeven;
823 using vnl_math::rnd_halfintup;
824 using vnl_math::rnd;
825 using vnl_math::floor;
826 using vnl_math::ceil;
827 using vnl_math::sgn;
828 using vnl_math::sgn0;
829 using vnl_math::remainder_truncated;
830 using vnl_math::remainder_floored;
831 using vnl_math::sqr;
832 using vnl_math::cube;
833 using vnl_math::squared_magnitude;
834 
835 
836 /*============================================
837 Decouple dependence and exposure of vnl_math::abs operations
838 in ITK. Placing this small amount of duplicate vnl_math
839 code directly in ITK removes backward compatibility
840 issues with system installed VXL versions.
841 */
842 inline bool
843 abs(bool x)
844 {
845  return x;
846 }
847 inline unsigned char
848 abs(unsigned char x)
849 {
850  return x;
851 }
852 inline unsigned char
853 abs(signed char x)
854 {
855  return x < 0 ? static_cast<unsigned char>(-x) : x;
856 }
857 inline unsigned char
858 abs(char x)
859 {
860  return static_cast<unsigned char>(x);
861 }
862 inline unsigned short
863 abs(short x)
864 {
865  return x < 0 ? static_cast<unsigned short>(-x) : x;
866 }
867 inline unsigned short
868 abs(unsigned short x)
869 {
870  return x;
871 }
872 inline unsigned int
873 abs(unsigned int x)
874 {
875  return x;
876 }
877 inline unsigned long
878 abs(unsigned long x)
879 {
880  return x;
881 }
882 // long long - target type will have width of at least 64 bits. (since C++11)
883 inline unsigned long long
884 abs(unsigned long long x)
885 {
886  return x;
887 }
888 
889 using std::abs;
890 
891 } // end namespace Math
892 } // end namespace itk
893 
894 #endif // end of itkMath.h
itk::Math::Detail::AlmostEqualsFloatVsFloat::AlmostEqualsFunction
static bool AlmostEqualsFunction(double x1, double x2)
Definition: itkMath.h:361
itk::Math::FloatAddULP
T FloatAddULP(T x, typename Detail::FloatIEEE< T >::IntType ulps)
Add the given ULPs (units in the last place) to a float.
Definition: itkMath.h:271
itk::Math::GreatestPrimeFactor
ITKCommon_EXPORT unsigned short GreatestPrimeFactor(unsigned short n)
itk::Math::Detail::AlmostEqualsUnsignedVsSigned::AlmostEqualsFunction
static bool AlmostEqualsFunction(TUnsignedInt unsignedVariable, TSignedInt signedVariable)
Definition: itkMath.h:430
itk::Math::euler
static constexpr double euler
euler constant
Definition: itkMath.h:94
itk::Math::Detail::AlmostEqualsFloatVsFloat::AlmostEqualsFunction
static bool AlmostEqualsFunction(TFloatType1 x1, TFloatType2 x2)
Definition: itkMath.h:354
itk::Math::sqrt1_2
static constexpr double sqrt1_2
Definition: itkMath.h:90
itk::Math::Detail::FloatIEEE::FloatType
T FloatType
Definition: itkMathDetail.h:492
itk::Math::Detail::AlmostEqualsSignedVsUnsigned::AlmostEqualsFunction
static bool AlmostEqualsFunction(TSignedInt signedVariable, TUnsignedInt unsignedVariable)
Definition: itkMath.h:412
itk::Math::Detail::AlmostEqualsSignedVsUnsigned
Definition: itkMath.h:408
itk::Math::sqrt1_3
static constexpr double sqrt1_3
Definition: itkMath.h:92
itk::Math::Detail::FloatIEEE::IntType
typename FloatIEEETraits< T >::IntType IntType
Definition: itkMathDetail.h:493
itk::NumericTraits::ValueType
T ValueType
Definition: itkNumericTraits.h:66
itk::Math::Round
TReturn Round(TInput x)
Round towards nearest integer (This is a synonym for RoundHalfIntegerUp)
Definition: itkMath.h:179
itkMathDetail.h
itk::Math::one_over_sqrt2pi
static constexpr double one_over_sqrt2pi
Definition: itkMath.h:86
itk::Math::Detail::AlmostEqualsFunctionSelector::SelectedVersion
AlmostEqualsPlainOldEquals SelectedVersion
Definition: itkMath.h:452
itk::Math::UnsignedProduct
constexpr TReturnType UnsignedProduct(const uintmax_t a, const uintmax_t b) noexcept
Definition: itkMath.h:774
itk::Math::Detail::FloatIEEE
Definition: itkMathDetail.h:490
itk::Math::Detail::AlmostEqualsFloatVsFloat
Definition: itkMath.h:350
itk::Math::ExactlyEquals
bool ExactlyEquals(const TInput1 &x1, const TInput2 &x2)
Return the result of an exact comparison between two scalar values of potentially different types.
Definition: itkMath.h:726
itk::Math::Detail::AlmostEqualsIntegerVsFloat::AlmostEqualsFunction
static bool AlmostEqualsFunction(TIntType integerVariable, TFloatType floatingVariable)
Definition: itkMath.h:402
itkConceptChecking.h
itk::Math::Detail::FloatIEEE::AsULP
IntType AsULP() const
Definition: itkMathDetail.h:512
itk::Math::RoundHalfIntegerUp
RoundHalfIntegerUp(TInput x)
Round towards nearest integer.
itk::Math::NotExactlyEquals
bool NotExactlyEquals(const TInput1 &x1, const TInput2 &x2)
Definition: itkMath.h:736
itkTemplateFloatingToIntegerMacro
#define itkTemplateFloatingToIntegerMacro(name)
Definition: itkMath.h:106
itk::Math::pi_over_4
static constexpr double pi_over_4
Definition: itkMath.h:72
itk::Math::abs
bool abs(bool x)
Definition: itkMath.h:843
itk::Math::sqrt2pi
static constexpr double sqrt2pi
Definition: itkMath.h:82
itk::Concept::IsInteger
Definition: itkConceptChecking.h:875
itk::Math::float_eps
static constexpr float float_eps
Definition: itkMath.h:100
itk::Math::eps
static constexpr double eps
Definition: itkMath.h:97
itk::Math::two_over_sqrtpi
static constexpr double two_over_sqrtpi
Definition: itkMath.h:84
itk::Math::one_over_pi
static constexpr double one_over_pi
Definition: itkMath.h:76
itk::Math::Detail::AlmostEqualsPlainOldEquals
Definition: itkMath.h:436
itk::Math::log10e
static constexpr double log10e
Definition: itkMath.h:60
itk::Math::ln10
static constexpr double ln10
Definition: itkMath.h:64
itk::Math::Detail::AlmostEqualsFloatVsFloat::AlmostEqualsFunction
static bool AlmostEqualsFunction(double x1, float x2)
Definition: itkMath.h:368
itk::Math::RoundHalfIntegerToEven
RoundHalfIntegerToEven(TInput x)
Round towards nearest integer.
itk::Math::Detail::AlmostEqualsUnsignedVsSigned
Definition: itkMath.h:426
itk::Math::Floor
Floor(TInput x)
Round towards minus infinity.
itk::Math::log2e
static constexpr double log2e
Definition: itkMath.h:58
itk::Math::NotAlmostEquals
bool NotAlmostEquals(T1 x1, T2 x2)
Definition: itkMath.h:696
itk::Math::CastWithRangeCheck
TReturn CastWithRangeCheck(TInput x)
Definition: itkMath.h:214
itk::Math::UnsignedPower
constexpr TReturnType UnsignedPower(const uintmax_t base, const uintmax_t exponent) noexcept
Definition: itkMath.h:796
itk::Math::Detail::FloatIEEE::asInt
IntType asInt
Definition: itkMathDetail.h:497
itk::Math::FloatAlmostEqual
bool FloatAlmostEqual(T x1, T x2, typename Detail::FloatIEEE< T >::IntType maxUlps=4, typename Detail::FloatIEEE< T >::FloatType maxAbsoluteDifference=0.1 *itk::NumericTraits< T >::epsilon())
Compare two floats and return if they are effectively equal.
Definition: itkMath.h:310
itk::Math::pi_over_2
static constexpr double pi_over_2
Definition: itkMath.h:70
itk::Math::pi_over_180
static constexpr double pi_over_180
Definition: itkMath.h:74
itk::Math::Detail::AlmostEqualsFloatVsInteger
Definition: itkMath.h:388
itk::NumericTraits
Define additional traits for native types such as int or float.
Definition: itkNumericTraits.h:59
itk::Math::sqrt2
static constexpr double sqrt2
Definition: itkMath.h:88
itk::Math::deg_per_rad
static constexpr double deg_per_rad
Definition: itkMath.h:80
itk::Math::IsPrime
ITKCommon_EXPORT bool IsPrime(unsigned short n)
itk::Math::Detail::AlmostEqualsFloatVsInteger::AlmostEqualsFunction
static bool AlmostEqualsFunction(TFloatType floatingVariable, TIntType integerVariable)
Definition: itkMath.h:392
itk::Math::float_sqrteps
static constexpr float float_sqrteps
Definition: itkMath.h:101
itkConceptMacro
#define itkConceptMacro(name, concept)
Definition: itkConceptChecking.h:65
itk::Math::Detail::AlmostEqualsPlainOldEquals::AlmostEqualsFunction
static bool AlmostEqualsFunction(TIntegerType1 x1, TIntegerType2 x2)
Definition: itkMath.h:440
itk::Math::Detail::AlmostEqualsFloatVsFloat::AlmostEqualsFunction
static bool AlmostEqualsFunction(float x1, double x2)
Definition: itkMath.h:375
itk
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
Definition: itkAnnulusOperator.h:24
itk::NumericTraits::IsComplex
static constexpr bool IsComplex
Definition: itkNumericTraits.h:144
itk::Math::Ceil
Ceil(TInput x)
Round towards plus infinity.
itk::Math::two_over_pi
static constexpr double two_over_pi
Definition: itkMath.h:78
itk::Math::AlmostEquals
bool AlmostEquals(T1 x1, T2 x2)
Provide consistent equality checks between values of potentially different scalar or complex types.
Definition: itkMath.h:688
itk::Math::e
static constexpr double e
Definition: itkMath.h:56
itk::Math::abs
unsigned long long abs(unsigned long long x)
Definition: itkMath.h:884
itk::Math::Detail::AlmostEqualsFloatVsFloat::AlmostEqualsFunction
static bool AlmostEqualsFunction(float x1, float x2)
Definition: itkMath.h:382
itk::Math::Detail::AlmostEqualsIntegerVsFloat
Definition: itkMath.h:398
itk::Math::pi
static constexpr double pi
Definition: itkMath.h:66
itk::Math::FloatDifferenceULP
Detail::FloatIEEE< T >::IntType FloatDifferenceULP(T x1, T x2)
Return the signed distance in ULPs (units in the last place) between two floats.
Definition: itkMath.h:255
itk::Math::twopi
static constexpr double twopi
Definition: itkMath.h:68
itk::Math::Detail::FloatIEEE::asFloat
FloatType asFloat
Definition: itkMathDetail.h:496
itk::Math::sqrteps
static constexpr double sqrteps
Definition: itkMath.h:98
itk::Math::ln2
static constexpr double ln2
Definition: itkMath.h:62
itk::Math::Detail::AlmostEqualsFunctionSelector
Definition: itkMath.h:450