source: trunk/test_more/tan.cpp @ 3683

Last change on this file since 3683 was 3683, checked in by bradbell, 5 years ago

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: febe930d34888cf37df862a1bf118229b9bf37a5
end hash code: 494270b7d9413bba508ae4944e44e33b6f7be05b

commit 494270b7d9413bba508ae4944e44e33b6f7be05b
Author: Brad Bell <bradbell@…>
Date: Sat May 9 19:20:51 2015 -0700

  1. Fix duplicate expm1 in example and test_more makefile.am, CMakeLists.txt.
  2. Extend log theory to include log1p function.


log_forward.omh: remove trailing white space
log_reverse.omh: remove trailing white space

commit d2e5c615a1d620d364c7c73f47f9db18aa4bcba3
Author: Brad Bell <bradbell@…>
Date: Sat May 9 10:09:24 2015 -0700

Add new flags to configure.ac and include auto-tools automatic changes.


test_one.sh.in: handel case where space between name and (void).
exp_reverse.omh: change plural to singular.
test_one.sh.in: handel case where space between name and (void).

commit c62e0f95b359b188556d49fb7e3a75b0eaad12e4
Author: Brad Bell <bradbell@…>
Date: Sat May 9 07:14:17 2015 -0700

Remove trialing white space.

commit f443608ff6f29ed5ff05fa136543d6f2baab7757
Author: Brad Bell <bradbell@…>
Date: Sat May 9 07:13:53 2015 -0700

Fix some warnings when using eigen_vector for the test vector.


configure.ac: Comments for auto-tool commands that will result in many makefile.in changes.
makefile.in: automatic change from corresponding makefile.am.
test_one.sh.in: use cppad_cxx_flags to determine if c++11.
makefile.in: automatic change from corresponding makefile.am.
exp_forward.omh: Fix z{(0)} to be correct for both cases.
makefile.in: automatic change from corresponding makefile.am.

commit 003b9c373b2b77fde81427f57ee3db364fea5eff
Author: Brad Bell <bradbell@…>
Date: Sat May 9 04:53:44 2015 -0700

Add expm1 function.

commit a2b3d2fd72cda066e110368860452c5299211c30
Author: Brad Bell <bradbell@…>
Date: Fri May 8 19:39:12 2015 -0700

CMakeLists.txt: simplify ENDFOREACH command.

commit 31016ed04a3fd618456de115fd98c58f07b89f3e
Author: Brad Bell <bradbell@…>
Date: Fri May 8 17:04:34 2015 -0700

check_example.sh: Fix check that all examples are in list, remove trailing white space.
exp.cpp: minor white space edit.
example_list.omh: add examples that were missing.

commit e48ff330292e90ba40baffa8b2d1b2d12c44f099
Author: Brad Bell <bradbell@…>
Date: Fri May 8 16:31:28 2015 -0700

  1. Add expm1 funtion to exp theory.
  2. Change Exp -> exp.
  3. Remove redundant index commands.
  4. Remove trailing white space.


exp.cpp: more modern names in example.

  • Property svn:keywords set to Id
File size: 4.6 KB
Line 
1/* $Id: tan.cpp 3683 2015-05-10 02:24:16Z bradbell $ */
2/* --------------------------------------------------------------------------
3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 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/*
15Test higher order derivatives for tan(x) function.
16*/
17
18# include <cppad/cppad.hpp>
19
20namespace {
21        bool tan_two(void)
22        {       bool ok = true;
23                using CppAD::AD;
24                using CppAD::NearEqual;
25                double eps = 10. * std::numeric_limits<double>::epsilon();
26
27                // domain space vector
28                size_t n = 1;
29                CPPAD_TESTVECTOR(AD<double>) ax(n);
30                ax[0] = 0.5;
31
32                // declare independent variables and starting recording
33                CppAD::Independent(ax);
34
35                // range space vector
36                size_t m = 1;
37                CPPAD_TESTVECTOR(AD<double>) ay(m);
38                ay[0] = tan( ax[0] );
39
40                // create f: x -> y and stop tape recording
41                CppAD::ADFun<double> f(ax, ay);
42
43                // first order Taylor coefficient
44                CPPAD_TESTVECTOR(double) x1(n), y1;
45                x1[0] = 2.0;
46                y1    = f.Forward(1, x1);
47                ok   &= size_t( y1.size() ) == m;
48
49                // secondorder Taylor coefficients
50                CPPAD_TESTVECTOR(double) x2(n), y2;
51                x2[0] = 0.0;
52                y2    = f.Forward(2, x2);
53                ok   &= size_t( y2.size() ) == m;
54                //
55                // Y  (t)    = F[X_0(t)]
56                //           =  tan(0.5 + 2t )
57                // Y' (t)    =  2 * cos(0.5 + 2t )^(-2)
58                double sec_sq  = 1.0 / ( cos(0.5) * cos(0.5) );
59                double check   = 2.0 * sec_sq;
60                ok  &= NearEqual(y1[0] , check, eps, eps);
61                //
62                // Y''(0)    = 8*cos(0.5)^(-3)*sin(0.5)
63                check = 8.0 * tan(0.5) * sec_sq / 2.0;
64                ok    &= NearEqual(y2[0] , check, eps, eps);
65                //
66                return ok;
67        }
68        bool tan_case(bool tan_first)
69        {       bool ok = true;
70                double eps = 100. * std::numeric_limits<double>::epsilon();
71                using CppAD::AD;
72                using CppAD::NearEqual;
73
74                // independent variable vector, indices, values, and declaration
75                size_t n = 1;
76                CPPAD_TESTVECTOR(AD<double>) ax(n);
77                ax[0]     = .7;
78                Independent(ax);
79
80                // dependent variable vector and indices
81                size_t m = 1;
82                CPPAD_TESTVECTOR(AD<double>) ay(m);
83                if( tan_first )
84                        ay[0] = atan( tan( ax[0] ) );
85                else    ay[0] = tan( atan( ax[0] ) );
86
87                // check value
88                ok &= NearEqual(ax[0] , ay[0],  eps, eps);
89
90                // create f: x -> y and vectors used for derivative calculations
91                CppAD::ADFun<double> f(ax, ay);
92                CPPAD_TESTVECTOR(double) dx(n), dy(m);
93
94                // forward computation of partials w.r.t. x
95                dx[0] = 1.;
96                dy    = f.Forward(1, dx);
97                ok   &= NearEqual(dy[0], 1e0, eps, eps);
98                size_t p, order = 5;
99                dx[0] = 0.;
100                for(p = 2; p < order; p++)
101                {       dy    = f.Forward(p, dx);
102                        ok   &= NearEqual(dy[0], 0e0, eps, eps);
103                }
104
105                // reverse computation of order partial
106                CPPAD_TESTVECTOR(double)  w(m), dw(n * order);
107                w[0] = 1.;
108                dw   = f.Reverse(order, w);
109                ok   &= NearEqual(dw[0], 1e0, eps, eps);
110                for(p = 1; p < order; p++)
111                        ok   &= NearEqual(dw[p], 0e0, eps, eps);
112
113                return ok;
114        }
115        bool tanh_case(bool tanh_first)
116        {       bool ok = true;
117                double eps = 100. * std::numeric_limits<double>::epsilon();
118                using CppAD::AD;
119                using CppAD::NearEqual;
120
121                // independent variable vector, indices, values, and declaration
122                size_t n = 1;
123                CPPAD_TESTVECTOR(AD<double>) ax(n);
124                ax[0]     = .5;
125                Independent(ax);
126
127                // dependent variable vector and indices
128                size_t m = 1;
129                CPPAD_TESTVECTOR(AD<double>) ay(m);
130                AD<double> z;
131                if( tanh_first )
132                {       z     = tanh( ax[0] );
133                        ay[0] = .5 * log( (1. + z) / (1. - z) );
134                }
135                else
136                {       z     = .5 * log( (1. + ax[0]) / (1. - ax[0]) );
137                        ay[0] = tanh(z);
138                }
139                // check value
140                ok &= NearEqual(ax[0] , ay[0],  eps, eps);
141
142                // create f: x -> y and vectors used for derivative calculations
143                CppAD::ADFun<double> f(ax, ay);
144                CPPAD_TESTVECTOR(double) dx(n), dy(m);
145
146                // forward computation of partials w.r.t. x
147                dx[0] = 1.;
148                dy    = f.Forward(1, dx);
149                ok   &= NearEqual(dy[0], 1e0, eps, eps);
150                size_t p, order = 5;
151                dx[0] = 0.;
152                for(p = 2; p < order; p++)
153                {       dy    = f.Forward(p, dx);
154                        ok   &= NearEqual(dy[0], 0e0, eps, eps);
155                }
156
157                // reverse computation of order partial
158                CPPAD_TESTVECTOR(double)  w(m), dw(n * order);
159                w[0] = 1.;
160                dw   = f.Reverse(order, w);
161                ok   &= NearEqual(dw[0], 1e0, eps, eps);
162                for(p = 1; p < order; p++)
163                        ok   &= NearEqual(dw[p], 0e0, eps, eps);
164
165                return ok;
166        }
167}
168bool tan(void)
169{       bool ok = true;
170        //
171        ok     &= tan_case(true);
172        ok     &= tan_case(false);
173        ok     &= tanh_case(true);
174        ok     &= tanh_case(false);
175        //
176        ok     &= tan_two();
177        return ok;
178}
Note: See TracBrowser for help on using the repository browser.