source: branches/cache/cppad/local/forward0sweep.hpp @ 3335

Last change on this file since 3335 was 3335, checked in by bradbell, 6 years ago
  1. cache.sh should not revert sweep files that have changed.
  2. Fix calls that were erased by mistake fixed in 1.
  3. Use cache2var (better description than cache).
  4. Put cache2var in ADFun function object.
  • Property svn:keywords set to Id
File size: 20.3 KB
Line 
1/* $Id: forward0sweep.hpp 3335 2014-09-15 22:32:35Z 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 numvar
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, ... , numvar - 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                numvar,
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() == numvar );
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
239        // 2DO: implement tracing cache
240        CppAD::vector<addr_t> cache2var;
241# endif
242
243        // skip the BeginOp at the beginning of the recording
244        play->forward_start(op, arg, i_op, i_var);
245        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
246# if CPPAD_FORWARD0SWEEP_TRACE
247        std::cout << std::endl;
248# endif
249        bool more_operators = true;
250        while(more_operators)
251        {
252                // this op
253                play->forward_next(op, arg, i_op, i_var);
254                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
255                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
256                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
257                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
258
259                // check if we are skipping this operation
260                while( cskip_op[i_op] )
261                {       if( op == CSumOp )
262                        {       // CSumOp has a variable number of arguments
263                                play->forward_csum(op, arg, i_op, i_var);
264                        }
265                        play->forward_next(op, arg, i_op, i_var);
266                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
267                }
268
269                // action to take depends on the case
270                switch( op )
271                {
272                        case AbsOp:
273                        forward_abs_op_0(i_var, arg[0], J, taylor);
274                        break;
275                        // -------------------------------------------------
276
277                        case AddvvOp:
278                        forward_addvv_op_0(i_var, arg, parameter, J, taylor);
279                        break;
280                        // -------------------------------------------------
281
282                        case AddpvOp:
283                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
284                        forward_addpv_op_0(i_var, arg, parameter, J, taylor);
285                        break;
286                        // -------------------------------------------------
287
288                        case AcosOp:
289                        // sqrt(1 - x * x), acos(x)
290                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
291                        forward_acos_op_0(i_var, arg[0], J, taylor);
292                        break;
293                        // -------------------------------------------------
294
295                        case AsinOp:
296                        // sqrt(1 - x * x), asin(x)
297                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
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                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
305                        forward_atan_op_0(i_var, arg[0], J, taylor);
306                        break;
307                        // -------------------------------------------------
308
309                        case CExpOp:
310                        // Use the general case with d == 0
311                        // (could create an optimzied verison for this case)
312                        forward_cond_op_0(
313                                i_var, arg, num_par, parameter, J, taylor
314                        );
315                        break;
316                        // ---------------------------------------------------
317                        case ComOp:
318                        forward_comp_op_0(
319                        compareCount, arg, num_par, parameter, J, taylor
320                        );
321                        break;
322                        // ---------------------------------------------------
323
324                        case CosOp:
325                        // sin(x), cos(x)
326                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
327                        forward_cos_op_0(i_var, arg[0], J, taylor);
328                        break;
329                        // ---------------------------------------------------
330
331                        case CoshOp:
332                        // sinh(x), cosh(x)
333                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
334                        forward_cosh_op_0(i_var, arg[0], J, taylor);
335                        break;
336                        // -------------------------------------------------
337
338                        case CSkipOp:
339                        // CSkipOp has a variable number of arguments and
340                        // forward_next thinks it has no arguments.
341                        // we must inform forward_next of this special case.
342                        forward_cskip_op_0(
343                                i_var, arg, num_par, parameter, J, taylor, cskip_op
344                        );
345                        play->forward_cskip(op, arg, i_op, i_var);
346                        break;
347                        // -------------------------------------------------
348
349                        case CSumOp:
350                        // CSumOp has a variable number of arguments and
351                        // forward_next thinks it has no arguments.
352                        // we must inform forward_next of this special case.
353                        forward_csum_op(
354                                0, 0, i_var, arg, num_par, parameter, J, taylor
355                        );
356                        play->forward_csum(op, arg, i_op, i_var);
357                        break;
358                        // -------------------------------------------------
359
360                        case DisOp:
361                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
362                        break;
363                        // -------------------------------------------------
364
365                        case DivvvOp:
366                        forward_divvv_op_0(i_var, arg, parameter, J, taylor);
367                        break;
368                        // -------------------------------------------------
369
370                        case DivpvOp:
371                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
372                        forward_divpv_op_0(i_var, arg, parameter, J, taylor);
373                        break;
374                        // -------------------------------------------------
375
376                        case DivvpOp:
377                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
378                        forward_divvp_op_0(i_var, arg, parameter, J, taylor);
379                        break;
380                        // -------------------------------------------------
381
382                        case EndOp:
383                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
384                        more_operators = false;
385                        break;
386                        // -------------------------------------------------
387
388                        case ExpOp:
389                        forward_exp_op_0(i_var, arg[0], J, taylor);
390                        break;
391                        // -------------------------------------------------
392
393                        case InvOp:
394                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
395                        break;
396                        // -------------------------------------------------
397
398                        case LdpOp:
399                        forward_load_p_op_0(
400                                play,
401                                i_var, 
402                                arg, 
403                                parameter, 
404                                J, 
405                                taylor,
406                                isvar_by_ind.data(),
407                                index_by_ind.data(),
408                                var_by_load_op.data()
409                        );
410                        break;
411                        // -------------------------------------------------
412
413                        case LdvOp:
414                        forward_load_v_op_0(
415                                play,
416                                i_var, 
417                                arg, 
418                                parameter, 
419                                J, 
420                                taylor,
421                                isvar_by_ind.data(),
422                                index_by_ind.data(),
423                                var_by_load_op.data()
424                        );
425                        break;
426                        // -------------------------------------------------
427
428                        case LogOp:
429                        forward_log_op_0(i_var, arg[0], J, taylor);
430                        break;
431                        // -------------------------------------------------
432
433                        case MulvvOp:
434                        forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
435                        break;
436                        // -------------------------------------------------
437
438                        case MulpvOp:
439                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
440                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
441                        break;
442                        // -------------------------------------------------
443
444                        case ParOp:
445                        forward_par_op_0(
446                                i_var, arg, num_par, parameter, J, taylor
447                        );
448                        break;
449                        // -------------------------------------------------
450
451                        case PowvpOp:
452                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
453                        forward_powvp_op_0(i_var, arg, parameter, J, taylor);
454                        break;
455                        // -------------------------------------------------
456
457                        case PowpvOp:
458                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
459                        forward_powpv_op_0(i_var, arg, parameter, J, taylor);
460                        break;
461                        // -------------------------------------------------
462
463                        case PowvvOp:
464                        forward_powvv_op_0(i_var, arg, parameter, J, taylor);
465                        break;
466                        // -------------------------------------------------
467
468                        case PriOp:
469                        if( print ) forward_pri_0(s_out,
470                                arg, num_text, text, num_par, parameter, J, taylor
471                        );
472                        break;
473                        // -------------------------------------------------
474
475                        case SignOp:
476                        // cos(x), sin(x)
477                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
478                        forward_sign_op_0(i_var, arg[0], J, taylor);
479                        break;
480                        // -------------------------------------------------
481
482                        case SinOp:
483                        // cos(x), sin(x)
484                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
485                        forward_sin_op_0(i_var, arg[0], J, taylor);
486                        break;
487                        // -------------------------------------------------
488
489                        case SinhOp:
490                        // cosh(x), sinh(x)
491                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
492                        forward_sinh_op_0(i_var, arg[0], J, taylor);
493                        break;
494                        // -------------------------------------------------
495
496                        case SqrtOp:
497                        forward_sqrt_op_0(i_var, arg[0], J, taylor);
498                        break;
499                        // -------------------------------------------------
500
501                        case StppOp:
502                        forward_store_pp_op_0(
503                                i_var, 
504                                arg, 
505                                num_par, 
506                                J, 
507                                taylor,
508                                isvar_by_ind.data(),
509                                index_by_ind.data()
510                        );
511                        break;
512                        // -------------------------------------------------
513
514                        case StpvOp:
515                        forward_store_pv_op_0(
516                                i_var, 
517                                arg, 
518                                num_par, 
519                                J, 
520                                taylor,
521                                isvar_by_ind.data(),
522                                index_by_ind.data()
523                        );
524                        break;
525                        // -------------------------------------------------
526
527                        case StvpOp:
528                        forward_store_vp_op_0(
529                                i_var, 
530                                arg, 
531                                num_par, 
532                                J, 
533                                taylor,
534                                isvar_by_ind.data(),
535                                index_by_ind.data()
536                        );
537                        break;
538                        // -------------------------------------------------
539
540                        case StvvOp:
541                        forward_store_vv_op_0(
542                                i_var, 
543                                arg, 
544                                num_par, 
545                                J, 
546                                taylor,
547                                isvar_by_ind.data(),
548                                index_by_ind.data()
549                        );
550                        break;
551                        // -------------------------------------------------
552
553                        case SubvvOp:
554                        forward_subvv_op_0(i_var, arg, parameter, J, taylor);
555                        break;
556                        // -------------------------------------------------
557
558                        case SubpvOp:
559                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
560                        forward_subpv_op_0(i_var, arg, parameter, J, taylor);
561                        break;
562                        // -------------------------------------------------
563
564                        case SubvpOp:
565                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
566                        forward_subvp_op_0(i_var, arg, parameter, J, taylor);
567                        break;
568                        // -------------------------------------------------
569
570                        case TanOp:
571                        // tan(x)^2, tan(x)
572                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
573                        forward_tan_op_0(i_var, arg[0], J, taylor);
574                        break;
575                        // -------------------------------------------------
576
577                        case TanhOp:
578                        // tanh(x)^2, tanh(x)
579                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
580                        forward_tanh_op_0(i_var, arg[0], J, taylor);
581                        break;
582                        // -------------------------------------------------
583
584                        case UserOp:
585                        // start or end an atomic operation sequence
586                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
587                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
588                        if( user_state == user_start )
589                        {       user_index = arg[0];
590                                user_id    = arg[1];
591                                user_n     = arg[2];
592                                user_m     = arg[3];
593                                user_atom  = atomic_base<Base>::class_object(user_index);
594# ifndef NDEBUG
595                                if( user_atom == CPPAD_NULL )
596                                {       std::string msg = 
597                                                atomic_base<Base>::class_name(user_index)
598                                                + ": atomic_base function has been deleted";
599                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
600                                }
601# endif
602                                if(user_tx.size() != user_n)
603                                        user_tx.resize(user_n);
604                                if(user_ty.size() != user_m)
605                                        user_ty.resize(user_m);
606# if CPPAD_FORWARD0SWEEP_TRACE
607                                if( user_iy.size() != user_m )
608                                        user_iy.resize(user_m);
609# endif
610                                user_j     = 0;
611                                user_i     = 0;
612                                user_state = user_arg;
613                        }
614                        else
615                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
616                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
617                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
618                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
619                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
620# ifndef NDEBUG
621                                if( ! user_ok )
622                                {       std::string msg = 
623                                                atomic_base<Base>::class_name(user_index)
624                                                + ": atomic_base.forward: returned false";
625                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
626                                }
627# endif
628# if CPPAD_FORWARD0SWEEP_TRACE
629                                user_state = user_trace;
630# else
631                                user_state = user_start;
632# endif
633                        }
634                        break;
635
636                        case UsrapOp:
637                        // parameter argument in an atomic operation sequence
638                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
639                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
640                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
641                        user_tx[user_j++] = parameter[ arg[0] ];
642                        if( user_j == user_n )
643                        {       // call users function for this operation
644                                user_atom->set_id(user_id);
645                                CPPAD_ATOMIC_CALL(p, q, 
646                                        user_vx, user_vy, user_tx, user_ty
647                                );
648                                user_state = user_ret;
649                        }
650                        break;
651
652                        case UsravOp:
653                        // variable argument in an atomic operation sequence
654                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
655                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
656                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
657                        user_tx[user_j++] = taylor[ arg[0] * J + 0 ];
658                        if( user_j == user_n )
659                        {       // call users function for this operation
660                                user_atom->set_id(user_id);
661                                CPPAD_ATOMIC_CALL(p, q, 
662                                        user_vx, user_vy, user_tx, user_ty
663                                );
664                                user_state = user_ret;
665                        }
666                        break;
667
668                        case UsrrpOp:
669                        // parameter result in an atomic operation sequence
670                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
671                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
672# if CPPAD_FORWARD0SWEEP_TRACE
673                        user_iy[user_i] = 0;
674# endif
675                        user_i++;
676                        if( user_i == user_m )
677                                user_state = user_end;
678                        break;
679
680                        case UsrrvOp:
681                        // variable result in an atomic operation sequence
682                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
683                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
684# if CPPAD_FORWARD0SWEEP_TRACE
685                        user_iy[user_i] = i_var;
686# endif
687                        taylor[ i_var * J + 0 ] = user_ty[user_i++];
688                        if( user_i == user_m )
689                                user_state = user_end;
690                        break;
691                        // -------------------------------------------------
692
693                        default:
694                        CPPAD_ASSERT_UNKNOWN(false);
695                }
696# if CPPAD_FORWARD0SWEEP_TRACE
697                size_t  d  = 0;
698                if( user_state == user_trace )
699                {       user_state = user_start;
700
701                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
702                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
703                        for(size_t i = 0; i < user_m; i++) if( user_iy[i] > 0 )
704                        {       size_t i_tmp   = (i_op + i) - user_m;
705                                printOp(
706                                        std::cout, 
707                                        play,
708                                        i_tmp,
709                                        user_iy[i],
710                                        UsrrvOp, 
711                                        CPPAD_NULL,
712                                        cache2var
713                                );
714                                Base* Z_tmp = taylor + user_iy[i] * J;
715                                printOpResult(
716                                        std::cout, 
717                                        d + 1, 
718                                        Z_tmp,
719                                        0, 
720                                        (Base *) CPPAD_NULL
721                                );
722                                std::cout << std::endl;
723                        }
724                }
725                Base*           Z_tmp   = taylor + i_var * J;
726                const addr_t*   arg_tmp = arg;
727                if( op == CSumOp )
728                        arg_tmp = arg - arg[-1] - 4;
729                if( op == CSkipOp )
730                        arg_tmp = arg - arg[-1] - 7;
731                if( op != UsrrvOp )
732                {
733                        printOp(
734                                std::cout, 
735                                play,
736                                i_op,
737                                i_var,
738                                op, 
739                                arg_tmp,
740                                cache2var
741                        );
742                        if( NumRes(op) > 0 ) printOpResult(
743                                std::cout, 
744                                d + 1, 
745                                Z_tmp, 
746                                0, 
747                                (Base *) CPPAD_NULL
748                        );
749                        std::cout << std::endl;
750                }
751        }
752        std::cout << std::endl;
753# else
754        }
755# endif
756        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
757        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
758
759        return compareCount;
760}
761
762} // END_CPPAD_NAMESPACE
763
764// preprocessor symbols that are local to this file
765# undef CPPAD_FORWARD0SWEEP_TRACE
766# undef CPPAD_ATOMIC_CALL
767
768# endif
Note: See TracBrowser for help on using the repository browser.