source: trunk/example/atomic/get_started.cpp @ 2902

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

atomic_base.hpp: remove documentaiton text used in old atomic functions.
get_started.cpp: remove executable property (set by mistake).

  • Property svn:keywords set to Id
File size: 3.7 KB
Line 
1// $Id: get_started.cpp 2902 2013-09-19 12:19:11Z bradbell $
2/* --------------------------------------------------------------------------
3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 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$begin atomic_get_started.cpp$$
15
16$section Getting Started with Atomic Operations: Example and Test$$
17$index get_started, atomic operation$$
18$index atomic, get_started $$
19$index operation, atomic get_started$$
20
21$head Purpose$$
22This example demonstrates the minimal amount of information
23necessary for a $cref atomic_base$$ operation.
24
25$code
26$verbatim%example/atomic/get_started.cpp%0%// BEGIN C++%// END C++%1%$$
27$$
28
29$end
30*/
31// BEGIN C++
32# include <cppad/cppad.hpp>
33
34namespace { // Begin empty namespace
35// ----------------------------------------------------------------------
36using CppAD::vector;
37
38//
39class atomic_get_started : public CppAD::atomic_base<double> {
40public:
41        // ----------------------------------------------------------------------
42        // constructor (example use of const std::string& instead of const char*)
43        atomic_get_started(const std::string& name) : 
44        CppAD::atomic_base<double>(name)
45        { }
46private:
47        // ----------------------------------------------------------------------
48        // forward mode routine called by CppAD
49        virtual bool forward(
50                size_t                    q ,
51                size_t                    p ,
52                const vector<bool>&      vx ,
53                      vector<bool>&      vy ,
54                const vector<double>&    tx ,
55                      vector<double>&    ty
56        )
57        {       size_t n = tx.size() / (p + 1);
58                size_t m = ty.size() / (p + 1);
59                assert( n == 1 );
60                assert( m == 1 );
61
62                // return flag
63                bool ok = p == 0;
64                if( ! ok )
65                        return ok;
66
67                // check for defining variable information
68                // This case must always be implemented
69                if( vx.size() > 0 )
70                        vy[0] = vx[0];
71
72                // Order zero forward mode.
73                // This case must always be implemented
74                // y^0 = f( x^0 ) = 1 / x^0
75                double f = 1. / tx[0];
76                if( q <= 0 )
77                        ty[0] = f;
78                return ok;
79        }
80}; // End of atomic_get_started class
81}  // End empty namespace
82
83bool get_started(void)
84{       bool ok = true;
85        using CppAD::AD;
86        using CppAD::NearEqual;
87        double eps = 10. * CppAD::numeric_limits<double>::epsilon();
88
89        // --------------------------------------------------------------------
90        // Create the atomic get_started object
91        atomic_get_started afun("atomic_get_started");
92        // --------------------------------------------------------------------
93        // Create the function f(x)
94        //
95        // domain space vector
96        size_t n  = 1;
97        double  x0 = 0.5;
98        vector< AD<double> > ax(n);
99        ax[0]     = x0;
100
101        // declare independent variables and start tape recording
102        CppAD::Independent(ax);
103
104        // range space vector
105        size_t m = 1;
106        vector< AD<double> > ay(m);
107
108        // call user function and store get_started(x) in au[0]
109        vector< AD<double> > au(m);
110        afun(ax, au);        // u = 1 / x
111
112        // now use AD division to invert to invert the operation
113        ay[0] = 1.0 / au[0]; // y = 1 / u = x
114
115        // create f: x -> y and stop tape recording
116        CppAD::ADFun<double> f;
117        f.Dependent (ax, ay);  // f(x) = x
118
119        // --------------------------------------------------------------------
120        // Check forward mode results
121        //
122        // check function value
123        double check = x0;
124        ok &= NearEqual( Value(ay[0]) , check,  eps, eps);
125
126        // check zero order forward mode
127        size_t p;
128        vector<double> x_p(n), y_p(m);
129        p      = 0;
130        x_p[0] = x0;
131        y_p    = f.Forward(p, x_p);
132        ok &= NearEqual(y_p[0] , check,  eps, eps);
133
134        return ok;
135}
136// END C++
Note: See TracBrowser for help on using the repository browser.