source: branches/cache/cppad/local/mul_op.hpp @ 3324

Last change on this file since 3324 was 3324, checked in by bradbell, 6 years ago

merge trunk changes into cache

  • Property svn:keywords set to Id
File size: 9.3 KB
Line 
1/* $Id: mul_op.hpp 3324 2014-09-12 12:14:53Z bradbell $ */
2# ifndef CPPAD_MUL_OP_INCLUDED
3# define CPPAD_MUL_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 mul_op.hpp
19Forward and reverse mode calculations for z = x * y.
20*/
21
22// --------------------------- Mulvv -----------------------------------------
23/*!
24Compute forward mode Taylor coefficients for result of op = MulvvOp.
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_mulvv_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(MulvvOp) == 2 );
49        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
50        CPPAD_ASSERT_UNKNOWN( q < cap_order );
51        CPPAD_ASSERT_UNKNOWN( p <= q );
52
53        // Taylor coefficients corresponding to arguments and result
54        Base* x = taylor + arg[0] * cap_order;
55        Base* y = taylor + arg[1] * cap_order;
56        Base* z = taylor + i_z    * cap_order;
57
58        size_t k;
59        for(size_t d = p; d <= q; d++)
60        {       z[d] = Base(0);
61                for(k = 0; k <= d; k++)
62                        z[d] += x[d-k] * y[k];
63        }
64}
65/*!
66Multiple directions forward mode Taylor coefficients for op = MulvvOp.
67
68The C++ source code corresponding to this operation is
69\verbatim
70        z = x * y
71\endverbatim
72In the documentation below,
73this operations is for the case where both x and y are variables
74and the argument \a parameter is not used.
75
76\copydetails forward_binary_op_dir
77*/
78
79template <class Base>
80inline void forward_mulvv_op_dir(
81        size_t        q           , 
82        size_t        r           , 
83        size_t        i_z         ,
84        const addr_t* arg         ,
85        const Base*   parameter   ,
86        size_t        cap_order   ,
87        Base*         taylor      )
88{
89        // check assumptions
90        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
91        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
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        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 k, ell, m;
102        for(ell = 0; ell < r; ell++)
103        {       m = (q-1)*r + ell + 1;
104                z[m] = x[0] * y[m] + x[m] * y[0]; 
105                for(k = 1; k < q; k++)
106                        z[m] += x[(q-k-1)*r + ell + 1] * y[(k-1)*r + ell + 1];
107        }
108}
109
110/*!
111Compute zero order forward mode Taylor coefficients for result of op = MulvvOp.
112
113The C++ source code corresponding to this operation is
114\verbatim
115        z = x * y
116\endverbatim
117In the documentation below,
118this operations is for the case where both x and y are variables
119and the argument \a parameter is not used.
120
121\copydetails forward_binary_op_0
122*/
123
124template <class Base>
125inline void forward_mulvv_op_0(
126        size_t        i_z         ,
127        const addr_t* arg         ,
128        const Base*   parameter   ,
129        size_t        cap_order   ,
130        Base*         taylor      )
131{
132        // check assumptions
133        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
134        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
135
136        // Taylor coefficients corresponding to arguments and result
137        Base* x = taylor + arg[0] * cap_order;
138        Base* y = taylor + arg[1] * cap_order;
139        Base* z = taylor + i_z    * cap_order;
140
141        z[0] = x[0] * y[0];
142}
143
144/*!
145Compute reverse mode partial derivatives for result of op = MulvvOp.
146
147The C++ source code corresponding to this operation is
148\verbatim
149        z = x * y
150\endverbatim
151In the documentation below,
152this operations is for the case where both x and y are variables
153and the argument \a parameter is not used.
154
155\copydetails reverse_binary_op
156*/
157
158template <class Base>
159inline void reverse_mulvv_op(
160        size_t        d           , 
161        size_t        i_z         ,
162        const addr_t* arg         ,
163        const Base*   parameter   ,
164        size_t        cap_order   ,
165        const Base*   taylor      ,
166        size_t        nc_partial  ,
167        Base*         partial     )
168{
169        // check assumptions
170        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
171        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
172        CPPAD_ASSERT_UNKNOWN( d < cap_order );
173        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
174
175        // Arguments
176        const Base* x  = taylor + arg[0] * cap_order;
177        const Base* y  = taylor + arg[1] * cap_order;
178
179        // Partial derivatives corresponding to arguments and result
180        Base* px = partial + arg[0] * nc_partial;
181        Base* py = partial + arg[1] * nc_partial;
182        Base* pz = partial + i_z    * nc_partial;
183
184
185        // number of indices to access
186        size_t j = d + 1;
187        size_t k;
188        while(j)
189        {       --j;
190                for(k = 0; k <= j; k++)
191                {       
192                        px[j-k] += pz[j] * y[k];
193                        py[k]   += pz[j] * x[j-k];
194                }
195        }
196}
197// --------------------------- Mulpv -----------------------------------------
198/*!
199Compute forward mode Taylor coefficients for result of op = MulpvOp.
200
201The C++ source code corresponding to this operation is
202\verbatim
203        z = x * y
204\endverbatim
205In the documentation below,
206this operations is for the case where x is a parameter and y is a variable.
207
208\copydetails forward_binary_op
209*/
210
211template <class Base>
212inline void forward_mulpv_op(
213        size_t        p           , 
214        size_t        q           , 
215        size_t        i_z         ,
216        const addr_t* arg         ,
217        const Base*   parameter   ,
218        size_t        cap_order   ,
219        Base*         taylor      )
220{
221        // check assumptions
222        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
223        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
224        CPPAD_ASSERT_UNKNOWN( q < cap_order );
225        CPPAD_ASSERT_UNKNOWN( p <= q );
226
227        // Taylor coefficients corresponding to arguments and result
228        Base* y = taylor + arg[1] * cap_order;
229        Base* z = taylor + i_z    * cap_order;
230
231        // Paraemter value
232        Base x = parameter[ arg[0] ];
233
234        for(size_t d = p; d <= q; d++)
235                z[d] = x * y[d];
236}
237/*!
238Multiple directions forward mode Taylor coefficients for op = MulpvOp.
239
240The C++ source code corresponding to this operation is
241\verbatim
242        z = x * y
243\endverbatim
244In the documentation below,
245this operations is for the case where x is a parameter and y is a variable.
246
247\copydetails forward_binary_op_dir
248*/
249
250template <class Base>
251inline void forward_mulpv_op_dir(
252        size_t        q           , 
253        size_t        r           , 
254        size_t        i_z         ,
255        const addr_t* arg         ,
256        const Base*   parameter   ,
257        size_t        cap_order   ,
258        Base*         taylor      )
259{
260        // check assumptions
261        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
262        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
263        CPPAD_ASSERT_UNKNOWN( 0 < q );
264        CPPAD_ASSERT_UNKNOWN( q < cap_order );
265
266        // Taylor coefficients corresponding to arguments and result
267        size_t num_taylor_per_var = (cap_order-1) * r + 1;
268        size_t m                  = (q-1) * r + 1;
269        Base* y = taylor + arg[1] * num_taylor_per_var + m;
270        Base* z = taylor + i_z    * num_taylor_per_var + m;
271
272        // Paraemter value
273        Base x = parameter[ arg[0] ];
274
275        for(size_t ell = 0; ell < r; ell++)
276                z[ell] = x * y[ell];
277}
278/*!
279Compute zero order forward mode Taylor coefficient for result of op = MulpvOp.
280
281The C++ source code corresponding to this operation is
282\verbatim
283        z = x * y
284\endverbatim
285In the documentation below,
286this operations is for the case where x is a parameter and y is a variable.
287
288\copydetails forward_binary_op_0
289*/
290
291template <class Base>
292inline void forward_mulpv_op_0(
293        size_t        i_z         ,
294        const addr_t* arg         ,
295        const Base*   parameter   ,
296        size_t        cap_order   ,
297        Base*         taylor      )
298{
299        // check assumptions
300        CPPAD_ASSERT_UNKNOWN( NumArg(MulpvOp) == 2 );
301        CPPAD_ASSERT_UNKNOWN( NumRes(MulpvOp) == 1 );
302
303        // Paraemter value
304        Base x = parameter[ arg[0] ];
305
306        // Taylor coefficients corresponding to arguments and result
307        Base* y = taylor + arg[1] * cap_order;
308        Base* z = taylor + i_z    * cap_order;
309
310        z[0] = x * y[0];
311}
312
313/*!
314Compute reverse mode partial derivative for result of op = MulpvOp.
315
316The C++ source code corresponding to this operation is
317\verbatim
318        z = x * y
319\endverbatim
320In the documentation below,
321this operations is for the case where x is a parameter and y is a variable.
322
323\copydetails reverse_binary_op
324*/
325
326template <class Base>
327inline void reverse_mulpv_op(
328        size_t        d           , 
329        size_t        i_z         ,
330        const addr_t* arg         ,
331        const Base*   parameter   ,
332        size_t        cap_order   ,
333        const Base*   taylor      ,
334        size_t        nc_partial  ,
335        Base*         partial     )
336{
337        // check assumptions
338        CPPAD_ASSERT_UNKNOWN( NumArg(MulvvOp) == 2 );
339        CPPAD_ASSERT_UNKNOWN( NumRes(MulvvOp) == 1 );
340        CPPAD_ASSERT_UNKNOWN( d < cap_order );
341        CPPAD_ASSERT_UNKNOWN( d < nc_partial );
342
343        // Arguments
344        Base x  = parameter[ arg[0] ];
345
346        // Partial derivatives corresponding to arguments and result
347        Base* py = partial + arg[1] * nc_partial;
348        Base* pz = partial + i_z    * nc_partial;
349
350        // number of indices to access
351        size_t j = d + 1;
352        while(j)
353        {       --j;
354                py[j] += pz[j] * x;
355        }
356}
357
358
359} // END_CPPAD_NAMESPACE
360# endif
Note: See TracBrowser for help on using the repository browser.