source: trunk/test_more/tan.cpp @ 3008

Last change on this file since 3008 was 2506, checked in by bradbell, 7 years ago

Change Licenses: CPL-1.0 -> EPL-1.0, GPL-2.0->GPL-3.0

  • Property svn:keywords set to Id
File size: 3.4 KB
Line 
1/* $Id: tan.cpp 2506 2012-10-24 19:36:49Z bradbell $ */
2/* --------------------------------------------------------------------------
3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-12 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_case(bool tan_first)
22        {       bool ok = true;
23                double eps = 100. * std::numeric_limits<double>::epsilon();
24                using CppAD::AD;
25                using CppAD::NearEqual;
26       
27                // independent variable vector, indices, values, and declaration
28                size_t n = 1;
29                CPPAD_TESTVECTOR(AD<double>) ax(n);
30                ax[0]     = .7;
31                Independent(ax);
32       
33                // dependent variable vector and indices
34                size_t m = 1;
35                CPPAD_TESTVECTOR(AD<double>) ay(m);
36                if( tan_first )
37                        ay[0] = atan( tan( ax[0] ) );
38                else    ay[0] = tan( atan( ax[0] ) );
39       
40                // check value
41                ok &= NearEqual(ax[0] , ay[0],  eps, eps);
42       
43                // create f: x -> y and vectors used for derivative calculations
44                CppAD::ADFun<double> f(ax, ay); 
45                CPPAD_TESTVECTOR(double) dx(n), dy(m);
46       
47                // forward computation of partials w.r.t. x
48                dx[0] = 1.;
49                dy    = f.Forward(1, dx);
50                ok   &= NearEqual(dy[0], 1e0, eps, eps);
51                size_t p, order = 5;
52                dx[0] = 0.;
53                for(p = 2; p < order; p++)
54                {       dy    = f.Forward(p, dx);
55                        ok   &= NearEqual(dy[0], 0e0, eps, eps);
56                }
57       
58                // reverse computation of order partial
59                CPPAD_TESTVECTOR(double)  w(m), dw(n * order);
60                w[0] = 1.;
61                dw   = f.Reverse(order, w);
62                ok   &= NearEqual(dw[0], 1e0, eps, eps);
63                for(p = 1; p < order; p++)
64                        ok   &= NearEqual(dw[p], 0e0, eps, eps);
65       
66                return ok;
67        }
68        bool tanh_case(bool tanh_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]     = .5;
78                Independent(ax);
79       
80                // dependent variable vector and indices
81                size_t m = 1;
82                CPPAD_TESTVECTOR(AD<double>) ay(m);
83                AD<double> z;
84                if( tanh_first )
85                {       z     = tanh( ax[0] );
86                        ay[0] = .5 * log( (1. + z) / (1. - z) );
87                }
88                else
89                {       z     = .5 * log( (1. + ax[0]) / (1. - ax[0]) );
90                        ay[0] = tanh(z);
91                }
92                // check value
93                ok &= NearEqual(ax[0] , ay[0],  eps, eps);
94       
95                // create f: x -> y and vectors used for derivative calculations
96                CppAD::ADFun<double> f(ax, ay); 
97                CPPAD_TESTVECTOR(double) dx(n), dy(m);
98       
99                // forward computation of partials w.r.t. x
100                dx[0] = 1.;
101                dy    = f.Forward(1, dx);
102                ok   &= NearEqual(dy[0], 1e0, eps, eps);
103                size_t p, order = 5;
104                dx[0] = 0.;
105                for(p = 2; p < order; p++)
106                {       dy    = f.Forward(p, dx);
107                        ok   &= NearEqual(dy[0], 0e0, eps, eps);
108                }
109       
110                // reverse computation of order partial
111                CPPAD_TESTVECTOR(double)  w(m), dw(n * order);
112                w[0] = 1.;
113                dw   = f.Reverse(order, w);
114                ok   &= NearEqual(dw[0], 1e0, eps, eps);
115                for(p = 1; p < order; p++)
116                        ok   &= NearEqual(dw[p], 0e0, eps, eps);
117       
118                return ok;
119        }
120}
121bool tan(void)
122{       bool ok = true;
123        ok     &= tan_case(true);
124        ok     &= tan_case(false);
125        ok     &= tanh_case(true);
126        ok     &= tanh_case(false);
127        return ok;
128}
Note: See TracBrowser for help on using the repository browser.