CppAD: A C++ Algorithmic Differentiation Package  20171217
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
forward2sweep.hpp
Go to the documentation of this file.
1 # ifndef CPPAD_LOCAL_FORWARD2SWEEP_HPP
2 # define CPPAD_LOCAL_FORWARD2SWEEP_HPP
3 
4 /* --------------------------------------------------------------------------
5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-17 Bradley M. Bell
6 
7 CppAD is distributed under multiple licenses. This distribution is under
8 the terms of the
9  Eclipse Public License Version 1.0.
10 
11 A copy of this license is included in the COPYING file of this distribution.
12 Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13 -------------------------------------------------------------------------- */
14 
15 namespace CppAD { namespace local { // BEGIN_CPPAD_LOCAL_NAMESPACE
16 /*!
17 \file forward2sweep.hpp
18 Compute one Taylor coefficient for each direction requested.
19 */
20 
21 /*
22 \def CPPAD_ATOMIC_CALL
23 This avoids warnings when NDEBUG is defined and user_ok is not used.
24 If NDEBUG is defined, this resolves to
25 \code
26  user_atom->forward
27 \endcode
28 otherwise, it respolves to
29 \code
30  user_ok = user_atom->forward
31 \endcode
32 This macro is undefined at the end of this file to facillitate its
33 use with a different definition in other files.
34 */
35 # ifdef NDEBUG
36 # define CPPAD_ATOMIC_CALL user_atom->forward
37 # else
38 # define CPPAD_ATOMIC_CALL user_ok = user_atom->forward
39 # endif
40 
41 /*!
42 \def CPPAD_FORWARD2SWEEP_TRACE
43 This value is either zero or one.
44 Zero is the normal operational value.
45 If it is one, a trace of every forward2sweep computation is printed.
46 */
47 # define CPPAD_FORWARD2SWEEP_TRACE 0
48 
49 /*!
50 Compute multiple directions forward mode Taylor coefficients.
51 
52 \tparam Base
53 The type used during the forward mode computations; i.e., the corresponding
54 recording of operations used the type AD<Base>.
55 
56 \param q
57 is the order of the Taylor coefficients
58 that are computed during this call;
59 <code>q > 0</code>.
60 
61 \param r
62 is the number of Taylor coefficients
63 that are computed during this call.
64 
65 \param n
66 is the number of independent variables on the tape.
67 
68 \param numvar
69 is the total number of variables on the tape.
70 This is also equal to the number of rows in the matrix taylor; i.e.,
71 play->num_var_rec().
72 
73 \param play
74 The information stored in play
75 is a recording of the operations corresponding to the function
76 \f[
77  F : {\bf R}^n \rightarrow {\bf R}^m
78 \f]
79 where \f$ n \f$ is the number of independent variables and
80 \f$ m \f$ is the number of dependent variables.
81 
82 \param J
83 Is the number of columns in the coefficient matrix taylor.
84 This must be greater than or equal one.
85 
86 \param taylor
87 \n
88 \b Input:
89 For <code>i = 1 , ... , numvar-1</code>,
90 <code>taylor[ (J-1)*r*i + i + 0 ]</code>
91 is the zero order Taylor coefficient corresponding to
92 the i-th variable and all directions.
93 For <code>i = 1 , ... , numvar-1</code>,
94 For <code>k = 1 , ... , q-1</code>,
95 <code>ell = 0 , ... , r-1</code>,
96 <code>taylor[ (J-1)*r*i + i + (k-1)*r + ell + 1 ]</code>
97 is the k-th order Taylor coefficient corresponding to
98 the i-th variabel and ell-th direction.
99 \n
100 \n
101 \b Input:
102 For <code>i = 1 , ... , n</code>,
103 <code>ell = 0 , ... , r-1</code>,
104 <code>taylor[ (J-1)*r*i + i + (q-1)*r + ell + 1 ]</code>
105 is the q-th order Taylor coefficient corresponding to
106 the i-th variable and ell-th direction
107 (these are the independent varaibles).
108 \n
109 \n
110 \b Output:
111 For <code>i = n+1 , ... , numvar-1</code>,
112 <code>ell = 0 , ... , r-1</code>,
113 <code>taylor[ (J-1)*r*i + i + (q-1)*r + ell + 1 ]</code>
114 is the q-th order Taylor coefficient corresponding to
115 the i-th variable and ell-th direction.
116 
117 \param cskip_op
118 Is a vector with size play->num_op_rec().
119 If cskip_op[i] is true, the operator with index i
120 does not affect any of the dependent variable (given the value
121 of the independent variables).
122 
123 \param var_by_load_op
124 is a vector with size play->num_load_op_rec().
125 It is the variable index corresponding to each the
126 load instruction.
127 In the case where the index is zero,
128 the instruction corresponds to a parameter (not variable).
129 
130 */
131 
132 template <class Base>
133 void forward2sweep(
134  const local::player<Base>* play,
135  const size_t q,
136  const size_t r,
137  const size_t n,
138  const size_t numvar,
139  const size_t J,
140  Base* taylor,
141  const bool* cskip_op,
142  const pod_vector<addr_t>& var_by_load_op
143 )
144 {
145  CPPAD_ASSERT_UNKNOWN( q > 0 );
146  CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
147  CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == numvar );
148 
149  // used to avoid compiler errors until all operators are implemented
150  size_t p = q;
151 
152  // op code for current instruction
153  OpCode op;
154 
155  // index for current instruction
156  size_t i_op;
157 
158  // next variables
159  size_t i_var;
160 
161  // operation argument indices
162  const addr_t* arg = CPPAD_NULL;
163 
164  // work space used by UserOp.
165  vector<bool> user_vx; // empty vecotor
166  vector<bool> user_vy; // empty vecotor
167  vector<Base> user_tx_one; // argument vector Taylor coefficients
168  vector<Base> user_tx_all;
169  vector<Base> user_ty_one; // result vector Taylor coefficients
170  vector<Base> user_ty_all;
171  //
172  // information defined by forward_user
173  size_t user_old=0, user_m=0, user_n=0, user_i=0, user_j=0;
174  enum_user_state user_state = start_user; // proper initialization
175  //
176  atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
177 # ifndef NDEBUG
178  bool user_ok = false; // atomic op return value
179 # endif
180 
181  // length of the parameter vector (used by CppAD assert macros)
182  const size_t num_par = play->num_par_rec();
183 
184  // pointer to the beginning of the parameter vector
185  const Base* parameter = CPPAD_NULL;
186  if( num_par > 0 )
187  parameter = play->GetPar();
188 
189  // temporary indices
190  size_t i, j, k, ell;
191 
192  // number of orders for this user calculation
193  // (not needed for order zero)
194  const size_t user_q1 = q+1;
195 
196  // variable indices for results vector
197  // (done differently for order zero).
198  vector<size_t> user_iy;
199 
200  // skip the BeginOp at the beginning of the recording
201  i_op = 0;
202  play->get_op_info(i_op, op, arg, i_var);
203  CPPAD_ASSERT_UNKNOWN( op == BeginOp );
204 # if CPPAD_FORWARD2SWEEP_TRACE
205  bool user_trace = false;
206  std::cout << std::endl;
207  CppAD::vector<Base> Z_vec(q+1);
208 # endif
209  bool flag; // a temporary flag to use in switch cases
210  bool more_operators = true;
211  while(more_operators)
212  {
213  // this op
214  play->get_op_info(++i_op, op, arg, i_var);
215  CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
216 
217  // check if we are skipping this operation
218  while( cskip_op[i_op] )
219  { switch(op)
220  {
221  case UserOp:
222  { // get information for this user atomic call
223  CPPAD_ASSERT_UNKNOWN( user_state == start_user );
224  play->get_user_info(op, arg, user_old, user_m, user_n);
225  //
226  // skip to the second UserOp
227  i_op += user_m + user_n;
228  play->get_op_info(++i_op, op, arg, i_var);
229  CPPAD_ASSERT_UNKNOWN( op == UserOp );
230  }
231  break;
232 
233  default:
234  break;
235  }
236  play->get_op_info(++i_op, op, arg, i_var);
237  CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
238  }
239 
240  // action depends on the operator
241  switch( op )
242  {
243  case AbsOp:
244  forward_abs_op_dir(q, r, i_var, arg[0], J, taylor);
245  break;
246  // -------------------------------------------------
247 
248  case AddvvOp:
249  forward_addvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
250  break;
251  // -------------------------------------------------
252 
253  case AddpvOp:
254  CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
255  forward_addpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
256  break;
257  // -------------------------------------------------
258 
259  case AcosOp:
260  // sqrt(1 - x * x), acos(x)
261  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
262  forward_acos_op_dir(q, r, i_var, arg[0], J, taylor);
263  break;
264  // -------------------------------------------------
265 
266 # if CPPAD_USE_CPLUSPLUS_2011
267  case AcoshOp:
268  // sqrt(x * x - 1), acosh(x)
269  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
270  forward_acosh_op_dir(q, r, i_var, arg[0], J, taylor);
271  break;
272 # endif
273  // -------------------------------------------------
274 
275  case AsinOp:
276  // sqrt(1 - x * x), asin(x)
277  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
278  forward_asin_op_dir(q, r, i_var, arg[0], J, taylor);
279  break;
280  // -------------------------------------------------
281 
282 # if CPPAD_USE_CPLUSPLUS_2011
283  case AsinhOp:
284  // sqrt(1 + x * x), asinh(x)
285  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
286  forward_asinh_op_dir(q, r, i_var, arg[0], J, taylor);
287  break;
288 # endif
289  // -------------------------------------------------
290 
291  case AtanOp:
292  // 1 + x * x, atan(x)
293  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
294  forward_atan_op_dir(q, r, i_var, arg[0], J, taylor);
295  break;
296  // -------------------------------------------------
297 
298 # if CPPAD_USE_CPLUSPLUS_2011
299  case AtanhOp:
300  // 1 - x * x, atanh(x)
301  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
302  forward_atanh_op_dir(q, r, i_var, arg[0], J, taylor);
303  break;
304 # endif
305  // -------------------------------------------------
306 
307  case CExpOp:
308  forward_cond_op_dir(
309  q, r, i_var, arg, num_par, parameter, J, taylor
310  );
311  break;
312  // ---------------------------------------------------
313 
314  case CosOp:
315  // sin(x), cos(x)
316  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
317  forward_cos_op_dir(q, r, i_var, arg[0], J, taylor);
318  break;
319  // ---------------------------------------------------
320 
321  case CoshOp:
322  // sinh(x), cosh(x)
323  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
324  forward_cosh_op_dir(q, r, i_var, arg[0], J, taylor);
325  break;
326  // -------------------------------------------------
327 
328  case CSkipOp:
329  // CSkipOp only does somthing on order zero.
330  CPPAD_ASSERT_UNKNOWN( p > 0 );
331  break;
332  // -------------------------------------------------
333 
334  case CSumOp:
335  forward_csum_op_dir(
336  q, r, i_var, arg, num_par, parameter, J, taylor
337  );
338  break;
339  // -------------------------------------------------
340 
341  case DisOp:
342  forward_dis_op(p, q, r, i_var, arg, J, taylor);
343  break;
344  // -------------------------------------------------
345 
346  case DivvvOp:
347  forward_divvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
348  break;
349  // -------------------------------------------------
350 
351  case DivpvOp:
352  CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
353  forward_divpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
354  break;
355  // -------------------------------------------------
356 
357  case DivvpOp:
358  CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
359  forward_divvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
360  break;
361  // -------------------------------------------------
362 
363  case EndOp:
364  // needed for sparse_jacobian test
365  CPPAD_ASSERT_NARG_NRES(op, 0, 0);
366  more_operators = false;
367  break;
368  // -------------------------------------------------
369 
370 # if CPPAD_USE_CPLUSPLUS_2011
371  case ErfOp:
372  forward_erf_op_dir(q, r, i_var, arg, parameter, J, taylor);
373  break;
374  // -------------------------------------------------
375 # endif
376 
377  case ExpOp:
378  forward_exp_op_dir(q, r, i_var, arg[0], J, taylor);
379  break;
380  // -------------------------------------------------
381 
382 # if CPPAD_USE_CPLUSPLUS_2011
383  case Expm1Op:
384  forward_expm1_op_dir(q, r, i_var, arg[0], J, taylor);
385  break;
386 # endif
387  // -------------------------------------------------
388 
389  case InvOp:
390  CPPAD_ASSERT_NARG_NRES(op, 0, 1);
391  break;
392  // -------------------------------------------------
393 
394  case LdpOp:
395  case LdvOp:
396  forward_load_op(
397  play,
398  op,
399  p,
400  q,
401  r,
402  J,
403  i_var,
404  arg,
405  var_by_load_op.data(),
406  taylor
407  );
408  break;
409  // ---------------------------------------------------
410 
411  case EqpvOp:
412  case EqvvOp:
413  case LtpvOp:
414  case LtvpOp:
415  case LtvvOp:
416  case LepvOp:
417  case LevpOp:
418  case LevvOp:
419  case NepvOp:
420  case NevvOp:
421  CPPAD_ASSERT_UNKNOWN(q > 0 );
422  break;
423  // -------------------------------------------------
424 
425  case LogOp:
426  forward_log_op_dir(q, r, i_var, arg[0], J, taylor);
427  break;
428  // ---------------------------------------------------
429 
430 # if CPPAD_USE_CPLUSPLUS_2011
431  case Log1pOp:
432  forward_log1p_op_dir(q, r, i_var, arg[0], J, taylor);
433  break;
434 # endif
435  // ---------------------------------------------------
436 
437  case MulpvOp:
438  CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
439  forward_mulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
440  break;
441  // -------------------------------------------------
442 
443  case MulvvOp:
444  forward_mulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
445  break;
446  // -------------------------------------------------
447 
448  case ParOp:
449  k = i_var*(J-1)*r + i_var + (q-1)*r + 1;
450  for(ell = 0; ell < r; ell++)
451  taylor[k + ell] = Base(0.0);
452  break;
453  // -------------------------------------------------
454 
455  case PowpvOp:
456  CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
457  forward_powpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
458  break;
459  // -------------------------------------------------
460 
461  case PowvpOp:
462  CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
463  forward_powvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
464  break;
465  // -------------------------------------------------
466 
467  case PowvvOp:
468  forward_powvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
469  break;
470  // -------------------------------------------------
471 
472  case PriOp:
473  CPPAD_ASSERT_UNKNOWN(q > 0);
474  break;
475  // -------------------------------------------------
476 
477  case SignOp:
478  // sign(x)
479  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
480  forward_sign_op_dir(q, r, i_var, arg[0], J, taylor);
481  break;
482  // -------------------------------------------------
483 
484  case SinOp:
485  // cos(x), sin(x)
486  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
487  forward_sin_op_dir(q, r, i_var, arg[0], J, taylor);
488  break;
489  // -------------------------------------------------
490 
491  case SinhOp:
492  // cosh(x), sinh(x)
493  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
494  forward_sinh_op_dir(q, r, i_var, arg[0], J, taylor);
495  break;
496  // -------------------------------------------------
497 
498  case SqrtOp:
499  forward_sqrt_op_dir(q, r, i_var, arg[0], J, taylor);
500  break;
501  // -------------------------------------------------
502 
503  case StppOp:
504  case StpvOp:
505  case StvpOp:
506  case StvvOp:
507  CPPAD_ASSERT_UNKNOWN(q > 0 );
508  break;
509  // -------------------------------------------------
510 
511  case SubvvOp:
512  forward_subvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
513  break;
514  // -------------------------------------------------
515 
516  case SubpvOp:
517  CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
518  forward_subpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
519  break;
520  // -------------------------------------------------
521 
522  case SubvpOp:
523  CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
524  forward_subvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
525  break;
526  // -------------------------------------------------
527 
528  case TanOp:
529  // tan(x)^2, tan(x)
530  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
531  forward_tan_op_dir(q, r, i_var, arg[0], J, taylor);
532  break;
533  // -------------------------------------------------
534 
535  case TanhOp:
536  // tanh(x)^2, tanh(x)
537  CPPAD_ASSERT_UNKNOWN( i_var < numvar );
538  forward_tanh_op_dir(q, r, i_var, arg[0], J, taylor);
539  break;
540  // -------------------------------------------------
541 
542  case UserOp:
543  // start or end an atomic function call
544  flag = user_state == start_user;
545  user_atom = play->get_user_info(op, arg, user_old, user_m, user_n);
546  if( flag )
547  { user_state = arg_user;
548  user_i = 0;
549  user_j = 0;
550  //
551  user_tx_one.resize(user_n * user_q1);
552  user_tx_all.resize(user_n * (q * r + 1));
553  //
554  user_ty_one.resize(user_m * user_q1);
555  user_ty_all.resize(user_m * (q * r + 1));
556  //
557  user_iy.resize(user_m);
558  }
559  else
560  { user_state = start_user;
561  //
562  // call users function for this operation
563  user_atom->set_old(user_old);
564  for(ell = 0; ell < r; ell++)
565  { // set user_tx
566  for(j = 0; j < user_n; j++)
567  { size_t j_all = j * (q * r + 1);
568  size_t j_one = j * user_q1;
569  user_tx_one[j_one+0] = user_tx_all[j_all+0];
570  for(k = 1; k < user_q1; k++)
571  { size_t k_all = j_all + (k-1)*r+1+ell;
572  size_t k_one = j_one + k;
573  user_tx_one[k_one] = user_tx_all[k_all];
574  }
575  }
576  // set user_ty
577  for(i = 0; i < user_m; i++)
578  { size_t i_all = i * (q * r + 1);
579  size_t i_one = i * user_q1;
580  user_ty_one[i_one+0] = user_ty_all[i_all+0];
581  for(k = 1; k < q; k++)
582  { size_t k_all = i_all + (k-1)*r+1+ell;
583  size_t k_one = i_one + k;
584  user_ty_one[k_one] = user_ty_all[k_all];
585  }
586  }
587  CPPAD_ATOMIC_CALL(
588  q, q, user_vx, user_vy, user_tx_one, user_ty_one
589  );
590 # ifndef NDEBUG
591  if( ! user_ok )
592  { std::string msg =
593  user_atom->afun_name()
594  + ": atomic_base.forward: returned false";
595  CPPAD_ASSERT_KNOWN(false, msg.c_str() );
596  }
597 # endif
598  for(i = 0; i < user_m; i++)
599  { if( user_iy[i] > 0 )
600  { size_t i_taylor = user_iy[i]*((J-1)*r+1);
601  size_t q_taylor = i_taylor + (q-1)*r+1+ell;
602  size_t q_one = i * user_q1 + q;
603  taylor[q_taylor] = user_ty_one[q_one];
604  }
605  }
606  }
607 # if CPPAD_FORWARD2SWEEP_TRACE
608  user_trace = true;
609 # endif
610  }
611  break;
612 
613  case UsrapOp:
614  // parameter argument for a user atomic function
615  CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
616  CPPAD_ASSERT_UNKNOWN( user_state == arg_user );
617  CPPAD_ASSERT_UNKNOWN( user_i == 0 );
618  CPPAD_ASSERT_UNKNOWN( user_j < user_n );
619  CPPAD_ASSERT_UNKNOWN( size_t( arg[0] ) < num_par );
620  //
621  user_tx_all[user_j*(q*r+1) + 0] = parameter[ arg[0]];
622  for(ell = 0; ell < r; ell++)
623  for(k = 1; k < user_q1; k++)
624  user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] = Base(0.0);
625  //
626  ++user_j;
627  if( user_j == user_n )
628  user_state = ret_user;
629  break;
630 
631  case UsravOp:
632  // variable argument for a user atomic function
633  CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
634  CPPAD_ASSERT_UNKNOWN( user_state == arg_user );
635  CPPAD_ASSERT_UNKNOWN( user_i == 0 );
636  CPPAD_ASSERT_UNKNOWN( user_j < user_n );
637  //
638  user_tx_all[user_j*(q*r+1)+0] = taylor[arg[0]*((J-1)*r+1)+0];
639  for(ell = 0; ell < r; ell++)
640  { for(k = 1; k < user_q1; k++)
641  { user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] =
642  taylor[arg[0]*((J-1)*r+1) + (k-1)*r+1+ell];
643  }
644  }
645  //
646  ++user_j;
647  if( user_j == user_n )
648  user_state = ret_user;
649  break;
650 
651  case UsrrpOp:
652  // parameter result for a user atomic function
653  CPPAD_ASSERT_NARG_NRES(op, 1, 0);
654  CPPAD_ASSERT_UNKNOWN( user_state == ret_user );
655  CPPAD_ASSERT_UNKNOWN( user_i < user_m );
656  CPPAD_ASSERT_UNKNOWN( user_j == user_n );
657  //
658  user_iy[user_i] = 0;
659  user_ty_all[user_i*(q*r+1) + 0] = parameter[ arg[0]];
660  for(ell = 0; ell < r; ell++)
661  for(k = 1; k < user_q1; k++)
662  user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] = Base(0.0);
663  //
664  ++user_i;
665  if( user_i == user_m )
666  user_state = end_user;
667  break;
668 
669  case UsrrvOp:
670  // variable result for a user atomic function
671  CPPAD_ASSERT_NARG_NRES(op, 0, 1);
672  CPPAD_ASSERT_UNKNOWN( user_state == ret_user );
673  CPPAD_ASSERT_UNKNOWN( user_i < user_m );
674  CPPAD_ASSERT_UNKNOWN( user_j == user_n );
675  //
676  user_iy[user_i] = i_var;
677  user_ty_all[user_i*(q*r+1)+0] = taylor[i_var*((J-1)*r+1)+0];
678  for(ell = 0; ell < r; ell++)
679  { for(k = 1; k < user_q1; k++)
680  { user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] =
681  taylor[i_var*((J-1)*r+1) + (k-1)*r+1+ell];
682  }
683  }
684  ++user_i;
685  if( user_i == user_m )
686  user_state = end_user;
687  break;
688  // -------------------------------------------------
689 
690  case ZmulpvOp:
691  CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
692  forward_zmulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
693  break;
694  // -------------------------------------------------
695 
696  case ZmulvpOp:
697  CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
698  forward_zmulvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
699  break;
700  // -------------------------------------------------
701 
702  case ZmulvvOp:
703  forward_zmulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
704  break;
705  // -------------------------------------------------
706 
707  default:
708  CPPAD_ASSERT_UNKNOWN(0);
709  }
710 # if CPPAD_FORWARD2SWEEP_TRACE
711  if( user_trace )
712  { user_trace = false;
713  CPPAD_ASSERT_UNKNOWN( op == UserOp );
714  CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
715  for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
716  { size_t i_tmp = (i_op + i) - user_m;
717  printOp(
718  std::cout,
719  play,
720  i_tmp,
721  user_iy[i],
722  UsrrvOp,
723  CPPAD_NULL
724  );
725  Base* Z_tmp = taylor + user_iy[i]*((J-1) * r + 1);
726  { Z_vec[0] = Z_tmp[0];
727  for(ell = 0; ell < r; ell++)
728  { std::cout << std::endl << " ";
729  for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
730  Z_vec[p_tmp] = Z_tmp[(p_tmp-1)*r+ell+1];
731  printOpResult(
732  std::cout,
733  q + 1,
734  Z_vec.data(),
735  0,
736  (Base *) CPPAD_NULL
737  );
738  }
739  }
740  std::cout << std::endl;
741  }
742  }
743  if( op != UsrrvOp )
744  { printOp(
745  std::cout,
746  play,
747  i_op,
748  i_var,
749  op,
750  arg
751  );
752  Base* Z_tmp = CPPAD_NULL;
753  if( op == UsravOp )
754  Z_tmp = taylor + arg[0]*((J-1) * r + 1);
755  else if( NumRes(op) > 0 )
756  Z_tmp = taylor + i_var*((J-1)*r + 1);
757  if( Z_tmp != CPPAD_NULL )
758  { Z_vec[0] = Z_tmp[0];
759  for(ell = 0; ell < r; ell++)
760  { std::cout << std::endl << " ";
761  for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
762  Z_vec[p_tmp] = Z_tmp[ (p_tmp-1)*r + ell + 1];
763  printOpResult(
764  std::cout,
765  q + 1,
766  Z_vec.data(),
767  0,
768  (Base *) CPPAD_NULL
769  );
770  }
771  }
772  std::cout << std::endl;
773  }
774  }
775  std::cout << std::endl;
776 # else
777  }
778 # endif
779  CPPAD_ASSERT_UNKNOWN( user_state == start_user );
780 
781  return;
782 }
783 
784 // preprocessor symbols that are local to this file
785 # undef CPPAD_FORWARD2SWEEP_TRACE
786 # undef CPPAD_ATOMIC_CALL
787 
788 } } // END_CPPAD_LOCAL_NAMESPACE
789 # endif
CppAD::local::forward_acos_op_dir
void forward_acos_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = AcosOp.
Definition: acos_op.hpp:104
CPPAD_ASSERT_KNOWN
#define CPPAD_ASSERT_KNOWN(exp, msg)
Check that exp is true, if not print msg and terminate execution.
Definition: cppad_assert.hpp:113
CppAD::local::forward_expm1_op_dir
void forward_expm1_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficient for op = Expm1Op.
Definition: expm1_op.hpp:80
CppAD::local::forward_sin_op_dir
void forward_sin_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Compute forward mode Taylor coefficient for result of op = SinOp.
Definition: sin_op.hpp:97
CppAD::local::player::num_par_rec
size_t num_par_rec(void) const
Fetch number of parameters in the recording.
Definition: player.hpp:638
CppAD::local::printOpResult
void printOpResult(std::ostream &os, size_t nfz, const Value *fz, size_t nrz, const Value *rz)
Prints the result values correspnding to an operator.
Definition: op_code.hpp:852
CppAD::local::forward_powvp_op_dir
void forward_powvp_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = PowvpOp.
Definition: pow_op.hpp:525
CppAD::local::forward_acosh_op_dir
void forward_acosh_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = AcoshOp.
Definition: acosh_op.hpp:105
CppAD::local::forward_atan_op_dir
void forward_atan_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction Taylor coefficient for op = AtanOp.
Definition: atan_op.hpp:96
CppAD::addr_t
CPPAD_TAPE_ADDR_TYPE addr_t
Definition: declare_ad.hpp:44
CppAD::local::pod_vector< addr_t >
CppAD::local::ret_user
next UsrrpOp (UsrrvOp) is a parameter (variable) result
Definition: user_state.hpp:25
CppAD::local::forward_subpv_op_dir
void forward_subpv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = SubpvOp.
Definition: sub_op.hpp:238
CppAD::local::forward_sign_op_dir
void forward_sign_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficient for op = SignOp.
Definition: sign_op.hpp:70
CppAD::local::NumArg
size_t NumArg(OpCode op)
Number of arguments for a specified operator.
Definition: op_code.hpp:175
CppAD::local::player
Class used to store and play back an operation sequence recording.
Definition: declare_ad.hpp:27
CppAD::vector::data
Type * data(void)
raw pointer to the data
Definition: vector.hpp:391
CppAD::local::forward_divvp_op_dir
void forward_divvp_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficients for op = DivvvOp.
Definition: div_op.hpp:458
CppAD::local::forward_subvv_op_dir
void forward_subvv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = SubvvOp.
Definition: sub_op.hpp:76
CppAD::local::forward_addpv_op_dir
void forward_addpv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = AddpvOp.
Definition: add_op.hpp:236
CppAD::local::forward_zmulvv_op_dir
void forward_zmulvv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = ZmulvvOp.
Definition: zmul_op.hpp:79
CPPAD_ATOMIC_CALL
#define CPPAD_ATOMIC_CALL
Definition: forward2sweep.hpp:38
CppAD::vector::resize
void resize(size_t n)
change the number of elements in this vector.
Definition: vector.hpp:399
CppAD::local::NumRes
size_t NumRes(OpCode op)
Number of variables resulting from the specified operation.
Definition: op_code.hpp:281
CppAD::local::forward_zmulpv_op_dir
void forward_zmulpv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = ZmulpvOp.
Definition: zmul_op.hpp:249
CppAD::local::forward_erf_op_dir
void forward_erf_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Forward mode Taylor coefficient for result of op = ErfOp.
Definition: erf_op.hpp:332
CppAD::local::forward_log1p_op_dir
void forward_log1p_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Muiltiple directions Taylor coefficient for op = Log1pOp.
Definition: log1p_op.hpp:85
CppAD::local::end_user
next UserOp marks end of a user atomic call
Definition: user_state.hpp:28
CppAD::local::forward_divpv_op_dir
void forward_divpv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = DivpvOp.
Definition: div_op.hpp:277
CppAD::local::player::get_user_info
atomic_base< Base > * get_user_info(const OpCode op, const addr_t *op_arg, size_t &user_old, size_t &user_m, size_t &user_n) const
unpack extra information corresponding to a UserOp
Definition: player.hpp:517
CppAD::local::forward_powvv_op_dir
void forward_powvv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = PowvvOp.
Definition: pow_op.hpp:89
CppAD::local::forward_load_op
void forward_load_op(const local::player< Base > *play, OpCode op, size_t p, size_t q, size_t r, size_t cap_order, size_t i_z, const addr_t *arg, const addr_t *var_by_load_op, Base *taylor)
Forward mode, except for zero order, for op = LdpOp or op = LdvOp.
Definition: load_op.hpp:414
CppAD::local::forward_abs_op_dir
void forward_abs_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = AbsOp.
Definition: abs_op.hpp:66
CppAD::atomic_base::set_old
virtual void set_old(size_t id)
Set value of id (used by deprecated old_atomic class)
Definition: atomic_base.hpp:2418
CppAD::local::forward_exp_op_dir
void forward_exp_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficient for op = ExpOp.
Definition: exp_op.hpp:78
CppAD::local::OpCode
OpCode
Type used to distinguish different AD&lt; Base &gt; atomic operations.
Definition: op_code.hpp:49
CppAD::local::forward_asinh_op_dir
void forward_asinh_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = AsinhOp.
Definition: asinh_op.hpp:105
CppAD::local::forward_csum_op_dir
void forward_csum_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficients for op = CsumOp.
Definition: csum_op.hpp:211
CppAD::local::start_user
next UserOp marks beginning of a user atomic call
Definition: user_state.hpp:19
CppAD::local::player::get_op_info
void get_op_info(size_t op_index, OpCode &op, const addr_t *&op_arg, size_t &var_index) const
fetch the information corresponding to an operator
Definition: player.hpp:485
CppAD::local::forward_tanh_op_dir
void forward_tanh_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = TanOp.
Definition: tanh_op.hpp:95
CppAD::local::forward_mulvv_op_dir
void forward_mulvv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = MulvvOp.
Definition: mul_op.hpp:79
CppAD::local::pod_vector::data
Type * data(void)
current data pointer is no longer valid after any of the following: extend, erase, operator=, and ~pod_vector. Take extreem care when using this function.
Definition: pod_vector.hpp:89
CppAD::local::arg_user
next UsrapOp (UsravOp) is a parameter (variable) argument
Definition: user_state.hpp:22
CppAD::local::forward_dis_op
void forward_dis_op(size_t p, size_t q, size_t r, size_t i_z, const addr_t *arg, size_t cap_order, Base *taylor)
forward mode Taylor coefficient for result of op = DisOp.
Definition: discrete_op.hpp:90
CPPAD_ASSERT_UNKNOWN
#define CPPAD_ASSERT_UNKNOWN(exp)
Check that exp is true, if not terminate execution.
Definition: cppad_assert.hpp:139
CppAD::local::forward_cosh_op_dir
void forward_cosh_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Compute forward mode Taylor coefficient for result of op = CoshOp.
Definition: cosh_op.hpp:97
CppAD::local::forward_zmulvp_op_dir
void forward_zmulvp_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = ZmulvpOp.
Definition: zmul_op.hpp:409
CppAD::local::forward_subvp_op_dir
void forward_subvp_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = SubvvOp.
Definition: sub_op.hpp:397
CppAD::local::forward_log_op_dir
void forward_log_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Muiltiple directions Taylor coefficient for op = LogOp.
Definition: log_op.hpp:84
CppAD::local::forward_mulpv_op_dir
void forward_mulpv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = MulpvOp.
Definition: mul_op.hpp:250
CppAD::atomic_base
Definition: atomic_base.hpp:28
CppAD::local::forward_asin_op_dir
void forward_asin_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = AsinOp.
Definition: asin_op.hpp:104
CppAD::local::printOp
void printOp(std::ostream &os, const local::player< Base > *play, size_t i_op, size_t i_var, OpCode op, const addr_t *ind)
Prints a single operator and its operands.
Definition: op_code.hpp:547
CppAD::local::forward_cond_op_dir
void forward_cond_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, size_t num_par, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = CExpOp.
Definition: cond_op.hpp:482
CPPAD_ASSERT_NARG_NRES
#define CPPAD_ASSERT_NARG_NRES(op, n_arg, n_res)
Check that operator op has the specified number of of arguments and results.
Definition: cppad_assert.hpp:158
CppAD::local::forward_sinh_op_dir
void forward_sinh_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Compute forward mode Taylor coefficient for result of op = SinhOp.
Definition: sinh_op.hpp:98
CppAD::local::forward_powpv_op_dir
void forward_powpv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = PowpvOp.
Definition: pow_op.hpp:303
CppAD::local::forward_cos_op_dir
void forward_cos_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Compute forward mode Taylor coefficient for result of op = CosOp.
Definition: cos_op.hpp:97
CppAD::atomic_base::afun_name
const std::string & afun_name(void) const
Name corresponding to a base_atomic object.
Definition: atomic_base.hpp:104
CppAD::local::forward_atanh_op_dir
void forward_atanh_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction Taylor coefficient for op = AtanhOp.
Definition: atanh_op.hpp:97
CppAD::local::forward_divvv_op_dir
void forward_divvv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = DivvvOp.
Definition: div_op.hpp:83
CppAD::local::forward_tan_op_dir
void forward_tan_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficient for op = TanOp.
Definition: tan_op.hpp:95
CppAD::local::player::GetPar
Base GetPar(size_t i) const
Fetch a parameter from the recording.
Definition: player.hpp:584
CppAD::local::forward_addvv_op_dir
void forward_addvv_op_dir(size_t q, size_t r, size_t i_z, const addr_t *arg, const Base *parameter, size_t cap_order, Base *taylor)
Multiple directions forward mode Taylor coefficients for op = AddvvOp.
Definition: add_op.hpp:76
CppAD::local::forward2sweep
void forward2sweep(const local::player< Base > *play, const size_t q, const size_t r, const size_t n, const size_t numvar, const size_t J, Base *taylor, const bool *cskip_op, const pod_vector< addr_t > &var_by_load_op)
Compute multiple directions forward mode Taylor coefficients.
Definition: forward2sweep.hpp:133
CppAD::local::player::num_var_rec
size_t num_var_rec(void) const
Fetch number of variables in the recording.
Definition: player.hpp:614
CppAD::local::forward_sqrt_op_dir
void forward_sqrt_op_dir(size_t q, size_t r, size_t i_z, size_t i_x, size_t cap_order, Base *taylor)
Multiple direction forward mode Taylor coefficient for op = SqrtOp.
Definition: sqrt_op.hpp:79