Changeset 1607


Ignore:
Timestamp:
Dec 11, 2009 8:01:16 AM (11 years ago)
Author:
bradbell
Message:

trunk: Minor cleanup.

optimize.cpp: better names for the test functions in this file.
optimize.hpp: change add_connect, make sure break after each case group.

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/local/optimize.hpp

    r1606 r1607  
    147147
    148148        /// There is only one operation that connects this variable to the
    149         /// independent variables and it is an AddvvOp operation.
     149        /// independent variables and it is an AddvvOp or AddpvOp.
    150150        add_connected
    151151};
     
    713713                        if( tape[i_var].connect != not_connected )
    714714                                tape[arg[0]].connect = yes_connected;
    715                         break;
     715                        break; // --------------------------------------------
    716716
    717717                        // Unary operator where operand is arg[1]
    718                         case AddpvOp:
    719718                        case DivpvOp:
    720719                        case MulpvOp:
     
    724723                        if( tape[i_var].connect != not_connected )
    725724                                tape[arg[1]].connect = yes_connected;
    726                         break;
     725                        break; // --------------------------------------------
     726
     727               
     728                        // Special case for AddpvOp
     729                        case AddpvOp:
     730                        if( tape[i_var].connect != not_connected )
     731                        {
     732                                if( tape[arg[1]].connect == not_connected )
     733                                        tape[arg[1]].connect = add_connected;
     734                                else
     735                                        tape[arg[1]].connect = yes_connected;
     736                        }
     737                        break; // --------------------------------------------
    727738
    728739               
     
    741752                                        tape[arg[1]].connect = yes_connected;
    742753                        }
     754                        break; // --------------------------------------------
    743755
    744756                        // Binary operator (not AddvvOp)
     
    753765                                tape[arg[1]].connect = yes_connected;
    754766                        }
    755                         break;
     767                        break; // --------------------------------------------
    756768
    757769                        // Conditional expression operators
     
    767779                                }
    768780                        }
     781                        break;  // --------------------------------------------
    769782
    770783                        // Operations where there is noting to do
     
    776789                        case PripOp:
    777790                        case StppOp:
    778                         break;
     791                        break;  // --------------------------------------------
    779792
    780793                        // Load using a parameter index
     
    785798                                vecad_connect[i] = yes_connected;
    786799                        }
    787                         break;
     800                        break; // --------------------------------------------
    788801
    789802                        // Load using a variable index
     
    795808                                tape[arg[1]].connect = yes_connected;
    796809                        }
    797                         break;
     810                        break; // --------------------------------------------
    798811
    799812                        // Store a variable using a parameter index
     
    802815                        if( vecad_connect[i] != not_connected )
    803816                                tape[arg[2]].connect = yes_connected;
    804                         break;
     817                        break; // --------------------------------------------
    805818
    806819                        // Store a variable using a variable index
     
    811824                                tape[arg[2]].connect = yes_connected;
    812825                        }
    813                         break;
     826                        break; // --------------------------------------------
    814827
    815828                        // all cases should be handled above
  • trunk/test_more/optimize.cpp

    r1601 r1607  
    1919        // Test the reverse dependency analysis optimization
    2020        template <class Vector>
    21         void FunOne(const Vector& x, Vector& y, size_t& original, size_t& opt)
     21        void depend_fun
     22        (const Vector& x, Vector& y, size_t& original, size_t& opt)
    2223        {       typedef typename Vector::value_type Scalar;
    2324                Scalar a;
     
    8081        }
    8182
    82         bool CaseOne(void)
     83        bool depend_one(void)
    8384        {       // Test all except for VecAD operations
    8485                bool ok = true;
     
    100101                size_t m = n;
    101102                CPPAD_TEST_VECTOR< AD<double> > Y(m);
    102                 FunOne(X, Y, original, opt);
     103                depend_fun(X, Y, original, opt);
    103104       
    104105                // create f: X -> Y and stop tape recording
     
    110111                        x[j] = Value(X[j]);
    111112                y = F.Forward(0, x);
    112                 FunOne(x, check, original, opt);
     113                depend_fun(x, check, original, opt);
    113114                for(i = 0; i < m; i++)
    114115                        ok &= (y[i] == check[i]);
     
    132133        }
    133134
    134         bool CaseTwo(void)
     135        bool depend_two(void)
    135136        {       // Test VecAD operations
    136137                bool ok = true;
     
    206207                return ok;
    207208        }
    208         bool CaseThree(void)
     209        bool depend_three(void)
    209210        {       // Power function is a special case for optimize
    210211                bool ok = true;
     
    260261
    261262        template <class Vector>
    262         void fun_one(const Vector& x, Vector& y, size_t& original, size_t& opt)
     263        void duplicate_fun
     264        (const Vector& x, Vector& y, size_t& original, size_t& opt)
    263265        {       typedef typename Vector::value_type Scalar;
    264266                original = 0;
     
    328330                return;
    329331        }
    330         bool case_one(void)
     332        bool duplicate_one(void)
    331333        {
    332334                bool ok = true;
     
    348350                size_t m = n;
    349351                CPPAD_TEST_VECTOR< AD<double> > Y(m);
    350                 fun_one(X, Y, original, opt);
     352                duplicate_fun(X, Y, original, opt);
    351353       
    352354                // create f: X -> Y and stop tape recording
     
    358360                        x[j] = Value(X[j]);
    359361                y = F.Forward(0, x);
    360                 fun_one(x, check, original, opt);
     362                duplicate_fun(x, check, original, opt);
    361363                for(i = 0; i < m; i++)
    362364                        ok &= (y[i] == check[i]);
     
    380382        }
    381383        // -------------------------------------------------------------------
    382         bool case_two(void)
     384        bool duplicate_two(void)
    383385        {       // test that duplicate expression removal is relative to
    384386                // new and not just old argument indices.
     
    445447        }
    446448        // -------------------------------------------------------------------
    447         bool case_three(void)
     449        bool duplicate_three(void)
    448450        {       // test that duplicate expression removal is relative to
    449451                // new and not just old argument indices (commutative case).
     
    514516{       bool ok = true;
    515517        // check reverse dependency analysis optimization
    516         ok     &= CaseOne();
    517         ok     &= CaseTwo();
    518         ok     &= CaseThree();
     518        ok     &= depend_one();
     519        ok     &= depend_two();
     520        ok     &= depend_three();
    519521        // check removal of duplicate expressions
    520         ok     &= case_one();
    521         ok     &= case_two();
    522         ok     &= case_three();
     522        ok     &= duplicate_one();
     523        ok     &= duplicate_two();
     524        ok     &= duplicate_three();
    523525        return ok;
    524526}
Note: See TracChangeset for help on using the changeset viewer.