source: branches/cache/cppad/local/forward0sweep.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: 19.9 KB
Line 
1/* $Id: forward0sweep.hpp 3341 2014-09-19 11:47:30Z bradbell $ */
2# ifndef CPPAD_FORWARD0SWEEP_INCLUDED
3# define CPPAD_FORWARD0SWEEP_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 forward0sweep.hpp
19Compute zero order forward mode Taylor coefficients.
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 maco is undefined at the end of this file to facillitate is
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_FORWARD0SWEEP_TRACE
44This value is either zero or one.
45Zero is the normal operational value.
46If it is one, a trace of every forward0sweep computation is printed.
47(Note that forward0sweep is not used if CPPAD_USE_FORWARD0SWEEP is zero).
48*/
49# define CPPAD_FORWARD0SWEEP_TRACE 0
50
51/*!
52Compute zero order forward mode Taylor coefficients.
53
54<!-- define forward0sweep_doc_define -->
55\tparam Base
56The type used during the forward mode computations; i.e., the corresponding
57recording of operations used the type AD<Base>.
58
59\param s_out
60Is the stream where output corresponding to PriOp operations will
61be written.
62
63\param print
64If print is false,
65suppress the output that is otherwise generated by the c PriOp instructions.
66
67\param n
68is the number of independent variables on the tape.
69
70\param num_var
71is the total number of variables on the tape.
72This is also equal to the number of rows in the matrix taylor; i.e.,
73play->num_var_rec().
74
75\param play
76The information stored in play
77is a recording of the operations corresponding to the function
78\f[
79        F : {\bf R}^n \rightarrow {\bf R}^m
80\f]
81where \f$ n \f$ is the number of independent variables and
82\f$ m \f$ is the number of dependent variables.
83\n
84\n
85The object play is effectly constant.
86The exception to this is that while palying back the tape
87the object play holds information about the current location
88with in the tape and this changes during palyback.
89
90\param J
91Is the number of columns in the coefficient matrix taylor.
92This must be greater than or equal one.
93
94<!-- end forward0sweep_doc_define -->
95
96\param taylor
97\n
98\b Input:
99For i = 1 , ... , n,
100<code>taylor [i * J + 0]</code>
101variable with index j on the tape
102(these are the independent variables).
103\n
104\n
105\b Output:
106For i = n + 1, ... , num_var - 1,
107<code>taylor [i * J + 0]</code>
108is the zero order Taylor coefficient for the variable with
109index i on the tape.
110
111\param cskip_op
112Is a vector with size play->num_op_rec().
113The input value of the elements does not matter.
114Upon return, if cskip_op[i] is true, the operator index i
115does not affect any of the dependent variable
116(given the value of the independent variables).
117
118\param var_by_load_op
119Is a vector with size play->num_load_op_rec().
120The input value of the elements does not matter.
121Upon return,
122it is the variable index corresponding the result for each load operator.
123In the case where the index is zero,
124the load operator results in a parameter (not a variable).
125Note that the is no variable with index zero on the tape.
126
127\return
128The return value is equal to the number of ComOp operations
129that have a different result from when the information in
130play was recorded.
131(Note that if NDEBUG is true, there are no ComOp operations
132in play and hence this return value is always zero.)
133*/
134
135template <class Base>
136size_t forward0sweep(
137        std::ostream&         s_out,
138        bool                  print,
139        size_t                n,
140        size_t                num_var,
141        player<Base>*         play,
142        size_t                J,
143        Base*                 taylor,
144        bool*                 cskip_op,
145        pod_vector<addr_t>&   var_by_load_op
146)
147{       CPPAD_ASSERT_UNKNOWN( J >= 1 );
148        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
149
150        // use p, q, r so other forward sweeps can use code defined here
151        size_t p = 0;
152        size_t q = 0;
153        size_t r = 1;
154        /*
155        <!-- define forward0sweep_code_define -->
156        */
157        // op code for current instruction
158        OpCode op;
159
160        // index for current instruction
161        size_t i_op;
162
163        // next variables
164        size_t i_var;
165
166        // operation argument indices
167        const addr_t*   arg = CPPAD_NULL;
168
169        // initialize the comparision operator (ComOp) counter
170        size_t compareCount = 0;
171
172        // If this includes a zero calculation, initialize this information
173        pod_vector<bool>   isvar_by_ind;
174        pod_vector<size_t> index_by_ind;
175        if( p == 0 )
176        {       size_t i;
177
178                // this includes order zero calculation, initialize vector indices
179                size_t num = play->num_vec_ind_rec();
180                if( num > 0 )
181                {       isvar_by_ind.extend(num);
182                        index_by_ind.extend(num);
183                        for(i = 0; i < num; i++)
184                        {       index_by_ind[i] = play->GetVecInd(i);
185                                isvar_by_ind[i] = false;
186                        }
187                }
188                // includes zero order, so initialize conditional skip flags
189                num = play->num_op_rec();
190                for(i = 0; i < num; i++)
191                        cskip_op[i] = false;
192        }
193
194        // work space used by UserOp.
195        vector<bool> user_vx;        // empty vecotor
196        vector<bool> user_vy;        // empty vecotor
197        vector<Base> user_tx;        // argument vector Taylor coefficients
198        vector<Base> user_ty;        // result vector Taylor coefficients
199        size_t user_index = 0;       // indentifier for this atomic operation
200        size_t user_id    = 0;       // user identifier for this call to operator
201        size_t user_i     = 0;       // index in result vector
202        size_t user_j     = 0;       // index in argument vector
203        size_t user_m     = 0;       // size of result vector
204        size_t user_n     = 0;       // size of arugment vector
205        //
206        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
207# ifndef NDEBUG
208        bool               user_ok   = false;      // atomic op return value
209# endif
210        //
211        // next expected operator in a UserOp sequence
212        enum { user_start, user_arg, user_ret, user_end, user_trace }
213        user_state = user_start;
214
215        // length of the parameter vector (used by CppAD assert macros)
216        const size_t num_par = play->num_par_rec();
217
218        // pointer to the beginning of the parameter vector
219        const Base* parameter = CPPAD_NULL;
220        if( num_par > 0 )
221                parameter = play->GetPar();
222
223        // length of the text vector (used by CppAD assert macros)
224        const size_t num_text = play->num_text_rec();
225
226        // pointer to the beginning of the text vector
227        const char* text = CPPAD_NULL;
228        if( num_text > 0 )
229                text = play->GetTxt(0);
230        /*
231        <!-- end forward0sweep_code_define -->
232        */
233
234# if CPPAD_FORWARD0SWEEP_TRACE
235        // variable indices for results vector
236        // (done differently for order zero).
237        vector<size_t> user_iy;     
238# endif
239# ifndef NDEBUG
240        // 2DO: implement tracing cache
241        CppAD::vector<addr_t> cache2var;
242# endif
243
244        // skip the BeginOp at the beginning of the recording
245        play->forward_start(op, arg, i_op, i_var);
246        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
247# if CPPAD_FORWARD0SWEEP_TRACE
248        std::cout << std::endl;
249# endif
250        bool more_operators = true;
251        while(more_operators)
252        {
253                // this op
254                play->forward_next(op, arg, i_op, i_var);
255
256                // check if we are skipping this operation
257                while( cskip_op[i_op] )
258                {       if( op == CSumOp )
259                        {       // CSumOp has a variable number of arguments
260                                play->forward_csum(op, arg, i_op, i_var);
261                        }
262                        play->forward_next(op, arg, i_op, i_var);
263                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
264                }
265                CPPAD_ASSERT_UNKNOWN( i_var < num_var  );
266                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
267                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
268                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
269                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
270
271                // action to take depends on the case
272                switch( op )
273                {
274                        case AbsOp:
275                        forward_abs_op_0(i_var, arg[0], J, taylor);
276                        break;
277                        // -------------------------------------------------
278
279                        case AddvvOp:
280                        forward_addvv_op_0(i_var, arg, parameter, J, taylor);
281                        break;
282                        // -------------------------------------------------
283
284                        case AddpvOp:
285                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
286                        forward_addpv_op_0(i_var, arg, parameter, J, taylor);
287                        break;
288                        // -------------------------------------------------
289
290                        case AcosOp:
291                        // sqrt(1 - x * x), acos(x)
292                        forward_acos_op_0(i_var, arg[0], J, taylor);
293                        break;
294                        // -------------------------------------------------
295
296                        case AsinOp:
297                        // sqrt(1 - x * x), asin(x)
298                        forward_asin_op_0(i_var, arg[0], J, taylor);
299                        break;
300                        // -------------------------------------------------
301
302                        case AtanOp:
303                        // 1 + x * x, atan(x)
304                        forward_atan_op_0(i_var, arg[0], J, taylor);
305                        break;
306                        // -------------------------------------------------
307
308                        case CExpOp:
309                        // Use the general case with d == 0
310                        // (could create an optimzied verison for this case)
311                        forward_cond_op_0(
312                                i_var, arg, num_par, parameter, J, taylor
313                        );
314                        break;
315                        // ---------------------------------------------------
316                        case ComOp:
317                        forward_comp_op_0(
318                        compareCount, arg, num_par, parameter, J, taylor
319                        );
320                        break;
321                        // ---------------------------------------------------
322
323                        case CosOp:
324                        // sin(x), cos(x)
325                        forward_cos_op_0(i_var, arg[0], J, taylor);
326                        break;
327                        // ---------------------------------------------------
328
329                        case CoshOp:
330                        // sinh(x), cosh(x)
331                        forward_cosh_op_0(i_var, arg[0], J, taylor);
332                        break;
333                        // -------------------------------------------------
334
335                        case CSkipOp:
336                        // CSkipOp has a variable number of arguments and
337                        // forward_next thinks it has no arguments.
338                        // we must inform forward_next of this special case.
339                        forward_cskip_op_0(
340                                i_var, arg, num_par, parameter, J, taylor, cskip_op
341                        );
342                        play->forward_cskip(op, arg, i_op, i_var);
343                        break;
344                        // -------------------------------------------------
345
346                        case CSumOp:
347                        // CSumOp has a variable number of arguments and
348                        // forward_next thinks it has no arguments.
349                        // we must inform forward_next of this special case.
350                        forward_csum_op(
351                                0, 0, i_var, arg, num_par, parameter, J, taylor
352                        );
353                        play->forward_csum(op, arg, i_op, i_var);
354                        break;
355                        // -------------------------------------------------
356
357                        case DisOp:
358                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
359                        break;
360                        // -------------------------------------------------
361
362                        case DivvvOp:
363                        forward_divvv_op_0(i_var, arg, parameter, J, taylor);
364                        break;
365                        // -------------------------------------------------
366
367                        case DivpvOp:
368                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
369                        forward_divpv_op_0(i_var, arg, parameter, J, taylor);
370                        break;
371                        // -------------------------------------------------
372
373                        case DivvpOp:
374                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
375                        forward_divvp_op_0(i_var, arg, parameter, J, taylor);
376                        break;
377                        // -------------------------------------------------
378
379                        case EndOp:
380                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
381                        more_operators = false;
382                        break;
383                        // -------------------------------------------------
384
385                        case ExpOp:
386                        forward_exp_op_0(i_var, arg[0], J, taylor);
387                        break;
388                        // -------------------------------------------------
389
390                        case InvOp:
391                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
392                        break;
393                        // -------------------------------------------------
394
395                        case LdpOp:
396                        forward_load_p_op_0(
397                                play,
398                                i_var, 
399                                arg, 
400                                parameter, 
401                                J, 
402                                taylor,
403                                isvar_by_ind.data(),
404                                index_by_ind.data(),
405                                var_by_load_op.data()
406                        );
407                        break;
408                        // -------------------------------------------------
409
410                        case LdvOp:
411                        forward_load_v_op_0(
412                                play,
413                                i_var, 
414                                arg, 
415                                parameter, 
416                                J, 
417                                taylor,
418                                isvar_by_ind.data(),
419                                index_by_ind.data(),
420                                var_by_load_op.data()
421                        );
422                        break;
423                        // -------------------------------------------------
424
425                        case LogOp:
426                        forward_log_op_0(i_var, arg[0], J, taylor);
427                        break;
428                        // -------------------------------------------------
429
430                        case MulvvOp:
431                        forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
432                        break;
433                        // -------------------------------------------------
434
435                        case MulpvOp:
436                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
437                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
438                        break;
439                        // -------------------------------------------------
440
441                        case ParOp:
442                        forward_par_op_0(
443                                i_var, arg, num_par, parameter, J, taylor
444                        );
445                        break;
446                        // -------------------------------------------------
447
448                        case PowvpOp:
449                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
450                        forward_powvp_op_0(i_var, arg, parameter, J, taylor);
451                        break;
452                        // -------------------------------------------------
453
454                        case PowpvOp:
455                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
456                        forward_powpv_op_0(i_var, arg, parameter, J, taylor);
457                        break;
458                        // -------------------------------------------------
459
460                        case PowvvOp:
461                        forward_powvv_op_0(i_var, arg, parameter, J, taylor);
462                        break;
463                        // -------------------------------------------------
464
465                        case PriOp:
466                        if( print ) forward_pri_0(s_out,
467                                arg, num_text, text, num_par, parameter, J, taylor
468                        );
469                        break;
470                        // -------------------------------------------------
471
472                        case SignOp:
473                        // cos(x), sin(x)
474                        forward_sign_op_0(i_var, arg[0], J, taylor);
475                        break;
476                        // -------------------------------------------------
477
478                        case SinOp:
479                        // cos(x), sin(x)
480                        forward_sin_op_0(i_var, arg[0], J, taylor);
481                        break;
482                        // -------------------------------------------------
483
484                        case SinhOp:
485                        // cosh(x), sinh(x)
486                        forward_sinh_op_0(i_var, arg[0], J, taylor);
487                        break;
488                        // -------------------------------------------------
489
490                        case SqrtOp:
491                        forward_sqrt_op_0(i_var, arg[0], J, taylor);
492                        break;
493                        // -------------------------------------------------
494
495                        case StppOp:
496                        forward_store_pp_op_0(
497                                i_var, 
498                                arg, 
499                                num_par, 
500                                J, 
501                                taylor,
502                                isvar_by_ind.data(),
503                                index_by_ind.data()
504                        );
505                        break;
506                        // -------------------------------------------------
507
508                        case StpvOp:
509                        forward_store_pv_op_0(
510                                i_var, 
511                                arg, 
512                                num_par, 
513                                J, 
514                                taylor,
515                                isvar_by_ind.data(),
516                                index_by_ind.data()
517                        );
518                        break;
519                        // -------------------------------------------------
520
521                        case StvpOp:
522                        forward_store_vp_op_0(
523                                i_var, 
524                                arg, 
525                                num_par, 
526                                J, 
527                                taylor,
528                                isvar_by_ind.data(),
529                                index_by_ind.data()
530                        );
531                        break;
532                        // -------------------------------------------------
533
534                        case StvvOp:
535                        forward_store_vv_op_0(
536                                i_var, 
537                                arg, 
538                                num_par, 
539                                J, 
540                                taylor,
541                                isvar_by_ind.data(),
542                                index_by_ind.data()
543                        );
544                        break;
545                        // -------------------------------------------------
546
547                        case SubvvOp:
548                        forward_subvv_op_0(i_var, arg, parameter, J, taylor);
549                        break;
550                        // -------------------------------------------------
551
552                        case SubpvOp:
553                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
554                        forward_subpv_op_0(i_var, arg, parameter, J, taylor);
555                        break;
556                        // -------------------------------------------------
557
558                        case SubvpOp:
559                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
560                        forward_subvp_op_0(i_var, arg, parameter, J, taylor);
561                        break;
562                        // -------------------------------------------------
563
564                        case TanOp:
565                        // tan(x)^2, tan(x)
566                        forward_tan_op_0(i_var, arg[0], J, taylor);
567                        break;
568                        // -------------------------------------------------
569
570                        case TanhOp:
571                        // tanh(x)^2, tanh(x)
572                        forward_tanh_op_0(i_var, arg[0], J, taylor);
573                        break;
574                        // -------------------------------------------------
575
576                        case UserOp:
577                        // start or end an atomic operation sequence
578                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
579                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
580                        if( user_state == user_start )
581                        {       user_index = arg[0];
582                                user_id    = arg[1];
583                                user_n     = arg[2];
584                                user_m     = arg[3];
585                                user_atom  = atomic_base<Base>::class_object(user_index);
586# ifndef NDEBUG
587                                if( user_atom == CPPAD_NULL )
588                                {       std::string msg = 
589                                                atomic_base<Base>::class_name(user_index)
590                                                + ": atomic_base function has been deleted";
591                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
592                                }
593# endif
594                                if(user_tx.size() != user_n)
595                                        user_tx.resize(user_n);
596                                if(user_ty.size() != user_m)
597                                        user_ty.resize(user_m);
598# if CPPAD_FORWARD0SWEEP_TRACE
599                                if( user_iy.size() != user_m )
600                                        user_iy.resize(user_m);
601# endif
602                                user_j     = 0;
603                                user_i     = 0;
604                                user_state = user_arg;
605                        }
606                        else
607                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
608                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
609                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
610                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
611                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
612# ifndef NDEBUG
613                                if( ! user_ok )
614                                {       std::string msg = 
615                                                atomic_base<Base>::class_name(user_index)
616                                                + ": atomic_base.forward: returned false";
617                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
618                                }
619# endif
620# if CPPAD_FORWARD0SWEEP_TRACE
621                                user_state = user_trace;
622# else
623                                user_state = user_start;
624# endif
625                        }
626                        break;
627
628                        case UsrapOp:
629                        // parameter argument in an atomic operation sequence
630                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
631                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
632                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
633                        user_tx[user_j++] = parameter[ arg[0] ];
634                        if( user_j == user_n )
635                        {       // call users function for this operation
636                                user_atom->set_id(user_id);
637                                CPPAD_ATOMIC_CALL(p, q, 
638                                        user_vx, user_vy, user_tx, user_ty
639                                );
640                                user_state = user_ret;
641                        }
642                        break;
643
644                        case UsravOp:
645                        // variable argument in an atomic operation sequence
646                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
647                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
648                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
649                        user_tx[user_j++] = taylor[ arg[0] * J + 0 ];
650                        if( user_j == user_n )
651                        {       // call users function for this operation
652                                user_atom->set_id(user_id);
653                                CPPAD_ATOMIC_CALL(p, q, 
654                                        user_vx, user_vy, user_tx, user_ty
655                                );
656                                user_state = user_ret;
657                        }
658                        break;
659
660                        case UsrrpOp:
661                        // parameter result in an atomic operation sequence
662                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
663                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
664# if CPPAD_FORWARD0SWEEP_TRACE
665                        user_iy[user_i] = 0;
666# endif
667                        user_i++;
668                        if( user_i == user_m )
669                                user_state = user_end;
670                        break;
671
672                        case UsrrvOp:
673                        // variable result in an atomic operation sequence
674                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
675                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
676# if CPPAD_FORWARD0SWEEP_TRACE
677                        user_iy[user_i] = i_var;
678# endif
679                        taylor[ i_var * J + 0 ] = user_ty[user_i++];
680                        if( user_i == user_m )
681                                user_state = user_end;
682                        break;
683                        // -------------------------------------------------
684
685                        default:
686                        CPPAD_ASSERT_UNKNOWN(false);
687                }
688# if CPPAD_FORWARD0SWEEP_TRACE
689                size_t  d  = 0;
690                if( user_state == user_trace )
691                {       user_state = user_start;
692
693                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
694                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
695                        for(size_t i = 0; i < user_m; i++) if( user_iy[i] > 0 )
696                        {       size_t i_tmp   = (i_op + i) - user_m;
697                                printOp(
698                                        std::cout, 
699                                        play,
700                                        i_tmp,
701                                        user_iy[i],
702                                        UsrrvOp, 
703                                        CPPAD_NULL,
704                                        cache2var
705                                );
706                                Base* Z_tmp = taylor + user_iy[i] * J;
707                                printOpResult(
708                                        std::cout, 
709                                        d + 1, 
710                                        Z_tmp,
711                                        0, 
712                                        (Base *) CPPAD_NULL
713                                );
714                                std::cout << std::endl;
715                        }
716                }
717                Base*           Z_tmp   = taylor + i_var * J;
718                const addr_t*   arg_tmp = arg;
719                if( op == CSumOp )
720                        arg_tmp = arg - arg[-1] - 4;
721                if( op == CSkipOp )
722                        arg_tmp = arg - arg[-1] - 7;
723                if( op != UsrrvOp )
724                {
725                        printOp(
726                                std::cout, 
727                                play,
728                                i_op,
729                                i_var,
730                                op, 
731                                arg_tmp,
732                                cache2var
733                        );
734                        if( NumRes(op) > 0 ) printOpResult(
735                                std::cout, 
736                                d + 1, 
737                                Z_tmp, 
738                                0, 
739                                (Base *) CPPAD_NULL
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 compareCount;
752}
753
754} // END_CPPAD_NAMESPACE
755
756// preprocessor symbols that are local to this file
757# undef CPPAD_FORWARD0SWEEP_TRACE
758# undef CPPAD_ATOMIC_CALL
759
760# endif
Note: See TracBrowser for help on using the repository browser.