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

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

these warnings, so supress then in these cases.

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

CPPAD_ASSERT_ARG_BEFORE_RESULT (only one argument case so far).

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

  • Property svn:keywords set to Id
File size: 22.3 KB
Line 
1/* $Id: forward1sweep.hpp 3320 2014-09-11 23:06:21Z 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 numvar
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 , ... , numvar-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 , ... , numvar-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          numvar,
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() == numvar );
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        bool more_operators = true;
296        while(more_operators)
297        {
298                // this op
299                play->forward_next(op, arg, i_op, i_var);
300                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
301                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
302                CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
303                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, 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
315                // action depends on the operator
316                switch( op )
317                {
318                        case AbsOp:
319                        forward_abs_op(p, q, i_var, arg[0], J, taylor);
320                        break;
321                        // -------------------------------------------------
322
323                        case AddvvOp:
324                        forward_addvv_op(p, q, i_var, arg, parameter, J, taylor);
325                        break;
326                        // -------------------------------------------------
327
328                        case AddpvOp:
329                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
330                        forward_addpv_op(p, q, i_var, arg, parameter, J, taylor);
331                        break;
332                        // -------------------------------------------------
333
334                        case AcosOp:
335                        // sqrt(1 - x * x), acos(x)
336                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
337                        forward_acos_op(p, q, i_var, arg[0], J, taylor);
338                        break;
339                        // -------------------------------------------------
340
341                        case AsinOp:
342                        // sqrt(1 - x * x), asin(x)
343                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
344                        forward_asin_op(p, q, i_var, arg[0], J, taylor);
345                        break;
346                        // -------------------------------------------------
347
348                        case AtanOp:
349                        // 1 + x * x, atan(x)
350                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
351                        forward_atan_op(p, q, i_var, arg[0], J, taylor);
352                        break;
353                        // -------------------------------------------------
354
355                        case CExpOp:
356                        forward_cond_op(
357                                p, q, i_var, arg, num_par, parameter, J, taylor
358                        );
359                        break;
360                        // ---------------------------------------------------
361
362                        case ComOp:
363                        if( p == 0 ) forward_comp_op_0(
364                        compareCount, arg, num_par, parameter, J, taylor
365                        );
366                        break;
367                        // ---------------------------------------------------
368
369                        case CosOp:
370                        // sin(x), cos(x)
371                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
372                        forward_cos_op(p, q, i_var, arg[0], J, taylor);
373                        break;
374                        // ---------------------------------------------------
375
376                        case CoshOp:
377                        // sinh(x), cosh(x)
378                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
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, 0);
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                                i_var, arg, num_text, text, num_par, parameter, J, taylor
578                        );
579                        break;
580                        // -------------------------------------------------
581
582                        case SignOp:
583                        // sign(x)
584                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
585                        forward_sign_op(p, q, i_var, arg[0], J, taylor);
586                        break;
587                        // -------------------------------------------------
588
589                        case SinOp:
590                        // cos(x), sin(x)
591                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
592                        forward_sin_op(p, q, i_var, arg[0], J, taylor);
593                        break;
594                        // -------------------------------------------------
595
596                        case SinhOp:
597                        // cosh(x), sinh(x)
598                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
599                        forward_sinh_op(p, q, i_var, arg[0], J, taylor);
600                        break;
601                        // -------------------------------------------------
602
603                        case SqrtOp:
604                        forward_sqrt_op(p, q, i_var, arg[0], J, taylor);
605                        break;
606                        // -------------------------------------------------
607
608                        case StppOp:
609                        if( p == 0 )
610                        {       forward_store_pp_op_0(
611                                        i_var, 
612                                        arg, 
613                                        num_par, 
614                                        J, 
615                                        taylor,
616                                        isvar_by_ind.data(),
617                                        index_by_ind.data()
618                                );
619                        }
620                        break;
621                        // -------------------------------------------------
622
623                        case StpvOp:
624                        if( p == 0 )
625                        {       forward_store_pv_op_0(
626                                        i_var, 
627                                        arg, 
628                                        num_par, 
629                                        J, 
630                                        taylor,
631                                        isvar_by_ind.data(),
632                                        index_by_ind.data()
633                                );
634                        }
635                        break;
636                        // -------------------------------------------------
637
638                        case StvpOp:
639                        if( p == 0 )
640                        {       forward_store_vp_op_0(
641                                        i_var, 
642                                        arg, 
643                                        num_par, 
644                                        J, 
645                                        taylor,
646                                        isvar_by_ind.data(),
647                                        index_by_ind.data()
648                                );
649                        }
650                        break;
651                        // -------------------------------------------------
652
653                        case StvvOp:
654                        if( p == 0 )
655                        {       forward_store_vv_op_0(
656                                        i_var, 
657                                        arg, 
658                                        num_par, 
659                                        J, 
660                                        taylor,
661                                        isvar_by_ind.data(),
662                                        index_by_ind.data()
663                                );
664                        }
665                        break;
666                        // -------------------------------------------------
667
668                        case SubvvOp:
669                        forward_subvv_op(p, q, i_var, arg, parameter, J, taylor);
670                        break;
671                        // -------------------------------------------------
672
673                        case SubpvOp:
674                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
675                        forward_subpv_op(p, q, i_var, arg, parameter, J, taylor);
676                        break;
677                        // -------------------------------------------------
678
679                        case SubvpOp:
680                        CPPAD_ASSERT_UNKNOWN( size_t(arg[1]) < num_par );
681                        forward_subvp_op(p, q, i_var, arg, parameter, J, taylor);
682                        break;
683                        // -------------------------------------------------
684
685                        case TanOp:
686                        // tan(x)^2, tan(x)
687                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
688                        forward_tan_op(p, q, i_var, arg[0], J, taylor);
689                        break;
690                        // -------------------------------------------------
691
692                        case TanhOp:
693                        // tanh(x)^2, tanh(x)
694                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
695                        forward_tanh_op(p, q, i_var, arg[0], J, taylor);
696                        break;
697                        // -------------------------------------------------
698
699                        case UserOp:
700                        // start or end an atomic operation sequence
701                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
702                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
703                        if( user_state == user_start )
704                        {       user_index = arg[0];
705                                user_id    = arg[1];
706                                user_n     = arg[2];
707                                user_m     = arg[3];
708                                user_atom  = atomic_base<Base>::class_object(user_index);
709# ifndef NDEBUG
710                                if( user_atom == CPPAD_NULL )
711                                {       std::string msg = 
712                                                atomic_base<Base>::class_name(user_index)
713                                                + ": atomic_base function has been deleted";
714                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
715                                }
716# endif
717                                if(user_tx.size() != user_n * user_q1)
718                                        user_tx.resize(user_n * user_q1);
719                                if(user_ty.size() != user_m * user_q1)
720                                        user_ty.resize(user_m * user_q1);
721                                if(user_iy.size() != user_m)
722                                        user_iy.resize(user_m);
723                                user_j     = 0;
724                                user_i     = 0;
725                                user_state = user_arg;
726                        }
727                        else
728                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
729                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
730                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
731                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
732                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
733
734                                // call users function for this operation
735                                user_atom->set_id(user_id);
736                                CPPAD_ATOMIC_CALL(
737                                        p, q, user_vx, user_vy, user_tx, user_ty
738                                );
739# ifndef NDEBUG
740                                if( ! user_ok )
741                                {       std::string msg = 
742                                                atomic_base<Base>::class_name(user_index)
743                                                + ": atomic_base.forward: returned false";
744                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
745                                }
746# endif
747                                for(i = 0; i < user_m; i++) 
748                                        if( user_iy[i] > 0 )
749                                                for(k = p; k <= q; k++)
750                                                        taylor[ user_iy[i] * J + k ] = 
751                                                                user_ty[ i * user_q1 + k ];
752# if CPPAD_FORWARD1SWEEP_TRACE
753                                user_state = user_trace;
754# else
755                                user_state = user_start;
756# endif
757                        }
758                        break;
759
760                        case UsrapOp:
761                        // parameter argument in an atomic operation sequence
762                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
763                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
764                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
765                        user_tx[user_j * user_q1 + 0] = parameter[ arg[0]];
766                        for(k = 1; k < user_q1; k++)
767                                user_tx[user_j * user_q1 + k] = Base(0);
768                        ++user_j;
769                        if( user_j == user_n )
770                                user_state = user_ret;
771                        break;
772
773                        case UsravOp:
774                        // variable argument in an atomic operation sequence
775                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
776                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
777                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
778                        for(k = 0; k < user_q1; k++)
779                                user_tx[user_j * user_q1 + k] = taylor[ arg[0] * J + k];
780                        ++user_j;
781                        if( user_j == user_n )
782                                user_state = user_ret;
783                        break;
784
785                        case UsrrpOp:
786                        // parameter result in an atomic operation sequence
787                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
788                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
789                        user_iy[user_i] = 0;
790                        user_ty[user_i * user_q1 + 0] = parameter[ arg[0]];
791                        for(k = 1; k < p; k++)
792                                user_ty[user_i * user_q1 + k] = Base(0);
793                        user_i++;
794                        if( user_i == user_m )
795                                user_state = user_end;
796                        break;
797
798                        case UsrrvOp:
799                        // variable result in an atomic operation sequence
800                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
801                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
802                        user_iy[user_i] = i_var;
803                        for(k = 0; k < p; k++)
804                                user_ty[user_i * user_q1 + k] = taylor[ i_var * J + k];
805                        user_i++;
806                        if( user_i == user_m )
807                                user_state = user_end;
808                        break;
809                        // -------------------------------------------------
810
811                        default:
812                        CPPAD_ASSERT_UNKNOWN(0);
813                }
814# if CPPAD_FORWARD1SWEEP_TRACE
815                if( user_state == user_trace )
816                {       user_state = user_start;
817
818                        CPPAD_ASSERT_UNKNOWN( op == UserOp );
819                        CPPAD_ASSERT_UNKNOWN( NumArg(UsrrvOp) == 0 );
820                        for(i = 0; i < user_m; i++) if( user_iy[i] > 0 )
821                        {       size_t i_tmp   = (i_op + i) - user_m;
822                                printOp(
823                                        std::cout, 
824                                        play,
825                                        i_tmp,
826                                        user_iy[i],
827                                        UsrrvOp, 
828                                        CPPAD_NULL
829                                );
830                                Base* Z_tmp = taylor + user_iy[i] * J;
831                                printOpResult(
832                                        std::cout, 
833                                        q + 1, 
834                                        Z_tmp,
835                                        0, 
836                                        (Base *) CPPAD_NULL
837                                );
838                                std::cout << std::endl;
839                        }
840                }
841                Base*           Z_tmp   = taylor + J * i_var;
842                const addr_t*   arg_tmp = arg;
843                if( op == CSumOp )
844                        arg_tmp = arg - arg[-1] - 4;
845                if( op == CSkipOp )
846                        arg_tmp = arg - arg[-1] - 7;
847                if( op != UsrrvOp )
848                {
849                        printOp(
850                                std::cout, 
851                                play,
852                                i_op,
853                                i_var,
854                                op, 
855                                arg_tmp
856                        );
857                        if( NumRes(op) > 0 ) printOpResult(
858                                std::cout, 
859                                q + 1, 
860                                Z_tmp, 
861                                0, 
862                                (Base *) CPPAD_NULL
863                        );
864                        std::cout << std::endl;
865                }
866        }
867        std::cout << std::endl;
868# else
869        }
870# endif
871        CPPAD_ASSERT_UNKNOWN( user_state == user_start );
872        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
873
874        return compareCount;
875}
876
877// preprocessor symbols that are local to this file
878# undef CPPAD_FORWARD1SWEEP_TRACE
879# undef CPPAD_ATOMIC_CALL
880
881} // END_CPPAD_NAMESPACE
882# endif
Note: See TracBrowser for help on using the repository browser.