This file contains classes and typedefs needed to provide uniform handling of floating point numeric values. More...
#include <cstddef>#include <cassert>#include <complex>#include <iostream>#include <limits>Go to the source code of this file.
Classes | |
| struct | Widest< R1, R2 > |
| This class is specialized for all 36 combinations of standard types (that is, real and complex types in each of three precisions) and has typedefs "Type" which is the appropriate "widened" type for use when R1 & R2 appear in an operation together, and "Precision" which is the wider precision (float,double,long double). More... | |
| struct | Widest< float, float > |
| struct | Widest< float, double > |
| struct | Widest< float, long double > |
| struct | Widest< double, float > |
| struct | Widest< double, double > |
| struct | Widest< double, long double > |
| struct | Widest< long double, float > |
| struct | Widest< long double, double > |
| struct | Widest< long double, long double > |
| struct | Widest< complex< R1 >, complex< R2 > > |
| struct | Widest< complex< R1 >, R2 > |
| struct | Widest< R1, complex< R2 > > |
| struct | Narrowest< R1, R2 > |
| This class is specialized for all 36 combinations of standard types (that is, real and complex types in each of three precisions) and has typedefs "Type" which is the appropriate "narrowed" type for use when R1 & R2 appear in an operation together where the result must be of the narrower precision, and "Precision" which is the expected precision of the result (float, double, long double). More... | |
| struct | Narrowest< float, float > |
| struct | Narrowest< float, double > |
| struct | Narrowest< float, long double > |
| struct | Narrowest< double, float > |
| struct | Narrowest< double, double > |
| struct | Narrowest< double, long double > |
| struct | Narrowest< long double, float > |
| struct | Narrowest< long double, double > |
| struct | Narrowest< long double, long double > |
| struct | Narrowest< complex< R1 >, complex< R2 > > |
| struct | Narrowest< complex< R1 >, R2 > |
| struct | Narrowest< R1, complex< R2 > > |
| class | RTraits< R > |
| RTraits is a helper class for NTraits. More... | |
| class | RTraits< float > |
| class | RTraits< double > |
| class | RTraits< long double > |
| class | NTraits< N > |
| class | NTraits< complex< R > > |
| Partial specialization for complex numbers -- underlying real R is still a template parameter. More... | |
| struct | Result< P > |
| struct | Substitute< P > |
| class | NTraits< conjugate< R > > |
| struct | Result< P > |
| struct | Substitute< P > |
| class | CNT< complex< R > > |
| Specializations of CNT for numeric types. More... | |
| class | CNT< conjugate< R > > |
| class | CNT< float > |
| class | CNT< double > |
| class | CNT< long double > |
Namespaces | |
| namespace | SimTK |
This is the top-level SimTK namespace into which all SimTK names are placed to avoid collision with other symbols. | |
Defines | |
| #define | SimTK_BNTCMPLX_SPEC(T1, T2) |
| #define | SimTK_NTRAITS_CONJ_SPEC(T1, T2) |
| #define | SimTK_DEFINE_REAL_NTRAITS(R) |
Functions | |
| bool | isNaN (const float &x) |
| bool | isNaN (const double &x) |
| bool | isNaN (const long double &x) |
| template<class P > | |
| bool | isNaN (const std::complex< P > &x) |
| template<class P > | |
| bool | isNaN (const conjugate< P > &x) |
| bool | isFinite (const float &x) |
| bool | isFinite (const double &x) |
| bool | isFinite (const long double &x) |
| template<class P > | |
| bool | isFinite (const std::complex< P > &x) |
| template<class P > | |
| bool | isFinite (const conjugate< P > &x) |
| bool | isInf (const float &x) |
| bool | isInf (const double &x) |
| bool | isInf (const long double &x) |
| template<class P > | |
| bool | isInf (const std::complex< P > &x) |
| template<class P > | |
| bool | isInf (const conjugate< P > &x) |
| bool | isNumericallyEqual (const float &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Compare two floats for approximate equality. | |
| bool | isNumericallyEqual (const double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| Compare two doubles for approximate equality. | |
| bool | isNumericallyEqual (const long double &a, const long double &b, double tol=RTraits< long double >::getDefaultTolerance()) |
| Compare two long doubles for approximate equality. | |
| bool | isNumericallyEqual (const float &a, const double &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Compare a float and a double for approximate equality at float precision. | |
| bool | isNumericallyEqual (const double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Compare a float and a double for approximate equality at float precision. | |
| bool | isNumericallyEqual (const float &a, const long double &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Compare a float and a long double for approximate equality at float precision. | |
| bool | isNumericallyEqual (const long double &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Compare a float and a long double for approximate equality at float precision. | |
| bool | isNumericallyEqual (const double &a, const long double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| Compare a double and a long double for approximate equality at double precision. | |
| bool | isNumericallyEqual (const long double &a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| Compare a double and a long double for approximate equality at double precision. | |
| bool | isNumericallyEqual (const float &a, int b, double tol=RTraits< float >::getDefaultTolerance()) |
| Test a float for approximate equality to an integer. | |
| bool | isNumericallyEqual (int a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Test a float for approximate equality to an integer. | |
| bool | isNumericallyEqual (const double &a, int b, double tol=RTraits< double >::getDefaultTolerance()) |
| Test a double for approximate equality to an integer. | |
| bool | isNumericallyEqual (int a, const double &b, double tol=RTraits< double >::getDefaultTolerance()) |
| Test a double for approximate equality to an integer. | |
| bool | isNumericallyEqual (const long double &a, int b, double tol=RTraits< long double >::getDefaultTolerance()) |
| Test a long double for approximate equality to an integer. | |
| bool | isNumericallyEqual (int a, const long double &b, double tol=RTraits< long double >::getDefaultTolerance()) |
| Test a long double for approximate equality to an integer. | |
| template<class P , class Q > | |
| bool | isNumericallyEqual (const std::complex< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| Compare two complex numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. | |
| template<class P , class Q > | |
| bool | isNumericallyEqual (const conjugate< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| Compare two conjugate numbers for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. | |
| template<class P , class Q > | |
| bool | isNumericallyEqual (const std::complex< P > &a, const conjugate< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. | |
| template<class P , class Q > | |
| bool | isNumericallyEqual (const conjugate< P > &a, const std::complex< Q > &b, double tol=RTraits< typename Narrowest< P, Q >::Precision >::getDefaultTolerance()) |
| Compare a complex and a conjugate number for approximate equality, using the numerical accuracy expectation of the narrower of the two precisions in the case of mixed precision. | |
| template<class P > | |
| bool | isNumericallyEqual (const std::complex< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular real float. | |
| template<class P > | |
| bool | isNumericallyEqual (const float &a, const std::complex< P > &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular real float. | |
| template<class P > | |
| bool | isNumericallyEqual (const std::complex< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular real double. | |
| template<class P > | |
| bool | isNumericallyEqual (const double &a, const std::complex< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular real double. | |
| template<class P > | |
| bool | isNumericallyEqual (const std::complex< P > &a, const long double &b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular real long double. | |
| template<class P > | |
| bool | isNumericallyEqual (const long double &a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular real long double. | |
| template<class P > | |
| bool | isNumericallyEqual (const std::complex< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular integer. | |
| template<class P > | |
| bool | isNumericallyEqual (int a, const std::complex< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a complex number is approximately equal to a particular integer. | |
| template<class P > | |
| bool | isNumericallyEqual (const conjugate< P > &a, const float &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular real float. | |
| template<class P > | |
| bool | isNumericallyEqual (const float &a, const conjugate< P > &b, double tol=RTraits< float >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular real float. | |
| template<class P > | |
| bool | isNumericallyEqual (const conjugate< P > &a, const double &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular real double. | |
| template<class P > | |
| bool | isNumericallyEqual (const double &a, const conjugate< P > &b, double tol=RTraits< typename Narrowest< P, double >::Precision >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular real double. | |
| template<class P > | |
| bool | isNumericallyEqual (const conjugate< P > &a, const long double &b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular real long double. | |
| template<class P > | |
| bool | isNumericallyEqual (const long double &a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular real long double. | |
| template<class P > | |
| bool | isNumericallyEqual (const conjugate< P > &a, int b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular integer. | |
| template<class P > | |
| bool | isNumericallyEqual (int a, const conjugate< P > &b, double tol=RTraits< P >::getDefaultTolerance()) |
| Test whether a conjugate number is approximately equal to a particular integer. | |
| SimTK_BNTCMPLX_SPEC (float, float) | |
| SimTK_BNTCMPLX_SPEC (float, double) | |
| SimTK_BNTCMPLX_SPEC (float, long double) | |
| SimTK_BNTCMPLX_SPEC (double, float) | |
| SimTK_BNTCMPLX_SPEC (double, double) | |
| SimTK_BNTCMPLX_SPEC (double, long double) | |
| SimTK_BNTCMPLX_SPEC (long double, float) | |
| SimTK_BNTCMPLX_SPEC (long double, double) | |
| SimTK_BNTCMPLX_SPEC (long double, long double) | |
| SimTK_NTRAITS_CONJ_SPEC (float, float) | |
| SimTK_NTRAITS_CONJ_SPEC (float, double) | |
| SimTK_NTRAITS_CONJ_SPEC (float, long double) | |
| SimTK_NTRAITS_CONJ_SPEC (double, float) | |
| SimTK_NTRAITS_CONJ_SPEC (double, double) | |
| SimTK_NTRAITS_CONJ_SPEC (double, long double) | |
| SimTK_NTRAITS_CONJ_SPEC (long double, float) | |
| SimTK_NTRAITS_CONJ_SPEC (long double, double) | |
| SimTK_NTRAITS_CONJ_SPEC (long double, long double) | |
| SimTK_DEFINE_REAL_NTRAITS (float) | |
| SimTK_DEFINE_REAL_NTRAITS (double) | |
| SimTK_DEFINE_REAL_NTRAITS (long double) | |
This file contains classes and typedefs needed to provide uniform handling of floating point numeric values.
There are three numeric types: real, complex, conjugate and each comes in float, double, and long double precision. Each of these may be modified by a negator, which does not change the in-memory representation but negates the interpretation. Thus there are 18 distinct scalar types: 3 precisions each of real, complex, and conjugate and their negators.
* The Scalar Types * ---------------- * Here is a complete taxonomy of the scalar types we support. * * <scalar> ::= <number> | negator< <number> > * <number> ::= <standard> | <conjugate> * <standard> ::= <real> | <complex> * * <real> ::= float | double | long double * <complex> ::= complex< <real> > * <conjugate> ::= conjugate< <real> > *
| #define SimTK_BNTCMPLX_SPEC | ( | T1, | |||
| T2 | ) |
template<> template<> struct NTraits< complex<T1> >::Result<T2> { \ typedef Widest< complex<T1>,T2 >::Type W; \ typedef W Mul; typedef W Dvd; typedef W Add; typedef W Sub; \ }; \ template<> template<> struct NTraits< complex<T1> >::Result< complex<T2> > { \ typedef Widest< complex<T1>,complex<T2> >::Type W; \ typedef W Mul; typedef W Dvd; typedef W Add; typedef W Sub; \ }; \ template<> template<> struct NTraits< complex<T1> >::Result< conjugate<T2> > { \ typedef Widest< complex<T1>,complex<T2> >::Type W; \ typedef W Mul; typedef W Dvd; typedef W Add; typedef W Sub; \ }
| #define SimTK_DEFINE_REAL_NTRAITS | ( | R | ) |
| #define SimTK_NTRAITS_CONJ_SPEC | ( | T1, | |||
| T2 | ) |
template<> template<> struct NTraits< conjugate<T1> >::Result<T2> { \ typedef conjugate<Widest<T1,T2>::Type> W; \ typedef W Mul; typedef W Dvd; typedef W Add; typedef W Sub; \ }; \ template<> template<> struct NTraits< conjugate<T1> >::Result<complex<T2> >{\ typedef Widest<complex<T1>,complex<T2> >::Type W; \ typedef W Mul; typedef W Dvd; typedef W Add; typedef negator<W> Sub; \ }; \ template<> template<> struct NTraits< conjugate<T1> >::Result<conjugate<T2> >{\ typedef Widest<T1,T2>::Type W; typedef complex<W> WC; \ typedef negator<WC> Mul; typedef WC Dvd; typedef conjugate<W> Add; typedef WC Sub;\ }
1.6.1