source: trunk/cppad/local/forward0sweep.hpp @ 3301

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

merge in multiple forward direcitons from branches/forward_dir

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