source: trunk/test_more/mul_eq.cpp @ 2506

Last change on this file since 2506 was 2506, checked in by bradbell, 8 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.5 KB
Line 
1/* $Id: mul_eq.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/*
14Two old MulEq examples now used just for valiadation testing
15*/
16# include <cppad/cppad.hpp>
17
18namespace { // BEGIN empty namespace
19
20bool MulEqTestOne(void)
21{       bool ok = true;
22
23        using namespace CppAD;
24
25        // independent variable vector, indices, values, and declaration
26        CPPAD_TESTVECTOR(AD<double>) U(2);
27        size_t s = 0;
28        size_t t = 1;
29        U[s]     = 3.;
30        U[t]     = 2.;
31        Independent(U);
32
33        // dependent variable vector and indices
34        CPPAD_TESTVECTOR(AD<double>) Z(2);
35        size_t x = 0;
36        size_t y = 1;
37
38        // some initial values
39        AD<double> zero = 0.;
40        AD<double> one  = 1.;
41
42        // dependent variable values
43        Z[x]  = U[s];
44        Z[y]  = U[t];
45        Z[x] *= U[t];  // AD<double> *= AD<double>
46        Z[y] *= 5.;    // AD<double> *= double
47        zero *= Z[x];
48        one  *= Z[x];
49
50        // check that zero is a parameter
51        ok &= Parameter(zero);
52
53        // create f: U -> Z and vectors used for derivative calculations
54        ADFun<double> f(U, Z);
55        CPPAD_TESTVECTOR(double) v( f.Domain() );
56        CPPAD_TESTVECTOR(double) w( f.Range() );
57
58        // check values
59        ok &= ( Z[x] == 3. * 2. );
60        ok &= ( Z[y] == 2. * 5. );
61        ok &= ( zero == 0. );
62        ok &= ( one == Z[x] );
63
64        // forward computation of partials w.r.t. t
65        v[s] = 0.;
66        v[t] = 1.;
67        w    = f.Forward(1, v);
68        ok &= ( w[x] == U[s] );  // dx/dt
69        ok &= ( w[y] == 5. );    // dy/dt
70
71        // reverse computation of second partials of x
72        CPPAD_TESTVECTOR(double) r( f.Domain() * 2 );
73        w[x] = 1.;
74        w[y] = 0.;
75        r    = f.Reverse(2, w);
76        ok &= ( r[2 * s + 1] == 1. );
77        ok &= ( r[2 * t + 1] == 0. );
78
79        return ok;
80}
81
82bool MulEqTestTwo(void)
83{       bool ok = true;
84
85        using namespace CppAD;
86
87        // independent variable vector
88        double u0 = .5;
89        CPPAD_TESTVECTOR(AD<double>) U(1);
90        U[0]      = u0; 
91        Independent(U);
92
93        // dependent variable vector
94        CPPAD_TESTVECTOR(AD<double>) Z(1);
95        Z[0] = U[0];       // initial value
96        Z[0] *= 2;         // AD<double> *= int
97        Z[0] *= 4.;        // AD<double> *= double
98        Z[0] *= U[0];      // AD<double> *= AD<double>
99
100        // create f: U -> Z and vectors used for derivative calculations
101        ADFun<double> f(U, Z); 
102        CPPAD_TESTVECTOR(double) v(1);
103        CPPAD_TESTVECTOR(double) w(1);
104
105        // check value
106        ok &= NearEqual(Z[0] , u0*2*4*u0,  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        v[0]         = 1.;
113        for(j = 1; j < p; j++)
114        {       double value;
115                if( j == 1 )
116                        value = 16. * u0;
117                else if( j == 2 )
118                        value = 16.;
119                else    value = 0.;
120
121                jfac *= j;
122                w     = f.Forward(j, v);       
123                ok &= NearEqual(jfac*w[0], value, 1e-10 , 1e-10); // d^jz/du^j
124                v[0]  = 0.;
125        }
126
127        // reverse computation of partials of Taylor coefficients
128        CPPAD_TESTVECTOR(double) r(p); 
129        w[0]  = 1.;
130        r     = f.Reverse(p, w);
131        jfac  = 1.;
132        for(j = 0; j < p; j++)
133        {       double value;
134                if( j == 0 )
135                        value = 16. * u0;
136                else if( j == 1 )
137                        value = 16.;
138                else    value = 0.;
139
140                ok &= NearEqual(jfac*r[j], value, 1e-10 , 1e-10); // d^jz/du^j
141                jfac *= (j + 1);
142        }
143
144        return ok;
145}
146
147} // END empty namespace
148
149bool MulEq(void)
150{       bool ok = true;
151        ok &= MulEqTestOne();
152        ok &= MulEqTestTwo(); 
153        return ok;
154}
Note: See TracBrowser for help on using the repository browser.