source: trunk/test_more/atan.cpp @ 2354

Last change on this file since 2354 was 1370, checked in by bradbell, 11 years ago

trunk: Fix svn_add_id.sh and use it set Id property for some missed files.

  • Property svn:keywords set to Id
File size: 3.4 KB
Line 
1/* $Id: atan.cpp 1370 2009-05-31 05:31:50Z bradbell $ */
2/* --------------------------------------------------------------------------
3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-07 Bradley M. Bell
4
5CppAD is distributed under multiple licenses. This distribution is under
6the terms of the
7                    Common 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/*
15Two old atan examples now used just for validation testing.
16*/
17
18# include <cppad/cppad.hpp>
19
20namespace { // BEGIN empty namespace
21
22bool AtanTestOne(void)
23{       bool ok = true;
24
25        using CppAD::atan;
26        using namespace CppAD;
27
28        // independent variable vector, indices, values, and declaration
29        CPPAD_TEST_VECTOR< AD<double> > U(1);
30        size_t s = 0;
31        U[s]     = 1.;
32        Independent(U);
33
34        // some temporary values
35        AD<double> x = cos(U[s]);
36        AD<double> y = sin(U[s]); 
37        AD<double> z = y / x;       // tan(s)
38
39        // dependent variable vector and indices
40        CPPAD_TEST_VECTOR< AD<double> > Z(1);
41        size_t a = 0;
42
43        // dependent variable values
44        Z[a] = atan(z); // atan( tan(s) )
45
46        // create f: U -> Z and vectors used for dierivative calculations
47        ADFun<double> f(U, Z); 
48        CPPAD_TEST_VECTOR<double> v( f.Domain() );
49        CPPAD_TEST_VECTOR<double> w( f.Range() );
50
51        // check value
52        ok &= NearEqual(U[s] , Z[a],  1e-10 , 1e-10);
53
54        // forward computation of partials w.r.t. s
55        v[s] = 1.;
56        w    = f.Forward(1, v);
57        ok &= NearEqual(w[a], 1e0, 1e-10 , 1e-10);  // da/ds
58
59        // reverse computation of first order partial of a
60        w[a] = 1.;
61        v    = f.Reverse(1, w);
62        ok &= NearEqual(v[s], 1e0, 1e-10 , 1e-10);  // da/ds
63
64        // forward computation of second partials w.r.t. s and s
65        v[s] = 1.;
66        f.Forward(1, v);
67        v[s] = 0.;
68        w    = f.Forward(2, v);
69        ok &= NearEqual(2. * w[a], 0e0, 1e-10 , 1e-10);     // d^2 a / (ds ds)
70
71        // reverse computation of second partials of a
72        CPPAD_TEST_VECTOR<double> r( f.Domain() * 2 );
73        w[a] = 1.;
74        r    = f.Reverse(2, w);
75        ok &= NearEqual(r[2 * s + 1] ,0e0, 1e-10 , 1e-10 ); // d^2 a / (ds ds)
76
77        return ok;
78}
79
80bool AtanTestTwo(void)
81{       bool ok = true;
82
83        using CppAD::atan;
84        using CppAD::sin;
85        using CppAD::cos;
86        using namespace CppAD;
87
88        // independent variable vector
89        CPPAD_TEST_VECTOR< AD<double> > U(1);
90        U[0]     = 1.;
91        Independent(U);
92
93        // a temporary values
94        AD<double> x = sin(U[0]) / cos(U[0]); 
95
96        // dependent variable vector
97        CPPAD_TEST_VECTOR< AD<double> > Z(1);
98        Z[0] = atan(x); // atan( tan(u) )
99
100        // create f: U -> Z and vectors used for derivative calculations
101        ADFun<double> f(U, Z); 
102        CPPAD_TEST_VECTOR<double> v(1);
103        CPPAD_TEST_VECTOR<double> w(1);
104
105        // check value
106        ok &= NearEqual(U[0] , Z[0],  1e-10 , 1e-10);
107
108        // forward computation of partials w.r.t. u
109        size_t j;
110        size_t p     = 5;
111        double jfac  = 1.;
112        double value = 1.;
113        v[0]         = 1.;
114        for(j = 1; j < p; j++)
115        {       jfac *= j;
116                w     = f.Forward(j, v);       
117                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
118                v[0]  = 0.;
119                value = 0.;
120        }
121
122        // reverse computation of partials of Taylor coefficients
123        CPPAD_TEST_VECTOR<double> r(p); 
124        w[0]  = 1.;
125        r     = f.Reverse(p, w);
126        jfac  = 1.;
127        value = 1.;
128        for(j = 0; j < p; j++)
129        {       ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
130                jfac *= (j + 1);
131                value = 0.;
132        }
133
134        return ok;
135}
136
137} // END empty namespace
138
139bool Atan(void)
140{       bool ok = true;
141        ok &= AtanTestOne();
142        ok &= AtanTestTwo(); 
143        return ok;
144}
Note: See TracBrowser for help on using the repository browser.