Eigen  5.0.1-dev+master
 
Loading...
Searching...
No Matches
Eigen::NumTraits< T > Class Template Reference

#include <Eigen/src/Core/NumTraits.h>

Detailed Description

template<typename T>
class Eigen::NumTraits< T >

Holds information about the various numeric (i.e. scalar) types allowed by Eigen.

Template Parameters
Tthe numeric type at hand

This class stores enums, typedefs and static methods giving information about a numeric type. The default precision queries use std::numeric_limits when specialized. Otherwise binary precision uses an epsilon-based calculation when available, and decimal precision is derived from the real type's binary precision. Decimal queries without usable precision information return zero (unspecified precision). The binary digits() query still requires usable precision information. Custom scalar types can specialize these methods when finite precision information is available.

The provided data consists of:

  • A typedef Real, giving the "real part" type of T. If T is already real, then Real is just a typedef to T. If T is std::complex<U> then Real is a typedef to U.
  • A typedef NonInteger, giving the type that should be used for operations producing non-integral values, such as quotients, square roots, etc. If T is a floating-point type, then this typedef just gives T again. Note however that many Eigen functions such as internal::sqrt simply refuse to take integers. Outside of a few cases, Eigen doesn't do automatic type promotion. Thus, this typedef is only intended as a helper for code that needs to explicitly promote types.
  • A typedef Literal giving the type to use for numeric literals such as "2" or "0.5". For instance, for std::complex<U>, Literal is defined as U. Of course, this type must be fully compatible with T. In doubt, just use T here.
  • A typedef Nested giving the type to use to nest a value inside of the expression tree. If you don't know what this means, just use T here.
  • An enum value IsComplex. It is equal to 1 if T is a std::complex type, and to 0 otherwise.
  • An enum value IsInteger. It is equal to 1 if T is an integer type such as int, and to 0 otherwise.
  • Enum values ReadCost, AddCost and MulCost representing a rough estimate of the number of CPU cycles needed by move / add / mul instructions respectively, assuming the data is already stored in CPU registers. Stay vague here. No need to do architecture-specific stuff. If you don't know what this means, just use Eigen::HugeCost.
  • An enum value IsSigned. It is equal to 1 if T is a signed type and to 0 if T is unsigned.
  • An enum value RequireInitialization. It is equal to 1 if the constructor of the numeric type T must be called, and to 0 if it is safe not to call it. Default is 0 if T is an arithmetic type, and 1 otherwise.
  • An epsilon() function which, unlike std::numeric_limits::epsilon(), it returns a Real instead of a T.
  • A dummy_precision() function returning a default relative tolerance for approximate comparisons. This is distinct from epsilon() and does not describe the rounding error of an algorithm.
  • highest() and lowest() functions returning the highest and lowest possible values respectively.
  • digits() function returning the number of radix digits (non-sign digits for integers, mantissa for floating-point). This is the analogue of std::numeric_limits<T>::digits which is used as the default implementation if specialized.
  • digits10() function returning the number of decimal digits that can be represented without change. This is the analogue of std::numeric_limits<T>::digits10 which is used as the default implementation if specialized.
  • max_digits10() function returning the number of decimal digits required to uniquely represent all distinct values of the type. This is the analogue of std::numeric_limits<T>::max_digits10 which is used as the default implementation if specialized.
  • min_exponent() and max_exponent() functions returning the highest and lowest possible values, respectively, such that the radix raised to the power exponent-1 is a normalized floating-point number. These are equivalent to std::numeric_limits<T>::min_exponent/std::numeric_limits<T>::max_exponent.
  • infinity() function returning a representation of positive infinity, if available.
  • quiet_NaN() function returning a non-signaling "not-a-number", if available.

The documentation for this class was generated from the following file: