Changeset 1612


Ignore:
Timestamp:
Dec 22, 2009 8:51:29 AM (11 years ago)
Author:
bradbell
Message:

trunk: Improve cummulative addition speed (only affects optimized tape).

check_doxygen.sh: only error exit when doxygen version >= 1.5.5.
check_simple_vector.cpp: fix error when compiling with boost library.
makefile.am: include csum_op.hpp in distribution.
whats_new_09.omh: changes from uses point of view.
player.hpp: add special functions for CSumOp variable number of arguments.
prototype.hpp: minor edits to doxygen documentation.
optimize.hpp: use separate stack for operators, adds, and subtracts.
op.hpp: include csum_op.hpp in source.

Convert CAddOp, CSubOp and CSumOp to just CSumOp:


for_jac_sweep.hpp, op_code.hpp, forward0sweep.hpp, forward_sweep.hpp,
rev_jac_sweep.hpp, rev_hes_sweep.hpp, reverse_sweep.hpp

Warning:


Subversion download will not work because changes to makefile.in needs
to be checked in (from a different system with different version of automake).

Location:
trunk
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/check_doxygen.sh

    r1561 r1612  
    1111# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1212# -----------------------------------------------------------------------------
     13doxygen_version=`doxygen --version  | sed -e 's|\.|*100+|' -e's|\.|*10+|'`
     14let doxygen_version=$doxygen_version
    1315#
    1416# classes that have been completely documented
     
    3537        cos_op.hpp
    3638        cosh_op.hpp
     39        csum_op.hpp
    3740        cppad_assert.hpp
    3841        define.hpp
     
    7881        then
    7982                echo "Unexpected doxygen error or warning for $file."
    80                 exit 1
     83                if (( $doxygen_version > 155 ))
     84                then
     85                        exit 1
     86                else
     87                        exit 0
     88                fi
    8189        fi
    8290done
     
    8795        then
    8896                echo "Unexpected doxygen error or warning for $file."
    89                 exit 1
     97                if (( $doxygen_version > 155 ))
     98                then
     99                        exit 1
     100                else
     101                        exit 0
     102                fi
    90103        fi
    91104done
     
    101114        then
    102115                echo "Unexpected doxygen error or warning for $file."
    103                 exit 1
     116                if (( $doxygen_version > 155 ))
     117                then
     118                        exit 1
     119                else
     120                        exit 0
     121                fi
    104122        fi
    105123done
  • trunk/cppad/local/for_jac_sweep.hpp

    r1608 r1612  
    101101        // cum_sparsity accumulates sparsity pattern a cummulative sum
    102102        size_t limit = var_sparsity.end();
    103         Vector_set  csum_sparsity;
    104         csum_sparsity.resize(1, limit);
    105         csum_sparsity.clear(0);   // initialize as empty
    106103
    107104        // vecad_sparsity contains a sparsity pattern from each VecAD object
     
    204201                        // -------------------------------------------------
    205202
    206                         case CAddOp:
    207                         // add x to the cummulative summation
    208                         CPPAD_ASSERT_NARG_NRES(op, 1, 0);
    209                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    210                         csum_sparsity.binary_union(
    211                                 0,           // index in csum for result
    212                                 0,           // index in csum for left operand
    213                                 arg[0],      // index for right operand
    214                                 var_sparsity // right operand vector
    215                         );
    216                         break;
    217 
    218                         case CSubOp:
    219                         // subtract x from the cummulative summation
    220                         CPPAD_ASSERT_NARG_NRES(op, 1, 0);
    221                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    222                         csum_sparsity.binary_union(
    223                                 0,           // index in csum for result
    224                                 0,           // index in csum for left operand
    225                                 arg[0],      // index for right operand
    226                                 var_sparsity // right operand vector
    227                         );
    228                         break;
    229 
    230203                        case CSumOp:
    231                         // end of a cummulative summation
    232                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    233                         var_sparsity.assignment(
    234                                 i_var,         // target index in var_sparsity
    235                                 0,             // index in csum
    236                                 csum_sparsity  // vector version of csum
    237                         );
    238                         break;
    239 
    240                         // initialize for next summation
    241                         csum_sparsity.clear(0);
     204                        // CSumOp has a variable number of arguments and
     205                        // next_forward thinks it one has one argument.
     206                        // we must inform next_forward of this special case.
     207                        play->forward_csum(op, arg, i_op, i_var);
     208                        forward_sparse_jacobian_csum_op(
     209                                i_var, arg, var_sparsity
     210                        );
     211                        break;
    242212                        // -------------------------------------------------
    243213
  • trunk/cppad/local/forward0sweep.hpp

    r1608 r1612  
    122122        size_t compareCount = 0;
    123123
    124         // value used for cummulative summations
    125         Base zero(0);
    126         Base csum(zero);
    127 
    128124        // This is an order zero calculation, initialize vector indices
    129125        size_t *VectorInd = CPPAD_NULL;  // address for each element
     
    215211                        // -------------------------------------------------
    216212
    217                         case CAddOp:
    218                         // add x to the cummulative summation
    219                         CPPAD_ASSERT_NARG_NRES(op, 1, 0);
    220                         csum += Taylor[ arg[0] * J + 0 ];
    221                         break;
    222 
    223                         case CSubOp:
    224                         // subtract x from the cummulative summation
    225                         CPPAD_ASSERT_NARG_NRES(op, 1, 0);
    226                         csum -= Taylor[ arg[0] * J + 0 ];
    227                         break;
    228 
    229213                        case CSumOp:
    230                         // complete the cummulative summation
    231                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
    232                         Taylor[ i_var * J + 0 ] = csum + parameter[ arg[0] ];
    233 
    234                         // initialize for next summation
    235                         csum = zero;
     214                        // CSumOp has a variable number of arguments and
     215                        // next_forward thinks it one has one argument.
     216                        // we must inform next_forward of this special case.
     217                        Rec->forward_csum(op, arg, i_op, i_var);
     218                        forward_csum_op(
     219                                0, i_var, arg, num_par, parameter, J, Taylor
     220                        );
    236221                        break;
    237222
  • trunk/cppad/local/forward_sweep.hpp

    r1608 r1612  
    133133        size_t compareCount = 0;
    134134
    135         // value used for cummulative summations
    136         Base zero(0);
    137         Base csum(zero);
    138 
    139135        // if this is an order zero calculation, initialize vector indices
    140136        size_t *VectorInd = CPPAD_NULL;  // address for each element
     
    223219                        // -------------------------------------------------
    224220
    225                         case CAddOp:
    226                         // add x to the cummulative summation
    227                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    228                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
    229                         csum += Taylor[ arg[0] * J + d ];
    230                         break;
    231 
    232                         case CSubOp:
    233                         // subtract x from the cummulative summation
    234                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    235                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
    236                         csum -= Taylor[ arg[0] * J + d ];
    237                         break;
    238 
    239221                        case CSumOp:
    240                         // complete the cummulative summation
    241                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    242                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    243                         Taylor[i_var * J + d] = csum;
    244 # if ! CPPAD_USE_FORWARD0SWEEP
    245                         if( d == 0 )
    246                                 Taylor[i_var * J + d] += parameter[arg[0]];
    247 # endif
    248                         // initialize for next summation
    249                         csum = zero;
     222                        // CSumOp has a variable number of arguments and
     223                        // next_forward thinks it one has one argument.
     224                        // we must inform next_forward of this special case.
     225                        Rec->forward_csum(op, arg, i_op, i_var);
     226                        forward_csum_op(
     227                                d, i_var, arg, num_par, parameter, J, Taylor
     228                        );
    250229                        break;
    251230                        // -------------------------------------------------
  • trunk/cppad/local/op.hpp

    r1539 r1612  
    2929# include <cppad/local/cos_op.hpp>
    3030# include <cppad/local/cosh_op.hpp>
     31# include <cppad/local/csum_op.hpp>
    3132# include <cppad/local/discrete_op.hpp>
    3233# include <cppad/local/div_op.hpp>
  • trunk/cppad/local/op_code.hpp

    r1608 r1612  
    5151        AtanOp,   // atan(variable)
    5252        BeginOp,  // used to mark the beginning of the tape
    53         CAddOp,   // add a variable to the current cummulation summation
    5453        CExpOp,   // CondExp(cop, left, right, trueCase, falseCase)
    5554        ComOp,    // Compare(cop, result, left, right)
    5655        CosOp,    //  cos(variable)
    5756        CoshOp,   // cosh(variable)
    58         CSubOp,   // subtract a variable from the current cummulation summation
    59         CSumOp,   // add a prameter and terminate current cummulative summation
     57        CSumOp,   // Cummulative summation (has variable number of arguments)
    6058        DisOp,    //  dis(variable,    index)
    6159        DivpvOp,  //      parameter  / variable
     
    110108        1, // AtanOp
    111109        0, // BeginOp
    112         1, // CAddOp
    113110        6, // CExpOp
    114111        4, // ComOp
    115112        1, // CosOp
    116113        1, // CoshOp
    117         1, // CSubOp
    118         1, // CSumOp
     114        0, // CSumOp   (actually has a variable number of arguments, not zero)
    119115        2, // DisOp
    120116        2, // DivpvOp
     
    188184        2, // AtanOp
    189185        1, // BeginOp  offsets first variable to have index one (not zero)
    190         0, // CAddOp
    191186        1, // CExpOp
    192187        0, // ComOp
    193188        2, // CosOp
    194189        2, // CoshOp
    195         0, // CSubOp
    196190        1, // CSumOp
    197191        1, // DisOp
     
    368362        size_t                 nrz    ,
    369363        const  Value          *rz     )
    370 {       
     364{       size_t i;
     365       
    371366        static const char *CompareOpName[] =
    372367                { "Lt", "Le", "Eq", "Ge", "Gt", "Ne" };
     
    379374                "Atan"  ,
    380375                "Begin" ,
    381                 "CAdd"  ,
    382376                "CExp"  ,
    383377                "Com"   ,
    384378                "Cos"   ,
    385379                "Cosh"  ,
    386                 "CSub"  ,
    387380                "CSum"  ,
    388381                "DisOp" ,
     
    435428        switch( op )
    436429        {
     430                case CSumOp:
     431                /*
     432                ind[0] = number of addition variables in summation
     433                ind[1] = number of subtraction variables in summation
     434                ind[2] = index of parameter that initializes summation
     435                ind[3], ... , ind[2+ind[0]] = index for positive variables
     436                ind[3+ind[0]], ..., ind[2+ind[0]+ind[1]] = negative variables
     437                ind[3+ind[0]+ind[1]] = ind[0] + ind[1]
     438                */
     439                CPPAD_ASSERT_UNKNOWN( ind[3+ind[0]+ind[1]] == ind[0]+ind[1] );
     440                printOpField(os, " pr=", Rec->GetPar(ind[2]), ncol);
     441                for(i = 0; i < ind[0]; i++)
     442                         printOpField(os, " +v=", ind[3+i], ncol);
     443                for(i = 0; i < ind[1]; i++)
     444                         printOpField(os, " -v=", ind[3+ind[0]+i], ncol);
     445                break;
     446
    437447                case LdpOp:
    438448                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 3 );
     
    507517                case AsinOp:
    508518                case AtanOp:
    509                 case CAddOp:
    510519                case CosOp:
    511520                case CoshOp:
    512                 case CSubOp:
    513521                case ExpOp:
    514522                case LogOp:
     
    521529
    522530                case ParOp:
    523                 case CSumOp:
    524531                CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    525532                printOpField(os, "  p=", Rec->GetPar(ind[0]), ncol);
  • trunk/cppad/local/optimize.hpp

    r1610 r1612  
    182182
    183183/*!
    184 Structure used by \c optimize_record_csum
     184Structures used by \c optimize_record_csum
    185185to hold information about one variable.
    186186*/
     
    197197        bool                add;
    198198};
     199struct optimize_csum_stacks {
     200        /// stack of operations in the cummulative summation
     201        std::stack<struct optimize_csum_variable>   op_stack;
     202        /// stack of variables to be added
     203        std::stack<size_t >                         add_stack;
     204        /// stack of variables to be subtracted
     205        std::stack<size_t >                         sub_stack;
     206};
     207
    199208
    200209/*!
     
    623632\param work
    624633Is used for computaiton. On input and output,
    625 <tt>work.empty()</tt> is true.
    626         This stack is passed in so that elements can be allocated once
    627         and then the elements can be reused with different values
    628 (for speed).
     634<tt>work.op_stack.empty()</tt>,
     635<tt>work.add_stack.empty()</tt>, and
     636<tt>work.sub_stack.empty()</tt>,
     637are all true true.
     638These stacks are passed in so that elements can be allocated once
     639and then the elements can be reused with calls to \c optimize_record_csum.
    629640
    630641\par Exception
     
    655666        const Base*                                        par            ,
    656667        recorder<Base>*                                    rec            ,
    657         std::stack<struct optimize_csum_variable>&         work           )
     668        optimize_csum_stacks&                              work           )
    658669{
    659         CPPAD_ASSERT_UNKNOWN( work.empty() );
     670       
     671        CPPAD_ASSERT_UNKNOWN( work.op_stack.empty() );
     672        CPPAD_ASSERT_UNKNOWN( work.add_stack.empty() );
     673        CPPAD_ASSERT_UNKNOWN( work.sub_stack.empty() );
     674        CPPAD_ASSERT_UNKNOWN( tape[current].connect == yes_connected );
    660675
    661676        size_t                        i;
    662         size_t                        new_arg;
    663677        OpCode                        op;
    664678        const size_t*                 arg;
     
    666680        struct optimize_csum_variable var;
    667681
    668         CPPAD_ASSERT_UNKNOWN( tape[current].connect == yes_connected );
    669682        var.op  = tape[current].op;
    670683        var.arg = tape[current].arg;
    671684        var.add = true;
    672         work.push( var );
     685        work.op_stack.push( var );
    673686        Base sum_par(0);
    674         while( ! work.empty() )
    675         {       var     = work.top();
    676                 work.pop();
     687        while( ! work.op_stack.empty() )
     688        {       var     = work.op_stack.top();
     689                work.op_stack.pop();
    677690                op      = var.op;
    678691                arg     = var.arg;
     
    698711                                var.arg = tape[arg[0]].arg;
    699712                                var.add = add;
    700                                 work.push( var );
    701                         }
    702                         else
    703                         {       new_arg = tape[arg[0]].new_var;
    704                                 rec->PutArg(new_arg);
    705                                 if( add )
    706                                         i = rec->PutOp(CAddOp);
    707                                 else    i = rec->PutOp(CSubOp);
    708                                 CPPAD_ASSERT_UNKNOWN(new_arg <= i);
    709                         }
     713                                work.op_stack.push( var );
     714                        }
     715                        else if( add )
     716                                work.add_stack.push(arg[0]);
     717                        else    work.sub_stack.push(arg[0]);
    710718                        break;
    711719
     
    736744                                var.arg  = tape[arg[1]].arg;
    737745                                var.add  = add;
    738                                 work.push( var );
    739                         }
    740                         else
    741                         {       new_arg = tape[arg[1]].new_var;
    742                                 rec->PutArg(new_arg);
    743                                 if( add )
    744                                         i = rec->PutOp(CAddOp);
    745                                 else    i = rec->PutOp(CSubOp);
    746                                 CPPAD_ASSERT_UNKNOWN(new_arg <= i);
    747                         }
     746                                work.op_stack.push( var );
     747                        }
     748                        else if( add )
     749                                work.add_stack.push(arg[1]);
     750                        else    work.sub_stack.push(arg[1]);
    748751                        break;
    749752
     
    752755                }
    753756        }
    754         // add in the parameter value at the end
    755         new_arg = rec->PutPar(sum_par);
    756         rec->PutArg(new_arg);
    757         i =rec->PutOp(CSumOp);
     757        // number of variables in this cummulative sum operator
     758        size_t n_add = work.add_stack.size();
     759        size_t n_sub = work.sub_stack.size();
     760        size_t old_arg, new_arg;
     761        rec->PutArg(n_add);                // arg[0]
     762        rec->PutArg(n_sub);                // arg[1]
     763        new_arg = rec->PutPar( sum_par );
     764        rec->PutArg(new_arg);              // arg[2]
     765        for(i = 0; i < n_add; i++)
     766        {       CPPAD_ASSERT_UNKNOWN( ! work.add_stack.empty() );
     767                old_arg = work.add_stack.top();
     768                new_arg = tape[old_arg].new_var;
     769                CPPAD_ASSERT_UNKNOWN( new_arg < tape.size() );
     770                rec->PutArg(new_arg);      // arg[3+i]
     771                work.add_stack.pop();
     772        }
     773        for(i = 0; i < n_sub; i++)
     774        {       CPPAD_ASSERT_UNKNOWN( ! work.sub_stack.empty() );
     775                old_arg = work.sub_stack.top();
     776                new_arg = tape[old_arg].new_var;
     777                CPPAD_ASSERT_UNKNOWN( new_arg < tape.size() );
     778                rec->PutArg(new_arg);      // arg[3 + arg[0] + i]
     779                work.sub_stack.pop();
     780        }
     781        rec->PutArg(n_add + n_sub);        // arg[3 + arg[0] + arg[1]]
     782        i = rec->PutOp(CSumOp);
    758783        CPPAD_ASSERT_UNKNOWN(new_arg < tape.size());
    759784
     
    10831108        // temporary work space used by optimize_record_csum
    10841109        // (decalared here to avoid realloaction of memory)
    1085         std::stack<struct optimize_csum_variable> csum_work;
     1110        optimize_csum_stacks csum_work;
    10861111
    10871112        while(op != EndOp)
  • trunk/cppad/local/player.hpp

    r1598 r1612  
    497497        The input value of op does not matter. Its output value is the
    498498        next operator in the recording.
     499        For speed, \c next_forward does not check for the special case
     500        of <tt>op == CSumOp</tt>. In this case, the other return values
     501        from \c next_forward must be corrected by a call to \c forward_csum.
    499502
    500503        \param op_arg
     
    530533                // index for last result for next operator
    531534                var_index   = var_index_ += NumRes(op);
     535
     536                CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
     537                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
     538                CPPAD_ASSERT_UNKNOWN( var_index_  < num_rec_var_ );
     539        }
     540        /*!
     541        Correct \c next_forward return values when <tt>op == CSumOp</tt>.
     542
     543        \param op
     544        The input value of op must be the return value from the previous
     545        call to \c next_forward and must be \c CSumOp.
     546
     547        \param op_arg
     548        The input value of *op_arg must be the return value from the
     549        previous call to \c next_forward. Its output value is the
     550        beginning of the vector of argument indices for this operation.
     551
     552        \param op_index
     553        The input value of op_index does must be the return value from the
     554        previous call to \c next_forward. Its output value
     555        is the index of this operator in the recording.
     556
     557        \param var_index
     558        The input value of var_index must be the return value from the
     559        previous call to \c next_forward. Its output value is the
     560        index of the primary (last) result corresponding to this.
     561        */
     562        void forward_csum(
     563        OpCode& op, const size_t*& op_arg, size_t& op_index, size_t& var_index)
     564        {       using CppAD::NumRes;
     565                using CppAD::NumArg;
     566                CPPAD_ASSERT_UNKNOWN( op == CSumOp );
     567                CPPAD_ASSERT_UNKNOWN( NumArg(CSumOp) == 0 );
     568                CPPAD_ASSERT_UNKNOWN(
     569                op_arg[0] + op_arg[1] == op_arg[ 3 + op_arg[0] + op_arg[1] ]
     570                );
     571                /*
     572                The only thing that really needs fixing is op_arg_.
     573                Actual number of arugments for this operator is
     574                        op_arg[0] + op_arg[1] + 4.
     575                We must change op_arg_ so that when you add NumArg(CSumOp)
     576                you get first argument for next operator in sequence.
     577                */
     578                op_arg_    += op_arg[0] + op_arg[1] + 4;
    532579
    533580                CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
     
    603650        The last operator sets op_arg equal to the beginning of the
    604651        argument indices for the entire recording.
     652        For speed, \c next_reverse does not check for the special case
     653        of <tt>op == CSumOp</tt>. In this case, the other return values
     654        from \c next_reverse must be corrected by a call to \c reverse_csum.
     655
    605656
    606657        \param op_index
     
    639690                op_arg      = op_arg_ + rec_op_arg_;                 // pointer
    640691        }
     692        /*!
     693        Correct \c next_reverse return values when <tt>op == CSumOp</tt>.
     694
     695        \param op
     696        The input value of op must be the return value from the previous
     697        call to \c next_reverse and must be \c CSumOp.
     698
     699        \param op_arg
     700        The input value of *op_arg must be the return value from the
     701        previous call to \c next_reverse. Its output value is the
     702        beginning of the vector of argument indices for this operation.
     703
     704        \param op_index
     705        The input value of op_index must be the return value from the
     706        previous call to \c next_reverse. Its output value
     707        is the index of the this operator in the recording.
     708
     709        \param var_index
     710        The input value of var_index must be the return value from the
     711        previous call to \c next_reverse. Its output value is the
     712        index of the primary (last) result corresponding to this operator.
     713        */
     714
     715        void reverse_csum(
     716        OpCode& op, const size_t*& op_arg, size_t& op_index, size_t& var_index)
     717        {       using CppAD::NumRes;
     718                using CppAD::NumArg;
     719                CPPAD_ASSERT_UNKNOWN( op == CSumOp );
     720                CPPAD_ASSERT_UNKNOWN( NumArg(CSumOp) == 0 );
     721                /*
     722                The things needs fixing are op_arg_ and op_arg. Currently,
     723                op_arg points first arugment for the previous operator.
     724                */
     725                --op_arg;
     726                op_arg_    -= (op_arg[0] + 4);
     727                op_arg      = op_arg_ + rec_op_arg_;
     728
     729                CPPAD_ASSERT_UNKNOWN(
     730                op_arg[0] + op_arg[1] == op_arg[ 3 + op_arg[0] + op_arg[1] ]
     731                );
     732                CPPAD_ASSERT_UNKNOWN( op_index_  < num_rec_op_ );
     733                CPPAD_ASSERT_UNKNOWN( op_arg_ + NumArg(op) <= num_rec_op_arg_ );
     734                CPPAD_ASSERT_UNKNOWN( var_index_  < num_rec_var_ );
     735        }
    641736
    642737};
  • trunk/cppad/local/prototype_op.hpp

    r1588 r1612  
    13231323\param rev_jacobian
    13241324\a rev_jacobian[i_z]
    1325 is all false (true) if the Jacobian of G with respect to z is alwyas zero
     1325is all false (true) if the Jacobian of G with respect to z must be zero
    13261326(may be non-zero).
    13271327\n
    13281328\n
    13291329\a rev_jacobian[i_x]
    1330 is all zero (ones) if the Jacobian with respect to x is zero (non-zero).
     1330is all false (true) if the Jacobian with respect to x must be zero
     1331(may be non-zero).
    13311332On input, it corresponds to the function G,
    13321333and on output it corresponds to the function H.
  • trunk/cppad/local/rev_hes_sweep.hpp

    r1608 r1612  
    246246                        // -------------------------------------------------
    247247
    248                         case CAddOp:
    249                         // add x to the cummulative summation
    250                         CPPAD_ASSERT_NARG_NRES(op, 1, 0)
    251                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    252                         reverse_sparse_hessian_linear_unary_op(
    253                         i_var+1, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    254                         );
    255                         break;
    256 
    257                         case CSubOp:
    258                         // subtract x from the cummulative summation
    259                         CPPAD_ASSERT_NARG_NRES(op, 1, 0)
    260                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    261                         reverse_sparse_hessian_linear_unary_op(
    262                         i_var+1, arg[0], RevJac, for_jac_sparse, rev_hes_sparse
    263                         );
    264                         break;
    265 
    266248                        case CSumOp:
    267                         // end of a cummulative summation
    268                         CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     249                        // CSumOp has a variable number of arguments and
     250                        // next_reverse thinks it one has one argument.
     251                        // We must inform next_reverse of this special case.
     252                        play->reverse_csum(op, arg, i_op, i_var);
     253                        reverse_sparse_hessian_csum_op(
     254                                i_var, arg, RevJac, rev_hes_sparse
     255                        );
    269256                        break;
    270257                        // -------------------------------------------------
  • trunk/cppad/local/rev_jac_sweep.hpp

    r1608 r1612  
    213213                        // -------------------------------------------------
    214214
    215                         case CAddOp:
    216                         // add x to the cummulative summation
    217                         CPPAD_ASSERT_NARG_NRES(op, 1, 0);
    218                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    219                         reverse_sparse_jacobian_unary_op(
    220                                 i_var+1, arg[0], var_sparsity
    221                         );
    222                         break;
    223 
    224                         case CSubOp:
    225                         // subtract x from the cummulative summation
    226                         CPPAD_ASSERT_NARG_NRES(op, 1, 0);
    227                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    228                         reverse_sparse_jacobian_unary_op(
    229                                 i_var+1, arg[0], var_sparsity
    230                         );
    231                         break;
    232 
    233215                        case CSumOp:
    234                         // end of a cummulative summation
    235                         CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     216                        // CSumOp has a variable number of arguments and
     217                        // next_reverse thinks it one has one argument.
     218                        // We must inform next_reverse of this special case.
     219                        play->reverse_csum(op, arg, i_op, i_var);
     220                        reverse_sparse_jacobian_csum_op(
     221                                i_var, arg, var_sparsity
     222                        );
    236223                        break;
    237224                        // -------------------------------------------------
  • trunk/cppad/local/reverse_sweep.hpp

    r1608 r1612  
    143143        size_t         i_op;
    144144        size_t        i_var;
    145         size_t            k;
    146145
    147146        const size_t   *arg = 0;
     
    251250                        // --------------------------------------------------
    252251
    253                         case CAddOp:
    254                         // add x to the cummulative summation
    255                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    256                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
    257                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    258                         for(k = 0; k <= d; k++)
    259                                 Partial[ arg[0] * K + k ] +=
    260                                         Partial[ (i_var+1) * K + k ];
    261                         break;
    262 
    263                         case CSubOp:
    264                         // subtract x from the cummulative summation
    265                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    266                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 0 );
    267                         CPPAD_ASSERT_UNKNOWN( (i_var+1) < numvar );
    268                         for(k = 0; k <= d; k++)
    269                                 Partial[ arg[0] * K + k ] -=
    270                                         Partial[ (i_var+1) * K + k ];
    271                         break;
    272 
    273252                        case CSumOp:
     253                        // CSumOp has a variable number of arguments and
     254                        // next_reverse thinks it one has one argument.
     255                        // We must inform next_reverse of this special case.
     256                        Rec->reverse_csum(op, arg, i_op, i_var);
     257                        reverse_csum_op(
     258                                d, i_var, arg, K, Partial
     259                        );
    274260                        // end of a cummulative summation
    275                         CPPAD_ASSERT_UNKNOWN( NumArg(op) == 1 );
    276                         CPPAD_ASSERT_UNKNOWN( NumRes(op) == 1 );
    277261                        break;
    278262                        // -------------------------------------------------
  • trunk/makefile.am

    r1592 r1612  
    9999        cppad/local/cos_op.hpp \
    100100        cppad/local/cosh_op.hpp \
     101        cppad/local/csum_op.hpp \
    101102        cppad/local/cppad_assert.hpp \
    102103        cppad/local/declare_ad.hpp \
  • trunk/omh/whats_new_09.omh

    r1610 r1612  
    6060trying to read and understand the CppAD source code.)
    6161
     62$head 12-22$$
     63Convert the optimization of a sequence of additions from multiple operators
     64to one operator with a varying number of arguments. This improved the speed
     65for forward and reverse mode computations of an optimized tape.
     66
    6267$head 12-18$$
    6368It turns out that detection of a sequence of additions makes the optimization
  • trunk/test_more/check_simple_vector.cpp

    r1556 r1612  
    1111-------------------------------------------------------------------------- */
    1212
    13 # include <cppad/configure.hpp>
    14 # include <cppad/vector.hpp>
    15 # include <cppad/check_simple_vector.hpp>
     13# include <cppad/cppad.hpp>
    1614# include <set>
    1715# include <vector>
     
    2725                CheckSimpleVector<Scalar, std::valarray<Scalar> > (x, y);
    2826# if CPPAD_BOOSTVECTOR
    29                 typedef boost_vector boost::numeric::ublas::vector<Scalar>;
     27                typedef boost::numeric::ublas::vector<Scalar> boost_vector;
    3028                CheckSimpleVector<Scalar, boost_vector > (x, y);
    3129# endif
Note: See TracChangeset for help on using the changeset viewer.