Changeset 1590 for trunk/test_more


Ignore:
Timestamp:
Nov 26, 2009 11:48:10 AM (11 years ago)
Author:
bradbell
Message:

trunk: Start removal of identical expressions during optimization.

exzample/optimize.cpp: demonstrate this to the user.
test_more/optimize.cpp: test the cases done so far.
whats_new_09.omh: user's view of the changes.
recorder.hpp: move hash table assertion to hash_code.hpp.
hash_code.hpp: add function for hashing operators.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/test_more/optimize.cpp

    r1589 r1590  
    1616namespace {
    1717
     18        // -------------------------------------------------------------------
     19        // Test the reverse dependency analysis optimization
    1820        template <class Vector>
    19         void fun(const Vector& x, Vector& y, size_t& original, size_t& opt)
     21        void FunOne(const Vector& x, Vector& y, size_t& original, size_t& opt)
    2022        {       typedef typename Vector::value_type Scalar;
    2123                Scalar a;
     
    9799                size_t m = n;
    98100                CPPAD_TEST_VECTOR< AD<double> > Y(m);
    99                 fun(X, Y, original, opt);
     101                FunOne(X, Y, original, opt);
    100102       
    101103                // create f: X -> Y and stop tape recording
     
    107109                        x[j] = Value(X[j]);
    108110                y = F.Forward(0, x);
    109                 fun(x, check, original, opt);
     111                FunOne(x, check, original, opt);
    110112                for(i = 0; i < m; i++)
    111113                        ok &= (y[i] == check[i]);
     
    249251                return ok;
    250252        }
     253        // -------------------------------------------------------------------
     254        // Test duplicate operation analysis
     255
     256        template <class Vector>
     257        void fun_one(const Vector& x, Vector& y, size_t& original, size_t& opt)
     258        {       typedef typename Vector::value_type Scalar;
     259                original = 0;
     260                opt      = 0;
     261
     262                // unary operator where operand is arg[0] and one result
     263                Scalar a1 = CppAD::exp(x[0]);
     264                original += 1;
     265                opt      += 1;
     266
     267                // unary operator where operand is arg[0] and two results
     268                Scalar b1 = CppAD::sin(x[1]);
     269                original += 2;
     270                opt      += 2;
     271
     272                // non-communative binary operator where left is a variable
     273                // and right is a parameter
     274                Scalar c1 = x[2] - 3.;
     275                original += 1;
     276                opt      += 1;
     277
     278                // non-communative binary operator where left is a parameter
     279                // and right is a variable
     280                Scalar d1 = 3. / x[3];
     281                original += 1;
     282                opt      += 1;
     283
     284                // non-communative binary operator where left is a variable
     285                // and right is a variable
     286                Scalar e1 = pow(x[3], x[4]);
     287                original += 3;
     288                opt      += 3;
     289
     290                // duplicate variables
     291                Scalar a2 = CppAD::exp(x[0]);
     292                Scalar b2 = CppAD::sin(x[1]);  // counts for 2 variables
     293                Scalar c2 = x[2] - 3.;
     294                Scalar d2 = 3. / x[3];
     295                Scalar e2 = pow(x[3], x[4]);   // counts for 3 variables
     296                original += 8;
     297
     298                // result vector
     299                y[0] = a1 + a2;
     300                y[1] = b1 + b2;
     301                y[2] = c1 + c2;
     302                y[3] = d1 + d2;
     303                y[4] = e1 + e2;
     304                original += 5;
     305                opt      += 5;
     306
     307                return;
     308        }
     309        bool case_one(void)
     310        {
     311                bool ok = true;
     312                using CppAD::AD;
     313                size_t original;
     314                size_t opt;
     315                size_t i, j;
     316       
     317                // domain space vector
     318                size_t n  = 5;
     319                CPPAD_TEST_VECTOR< AD<double> > X(n);
     320                for(j = 0; j < n; j++)
     321                        X[j] = 1. / double(j + 1);
     322       
     323                // declare independent variables and start tape recording
     324                CppAD::Independent(X);
     325       
     326                // range space vector
     327                size_t m = n;
     328                CPPAD_TEST_VECTOR< AD<double> > Y(m);
     329                fun_one(X, Y, original, opt);
     330       
     331                // create f: X -> Y and stop tape recording
     332                CppAD::ADFun<double> F;
     333                F.Dependent(X, Y);
     334       
     335                CPPAD_TEST_VECTOR<double> x(n), y(m), check(m);
     336                for(j = 0; j < n; j++)
     337                        x[j] = Value(X[j]);
     338                y = F.Forward(0, x);
     339                fun_one(x, check, original, opt);
     340                for(i = 0; i < m; i++)
     341                        ok &= (y[i] == check[i]);
     342       
     343                // Check size before optimization
     344                ok &= F.size_var() == (n + 1 + original);
     345       
     346                // Optimize the operation sequence
     347                F.optimize();
     348       
     349                // Check size after optimization
     350                ok &= F.size_var() == (n + 1 + opt);
     351       
     352                // check result now
     353                // (should have already been checked if NDEBUG not defined)
     354                y = F.Forward(0, x);
     355                for(i = 0; i < m; i++)
     356                        ok &= (y[i] == check[i]);
     357       
     358                return ok;
     359        }
     360        // -------------------------------------------------------------------
    251361}
    252362
     
    257367        ok     &= CaseThree();
    258368
     369        // ------------------
     370        ok     &= case_one();
    259371        return ok;
    260372}
Note: See TracChangeset for help on using the changeset viewer.