source: trunk/cppad/local/sub_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: 13.7 KB
Line 
1/* $Id: sub_op.hpp 3301 2014-05-24 05:20:21Z bradbell $ */
2# ifndef CPPAD_SUB_OP_INCLUDED
3# define CPPAD_SUB_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 sub_op.hpp
19Forward and reverse mode calculations for z = x - y.
20*/
21
22// --------------------------- Subvv -----------------------------------------
23/*!
24Compute forward mode Taylor coefficients for result of op = SubvvOp.
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_subvv_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(SubvvOp) == 2 );
49        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 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 d = p; d <= q; d++)
61                z[d] = x[d] - y[d];
62}
63/*!
64Multiple directions forward mode Taylor coefficients for op = SubvvOp.
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_subvv_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(SubvvOp) == 2 );
89        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 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( 0 < q );
93        CPPAD_ASSERT_UNKNOWN( q < cap_order );
94
95        // Taylor coefficients corresponding to arguments and result
96        size_t num_taylor_per_var = (cap_order-1) * r + 1;
97        size_t m                  = (q-1) * r + 1;
98        Base* x = taylor + arg[0] * num_taylor_per_var + m;
99        Base* y = taylor + arg[1] * num_taylor_per_var + m;
100        Base* z = taylor + i_z    * num_taylor_per_var + m;
101
102        for(size_t ell = 0; ell < r; ell++)
103                z[ell] = x[ell] - y[ell];
104}
105
106/*!
107Compute zero order forward mode Taylor coefficients for result of op = SubvvOp.
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_subvv_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(SubvvOp) == 2 );
130        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 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 = SubvvOp.
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_subvv_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(SubvvOp) == 2 );
169        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 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// --------------------------- Subpv -----------------------------------------
190/*!
191Compute forward mode Taylor coefficients for result of op = SubpvOp.
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*/
202
203template <class Base>
204inline void forward_subpv_op(
205        size_t        p           , 
206        size_t        q           , 
207        size_t        i_z         ,
208        const addr_t* arg         ,
209        const Base*   parameter   ,
210        size_t        cap_order   ,
211        Base*         taylor      )
212{
213        // check assumptions
214        CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
215        CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
216        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
217        CPPAD_ASSERT_UNKNOWN( q < cap_order );
218        CPPAD_ASSERT_UNKNOWN( p <= q );
219
220        // Taylor coefficients corresponding to arguments and result
221        Base* y = taylor + arg[1] * cap_order;
222        Base* z = taylor + i_z    * cap_order;
223
224        // Paraemter value
225        Base x = parameter[ arg[0] ];
226        if( p == 0 )
227        {       z[0] = x - y[0];
228                p++;
229        }
230        for(size_t d = p; d <= q; d++)
231                z[d] = - y[d];
232}
233/*!
234Multiple directions forward mode Taylor coefficients for op = SubpvOp.
235
236The C++ source code corresponding to this operation is
237\verbatim
238        z = x - y
239\endverbatim
240In the documentation below,
241this operations is for the case where x is a parameter and y is a variable.
242
243\copydetails forward_binary_op_dir
244*/
245
246template <class Base>
247inline void forward_subpv_op_dir(
248        size_t        q           , 
249        size_t        r           , 
250        size_t        i_z         ,
251        const addr_t* arg         ,
252        const Base*   parameter   ,
253        size_t        cap_order   ,
254        Base*         taylor      )
255{
256        // check assumptions
257        CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
258        CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
259        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
260        CPPAD_ASSERT_UNKNOWN( 0 < q );
261        CPPAD_ASSERT_UNKNOWN( q < cap_order );
262
263        // Taylor coefficients corresponding to arguments and result
264        size_t num_taylor_per_var = (cap_order-1) * r + 1;
265        size_t m                  = (q-1) * r + 1;
266        Base* y = taylor + arg[1] * num_taylor_per_var + m;
267        Base* z = taylor + i_z    * num_taylor_per_var + m;
268
269        // Paraemter value
270        for(size_t ell = 0; ell < r; ell++)
271                z[ell] = - y[ell];
272}
273/*!
274Compute zero order forward mode Taylor coefficient for result of op = SubpvOp.
275
276The C++ source code corresponding to this operation is
277\verbatim
278        z = x - y
279\endverbatim
280In the documentation below,
281this operations is for the case where x is a parameter and y is a variable.
282
283\copydetails forward_binary_op_0
284*/
285
286template <class Base>
287inline void forward_subpv_op_0(
288        size_t        i_z         ,
289        const addr_t* arg         ,
290        const Base*   parameter   ,
291        size_t        cap_order   ,
292        Base*         taylor      )
293{
294        // check assumptions
295        CPPAD_ASSERT_UNKNOWN( NumArg(SubpvOp) == 2 );
296        CPPAD_ASSERT_UNKNOWN( NumRes(SubpvOp) == 1 );
297        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
298
299        // Paraemter value
300        Base x = parameter[ arg[0] ];
301
302        // Taylor coefficients corresponding to arguments and result
303        Base* y = taylor + arg[1] * cap_order;
304        Base* z = taylor + i_z    * cap_order;
305
306        z[0] = x - y[0];
307}
308
309/*!
310Compute reverse mode partial derivative for result of op = SubpvOp.
311
312The C++ source code corresponding to this operation is
313\verbatim
314        z = x - y
315\endverbatim
316In the documentation below,
317this operations is for the case where x is a parameter and y is a variable.
318
319\copydetails reverse_binary_op
320*/
321
322template <class Base>
323inline void reverse_subpv_op(
324        size_t        d           , 
325        size_t        i_z         ,
326        const addr_t* arg         ,
327        const Base*   parameter   ,
328        size_t        cap_order   ,
329        const Base*   taylor      ,
330        size_t        nc_partial  ,
331        Base*         partial     )
332{
333        // check assumptions
334        CPPAD_ASSERT_UNKNOWN( NumArg(SubvvOp) == 2 );
335        CPPAD_ASSERT_UNKNOWN( NumRes(SubvvOp) == 1 );
336        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < i_z );
337        CPPAD_ASSERT_UNKNOWN( d < cap_order );
338        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
339
340        // Partial derivatives corresponding to arguments and result
341        Base* py = partial + arg[1] * nc_partial;
342        Base* pz = partial + i_z    * nc_partial;
343
344        // number of indices to access
345        size_t i = d + 1;
346        while(i)
347        {       --i;
348                py[i] -= pz[i];
349        }
350}
351
352// --------------------------- Subvp -----------------------------------------
353/*!
354Compute forward mode Taylor coefficients for result of op = SubvvOp.
355
356The C++ source code corresponding to this operation is
357\verbatim
358        z = x - y
359\endverbatim
360In the documentation below,
361this operations is for the case where x is a variable and y is a parameter.
362
363\copydetails forward_binary_op
364*/
365
366template <class Base>
367inline void forward_subvp_op(
368        size_t        p           , 
369        size_t        q           , 
370        size_t        i_z         ,
371        const addr_t* arg         ,
372        const Base*   parameter   ,
373        size_t        cap_order   ,
374        Base*         taylor      )
375{
376        // check assumptions
377        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
378        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
379        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
380        CPPAD_ASSERT_UNKNOWN( q < cap_order );
381        CPPAD_ASSERT_UNKNOWN( p <= q );
382
383        // Taylor coefficients corresponding to arguments and result
384        Base* x = taylor + arg[0] * cap_order;
385        Base* z = taylor + i_z    * cap_order;
386
387        // Parameter value
388        Base y = parameter[ arg[1] ];
389        if( p == 0 )
390        {       z[0] = x[0] - y;
391                p++;
392        }
393        for(size_t d = p; d <= q; d++)
394                z[d] = x[d];
395}
396/*!
397Multiple directions forward mode Taylor coefficients for op = SubvvOp.
398
399The C++ source code corresponding to this operation is
400\verbatim
401        z = x - y
402\endverbatim
403In the documentation below,
404this operations is for the case where x is a variable and y is a parameter.
405
406\copydetails forward_binary_op_dir
407*/
408
409template <class Base>
410inline void forward_subvp_op_dir(
411        size_t        q           , 
412        size_t        r           , 
413        size_t        i_z         ,
414        const addr_t* arg         ,
415        const Base*   parameter   ,
416        size_t        cap_order   ,
417        Base*         taylor      )
418{
419        // check assumptions
420        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
421        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
422        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
423        CPPAD_ASSERT_UNKNOWN( 0 < q );
424        CPPAD_ASSERT_UNKNOWN( q < cap_order );
425
426        // Taylor coefficients corresponding to arguments and result
427        size_t num_taylor_per_var = (cap_order-1) * r + 1;
428        Base* x = taylor + arg[0] * num_taylor_per_var;
429        Base* z = taylor + i_z    * num_taylor_per_var;
430
431        // Parameter value
432        size_t m = (q-1) * r + 1;
433        for(size_t ell = 0; ell < r; ell++)
434                z[m+ell] = x[m+ell];
435}
436
437/*!
438Compute zero order forward mode Taylor coefficients for result of op = SubvvOp.
439
440The C++ source code corresponding to this operation is
441\verbatim
442        z = x - y
443\endverbatim
444In the documentation below,
445this operations is for the case where x is a variable and y is a parameter.
446
447\copydetails forward_binary_op_0
448*/
449
450template <class Base>
451inline void forward_subvp_op_0(
452        size_t        i_z         ,
453        const addr_t* arg         ,
454        const Base*   parameter   ,
455        size_t        cap_order   ,
456        Base*         taylor      )
457{
458        // check assumptions
459        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
460        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
461        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
462
463        // Parameter value
464        Base y = parameter[ arg[1] ];
465
466        // Taylor coefficients corresponding to arguments and result
467        Base* x = taylor + arg[0] * cap_order;
468        Base* z = taylor + i_z    * cap_order;
469
470        z[0] = x[0] - y;
471}
472
473/*!
474Compute reverse mode partial derivative for result of op = SubvpOp.
475
476The C++ source code corresponding to this operation is
477\verbatim
478        z = x - y
479\endverbatim
480In the documentation below,
481this operations is for the case where x is a variable and y is a parameter.
482
483\copydetails reverse_binary_op
484*/
485
486template <class Base>
487inline void reverse_subvp_op(
488        size_t        d           , 
489        size_t        i_z         ,
490        const addr_t* arg         ,
491        const Base*   parameter   ,
492        size_t        cap_order   ,
493        const Base*   taylor      ,
494        size_t        nc_partial  ,
495        Base*         partial     )
496{
497        // check assumptions
498        CPPAD_ASSERT_UNKNOWN( NumArg(SubvpOp) == 2 );
499        CPPAD_ASSERT_UNKNOWN( NumRes(SubvpOp) == 1 );
500        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < i_z );
501        CPPAD_ASSERT_UNKNOWN( d < cap_order );
502        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
503
504        // Partial derivatives corresponding to arguments and result
505        Base* px = partial + arg[0] * nc_partial;
506        Base* pz = partial + i_z    * nc_partial;
507
508        // number of indices to access
509        size_t i = d + 1;
510        while(i)
511        {       --i;
512                px[i] += pz[i];
513        }
514}
515
516} // END_CPPAD_NAMESPACE
517# endif
Note: See TracBrowser for help on using the repository browser.