Changeset 2954


Ignore:
Timestamp:
Oct 16, 2013 12:32:12 AM (6 years ago)
Author:
bradbell
Message:

optimize.hpp: prepare for having a conneciton index and type.

File:
1 edited

Legend:

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

    r2920 r2954  
    146146State for this variable set during reverse sweep.
    147147*/
    148 enum optimize_connection {
     148enum optimize_connection_type {
    149149        /// There is no operation that connects this variable to the
    150150        /// independent variables.
     
    182182
    183183        /// How is this variable connected to the independent variables
    184         optimize_connection connect;
     184        optimize_connection_type connect_type;
    185185
    186186        /// Set during forward sweep to the index in the
     
    950950<tt>i = tape[current].arg[j]</tt>,
    951951and
    952 <tt>tape[arg[j]].connect == csum_connected</tt>.
     952<tt>tape[arg[j]].connect_type == csum_connected</tt>.
    953953It then follows that
    954954<tt>tape[i].new_var == tape.size()</tt>.
     
    958958must be one of <tt>AddpvOp, AddvvOp, SubpvOp, SubvpOp, SubvvOp</tt>.
    959959
    960 \li <tt>tape[current].connect</tt> must be \c yes_connected.
     960\li <tt>tape[current].connect_type</tt> must be \c yes_connected.
    961961*/
    962962
     
    975975        CPPAD_ASSERT_UNKNOWN( work.add_stack.empty() );
    976976        CPPAD_ASSERT_UNKNOWN( work.sub_stack.empty() );
    977         CPPAD_ASSERT_UNKNOWN( tape[current].connect == yes_connected );
     977        CPPAD_ASSERT_UNKNOWN( tape[current].connect_type == yes_connected );
    978978
    979979        size_t                        i;
     
    10071007                        case SubvpOp:
    10081008                        case SubvvOp:
    1009                         if( tape[arg[0]].connect == csum_connected )
     1009                        if( tape[arg[0]].connect_type == csum_connected )
    10101010                        {       CPPAD_ASSERT_UNKNOWN(
    10111011                                        size_t(tape[arg[0]].new_var) == tape.size()
     
    10401040                        case AddvvOp:
    10411041                        case AddpvOp:
    1042                         if( tape[arg[1]].connect == csum_connected )
     1042                        if( tape[arg[1]].connect_type == csum_connected )
    10431043                        {       CPPAD_ASSERT_UNKNOWN(
    10441044                                        size_t(tape[arg[1]].new_var) == tape.size()
     
    11581158        // initialize all variables has having no connections
    11591159        for(i = 0; i < num_var; i++)
    1160                 tape[i].connect = not_connected;
     1160                tape[i].connect_type = not_connected;
    11611161
    11621162        for(j = 0; j < m; j++)
    11631163        {       // mark dependent variables as having one or more connections
    1164                 tape[ dep_taddr[j] ].connect = yes_connected;
     1164                tape[ dep_taddr[j] ].connect_type = yes_connected;
    11651165        }
    11661166
     
    11681168        // vecad maps a VecAD index (which corresponds to the beginning of the
    11691169        // VecAD object) to the vecad_connect falg for the VecAD object.
    1170         CppAD::vector<optimize_connection>   vecad_connect(num_vecad_vec);
     1170        CppAD::vector<optimize_connection_type>   vecad_connect(num_vecad_vec);
    11711171        CppAD::vector<size_t> vecad(num_vecad_ind);
    11721172        j = 0;
     
    12421242                        case TanOp:
    12431243                        case TanhOp:
    1244                         if( tape[i_var].connect != not_connected )
    1245                                 tape[arg[0]].connect = yes_connected;
     1244                        if( tape[i_var].connect_type != not_connected )
     1245                                tape[arg[0]].connect_type = yes_connected;
    12461246                        break; // --------------------------------------------
    12471247
     
    12511251                        case MulpvOp:
    12521252                        case PowpvOp:
    1253                         if( tape[i_var].connect != not_connected )
    1254                                 tape[arg[1]].connect = yes_connected;
     1253                        if( tape[i_var].connect_type != not_connected )
     1254                                tape[arg[1]].connect_type = yes_connected;
    12551255                        break; // --------------------------------------------
    12561256               
    12571257                        // Special case for SubvpOp
    12581258                        case SubvpOp:
    1259                         if( tape[i_var].connect != not_connected )
     1259                        if( tape[i_var].connect_type != not_connected )
    12601260                        {
    1261                                 if( tape[arg[0]].connect == not_connected )
    1262                                         tape[arg[0]].connect = sum_connected;
     1261                                if( tape[arg[0]].connect_type == not_connected )
     1262                                        tape[arg[0]].connect_type = sum_connected;
    12631263                                else
    1264                                         tape[arg[0]].connect = yes_connected;
    1265                                 if( tape[i_var].connect == sum_connected )
    1266                                         tape[i_var].connect = csum_connected;
     1264                                        tape[arg[0]].connect_type = yes_connected;
     1265                                if( tape[i_var].connect_type == sum_connected )
     1266                                        tape[i_var].connect_type = csum_connected;
    12671267                        }
    12681268                        break; // --------------------------------------------
     
    12711271                        case AddpvOp:
    12721272                        case SubpvOp:
    1273                         if( tape[i_var].connect != not_connected )
     1273                        if( tape[i_var].connect_type != not_connected )
    12741274                        {
    1275                                 if( tape[arg[1]].connect == not_connected )
    1276                                         tape[arg[1]].connect = sum_connected;
     1275                                if( tape[arg[1]].connect_type == not_connected )
     1276                                        tape[arg[1]].connect_type = sum_connected;
    12771277                                else
    1278                                         tape[arg[1]].connect = yes_connected;
    1279                                 if( tape[i_var].connect == sum_connected )
    1280                                         tape[i_var].connect = csum_connected;
     1278                                        tape[arg[1]].connect_type = yes_connected;
     1279                                if( tape[i_var].connect_type == sum_connected )
     1280                                        tape[i_var].connect_type = csum_connected;
    12811281                        }
    12821282                        break; // --------------------------------------------
     
    12861286                        case AddvvOp:
    12871287                        case SubvvOp:
    1288                         if( tape[i_var].connect != not_connected )
     1288                        if( tape[i_var].connect_type != not_connected )
    12891289                        {
    1290                                 if( tape[arg[0]].connect == not_connected )
    1291                                         tape[arg[0]].connect = sum_connected;
     1290                                if( tape[arg[0]].connect_type == not_connected )
     1291                                        tape[arg[0]].connect_type = sum_connected;
    12921292                                else
    1293                                         tape[arg[0]].connect = yes_connected;
    1294 
    1295                                 if( tape[arg[1]].connect == not_connected )
    1296                                         tape[arg[1]].connect = sum_connected;
     1293                                        tape[arg[0]].connect_type = yes_connected;
     1294
     1295                                if( tape[arg[1]].connect_type == not_connected )
     1296                                        tape[arg[1]].connect_type = sum_connected;
    12971297                                else
    1298                                         tape[arg[1]].connect = yes_connected;
    1299                                 if( tape[i_var].connect == sum_connected )
    1300                                         tape[i_var].connect = csum_connected;
     1298                                        tape[arg[1]].connect_type = yes_connected;
     1299                                if( tape[i_var].connect_type == sum_connected )
     1300                                        tape[i_var].connect_type = csum_connected;
    13011301                        }
    13021302                        break; // --------------------------------------------
     
    13071307                        case MulvvOp:
    13081308                        case PowvvOp:
    1309                         if( tape[i_var].connect != not_connected )
     1309                        if( tape[i_var].connect_type != not_connected )
    13101310                        {
    1311                                 tape[arg[0]].connect = yes_connected;
    1312                                 tape[arg[1]].connect = yes_connected;
     1311                                tape[arg[0]].connect_type = yes_connected;
     1312                                tape[arg[1]].connect_type = yes_connected;
    13131313                        }
    13141314                        break; // --------------------------------------------
     
    13171317                        case CExpOp:
    13181318                        CPPAD_ASSERT_UNKNOWN( NumArg(CExpOp) == 6 );
    1319                         if( tape[i_var].connect != not_connected )
     1319                        if( tape[i_var].connect_type != not_connected )
    13201320                        {
    13211321                                mask = 1;
     
    13231323                                {       if( arg[1] & mask )
    13241324                                        {       CPPAD_ASSERT_UNKNOWN( size_t(arg[i]) < i_var );
    1325                                                 tape[arg[i]].connect = yes_connected;
     1325                                                tape[arg[i]].connect_type = yes_connected;
    13261326                                        }
    13271327                                        mask = mask << 1;
     
    13411341                        // Load using a parameter index
    13421342                        case LdpOp:
    1343                         if( tape[i_var].connect != not_connected )
     1343                        if( tape[i_var].connect_type != not_connected )
    13441344                        {
    13451345                                i                = vecad[ arg[0] - 1 ];
     
    13501350                        // Load using a variable index
    13511351                        case LdvOp:
    1352                         if( tape[i_var].connect != not_connected )
     1352                        if( tape[i_var].connect_type != not_connected )
    13531353                        {
    13541354                                i                    = vecad[ arg[0] - 1 ];
    13551355                                vecad_connect[i]     = yes_connected;
    1356                                 tape[arg[1]].connect = yes_connected;
     1356                                tape[arg[1]].connect_type = yes_connected;
    13571357                        }
    13581358                        break; // --------------------------------------------
     
    13621362                        i = vecad[ arg[0] - 1 ];
    13631363                        if( vecad_connect[i] != not_connected )
    1364                                 tape[arg[2]].connect = yes_connected;
     1364                                tape[arg[2]].connect_type = yes_connected;
    13651365                        break; // --------------------------------------------
    13661366
     
    13691369                        i = vecad[ arg[0] - 1 ];
    13701370                        if( vecad_connect[i] )
    1371                         {       tape[arg[1]].connect = yes_connected;
    1372                                 tape[arg[2]].connect = yes_connected;
     1371                        {       tape[arg[1]].connect_type = yes_connected;
     1372                                tape[arg[2]].connect_type = yes_connected;
    13731373                        }
    13741374                        break;
     
    14231423                        --user_j;
    14241424                        if( ! user_s[user_j].empty() )
    1425                         {       tape[arg[0]].connect = yes_connected;
     1425                        {       tape[arg[0]].connect_type = yes_connected;
    14261426                                user_keep.top() = true;
    14271427                        }
     
    14561456                        --user_i;
    14571457                        user_r[user_i].clear();
    1458                         if( tape[i_var].connect != not_connected )
     1458                        if( tape[i_var].connect_type != not_connected )
    14591459                                user_r[user_i].insert(0);
    14601460                        if( user_i == 0 )
     
    15721572                        case SubvpOp:
    15731573                        case SubvvOp:
    1574                         keep  = tape[i_var].connect != not_connected;
    1575                         keep &= tape[i_var].connect != csum_connected;
     1574                        keep  = tape[i_var].connect_type != not_connected;
     1575                        keep &= tape[i_var].connect_type != csum_connected;
    15761576                        break;
    15771577
     
    15851585
    15861586                        default:
    1587                         keep = tape[i_var].connect != not_connected;
     1587                        keep = tape[i_var].connect_type != not_connected;
    15881588                        break;
    15891589                }
     
    16321632                        // left is a variable and right is a parameter
    16331633                        case SubvpOp:
    1634                         if( tape[arg[0]].connect == csum_connected )
     1634                        if( tape[arg[0]].connect_type == csum_connected )
    16351635                        {
    16361636                                // convert to a sequence of summation operators
     
    16761676                        case SubpvOp:
    16771677                        case AddpvOp:
    1678                         if( tape[arg[1]].connect == csum_connected )
     1678                        if( tape[arg[1]].connect_type == csum_connected )
    16791679                        {
    16801680                                // convert to a sequence of summation operators
     
    17211721                        case AddvvOp:
    17221722                        case SubvvOp:
    1723                         if( (tape[arg[0]].connect == csum_connected) |
    1724                             (tape[arg[1]].connect == csum_connected)
     1723                        if( (tape[arg[0]].connect_type == csum_connected) |
     1724                            (tape[arg[1]].connect_type == csum_connected)
    17251725                        )
    17261726                        {
Note: See TracChangeset for help on using the changeset viewer.