Changeset 3372


Ignore:
Timestamp:
Sep 28, 2014 2:42:37 PM (6 years ago)
Author:
bradbell
Message:
  1. Fix some more bugs in the optimization of conditional expressions.
  2. Assert not skipping a skip.

opt_cond_exp.sh: demonstration of bug (crashed).
optimize.hpp: assure i_arg is zero when not using CSkip.
player.hpp: fix bug in reverse_cskip.
reverse_sweep.hpp: fix tracing of reverse mode.

Location:
trunk
Files:
6 edited
1 copied

Legend:

Unmodified
Added
Removed
  • trunk/bug/opt_cond_exp.sh

    r3370 r3372  
    1515EOF
    1616cat << EOF > bug.$$
    17 # include <iostream>
    18 int main(void)
    19 {       // C++ source code
    20         using std::cout;
     17#include <cppad/cppad.hpp>
    2118
    22         cout << "1. svn copy template.sh <name>.sh\n";
    23         cout << "2. Edit <name>.sh replacing description and C++ source code\n";
    24         cout << "3. Run ./<name>.sh\n";
    25         cout << "where <name> is a name that describes the bug\n";
    26        
    27         return 0;
     19namespace {
     20        using CppAD::vector;
     21        using CppAD::AD;
     22        using CppAD::ADFun;
     23
     24        template <class Type>
     25        Type max(const vector<Type> &arg)
     26        {       Type res = arg[0];
     27                for(size_t i = 0;i < arg.size(); i++)
     28                res = CondExpGt(res, arg[i], res, arg[i]);
     29                return res;
     30        }
     31}
     32
     33int main()
     34{
     35        // n >= 3 required to trigger bug
     36        size_t n = 2;
     37
     38        vector< AD<double> > ax(n), ay(1);
     39        for(size_t i = 0; i < n; i++)
     40                ax[i] = 1.0;
     41        Independent(ax);
     42        ay[0] = max(ax) + max(ax);
     43        ADFun<double> f(ax, ay);
     44
     45        f.optimize();
     46
     47        vector<double> x(n);
     48        for(size_t i = 0;i < n; i++)
     49                x[i] = 1.0;
     50        std::cout << f.Jacobian(x) << "\n";
    2851}
    2952EOF
  • trunk/cppad/local/forward0sweep.hpp

    r3323 r3372  
    260260                                play->forward_csum(op, arg, i_op, i_var);
    261261                        }
     262                        CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
     263                        // if( op == CSkipOp )
     264                        // {    // CSkip has a variable number of arguments
     265                        //      play->forward_cskip(op, arg, i_op, i_var);
     266                        // }
    262267                        play->forward_next(op, arg, i_op, i_var);
    263268                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
  • trunk/cppad/local/forward1sweep.hpp

    r3323 r3372  
    309309                                play->forward_csum(op, arg, i_op, i_var);
    310310                        }
     311                        CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
     312                        // if( op == CSkipOp )
     313                        // {    // CSkip has a variable number of arguments
     314                        //      play->forward_cskip(op, arg, i_op, i_var);
     315                        // }
    311316                        play->forward_next(op, arg, i_op, i_var);
    312317                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
  • trunk/cppad/local/forward2sweep.hpp

    r3321 r3372  
    239239                                play->forward_csum(op, arg, i_op, i_var);
    240240                        }
     241                        CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
     242                        // if( op == CSkipOp )
     243                        // {    // CSkip has a variable number of arguments
     244                        //      play->forward_cskip(op, arg, i_op, i_var);
     245                        // }
    241246                        play->forward_next(op, arg, i_op, i_var);
    242247                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
  • trunk/cppad/local/optimize.hpp

    r3370 r3372  
    16521652                                info.n_op_true  = 0;
    16531653                                info.n_op_false = 0;
     1654                                info.i_arg      = 0; // case where no CSkipOp for this CExpOp
    16541655                                //
    16551656                                size_t index    = 0;
     
    20522053                if( skip )
    20532054                {       cskip_order_next++;
    2054                         skip &= cskip_info[j].skip_var_true.size() > 0 ||
    2055                                         cskip_info[j].skip_var_false.size() > 0;
     2055                        struct_cskip_info info = cskip_info[j];
     2056                        size_t n_true  = info.skip_var_true.size() + info.n_op_true;
     2057                        size_t n_false = info.skip_var_false.size() + info.n_op_false;
     2058                        skip &= n_true > 0 || n_false > 0;
    20562059                        if( skip )
    2057                         {       struct_cskip_info info = cskip_info[j];
    2058                                 CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
    2059                                 size_t n_true  =
    2060                                         info.skip_var_true.size() + info.n_op_true;
    2061                                 size_t n_false =
    2062                                         info.skip_var_false.size() + info.n_op_false;
     2060                        {       CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
    20632061                                size_t n_arg   = 7 + n_true + n_false;
    20642062                                // reserve space for the arguments to this operator but
     
    20682066                                rec->PutOp(CSkipOp);
    20692067                        }
    2070                         else    cskip_info[j].i_arg = 0;
    20712068                }
    20722069
  • trunk/cppad/local/player.hpp

    r3232 r3372  
    619619                /*
    620620                The variables that need fixing are op_arg_ and op_arg. Currently,
    621                 op_arg points first argument for the previous operator.
     621                op_arg points to the last argument for the previous operator.
    622622                */
     623                // last argument for this csum operation
    623624                --op_arg;
     625                // first argument for this csum operation
    624626                op_arg      = op_arg_    -= (op_arg[0] + 4);
     627                // now op_arg points to the first argument for this csum operator
    625628
    626629                CPPAD_ASSERT_UNKNOWN(
    627630                op_arg[0] + op_arg[1] == op_arg[ 3 + op_arg[0] + op_arg[1] ]
    628631                );
     632
    629633                CPPAD_ASSERT_UNKNOWN( op_index_  < op_rec_.size() );
    630634                CPPAD_ASSERT_UNKNOWN( op_arg_rec_.data() <= op_arg_ );
     
    666670                /*
    667671                The variables that need fixing are op_arg_ and op_arg. Currently,
    668                 op_arg points first arugment for the previous operator.
     672                op_arg points to the last arugment for the previous operator.
    669673                */
     674                // last argument for this cskip operation
    670675                --op_arg;
    671                 op_arg      = op_arg_    -= (op_arg[0] + 4);
     676                // first argument for this cskip operation
     677                op_arg      = op_arg_    -= (op_arg[0] + 7);
    672678
    673679                CPPAD_ASSERT_UNKNOWN(
    674                 op_arg[1] + op_arg[2] == op_arg[ 3 + op_arg[1] + op_arg[2] ]
     680                op_arg[4] + op_arg[5] == op_arg[ 6 + op_arg[4] + op_arg[5] ]
    675681                );
    676682                CPPAD_ASSERT_UNKNOWN( op_index_  < op_rec_.size() );
  • trunk/cppad/local/reverse_sweep.hpp

    r3348 r3372  
    251251                                play->reverse_csum(op, arg, i_op, i_var);
    252252                        }
     253                        CPPAD_ASSERT_UNKNOWN( op != CSkipOp );
     254                        // if( op == CSkipOp )
     255                        // {    // CSkip has a variable number of arguments
     256                        //      play->reverse_cskip(op, arg, i_op, i_var);
     257                        // }
     258                        CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    253259                        play->reverse_next(op, arg, i_op, i_var);
    254                         CPPAD_ASSERT_UNKNOWN( i_op < play->num_op_rec() );
    255260                }
    256261
    257262                // rest of informaiton depends on the case
    258263# if CPPAD_REVERSE_SWEEP_TRACE
     264                if( op == CSumOp )
     265                {       // CSumOp has a variable number of arguments
     266                        play->reverse_csum(op, arg, i_op, i_var);
     267                }
     268                if( op == CSkipOp )
     269                {       // CSkip has a variable number of arguments
     270                        play->reverse_cskip(op, arg, i_op, i_var);
     271                }
    259272                size_t       i_tmp  = i_var;
    260273                const Base*  Z_tmp  = Taylor + i_var * J;
     
    339352                        // forward_next thinks it one has one argument.
    340353                        // we must inform reverse_next of this special case.
     354# if ! CPPAD_REVERSE_SWEEP_TRACE
    341355                        play->reverse_cskip(op, arg, i_op, i_var);
     356# endif
    342357                        break;
    343358                        // -------------------------------------------------
     
    347362                        // reverse_next thinks it one has one argument.
    348363                        // We must inform reverse_next of this special case.
     364# if ! CPPAD_REVERSE_SWEEP_TRACE
    349365                        play->reverse_csum(op, arg, i_op, i_var);
     366# endif
    350367                        reverse_csum_op(
    351368                                d, i_var, arg, K, Partial
Note: See TracChangeset for help on using the changeset viewer.