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

Last change on this file since 3342 was 3342, checked in by bradbell, 6 years ago
  1. Zero order forward mode trace is correct, but results not getteing back

to function object; i.e. y and y_cache different.

  1. Change numvar to num_var in reverse mode sweep functions.
  • Property svn:keywords set to Id
File size: 20.5 KB
Line 
1/* $Id: forward0sweep.hpp 3342 2014-09-19 12:22:05Z 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        size_t num_cache = play->num_cache_rec();
156
157        // initialize cache indices with invalid variable value
158        CppAD::vector<addr_t> cache2var( num_cache );
159        for(size_t i = 0; i < num_cache; i++)
160                cache2var[i] = addr_t(0);
161
162        // use p, q, r so other forward sweeps can use code defined here
163        size_t p = 0;
164        size_t q = 0;
165        size_t r = 1;
166        /*
167        <!-- define forward0sweep_code_define -->
168        */
169        // op code for current instruction
170        OpCode op;
171
172        // index for current instruction
173        size_t i_op;
174
175        // next variables
176        size_t i_var;
177
178        // operation argument indices
179        const addr_t*   arg = CPPAD_NULL;
180
181        // initialize the comparision operator (ComOp) counter
182        size_t compareCount = 0;
183
184        // If this includes a zero calculation, initialize this information
185        pod_vector<bool>   isvar_by_ind;
186        pod_vector<size_t> index_by_ind;
187        if( p == 0 )
188        {       size_t i;
189
190                // this includes order zero calculation, initialize vector indices
191                size_t num = play->num_vec_ind_rec();
192                if( num > 0 )
193                {       isvar_by_ind.extend(num);
194                        index_by_ind.extend(num);
195                        for(i = 0; i < num; i++)
196                        {       index_by_ind[i] = play->GetVecInd(i);
197                                isvar_by_ind[i] = false;
198                        }
199                }
200                // includes zero order, so initialize conditional skip flags
201                num = play->num_op_rec();
202                for(i = 0; i < num; i++)
203                        cskip_op[i] = false;
204        }
205
206        // work space used by UserOp.
207        vector<bool> user_vx;        // empty vecotor
208        vector<bool> user_vy;        // empty vecotor
209        vector<Base> user_tx;        // argument vector Taylor coefficients
210        vector<Base> user_ty;        // result vector Taylor coefficients
211        size_t user_index = 0;       // indentifier for this atomic operation
212        size_t user_id    = 0;       // user identifier for this call to operator
213        size_t user_i     = 0;       // index in result vector
214        size_t user_j     = 0;       // index in argument vector
215        size_t user_m     = 0;       // size of result vector
216        size_t user_n     = 0;       // size of arugment vector
217        //
218        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
219# ifndef NDEBUG
220        bool               user_ok   = false;      // atomic op return value
221# endif
222        //
223        // next expected operator in a UserOp sequence
224        enum { user_start, user_arg, user_ret, user_end, user_trace }
225        user_state = user_start;
226
227        // length of the parameter vector (used by CppAD assert macros)
228        const size_t num_par = play->num_par_rec();
229
230        // pointer to the beginning of the parameter vector
231        const Base* parameter = CPPAD_NULL;
232        if( num_par > 0 )
233                parameter = play->GetPar();
234
235        // length of the text vector (used by CppAD assert macros)
236        const size_t num_text = play->num_text_rec();
237
238        // pointer to the beginning of the text vector
239        const char* text = CPPAD_NULL;
240        if( num_text > 0 )
241                text = play->GetTxt(0);
242        /*
243        <!-- end forward0sweep_code_define -->
244        */
245
246# if CPPAD_FORWARD0SWEEP_TRACE
247        // variable indices for results vector
248        // (done differently for order zero).
249        vector<size_t> user_iy;     
250# endif
251
252        // skip the BeginOp at the beginning of the recording
253        play->forward_start(op, arg, i_op, i_var);
254        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
255# if CPPAD_FORWARD0SWEEP_TRACE
256        std::cout << std::endl;
257# endif
258        bool more_operators = true;
259        while(more_operators)
260        {
261                // this op
262                play->forward_next(op, arg, i_op, i_var);
263
264                // check if we are skipping this operation
265                while( cskip_op[i_op] )
266                {       if( op == CSumOp )
267                        {       // CSumOp has a variable number of arguments
268                                play->forward_csum(op, arg, i_op, i_var);
269                        }
270                        play->forward_next(op, arg, i_op, i_var);
271                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
272                }
273                CPPAD_ASSERT_UNKNOWN( i_var < num_var  );
274                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
275                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
276                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
277                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
278
279                // action to take depends on the case
280                switch( op )
281                {
282                        case AbsOp:
283                        forward_abs_op_0(i_var, arg[0], J, taylor);
284                        break;
285                        // -------------------------------------------------
286
287                        case AddvvOp:
288                        forward_addvv_op_0(i_var, arg, parameter, J, taylor);
289                        break;
290                        // -------------------------------------------------
291
292                        case AddpvOp:
293                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
294                        forward_addpv_op_0(i_var, arg, parameter, J, taylor);
295                        break;
296                        // -------------------------------------------------
297
298                        case AcosOp:
299                        // sqrt(1 - x * x), acos(x)
300                        forward_acos_op_0(i_var, arg[0], J, taylor);
301                        break;
302                        // -------------------------------------------------
303
304                        case AsinOp:
305                        // sqrt(1 - x * x), asin(x)
306                        forward_asin_op_0(i_var, arg[0], J, taylor);
307                        break;
308                        // -------------------------------------------------
309
310                        case AtanOp:
311                        // 1 + x * x, atan(x)
312                        forward_atan_op_0(i_var, arg[0], J, taylor);
313                        break;
314                        // -------------------------------------------------
315
316                        case CExpOp:
317                        // Use the general case with d == 0
318                        // (could create an optimzied verison for this case)
319                        forward_cond_op_0(
320                                i_var, arg, num_par, parameter, J, taylor
321                        );
322                        break;
323                        // ---------------------------------------------------
324                        case ComOp:
325                        forward_comp_op_0(
326                        compareCount, arg, num_par, parameter, J, taylor
327                        );
328                        break;
329                        // ---------------------------------------------------
330
331                        case CosOp:
332                        // sin(x), cos(x)
333                        forward_cos_op_0(i_var, arg[0], J, taylor);
334                        break;
335                        // ---------------------------------------------------
336
337                        case CoshOp:
338                        // sinh(x), cosh(x)
339                        forward_cosh_op_0(i_var, arg[0], J, taylor);
340                        break;
341                        // -------------------------------------------------
342
343                        case CSkipOp:
344                        // CSkipOp has a variable number of arguments and
345                        // forward_next thinks it has no arguments.
346                        // we must inform forward_next of this special case.
347                        forward_cskip_op_0(
348                                i_var, arg, num_par, parameter, J, taylor, cskip_op
349                        );
350                        play->forward_cskip(op, arg, i_op, i_var);
351                        break;
352                        // -------------------------------------------------
353
354                        case CSumOp:
355                        // CSumOp has a variable number of arguments and
356                        // forward_next thinks it has no arguments.
357                        // we must inform forward_next of this special case.
358                        forward_csum_op(
359                                0, 0, i_var, arg, num_par, parameter, J, taylor
360                        );
361                        play->forward_csum(op, arg, i_op, i_var);
362                        break;
363                        // -------------------------------------------------
364
365                        case DisOp:
366                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
367                        break;
368                        // -------------------------------------------------
369
370                        case DivvvOp:
371                        forward_divvv_op_0(i_var, arg, parameter, J, taylor);
372                        break;
373                        // -------------------------------------------------
374
375                        case DivpvOp:
376                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
377                        forward_divpv_op_0(i_var, arg, parameter, J, taylor);
378                        break;
379                        // -------------------------------------------------
380
381                        case DivvpOp:
382                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
383                        forward_divvp_op_0(i_var, arg, parameter, J, taylor);
384                        break;
385                        // -------------------------------------------------
386
387                        case EndOp:
388                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
389                        more_operators = false;
390                        break;
391                        // -------------------------------------------------
392
393                        case ExpOp:
394                        forward_exp_op_0(i_var, arg[0], J, taylor);
395                        break;
396                        // -------------------------------------------------
397
398                        case InvOp:
399                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
400                        break;
401                        // -------------------------------------------------
402
403                        case LdpOp:
404                        forward_load_p_op_0(
405                                play,
406                                i_var, 
407                                arg, 
408                                parameter, 
409                                J, 
410                                taylor,
411                                isvar_by_ind.data(),
412                                index_by_ind.data(),
413                                var_by_load_op.data()
414                        );
415                        break;
416                        // -------------------------------------------------
417
418                        case LdvOp:
419                        forward_load_v_op_0(
420                                play,
421                                i_var, 
422                                arg, 
423                                parameter, 
424                                J, 
425                                taylor,
426                                isvar_by_ind.data(),
427                                index_by_ind.data(),
428                                var_by_load_op.data()
429                        );
430                        break;
431                        // -------------------------------------------------
432
433                        case LogOp:
434                        forward_log_op_0(i_var, arg[0], J, taylor);
435                        break;
436                        // -------------------------------------------------
437
438                        case MulvvOp:
439                        forward_mulvv_op_0(i_var, arg, parameter, J, taylor);
440                        break;
441                        // -------------------------------------------------
442
443                        case MulpvOp:
444                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
445                        forward_mulpv_op_0(i_var, arg, parameter, J, taylor);
446                        break;
447                        // -------------------------------------------------
448
449                        case ParOp:
450                        forward_par_op_0(
451                                i_var, arg, num_par, parameter, J, taylor
452                        );
453                        break;
454                        // -------------------------------------------------
455
456                        case PowvpOp:
457                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
458                        forward_powvp_op_0(i_var, arg, parameter, J, taylor);
459                        break;
460                        // -------------------------------------------------
461
462                        case PowpvOp:
463                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
464                        forward_powpv_op_0(i_var, arg, parameter, J, taylor);
465                        break;
466                        // -------------------------------------------------
467
468                        case PowvvOp:
469                        forward_powvv_op_0(i_var, arg, parameter, J, taylor);
470                        break;
471                        // -------------------------------------------------
472
473                        case PriOp:
474                        if( print ) forward_pri_0(s_out,
475                                arg, num_text, text, num_par, parameter, J, taylor
476                        );
477                        break;
478                        // -------------------------------------------------
479
480                        case SignOp:
481                        // cos(x), sin(x)
482                        forward_sign_op_0(i_var, arg[0], J, taylor);
483                        break;
484                        // -------------------------------------------------
485
486                        case SinOp:
487                        // cos(x), sin(x)
488                        forward_sin_op_0(i_var, arg[0], J, taylor);
489                        break;
490                        // -------------------------------------------------
491
492                        case SinhOp:
493                        // cosh(x), sinh(x)
494                        forward_sinh_op_0(i_var, arg[0], J, taylor);
495                        break;
496                        // -------------------------------------------------
497
498                        case SqrtOp:
499                        forward_sqrt_op_0(i_var, arg[0], J, taylor);
500                        break;
501                        // -------------------------------------------------
502
503                        case StppOp:
504                        forward_store_pp_op_0(
505                                i_var, 
506                                arg, 
507                                num_par, 
508                                J, 
509                                taylor,
510                                isvar_by_ind.data(),
511                                index_by_ind.data()
512                        );
513                        break;
514                        // -------------------------------------------------
515
516                        case StpvOp:
517                        forward_store_pv_op_0(
518                                i_var, 
519                                arg, 
520                                num_par, 
521                                J, 
522                                taylor,
523                                isvar_by_ind.data(),
524                                index_by_ind.data()
525                        );
526                        break;
527                        // -------------------------------------------------
528
529                        case StvpOp:
530                        forward_store_vp_op_0(
531                                i_var, 
532                                arg, 
533                                num_par, 
534                                J, 
535                                taylor,
536                                isvar_by_ind.data(),
537                                index_by_ind.data()
538                        );
539                        break;
540                        // -------------------------------------------------
541
542                        case StvvOp:
543                        forward_store_vv_op_0(
544                                i_var, 
545                                arg, 
546                                num_par, 
547                                J, 
548                                taylor,
549                                isvar_by_ind.data(),
550                                index_by_ind.data()
551                        );
552                        break;
553                        // -------------------------------------------------
554
555                        case SubvvOp:
556                        forward_subvv_op_0(i_var, arg, parameter, J, taylor);
557                        break;
558                        // -------------------------------------------------
559
560                        case SubpvOp:
561                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
562                        forward_subpv_op_0(i_var, arg, parameter, J, taylor);
563                        break;
564                        // -------------------------------------------------
565
566                        case SubvpOp:
567                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
568                        forward_subvp_op_0(i_var, arg, parameter, J, taylor);
569                        break;
570                        // -------------------------------------------------
571
572                        case TanOp:
573                        // tan(x)^2, tan(x)
574                        forward_tan_op_0(i_var, arg[0], J, taylor);
575                        break;
576                        // -------------------------------------------------
577
578                        case TanhOp:
579                        // tanh(x)^2, tanh(x)
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( num_cache != 0 )
697                {       size_t i_cache = size_t( play->GetVar2Cache(i_var) );
698                        CPPAD_ASSERT_UNKNOWN( i_cache >= num_var );
699                        taylor[ i_cache * J + 0 ]      = taylor[ i_var * J + 0 ];
700                        // use zero orgin cache indiex for cache2var vector
701                        cache2var[ i_cache - num_var ] = i_var;
702                }
703# if CPPAD_FORWARD0SWEEP_TRACE
704                size_t  d  = 0;
705                if( user_state == user_trace )
706                {       user_state = user_start;
707
708                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
709                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
710                        for(size_t i = 0; i < user_m; i++) if( user_iy[i] > 0 )
711                        {       size_t i_tmp   = (i_op + i) - user_m;
712                                printOp(
713                                        std::cout, 
714                                        play,
715                                        i_tmp,
716                                        user_iy[i],
717                                        UsrrvOp, 
718                                        CPPAD_NULL,
719                                        num_var,
720                                        cache2var
721                                );
722                                Base* Z_tmp = taylor + user_iy[i] * J;
723                                printOpResult(
724                                        std::cout, 
725                                        d + 1, 
726                                        Z_tmp,
727                                        0, 
728                                        (Base *) CPPAD_NULL
729                                );
730                                std::cout << std::endl;
731                        }
732                }
733                Base*           Z_tmp   = taylor + i_var * J;
734                const addr_t*   arg_tmp = arg;
735                if( op == CSumOp )
736                        arg_tmp = arg - arg[-1] - 4;
737                if( op == CSkipOp )
738                        arg_tmp = arg - arg[-1] - 7;
739                if( op != UsrrvOp )
740                {
741                        printOp(
742                                std::cout, 
743                                play,
744                                i_op,
745                                i_var,
746                                op, 
747                                arg_tmp,
748                                num_var,
749                                cache2var
750                        );
751                        if( NumRes(op) > 0 ) printOpResult(
752                                std::cout, 
753                                d + 1, 
754                                Z_tmp, 
755                                0, 
756                                (Base *) CPPAD_NULL
757                        );
758                        std::cout << std::endl;
759                }
760        }
761        std::cout << std::endl;
762# else
763        }
764# endif
765        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
766        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
767
768        return compareCount;
769}
770
771} // END_CPPAD_NAMESPACE
772
773// preprocessor symbols that are local to this file
774# undef CPPAD_FORWARD0SWEEP_TRACE
775# undef CPPAD_ATOMIC_CALL
776
777# endif
Note: See TracBrowser for help on using the repository browser.