source: trunk/cppad/local/forward_sweep.hpp @ 2910

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

Remove CPPAD_BEGIN_NAMESPACE, CPPAD_END_NAMESPACE, and instead use

namespace CppAD { BEGIN_CPPAD_NAMESPACE
}
END_CPPAD_NAMESPACE

becasue doxygen 1.8.3 gets confused when using a macro for this purpose
(begining and ending the CppAD namespace without indenting code).

  • Property svn:keywords set to Id
File size: 19.5 KB
Line 
1/* $Id: forward_sweep.hpp 2910 2013-10-07 13:27:58Z 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\a return
123If \a p is not zero, the return value is zero.
124If \a p is zero,
125the return value is equal to the number of ComOp operations
126that have a different result from when the information in
127\a Rec was recorded.
128(Note that if NDEBUG is true, there are no ComOp operations
129in Rec and hence this return value is always zero.)
130*/
131
132template <class Base>
133size_t forward_sweep(
134        std::ostream&         s_out,
135        const bool            print,
136        const size_t          q,
137        const size_t          p,
138        const size_t          n,
139        const size_t          numvar,
140        player<Base>         *Rec,
141        const size_t         J,
142        Base                 *Taylor
143)
144{       CPPAD_ASSERT_UNKNOWN( J >= p + 1 );
145        CPPAD_ASSERT_UNKNOWN( q <= p );
146
147        // op code for current instruction
148        OpCode           op;
149
150        // index for current instruction
151        size_t         i_op;
152
153        // next variables
154        size_t        i_var;
155
156        // arg (not as a constant)
157        addr_t*         non_const_arg = CPPAD_NULL;
158
159        // arg (as a constant)
160        const addr_t*   arg = CPPAD_NULL;
161
162        // temporary indices
163        size_t i, ell;
164
165        // initialize the comparision operator (ComOp) counter
166        size_t compareCount = 0;
167
168        // if this is an order zero calculation, initialize vector indices
169        pod_vector<size_t> VectorInd;  // address for each element
170        pod_vector<bool>   VectorVar;  // is element a variable
171        i = Rec->num_rec_vecad_ind();
172        if( i > 0 )
173        {       VectorInd.extend(i);
174                VectorVar.extend(i);
175                while(i--)
176                {       VectorInd[i] = Rec->GetVecInd(i);
177                        VectorVar[i] = false;
178                }
179        }
180
181        // Work space used by UserOp. Note User assumes q = p.
182        const size_t user_p1 = p+1;  // number of orders for this user calculation
183        vector<bool> user_vx;        // empty vector
184        vector<bool> user_vy;        // empty vector
185        vector<Base> user_tx;        // argument vector Taylor coefficients
186        vector<Base> user_ty;        // result vector Taylor coefficients
187        vector<size_t> user_iy;      // variable indices for results vector
188        size_t user_index = 0;       // indentifier for this atomic operation
189        size_t user_id    = 0;       // user identifier for this call to operator
190        size_t user_i     = 0;       // index in result vector
191        size_t user_j     = 0;       // index in argument vector
192        size_t user_m     = 0;       // size of result vector
193        size_t user_n     = 0;       // size of arugment vector
194        //
195        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
196# ifndef NDEBUG
197        bool               user_ok   = false;      // atomic op return value
198# endif
199        //
200        // next expected operator in a UserOp sequence
201        enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
202
203        // check numvar argument
204        CPPAD_ASSERT_UNKNOWN( Rec->num_rec_var() == numvar );
205
206        // length of the parameter vector (used by CppAD assert macros)
207        const size_t num_par = Rec->num_rec_par();
208
209        // pointer to the beginning of the parameter vector
210        const Base* parameter = CPPAD_NULL;
211        if( num_par > 0 )
212                parameter = Rec->GetPar();
213
214        // length of the text vector (used by CppAD assert macros)
215        const size_t num_text = Rec->num_rec_text();
216
217        // pointer to the beginning of the text vector
218        const char* text = CPPAD_NULL;
219        if( num_text > 0 )
220                text = Rec->GetTxt(0);
221
222        // skip the BeginOp at the beginning of the recording
223        Rec->start_forward(op, arg, i_op, i_var);
224        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
225# if CPPAD_FORWARD_SWEEP_TRACE
226        std::cout << std::endl;
227# endif
228        while(op != EndOp)
229        {
230                // this op
231                Rec->next_forward(op, arg, i_op, i_var);
232                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
233                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
234
235                // action depends on the operator
236                switch( op )
237                {
238                        case AbsOp:
239                        forward_abs_op(q, p, i_var, arg[0], J, Taylor);
240                        break;
241                        // -------------------------------------------------
242
243                        case AddvvOp:
244                        forward_addvv_op(q, p, i_var, arg, parameter, J, Taylor);
245                        break;
246                        // -------------------------------------------------
247
248                        case AddpvOp:
249                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
250                        forward_addpv_op(q, p, i_var, arg, parameter, J, Taylor);
251                        break;
252                        // -------------------------------------------------
253
254                        case AcosOp:
255                        // sqrt(1 - x * x), acos(x)
256                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
257                        forward_acos_op(q, p, i_var, arg[0], J, Taylor);
258                        break;
259                        // -------------------------------------------------
260
261                        case AsinOp:
262                        // sqrt(1 - x * x), asin(x)
263                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
264                        forward_asin_op(q, p, i_var, arg[0], J, Taylor);
265                        break;
266                        // -------------------------------------------------
267
268                        case AtanOp:
269                        // 1 + x * x, atan(x)
270                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
271                        forward_atan_op(q, p, i_var, arg[0], J, Taylor);
272                        break;
273                        // -------------------------------------------------
274
275                        case CExpOp:
276                        forward_cond_op(
277                                q, p, i_var, arg, num_par, parameter, J, Taylor
278                        );
279                        break;
280                        // ---------------------------------------------------
281
282                        case ComOp:
283                        if( q == 0 ) forward_comp_op_0(
284                        compareCount, arg, num_par, parameter, J, Taylor
285                        );
286                        break;
287                        // ---------------------------------------------------
288
289                        case CosOp:
290                        // sin(x), cos(x)
291                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
292                        forward_cos_op(q, p, i_var, arg[0], J, Taylor);
293                        break;
294                        // ---------------------------------------------------
295
296                        case CoshOp:
297                        // sinh(x), cosh(x)
298                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
299                        forward_cosh_op(q, p, i_var, arg[0], J, Taylor);
300                        break;
301                        // -------------------------------------------------
302
303                        case CSumOp:
304                        // CSumOp has a variable number of arguments and
305                        // next_forward thinks it one has one argument.
306                        // we must inform next_forward of this special case.
307                        Rec->forward_csum(op, arg, i_op, i_var);
308                        forward_csum_op(
309                                q, p, i_var, arg, num_par, parameter, J, Taylor
310                        );
311                        break;
312                        // -------------------------------------------------
313
314                        case DisOp:
315                        i = q;
316                        if( i == 0 )
317                        {       forward_dis_op_0(i_var, arg, J, Taylor);
318                                i++;
319                        }
320                        while(i <= p)
321                        {       Taylor[ i_var * J + i] = Base(0);
322                                i++;
323                        }
324                        break;
325                        // -------------------------------------------------
326
327                        case DivvvOp:
328                        forward_divvv_op(q, p, i_var, arg, parameter, J, Taylor);
329                        break;
330                        // -------------------------------------------------
331
332                        case DivpvOp:
333                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
334                        forward_divpv_op(q, p, i_var, arg, parameter, J, Taylor);
335                        break;
336                        // -------------------------------------------------
337
338                        case DivvpOp:
339                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
340                        forward_divvp_op(q, p, i_var, arg, parameter, J, Taylor);
341                        break;
342                        // -------------------------------------------------
343
344                        case EndOp:
345                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
346                        break;
347                        // -------------------------------------------------
348
349                        case ExpOp:
350                        forward_exp_op(q, p, i_var, arg[0], J, Taylor);
351                        break;
352                        // -------------------------------------------------
353
354                        case InvOp:
355                        CPPAD_ASSERT_UNKNOWN( NumArg(op) == 0 );
356                        break;
357                        // -------------------------------------------------
358
359                        case LdpOp:
360                        if( q == 0 )
361                        {       non_const_arg = Rec->forward_non_const_arg();
362                                forward_load_p_op_0(
363                                        i_var, 
364                                        non_const_arg, 
365                                        num_par, 
366                                        parameter, 
367                                        J, 
368                                        Taylor,
369                                        Rec->num_rec_vecad_ind(),
370                                        VectorVar.data(),
371                                        VectorInd.data()
372                                );
373                                if( q < p )
374                                        forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
375                        }
376                        else
377                        {       forward_load_op( op, q, p, i_var, arg, J, Taylor);
378                        }
379                        break;
380                        // -------------------------------------------------
381
382                        case LdvOp:
383                        if( q == 0 )
384                        {       non_const_arg = Rec->forward_non_const_arg();
385                                forward_load_v_op_0(
386                                        i_var, 
387                                        non_const_arg, 
388                                        num_par, 
389                                        parameter, 
390                                        J, 
391                                        Taylor,
392                                        Rec->num_rec_vecad_ind(),
393                                        VectorVar.data(),
394                                        VectorInd.data()
395                                );
396                                if( q < p )
397                                        forward_load_op( op, q+1, p, i_var, arg, J, Taylor);
398                        }
399                        else
400                        {       forward_load_op( op, q, p, i_var, arg, J, Taylor);
401                        }
402                        break;
403                        // -------------------------------------------------
404
405                        case LogOp:
406                        forward_log_op(q, p, i_var, arg[0], J, Taylor);
407                        break;
408                        // -------------------------------------------------
409
410                        case MulvvOp:
411                        forward_mulvv_op(q, p, i_var, arg, parameter, J, Taylor);
412                        break;
413                        // -------------------------------------------------
414
415                        case MulpvOp:
416                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
417                        forward_mulpv_op(q, p, i_var, arg, parameter, J, Taylor);
418                        break;
419                        // -------------------------------------------------
420
421                        case ParOp:
422                        i = q;
423                        if( i == 0 )
424                        {       forward_par_op_0(
425                                        i_var, arg, num_par, parameter, J, Taylor
426                                );
427                                i++;
428                        }
429                        while(i <= p)
430                        {       Taylor[ i_var * J + i] = Base(0); 
431                                i++;
432                        }
433                        break;
434                        // -------------------------------------------------
435
436                        case PowvpOp:
437                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
438                        forward_powvp_op(q, p, i_var, arg, parameter, J, Taylor);
439                        break;
440                        // -------------------------------------------------
441
442                        case PowpvOp:
443                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
444                        forward_powpv_op(q, p, i_var, arg, parameter, J, Taylor);
445                        break;
446                        // -------------------------------------------------
447
448                        case PowvvOp:
449                        forward_powvv_op(q, p, i_var, arg, parameter, J, Taylor);
450                        break;
451                        // -------------------------------------------------
452
453                        case PriOp:
454                        if( (q == 0) & print ) forward_pri_0(s_out,
455                                i_var, arg, num_text, text, num_par, parameter, J, Taylor
456                        );
457                        break;
458                        // -------------------------------------------------
459
460                        case SignOp:
461                        // sign(x)
462                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
463                        forward_sign_op(q, p, i_var, arg[0], J, Taylor);
464                        break;
465                        // -------------------------------------------------
466
467                        case SinOp:
468                        // cos(x), sin(x)
469                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
470                        forward_sin_op(q, p, i_var, arg[0], J, Taylor);
471                        break;
472                        // -------------------------------------------------
473
474                        case SinhOp:
475                        // cosh(x), sinh(x)
476                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
477                        forward_sinh_op(q, p, i_var, arg[0], J, Taylor);
478                        break;
479                        // -------------------------------------------------
480
481                        case SqrtOp:
482                        forward_sqrt_op(q, p, i_var, arg[0], J, Taylor);
483                        break;
484                        // -------------------------------------------------
485
486                        case StppOp:
487                        if( q == 0 )
488                        {       forward_store_pp_op_0(
489                                        i_var, 
490                                        arg, 
491                                        num_par, 
492                                        J, 
493                                        Taylor,
494                                        Rec->num_rec_vecad_ind(),
495                                        VectorVar.data(),
496                                        VectorInd.data()
497                                );
498                        }
499                        break;
500                        // -------------------------------------------------
501
502                        case StpvOp:
503                        if( q == 0 )
504                        {       forward_store_pv_op_0(
505                                        i_var, 
506                                        arg, 
507                                        num_par, 
508                                        J, 
509                                        Taylor,
510                                        Rec->num_rec_vecad_ind(),
511                                        VectorVar.data(),
512                                        VectorInd.data()
513                                );
514                        }
515                        break;
516                        // -------------------------------------------------
517
518                        case StvpOp:
519                        if( q == 0 )
520                        {       forward_store_vp_op_0(
521                                        i_var, 
522                                        arg, 
523                                        num_par, 
524                                        J, 
525                                        Taylor,
526                                        Rec->num_rec_vecad_ind(),
527                                        VectorVar.data(),
528                                        VectorInd.data()
529                                );
530                        }
531                        break;
532                        // -------------------------------------------------
533
534                        case StvvOp:
535                        if( q == 0 )
536                        {       forward_store_vv_op_0(
537                                        i_var, 
538                                        arg, 
539                                        num_par, 
540                                        J, 
541                                        Taylor,
542                                        Rec->num_rec_vecad_ind(),
543                                        VectorVar.data(),
544                                        VectorInd.data()
545                                );
546                        }
547                        break;
548                        // -------------------------------------------------
549
550                        case SubvvOp:
551                        forward_subvv_op(q, p, 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(q, p, 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(q, p, 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(q, p, 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(q, p, 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 * user_p1)
600                                        user_tx.resize(user_n * user_p1);
601                                if(user_ty.size() != user_m * user_p1)
602                                        user_ty.resize(user_m * user_p1);
603                                if(user_iy.size() != user_m)
604                                        user_iy.resize(user_m);
605                                user_j     = 0;
606                                user_i     = 0;
607                                user_state = user_arg;
608                        }
609                        else
610                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
611                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
612                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
613                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
614                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
615
616                                // call users function for this operation
617                                user_atom->set_id(user_id);
618                                CPPAD_ATOMIC_CALL(
619                                        q, p, user_vx, user_vy, user_tx, user_ty
620                                );
621# ifndef NDEBUG
622                                if( ! user_ok )
623                                {       std::string msg = 
624                                                atomic_base<Base>::class_name(user_index)
625                                                + ": atomic_base.forward: returned false";
626                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
627                                }
628# endif
629                                for(i = 0; i < user_m; i++) 
630                                        if( user_iy[i] > 0 )
631                                                for(ell = q; ell <= p; ell++)
632                                                        Taylor[ user_iy[i] * J + ell ] = 
633                                                                user_ty[ i * user_p1 + ell ];
634
635                                user_state = user_start;
636                        }
637                        break;
638
639                        case UsrapOp:
640                        // parameter argument in an atomic operation sequence
641                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
642                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
643                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
644                        user_tx[user_j * user_p1 + 0] = parameter[ arg[0]];
645                        for(ell = 1; ell < user_p1; ell++)
646                                user_tx[user_j * user_p1 + ell] = Base(0);
647                        ++user_j;
648                        if( user_j == user_n )
649                                user_state = user_ret;
650                        break;
651
652                        case UsravOp:
653                        // variable argument in an atomic operation sequence
654                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
655                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
656                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
657                        for(ell = 0; ell < user_p1; ell++)
658                                user_tx[user_j * user_p1 + ell] = Taylor[ arg[0] * J + ell];
659                        ++user_j;
660                        if( user_j == user_n )
661                                user_state = user_ret;
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                        user_iy[user_i] = 0;
669                        user_ty[user_i * user_p1 + 0] = parameter[ arg[0]];
670                        for(ell = 1; ell < q; ell++)
671                                user_ty[user_i * user_p1 + ell] = Base(0);
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                        user_iy[user_i] = i_var;
682                        for(ell = 0; ell < q; ell++)
683                                user_ty[user_i * user_p1 + ell] = Taylor[ i_var * J + ell];
684                        user_i++;
685                        if( user_i == user_m )
686                                user_state = user_end;
687                        break;
688                        // -------------------------------------------------
689
690                        default:
691                        CPPAD_ASSERT_UNKNOWN(0);
692                }
693# if CPPAD_FORWARD_SWEEP_TRACE
694                size_t       i_tmp  = i_var;
695                Base*        Z_tmp  = Taylor + J * i_var;
696                printOp(
697                        std::cout, 
698                        Rec,
699                        i_tmp,
700                        op, 
701                        arg,
702                        p + 1, 
703                        Z_tmp, 
704                        0, 
705                        (Base *) CPPAD_NULL
706                );
707        }
708        std::cout << std::endl;
709# else
710        }
711# endif
712        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
713        CPPAD_ASSERT_UNKNOWN( i_var + 1 == Rec->num_rec_var() );
714
715        return compareCount;
716}
717
718// preprocessor symbols that are local to this file
719# undef CPPAD_FORWARD_SWEEP_TRACE
720# undef CPPAD_ATOMIC_CALL
721
722/*! \} */
723} // END_CPPAD_NAMESPACE
724# endif
Note: See TracBrowser for help on using the repository browser.