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

Last change on this file since 3320 was 3320, checked in by bradbell, 6 years ago
  1. g++ 4.8.2 has shadow warnings by default, but eigen and fadbad do not

these warnings, so supress then in these cases.

  1. Move check that arguments come before result into on place,

CPPAD_ASSERT_ARG_BEFORE_RESULT (only one argument case so far).

main.cpp: fix shadowing of index variable.
CMakeLists.txt: adapt to change in teuchos library name.
sparse_jacobian.cpp: fix a shadowed variable.
check_svn_id.sh: ignore svn_commit.sh.
gpl_license.sh: ignore svn_commit.sh.

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