Changeset 2970


Ignore:
Timestamp:
Oct 18, 2013 10:16:02 PM (6 years ago)
Author:
bradbell
Message:

Convert forward_sweep to handel CSkip operators.

forward0sweep.hpp: minor clean up of doxygen, alphabetic order ops.

Location:
branches/opt_cond_exp/cppad/local
Files:
4 edited

Legend:

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

    r2968 r2970  
    127127# else
    128128                compare_change_ = forward_sweep(s, true, q,
    129                         p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
     129                        p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
     130                        cskip_var_
    130131                );
    131132# endif
     
    133134        else if( q == 0 )
    134135        {       compare_change_ = forward_sweep(s, true, q,
    135                         p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
     136                        p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
     137                        cskip_var_
    136138                );
    137139        }
    138140        else
    139141        {       forward_sweep(s, true, q,
    140                         p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
     142                        p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
     143                        cskip_var_
    141144                );
    142145        }
  • branches/opt_cond_exp/cppad/local/forward0sweep.hpp

    r2969 r2970  
    111111index i on the tape.
    112112
     113\param cskip_var
     114Is a vector with size \c numvar,
     115the input value of the elements does not matter.
     116Upon return, if cskip_var[i] is true, the value of variable with index i
     117does not affect any of the dependent variable (given the value
     118of the independent variables).
     119
    113120\a return
    114121The return value is equal to the number of ComOp operations
     
    117124(Note that if NDEBUG is true, there are no ComOp operations
    118125in Rec and hence this return value is always zero.)
    119 
    120 \param cskip_var
    121 Is a vector with size \c numvar,
    122 the input value of the elements does not matter.
    123 Upon return, if cskip_var[i] is true, the value of variable with index i
    124 does not affect any of the dependent variable (given the value
    125 of the independent variables).
    126126*/
    127127
     
    223223                // this op
    224224                Rec->next_forward(op, arg, i_op, i_var);
     225                CPPAD_ASSERT_UNKNOWN( (i_op > n)  | (op == InvOp) ); 
     226                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    225227
    226228                // check if we are skipping this operation
     
    235237                }
    236238
    237 # ifndef NDEBUG
    238                 if( i_op <= n )
    239                 {       CPPAD_ASSERT_UNKNOWN((op == InvOp) | (op == BeginOp));
    240                 }
    241                 else    CPPAD_ASSERT_UNKNOWN((op != InvOp) & (op != BeginOp));
    242 # endif
    243 
    244239                // action to take depends on the case
    245240                switch( op )
     
    279274                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    280275                        forward_atan_op_0(i_var, arg[0], J, Taylor);
     276                        break;
     277                        // -------------------------------------------------
     278
     279                        case CExpOp:
     280                        // Use the general case with d == 0
     281                        // (could create an optimzied verison for this case)
     282                        forward_cond_op_0(
     283                                i_var, arg, num_par, parameter, J, Taylor
     284                        );
     285                        break;
     286                        // ---------------------------------------------------
     287                        case ComOp:
     288                        forward_comp_op_0(
     289                        compareCount, arg, num_par, parameter, J, Taylor
     290                        );
     291                        break;
     292                        // ---------------------------------------------------
     293
     294                        case CosOp:
     295                        // sin(x), cos(x)
     296                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     297                        forward_cos_op_0(i_var, arg[0], J, Taylor);
     298                        break;
     299                        // ---------------------------------------------------
     300
     301                        case CoshOp:
     302                        // sinh(x), cosh(x)
     303                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
     304                        forward_cosh_op_0(i_var, arg[0], J, Taylor);
    281305                        break;
    282306                        // -------------------------------------------------
     
    301325                                0, 0, i_var, arg, num_par, parameter, J, Taylor
    302326                        );
    303                         break;
    304 
    305                         // -------------------------------------------------
    306                         case CExpOp:
    307                         // Use the general case with d == 0
    308                         // (could create an optimzied verison for this case)
    309                         forward_cond_op_0(
    310                                 i_var, arg, num_par, parameter, J, Taylor
    311                         );
    312                         break;
    313                         // ---------------------------------------------------
    314                         case ComOp:
    315                         forward_comp_op_0(
    316                         compareCount, arg, num_par, parameter, J, Taylor
    317                         );
    318                         break;
    319                         // ---------------------------------------------------
    320 
    321                         case CosOp:
    322                         // sin(x), cos(x)
    323                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    324                         forward_cos_op_0(i_var, arg[0], J, Taylor);
    325                         break;
    326                         // ---------------------------------------------------
    327 
    328                         case CoshOp:
    329                         // sinh(x), cosh(x)
    330                         CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    331                         forward_cosh_op_0(i_var, arg[0], J, Taylor);
    332327                        break;
    333328                        // -------------------------------------------------
  • branches/opt_cond_exp/cppad/local/forward_sweep.hpp

    r2910 r2970  
    120120index i on the tape.
    121121
     122\param cskip_var
     123Is a vector with size \c numvar,
     124
     125\li <tt>q = 0</tt>
     126In this case,
     127the input value of the elements does not matter.
     128Upon return, if cskip_var[i] is true, the value of variable with index i
     129does not affect any of the dependent variable (given the value
     130of the independent variables).
     131
     132\li <tt>q > 0</tt>
     133The vector is not modified and
     134if cskip_var[i] is true, the value of variable with index i
     135does not affect any of the dependent variable (given the value
     136of the independent variables).
     137
    122138\a return
    123139If \a p is not zero, the return value is zero.
     
    139155        const size_t          numvar,
    140156        player<Base>         *Rec,
    141         const size_t         J,
    142         Base                 *Taylor
     157        const size_t          J,
     158        Base                 *Taylor,
     159        CppAD::vector<bool>&  cskip_var
    143160)
    144161{       CPPAD_ASSERT_UNKNOWN( J >= p + 1 );
     
    166183        size_t compareCount = 0;
    167184
    168         // if this is an order zero calculation, initialize vector indices
    169185        pod_vector<size_t> VectorInd;  // address for each element
    170186        pod_vector<bool>   VectorVar;  // is element a variable
    171         i = Rec->num_rec_vecad_ind();
    172         if( i > 0 )
    173         {       VectorInd.extend(i);
    174                 VectorVar.extend(i);
    175                 while(i--)
    176                 {       VectorInd[i] = Rec->GetVecInd(i);
    177                         VectorVar[i] = false;
     187        if( q == 0 )
     188        {
     189                // this includes order zero calculation, initialize vector indices
     190                i = Rec->num_rec_vecad_ind();
     191                if( i > 0 )
     192                {       VectorInd.extend(i);
     193                        VectorVar.extend(i);
     194                        while(i--)
     195                        {       VectorInd[i] = Rec->GetVecInd(i);
     196                                VectorVar[i] = false;
     197                        }
    178198                }
     199                // includes zero order, so initialize conditional skip flags
     200                for(i = 0; i < numvar; i++)
     201                        cskip_var[i] = false;
    179202        }
    180203
     
    233256                CPPAD_ASSERT_UNKNOWN( (i_op <= n) | (op != InvOp) ); 
    234257
     258                // check if we are skipping this operation
     259                CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
     260                CPPAD_ASSERT_UNKNOWN( NumRes(EndOp)  == 0 );
     261                while( cskip_var[i_var] && NumRes(op) > 0 )
     262                {       Rec->next_forward(op, arg, i_op, i_var);
     263                        if( op == CSumOp )
     264                        {       // CSumOp has a variable number of arguments and
     265                                Rec->forward_csum(op, arg, i_op, i_var);
     266                        }
     267                }
     268
    235269                // action depends on the operator
    236270                switch( op )
     
    298332                        CPPAD_ASSERT_UNKNOWN( i_var < numvar  );
    299333                        forward_cosh_op(q, p, i_var, arg[0], J, Taylor);
     334                        break;
     335                        // -------------------------------------------------
     336
     337                        case CSkipOp:
     338                        if( q == 0 )
     339                        {       // CSumOp has a variable number of arguments and
     340                                // next_forward thinks it one has one argument.
     341                                // we must inform next_forward of this special case.
     342                                Rec->forward_cskip(op, arg, i_op, i_var);
     343                                forward_cskip_op_0(
     344                                        i_var, arg, num_par, parameter, J, Taylor, cskip_var
     345                                );
     346                        }
    300347                        break;
    301348                        // -------------------------------------------------
  • branches/opt_cond_exp/cppad/local/fun_construct.hpp

    r2968 r2970  
    462462        size_t p = 0;
    463463        compare_change_ = forward_sweep(std::cout, false,
    464                 p, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data()
     464                p, p, n, total_num_var_, &play_, taylor_col_dim_, taylor_.data(),
     465                cskip_var_
    465466        );
    466467# endif
Note: See TracChangeset for help on using the changeset viewer.