Changeset 2977


Ignore:
Timestamp:
Oct 20, 2013 8:48:12 AM (6 years ago)
Author:
bradbell
Message:

Backout simplification that removed atomic sparsity from optimization.

optimize.cpp: test case that demonstrates the need.

Location:
branches/opt_cond_exp
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • branches/opt_cond_exp/cppad/local/optimize.hpp

    r2972 r2977  
    9191Hence the return value of $cref CompareChange$$ will always be zero
    9292for an optimized tape (even if $code NDEBUG$$ is not defined).
     93
     94$head Atomic Functions$$
     95There are some subtitle issue with optimized $cref atomic$$ functions
     96$latex v = g(u)$$.
     97$list number$$
     98The $cref atomic_rev_sparse_jac$$ function is be used to determine
     99which components of $icode u$$ affect the dependent variables of $icode f$$.
     100Currently this always uses $code std::set<size_t>$$ for the sparsity patterns.
     101It should use the current setting of
     102$cref/atomic_sparsity/atomic_option/atomic_sparsity/$$ for the
     103atomic function $latex g(u)$$.
     104$lnext
     105If $icode%u%[%i%]%$$ does not affect the value of
     106the dependent variables for $icode f$$,
     107the value of $icode%u%[%i%]%$$ is set to $cref nan$$.
     108$lend
     109
    93110
    94111$head Checking Optimization$$
     
    12201237
    12211238        // work space used by UserOp.
    1222 # ifndef NDEBUG
     1239        typedef std::set<size_t> size_set;
     1240        size_t user_q     = 0;       // maximum set element plus one
     1241        vector< size_set > user_r;   // sparsity pattern for the argument x
     1242        vector< size_set > user_s;   // sparisty pattern for the result y
    12231243        size_t user_index = 0;       // indentifier for this user_atomic operation
    12241244        size_t user_id    = 0;       // user identifier for this call to operator
    1225 # endif
    12261245        size_t user_i     = 0;       // index in result vector
    12271246        size_t user_j     = 0;       // index in argument vector
     
    15661585                        CPPAD_ASSERT_UNKNOWN( NumArg( UserOp ) == 4 );
    15671586                        if( user_state == user_end )
    1568                         {       
    1569 # ifndef NDEBUG
    1570                                 user_index = arg[0];
     1587                        {       user_index = arg[0];
    15711588                                user_id    = arg[1];
    1572 # endif
    15731589                                user_n     = arg[2];
    15741590                                user_m     = arg[3];
     1591                                user_q     = 1;
     1592                                if(user_s.size() != user_n )
     1593                                        user_s.resize(user_n);
     1594                                if(user_r.size() != user_m )
     1595                                        user_r.resize(user_m);
    15751596                                user_j     = user_n;
    15761597                                user_i     = user_m;
     
    16081629                        CPPAD_ASSERT_UNKNOWN( 0 < arg[0] );
    16091630                        --user_j;
    1610                         tape[arg[0]].connect_type  = user_connect_type.top();
    1611                         tape[arg[0]].connect_index = user_connect_index.top();
     1631                        if( ! user_s[user_j].empty() )
     1632                        {       tape[arg[0]].connect_type = yes_connected;
     1633                                user_connect_type.top()   = yes_connected;
     1634                        }
    16121635                        if( user_j == 0 )
    16131636                                user_state = user_start;
     
    16211644                        CPPAD_ASSERT_UNKNOWN( size_t(arg[0]) < num_par );
    16221645                        --user_i;
     1646                        user_r[user_i].clear();
    16231647                        if( user_i == 0 )
     1648                        {       // call users function for this operation
     1649                                atomic_base<Base>* atom =
     1650                                        atomic_base<Base>::class_object(user_index);
     1651                                atom->set_id(user_id);
     1652                                atom->rev_sparse_jac(
     1653                                        user_q, user_r, user_s
     1654                                );
    16241655                                user_state = user_arg;
     1656                        }
    16251657                        break;
    16261658
     
    16301662                        CPPAD_ASSERT_UNKNOWN( 0 < user_i && user_i <= user_m );
    16311663                        --user_i;
     1664                        user_r[user_i].clear();
    16321665                        switch( connect_type )
    16331666                        {       case not_connected:
     
    16381671                                case csum_connected:
    16391672                                user_connect_type.top() = yes_connected;
     1673                                user_r[user_i].insert(0);
    16401674                                break;
    16411675
     
    16501684                                if( flag )
    16511685                                        user_connect_type.top() = yes_connected;
     1686                                user_r[user_i].insert(0);
    16521687                                break;
    16531688
     
    16561691                        }
    16571692                        if( user_i == 0 )
     1693                        {       // call users function for this operation
     1694                                atomic_base<Base>* atom =
     1695                                        atomic_base<Base>::class_object(user_index);
     1696                                atom->set_id(user_id);
     1697                                atom->rev_sparse_jac(
     1698                                        user_q, user_r, user_s
     1699                                );
    16581700                                user_state = user_arg;
     1701                        }
    16591702                        break;
    16601703                        // ============================================================
  • branches/opt_cond_exp/omh/whats_new/whats_new_13.omh

    r2972 r2977  
    5656assist you in learning about changes between various versions of CppAD.
    5757
    58 $head 10-19$$
    59 Remove the requirement that if $cref optimize$$ is used,
    60 all the $cref/user atomic/atomic_base/$$ functions must define
    61 $cref atomic_rev_sparse_jac$$.
    62 
    6358$head 10-16$$
    6459Fix bug in $cref/Tracing/WishList/Tracing/$$ $cref atomic$$ functions.
     
    172167$lnext
    173168Use this option to remove the need to handel $code nan$$ as a special
    174 case in $cref checkpoint$$ and $cref atomic_base$$ functions.
     169case in $cref checkpoint$$ functions that
     170$cref/atomic functions/optimize/Atomic Functions/$$ in within
     171another function is optimized.
    175172$lnext
    176173Check $cref/reverse/reverse_any/$$  mode results when
     
    186183This has been fixed.
    187184In addition, documentation about using $code optimize$$
    188 with $cref atomic_base$$ functions has been added.
    189 (This connection and documentation was later removed.)
     185with $cref/atomic functions/optimize/Atomic Functions/$$ has been added.
    190186
    191187$head 08-06$$
  • branches/opt_cond_exp/test_more/optimize.cpp

    r2892 r2977  
    3636
    3737                // start recording a new function
    38                 ax[0] = 3.0;
    39                 ax[1] = 4.0;
    4038                CppAD::Independent(ax);
    4139
    4240                // now use algo_check during the recording
    43                 au[0] = ax[0];
    44                 au[1] = ax[0] + ax[1];
     41                au[0] = ax[0] + ax[1]; // this argument requires a new variable
     42                au[1] = ax[0] - ax[1]; // this argument also requires a new variable
    4543                algo_check(au, aw);
    4644
    47                 // now create a function that does not depend on au[1]
     45                // now create f(x) = x_0 - x_1
    4846                ay[0] = aw[0];
    4947                CppAD::ADFun<double> f(ax, ay);
     48
     49                // number of variables before optimization
     50                size_t n_before = f.size_var();
    5051 
    5152                // now optimize f so that the calculation of au[1] is removed
    5253                f.optimize();
     54
     55                // check difference in number of variables
     56                size_t n_after = f.size_var();
     57                ok &= n_before == n_after + 1;
    5358
    5459                // now compute and check a forward mode calculation
     
    5762                x[1] = 6.0;
    5863                y    = f.Forward(0, x);
    59                 ok  &= (y[0] == x[0]);
     64                ok  &= (y[0] == x[0] + x[1]);
    6065
    6166                return ok;
Note: See TracChangeset for help on using the changeset viewer.