source: trunk/test_more/tan.cpp @ 3301

Last change on this file since 3301 was 3301, checked in by bradbell, 6 years ago

merge in multiple forward direcitons from branches/forward_dir

  • Property svn:keywords set to Id
File size: 4.6 KB
Line 
1/* $Id: tan.cpp 3301 2014-05-24 05:20:21Z bradbell $ */
2/* --------------------------------------------------------------------------
3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 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   &= 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   &= 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.