source: trunk/cppad/local/add_op.hpp @ 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: 9.4 KB
Line 
1/* $Id: add_op.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
2# ifndef CPPAD_ADD_OP_INCLUDED
3# define CPPAD_ADD_OP_INCLUDED
4
5/* --------------------------------------------------------------------------
6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
7
8CppAD is distributed under multiple licenses. This distribution is under
9the terms of the
10                    Eclipse Public License Version 1.0.
11
12A copy of this license is included in the COPYING file of this distribution.
13Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
14-------------------------------------------------------------------------- */
15
16namespace CppAD { // BEGIN_CPPAD_NAMESPACE
17/*!
18\file add_op.hpp
19Forward and reverse mode calculations for z = x + y.
20*/
21
22// --------------------------- Addvv -----------------------------------------
23/*!
24Compute forward mode Taylor coefficients for result of op = AddvvOp.
25
26The C++ source code corresponding to this operation is
27\verbatim
28        z = x + y
29\endverbatim
30In the documentation below,
31this operations is for the case where both x and y are variables
32and the argument \a parameter is not used.
33
34\copydetails forward_binary_op
35*/
36
37template <class Base>
38inline void forward_addvv_op(
39        size_t        p           , 
40        size_t        q           , 
41        size_t        i_z         ,
42        const addr_t* arg         ,
43        const Base*   parameter   ,
44        size_t        cap_order   ,
45        Base*         taylor      )
46{
47        // check assumptions
48        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
49        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
50        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
51        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
52        CPPAD_ASSERT_UNKNOWN( q < cap_order );
53        CPPAD_ASSERT_UNKNOWN( p <= q  );
54
55        // Taylor coefficients corresponding to arguments and result
56        Base* x = taylor + arg[0] * cap_order;
57        Base* y = taylor + arg[1] * cap_order;
58        Base* z = taylor + i_z    * cap_order;
59
60        for(size_t j = p; j <= q; j++)
61                z[j] = x[j] + y[j];
62}
63/*!
64Multiple directions forward mode Taylor coefficients for op = AddvvOp.
65
66The C++ source code corresponding to this operation is
67\verbatim
68        z = x + y
69\endverbatim
70In the documentation below,
71this operations is for the case where both x and y are variables
72and the argument \a parameter is not used.
73
74\copydetails forward_binary_op_dir
75*/
76
77template <class Base>
78inline void forward_addvv_op_dir(
79        size_t        q           , 
80        size_t        r           , 
81        size_t        i_z         ,
82        const addr_t* arg         ,
83        const Base*   parameter   ,
84        size_t        cap_order   ,
85        Base*         taylor      )
86{
87        // check assumptions
88        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
89        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
90        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
91        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
92        CPPAD_ASSERT_UNKNOWN( q < cap_order );
93        CPPAD_ASSERT_UNKNOWN( 0 < q  );
94
95        // Taylor coefficients corresponding to arguments and result
96        size_t num_taylor_per_var = (cap_order-1) * r + 1;
97        Base* x = taylor + arg[0] * num_taylor_per_var;
98        Base* y = taylor + arg[1] * num_taylor_per_var;
99        Base* z = taylor +    i_z * num_taylor_per_var;
100
101        size_t m = (q-1)*r + 1 ;
102        for(size_t ell = 0; ell < r; ell++)
103                z[m+ell] = x[m+ell] + y[m+ell];
104}
105
106/*!
107Compute zero order forward mode Taylor coefficients for result of op = AddvvOp.
108
109The C++ source code corresponding to this operation is
110\verbatim
111        z = x + y
112\endverbatim
113In the documentation below,
114this operations is for the case where both x and y are variables
115and the argument \a parameter is not used.
116
117\copydetails forward_binary_op_0
118*/
119
120template <class Base>
121inline void forward_addvv_op_0(
122        size_t        i_z         ,
123        const addr_t* arg         ,
124        const Base*   parameter   ,
125        size_t        cap_order   ,
126        Base*         taylor      )
127{
128        // check assumptions
129        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
130        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
131        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
132        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
133
134        // Taylor coefficients corresponding to arguments and result
135        Base* x = taylor + arg[0] * cap_order;
136        Base* y = taylor + arg[1] * cap_order;
137        Base* z = taylor + i_z    * cap_order;
138
139        z[0] = x[0] + y[0];
140}
141
142/*!
143Compute reverse mode partial derivatives for result of op = AddvvOp.
144
145The C++ source code corresponding to this operation is
146\verbatim
147        z = x + y
148\endverbatim
149In the documentation below,
150this operations is for the case where both x and y are variables
151and the argument \a parameter is not used.
152
153\copydetails reverse_binary_op
154*/
155
156template <class Base>
157inline void reverse_addvv_op(
158        size_t        d           , 
159        size_t        i_z         ,
160        const addr_t* arg         ,
161        const Base*   parameter   ,
162        size_t        cap_order   ,
163        const Base*   taylor      ,
164        size_t        nc_partial  ,
165        Base*         partial     )
166{
167        // check assumptions
168        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
169        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
170        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
171        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
172        CPPAD_ASSERT_UNKNOWN( d < cap_order );
173        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
174
175        // Partial derivatives corresponding to arguments and result
176        Base* px = partial + arg[0] * nc_partial;
177        Base* py = partial + arg[1] * nc_partial;
178        Base* pz = partial + i_z    * nc_partial;
179
180        // number of indices to access
181        size_t i = d + 1;
182        while(i)
183        {       --i;
184                px[i] += pz[i];
185                py[i] += pz[i];
186        }
187}
188
189// --------------------------- Addpv -----------------------------------------
190/*!
191Compute forward mode Taylor coefficients for result of op = AddpvOp.
192
193The C++ source code corresponding to this operation is
194\verbatim
195        z = x + y
196\endverbatim
197In the documentation below,
198this operations is for the case where x is a parameter and y is a variable.
199
200\copydetails forward_binary_op
201*/
202template <class Base>
203inline void forward_addpv_op(
204        size_t        p           , 
205        size_t        q           , 
206        size_t        i_z         ,
207        const addr_t* arg         ,
208        const Base*   parameter   ,
209        size_t        cap_order   ,
210        Base*         taylor      )
211{
212        // check assumptions
213        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
214        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
215        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
216        CPPAD_ASSERT_UNKNOWN( q < cap_order );
217        CPPAD_ASSERT_UNKNOWN( p <= q );
218
219        // Taylor coefficients corresponding to arguments and result
220        Base* y = taylor + arg[1] * cap_order;
221        Base* z = taylor + i_z    * cap_order;
222
223        if( p == 0 )
224        {       // Paraemter value
225                Base x = parameter[ arg[0] ];
226                z[0] = x + y[0];
227                p++;
228        }
229        for(size_t j = p; j <= q; j++)
230                z[j] = y[j];
231}
232/*!
233Multiple directions forward mode Taylor coefficients for op = AddpvOp.
234
235The C++ source code corresponding to this operation is
236\verbatim
237        z = x + y
238\endverbatim
239In the documentation below,
240this operations is for the case where x is a parameter and y is a variable.
241
242\copydetails forward_binary_op_dir
243*/
244template <class Base>
245inline void forward_addpv_op_dir(
246        size_t        q           , 
247        size_t        r           , 
248        size_t        i_z         ,
249        const addr_t* arg         ,
250        const Base*   parameter   ,
251        size_t        cap_order   ,
252        Base*         taylor      )
253{
254        // check assumptions
255        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
256        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
257        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
258        CPPAD_ASSERT_UNKNOWN( 0 < q );
259        CPPAD_ASSERT_UNKNOWN( q < cap_order );
260
261        // Taylor coefficients corresponding to arguments and result
262        size_t num_taylor_per_var = (cap_order-1) * r + 1;
263        size_t m                  = (q-1) * r + 1;
264        Base* y = taylor + arg[1] * num_taylor_per_var + m;
265        Base* z = taylor + i_z    * num_taylor_per_var + m;
266
267        for(size_t ell = 0; ell < r; ell++)
268                z[ell] = y[ell];
269}
270/*!
271Compute zero order forward mode Taylor coefficient for result of op = AddpvOp.
272
273The C++ source code corresponding to this operation is
274\verbatim
275        z = x + y
276\endverbatim
277In the documentation below,
278this operations is for the case where x is a parameter and y is a variable.
279
280\copydetails forward_binary_op_0
281*/
282
283template <class Base>
284inline void forward_addpv_op_0(
285        size_t        i_z         ,
286        const addr_t* arg         ,
287        const Base*   parameter   ,
288        size_t        cap_order   ,
289        Base*         taylor      )
290{
291        // check assumptions
292        CPPAD_ASSERT_UNKNOWN( NumArg(AddpvOp) == 2 );
293        CPPAD_ASSERT_UNKNOWN( NumRes(AddpvOp) == 1 );
294        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
295
296        // Paraemter value
297        Base x = parameter[ arg[0] ];
298
299        // Taylor coefficients corresponding to arguments and result
300        Base* y = taylor + arg[1] * cap_order;
301        Base* z = taylor + i_z    * cap_order;
302
303        z[0] = x + y[0];
304}
305
306/*!
307Compute reverse mode partial derivative for result of op = AddpvOp.
308
309The C++ source code corresponding to this operation is
310\verbatim
311        z = x + y
312\endverbatim
313In the documentation below,
314this operations is for the case where x is a parameter and y is a variable.
315
316\copydetails reverse_binary_op
317*/
318
319template <class Base>
320inline void reverse_addpv_op(
321        size_t        d           , 
322        size_t        i_z         ,
323        const addr_t* arg         ,
324        const Base*   parameter   ,
325        size_t        cap_order   ,
326        const Base*   taylor      ,
327        size_t        nc_partial  ,
328        Base*         partial     )
329{
330        // check assumptions
331        CPPAD_ASSERT_UNKNOWN( NumArg(AddvvOp) == 2 );
332        CPPAD_ASSERT_UNKNOWN( NumRes(AddvvOp) == 1 );
333        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
334        CPPAD_ASSERT_UNKNOWN( d < cap_order );
335        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
336
337        // Partial derivatives corresponding to arguments and result
338        Base* py = partial + arg[1] * nc_partial;
339        Base* pz = partial + i_z    * nc_partial;
340
341        // number of indices to access
342        size_t i = d + 1;
343        while(i)
344        {       --i;
345                py[i] += pz[i];
346        }
347}
348
349
350} // END_CPPAD_NAMESPACE
351# endif
Note: See TracBrowser for help on using the repository browser.