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

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

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

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