source: trunk/test_more/limits.cpp @ 2722

Last change on this file since 2722 was 2722, checked in by bradbell, 7 years ago
  1. Change echo_exec to echo_eval.

limits.hpp: Improve documentation.
limits.cpp: Simplify example.
epsilon.cpp: Replace by more general limits.cpp.
limits.cpp: Modified version of old example/limits.cpp.

  • Property svn:keywords set to Id
File size: 5.7 KB
Line 
1/* $Id: limits.cpp 2722 2013-01-06 16:52:46Z bradbell $ */
2/* --------------------------------------------------------------------------
3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
4
5CppAD is distributed under multiple licenses. This distribution is under
6the terms of the
7                    Eclipse Public License Version 1.0.
8
9A copy of this license is included in the COPYING file of this distribution.
10Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
11-------------------------------------------------------------------------- */
12
13/*
14$begin limits.cpp$$
15$spell
16$$
17
18$section Numeric Limits: Example and Test$$
19$index limits$$
20$index example, limits$$
21$index test, limits$$
22
23$code
24$verbatim%example/limits.cpp%0%// BEGIN C++%// END C++%1%$$
25$$
26
27$end
28*/
29// BEGIN C++
30
31# ifdef _MSC_VER
32// Supress Microsoft compiler warning about possible loss of precision,
33// in the constructors (when converting to std::complex<float>)
34//      Type one = 1
35//      Type two = 2
36// 1 and 2 are small enough so no loss of precision when converting to float.
37# pragma warning(disable:4244)
38# endif
39
40# include <cppad/cppad.hpp>
41# include <complex>
42
43namespace {
44        using CppAD::vector;
45        using CppAD::abs_geq;
46
47        template <class Type>
48        Type add_one(const Type& value)
49        {       return( Type(1) + value ); }
50        // -----------------------------------------------------------------
51        template <class Type>
52        bool check_epsilon(void)
53        {       bool ok    = true;
54                vector<Type> eps(1), one(1), two(1), eps2(1), check(1);
55                eps[0]     = CppAD::numeric_limits<Type>::epsilon();
56                one[0]     = 1;
57                two[0]     = 2;
58                eps2[0]    = eps[0] / two[0]; 
59                check[0]   = add_one(eps[0]);
60                ok        &= one[0] != check[0];
61                check[0]   = add_one(eps2[0]);
62                ok        &= one[0] == check[0];
63                return ok;
64        }
65        // -----------------------------------------------------------------
66        template <class Type>
67        bool check_min(void)
68        {       bool ok    = true;
69                vector<Type> min(1),eps(1),one(1),three(1),hun(1),tmp(1),match(1);
70                min[0]     = CppAD::numeric_limits<Type>::min();
71                eps[0]     = CppAD::numeric_limits<Type>::epsilon();
72                one[0]     = Type(1);
73                three[0]   = Type(3);
74                hun[0]     = Type(100);
75                //
76                tmp[0]     = min[0] / hun[0];
77                match[0]   = tmp[0] * hun[0];
78                ok        &= abs_geq(match[0]/min[0] - one[0], three[0]*eps[0]);
79                //
80                tmp[0]     = min[0] * hun[0];
81                match[0]   = tmp[0] / (hun[0] * (Type(1) - eps[0]) );
82                ok        &= ! abs_geq(match[0]/min[0] - one[0], three[0]*eps[0]);
83                return ok;
84        }
85        // -----------------------------------------------------------------
86        template <class Type>
87        bool check_max(void)
88        {       bool ok    = true;
89                vector<Type> max(1),eps(1),one(1),three(1),hun(1),tmp(1),match(1);
90                max[0]     = CppAD::numeric_limits<Type>::max();
91                eps[0]     = CppAD::numeric_limits<Type>::epsilon();
92                one[0]     = Type(1);
93                three[0]   = Type(3);
94                hun[0]     = Type(100);
95                //
96                tmp[0]     = max[0] * hun[0];
97                match[0]   = tmp[0] / hun[0];
98                ok        &= abs_geq(match[0]/max[0] - one[0],  three[0]*eps[0]);
99                //
100                tmp[0]     = max[0] / hun[0];
101                match[0]   = tmp[0] * (hun[0] * (Type(1) - eps[0]) );
102                ok        &= ! abs_geq(match[0]/max[0] - one[0], three[0]*eps[0]);
103                return ok;
104        }
105        // ---------------------------------------------------------------------
106        template <class Type>
107        bool check_max_complex(void)
108        {       typedef std::complex<Type> Complex;
109                bool ok    = true;
110                vector<Complex> c_max(1), c_eps(1);
111                vector<Type> max(1),eps(1),one(1),three(1),hun(1),tmp(1),match(1);
112                c_max[0]   = CppAD::numeric_limits<Complex>::max();
113                c_eps[0]   = CppAD::numeric_limits<Type>::epsilon();
114                ok        &= c_eps[0].imag() == Type(0);
115                ok        &= c_max[0].imag() == Type(0);
116                max[0]    = c_max[0].real();
117                eps[0]    = c_eps[0].real();
118                one[0]    = Type(1);
119                three[0]  = Type(3);
120                hun[0]    = Type(100);
121                //
122                tmp[0]     = max[0] * hun[0];
123                match[0]   = tmp[0] / hun[0];
124                ok  &= CppAD::abs(match[0]/max[0] - one[0]) > three[0] * eps[0];
125                //
126                tmp[0]     = max[0] / hun[0];
127                match[0]   = tmp[0] * (hun[0] * (Type(1) - eps[0]));
128                ok  &= CppAD::abs(match[0]/max[0] - one[0]) < three[0] * eps[0];
129                return ok;
130        }
131        //
132        template <class Base>
133        bool check_max_ad_complex()
134        {       using CppAD::AD;
135                bool ok    = true;
136                AD<Base> c_max   = CppAD::numeric_limits< AD<Base> >::max();
137                ok &= Value(c_max).imag() == Base(0);
138                ok &= Value(c_max).real() == CppAD::numeric_limits<Base>::max();
139
140                return ok;
141        }
142}
143
144bool limits(void)
145{       bool ok = true;
146        using CppAD::AD;
147
148        // -------------------------------------------------------------------
149        // epsilon for Base types defined by CppAD
150        ok &= check_epsilon<float>();
151        ok &= check_epsilon<double>();
152        ok &= check_epsilon< std::complex<float> >();
153        ok &= check_epsilon< std::complex<double> >();
154
155        // epsilon for some AD types.
156        ok &= check_epsilon< AD<float> >();
157        ok &= check_epsilon< AD<double> >();
158        ok &= check_epsilon<  AD<std::complex<float> > >();
159        ok &= check_epsilon<  AD<std::complex<double> > >();
160
161        // -------------------------------------------------------------------
162        // min for Base types defined by CppAD
163        ok &= check_min<float>();
164        ok &= check_min<double>();
165        ok &= check_min< std::complex<float> >();
166        ok &= check_min< std::complex<double> >();
167
168        // min for some AD types.
169        ok &= check_min< AD<float> >();
170        ok &= check_min< AD<double> >();
171        ok &= check_min<  AD<std::complex<float> > >();
172        ok &= check_min<  AD<std::complex<double> > >();
173
174        // -------------------------------------------------------------------
175        // max for Base types defined by CppAD
176        ok &= check_max<float>();
177        ok &= check_max<double>();
178        ok &= check_max_complex<float>();
179        ok &= check_max_complex<double>();
180
181        // max for some AD types.
182        ok &= check_max< AD<float> >();
183        ok &= check_max< AD<double> >();
184        ok &= check_max_ad_complex< std::complex<float> >();
185        ok &= check_max_ad_complex< std::complex<double> >();
186
187        return ok;
188}
189// END C++
Note: See TracBrowser for help on using the repository browser.