source: branches/cache/cppad/local/forward1sweep.hpp @ 3341

Last change on this file since 3341 was 3341, checked in by bradbell, 6 years ago
  1. Add num_var and cache2var to cppad_assert_arg_before_result.
  2. In sweeps, change numvar to num_var.

forward2sweep.hpp: remove extra asserts (arg_before_result cases).

  • Property svn:keywords set to Id
File size: 22.0 KB
Line 
1/* $Id: forward1sweep.hpp 3341 2014-09-19 11:47:30Z bradbell $ */
2# ifndef CPPAD_FORWARD1SWEEP_INCLUDED
3# define CPPAD_FORWARD1SWEEP_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 forward1sweep.hpp
19Compute one Taylor coefficient for each order requested.
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 macro is undefined at the end of this file to facillitate its
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_FORWARD1SWEEP_TRACE
44This value is either zero or one.
45Zero is the normal operational value.
46If it is one, a trace of every forward1sweep computation is printed.
47*/
48# define CPPAD_FORWARD1SWEEP_TRACE 0
49
50/*!
51Compute arbitrary order forward mode Taylor coefficients.
52
53<!-- replace forward0sweep_doc_define -->
54\tparam Base
55The type used during the forward mode computations; i.e., the corresponding
56recording of operations used the type AD<Base>.
57
58\param s_out
59Is the stream where output corresponding to PriOp operations will
60be written.
61
62\param print
63If print is false,
64suppress the output that is otherwise generated by the c PriOp instructions.
65
66\param n
67is the number of independent variables on the tape.
68
69\param num_var
70is the total number of variables on the tape.
71This is also equal to the number of rows in the matrix taylor; i.e.,
72play->num_var_rec().
73
74\param play
75The information stored in play
76is a recording of the operations corresponding to the function
77\f[
78        F : {\bf R}^n \rightarrow {\bf R}^m
79\f]
80where \f$ n \f$ is the number of independent variables and
81\f$ m \f$ is the number of dependent variables.
82\n
83\n
84The object play is effectly constant.
85The exception to this is that while palying back the tape
86the object play holds information about the current location
87with in the tape and this changes during palyback.
88
89\param J
90Is the number of columns in the coefficient matrix taylor.
91This must be greater than or equal one.
92
93<!-- end forward0sweep_doc_define -->
94
95\param cskip_op
96Is a vector with size play->num_op_rec().
97\n
98\n
99<tt>p = 0</tt>
100\n
101In this case,
102the input value of the elements does not matter.
103Upon return, if cskip_op[i] is true, the operator with index i
104does not affect any of the dependent variable
105(given the value of the independent variables).
106\n
107\n
108<tt>p > 0</tt>
109\n
110In this case cskip_op is not modified and has the same meaning
111as its return value above.
112
113\param var_by_load_op
114is a vector with size play->num_load_op_rec().
115\n
116\n
117<tt>p == 0</tt>
118\n
119In this case,
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\n
127\n
128<tt>p > 0</tt>
129\n
130In this case var_by_load_op is not modified and has the meaning
131as its return value above.
132
133\param p
134is the lowest order of the Taylor coefficients
135that are computed during this call.
136
137\param q
138is the highest order of the Taylor coefficients
139that are computed during this call.
140
141\param taylor
142\n
143\b Input:
144For <code>i = 1 , ... , num_var-1</code>,
145<code>k = 0 , ... , p-1</code>,
146<code>taylor[ J*i + k]</code>
147is the k-th order Taylor coefficient corresponding to
148the i-th variable.
149\n
150\n
151\b Input:
152For <code>i = 1 , ... , n</code>,
153<code>k = p , ... , q</code>,
154<code>taylor[ J*j + k]</code>
155is the k-th order Taylor coefficient corresponding to
156the i-th variable
157(these are the independent varaibles).
158\n
159\n
160\b Output:
161For <code>i = n+1 , ... , num_var-1</code>, and
162<code>k = 0 , ... , p-1</code>,
163<code>taylor[ J*i + k]</code>
164is the k-th order Taylor coefficient corresponding to
165the i-th variable.
166
167\return
168If p is not zero, the return value is zero.
169If p is zero,
170the return value is equal to the number of ComOp operations
171that have a different result from when the information in
172a play was recorded.
173(Note that if NDEBUG is true, there are no ComOp operations
174in play and hence this return value is always zero.)
175*/
176
177template <class Base>
178size_t forward1sweep(
179        std::ostream&         s_out,
180        const bool            print,
181        const size_t          p,
182        const size_t          q,
183        const size_t          n,
184        const size_t          num_var,
185        player<Base>*         play,
186        const size_t          J,
187        Base*                 taylor,
188        bool*                 cskip_op,
189        pod_vector<addr_t>&   var_by_load_op
190)
191{
192        // number of directions
193        const size_t r = 1;
194
195        CPPAD_ASSERT_UNKNOWN( p <= q );
196        CPPAD_ASSERT_UNKNOWN( J >= q + 1 );
197        CPPAD_ASSERT_UNKNOWN( play->num_var_rec() == num_var );
198
199        /*
200        <!-- replace forward0sweep_code_define -->
201        */
202        // op code for current instruction
203        OpCode op;
204
205        // index for current instruction
206        size_t i_op;
207
208        // next variables
209        size_t i_var;
210
211        // operation argument indices
212        const addr_t*   arg = CPPAD_NULL;
213
214        // initialize the comparision operator (ComOp) counter
215        size_t compareCount = 0;
216
217        // If this includes a zero calculation, initialize this information
218        pod_vector<bool>   isvar_by_ind;
219        pod_vector<size_t> index_by_ind;
220        if( p == 0 )
221        {       size_t i;
222
223                // this includes order zero calculation, initialize vector indices
224                size_t num = play->num_vec_ind_rec();
225                if( num > 0 )
226                {       isvar_by_ind.extend(num);
227                        index_by_ind.extend(num);
228                        for(i = 0; i < num; i++)
229                        {       index_by_ind[i] = play->GetVecInd(i);
230                                isvar_by_ind[i] = false;
231                        }
232                }
233                // includes zero order, so initialize conditional skip flags
234                num = play->num_op_rec();
235                for(i = 0; i < num; i++)
236                        cskip_op[i] = false;
237        }
238
239        // work space used by UserOp.
240        vector<bool> user_vx;        // empty vecotor
241        vector<bool> user_vy;        // empty vecotor
242        vector<Base> user_tx;        // argument vector Taylor coefficients
243        vector<Base> user_ty;        // result vector Taylor coefficients
244        size_t user_index = 0;       // indentifier for this atomic operation
245        size_t user_id    = 0;       // user identifier for this call to operator
246        size_t user_i     = 0;       // index in result vector
247        size_t user_j     = 0;       // index in argument vector
248        size_t user_m     = 0;       // size of result vector
249        size_t user_n     = 0;       // size of arugment vector
250        //
251        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
252# ifndef NDEBUG
253        bool               user_ok   = false;      // atomic op return value
254# endif
255        //
256        // next expected operator in a UserOp sequence
257        enum { user_start, user_arg, user_ret, user_end, user_trace }
258        user_state = user_start;
259
260        // length of the parameter vector (used by CppAD assert macros)
261        const size_t num_par = play->num_par_rec();
262
263        // pointer to the beginning of the parameter vector
264        const Base* parameter = CPPAD_NULL;
265        if( num_par > 0 )
266                parameter = play->GetPar();
267
268        // length of the text vector (used by CppAD assert macros)
269        const size_t num_text = play->num_text_rec();
270
271        // pointer to the beginning of the text vector
272        const char* text = CPPAD_NULL;
273        if( num_text > 0 )
274                text = play->GetTxt(0);
275        /*
276        <!-- end forward0sweep_code_define -->
277        */
278        // temporary indices
279        size_t i, k;
280
281        // number of orders for this user calculation
282        // (not needed for order zero)
283        const size_t user_q1 = q+1;
284
285        // variable indices for results vector
286        // (done differently for order zero).
287        vector<size_t> user_iy;     
288
289        // skip the BeginOp at the beginning of the recording
290        play->forward_start(op, arg, i_op, i_var);
291        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
292# if CPPAD_FORWARD1SWEEP_TRACE
293        std::cout << std::endl;
294# endif
295# ifndef NDEBUG
296        // 2DO: implement tracing cache
297        CppAD::vector<addr_t> cache2var;
298# endif
299        bool more_operators = true;
300        while(more_operators)
301        {
302                // this op
303                play->forward_next(op, arg, i_op, i_var);
304
305                // check if we are skipping this operation
306                while( cskip_op[i_op] )
307                {       if( op == CSumOp )
308                        {       // CSumOp has a variable number of arguments
309                                play->forward_csum(op, arg, i_op, i_var);
310                        }
311                        play->forward_next(op, arg, i_op, i_var);
312                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
313                }
314                CPPAD_ASSERT_UNKNOWN( i_var < num_var );
315                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
316                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
317                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
318                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, num_var, cache2var, i_var);
319
320                // action depends on the operator
321                switch( op )
322                {
323                        case AbsOp:
324                        forward_abs_op(p, q, i_var, arg[0], J, taylor);
325                        break;
326                        // -------------------------------------------------
327
328                        case AddvvOp:
329                        forward_addvv_op(p, q, i_var, arg, parameter, J, taylor);
330                        break;
331                        // -------------------------------------------------
332
333                        case AddpvOp:
334                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
335                        forward_addpv_op(p, q, i_var, arg, parameter, J, taylor);
336                        break;
337                        // -------------------------------------------------
338
339                        case AcosOp:
340                        // sqrt(1 - x * x), acos(x)
341                        forward_acos_op(p, q, i_var, arg[0], J, taylor);
342                        break;
343                        // -------------------------------------------------
344
345                        case AsinOp:
346                        // sqrt(1 - x * x), asin(x)
347                        forward_asin_op(p, q, i_var, arg[0], J, taylor);
348                        break;
349                        // -------------------------------------------------
350
351                        case AtanOp:
352                        // 1 + x * x, atan(x)
353                        forward_atan_op(p, q, i_var, arg[0], J, taylor);
354                        break;
355                        // -------------------------------------------------
356
357                        case CExpOp:
358                        forward_cond_op(
359                                p, q, i_var, arg, num_par, parameter, J, taylor
360                        );
361                        break;
362                        // ---------------------------------------------------
363
364                        case ComOp:
365                        if( p == 0 ) forward_comp_op_0(
366                        compareCount, arg, num_par, parameter, J, taylor
367                        );
368                        break;
369                        // ---------------------------------------------------
370
371                        case CosOp:
372                        // sin(x), cos(x)
373                        forward_cos_op(p, q, i_var, arg[0], J, taylor);
374                        break;
375                        // ---------------------------------------------------
376
377                        case CoshOp:
378                        // sinh(x), cosh(x)
379                        forward_cosh_op(p, q, i_var, arg[0], J, taylor);
380                        break;
381                        // -------------------------------------------------
382
383                        case CSkipOp:
384                        // CSkipOp has a variable number of arguments and
385                        // forward_next thinks it has no arguments.
386                        // we must inform forward_next of this special case.
387                        if( p == 0 )
388                        {       forward_cskip_op_0(
389                                        i_var, arg, num_par, parameter, J, taylor, cskip_op
390                                );
391                        }
392                        play->forward_cskip(op, arg, i_op, i_var);
393                        break;
394                        // -------------------------------------------------
395
396                        case CSumOp:
397                        // CSumOp has a variable number of arguments and
398                        // forward_next thinks it has no arguments.
399                        // we must inform forward_next of this special case.
400                        forward_csum_op(
401                                p, q, i_var, arg, num_par, parameter, J, taylor
402                        );
403                        play->forward_csum(op, arg, i_op, i_var);
404                        break;
405                        // -------------------------------------------------
406
407                        case DisOp:
408                        forward_dis_op(p, q, r, i_var, arg, J, taylor);
409                        break;
410                        // -------------------------------------------------
411
412                        case DivvvOp:
413                        forward_divvv_op(p, q, i_var, arg, parameter, J, taylor);
414                        break;
415                        // -------------------------------------------------
416
417                        case DivpvOp:
418                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
419                        forward_divpv_op(p, q, i_var, arg, parameter, J, taylor);
420                        break;
421                        // -------------------------------------------------
422
423                        case DivvpOp:
424                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
425                        forward_divvp_op(p, q, i_var, arg, parameter, J, taylor);
426                        break;
427                        // -------------------------------------------------
428
429                        case EndOp:
430                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
431                        more_operators = false;
432                        break;
433                        // -------------------------------------------------
434
435                        case ExpOp:
436                        forward_exp_op(p, q, i_var, arg[0], J, taylor);
437                        break;
438                        // -------------------------------------------------
439
440                        case InvOp:
441                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
442                        break;
443                        // -------------------------------------------------
444
445                        case LdpOp:
446                        if( p == 0 )
447                        {       forward_load_p_op_0(
448                                        play,
449                                        i_var, 
450                                        arg, 
451                                        parameter, 
452                                        J, 
453                                        taylor,
454                                        isvar_by_ind.data(),
455                                        index_by_ind.data(),
456                                        var_by_load_op.data()
457                                );
458                                if( p < q ) forward_load_op( 
459                                        play,
460                                        op,
461                                        p+1,
462                                        q,
463                                        r,
464                                        J,
465                                        i_var,
466                                        arg,
467                                        var_by_load_op.data(),
468                                        taylor
469                                );
470                        }
471                        else    forward_load_op( 
472                                play,
473                                op,
474                                p,
475                                q,
476                                r,
477                                J,
478                                i_var,
479                                arg,
480                                var_by_load_op.data(),
481                                taylor
482                        );
483                        break;
484                        // -------------------------------------------------
485
486                        case LdvOp:
487                        if( p == 0 )
488                        {       forward_load_v_op_0(
489                                        play,
490                                        i_var, 
491                                        arg, 
492                                        parameter, 
493                                        J, 
494                                        taylor,
495                                        isvar_by_ind.data(),
496                                        index_by_ind.data(),
497                                        var_by_load_op.data()
498                                );
499                                if( p < q ) forward_load_op( 
500                                        play,
501                                        op,
502                                        p+1,
503                                        q,
504                                        r,
505                                        J,
506                                        i_var,
507                                        arg,
508                                        var_by_load_op.data(),
509                                        taylor
510                                );
511                        }
512                        else    forward_load_op( 
513                                play,
514                                op,
515                                p,
516                                q,
517                                r,
518                                J,
519                                i_var,
520                                arg,
521                                var_by_load_op.data(),
522                                taylor
523                        );
524                        break;
525                        // -------------------------------------------------
526
527                        case LogOp:
528                        forward_log_op(p, q, i_var, arg[0], J, taylor);
529                        break;
530                        // -------------------------------------------------
531
532                        case MulvvOp:
533                        forward_mulvv_op(p, q, i_var, arg, parameter, J, taylor);
534                        break;
535                        // -------------------------------------------------
536
537                        case MulpvOp:
538                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
539                        forward_mulpv_op(p, q, i_var, arg, parameter, J, taylor);
540                        break;
541                        // -------------------------------------------------
542
543                        case ParOp:
544                        i = p;
545                        if( i == 0 )
546                        {       forward_par_op_0(
547                                        i_var, arg, num_par, parameter, J, taylor
548                                );
549                                i++;
550                        }
551                        while(i <= q)
552                        {       taylor[ i_var * J + i] = Base(0); 
553                                i++;
554                        }
555                        break;
556                        // -------------------------------------------------
557
558                        case PowvpOp:
559                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
560                        forward_powvp_op(p, q, i_var, arg, parameter, J, taylor);
561                        break;
562                        // -------------------------------------------------
563
564                        case PowpvOp:
565                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
566                        forward_powpv_op(p, q, i_var, arg, parameter, J, taylor);
567                        break;
568                        // -------------------------------------------------
569
570                        case PowvvOp:
571                        forward_powvv_op(p, q, i_var, arg, parameter, J, taylor);
572                        break;
573                        // -------------------------------------------------
574
575                        case PriOp:
576                        if( (p == 0) & print ) forward_pri_0(s_out,
577                                arg, num_text, text, num_par, parameter, J, taylor
578                        );
579                        break;
580                        // -------------------------------------------------
581
582                        case SignOp:
583                        // sign(x)
584                        forward_sign_op(p, q, i_var, arg[0], J, taylor);
585                        break;
586                        // -------------------------------------------------
587
588                        case SinOp:
589                        // cos(x), sin(x)
590                        forward_sin_op(p, q, i_var, arg[0], J, taylor);
591                        break;
592                        // -------------------------------------------------
593
594                        case SinhOp:
595                        // cosh(x), sinh(x)
596                        forward_sinh_op(p, q, i_var, arg[0], J, taylor);
597                        break;
598                        // -------------------------------------------------
599
600                        case SqrtOp:
601                        forward_sqrt_op(p, q, i_var, arg[0], J, taylor);
602                        break;
603                        // -------------------------------------------------
604
605                        case StppOp:
606                        if( p == 0 )
607                        {       forward_store_pp_op_0(
608                                        i_var, 
609                                        arg, 
610                                        num_par, 
611                                        J, 
612                                        taylor,
613                                        isvar_by_ind.data(),
614                                        index_by_ind.data()
615                                );
616                        }
617                        break;
618                        // -------------------------------------------------
619
620                        case StpvOp:
621                        if( p == 0 )
622                        {       forward_store_pv_op_0(
623                                        i_var, 
624                                        arg, 
625                                        num_par, 
626                                        J, 
627                                        taylor,
628                                        isvar_by_ind.data(),
629                                        index_by_ind.data()
630                                );
631                        }
632                        break;
633                        // -------------------------------------------------
634
635                        case StvpOp:
636                        if( p == 0 )
637                        {       forward_store_vp_op_0(
638                                        i_var, 
639                                        arg, 
640                                        num_par, 
641                                        J, 
642                                        taylor,
643                                        isvar_by_ind.data(),
644                                        index_by_ind.data()
645                                );
646                        }
647                        break;
648                        // -------------------------------------------------
649
650                        case StvvOp:
651                        if( p == 0 )
652                        {       forward_store_vv_op_0(
653                                        i_var, 
654                                        arg, 
655                                        num_par, 
656                                        J, 
657                                        taylor,
658                                        isvar_by_ind.data(),
659                                        index_by_ind.data()
660                                );
661                        }
662                        break;
663                        // -------------------------------------------------
664
665                        case SubvvOp:
666                        forward_subvv_op(p, q, i_var, arg, parameter, J, taylor);
667                        break;
668                        // -------------------------------------------------
669
670                        case SubpvOp:
671                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
672                        forward_subpv_op(p, q, i_var, arg, parameter, J, taylor);
673                        break;
674                        // -------------------------------------------------
675
676                        case SubvpOp:
677                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
678                        forward_subvp_op(p, q, i_var, arg, parameter, J, taylor);
679                        break;
680                        // -------------------------------------------------
681
682                        case TanOp:
683                        // tan(x)^2, tan(x)
684                        forward_tan_op(p, q, i_var, arg[0], J, taylor);
685                        break;
686                        // -------------------------------------------------
687
688                        case TanhOp:
689                        // tanh(x)^2, tanh(x)
690                        forward_tanh_op(p, q, i_var, arg[0], J, taylor);
691                        break;
692                        // -------------------------------------------------
693
694                        case UserOp:
695                        // start or end an atomic operation sequence
696                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
697                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
698                        if( user_state == user_start )
699                        {       user_index = arg[0];
700                                user_id    = arg[1];
701                                user_n     = arg[2];
702                                user_m     = arg[3];
703                                user_atom  = atomic_base<Base>::class_object(user_index);
704# ifndef NDEBUG
705                                if( user_atom == CPPAD_NULL )
706                                {       std::string msg = 
707                                                atomic_base<Base>::class_name(user_index)
708                                                + ": atomic_base function has been deleted";
709                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
710                                }
711# endif
712                                if(user_tx.size() != user_n * user_q1)
713                                        user_tx.resize(user_n * user_q1);
714                                if(user_ty.size() != user_m * user_q1)
715                                        user_ty.resize(user_m * user_q1);
716                                if(user_iy.size() != user_m)
717                                        user_iy.resize(user_m);
718                                user_j     = 0;
719                                user_i     = 0;
720                                user_state = user_arg;
721                        }
722                        else
723                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
724                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
725                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
726                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
727                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
728
729                                // call users function for this operation
730                                user_atom->set_id(user_id);
731                                CPPAD_ATOMIC_CALL(
732                                        p, q, user_vx, user_vy, user_tx, user_ty
733                                );
734# ifndef NDEBUG
735                                if( ! user_ok )
736                                {       std::string msg = 
737                                                atomic_base<Base>::class_name(user_index)
738                                                + ": atomic_base.forward: returned false";
739                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
740                                }
741# endif
742                                for(i = 0; i < user_m; i++) 
743                                        if( user_iy[i] > 0 )
744                                                for(k = p; k <= q; k++)
745                                                        taylor[ user_iy[i] * J + k ] = 
746                                                                user_ty[ i * user_q1 + k ];
747# if CPPAD_FORWARD1SWEEP_TRACE
748                                user_state = user_trace;
749# else
750                                user_state = user_start;
751# endif
752                        }
753                        break;
754
755                        case UsrapOp:
756                        // parameter argument in an atomic operation sequence
757                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
758                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
759                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
760                        user_tx[user_j * user_q1 + 0] = parameter[ arg[0]];
761                        for(k = 1; k < user_q1; k++)
762                                user_tx[user_j * user_q1 + k] = Base(0);
763                        ++user_j;
764                        if( user_j == user_n )
765                                user_state = user_ret;
766                        break;
767
768                        case UsravOp:
769                        // variable argument in an atomic operation sequence
770                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
771                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
772                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
773                        for(k = 0; k < user_q1; k++)
774                                user_tx[user_j * user_q1 + k] = taylor[ arg[0] * J + k];
775                        ++user_j;
776                        if( user_j == user_n )
777                                user_state = user_ret;
778                        break;
779
780                        case UsrrpOp:
781                        // parameter result in an atomic operation sequence
782                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
783                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
784                        user_iy[user_i] = 0;
785                        user_ty[user_i * user_q1 + 0] = parameter[ arg[0]];
786                        for(k = 1; k < p; k++)
787                                user_ty[user_i * user_q1 + k] = Base(0);
788                        user_i++;
789                        if( user_i == user_m )
790                                user_state = user_end;
791                        break;
792
793                        case UsrrvOp:
794                        // variable result in an atomic operation sequence
795                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
796                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
797                        user_iy[user_i] = i_var;
798                        for(k = 0; k < p; k++)
799                                user_ty[user_i * user_q1 + k] = taylor[ i_var * J + k];
800                        user_i++;
801                        if( user_i == user_m )
802                                user_state = user_end;
803                        break;
804                        // -------------------------------------------------
805
806                        default:
807                        CPPAD_ASSERT_UNKNOWN(0);
808                }
809# if CPPAD_FORWARD1SWEEP_TRACE
810                if( user_state == user_trace )
811                {       user_state = user_start;
812
813                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
814                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
815                        for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
816                        {       size_t i_tmp   = (i_op + i) - user_m;
817                                printOp(
818                                        std::cout, 
819                                        play,
820                                        i_tmp,
821                                        user_iy[i],
822                                        UsrrvOp, 
823                                        CPPAD_NULL,
824                                        cache2var
825                                );
826                                Base* Z_tmp = taylor + user_iy[i] * J;
827                                printOpResult(
828                                        std::cout, 
829                                        q + 1, 
830                                        Z_tmp,
831                                        0, 
832                                        (Base *) CPPAD_NULL
833                                );
834                                std::cout << std::endl;
835                        }
836                }
837                Base*           Z_tmp   = taylor + J * i_var;
838                const addr_t*   arg_tmp = arg;
839                if( op == CSumOp )
840                        arg_tmp = arg - arg[-1] - 4;
841                if( op == CSkipOp )
842                        arg_tmp = arg - arg[-1] - 7;
843                if( op != UsrrvOp )
844                {
845                        printOp(
846                                std::cout, 
847                                play,
848                                i_op,
849                                i_var,
850                                op, 
851                                arg_tmp,
852                                cache2var
853                        );
854                        if( NumRes(op) > 0 ) printOpResult(
855                                std::cout, 
856                                q + 1, 
857                                Z_tmp, 
858                                0, 
859                                (Base *) CPPAD_NULL
860                        );
861                        std::cout << std::endl;
862                }
863        }
864        std::cout << std::endl;
865# else
866        }
867# endif
868        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
869        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
870
871        return compareCount;
872}
873
874// preprocessor symbols that are local to this file
875# undef CPPAD_FORWARD1SWEEP_TRACE
876# undef CPPAD_ATOMIC_CALL
877
878} // END_CPPAD_NAMESPACE
879# endif
Note: See TracBrowser for help on using the repository browser.