source: trunk/cppad/local/for_jac_sweep.hpp @ 3301

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

merge in multiple forward direcitons from branches/forward_dir

  • Property svn:keywords set to Id
File size: 19.6 KB
Line 
1/* $Id: for_jac_sweep.hpp 3301 2014-05-24 05:20:21Z 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
197                // rest of information depends on the case
198                switch( op )
199                {
200                        case AbsOp:
201                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
202                        forward_sparse_jacobian_unary_op(
203                                i_var, arg[0], var_sparsity
204                        );
205                        break;
206                        // -------------------------------------------------
207
208                        case AddvvOp:
209                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
210                        forward_sparse_jacobian_binary_op(
211                                i_var, arg, var_sparsity
212                        );
213                        break;
214                        // -------------------------------------------------
215
216                        case AddpvOp:
217                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
218                        forward_sparse_jacobian_unary_op(
219                                i_var, arg[1], var_sparsity
220                        );
221                        break;
222                        // -------------------------------------------------
223
224                        case AcosOp:
225                        // sqrt(1 - x * x), acos(x)
226                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
227                        forward_sparse_jacobian_unary_op(
228                                i_var, arg[0], var_sparsity
229                        );
230                        break;
231                        // -------------------------------------------------
232
233                        case AsinOp:
234                        // sqrt(1 - x * x), asin(x)
235                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
236                        forward_sparse_jacobian_unary_op(
237                                i_var, arg[0], var_sparsity
238                        );
239                        break;
240                        // -------------------------------------------------
241
242                        case AtanOp:
243                        // 1 + x * x, atan(x)
244                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
245                        forward_sparse_jacobian_unary_op(
246                                i_var, arg[0], var_sparsity
247                        );
248                        break;
249                        // -------------------------------------------------
250
251                        case CSkipOp:
252                        // CSipOp has a variable number of arguments and
253                        // forward_next thinks it has no arguments.
254                        // we must inform forward_next of this special case.
255                        play->forward_cskip(op, arg, i_op, i_var);
256                        break;
257                        // -------------------------------------------------
258
259                        case CSumOp:
260                        // CSumOp has a variable number of arguments and
261                        // forward_next thinks it has no arguments.
262                        // we must inform forward_next of this special case.
263                        forward_sparse_jacobian_csum_op(
264                                i_var, arg, var_sparsity
265                        );
266                        play->forward_csum(op, arg, i_op, i_var);
267                        break;
268                        // -------------------------------------------------
269
270                        case CExpOp:
271                        forward_sparse_jacobian_cond_op(
272                                i_var, arg, num_par, var_sparsity
273                        );
274                        break;
275                        // ---------------------------------------------------
276
277                        case ComOp:
278                        CPPAD_ASSERT_NARG_NRES(op, 4, 0);
279                        CPPAD_ASSERT_UNKNOWN( arg[1] > 1 );
280                        break;
281                        // --------------------------------------------------
282
283                        case CosOp:
284                        // sin(x), cos(x)
285                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
286                        forward_sparse_jacobian_unary_op(
287                                i_var, arg[0], var_sparsity
288                        );
289                        break;
290                        // ---------------------------------------------------
291
292                        case CoshOp:
293                        // sinh(x), cosh(x)
294                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
295                        forward_sparse_jacobian_unary_op(
296                                i_var, arg[0], var_sparsity
297                        );
298                        break;
299                        // -------------------------------------------------
300
301                        case DisOp:
302                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
303                        var_sparsity.clear(i_var);
304                        break;
305                        // -------------------------------------------------
306
307                        case DivvvOp:
308                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
309                        forward_sparse_jacobian_binary_op(
310                                i_var, arg, var_sparsity
311                        );
312                        break;
313                        // -------------------------------------------------
314
315                        case DivpvOp:
316                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
317                        forward_sparse_jacobian_unary_op(
318                                i_var, arg[1], var_sparsity
319                        );
320                        break;
321                        // -------------------------------------------------
322
323                        case DivvpOp:
324                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
325                        forward_sparse_jacobian_unary_op(
326                                i_var, arg[0], var_sparsity
327                        );
328                        break;
329                        // -------------------------------------------------
330
331                        case EndOp:
332                        CPPAD_ASSERT_NARG_NRES(op, 0, 0);
333                        more_operators = false;
334                        break;
335                        // -------------------------------------------------
336
337                        case ExpOp:
338                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
339                        forward_sparse_jacobian_unary_op(
340                                i_var, arg[0], var_sparsity
341                        );
342                        break;
343                        // -------------------------------------------------
344
345                        case InvOp:
346                        CPPAD_ASSERT_NARG_NRES(op, 0, 1);
347                        // sparsity pattern is already defined
348                        break;
349                        // -------------------------------------------------
350
351                        case LdpOp:
352                        forward_sparse_load_op(
353                                op,
354                                i_var,
355                                arg,
356                                num_vecad_ind,
357                                vecad_ind.data(),
358                                var_sparsity,
359                                vecad_sparsity
360                        );
361                        break;
362                        // -------------------------------------------------
363
364                        case LdvOp:
365                        forward_sparse_load_op(
366                                op,
367                                i_var,
368                                arg,
369                                num_vecad_ind,
370                                vecad_ind.data(),
371                                var_sparsity,
372                                vecad_sparsity
373                        );
374                        break;
375                        // -------------------------------------------------
376
377                        case LogOp:
378                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
379                        forward_sparse_jacobian_unary_op(
380                                i_var, arg[0], var_sparsity
381                        );
382                        break;
383                        // -------------------------------------------------
384
385                        case MulvvOp:
386                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
387                        forward_sparse_jacobian_binary_op(
388                                i_var, arg, var_sparsity
389                        );
390                        break;
391                        // -------------------------------------------------
392
393                        case MulpvOp:
394                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
395                        forward_sparse_jacobian_unary_op(
396                                i_var, arg[1], var_sparsity
397                        );
398                        break;
399                        // -------------------------------------------------
400
401                        case ParOp:
402                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
403                        var_sparsity.clear(i_var);
404                        break;
405                        // -------------------------------------------------
406
407                        case PowvpOp:
408                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
409                        forward_sparse_jacobian_unary_op(
410                                i_var, arg[0], var_sparsity
411                        );
412                        break;
413                        // -------------------------------------------------
414
415                        case PowpvOp:
416                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
417                        forward_sparse_jacobian_unary_op(
418                                i_var, arg[1], var_sparsity
419                        );
420                        break;
421                        // -------------------------------------------------
422
423                        case PowvvOp:
424                        CPPAD_ASSERT_NARG_NRES(op, 2, 3);
425                        forward_sparse_jacobian_binary_op(
426                                i_var, arg, var_sparsity
427                        );
428                        break;
429                        // -------------------------------------------------
430
431                        case PriOp:
432                        CPPAD_ASSERT_NARG_NRES(op, 5, 0);
433                        break;
434                        // -------------------------------------------------
435
436                        case SignOp:
437                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
438                        forward_sparse_jacobian_unary_op(
439                                i_var, arg[0], var_sparsity
440                        );
441                        break;
442                        // -------------------------------------------------
443
444                        case SinOp:
445                        // cos(x), sin(x)
446                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
447                        forward_sparse_jacobian_unary_op(
448                                i_var, arg[0], var_sparsity
449                        );
450                        break;
451                        // -------------------------------------------------
452
453                        case SinhOp:
454                        // cosh(x), sinh(x)
455                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
456                        forward_sparse_jacobian_unary_op(
457                                i_var, arg[0], var_sparsity
458                        );
459                        break;
460                        // -------------------------------------------------
461
462                        case SqrtOp:
463                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
464                        forward_sparse_jacobian_unary_op(
465                                i_var, arg[0], var_sparsity
466                        );
467                        break;
468                        // -------------------------------------------------
469
470                        case StppOp:
471                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
472                        // storing a parameter does not affect vector sparsity
473                        break;
474                        // -------------------------------------------------
475
476                        case StpvOp:
477                        forward_sparse_store_op(
478                                op,
479                                arg,
480                                num_vecad_ind,
481                                vecad_ind.data(),
482                                var_sparsity,
483                                vecad_sparsity
484                        );
485                        break;
486                        // -------------------------------------------------
487
488                        case StvpOp:
489                        CPPAD_ASSERT_NARG_NRES(op, 3, 0);
490                        // storing a parameter does not affect vector sparsity
491                        break;
492                        // -------------------------------------------------
493
494                        case StvvOp:
495                        forward_sparse_store_op(
496                                op,
497                                arg,
498                                num_vecad_ind,
499                                vecad_ind.data(),
500                                var_sparsity,
501                                vecad_sparsity
502                        );
503                        break;
504                        // -------------------------------------------------
505
506                        case SubvvOp:
507                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
508                        forward_sparse_jacobian_binary_op(
509                                i_var, arg, var_sparsity
510                        );
511                        break;
512                        // -------------------------------------------------
513
514                        case SubpvOp:
515                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
516                        forward_sparse_jacobian_unary_op(
517                                i_var, arg[1], var_sparsity
518                        );
519                        break;
520                        // -------------------------------------------------
521
522                        case SubvpOp:
523                        CPPAD_ASSERT_NARG_NRES(op, 2, 1);
524                        forward_sparse_jacobian_unary_op(
525                                i_var, arg[0], var_sparsity
526                        );
527                        break;
528                        // -------------------------------------------------
529
530                        case TanOp:
531                        // tan(x)^2, tan(x)
532                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
533                        forward_sparse_jacobian_unary_op(
534                                i_var, arg[0], var_sparsity
535                        );
536                        break;
537                        // -------------------------------------------------
538
539                        case TanhOp:
540                        // tanh(x)^2, tanh(x)
541                        CPPAD_ASSERT_NARG_NRES(op, 1, 2);
542                        forward_sparse_jacobian_unary_op(
543                                i_var, arg[0], var_sparsity
544                        );
545                        break;
546                        // -------------------------------------------------
547
548                        case UserOp:
549                        // start or end an atomic operation sequence
550                        CPPAD_ASSERT_UNKNOWN( NumRes( UserOp ) == 0 );
551                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
552                        if( user_state == user_start )
553                        {       user_index = arg[0];
554                                user_id    = arg[1];
555                                user_n     = arg[2];
556                                user_m     = arg[3];
557                                user_atom  = atomic_base<Base>::class_object(user_index);
558# ifndef NDEBUG
559                                if( user_atom == CPPAD_NULL )
560                                {       std::string msg = 
561                                                atomic_base<Base>::class_name(user_index)
562                                                + ": atomic_base function has been deleted";
563                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
564                                }
565# endif
566                                user_bool  = user_atom->sparsity() ==
567                                                        atomic_base<Base>::bool_sparsity_enum;
568                                if( user_bool )
569                                {       if( bool_r.size() != user_n * user_q )
570                                                bool_r.resize( user_n * user_q );
571                                        if( bool_s.size() != user_m * user_q )
572                                                bool_s.resize( user_m * user_q );
573                                        for(i = 0; i < user_n; i++)
574                                                for(j = 0; j < user_q; j++)
575                                                        bool_r[ i * user_q + j] = false;
576                                }
577                                else
578                                {       if(set_r.size() != user_n )
579                                                set_r.resize(user_n);
580                                        if(set_s.size() != user_m )
581                                                set_s.resize(user_m);
582                                        for(i = 0; i < user_n; i++)
583                                                set_r[i].clear();
584                                }
585                                user_j     = 0;
586                                user_i     = 0;
587                                user_state = user_arg;
588                        }
589                        else
590                        {       CPPAD_ASSERT_UNKNOWN( user_state == user_end );
591                                CPPAD_ASSERT_UNKNOWN( user_index == size_t(arg[0]) );
592                                CPPAD_ASSERT_UNKNOWN( user_id    == size_t(arg[1]) );
593                                CPPAD_ASSERT_UNKNOWN( user_n     == size_t(arg[2]) );
594                                CPPAD_ASSERT_UNKNOWN( user_m     == size_t(arg[3]) );
595# ifndef NDEBUG
596                                if( ! user_ok )
597                                {       std::string msg = 
598                                                atomic_base<Base>::class_name(user_index)
599                                                + ": atomic_base.for_sparse_jac: returned false";
600                                        CPPAD_ASSERT_KNOWN(false, msg.c_str() );
601                                }
602# endif
603                                user_state = user_start;
604                        }
605                        break;
606
607                        case UsrapOp:
608                        // parameter argument in an atomic operation sequence
609                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
610                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
611                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
612                        // set row user_j to empty sparsity pattern
613                        ++user_j;
614                        if( user_j == user_n )
615                        {       // call users function for this operation
616                                user_atom->set_id(user_id);
617                                if( user_bool )
618                                        CPPAD_ATOMIC_CALL(
619                                                user_q, bool_r, bool_s
620                                );
621                                else
622                                        CPPAD_ATOMIC_CALL(
623                                                user_q, set_r, set_s
624                                );
625                                user_state = user_ret;
626                        }
627                        break;
628
629                        case UsravOp:
630                        // variable argument in an atomic operation sequence
631                        CPPAD_ASSERT_UNKNOWN( user_state == user_arg );
632                        CPPAD_ASSERT_UNKNOWN( user_j < user_n );
633                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) <= i_var );
634                        // set row user_j to sparsity pattern for variable arg[0]
635                        var_sparsity.begin(arg[0]);
636                        i = var_sparsity.next_element();
637                        while( i < user_q )
638                        {       if( user_bool )
639                                        bool_r[user_j * user_q + i] = true;
640                                else
641                                        set_r[user_j].insert(i);
642                                i = var_sparsity.next_element();
643                        }
644                        ++user_j;
645                        if( user_j == user_n )
646                        {       // call users function for this operation
647                                user_atom->set_id(user_id);
648                                if( user_bool )
649                                        CPPAD_ATOMIC_CALL(
650                                                user_q, bool_r, bool_s
651                                );
652                                else
653                                        CPPAD_ATOMIC_CALL(
654                                                user_q, set_r, set_s
655                                );
656                                user_state = user_ret;
657                        }
658                        break;
659
660                        case UsrrpOp:
661                        // parameter result in an atomic operation sequence
662                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
663                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
664                        user_i++;
665                        if( user_i == user_m )
666                                user_state = user_end;
667                        break;
668
669                        case UsrrvOp:
670                        // variable result in an atomic operation sequence
671                        CPPAD_ASSERT_UNKNOWN( user_state == user_ret );
672                        CPPAD_ASSERT_UNKNOWN( user_i < user_m );
673                        // It might be faster if we add set union to var_sparsity
674                        // where one of the sets is not in var_sparsity
675                        if( user_bool )
676                        {       for(j = 0; j < user_q; j++)
677                                        if( bool_s[ user_i * user_q + j ] )
678                                                var_sparsity.add_element(i_var, j);
679                        }
680                        else
681                        {       set_itr = set_s[user_i].begin();
682                                set_end = set_s[user_i].end();
683                                while( set_itr != set_end )
684                                        var_sparsity.add_element(i_var, *set_itr++);
685                        }
686                        user_i++;
687                        if( user_i == user_m )
688                                user_state = user_end;
689                        break;
690                        // -------------------------------------------------
691
692                        default:
693                        CPPAD_ASSERT_UNKNOWN(0);
694                }
695# if CPPAD_FOR_JAC_SWEEP_TRACE
696                const addr_t*   arg_tmp = arg;
697                if( op == CSumOp )
698                        arg_tmp = arg - arg[-1] - 4;
699                if( op == CSkipOp )
700                        arg_tmp = arg - arg[-1] - 7;
701                //
702                // value for this variable
703                for(j = 0; j < limit; j++)
704                        z_value[j] = false;
705                var_sparsity.begin(i_var);
706                j = var_sparsity.next_element();
707                while( j < limit )
708                {       z_value[j] = true;
709                        j = var_sparsity.next_element();
710                }
711                printOp(
712                        std::cout,
713                        play,
714                        i_op,
715                        i_var,
716                        op,
717                        arg_tmp
718                );
719                if( NumRes(op) > 0 ) printOpResult(
720                        std::cout,
721                        1,
722                        &z_value,
723                        0,
724                        (CppAD::vectorBool *) CPPAD_NULL
725                );
726                std::cout << std::endl;
727        }
728        std::cout << std::endl;
729# else
730        }
731# endif
732        CPPAD_ASSERT_UNKNOWN( i_var + 1 == play->num_var_rec() );
733
734        return;
735}
736
737} // END_CPPAD_NAMESPACE
738
739// preprocessor symbols that are local to this file
740# undef CPPAD_FOR_JAC_SWEEP_TRACE
741# undef CPPAD_ATOMIC_CALL
742
743# endif
Note: See TracBrowser for help on using the repository browser.