Changeset 2987


Ignore:
Timestamp:
Oct 21, 2013 11:34:37 AM (6 years ago)
Author:
bradbell
Message:

Implement and test CondExpRel? optimization with Jacobian sparsity patterns.

for_jac_sweep.hpp: remove old code (not longer relevant to skipping operations).
optimize.hpp: Fix bug where CSkipOp was inserted before some independent variables.

Location:
branches/opt_cond_exp
Files:
5 edited

Legend:

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

    r2979 r2987  
    247247                                i_var, arg[0], var_sparsity
    248248                        );
     249                        break;
     250                        // -------------------------------------------------
     251
     252                        case CSkipOp:
     253                        // CSipOp has a variable number of arguments and
     254                        // next_forward thinks it one has one argument.
     255                        // we must inform next_forward of this special case.
     256                        play->forward_cskip(op, arg, i_op, i_var);
    249257                        break;
    250258                        // -------------------------------------------------
  • branches/opt_cond_exp/cppad/local/forward_sweep.hpp

    r2986 r2987  
    259259
    260260                // check if we are skipping this operation
    261                 CPPAD_ASSERT_UNKNOWN( NumRes(CSkipOp) == 0 );
    262                 CPPAD_ASSERT_UNKNOWN( NumRes(EndOp)  == 0 );
    263261                while( cskip_op[i_op] )
    264262                {       if( op == CSumOp )
  • branches/opt_cond_exp/cppad/local/optimize.hpp

    r2984 r2987  
    18841884                // determine if we should insert a conditional skip here
    18851885                bool skip = cskip_info_next < cskip_info.size();
     1886                skip     &= (op != BeginOp) & (op != InvOp);
    18861887                if( skip )
    18871888                {       j     = cskip_info_order[cskip_info_next];
  • branches/opt_cond_exp/cppad/local/rev_jac_sweep.hpp

    r2981 r2987  
    255255                        case BeginOp:
    256256                        CPPAD_ASSERT_NARG_NRES(op, 1, 1);
     257                        break;
     258                        // -------------------------------------------------
     259
     260                        case CSkipOp:
     261                        // CSkipOp has a variable number of arguments and
     262                        // next_reverse thinks it one has one argument.
     263                        // We must inform next_reverse of this special case.
     264                        play->reverse_cskip(op, arg, i_op, i_var);
    257265                        break;
    258266                        // -------------------------------------------------
  • branches/opt_cond_exp/test_more/optimize.cpp

    r2986 r2987  
    890890       
    891891                // dimension of the range space
    892                 size_t m = 2;
     892                size_t m = 3;
    893893       
    894894                // independent variable vector
     
    896896                X[0] = 2.;
    897897                X[1] = 3.;
     898                X[2] = 4.;
    898899                Independent(X);
    899900       
     
    917918                Y[index]             = Y[0] - (X[1] + X[2]);
    918919                Check[index * n + 0] = true;
     920                Check[index * n + 1] = true;
     921                Check[index * n + 2] = true;
     922                index++;
     923
     924                // Y[2]
     925                // 2DO: There is a subtitle issue that has to do with using reverse
     926                // jacobian sparsity patterns during the optimization process.
     927                // We need an option to include X[0] in the sparsity pattern
     928                // so the optimizer can know it affects the results.
     929                Y[index]             = CondExpLe(X[0], X[1], X[1]+X[1], X[2]-X[2]);
     930                Check[index * n + 0] = false;
    919931                Check[index * n + 1] = true;
    920932                Check[index * n + 2] = true;
     
    960972       
    961973                // dimension of the range space
    962                 size_t m = 2;
     974                size_t m = 3;
    963975       
    964976                // independent variable vector
     
    966978                X[0] = 2.;
    967979                X[1] = 3.;
     980                X[2] = 4.;
    968981                Independent(X);
    969982       
     
    9871000                Y[index]             = Y[0] - (X[1] + X[2]);
    9881001                Check[index * n + 0] = true;
     1002                Check[index * n + 1] = true;
     1003                Check[index * n + 2] = true;
     1004                index++;
     1005
     1006                // Y[2]
     1007                // 2DO: There is a subtitle issue that has to do with using reverse
     1008                // jacobian sparsity patterns during the optimization process.
     1009                // We need an option to include X[0] in the sparsity pattern
     1010                // so the optimizer can know it affects the results.
     1011                Y[index]             = CondExpLe(X[0], X[1], X[1]+X[1], X[2]-X[2]);
     1012                Check[index * n + 0] = false;
    9891013                Check[index * n + 1] = true;
    9901014                Check[index * n + 2] = true;
Note: See TracChangeset for help on using the changeset viewer.