Prev

Next

Index-> contents reference index search external

Up-> CppAD AD ADValued numeric_limits

CppAD-> Install Introduction AD ADFun preprocessor multi_thread utility ipopt_solve Example speed Appendix

AD-> ad_ctor ad_assign Convert ADValued BoolValued VecAD base_require

ADValued-> Arithmetic unary_standard_math binary_math CondExp Discrete numeric_limits atomic

numeric_limits-> num_limits.cpp

Headings-> Syntax CppAD::numeric_limits std::numeric_limits Float epsilon min max quiet_NaN digits10 Example

@(@\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }@)@Numeric Limits For an AD and Base Types
Syntax
eps = numeric_limits<Float>::epsilon()
min = numeric_limits<Float>::min()
max = numeric_limits<Float>::max()
nan = numeric_limits<Float>::quiet_NaN()
numeric_limits<Float>::digits10

CppAD::numeric_limits
These functions and have the prototype
     static Float CppAD::numeric_limits<Float>::fun(void)
where fun is epsilon, min, max, and quiet_NaN. (Note that digits10 is member variable and not a function.)

std::numeric_limits
CppAD does not use a specialization of std::numeric_limits because this would be to restrictive. The C++ standard specifies that Non-fundamental standard types, such as std::complex<double> shall not have specializations of std::numeric_limits; see Section 18.2 of ISO/IEC 14882:1998(E). In addition, since C++11, a only literal types can have a specialization of std::numeric_limits.

Float
These functions are defined for all AD<Base> , and for all corresponding Base types; see Base type base_limits .

epsilon
The result eps is equal to machine epsilon and has prototype
     Float eps
The file num_limits.cpp tests the value eps by checking that the following are true
     1 != 1 + eps
     1 == 1 + eps / 2
where all the values, and calculations, are done with the precision corresponding to Float .

min
The result min is equal to the minimum positive normalized value and has prototype
     Float min
The file num_limits.cpp tests the value min by checking that the following are true
     abs( ((min / 100) * 100) / min - 1 ) > 3 * eps
     abs( ((min * 100) / 100) / min - 1 ) < 3 * eps
where all the values, and calculations, are done with the precision corresponding to Float .

max
The result max is equal to the maximum finite value and has prototype
     Float max
The file num_limits.cpp tests the value max by checking that the following are true
     abs( ((max * 100) / 100) / max - 1 ) > 3 * eps
     abs( ((max / 100) * 100) / max - 1 ) < 3 * eps
where all the values, and calculations, are done with the precision corresponding to Float .

quiet_NaN
The result nan is not a number and has prototype
     Float nan
The file num_limits.cpp tests the value nan by checking that the following is true
     nan != nan

digits10
The member variable digits10 has prototype
     static const int numeric_limits<Float>::digits10
It is the number of decimal digits that can be represented by a Float value. A number with this many decimal digits can be converted to Float and back to a string, without change due to rounding or overflow.

Example
The file num_limits.cpp contains an example and test of these functions.

---

Input File: cppad/core/numeric_limits.hpp