source: trunk/cppad/local/forward2sweep.hpp @ 3678

Last change on this file since 3678 was 3678, checked in by bradbell, 5 years ago

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: c97a2e7145825a124c12ec7588a9c80b3a5b4c61
end hash code: 5e2f77aac80262cd007effafcc48ecf2d313e467

commit 5e2f77aac80262cd007effafcc48ecf2d313e467
Author: Brad Bell <bradbell@…>
Date: Tue May 5 09:43:28 2015 -0700

Properly handel case where compiler does not have asinh function.

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