Changeset 2988


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

Implement and test CExpOp optimization with reverse sparse Hessian calculation.

Location:
branches/opt_cond_exp
Files:
2 edited

Legend:

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

    r2981 r2988  
    275275                        case BeginOp:
    276276                        CPPAD_ASSERT_NARG_NRES(op, 1, 1)
     277                        break;
     278                        // -------------------------------------------------
     279
     280                        case CSkipOp:
     281                        // CSkipOp has a variable number of arguments and
     282                        // next_reverse thinks it one has one argument.
     283                        // We must inform next_reverse of this special case.
     284                        play->reverse_cskip(op, arg, i_op, i_var);
    277285                        break;
    278286                        // -------------------------------------------------
  • branches/opt_cond_exp/test_more/optimize.cpp

    r2987 r2988  
    882882                return ok;
    883883        }
    884         bool forward_sparse_jacobian_csum()
     884        bool forward_sparse_jacobian()
    885885        {       bool ok = true;
    886886                using namespace CppAD;
     
    964964                return ok;
    965965        }
    966         bool reverse_sparse_jacobian_csum()
     966        bool reverse_sparse_jacobian()
    967967        {       bool ok = true;
    968968                using namespace CppAD;
     
    10431043                return ok;
    10441044        }
    1045         bool reverse_sparse_hessian_csum(void)
     1045        bool reverse_sparse_hessian(void)
    10461046        {       bool ok = true;
    10471047                using CppAD::AD;
    10481048                size_t i, j;
    10491049       
    1050                 size_t n = 2;
     1050                size_t n = 3;
    10511051                CppAD::vector< AD<double> > X(n);
    10521052                X[0] = 1.;
    10531053                X[1] = 2.;
     1054                X[2] = 3.;
    10541055                CppAD::Independent(X);
    10551056       
    10561057                size_t m = 1;
    10571058                CppAD::vector< AD<double> > Y(m);
    1058                 Y[0] = (2. + X[0] + X[1] + 3.) * X[0];
     1059                Y[0] = CondExpGe( X[0], X[1],
     1060                        X[0] + (2. + X[1] + 3.) * X[1],
     1061                        X[0] + (2. + X[2] + 3.) * X[1]
     1062                );
    10591063       
    10601064                CppAD::vector<bool> check(n * n);
    1061                 check[0 * n + 0] = true;  // partial w.r.t. x[0], x[0]
    1062                 check[0 * n + 1] = true;  //                x[0], x[1]
    1063                 check[1 * n + 0] = true;  //                x[1], x[0]
    1064                 check[1 * n + 1] = false; //                x[1], x[1]
     1065                check[0 * n + 0] = false; // partial w.r.t. x[0], x[0]
     1066                check[0 * n + 1] = false; //                x[0], x[1]
     1067                check[0 * n + 2] = false; //                x[0], x[2]
     1068
     1069                check[1 * n + 0] = false; // partial w.r.t. x[1], x[0]
     1070                check[1 * n + 1] = true;  //                x[1], x[1]
     1071                check[1 * n + 2] = true;  //                x[1], x[2]
     1072
     1073                check[2 * n + 0] = false; // partial w.r.t. x[2], x[0]
     1074                check[2 * n + 1] = true;  //                x[2], x[1]
     1075                check[2 * n + 2] = false; //                x[2], x[2]
    10651076       
    10661077                // create function object F : X -> Y
     
    13241335        ok     &= forward_csum();
    13251336        ok     &= reverse_csum();
    1326         ok     &= forward_sparse_jacobian_csum();
    1327         ok     &= reverse_sparse_jacobian_csum();
    1328         ok     &= reverse_sparse_hessian_csum();
     1337        // sparsity patterns
     1338        ok     &= forward_sparse_jacobian();
     1339        ok     &= reverse_sparse_jacobian();
     1340        ok     &= reverse_sparse_hessian();
    13291341        // check that CondExp properly detects dependencies
    13301342        ok     &= cond_exp_depend();
Note: See TracChangeset for help on using the changeset viewer.