ITK  6.0.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
45namespace itk
46{
47namespace 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
56static constexpr double e = vnl_math::e;
58static constexpr double log2e = vnl_math::log2e;
60static constexpr double log10e = vnl_math::log10e;
62static constexpr double ln2 = vnl_math::ln2;
64static constexpr double ln10 = vnl_math::ln10;
66static constexpr double pi = vnl_math::pi;
68static constexpr double twopi = vnl_math::twopi;
70static constexpr double pi_over_2 = vnl_math::pi_over_2;
72static constexpr double pi_over_4 = vnl_math::pi_over_4;
74static constexpr double pi_over_180 = vnl_math::pi_over_180;
76static constexpr double one_over_pi = vnl_math::one_over_pi;
78static constexpr double two_over_pi = vnl_math::two_over_pi;
80static constexpr double deg_per_rad = vnl_math::deg_per_rad;
82static constexpr double sqrt2pi = vnl_math::sqrt2pi;
88static constexpr double sqrt2 = vnl_math::sqrt2;
90static constexpr double sqrt1_2 = vnl_math::sqrt1_2;
92static constexpr double sqrt1_3 = vnl_math::sqrt1_3;
94static constexpr double euler = vnl_math::euler;
95
96//: IEEE double machine precision
97static constexpr double eps = vnl_math::eps;
98static constexpr double sqrteps = vnl_math::sqrteps;
99//: IEEE single machine precision
100static constexpr float float_eps = vnl_math::float_eps;
101static 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 }
145
146
169
177template <typename TReturn, typename TInput>
178inline TReturn
179Round(TInput x)
180{
181 return RoundHalfIntegerUp<TReturn, TInput>(x);
182}
183
197
198
209
210#undef itkTemplateFloatingToIntegerMacro
211
212template <typename TReturn, typename TInput>
213inline 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
253template <typename T>
254inline 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
269template <typename T>
270inline T
272{
273 Detail::FloatIEEE<T> representInput(x);
274 Detail::FloatIEEE<T> representOutput(representInput.asInt + ulps);
275 return representOutput.asFloat;
276}
277
308template <typename T>
309inline 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
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
342namespace 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?
449template <bool TInput1IsIntger, bool TInput1IsSigned, bool TInput2IsInteger, bool TInput2IsSigned>
451{ // default case
453};
454
456template <>
457struct AlmostEqualsFunctionSelector<false, true, false, true>
458// floating type v floating type
459{
461};
462
463template <>
464struct AlmostEqualsFunctionSelector<false, true, true, true>
465// float vs int
466{
467 using SelectedVersion = AlmostEqualsFloatVsInteger;
468};
469
470template <>
471struct AlmostEqualsFunctionSelector<false, true, true, false>
472// float vs unsigned int
473{
474 using SelectedVersion = AlmostEqualsFloatVsInteger;
475};
476
477template <>
478struct AlmostEqualsFunctionSelector<true, false, false, true>
479// unsigned int vs float
480{
481 using SelectedVersion = AlmostEqualsIntegerVsFloat;
482};
483
484template <>
485struct AlmostEqualsFunctionSelector<true, true, false, true>
486// int vs float
487{
488 using SelectedVersion = AlmostEqualsIntegerVsFloat;
489};
490
491template <>
492struct AlmostEqualsFunctionSelector<true, true, true, false>
493// signed vs unsigned
494{
495 using SelectedVersion = AlmostEqualsSignedVsUnsigned;
496};
497
498template <>
499struct AlmostEqualsFunctionSelector<true, false, true, true>
500// unsigned vs signed
501{
502 using SelectedVersion = AlmostEqualsUnsignedVsSigned;
503};
504
505template <>
506struct AlmostEqualsFunctionSelector<true, true, true, true>
507// signed vs signed
508{
509 using SelectedVersion = AlmostEqualsPlainOldEquals;
510};
511
512template <>
513struct 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
521template <typename TInputType1, typename TInputType2>
522struct 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.
538template <typename TScalarType1, typename TScalarType2>
539inline bool
540AlmostEqualsScalarComparer(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.
550struct 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.
562struct 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.
575struct 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
589struct 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
602template <bool T1IsComplex, bool T2IsComplex> // Default is false, false
603struct AlmostEqualsComplexChooser
604{
605 using ChosenVersion = AlmostEqualsScalarVsScalar;
606};
607
608template <>
609struct AlmostEqualsComplexChooser<true, true>
610{
611 using ChosenVersion = AlmostEqualsComplexVsComplex;
612};
613
614template <>
615struct AlmostEqualsComplexChooser<false, true>
616{
617 using ChosenVersion = AlmostEqualsScalarVsComplex;
618};
619
620template <>
621struct 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.
631template <typename T1, typename T2>
632struct 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
686template <typename T1, typename T2>
687inline bool
688AlmostEquals(T1 x1, T2 x2)
689{
690 return Detail::AlmostEqualsComplexImplementer<T1, T2>::ChosenVersion::AlmostEqualsFunction(x1, x2);
691}
692
693// The NotAlmostEquals function
694template <typename T1, typename T2>
695inline bool
696NotAlmostEquals(T1 x1, T2 x2)
697{
698 return !AlmostEquals(x1, x2);
699}
700
701
723// The ExactlyEquals function
724template <typename TInput1, typename TInput2>
725inline bool
726ExactlyEquals(const TInput1 & x1, const TInput2 & x2)
727{
728 ITK_GCC_PRAGMA_PUSH
729 ITK_GCC_SUPPRESS_Wfloat_equal
730 return x1 == x2;
731 ITK_GCC_PRAGMA_POP
732}
733
734// The NotExactlyEquals function
735template <typename TInput1, typename TInput2>
736inline bool
737NotExactlyEquals(const TInput1 & x1, const TInput2 & x2)
738{
739 return !ExactlyEquals(x1, x2);
740}
741
742
747ITKCommon_EXPORT bool
748IsPrime(unsigned short n);
749ITKCommon_EXPORT bool
750IsPrime(unsigned int n);
751ITKCommon_EXPORT bool
752IsPrime(unsigned long n);
753ITKCommon_EXPORT bool
754IsPrime(unsigned long long n);
759ITKCommon_EXPORT unsigned short
760GreatestPrimeFactor(unsigned short n);
761ITKCommon_EXPORT unsigned int
762GreatestPrimeFactor(unsigned int n);
763ITKCommon_EXPORT unsigned long
764GreatestPrimeFactor(unsigned long n);
765ITKCommon_EXPORT unsigned long long
766GreatestPrimeFactor(unsigned long long n);
773template <typename TReturnType = uintmax_t>
774constexpr TReturnType
775UnsignedProduct(const uintmax_t a, const uintmax_t b) noexcept
776{
777 static_assert(std::is_unsigned_v<TReturnType>, "UnsignedProduct only supports unsigned return types");
778
779 // Note that numeric overflow is not "undefined behavior", for unsigned numbers.
780 // This function checks if the result of a*b is mathematically correct.
781 return (a == 0) || (b == 0) ||
782 (((static_cast<TReturnType>(a * b) / a) == b) && ((static_cast<TReturnType>(a * b) / b) == a))
783 ? static_cast<TReturnType>(a * b)
784 : (assert(!"UnsignedProduct overflow!"), 0);
785}
786
787
795template <typename TReturnType = uintmax_t>
796constexpr TReturnType
797UnsignedPower(const uintmax_t base, const uintmax_t exponent) noexcept
798{
799 static_assert(std::is_unsigned_v<TReturnType>, "UnsignedPower only supports unsigned return types");
800
801 // Uses recursive function calls because C++11 does not support other ways of
802 // iterations for a constexpr function.
803 return (exponent == 0)
804 ? (assert(base > 0), 1)
805 : (exponent == 1) ? base
806 : UnsignedProduct<TReturnType>(UnsignedPower<TReturnType>(base, exponent / 2),
807 UnsignedPower<TReturnType>(base, (exponent + 1) / 2));
808}
809
810
811/*==========================================
812 * Alias the vnl_math functions in the itk::Math
813 * namespace. If possible, use the std:: equivalents
814 */
815using std::isnan;
816using std::isinf;
817using std::isfinite;
818using std::isnormal;
819using std::cbrt;
820using std::hypot;
821using vnl_math::angle_0_to_2pi;
822using vnl_math::angle_minuspi_to_pi;
823using vnl_math::rnd_halfinttoeven;
824using vnl_math::rnd_halfintup;
825using vnl_math::rnd;
826using vnl_math::floor;
827using vnl_math::ceil;
828using vnl_math::sgn;
829using vnl_math::sgn0;
830using vnl_math::remainder_truncated;
831using vnl_math::remainder_floored;
832using vnl_math::sqr;
833using vnl_math::cube;
834using vnl_math::squared_magnitude;
835
836
837/*============================================
838Decouple dependence and exposure of vnl_math::abs operations
839in ITK. Placing this small amount of duplicate vnl_math
840code directly in ITK removes backward compatibility
841issues with system installed VXL versions.
842*/
843inline bool
844abs(bool x)
845{
846 return x;
847}
848inline unsigned char
849abs(unsigned char x)
850{
851 return x;
852}
853inline unsigned char
854abs(signed char x)
855{
856 return x < 0 ? static_cast<unsigned char>(-x) : x;
857}
858inline unsigned char
859abs(char x)
860{
861 return static_cast<unsigned char>(x);
862}
863inline unsigned short
864abs(short x)
865{
866 return x < 0 ? static_cast<unsigned short>(-x) : x;
867}
868inline unsigned short
869abs(unsigned short x)
870{
871 return x;
872}
873inline unsigned int
874abs(unsigned int x)
875{
876 return x;
877}
878inline unsigned long
879abs(unsigned long x)
880{
881 return x;
882}
883// long long - target type will have width of at least 64 bits. (since C++11)
884inline unsigned long long
885abs(unsigned long long x)
886{
887 return x;
888}
889
890using std::abs;
891
892} // end namespace Math
893} // end namespace itk
894
895#endif // end of itkMath.h
Define additional traits for native types such as int or float.
static bool IsPositive(T val)
static constexpr bool IsComplex
#define itkConceptMacro(name, concept)
#define itkTemplateFloatingToIntegerMacro(name)
Definition: itkMath.h:106
RoundHalfIntegerToEven(TInput x) template< TReturn
Round towards nearest integer.
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
bool AlmostEquals(T1 x1, T2 x2)
Provide consistent equality checks between values of potentially different scalar or complex types.
Definition: itkMath.h:688
static constexpr double sqrt2pi
Definition: itkMath.h:82
static constexpr double sqrt1_2
Definition: itkMath.h:90
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
ITKCommon_EXPORT unsigned short GreatestPrimeFactor(unsigned short n)
static constexpr double eps
Definition: itkMath.h:97
bool NotAlmostEquals(T1 x1, T2 x2)
Definition: itkMath.h:696
TInput Ceil(TInput x) template< typename TReturn
static constexpr double pi_over_2
Definition: itkMath.h:70
constexpr TReturnType UnsignedPower(const uintmax_t base, const uintmax_t exponent) noexcept
Definition: itkMath.h:797
TInput TInput TReturn CastWithRangeCheck(TInput x)
Definition: itkMath.h:214
static constexpr double one_over_sqrt2pi
Definition: itkMath.h:86
static constexpr double pi_over_4
Definition: itkMath.h:72
TInput RoundHalfIntegerUp(TInput x) template< typename TReturn
Round towards nearest integer (This is a synonym for RoundHalfIntegerUp)
bool abs(bool x)
Definition: itkMath.h:844
static constexpr double sqrteps
Definition: itkMath.h:98
static constexpr double two_over_sqrtpi
Definition: itkMath.h:84
unsigned long long abs(unsigned long long x)
Definition: itkMath.h:885
static constexpr double one_over_pi
Definition: itkMath.h:76
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
constexpr TReturnType UnsignedProduct(const uintmax_t a, const uintmax_t b) noexcept
Definition: itkMath.h:775
static constexpr double ln2
Definition: itkMath.h:62
Floor(TInput x) template< TReturn
Round towards minus infinity.
static constexpr double euler
euler constant
Definition: itkMath.h:94
static constexpr float float_sqrteps
Definition: itkMath.h:101
bool NotExactlyEquals(const TInput1 &x1, const TInput2 &x2)
Definition: itkMath.h:737
static constexpr float float_eps
Definition: itkMath.h:100
static constexpr double ln10
Definition: itkMath.h:64
static constexpr double twopi
Definition: itkMath.h:68
ITKCommon_EXPORT bool IsPrime(unsigned short n)
static constexpr double sqrt2
Definition: itkMath.h:88
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
static constexpr double pi
Definition: itkMath.h:66
static constexpr double deg_per_rad
Definition: itkMath.h:80
static constexpr double two_over_pi
Definition: itkMath.h:78
static constexpr double e
Definition: itkMath.h:56
static constexpr double sqrt1_3
Definition: itkMath.h:92
static constexpr double pi_over_180
Definition: itkMath.h:74
static constexpr double log10e
Definition: itkMath.h:60
static constexpr double log2e
Definition: itkMath.h:58
TInput TInput TReturn Round(TInput x)
Definition: itkMath.h:179
The "itk" namespace contains all Insight Segmentation and Registration Toolkit (ITK) classes....
static bool AlmostEqualsFunction(double x1, double x2)
Definition: itkMath.h:361
static bool AlmostEqualsFunction(float x1, double x2)
Definition: itkMath.h:375
static bool AlmostEqualsFunction(TFloatType1 x1, TFloatType2 x2)
Definition: itkMath.h:354
static bool AlmostEqualsFunction(double x1, float x2)
Definition: itkMath.h:368
static bool AlmostEqualsFunction(float x1, float x2)
Definition: itkMath.h:382
static bool AlmostEqualsFunction(TFloatType floatingVariable, TIntType integerVariable)
Definition: itkMath.h:392
AlmostEqualsPlainOldEquals SelectedVersion
Definition: itkMath.h:452
static bool AlmostEqualsFunction(TIntType integerVariable, TFloatType floatingVariable)
Definition: itkMath.h:402
static bool AlmostEqualsFunction(TIntegerType1 x1, TIntegerType2 x2)
Definition: itkMath.h:440
static bool AlmostEqualsFunction(TSignedInt signedVariable, TUnsignedInt unsignedVariable)
Definition: itkMath.h:412
static bool AlmostEqualsFunction(TUnsignedInt unsignedVariable, TSignedInt signedVariable)
Definition: itkMath.h:430
typename FloatIEEETraits< T >::IntType IntType