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

Last change on this file since 3344 was 3344, checked in by bradbell, 6 years ago

Implement and test first order forward mode.

cache.sh: Erase taylor coefficient when create cache.
forward1sweep.hpp: copy more information from forward0sweep.

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