Prev

Next

Index-> contents reference index search external

Up-> CppAD AD ADValued numeric_limits

Headings-> Syntax CppAD::numeric_limits std::numeric_limits Float epsilon min max quiet_NaN infinity 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}} }@)@This is cppad-20221105 documentation. Here is a link to its current documentation . 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()
inf = numeric_limits<Float>::infinity()
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, quiet_NaN, and infinity. (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

infinity
The result inf is equal to the positive infinite value and has prototype
    Float inf
The file num_limits.cpp tests the value inf by checking that the following are true
    inf + 100 == inf
    isnan(inf - inf)

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: include/cppad/core/numeric_limits.hpp