Ignore:
Timestamp:
Oct 20, 2013 2:00:28 PM (7 years ago)
Author:
bradbell
Message:
  1. Add operator index to trace output.
  2. Check that new operator values have been set and are valid.
  3. Reinitialize cskip_op_ after optimization.

optimize.hpp: Add test of entirely removing an atomic call.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/opt_cond_exp/test_more/optimize.cpp

    r2977 r2979  
    1919        // -------------------------------------------------------------------
    2020        // Test of optimizing out arguments to an atomic function
    21         void algo(
     21        void g_algo(
    2222                const CppAD::vector< CppAD::AD<double> >& ax ,
    2323                      CppAD::vector< CppAD::AD<double> >& ay )
    2424        {       ay = ax; }
    2525
     26        bool atomic_no_used(void)
     27        {       bool ok = true;
     28                using CppAD::AD;
     29                using CppAD::vector;
     30       
     31                // Create a checkpoint version of the function g
     32                vector< AD<double> > ax(2), ay(1), az(1);
     33                ax[0] = 0.;
     34                ax[1] = 1.;
     35                CppAD::checkpoint<double> g_check("g_check", g_algo, ax, ay);
     36       
     37                // independent variable vector
     38                Independent(ax);
     39       
     40                // call atomic function that does not get used
     41                g_check(ax, ay);
     42       
     43                // conditional expression
     44                az[0] = CondExpLt(ax[0], ax[1], ax[0] + ax[1], ax[0] - ax[1]);
     45               
     46                // create function object f : ax -> az
     47                CppAD::ADFun<double> f;
     48                f.Dependent(ax, az);
     49
     50                // number of variables before optimization
     51                size_t n_before = f.size_var();
     52               
     53                // now optimize the operation sequence
     54                f.optimize();
     55
     56                // number of variables before optimization
     57                size_t n_after = f.size_var();
     58                ok            &= n_after + 1 == n_before;
     59       
     60                // check optimization works ok
     61                vector<double> x(2), z(1);
     62                x[0] = 4.;
     63                x[1] = 3.;
     64                z    = f.Forward(0, x);
     65                ok   = z[0] == x[0] - x[1];
     66               
     67                return ok;
     68        }
     69
    2670        bool atomic_arguments(void)
    2771        {       bool ok = true;
     
    3074                vector< AD<double> > au(2), aw(2), ax(2), ay(1);
    3175
    32                 // create atomic function corresponding to algo
     76                // create atomic function corresponding to g_algo
    3377                au[0] = 1.0;
    3478                au[1] = 2.0;
    35                 CppAD::checkpoint<double> algo_check("algo", algo, au, ax);
     79                CppAD::checkpoint<double> g_check("g_algo", g_algo, au, ax);
    3680
    3781                // start recording a new function
    3882                CppAD::Independent(ax);
    3983
    40                 // now use algo_check during the recording
     84                // now use g_check during the recording
    4185                au[0] = ax[0] + ax[1]; // this argument requires a new variable
    4286                au[1] = ax[0] - ax[1]; // this argument also requires a new variable
    43                 algo_check(au, aw);
     87                g_check(au, aw);
    4488
    4589                // now create f(x) = x_0 - x_1
Note: See TracChangeset for help on using the changeset viewer.