source: branches/opt_cond_exp/cppad/local/for_jac_sweep.hpp @ 2979

Last change on this file since 2979 was 2979, checked in by bradbell, 7 years ago
  1. Add operator index to trace output.
  2. Check that new operator values have been set and are valid.
  3. Reinitialize cskip_op_ after optimization.

optimize.hpp: Add test of entirely removing an atomic call.

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