Changeset 3339


Ignore:
Timestamp:
Sep 18, 2014 8:34:53 AM (6 years ago)
Author:
bradbell
Message:

Fix problems running all tests (caused by adding extra phantom variable to
end of operation sequence).

Location:
branches/cache
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/cache/example/optimize.cpp

    r2506 r3339  
    7979        // declare independent variables and start tape recording
    8080        CppAD::Independent(X);
    81         size_t n_var = 1 + n; // one phantom variable at the beginning
    82         size_t n_opt = 1 + n; // and one for each independent variable
     81        size_t n_var = 2 + n; // A phantom variable at the beginning and end
     82        size_t n_opt = 2 + n; // and a varialbe for each independent variable
    8383
    8484        // range space vector
  • branches/cache/example/seq_property.cpp

    r2991 r3339  
    6565
    6666        // Use nvar to track the number of variables in the operation sequence.
    67         // Start with one for the phantom variable at tape address zero.
    68         size_t nvar = 1;
     67        // Include two phantom variables, one at beginning of tape and one at end.
     68        size_t nvar = 2;
    6969
    7070        // Use npar to track the number of parameters in the operation sequence.
  • branches/cache/omh/whats_new/whats_new_14.omh

    r3311 r3339  
    1414$dollar @$$
    1515$spell
     16        var
    1617        alloc
    1718        ifndef
     
    5556assist you in learning about changes between various versions of CppAD.
    5657
     58$head cache branch$$
     59$subhead 10-18$$
     60An extra phantom (not used) variable was added to the end of the operation
     61sequence; i.e., $cref/f.size_var()/seq_property/size_var/$$ increased by one.
     62
    5763$head 05-28$$
    5864$list number$$
  • branches/cache/test_more/optimize.cpp

    r3008 r3339  
    241241                // number of variables before optimization
    242242                // (include ay[0] and ay[1])
    243                 size_t n_before = f.size_var();
     243                                size_t n_before = f.size_var();
    244244               
    245245                // now optimize the operation sequence
     
    405405       
    406406                // Check size before optimization
    407                 ok &= F.size_var() == (n + 1 + original);
     407                ok &= F.size_var() == (n + 2 + original);
    408408       
    409409                // Optimize the operation sequence
     
    411411       
    412412                // Check size after optimization
    413                 ok &= F.size_var() == (n + 1 + opt);
     413                ok &= F.size_var() == (n + 2 + opt);
    414414       
    415415                // check result now
     
    654654       
    655655                // Check size before optimization
    656                 ok &= F.size_var() == (n + 1 + original);
     656                ok &= F.size_var() == (n + 2 + original);
    657657       
    658658                // Optimize the operation sequence
     
    660660       
    661661                // Check size after optimization
    662                 ok &= F.size_var() == (n + 1 + opt);
     662                ok &= F.size_var() == (n + 2 + opt);
    663663       
    664664                // check result now
     
    713713
    714714                // check number of variables in original function
    715                 ok &= (F.size_var() ==  1 + n + m + 4 );
     715                ok &= (F.size_var() ==  2 + n + m + 4 );
    716716       
    717717                CppAD::vector<double> x(n), y(m);
     
    726726
    727727                // check number of variables  in optimized version
    728                 ok &= (F.size_var() == 1 + n + m + 2 );
     728                ok &= (F.size_var() == 2 + n + m + 2 );
    729729
    730730                y   = F.Forward(0, x);
     
    777777
    778778                // check number of variables in original function
    779                 ok &= (F.size_var() ==  1 + n + m + 4 );
     779                ok &= (F.size_var() ==  2 + n + m + 4 );
    780780       
    781781                CppAD::vector<double> x(n), y(m);
     
    790790
    791791                // check number of variables  in optimized version
    792                 ok &= (F.size_var() == 1 + n + m + 2 );
     792                ok &= (F.size_var() == 2 + n + m + 2 );
    793793
    794794                y   = F.Forward(0, x);
     
    832832
    833833                // check number of variables in original function
    834                 ok &= (F.size_var() ==  1 + n + n_operations );
     834                ok &= (F.size_var() ==  2 + n + n_operations );
    835835       
    836836                CppAD::vector<double> x(n), y(m);
     
    843843
    844844                // check same number of variables in optimized version
    845                 ok &= (F.size_var() == 1 + n + n_operations );
     845                ok &= (F.size_var() == 2 + n + n_operations );
    846846
    847847                y   = F.Forward(0, x);
     
    864864                        X[j] = double(j + 2);
    865865
    866                 size_t n_original = 1 + n;
    867                 size_t n_optimize = 1 + n;
     866                size_t n_original = 2 + n;
     867                size_t n_optimize = 2 + n;
    868868
    869869                // range space vector
     
    13841384                // create function
    13851385                CppAD::ADFun<double> g(ax, ay);
    1386                 // should have 1 + n + m + m varaibles
    1387                 ok &= g.size_var() == (1 + n + m + m);
     1386                // should have 2 + n + m + m varaibles
     1387                ok &= g.size_var() == (2 + n + m + m);
    13881388                g.optimize();
    1389                 // should have 1 + n + m varaibles
    1390                 ok &= g.size_var() == (1 + n + m);
     1389                // should have 2 + n + m varaibles
     1390                ok &= g.size_var() == (2 + n + m);
    13911391
    13921392                // now test that the optimized function gives same results
Note: See TracChangeset for help on using the changeset viewer.