source: branches/cache/cppad/local/for_jac_sweep.hpp @ 3324

Last change on this file since 3324 was 3324, checked in by bradbell, 6 years ago

merge trunk changes into cache

  • Property svn:keywords set to Id
File size: 19.7 KB
Line 
1/* $Id: for_jac_sweep.hpp 3324 2014-09-12 12:14:53Z bradbell $ */
2# ifndef CPPAD_FOR_JAC_SWEEP_INCLUDED
3# define CPPAD_FOR_JAC_SWEEP_INCLUDED
4/* --------------------------------------------------------------------------
5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
6
7CppAD is distributed under multiple licenses. This distribution is under
8the terms of the
9                    Eclipse Public License Version 1.0.
10
11A copy of this license is included in the COPYING file of this distribution.
12Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
13-------------------------------------------------------------------------- */
14
15# include <set>
16# include <cppad/local/pod_vector.hpp>
17
18namespace CppAD { // BEGIN_CPPAD_NAMESPACE
19/*!
20\file for_jac_sweep.hpp
21Compute Forward mode Jacobian sparsity patterns.
22*/
23
24/*!
25\def CPPAD_FOR_JAC_SWEEP_TRACE
26This value is either zero or one.
27Zero is the normal operational value.
28If it is one, a trace of every for_jac_sweep computation is printed.
29*/
30# define CPPAD_FOR_JAC_SWEEP_TRACE 0
31
32/*
33\def CPPAD_ATOMIC_CALL
34This avoids warnings when NDEBUG is defined and user_ok is not used.
35If \c NDEBUG is defined, this resolves to
36\code
37        user_atom->for_sparse_jac
38\endcode
39otherwise, it respolves to
40\code
41        user_ok = user_atom->for_sparse_jac
42\endcode
43This maco is undefined at the end of this file to facillitate is
44use with a different definition in other files.
45*/
46# ifdef NDEBUG
47# define CPPAD_ATOMIC_CALL user_atom->for_sparse_jac
48# else
49# define CPPAD_ATOMIC_CALL user_ok = user_atom->for_sparse_jac
50# endif
51
52/*!
53Given the sparsity pattern for the independent variables,
54ForJacSweep computes the sparsity pattern for all the other variables.
55
56\tparam Base
57base type for the operator; i.e., this operation sequence was recorded
58using AD< \a Base > and computations by this routine are done using type
59\a Base.
60
61\tparam Vector_set
62is the type used for vectors of sets. It can be either
63\c sparse_pack, \c sparse_set, or \c sparse_list.
64
65\param n
66is the number of independent variables on the tape.
67
68\param numvar
69is the total number of variables on the tape; i.e.,
70\a play->num_var_rec().
71
72\param play
73The information stored in \a play
74is a recording of the operations corresponding to a function
75\f[
76        F : {\bf R}^n \rightarrow {\bf R}^m
77\f]
78where \f$ n \f$ is the number of independent variables
79and \f$ m \f$ is the number of dependent variables.
80The object \a play is effectly constant.
81It is not declared const because while playing back the tape
82the object \a play holds information about the currentl location
83with in the tape and this changes during playback.
84
85\param var_sparsity
86\b Input: For j = 1 , ... , \a n,
87the sparsity pattern for the independent variable with index (j-1)
88corresponds to the set with index j in \a var_sparsity.
89\n
90\n
91\b Output: For i = \a n + 1 , ... , \a numvar - 1,
92the sparsity pattern for the variable with index i on the tape
93corresponds to the set with index i in \a var_sparsity.
94
95\par Checked Assertions:
96\li numvar == var_sparsity.n_set()
97\li numvar == play->num_var_rec()
98*/
99
100template <class Base, class Vector_set>
101void ForJacSweep(
102        size_t                n            ,
103        size_t                numvar       ,
104        player<Base>*         play         ,
105        Vector_set&           var_sparsity )
106{
107        OpCode           op;
108        size_t         i_op;
109        size_t        i_var;
110
111        const addr_t*   arg = CPPAD_NULL;
112
113        size_t            i, j, k;
114
115        // check numvar argument
116        CPPAD_ASSERT_UNKNOWN( play->num_var_rec()  == numvar );
117        CPPAD_ASSERT_UNKNOWN( var_sparsity.n_set() == numvar );
118
119        // length of the parameter vector (used by CppAD assert macros)
120        const size_t num_par = play->num_par_rec();
121
122        // cum_sparsity accumulates sparsity pattern a cummulative sum
123        size_t limit = var_sparsity.end();
124
125        // vecad_sparsity contains a sparsity pattern from each VecAD object
126        // to all the other variables.
127        // vecad_ind maps a VecAD index (the beginning of the
128        // VecAD object) to its from index in vecad_sparsity
129        size_t num_vecad_ind   = play->num_vec_ind_rec();
130        size_t num_vecad_vec   = play->num_vecad_vec_rec();
131        Vector_set  vecad_sparsity;
132        vecad_sparsity.resize(num_vecad_vec, limit);
133        pod_vector<size_t> vecad_ind;
134        if( num_vecad_vec > 0 )
135        {       size_t length;
136                vecad_ind.extend(num_vecad_ind);
137                j             = 0;
138                for(i = 0; i < num_vecad_vec; i++)
139                {       // length of this VecAD
140                        length   = play->GetVecInd(j);
141                        // set to proper index for this VecAD
142                        vecad_ind[j] = i; 
143                        for(k = 1; k <= length; k++)
144                                vecad_ind[j+k] = num_vecad_vec; // invalid index
145                        // start of next VecAD
146                        j       += length + 1;
147                }
148                CPPAD_ASSERT_UNKNOWN( j == play->num_vec_ind_rec() );
149        }
150
151        // --------------------------------------------------------------
152        // work space used by UserOp.
153        //
154        typedef std::set<size_t> size_set;
155        size_set::iterator set_itr;  // iterator for a standard set
156        size_set::iterator set_end;  // end of iterator sequence
157        vector< size_set > set_r;    // set sparsity pattern for the argument x
158        vector< size_set > set_s;    // set sparisty pattern for the result y
159        //
160        vector<bool>       bool_r;   // bool sparsity pattern for the argument x
161        vector<bool>       bool_s;   // bool sparisty pattern for the result y
162        //
163        const size_t user_q = limit; // maximum element plus one
164        size_t user_index = 0;       // indentifier for this atomic operation
165        size_t user_id    = 0;       // user identifier for this call to operator
166        size_t user_i     = 0;       // index in result vector
167        size_t user_j     = 0;       // index in argument vector
168        size_t user_m     = 0;       // size of result vector
169        size_t user_n     = 0;       // size of arugment vector
170        //
171        atomic_base<Base>* user_atom = CPPAD_NULL; // user's atomic op calculator
172        bool               user_bool = false;      // use bool or set sparsity ?
173# ifndef NDEBUG
174        bool               user_ok   = false;      // atomic op return value
175# endif
176        //
177        // next expected operator in a UserOp sequence
178        enum { user_start, user_arg, user_ret, user_end } user_state = user_start;
179        // --------------------------------------------------------------
180
181# if CPPAD_FOR_JAC_SWEEP_TRACE
182        std::cout << std::endl;
183        CppAD::vectorBool z_value(limit);
184# endif
185
186        // skip the BeginOp at the beginning of the recording
187        play->forward_start(op, arg, i_op, i_var);
188        CPPAD_ASSERT_UNKNOWN( op == BeginOp );
189        bool more_operators = true;
190        while(more_operators)
191        {
192                // this op
193                play->forward_next(op, arg, i_op, i_var);
194                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
195                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
196                CPPAD_ASSERT_ARG_BEFORE_RESULT(op, arg, i_var);
197
198                // rest of information depends on the case
199                switch( op )
200                {
201                        case AbsOp:
202                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
203                        forward_sparse_jacobian_unary_op(
204                                i_var, arg[0], var_sparsity
205                        );
206                        break;
207                        // -------------------------------------------------
208
209                        case AddvvOp:
210                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
211                        forward_sparse_jacobian_binary_op(
212                                i_var, arg, var_sparsity
213                        );
214                        break;
215                        // -------------------------------------------------
216
217                        case AddpvOp:
218                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
219                        forward_sparse_jacobian_unary_op(
220                                i_var, arg[1], var_sparsity
221                        );
222                        break;
223                        // -------------------------------------------------
224
225                        case AcosOp:
226                        // sqrt(1 - x * x), acos(x)
227                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
228                        forward_sparse_jacobian_unary_op(
229                                i_var, arg[0], var_sparsity
230                        );
231                        break;
232                        // -------------------------------------------------
233
234                        case AsinOp:
235                        // sqrt(1 - x * x), asin(x)
236                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
237                        forward_sparse_jacobian_unary_op(
238                                i_var, arg[0], var_sparsity
239                        );
240                        break;
241                        // -------------------------------------------------
242
243                        case AtanOp:
244                        // 1 + x * x, atan(x)
245                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
246                        forward_sparse_jacobian_unary_op(
247                                i_var, arg[0], var_sparsity
248                        );
249                        break;
250                        // -------------------------------------------------
251
252                        case CSkipOp:
253                        // CSipOp has a variable number of arguments and
254                        // forward_next thinks it has no arguments.
255                        // we must inform forward_next of this special case.
256                        play->forward_cskip(op, arg, i_op, i_var);
257                        break;
258                        // -------------------------------------------------
259
260                        case CSumOp:
261                        // CSumOp has a variable number of arguments and
262                        // forward_next thinks it has no arguments.
263                        // we must inform forward_next of this special case.
264                        forward_sparse_jacobian_csum_op(
265                                i_var, arg, var_sparsity
266                        );
267                        play->forward_csum(op, arg, i_op, i_var);
268                        break;
269                        // -------------------------------------------------
270
271                        case CExpOp:
272                        forward_sparse_jacobian_cond_op(
273                                i_var, arg, num_par, var_sparsity
274                        );
275                        break;
276                        // ---------------------------------------------------
277
278                        case ComOp:
279                        CPPAD_ASSERT_NARG_NRES(op, 4, 0);
280                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
281                        break;
282                        // --------------------------------------------------
283
284                        case CosOp:
285                        // sin(x), cos(x)
286                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
287                        forward_sparse_jacobian_unary_op(
288                                i_var, arg[0], var_sparsity
289                        );
290                        break;
291                        // ---------------------------------------------------
292
293                        case CoshOp:
294                        // sinh(x), cosh(x)
295                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
296                        forward_sparse_jacobian_unary_op(
297                                i_var, arg[0], var_sparsity
298                        );
299                        break;
300                        // -------------------------------------------------
301
302                        case DisOp:
303                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
304                        var_sparsity.clear(i_var);
305                        break;
306                        // -------------------------------------------------
307
308                        case DivvvOp:
309                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
310                        forward_sparse_jacobian_binary_op(
311                                i_var, arg, var_sparsity
312                        );
313                        break;
314                        // -------------------------------------------------
315
316                        case DivpvOp:
317                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
318                        forward_sparse_jacobian_unary_op(
319                                i_var, arg[1], var_sparsity
320                        );
321                        break;
322                        // -------------------------------------------------
323
324                        case DivvpOp:
325                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
326                        forward_sparse_jacobian_unary_op(
327                                i_var, arg[0], var_sparsity
328                        );
329                        break;
330                        // -------------------------------------------------
331
332                        case EndOp:
333                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
334                        more_operators = false;
335                        break;
336                        // -------------------------------------------------
337
338                        case ExpOp:
339                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
340                        forward_sparse_jacobian_unary_op(
341                                i_var, arg[0], var_sparsity
342                        );
343                        break;
344                        // -------------------------------------------------
345
346                        case InvOp:
347                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
348                        // sparsity pattern is already defined
349                        break;
350                        // -------------------------------------------------
351
352                        case LdpOp:
353                        forward_sparse_load_op(
354                                op,
355                                i_var,
356                                arg,
357                                num_vecad_ind,
358                                vecad_ind.data(),
359                                var_sparsity,
360                                vecad_sparsity
361                        );
362                        break;
363                        // -------------------------------------------------
364
365                        case LdvOp:
366                        forward_sparse_load_op(
367                                op,
368                                i_var,
369                                arg,
370                                num_vecad_ind,
371                                vecad_ind.data(),
372                                var_sparsity,
373                                vecad_sparsity
374                        );
375                        break;
376                        // -------------------------------------------------
377
378                        case LogOp:
379                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
380                        forward_sparse_jacobian_unary_op(
381                                i_var, arg[0], var_sparsity
382                        );
383                        break;
384                        // -------------------------------------------------
385
386                        case MulvvOp:
387                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
388                        forward_sparse_jacobian_binary_op(
389                                i_var, arg, var_sparsity
390                        );
391                        break;
392                        // -------------------------------------------------
393
394                        case MulpvOp:
395                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
396                        forward_sparse_jacobian_unary_op(
397                                i_var, arg[1], var_sparsity
398                        );
399                        break;
400                        // -------------------------------------------------
401
402                        case ParOp:
403                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
404                        var_sparsity.clear(i_var);
405                        break;
406                        // -------------------------------------------------
407
408                        case PowvpOp:
409                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
410                        forward_sparse_jacobian_unary_op(
411                                i_var, arg[0], var_sparsity
412                        );
413                        break;
414                        // -------------------------------------------------
415
416                        case PowpvOp:
417                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
418                        forward_sparse_jacobian_unary_op(
419                                i_var, arg[1], var_sparsity
420                        );
421                        break;
422                        // -------------------------------------------------
423
424                        case PowvvOp:
425                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
426                        forward_sparse_jacobian_binary_op(
427                                i_var, arg, var_sparsity
428                        );
429                        break;
430                        // -------------------------------------------------
431
432                        case PriOp:
433                        CPPAD_ASSERT_NARG_NRES(op, 5, 0);
434                        break;
435                        // -------------------------------------------------
436
437                        case SignOp:
438                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
439                        forward_sparse_jacobian_unary_op(
440                                i_var, arg[0], var_sparsity
441                        );
442                        break;
443                        // -------------------------------------------------
444
445                        case SinOp:
446                        // cos(x), sin(x)
447                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
448                        forward_sparse_jacobian_unary_op(
449                                i_var, arg[0], var_sparsity
450                        );
451                        break;
452                        // -------------------------------------------------
453
454                        case SinhOp:
455                        // cosh(x), sinh(x)
456                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
457                        forward_sparse_jacobian_unary_op(
458                                i_var, arg[0], var_sparsity
459                        );
460                        break;
461                        // -------------------------------------------------
462
463                        case SqrtOp:
464                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
465                        forward_sparse_jacobian_unary_op(
466                                i_var, arg[0], var_sparsity
467                        );
468                        break;
469                        // -------------------------------------------------
470
471                        case StppOp:
472                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
473                        // storing a parameter does not affect vector sparsity
474                        break;
475                        // -------------------------------------------------
476
477                        case StpvOp:
478                        forward_sparse_store_op(
479                                op,
480                                arg,
481                                num_vecad_ind,
482                                vecad_ind.data(),
483                                var_sparsity,
484                                vecad_sparsity
485                        );
486                        break;
487                        // -------------------------------------------------
488
489                        case StvpOp:
490                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
491                        // storing a parameter does not affect vector sparsity
492                        break;
493                        // -------------------------------------------------
494
495                        case StvvOp:
496                        forward_sparse_store_op(
497                                op,
498                                arg,
499                                num_vecad_ind,
500                                vecad_ind.data(),
501                                var_sparsity,
502                                vecad_sparsity
503                        );
504                        break;
505                        // -------------------------------------------------
506
507                        case SubvvOp:
508                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
509                        forward_sparse_jacobian_binary_op(
510                                i_var, arg, var_sparsity
511                        );
512                        break;
513                        // -------------------------------------------------
514
515                        case SubpvOp:
516                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
517                        forward_sparse_jacobian_unary_op(
518                                i_var, arg[1], var_sparsity
519                        );
520                        break;
521                        // -------------------------------------------------
522
523                        case SubvpOp:
524                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
525                        forward_sparse_jacobian_unary_op(
526                                i_var, arg[0], var_sparsity
527                        );
528                        break;
529                        // -------------------------------------------------
530
531                        case TanOp:
532                        // tan(x)^2, tan(x)
533                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
534                        forward_sparse_jacobian_unary_op(
535                                i_var, arg[0], var_sparsity
536                        );
537                        break;
538                        // -------------------------------------------------
539
540                        case TanhOp:
541                        // tanh(x)^2, tanh(x)
542                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
543                        forward_sparse_jacobian_unary_op(
544                                i_var, arg[0], var_sparsity
545                        );
546                        break;
547                        // -------------------------------------------------
548
549                        case UserOp:
550                        // start or end an atomic operation sequence
551                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
552                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
553                        if( user_state == user_start )
554                        {       user_index = arg[0];
555                                user_id    = arg[1];
556                                user_n     = arg[2];
557                                user_m     = arg[3];
558                                user_atom  = atomic_base<Base>::class_object(user_index);
559# ifndef NDEBUG
560                                if( user_atom == CPPAD_NULL )
561                                {       std::string msg = 
562                                                atomic_base<Base>::class_name(user_index)
563                                                + ": atomic_base function has been deleted";
564                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
565                                }
566# endif
567                                user_bool  = user_atom->sparsity() ==
568                                                        atomic_base<Base>::bool_sparsity_enum;
569                                if( user_bool )
570                                {       if( bool_r.size() != user_n * user_q )
571                                                bool_r.resize( user_n * user_q );
572                                        if( bool_s.size() != user_m * user_q )
573                                                bool_s.resize( user_m * user_q );
574                                        for(i = 0; i < user_n; i++)
575                                                for(j = 0; j < user_q; j++)
576                                                        bool_r[ i * user_q + j] = false;
577                                }
578                                else
579                                {       if(set_r.size() != user_n )
580                                                set_r.resize(user_n);
581                                        if(set_s.size() != user_m )
582                                                set_s.resize(user_m);
583                                        for(i = 0; i < user_n; i++)
584                                                set_r[i].clear();
585                                }
586                                user_j     = 0;
587                                user_i     = 0;
588                                user_state = user_arg;
589                        }
590                        else
591                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
592                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
593                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
594                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
595                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
596# ifndef NDEBUG
597                                if( ! user_ok )
598                                {       std::string msg = 
599                                                atomic_base<Base>::class_name(user_index)
600                                                + ": atomic_base.for_sparse_jac: returned false";
601                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
602                                }
603# endif
604                                user_state = user_start;
605                        }
606                        break;
607
608                        case UsrapOp:
609                        // parameter argument in an atomic operation sequence
610                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
611                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
612                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
613                        // set row user_j to empty sparsity pattern
614                        ++user_j;
615                        if( user_j == user_n )
616                        {       // call users function for this operation
617                                user_atom->set_id(user_id);
618                                if( user_bool )
619                                        CPPAD_ATOMIC_CALL(
620                                                user_q, bool_r, bool_s
621                                );
622                                else
623                                        CPPAD_ATOMIC_CALL(
624                                                user_q, set_r, set_s
625                                );
626                                user_state = user_ret;
627                        }
628                        break;
629
630                        case UsravOp:
631                        // variable argument in an atomic operation sequence
632                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
633                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
634                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
635                        // set row user_j to sparsity pattern for variable arg[0]
636                        var_sparsity.begin(arg[0]);
637                        i = var_sparsity.next_element();
638                        while( i < user_q )
639                        {       if( user_bool )
640                                        bool_r[user_j * user_q + i] = true;
641                                else
642                                        set_r[user_j].insert(i);
643                                i = var_sparsity.next_element();
644                        }
645                        ++user_j;
646                        if( user_j == user_n )
647                        {       // call users function for this operation
648                                user_atom->set_id(user_id);
649                                if( user_bool )
650                                        CPPAD_ATOMIC_CALL(
651                                                user_q, bool_r, bool_s
652                                );
653                                else
654                                        CPPAD_ATOMIC_CALL(
655                                                user_q, set_r, set_s
656                                );
657                                user_state = user_ret;
658                        }
659                        break;
660
661                        case UsrrpOp:
662                        // parameter result in an atomic operation sequence
663                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
664                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
665                        user_i++;
666                        if( user_i == user_m )
667                                user_state = user_end;
668                        break;
669
670                        case UsrrvOp:
671                        // variable result in an atomic operation sequence
672                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
673                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
674                        // It might be faster if we add set union to var_sparsity
675                        // where one of the sets is not in var_sparsity
676                        if( user_bool )
677                        {       for(j = 0; j < user_q; j++)
678                                        if( bool_s[ user_i * user_q + j ] )
679                                                var_sparsity.add_element(i_var, j);
680                        }
681                        else
682                        {       set_itr = set_s[user_i].begin();
683                                set_end = set_s[user_i].end();
684                                while( set_itr != set_end )
685                                        var_sparsity.add_element(i_var, *set_itr++);
686                        }
687                        user_i++;
688                        if( user_i == user_m )
689                                user_state = user_end;
690                        break;
691                        // -------------------------------------------------
692
693                        default:
694                        CPPAD_ASSERT_UNKNOWN(0);
695                }
696# if CPPAD_FOR_JAC_SWEEP_TRACE
697                const addr_t*   arg_tmp = arg;
698                if( op == CSumOp )
699                        arg_tmp = arg - arg[-1] - 4;
700                if( op == CSkipOp )
701                        arg_tmp = arg - arg[-1] - 7;
702                //
703                // value for this variable
704                for(j = 0; j < limit; j++)
705                        z_value[j] = false;
706                var_sparsity.begin(i_var);
707                j = var_sparsity.next_element();
708                while( j < limit )
709                {       z_value[j] = true;
710                        j = var_sparsity.next_element();
711                }
712                printOp(
713                        std::cout,
714                        play,
715                        i_op,
716                        i_var,
717                        op,
718                        arg_tmp
719                );
720                if( NumRes(op) > 0 ) printOpResult(
721                        std::cout,
722                        1,
723                        &z_value,
724                        0,
725                        (CppAD::vectorBool *) CPPAD_NULL
726                );
727                std::cout << std::endl;
728        }
729        std::cout << std::endl;
730# else
731        }
732# endif
733        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
734
735        return;
736}
737
738} // END_CPPAD_NAMESPACE
739
740// preprocessor symbols that are local to this file
741# undef CPPAD_FOR_JAC_SWEEP_TRACE
742# undef CPPAD_ATOMIC_CALL
743
744# endif
Note: See TracBrowser for help on using the repository browser.