source: branches/opt_cond_exp/cppad/local/forward_sweep.hpp @ 2970

Last change on this file since 2970 was 2970, checked in by bradbell, 7 years ago

Convert forward_sweep to handel CSkip operators.

forward0sweep.hpp: minor clean up of doxygen, alphabetic order ops.

  • Property svn:keywords set to Id
File size: 20.9 KB
Line 
1/* $Id: forward_sweep.hpp 2970 2013-10-19 02:16:02Z bradbell $ */
2# ifndef CPPAD_FORWARD_SWEEP_INCLUDED
3# define CPPAD_FORWARD_SWEEP_INCLUDED
4
5/* --------------------------------------------------------------------------
6CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 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\defgroup forward_sweep_hpp forward_sweep.hpp
19\{
20\file forward_sweep.hpp
21Compute zero order forward mode Taylor coefficients.
22*/
23
24/*
25\def CPPAD_ATOMIC_CALL
26This avoids warnings when NDEBUG is defined and user_ok is not used.
27If \c NDEBUG is defined, this resolves to
28\code
29        user_atom->forward
30\endcode
31otherwise, it respolves to
32\code
33        user_ok = user_atom->forward
34\endcode
35This maco is undefined at the end of this file to facillitate is
36use with a different definition in other files.
37*/
38# ifdef NDEBUG
39# define CPPAD_ATOMIC_CALL user_atom->forward
40# else
41# define CPPAD_ATOMIC_CALL user_ok = user_atom->forward
42# endif
43
44/*!
45\def CPPAD_FORWARD_SWEEP_TRACE
46This value is either zero or one.
47Zero is the normal operational value.
48If it is one, a trace of every forward_sweep computation is printed.
49*/
50# define CPPAD_FORWARD_SWEEP_TRACE 0
51
52/*!
53Compute arbitrary order forward mode Taylor coefficients.
54
55\tparam Base
56base type for the operator; i.e., this operation sequence was recorded
57using AD< \a Base > and computations by this routine are done using type
58\a Base.
59
60\param s_out
61Is the stream where output corresponding to \c PriOp operations will
62be written.
63
64\param print
65If \a print is false,
66suppress the output that is otherwise generated by the PriOp instructions.
67
68\param q
69is the lowest order of the Taylor coefficients
70that are computed during this call.
71
72\param p
73is the highest order of the Taylor coefficients
74that are computed during this call.
75
76\param n
77is the number of independent variables on the tape.
78
79\param numvar
80is the total number of variables on the tape.
81This is also equal to the number of rows in the matrix \a Taylor; i.e.,
82Rec->num_rec_var().
83
84\param Rec
85The information stored in \a Rec
86is a recording of the operations corresponding to the function
87\f[
88        F : {\bf R}^n \rightarrow {\bf R}^m
89\f]
90where \f$ n \f$ is the number of independent variables and
91\f$ m \f$ is the number of dependent variables.
92\n
93\n
94The object \a Rec is effectly constant.
95There are two exceptions to this.
96The first exception is that while palying back the tape
97the object \a Rec holds information about the current location
98with in the tape and this changes during palyback.
99The second exception is the fact that the
100zero order ( \a p = 0 ) versions of the VecAD operators LdpOp and LdvOp
101modify the corresponding \a op_arg values returned by
102\ref player::next_forward and \ref player::next_reverse; see the
103\link load_op.hpp LdpOp and LdvOp \endlink operations.
104
105\param J
106Is the number of columns in the coefficient matrix \a Taylor.
107This must be greater than or equal \a p + 1.
108
109\param Taylor
110\b Input: For j = 1 , ... , \a n, and for k = 0 , ... , \a p,
111\a Taylor [ j * J + k ]
112is the k-th order Taylor coefficient corresponding to
113variable with index j on the tape
114(independent variable with index (j-1) in the independent variable vector).
115\n
116\n
117\b Output: For i = \a n + 1, ... , \a numvar - 1, and for k = 0 , ... , \a p,
118\a Taylor [ i * J + k ]
119is the k-th order Taylor coefficient for the variable with
120index i on the tape.
121
122\param cskip_var
123Is a vector with size \c numvar,
124
125\li <tt>q = 0</tt>
126In this case,
127the input value of the elements does not matter.
128Upon return, if cskip_var[i] is true, the value of variable with index i
129does not affect any of the dependent variable (given the value
130of the independent variables).
131
132\li <tt>q > 0</tt>
133The vector is not modified and
134if cskip_var[i] is true, the value of variable with index i
135does not affect any of the dependent variable (given the value
136of the independent variables).
137
138\a return
139If \a p is not zero, the return value is zero.
140If \a p is zero,
141the return value is equal to the number of ComOp operations
142that have a different result from when the information in
143\a Rec was recorded.
144(Note that if NDEBUG is true, there are no ComOp operations
145in Rec and hence this return value is always zero.)
146*/
147
148template <class Base>
149size_t forward_sweep(
150        std::ostream&         s_out,
151        const bool            print,
152        const size_t          q,
153        const size_t          p,
154        const size_t          n,
155        const size_t          numvar,
156        player<Base>         *Rec,
157        const size_t          J,
158        Base                 *Taylor,
159        CppAD::vector<bool>&  cskip_var
160)
161{       CPPAD_ASSERT_UNKNOWN( J >= p + 1 );
162        CPPAD_ASSERT_UNKNOWN( q <= p );
163
164        // op code for current instruction
165        OpCode           op;
166
167        // index for current instruction
168        size_t         i_op;
169
170        // next variables
171        size_t        i_var;
172
173        // arg (not as a constant)
174        addr_t*         non_const_arg = CPPAD_NULL;
175
176        // arg (as a constant)
177        const addr_t*   arg = CPPAD_NULL;
178
179        // temporary indices
180        size_t i, ell;
181
182        // initialize the comparision operator (ComOp) counter
183        size_t compareCount = 0;
184
185        pod_vector<size_t> VectorInd;  // address for each element
186        pod_vector<bool>   VectorVar;  // is element a variable
187        if( q == 0 )
188        {
189                // this includes order zero calculation, initialize vector indices
190                i = Rec->num_rec_vecad_ind();
191                if( i > 0 )
192                {       VectorInd.extend(i);
193                        VectorVar.extend(i);
194                        while(i--)
195                        {       VectorInd[i] = Rec->GetVecInd(i);
196                                VectorVar[i] = false;
197                        }
198                }
199                // includes zero order, so initialize conditional skip flags
200                for(i = 0; i < numvar; i++)
201                        cskip_var[i] = false;
202        }
203
204        // Work space used by UserOp. Note User assumes q = p.
205        const size_t user_p1 = p+1;  // number of orders for this user calculation
206        vector<bool> user_vx;        // empty vector
207        vector<bool> user_vy;        // empty vector
208        vector<Base> user_tx;        // argument vector Taylor coefficients
209        vector<Base> user_ty;        // result vector Taylor coefficients
210        vector<size_t> user_iy;      // variable indices for results vector
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_state = user_start;
225
226        // check numvar argument
227        CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
228
229        // length of the parameter vector (used by CppAD assert macros)
230        const size_t num_par = Rec->num_rec_par();
231
232        // pointer to the beginning of the parameter vector
233        const Base* parameter = CPPAD_NULL;
234        if( num_par > 0 )
235                parameter = Rec->GetPar();
236
237        // length of the text vector (used by CppAD assert macros)
238        const size_t num_text = Rec->num_rec_text();
239
240        // pointer to the beginning of the text vector
241        const char* text = CPPAD_NULL;
242        if( num_text > 0 )
243                text = Rec->GetTxt(0);
244
245        // skip the BeginOp at the beginning of the recording
246        Rec->start_forward(op, arg, i_op, i_var);
247        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
248# if CPPAD_FORWARD_SWEEP_TRACE
249        std::cout << std::endl;
250# endif
251        while(op != EndOp)
252        {
253                // this op
254                Rec->next_forward(op, arg, i_op, i_var);
255                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
256                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
257
258                // check if we are skipping this operation
259                CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
260                CPPAD_ASSERT_UNKNOWN( NumRes(EndOp)  == 0 );
261                while( cskip_var[i_var] && NumRes(op) > 0 )
262                {       Rec->next_forward(op, arg, i_op, i_var);
263                        if( op == CSumOp )
264                        {       // CSumOp has a variable number of arguments and
265                                Rec->forward_csum(op, arg, i_op, i_var);
266                        }
267                }
268
269                // action depends on the operator
270                switch( op )
271                {
272                        case AbsOp:
273                        forward_abs_op(q, p, i_var, arg[0], J, Taylor);
274                        break;
275                        // -------------------------------------------------
276
277                        case AddvvOp:
278                        forward_addvv_op(q, p, i_var, arg, parameter, J, Taylor);
279                        break;
280                        // -------------------------------------------------
281
282                        case AddpvOp:
283                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
284                        forward_addpv_op(q, p, i_var, arg, parameter, J, Taylor);
285                        break;
286                        // -------------------------------------------------
287
288                        case AcosOp:
289                        // sqrt(1 - x * x), acos(x)
290                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
291                        forward_acos_op(q, p, i_var, arg[0], J, Taylor);
292                        break;
293                        // -------------------------------------------------
294
295                        case AsinOp:
296                        // sqrt(1 - x * x), asin(x)
297                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
298                        forward_asin_op(q, p, i_var, arg[0], J, Taylor);
299                        break;
300                        // -------------------------------------------------
301
302                        case AtanOp:
303                        // 1 + x * x, atan(x)
304                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
305                        forward_atan_op(q, p, i_var, arg[0], J, Taylor);
306                        break;
307                        // -------------------------------------------------
308
309                        case CExpOp:
310                        forward_cond_op(
311                                q, p, i_var, arg, num_par, parameter, J, Taylor
312                        );
313                        break;
314                        // ---------------------------------------------------
315
316                        case ComOp:
317                        if( q == 0 ) forward_comp_op_0(
318                        compareCount, arg, num_par, parameter, J, Taylor
319                        );
320                        break;
321                        // ---------------------------------------------------
322
323                        case CosOp:
324                        // sin(x), cos(x)
325                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
326                        forward_cos_op(q, p, i_var, arg[0], J, Taylor);
327                        break;
328                        // ---------------------------------------------------
329
330                        case CoshOp:
331                        // sinh(x), cosh(x)
332                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
333                        forward_cosh_op(q, p, i_var, arg[0], J, Taylor);
334                        break;
335                        // -------------------------------------------------
336
337                        case CSkipOp:
338                        if( q == 0 )
339                        {       // CSumOp has a variable number of arguments and
340                                // next_forward thinks it one has one argument.
341                                // we must inform next_forward of this special case.
342                                Rec->forward_cskip(op, arg, i_op, i_var);
343                                forward_cskip_op_0(
344                                        i_var, arg, num_par, parameter, J, Taylor, cskip_var
345                                );
346                        }
347                        break;
348                        // -------------------------------------------------
349
350                        case CSumOp:
351                        // CSumOp has a variable number of arguments and
352                        // next_forward thinks it one has one argument.
353                        // we must inform next_forward of this special case.
354                        Rec->forward_csum(op, arg, i_op, i_var);
355                        forward_csum_op(
356                                q, p, i_var, arg, num_par, parameter, J, Taylor
357                        );
358                        break;
359                        // -------------------------------------------------
360
361                        case DisOp:
362                        i = q;
363                        if( i == 0 )
364                        {       forward_dis_op_0(i_var, arg, J, Taylor);
365                                i++;
366                        }
367                        while(i <= p)
368                        {       Taylor[ i_var * J + i] = Base(0);
369                                i++;
370                        }
371                        break;
372                        // -------------------------------------------------
373
374                        case DivvvOp:
375                        forward_divvv_op(q, p, i_var, arg, parameter, J, Taylor);
376                        break;
377                        // -------------------------------------------------
378
379                        case DivpvOp:
380                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
381                        forward_divpv_op(q, p, i_var, arg, parameter, J, Taylor);
382                        break;
383                        // -------------------------------------------------
384
385                        case DivvpOp:
386                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
387                        forward_divvp_op(q, p, i_var, arg, parameter, J, Taylor);
388                        break;
389                        // -------------------------------------------------
390
391                        case EndOp:
392                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
393                        break;
394                        // -------------------------------------------------
395
396                        case ExpOp:
397                        forward_exp_op(q, p, i_var, arg[0], J, Taylor);
398                        break;
399                        // -------------------------------------------------
400
401                        case InvOp:
402                        CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
403                        break;
404                        // -------------------------------------------------
405
406                        case LdpOp:
407                        if( q == 0 )
408                        {       non_const_arg = Rec->forward_non_const_arg();
409                                forward_load_p_op_0(
410                                        i_var, 
411                                        non_const_arg, 
412                                        num_par, 
413                                        parameter, 
414                                        J, 
415                                        Taylor,
416                                        Rec->num_rec_vecad_ind(),
417                                        VectorVar.data(),
418                                        VectorInd.data()
419                                );
420                                if( q < p )
421                                        forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
422                        }
423                        else
424                        {       forward_load_op( op, q, p, i_var, arg, J, Taylor);
425                        }
426                        break;
427                        // -------------------------------------------------
428
429                        case LdvOp:
430                        if( q == 0 )
431                        {       non_const_arg = Rec->forward_non_const_arg();
432                                forward_load_v_op_0(
433                                        i_var, 
434                                        non_const_arg, 
435                                        num_par, 
436                                        parameter, 
437                                        J, 
438                                        Taylor,
439                                        Rec->num_rec_vecad_ind(),
440                                        VectorVar.data(),
441                                        VectorInd.data()
442                                );
443                                if( q < p )
444                                        forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
445                        }
446                        else
447                        {       forward_load_op( op, q, p, i_var, arg, J, Taylor);
448                        }
449                        break;
450                        // -------------------------------------------------
451
452                        case LogOp:
453                        forward_log_op(q, p, i_var, arg[0], J, Taylor);
454                        break;
455                        // -------------------------------------------------
456
457                        case MulvvOp:
458                        forward_mulvv_op(q, p, i_var, arg, parameter, J, Taylor);
459                        break;
460                        // -------------------------------------------------
461
462                        case MulpvOp:
463                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
464                        forward_mulpv_op(q, p, i_var, arg, parameter, J, Taylor);
465                        break;
466                        // -------------------------------------------------
467
468                        case ParOp:
469                        i = q;
470                        if( i == 0 )
471                        {       forward_par_op_0(
472                                        i_var, arg, num_par, parameter, J, Taylor
473                                );
474                                i++;
475                        }
476                        while(i <= p)
477                        {       Taylor[ i_var * J + i] = Base(0); 
478                                i++;
479                        }
480                        break;
481                        // -------------------------------------------------
482
483                        case PowvpOp:
484                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
485                        forward_powvp_op(q, p, i_var, arg, parameter, J, Taylor);
486                        break;
487                        // -------------------------------------------------
488
489                        case PowpvOp:
490                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
491                        forward_powpv_op(q, p, i_var, arg, parameter, J, Taylor);
492                        break;
493                        // -------------------------------------------------
494
495                        case PowvvOp:
496                        forward_powvv_op(q, p, i_var, arg, parameter, J, Taylor);
497                        break;
498                        // -------------------------------------------------
499
500                        case PriOp:
501                        if( (q == 0) & print ) forward_pri_0(s_out,
502                                i_var, arg, num_text, text, num_par, parameter, J, Taylor
503                        );
504                        break;
505                        // -------------------------------------------------
506
507                        case SignOp:
508                        // sign(x)
509                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
510                        forward_sign_op(q, p, i_var, arg[0], J, Taylor);
511                        break;
512                        // -------------------------------------------------
513
514                        case SinOp:
515                        // cos(x), sin(x)
516                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
517                        forward_sin_op(q, p, i_var, arg[0], J, Taylor);
518                        break;
519                        // -------------------------------------------------
520
521                        case SinhOp:
522                        // cosh(x), sinh(x)
523                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
524                        forward_sinh_op(q, p, i_var, arg[0], J, Taylor);
525                        break;
526                        // -------------------------------------------------
527
528                        case SqrtOp:
529                        forward_sqrt_op(q, p, i_var, arg[0], J, Taylor);
530                        break;
531                        // -------------------------------------------------
532
533                        case StppOp:
534                        if( q == 0 )
535                        {       forward_store_pp_op_0(
536                                        i_var, 
537                                        arg, 
538                                        num_par, 
539                                        J, 
540                                        Taylor,
541                                        Rec->num_rec_vecad_ind(),
542                                        VectorVar.data(),
543                                        VectorInd.data()
544                                );
545                        }
546                        break;
547                        // -------------------------------------------------
548
549                        case StpvOp:
550                        if( q == 0 )
551                        {       forward_store_pv_op_0(
552                                        i_var, 
553                                        arg, 
554                                        num_par, 
555                                        J, 
556                                        Taylor,
557                                        Rec->num_rec_vecad_ind(),
558                                        VectorVar.data(),
559                                        VectorInd.data()
560                                );
561                        }
562                        break;
563                        // -------------------------------------------------
564
565                        case StvpOp:
566                        if( q == 0 )
567                        {       forward_store_vp_op_0(
568                                        i_var, 
569                                        arg, 
570                                        num_par, 
571                                        J, 
572                                        Taylor,
573                                        Rec->num_rec_vecad_ind(),
574                                        VectorVar.data(),
575                                        VectorInd.data()
576                                );
577                        }
578                        break;
579                        // -------------------------------------------------
580
581                        case StvvOp:
582                        if( q == 0 )
583                        {       forward_store_vv_op_0(
584                                        i_var, 
585                                        arg, 
586                                        num_par, 
587                                        J, 
588                                        Taylor,
589                                        Rec->num_rec_vecad_ind(),
590                                        VectorVar.data(),
591                                        VectorInd.data()
592                                );
593                        }
594                        break;
595                        // -------------------------------------------------
596
597                        case SubvvOp:
598                        forward_subvv_op(q, p, i_var, arg, parameter, J, Taylor);
599                        break;
600                        // -------------------------------------------------
601
602                        case SubpvOp:
603                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
604                        forward_subpv_op(q, p, i_var, arg, parameter, J, Taylor);
605                        break;
606                        // -------------------------------------------------
607
608                        case SubvpOp:
609                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
610                        forward_subvp_op(q, p, i_var, arg, parameter, J, Taylor);
611                        break;
612                        // -------------------------------------------------
613
614                        case TanOp:
615                        // tan(x)^2, tan(x)
616                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
617                        forward_tan_op(q, p, i_var, arg[0], J, Taylor);
618                        break;
619                        // -------------------------------------------------
620
621                        case TanhOp:
622                        // tanh(x)^2, tanh(x)
623                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
624                        forward_tanh_op(q, p, i_var, arg[0], J, Taylor);
625                        break;
626                        // -------------------------------------------------
627
628                        case UserOp:
629                        // start or end an atomic operation sequence
630                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
631                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
632                        if( user_state == user_start )
633                        {       user_index = arg[0];
634                                user_id    = arg[1];
635                                user_n     = arg[2];
636                                user_m     = arg[3];
637                                user_atom  = atomic_base<Base>::class_object(user_index);
638# ifndef NDEBUG
639                                if( user_atom == CPPAD_NULL )
640                                {       std::string msg = 
641                                                atomic_base<Base>::class_name(user_index)
642                                                + ": atomic_base function has been deleted";
643                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
644                                }
645# endif
646                                if(user_tx.size() != user_n * user_p1)
647                                        user_tx.resize(user_n * user_p1);
648                                if(user_ty.size() != user_m * user_p1)
649                                        user_ty.resize(user_m * user_p1);
650                                if(user_iy.size() != user_m)
651                                        user_iy.resize(user_m);
652                                user_j     = 0;
653                                user_i     = 0;
654                                user_state = user_arg;
655                        }
656                        else
657                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
658                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
659                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
660                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
661                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
662
663                                // call users function for this operation
664                                user_atom->set_id(user_id);
665                                CPPAD_ATOMIC_CALL(
666                                        q, p, user_vx, user_vy, user_tx, user_ty
667                                );
668# ifndef NDEBUG
669                                if( ! user_ok )
670                                {       std::string msg = 
671                                                atomic_base<Base>::class_name(user_index)
672                                                + ": atomic_base.forward: returned false";
673                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
674                                }
675# endif
676                                for(i = 0; i < user_m; i++) 
677                                        if( user_iy[i] > 0 )
678                                                for(ell = q; ell <= p; ell++)
679                                                        Taylor[ user_iy[i] * J + ell ] = 
680                                                                user_ty[ i * user_p1 + ell ];
681
682                                user_state = user_start;
683                        }
684                        break;
685
686                        case UsrapOp:
687                        // parameter argument in an atomic operation sequence
688                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
689                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
690                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
691                        user_tx[user_j * user_p1 + 0] = parameter[ arg[0]];
692                        for(ell = 1; ell < user_p1; ell++)
693                                user_tx[user_j * user_p1 + ell] = Base(0);
694                        ++user_j;
695                        if( user_j == user_n )
696                                user_state = user_ret;
697                        break;
698
699                        case UsravOp:
700                        // variable argument in an atomic operation sequence
701                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
702                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
703                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
704                        for(ell = 0; ell < user_p1; ell++)
705                                user_tx[user_j * user_p1 + ell] = Taylor[ arg[0] * J + ell];
706                        ++user_j;
707                        if( user_j == user_n )
708                                user_state = user_ret;
709                        break;
710
711                        case UsrrpOp:
712                        // parameter result in an atomic operation sequence
713                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
714                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
715                        user_iy[user_i] = 0;
716                        user_ty[user_i * user_p1 + 0] = parameter[ arg[0]];
717                        for(ell = 1; ell < q; ell++)
718                                user_ty[user_i * user_p1 + ell] = Base(0);
719                        user_i++;
720                        if( user_i == user_m )
721                                user_state = user_end;
722                        break;
723
724                        case UsrrvOp:
725                        // variable result in an atomic operation sequence
726                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
727                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
728                        user_iy[user_i] = i_var;
729                        for(ell = 0; ell < q; ell++)
730                                user_ty[user_i * user_p1 + ell] = Taylor[ i_var * J + ell];
731                        user_i++;
732                        if( user_i == user_m )
733                                user_state = user_end;
734                        break;
735                        // -------------------------------------------------
736
737                        default:
738                        CPPAD_ASSERT_UNKNOWN(0);
739                }
740# if CPPAD_FORWARD_SWEEP_TRACE
741                size_t       i_tmp  = i_var;
742                Base*        Z_tmp  = Taylor + J * i_var;
743                printOp(
744                        std::cout, 
745                        Rec,
746                        i_tmp,
747                        op, 
748                        arg,
749                        p + 1, 
750                        Z_tmp, 
751                        0, 
752                        (Base *) CPPAD_NULL
753                );
754        }
755        std::cout << std::endl;
756# else
757        }
758# endif
759        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
760        CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
761
762        return compareCount;
763}
764
765// preprocessor symbols that are local to this file
766# undef CPPAD_FORWARD_SWEEP_TRACE
767# undef CPPAD_ATOMIC_CALL
768
769/*! \} */
770} // END_CPPAD_NAMESPACE
771# endif
Note: See TracBrowser for help on using the repository browser.