source: branches/cache/cppad/local/forward2sweep.hpp @ 3341

Last change on this file since 3341 was 3341, checked in by bradbell, 6 years ago
  1. Add num_var and cache2var to cppad_assert_arg_before_result.
  2. In sweeps, change numvar to num_var.

forward2sweep.hpp: remove extra asserts (arg_before_result cases).

  • Property svn:keywords set to Id
File size: 20.7 KB
Line 
1/* $Id: forward2sweep.hpp 3341 2014-09-19 11:47:30Z bradbell $ */
2# ifndef CPPAD_FORWARD2SWEEP_INCLUDED
3# define CPPAD_FORWARD2SWEEP_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 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 num_var
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 , ... , num_var-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 , ... , num_var-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 , ... , num_var-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\return
138The return value is zero.
139*/
140
141template <class Base>
142size_t forward2sweep(
143        const size_t                q,
144        const size_t                r,
145        const size_t                n,
146        const size_t                num_var,
147              player<Base>*         play,
148        const size_t                J,
149              Base*                 taylor,
150        const bool*                 cskip_op,
151        const pod_vector<addr_t>&   var_by_load_op
152)
153{
154        CPPAD_ASSERT_UNKNOWN( q > 0 );
155        CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
156        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
157
158        // used to avoid compiler errors until all operators are implemented
159        size_t p = q;
160
161        // op code for current instruction
162        OpCode op;
163
164        // index for current instruction
165        size_t i_op;
166
167        // next variables
168        size_t i_var;
169
170        // operation argument indices
171        const addr_t*   arg = CPPAD_NULL;
172
173        // initialize the comparision operator (ComOp) counter
174        const size_t compareCount = 0;
175
176        // work space used by UserOp.
177        vector<bool> user_vx;        // empty vecotor
178        vector<bool> user_vy;        // empty vecotor
179        vector<Base> user_tx_one;    // argument vector Taylor coefficients
180        vector<Base> user_tx_all;
181        vector<Base> user_ty_one;    // result vector Taylor coefficients
182        vector<Base> user_ty_all;
183        size_t user_index = 0;       // indentifier for this atomic operation
184        size_t user_id    = 0;       // user identifier for this call to operator
185        size_t user_i     = 0;       // index in result vector
186        size_t user_j     = 0;       // index in argument vector
187        size_t user_m     = 0;       // size of result vector
188        size_t user_n     = 0;       // size of arugment vector
189        //
190        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
191# ifndef NDEBUG
192        bool               user_ok   = false;      // atomic op return value
193# endif
194        //
195        // next expected operator in a UserOp sequence
196        enum { user_start, user_arg, user_ret, user_end, user_trace }
197        user_state = user_start;
198
199        // length of the parameter vector (used by CppAD assert macros)
200        const size_t num_par = play->num_par_rec();
201
202        // pointer to the beginning of the parameter vector
203        const Base* parameter = CPPAD_NULL;
204        if( num_par > 0 )
205                parameter = play->GetPar();
206
207        // temporary indices
208        size_t i, j, k, ell;
209
210        // number of orders for this user calculation
211        // (not needed for order zero)
212        const size_t user_q1 = q+1;
213
214        // variable indices for results vector
215        // (done differently for order zero).
216        vector<size_t> user_iy;     
217
218        // skip the BeginOp at the beginning of the recording
219        play->forward_start(op, arg, i_op, i_var);
220        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
221# if CPPAD_FORWARD2SWEEP_TRACE
222        std::cout << std::endl;
223        CppAD::vector<Base> Z_vec(q+1);
224# endif
225# ifndef NDEBUG
226        // 2DO: implement tracing cache
227        CppAD::vector<addr_t> cache2var;
228# endif
229        bool more_operators = true;
230        while(more_operators)
231        {
232                // this op
233                play->forward_next(op, arg, i_op, i_var);
234                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
235                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
236                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
237                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
238
239                // check if we are skipping this operation
240                while( cskip_op[i_op] )
241                {       if( op == CSumOp )
242                        {       // CSumOp has a variable number of arguments
243                                play->forward_csum(op, arg, i_op, i_var);
244                        }
245                        play->forward_next(op, arg, i_op, i_var);
246                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
247                }
248
249                // action depends on the operator
250                switch( op )
251                {
252                        case AbsOp:
253                        forward_abs_op_dir(q, r, i_var, arg[0], J, taylor);
254                        break;
255                        // -------------------------------------------------
256
257                        case AddvvOp:
258                        forward_addvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
259                        break;
260                        // -------------------------------------------------
261
262                        case AddpvOp:
263                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
264                        forward_addpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
265                        break;
266                        // -------------------------------------------------
267
268                        case AcosOp:
269                        // sqrt(1 - x * x), acos(x)
270                        forward_acos_op_dir(q, r, i_var, arg[0], J, taylor);
271                        break;
272                        // -------------------------------------------------
273
274                        case AsinOp:
275                        // sqrt(1 - x * x), asin(x)
276                        forward_asin_op_dir(q, r, i_var, arg[0], J, taylor);
277                        break;
278                        // -------------------------------------------------
279
280                        case AtanOp:
281                        // 1 + x * x, atan(x)
282                        forward_atan_op_dir(q, r, i_var, arg[0], J, taylor);
283                        break;
284                        // -------------------------------------------------
285
286                        case CExpOp:
287                        forward_cond_op_dir(
288                                q, r, i_var, arg, num_par, parameter, J, taylor
289                        );
290                        break;
291                        // ---------------------------------------------------
292
293                        case ComOp:
294                        CPPAD_ASSERT_UNKNOWN(q > 0 );
295                        break;
296                        // ---------------------------------------------------
297
298                        case CosOp:
299                        // sin(x), cos(x)
300                        forward_cos_op_dir(q, r, i_var, arg[0], J, taylor);
301                        break;
302                        // ---------------------------------------------------
303
304                        case CoshOp:
305                        // sinh(x), cosh(x)
306                        forward_cosh_op_dir(q, r, i_var, arg[0], J, taylor);
307                        break;
308                        // -------------------------------------------------
309
310                        case CSkipOp:
311                        // CSkipOp has a variable number of arguments and
312                        // forward_next thinks it has no arguments.
313                        // we must inform forward_next of this special case.
314                        play->forward_cskip(op, arg, i_op, i_var);
315                        break;
316                        // -------------------------------------------------
317
318                        case CSumOp:
319                        // CSumOp has a variable number of arguments and
320                        // forward_next thinks it has no arguments.
321                        // we must inform forward_next of this special case.
322                        forward_csum_op_dir(
323                                q, r, i_var, arg, num_par, parameter, J, taylor
324                        );
325                        play->forward_csum(op, arg, i_op, i_var);
326                        break;
327                        // -------------------------------------------------
328
329                        case DisOp:
330                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
331                        break;
332                        // -------------------------------------------------
333
334                        case DivvvOp:
335                        forward_divvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
336                        break;
337                        // -------------------------------------------------
338
339                        case DivpvOp:
340                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
341                        forward_divpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
342                        break;
343                        // -------------------------------------------------
344
345                        case DivvpOp:
346                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
347                        forward_divvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
348                        break;
349                        // -------------------------------------------------
350
351                        case EndOp:
352                        // needed for sparse_jacobian test
353                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
354                        more_operators = false;
355                        break;
356                        // -------------------------------------------------
357
358                        case ExpOp:
359                        forward_exp_op_dir(q, r, i_var, arg[0], J, taylor);
360                        break;
361                        // -------------------------------------------------
362
363                        case InvOp:
364                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
365                        break;
366                        // -------------------------------------------------
367
368                        case LdpOp:
369                        case LdvOp:
370                        forward_load_op(
371                                play,
372                                op,
373                                p,
374                                q,
375                                r,
376                                J,
377                                i_var,
378                                arg,
379                                var_by_load_op.data(),
380                                taylor
381                        );
382                        break;
383                        // -------------------------------------------------
384
385                        case LogOp:
386                        forward_log_op_dir(q, r, i_var, arg[0], J, taylor);
387                        break;
388                        // -------------------------------------------------
389
390                        case MulvvOp:
391                        forward_mulvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
392                        break;
393                        // -------------------------------------------------
394
395                        case MulpvOp:
396                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
397                        forward_mulpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
398                        break;
399                        // -------------------------------------------------
400
401                        case ParOp:
402                        k = i_var*(J-1)*r + i_var + (q-1)*r;
403                        for(ell = 0; ell < r; ell++)
404                                taylor[k + ell] = Base(0); 
405                        break;
406                        // -------------------------------------------------
407
408                        case PowpvOp:
409                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
410                        forward_powpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
411                        break;
412                        // -------------------------------------------------
413
414                        case PowvpOp:
415                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
416                        forward_powvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
417                        break;
418                        // -------------------------------------------------
419
420                        case PowvvOp:
421                        forward_powvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
422                        break;
423                        // -------------------------------------------------
424
425                        case PriOp:
426                        CPPAD_ASSERT_UNKNOWN(q > 0);
427                        break;
428                        // -------------------------------------------------
429
430                        case SignOp:
431                        // sign(x)
432                        forward_sign_op_dir(q, r, i_var, arg[0], J, taylor);
433                        break;
434                        // -------------------------------------------------
435
436                        case SinOp:
437                        // cos(x), sin(x)
438                        forward_sin_op_dir(q, r, i_var, arg[0], J, taylor);
439                        break;
440                        // -------------------------------------------------
441
442                        case SinhOp:
443                        // cosh(x), sinh(x)
444                        forward_sinh_op_dir(q, r, i_var, arg[0], J, taylor);
445                        break;
446                        // -------------------------------------------------
447
448                        case SqrtOp:
449                        forward_sqrt_op_dir(q, r, i_var, arg[0], J, taylor);
450                        break;
451                        // -------------------------------------------------
452
453                        case StppOp:
454                        case StpvOp:
455                        case StvpOp:
456                        case StvvOp:
457                        CPPAD_ASSERT_UNKNOWN(q > 0 );
458                        break;
459                        // -------------------------------------------------
460
461                        case SubvvOp:
462                        forward_subvv_op_dir(q, r, i_var, arg, parameter, J, taylor);
463                        break;
464                        // -------------------------------------------------
465
466                        case SubpvOp:
467                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
468                        forward_subpv_op_dir(q, r, i_var, arg, parameter, J, taylor);
469                        break;
470                        // -------------------------------------------------
471
472                        case SubvpOp:
473                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
474                        forward_subvp_op_dir(q, r, i_var, arg, parameter, J, taylor);
475                        break;
476                        // -------------------------------------------------
477
478                        case TanOp:
479                        // tan(x)^2, tan(x)
480                        forward_tan_op_dir(q, r, i_var, arg[0], J, taylor);
481                        break;
482                        // -------------------------------------------------
483
484                        case TanhOp:
485                        // tanh(x)^2, tanh(x)
486                        forward_tanh_op_dir(q, r, i_var, arg[0], J, taylor);
487                        break;
488                        // -------------------------------------------------
489
490                        case UserOp:
491                        // start or end an atomic operation sequence
492                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
493                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
494                        if( user_state == user_start )
495                        {       user_index = arg[0];
496                                user_id    = arg[1];
497                                user_n     = arg[2];
498                                user_m     = arg[3];
499                                user_atom  = atomic_base<Base>::class_object(user_index);
500# ifndef NDEBUG
501                                if( user_atom == CPPAD_NULL )
502                                {       std::string msg = 
503                                                atomic_base<Base>::class_name(user_index)
504                                                + ": atomic_base function has been deleted";
505                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
506                                }
507# endif
508                                if(user_tx_one.size() != user_n * user_q1)
509                                        user_tx_one.resize(user_n * user_q1);
510                                if( user_tx_all.size() != user_n * (q * r + 1) )
511                                        user_tx_all.resize(user_n * (q * r + 1));
512                                //
513                                if(user_ty_one.size() != user_m * user_q1)
514                                        user_ty_one.resize(user_m * user_q1);
515                                if( user_ty_all.size() != user_m * (q * r + 1) )
516                                        user_ty_all.resize(user_m * (q * r + 1));
517                                //
518                                if(user_iy.size() != user_m)
519                                        user_iy.resize(user_m);
520                                user_j     = 0;
521                                user_i     = 0;
522                                user_state = user_arg;
523                        }
524                        else
525                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
526                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
527                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
528                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
529                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
530
531                                // call users function for this operation
532                                user_atom->set_id(user_id);
533                                for(ell = 0; ell < r; ell++)
534                                {       // set user_tx
535                                        for(j = 0; j < user_n; j++)
536                                        {       size_t j_all     = j * (q * r + 1);
537                                                size_t j_one     = j * user_q1;
538                                                user_tx_one[j_one+0] = user_tx_all[j_all+0];
539                                                for(k = 1; k < user_q1; k++)
540                                                {       size_t k_all       = j_all + (k-1)*r+1+ell;
541                                                        size_t k_one       = j_one + k;
542                                                        user_tx_one[k_one] = user_tx_all[k_all];
543                                                }
544                                        }
545                                        // set user_ty
546                                        for(i = 0; i < user_m; i++)
547                                        {       size_t i_all     = i * (q * r + 1);
548                                                size_t i_one     = i * user_q1;
549                                                user_ty_one[i_one+0] = user_ty_all[i_all+0];
550                                                for(k = 1; k < q; k++)
551                                                {       size_t k_all       = i_all + (k-1)*r+1+ell;
552                                                        size_t k_one       = i_one + k;
553                                                        user_ty_one[k_one] = user_ty_all[k_all];
554                                                }
555                                        }
556                                        CPPAD_ATOMIC_CALL(
557                                        q, q, user_vx, user_vy, user_tx_one, user_ty_one
558                                        );
559# ifndef NDEBUG
560                                        if( ! user_ok )
561                                        {       std::string msg = 
562                                                        atomic_base<Base>::class_name(user_index)
563                                                        + ": atomic_base.forward: returned false";
564                                                CPPAD_ASSERT_KNOWN(false, msg.c_str() );
565                                        }
566# endif
567                                        for(i = 0; i < user_m; i++) 
568                                        {       if( user_iy[i] > 0 )
569                                                {       size_t i_taylor = user_iy[i]*((J-1)*r+1); 
570                                                        size_t q_taylor = i_taylor + (q-1)*r+1+ell;
571                                                        size_t q_one    = i * user_q1 + q;
572                                                        taylor[q_taylor] = user_ty_one[q_one];
573                                                }
574                                        }
575                                }
576# if CPPAD_FORWARD2SWEEP_TRACE
577                                user_state = user_trace;
578# else
579                                user_state = user_start;
580# endif
581                        }
582                        break;
583
584                        case UsrapOp:
585                        // parameter argument in an atomic operation sequence
586                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
587                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
588                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
589                        user_tx_all[user_j*(q*r+1) + 0] = parameter[ arg[0]];
590                        for(ell = 0; ell < r; ell++)
591                                for(k = 1; k < user_q1; k++)
592                                        user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] = Base(0);
593                        ++user_j;
594                        if( user_j == user_n )
595                                user_state = user_ret;
596                        break;
597
598                        case UsravOp:
599                        // variable argument in an atomic operation sequence
600                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
601                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
602                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
603                        user_tx_all[user_j*(q*r+1)+0] = taylor[arg[0]*((J-1)*r+1)+0];
604                        for(ell = 0; ell < r; ell++)
605                        {       for(k = 1; k < user_q1; k++)
606                                {       user_tx_all[user_j*(q*r+1) + (k-1)*r+1+ell] = 
607                                                taylor[arg[0]*((J-1)*r+1) + (k-1)*r+1+ell];
608                                }
609                        }
610                        ++user_j;
611                        if( user_j == user_n )
612                                user_state = user_ret;
613                        break;
614
615                        case UsrrpOp:
616                        // parameter result in an atomic operation sequence
617                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
618                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
619                        user_iy[user_i] = 0;
620                        user_ty_all[user_i*(q*r+1) + 0] = parameter[ arg[0]];
621                        for(ell = 0; ell < r; ell++)
622                                for(k = 1; k < user_q1; k++)
623                                        user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] = Base(0);
624                        user_i++;
625                        if( user_i == user_m )
626                                user_state = user_end;
627                        break;
628
629                        case UsrrvOp:
630                        // variable result in an atomic operation sequence
631                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
632                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
633                        user_iy[user_i] = i_var;
634                        user_ty_all[user_i*(q*r+1)+0] = taylor[i_var*((J-1)*r+1)+0];
635                        for(ell = 0; ell < r; ell++)
636                        {       for(k = 1; k < user_q1; k++)
637                                {       user_ty_all[user_i*(q*r+1) + (k-1)*r+1+ell] = 
638                                                taylor[i_var*((J-1)*r+1) + (k-1)*r+1+ell];
639                                }
640                        }
641                        user_i++;
642                        if( user_i == user_m )
643                                user_state = user_end;
644                        break;
645                        // -------------------------------------------------
646
647                        default:
648                        CPPAD_ASSERT_UNKNOWN(0);
649                }
650# if CPPAD_FORWARD2SWEEP_TRACE
651                if( user_state == user_trace )
652                {       user_state = user_start;
653                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
654                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
655                        for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
656                        {       size_t i_tmp   = (i_op + i) - user_m;
657                                printOp(
658                                        std::cout, 
659                                        play,
660                                        i_tmp,
661                                        user_iy[i],
662                                        UsrrvOp, 
663                                        CPPAD_NULL,
664                                        cache2var
665                                );
666                                Base* Z_tmp = taylor + user_iy[i]*((J-1) * r + 1);
667                                {       Z_vec[0]    = Z_tmp[0];
668                                        for(ell = 0; ell < r; ell++)
669                                        {       std::cout << std::endl << "     ";
670                                                for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
671                                                        Z_vec[p_tmp] = Z_tmp[(p_tmp-1)*r+ell+1];
672                                                printOpResult(
673                                                        std::cout, 
674                                                        q + 1, 
675                                                        Z_vec.data(),
676                                                        0, 
677                                                        (Base *) CPPAD_NULL
678                                                );
679                                        }
680                                }
681                                std::cout << std::endl;
682                        }
683                }
684                const addr_t*   arg_tmp = arg;
685                if( op == CSumOp )
686                        arg_tmp = arg - arg[-1] - 4;
687                if( op == CSkipOp )
688                        arg_tmp = arg - arg[-1] - 7;
689                if( op != UsrrvOp )
690                {       printOp(
691                                std::cout, 
692                                play,
693                                i_op,
694                                i_var,
695                                op, 
696                                arg_tmp,
697                                cache2var
698                        );
699                        Base* Z_tmp = CPPAD_NULL;
700                        if( op == UsravOp )
701                                Z_tmp = taylor + arg[0]*((J-1) * r + 1);
702                        else if( NumRes(op) > 0 )
703                                Z_tmp = taylor + i_var*((J-1)*r + 1);
704                        if( Z_tmp != CPPAD_NULL )
705                        {       Z_vec[0]    = Z_tmp[0];
706                                for(ell = 0; ell < r; ell++)
707                                {       std::cout << std::endl << "     ";
708                                        for(size_t p_tmp = 1; p_tmp <= q; p_tmp++)
709                                                Z_vec[p_tmp] = Z_tmp[ (p_tmp-1)*r + ell + 1];
710                                        printOpResult(
711                                                std::cout, 
712                                                q + 1, 
713                                                Z_vec.data(),
714                                                0, 
715                                                (Base *) CPPAD_NULL
716                                        );
717                                }
718                        }
719                        std::cout << std::endl;
720                }
721        }
722        std::cout << std::endl;
723# else
724        }
725# endif
726        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
727        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
728
729        return compareCount;
730}
731
732// preprocessor symbols that are local to this file
733# undef CPPAD_FORWARD2SWEEP_TRACE
734# undef CPPAD_ATOMIC_CALL
735
736} // END_CPPAD_NAMESPACE
737# endif
Note: See TracBrowser for help on using the repository browser.