Changeset 1636


Ignore:
Timestamp:
Jan 24, 2010 11:57:24 PM (10 years ago)
Author:
bradbell
Message:

/home/bradbell/cppad/trunk.new: Split function recording from class definition.

ode_fast.hpp: count calls to eval_r.
ode_simple.hpp: count calls to eval_r.
ode_problem.hpp: add fucntion for counting calls to eval_r.
ode_speed.cpp: report number calls to eval_r.
speed.cpp: report number calls to eval_r.
hes_fg_map.cpp: use C style indexing in all the mathematics (base zero).
vec_fun_pattern.cpp: use C style indexing in all the mathematics (base zero).
ode_check.cpp: fix bug in test value for objective.
svn_status.sh: remove cppad_ipopt/test/test from status list.
check_doxygen.sh: add fun_record.hpp to warning check list.
retape_k1_l2.cpp: another test case.
test.cpp: add retape_k1_l2 and change retape to retape_k1_l1.
retape: move to retape_k1_l1.
test/makefile.am: add retape_k1_l2 and change retape to retape_k1_l1.
*/makefile.in: changes transferred from corresponding makefile.am.
speed/makefile.am: add fun_record.hpp to source list.
fun_record.hpp: move and document operation sequence recording to here.
cppad_ipopt_nlp.*: move operation sequence recording from here.
src/makefile.am: add fun_record.hpp to source list.
ode_run.hpp: test derivative at initial point (better user control).
get_started.hpp: test derivative at initial point (better user control).
check_svn_dist.sh: fix attempt to execute cppad_ipopt/src/src.
whats_new_10.omh: user's view of the changes.

Location:
trunk
Files:
2 added
24 edited
1 moved

Legend:

Unmodified
Added
Removed
  • trunk/check_doxygen.sh

    r1634 r1636  
    8383        sparse_set.hpp
    8484
     85        fun_record.hpp
    8586        hes_fg_map.cpp
    8687        jac_g_map.cpp
  • trunk/check_svn_dist.sh

    r1635 r1636  
    5757        program=`echo $name | sed -e 's|.*/||'`
    5858        # src directories create libraries
    59         if [ "$program" != "$src" ]
     59        if [ "$program" != "src" ]
    6060        then
    6161                echo "./$program"
  • trunk/cppad_ipopt/example/get_started.cpp

    r1628 r1636  
    152152                app->Options()->
    153153                SetStringValue("derivative_test", "second-order");
     154                app->Options()-> SetNumericValue(
     155                        "point_perturbation_radius", 0.
     156                );
    154157
    155158                // Initialize the IpoptApplication and process the options
  • trunk/cppad_ipopt/example/makefile.in

    r1635 r1636  
    9090CYGPATH_W = @CYGPATH_W@
    9191
    92 # $Id: makefile.am 1634 2010-01-24 08:44:17Z bradbell $
     92# $Id: makefile.am 1635 2010-01-24 16:27:06Z bradbell $
    9393# -----------------------------------------------------------------------------
    9494# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-10 Bradley M. Bell
  • trunk/cppad_ipopt/example/ode_check.cpp

    r1635 r1636  
    9898                check += eval_H<Number>(k + 1, y_i, a);
    9999        }
    100         Number obj_value = obj_value;
     100        Number obj_value = 0.; // optimal object (no noise in simulation)
    101101        ok &= CppAD::NearEqual(check, obj_value, rel_tol, abs_tol);
    102102
  • trunk/cppad_ipopt/example/ode_fast.hpp

    r1628 r1636  
    5858                {       return Nz + 1 + Nz; }
    5959                ADVector eval_r(size_t k, const ADVector &u)
    60                 {       size_t j;
     60                {       count_eval_r();
     61
     62                        size_t j;
    6163                        ADVector y(Ny), a(Na);
    6264                        // objective function --------------------------------
  • trunk/cppad_ipopt/example/ode_problem.hpp

    r1628 r1636  
    9393                return diff * diff;
    9494        }
     95        // function used to count the number of calls to eval_r
     96        size_t count_eval_r(void)
     97        {       static size_t count = 0;
     98                ++count;
     99                return count;
     100        }
    95101}
    96102// END PROGRAM
  • trunk/cppad_ipopt/example/ode_run.hpp

    r1635 r1636  
    101101        // Derivative testing is very slow for large problems
    102102        // so comment this out if you use a large value for N[].
    103         app->Options()-> SetStringValue(
    104                 "derivative_test", "second-order"
    105         );
     103        app->Options()-> SetStringValue( "derivative_test", "second-order");
     104        app->Options()-> SetNumericValue( "point_perturbation_radius", 0.);
    106105
    107106        // Initialize the application and process the options
  • trunk/cppad_ipopt/example/ode_simple.hpp

    r1628 r1636  
    6060                // using an Algorithmic Differentiation (AD) class.
    6161                ADVector eval_r(size_t not_used, const ADVector&  x)
    62                 {       // temporary indices
     62                {       count_eval_r();
     63
     64                        // temporary indices
    6365                        size_t i, j, k;
    6466                        // # of components of x corresponding to values for y
  • trunk/cppad_ipopt/speed/makefile.am

    r1634 r1636  
    3838        speed.cpp \
    3939        ../src/cppad_ipopt_nlp.cpp \
     40        ../src/fun_record.hpp \
    4041        ../src/hes_fg_map.cpp \
    4142        ../src/jac_g_map.cpp \
  • trunk/cppad_ipopt/speed/makefile.in

    r1635 r1636  
    6363CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
    6464        -o $@
     65COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
     66        $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
     67CCLD = $(CC)
     68LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
    6569SOURCES = $(speed_SOURCES)
    6670DIST_SOURCES = $(speed_SOURCES)
     
    205209        speed.cpp \
    206210        ../src/cppad_ipopt_nlp.cpp \
     211        ../src/fun_record.hpp \
    207212        ../src/hes_fg_map.cpp \
    208213        ../src/jac_g_map.cpp \
  • trunk/cppad_ipopt/speed/ode_speed.cpp

    r1635 r1636  
    2727# include "../example/ode_fast.hpp"
    2828# include <cassert>
     29# include <cstring>
    2930
    3031# if CPPAD_GETTIMEOFDAY & CPPAD_NO_MICROSOFT
     
    4748}
    4849
    49 double ode_speed(const std::string& name)
     50double ode_speed(const char* name, size_t& count)
    5051{
    5152        // determine simple and retape flags
    5253        bool simple = true, retape = true;
    53         if( name == "simple_retape_no" )
     54        if( std::strcmp(name, "simple_retape_no") == 0 )
    5455        {       simple = true; retape = false; }
    55         else if( name == "simple_retape_yes" )
     56        else if( std::strcmp(name, "simple_retape_yes") == 0 )
    5657        {       simple = true; retape = true; }
    57         else if( name == "fast_retape_no" )
     58        else if( std::strcmp(name, "fast_retape_no") == 0 )
    5859        {       simple = false; retape = false; }
    59         else if( name == "fast_retape_yes" )
     60        else if( std::strcmp(name, "fast_retape_yes") == 0 )
    6061        {       simple = false; retape = true; }
    6162        else    assert(false);
     
    6364        size_t i;
    6465        double s0, s1;
     66        size_t  c0, c1;
    6567
    6668        // solution vector
     
    7779
    7880        s0              = current_second();
     81        c0              = count_eval_r();
    7982        if( simple )
    8083                ipopt_ode_case<FG_simple>(retape, N, x);
    8184        else    ipopt_ode_case<FG_fast>(retape, N, x);
    8285        s1              = current_second();
     86        c1              = count_eval_r();
     87        count           = c1 - c0 - 1;
    8388        return s1 - s0;
    8489}
  • trunk/cppad_ipopt/speed/speed.cpp

    r1628 r1636  
    1111-------------------------------------------------------------------------- */
    1212
    13 # include <iostream>  // system include files used for I/O
    14 # include <string>    // std::string
     13# include <cstdio>  // system include files used for I/O
     14# include <string>  // std::string
    1515
    1616// external complied tests
    17 extern double ode_speed(const std::string& name);
     17extern double ode_speed(const char* name, size_t& count);
    1818
    1919// main program that runs all the cppad_ipopt speed tests
    2020int main(void)
    21 {       using std::cout;
    22         using std::endl;
    23         std::string name;
     21{       using std::printf;
     22        const char* name;
    2423        double      seconds;
     24        size_t      count;
    2525
    26         seconds = ode_speed("simple_retape_yes");
    27         cout << "ode simple_retape_yes: seconds = " << seconds << std::endl;
     26        name    = "simple_retape_yes";
     27        seconds = ode_speed(name, count);
     28        printf("ode %20s: seconds = %5.2f: count = %d\n", name, seconds, count);
    2829
    29         seconds = ode_speed("simple_retape_no");
    30         cout << "ode simple_retape_no:  seconds = " << seconds << std::endl;
     30        name    = "simple_retape_no";
     31        seconds = ode_speed(name, count);
     32        printf("ode %20s: seconds = %5.2f: count = %d\n", name, seconds, count);
    3133
    32         seconds = ode_speed("fast_retape_yes");
    33         cout << "ode fast_retape_yes:   seconds = " << seconds << std::endl;
     34        name    = "fast_retape_yes";
     35        seconds = ode_speed(name, count);
     36        printf("ode %20s: seconds = %5.2f: count = %d\n", name, seconds, count);
    3437
    35         seconds = ode_speed("fast_retape_no");
    36         cout << "ode fast_retape_no:    seconds = " << seconds << std::endl;
     38        name    = "fast_retape_no";
     39        seconds = ode_speed(name, count);
     40        printf("ode %20s: seconds = %5.2f: count = %d\n", name, seconds, count);
    3741       
    3842        return 0;
  • trunk/cppad_ipopt/src/cppad_ipopt_nlp.cpp

    r1634 r1636  
    1515# include "hes_fg_map.hpp"
    1616# include "vec_fun_pattern.hpp"
     17# include "fun_record.hpp"
    1718
    1819// define as 0 for false or 1 for true
     
    4344          fg_info_ ( fg_info ) ,
    4445          solution_ (solution)
    45 {       size_t j, k;
     46{       size_t k;
    4647
    4748        // set information needed in cppad_ipopt_fg_info
    48         fg_info->set_n(n);
    49         fg_info->set_m(m);
     49        fg_info_->set_n(n);
     50        fg_info_->set_m(m);
    5051
    5152        // get information from derived class version of fg_info
    52         K_ = fg_info->number_functions();
     53        K_ = fg_info_->number_functions();
    5354        L_.resize(K_);
    5455        p_.resize(K_);
     
    5657        r_fun_.resize(K_);
    5758        retape_.resize(K_);
     59        tape_ok_.resize(K_);
    5860        pattern_jac_r_.resize(K_);
    5961        pattern_r_lag_.resize(K_);
     
    6163        size_t max_q      = 0;
    6264        for(k = 0; k < K_; k++)
    63         {       L_[k]       = fg_info->number_terms(k);
    64                 p_[k]       = fg_info->range_size(k);
    65                 q_[k]       = fg_info->domain_size(k);
    66                 retape_[k]  = fg_info->retape(k);
     65        {       L_[k]       = fg_info_->number_terms(k);
     66                p_[k]       = fg_info_->range_size(k);
     67                q_[k]       = fg_info_->domain_size(k);
     68                retape_[k]  = fg_info_->retape(k);
    6769                max_p       = std::max(max_p, p_[k]);
    6870                max_q       = std::max(max_q, q_[k]);
     
    7375        J_.resize(max_q);
    7476# ifndef NDEBUG
    75         size_t i, ell;
     77        size_t i, j, ell;
    7678        // check for valid range and domain indices
    7779        for(k = 0; k < K_; k++) for(ell = 0; ell < L_[k]; ell++)
     
    8183                for( j = 0; j < q_[k]; j++)
    8284                        J_[j] = n; // an invalid domain index
    83                 fg_info->index(k, ell, I_, J_);
     85                fg_info_->index(k, ell, I_, J_);       
    8486                for( i = 0; i < p_[k]; i++) if( I_[i] > m )
    8587                {       std::cerr << "k=" << k << ", ell=" << ell
     
    99101# endif
    100102        // record r[k] for functions that do not need retaping
    101         for(k = 0; k < K_; k++) if( ! retape_[k] )
    102         {       // Record r_k (u): operation sequence does not depend on value
    103                 // of u but record at initial value to make debugging easier.
    104                 fg_info->index(k, 0, I_, J_);
    105                 ADVector u_ad(q_[k]);
    106                 for(j = 0; j < q_[k]; j++)
    107                         u_ad[j] = x_i[ J_[j] ];
    108                 record_r_fun(
    109                         fg_info_, k, p_, q_, u_ad, // inputs
    110                         r_fun_                     // outputs
    111                 );
     103        for(k = 0; k < K_; k++)
     104        {       tape_ok_[k] = false;
     105                 if( ! retape_[k] )
     106                {       // Operation sequence does not depend on value
     107                        // of u so record it once here in the constructor.
     108                        fg_info_->index(k, 0, I_, J_);
     109                        fun_record(
     110                                fg_info_        ,   // inputs
     111                                k               ,
     112                                p_              ,
     113                                q_              ,
     114                                n_              ,
     115                                x_i_            ,
     116                                J_              ,
     117                                r_fun_              // output
     118                        );
     119                        tape_ok_[k] = true;
     120                }
    112121        }
    113122
     
    146155}
    147156
    148 // static member function that records operation sequence
    149 void cppad_ipopt_nlp::record_r_fun(
    150         cppad_ipopt_fg_info*   fg_info  ,
    151         size_t                 k        ,
    152         SizeVector&            p        ,
    153         SizeVector&            q        ,
    154         ADVector&              u_ad     ,
    155         ADFunVector&           r_fun    )
    156 /*
    157 fg_info: input
    158 the cppad_ipopt_fg_info object that is used to information
    159 about the representation of fg(x).
    160 
    161 k: input
    162 index of the function r_k (u)
    163 
    164 p: input
    165 p[k] is number of components in the range space for r_k (u).
    166 
    167 q: input
    168 q[k] number of components in domain space for r_k (u).
    169 
    170 u_ad: input
    171 vector of independent variable values at which to record r_k (u).
    172 This is an input except for
    173 the fact that its CppAD private data changes.
    174 
    175 r_fun: output
    176 The CppAD operation sequence corresponding to the value of u_ad,
    177 and the algorithm used by fg_info, is stored in r_fun[k]. (Any operation
    178 seqeunce that was previously in r_fun[k] is deleted.)
    179 */
    180 {       CPPAD_ASSERT_UNKNOWN( u_ad.size() == size_t(q[k]) );
    181         // start the recording
    182         CppAD::Independent(u_ad);
    183         // vector of dependent variables during function recording
    184         ADVector r_ad = fg_info->eval_r(k, u_ad);
    185         CPPAD_ASSERT_KNOWN( r_ad.size() == p[k] ,
    186                 "cppad_ipopt_nlp: eval_r return value size not equal to p[k]."
    187         );
    188         // stop the recording and store operation sequence in r_fun
    189         r_fun[k].Dependent(u_ad, r_ad);
    190 }
    191 
    192157cppad_ipopt_nlp::~cppad_ipopt_nlp()
    193158{}
     
    258223        obj_value = 0.;
    259224
     225        // update tape_ok_ flag
     226        for(k = 0; k < K_; k++)
     227        {       if( new_x && retape_[k] )
     228                        tape_ok_[k] = false;
     229        }
     230
    260231        for(k = 0; k < K_; k++) for(ell = 0; ell < L_[k]; ell++)
    261232        {       fg_info_->index(k, ell, I_, J_);
    262233                for(iobj = 0; iobj < p_[k]; iobj++) if( I_[iobj] == 0 )
    263                 {       if( (new_x || K_ > 1)  && retape_[k] )
     234                {       if( ! tape_ok_[k] )
    264235                        {       // Record r_k for value of u corresponding to x
    265                                 ADVector u_ad(q_[k]);
    266                                 for(j = 0; j < q_[k]; j++)
    267                                 {       CPPAD_ASSERT_UNKNOWN( J_[j] < n_ );
    268                                         u_ad[j] = x[ J_[j] ];
    269                                 }
    270                                 record_r_fun(
    271                                         fg_info_, k, p_, q_, u_ad,  // inputs
    272                                         r_fun_                      // outputs
     236                                fun_record(
     237                                        fg_info_        ,   // inputs
     238                                        k               ,
     239                                        p_              ,
     240                                        q_              ,
     241                                        n_              ,
     242                                        x               ,
     243                                        J_              ,
     244                                        r_fun_             // output
    273245                                );
     246                                if( retape_[k] )
     247                                        tape_ok_[k] = L_[k] <= 1;
     248                                else    tape_ok_[k] = true;
    274249                        }
    275250                        NumberVector u(q_[k]);
     
    303278                grad_f[j] = 0.;
    304279
     280        // update tape_ok_ flag
     281        for(k = 0; k < K_; k++)
     282        {       if( new_x && retape_[k] )
     283                        tape_ok_[k] = false;
     284        }
     285
    305286        for(k = 0; k < K_; k++) for(ell = 0; ell < L_[k]; ell++)
    306287        {       fg_info_->index(k, ell, I_, J_);
    307288                for(iobj = 0; iobj < p_[k]; iobj++) if( I_[iobj] == 0 )
    308                 {       if( (new_x || K_ > 1)  && retape_[k] )
     289                {       if( ! tape_ok_[k] )
    309290                        {       // Record r_k for value of u corresponding to x
    310                                 // If we has stored all recordings in f_eval
    311                                 // we might not need to do this over again.
    312                                 ADVector u_ad(q_[k]);
    313                                 for(j = 0; j < q_[k]; j++)
    314                                 {       CPPAD_ASSERT_UNKNOWN( J_[j] < n_ );
    315                                         u_ad[j] = x[ J_[j] ];
    316                                 }
    317                                 record_r_fun(
    318                                         fg_info_, k, p_, q_, u_ad,  // inputs
    319                                         r_fun_                      // outputs
     291                                fun_record(
     292                                        fg_info_        ,   // inputs
     293                                        k               ,
     294                                        p_              ,
     295                                        q_              ,
     296                                        n_              ,
     297                                        x               ,
     298                                        J_              ,
     299                                        r_fun_              // output
    320300                                );
     301                                if( retape_[k] )
     302                                        tape_ok_[k] = L_[k] <= 1;
     303                                else    tape_ok_[k] = true;
    321304                        }
    322305                        NumberVector u(q_[k]);
     
    361344                g[i] = 0.;
    362345
     346        // update tape_ok_ flag
     347        for(k = 0; k < K_; k++)
     348        {       if( new_x && retape_[k] )
     349                        tape_ok_[k] = false;
     350        }
     351
    363352        for(k = 0; k < K_; k++) for(ell = 0; ell < L_[k]; ell++)
    364353        {       fg_info_->index(k, ell, I_, J_);
    365                 if( (new_x || K_ > 1)  && retape_[k] )
     354                if( ! tape_ok_[k] )
    366355                {       // Record r_k for value of u corresponding to x
    367                         ADVector     u_ad(q_[k]);
    368                         for(j = 0; j < q_[k]; j++)
    369                         {       CPPAD_ASSERT_UNKNOWN( J_[j] < n_ );
    370                                 u_ad[j] = x[ J_[j] ];
    371                         }
    372                         record_r_fun(
    373                                 fg_info_, k, p_, q_, u_ad,  // inputs
    374                                 r_fun_                      // outputs
     356                        fun_record(
     357                                fg_info_        ,   // inputs
     358                                k               ,
     359                                p_              ,
     360                                q_              ,
     361                                n_              ,
     362                                x               ,
     363                                J_              ,
     364                                r_fun_              // output
    375365                        );
    376366                }
     367                if( retape_[k] )
     368                        tape_ok_[k] = L_[k] <= 1;
     369                else    tape_ok_[k] = true;
    377370                NumberVector u(q_[k]);
    378371                NumberVector r(p_[k]);
     
    421414                values[l] = 0.;
    422415
     416        // update tape_ok_ flag
     417        for(k = 0; k < K_; k++)
     418        {       if( new_x && retape_[k] )
     419                        tape_ok_[k] = false;
     420        }
     421
    423422        for(k = 0; k < K_; k++) for(ell = 0; ell < L_[k]; ell++)
    424423        {       fg_info_->index(k, ell, I_, J_);
    425                 if( (new_x || K_ > 1)  && retape_[k] )
     424                if( ! tape_ok_[k] )
    426425                {       // Record r_k for value of u corresponding to x
    427                         ADVector     u_ad(q_[k]);
    428                         for(j = 0; j < q_[k]; j++)
    429                         {       CPPAD_ASSERT_UNKNOWN( J_[j] < n_ );
    430                                 u_ad[j] = x[ J_[j] ];
    431                         }
    432                         record_r_fun(
    433                                 fg_info_, k, p_, q_, u_ad,  // inputs
    434                                 r_fun_                      // outputs
     426                        fun_record(
     427                                fg_info_        ,   // inputs
     428                                k               ,
     429                                p_              ,
     430                                q_              ,
     431                                n_              ,
     432                                x               ,
     433                                J_              ,
     434                                r_fun_              // output
    435435                        );
    436436                }
     437                if( retape_[k] )
     438                        tape_ok_[k] = L_[k] <= 1;
     439                else    tape_ok_[k] = true;
    437440                NumberVector u(q_[k]);
    438441                NumberVector jac_r(p_[k] * q_[k]);
     
    484487                values[l] = 0.;
    485488
     489        // update tape_ok_ flag
     490        for(k = 0; k < K_; k++)
     491        {       if( new_x && retape_[k] )
     492                        tape_ok_[k] = false;
     493        }
     494
    486495        for(k = 0; k < K_; k++) for(ell = 0; ell < L_[k]; ell++)
    487496        {       fg_info_->index(k, ell, I_, J_);
    488                 if( (new_x || K_ > 1)  && retape_[k] )
     497                if( ! tape_ok_[k] )
    489498                {       // Record r_k for value of u corresponding to x
    490                         ADVector     u_ad(q_[k]);
    491                         for(j = 0; j < q_[k]; j++)
    492                         {       CPPAD_ASSERT_UNKNOWN( J_[j] < n_ );
    493                                 u_ad[j] = x[ J_[j] ];
    494                         }
    495                         record_r_fun(
    496                                 fg_info_, k, p_, q_, u_ad,  // inputs
    497                                 r_fun_                      // outputs
     499                        fun_record(
     500                                fg_info_        ,   // inputs
     501                                k               ,
     502                                p_              ,
     503                                q_              ,
     504                                n_              ,
     505                                x               ,
     506                                J_              ,
     507                                r_fun_              // output
    498508                        );
     509                if( retape_[k] )
     510                        tape_ok_[k] = L_[k] <= 1;
     511                else    tape_ok_[k] = true;
    499512                }
    500513                NumberVector w(p_[k]);
  • trunk/cppad_ipopt/src/cppad_ipopt_nlp.hpp

    r1634 r1636  
    816816        size_t                 K_;      // number terms in summation
    817817        BoolVector             retape_; // for operations sequence of r_k (u)
     818        BoolVector             tape_ok_;// tape is ok for current value of x
    818819        SizeVector             q_;      // dimension of domain for r_k (u)
    819820        SizeVector             p_;      // dimension of range for r_k (u)
     
    847848        cppad_ipopt_nlp& operator=(const cppad_ipopt_nlp&);
    848849
    849         // Methods used by public methods
    850         static void record_r_fun(
    851                 cppad_ipopt_fg_info  *fg_info    ,
    852                 size_t                k          ,
    853                 SizeVector&           p          ,
    854                 SizeVector&           q          ,
    855                 ADVector&             u_ad       ,
    856                 ADFunVector&          r_fun
    857         );
    858 
    859850};
    860851
  • trunk/cppad_ipopt/src/hes_fg_map.cpp

    r1634 r1636  
    3636\f$ F : {\bf R}^n \rightarrow {\bf R} \f$ by
    3737\f[
    38         F(x) = \sum_{i=1}^{m+1} fg(x)_i
     38        F(x) = \sum_{i=0}^m fg(x)_i
    3939\f]
    4040
     
    9696is a CppAD sparsity pattern for the Hessian of the function
    9797\f[
    98         R(u) = \sum_{i=1}^{p[k]} r_k (u)_i
     98        R(u) = \sum_{i=0}^{p[k]-1} r_k (u)_i
    9999\f]
    100100As such, <tt>pattern_hes_r[k].size() == q[k] * q[k]</tt>.
  • trunk/cppad_ipopt/src/makefile.am

    r1634 r1636  
    3434        cppad_ipopt_nlp.cpp \
    3535        cppad_ipopt_nlp.hpp \
     36        fun_record.hpp \
     37        hes_fg_map.cpp \
     38        hes_fg_map.hpp \
    3639        jac_g_map.cpp \
    3740        jac_g_map.hpp \
    38         hes_fg_map.cpp \
    39         hes_fg_map.hpp \
    4041        sparse_map2vec.cpp \
    4142        sparse_map2vec.hpp \
  • trunk/cppad_ipopt/src/makefile.in

    r1634 r1636  
    7171libcppad_ipopt_a_LIBADD =
    7272am_libcppad_ipopt_a_OBJECTS = cppad_ipopt_nlp.$(OBJEXT) \
    73         jac_g_map.$(OBJEXT) hes_fg_map.$(OBJEXT) \
     73        hes_fg_map.$(OBJEXT) jac_g_map.$(OBJEXT) \
    7474        sparse_map2vec.$(OBJEXT) vec_fun_pattern.$(OBJEXT)
    7575libcppad_ipopt_a_OBJECTS = $(am_libcppad_ipopt_a_OBJECTS)
     
    227227        cppad_ipopt_nlp.cpp \
    228228        cppad_ipopt_nlp.hpp \
     229        fun_record.hpp \
     230        hes_fg_map.cpp \
     231        hes_fg_map.hpp \
    229232        jac_g_map.cpp \
    230233        jac_g_map.hpp \
    231         hes_fg_map.cpp \
    232         hes_fg_map.hpp \
    233234        sparse_map2vec.cpp \
    234235        sparse_map2vec.hpp \
  • trunk/cppad_ipopt/src/vec_fun_pattern.cpp

    r1634 r1636  
    5151If <tt>retape[k]</tt> is false, <tt>r_fun[k]</tt> is not used.
    5252is a CppAD function object correspopnding to the function
    53 \f$ r_k : {\bf R}^{q[k]} \rightarrow {\bf R}^{p[k]} \f$$.
     53\f$ r_k : {\bf R}^{q[k]} \rightarrow {\bf R}^{p[k]} \f$.
    5454The following non-constant member functions will be called:
    5555\verbatim
     
    7676\f$ R : {\bf R}^{q[k]} \rightarrow {\bf R} \f$ which is defined by
    7777\f[
    78         R(u) = \sum_{i=1}^{p[k]} r_k (u)_i
     78        R(u) = \sum_{i=0}^{p[k]-1} r_k (u)_i
    7979\f]
    8080*/
  • trunk/cppad_ipopt/test/makefile.am

    r1634 r1636  
    3737        k_gt_one.cpp \
    3838        multiple_solution.cpp \
    39         retape.cpp
     39        retape_k1_l1.cpp \
     40        retape_k1_l2.cpp
  • trunk/cppad_ipopt/test/makefile.in

    r1635 r1636  
    4646PROGRAMS = $(noinst_PROGRAMS)
    4747am_test_OBJECTS = test.$(OBJEXT) k_gt_one.$(OBJEXT) \
    48         multiple_solution.$(OBJEXT) retape.$(OBJEXT)
     48        multiple_solution.$(OBJEXT) retape_k1_l1.$(OBJEXT) \
     49        retape_k1_l2.$(OBJEXT)
    4950test_OBJECTS = $(am_test_OBJECTS)
    5051test_LDADD = $(LDADD)
     
    202203        k_gt_one.cpp \
    203204        multiple_solution.cpp \
    204         retape.cpp
     205        retape_k1_l1.cpp \
     206        retape_k1_l2.cpp
    205207
    206208all: all-am
     
    253255@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/k_gt_one.Po@am__quote@
    254256@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/multiple_solution.Po@am__quote@
    255 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/retape.Po@am__quote@
     257@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/retape_k1_l1.Po@am__quote@
     258@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/retape_k1_l2.Po@am__quote@
    256259@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/test.Po@am__quote@
    257260
  • trunk/cppad_ipopt/test/retape_k1_l1.cpp

    r1634 r1636  
    4040} // end of empty namespace
    4141
    42 bool retape(void)
     42bool retape_k1_l1(void)
    4343{       bool ok = true;
    4444        size_t j;
  • trunk/cppad_ipopt/test/test.cpp

    r1633 r1636  
    2323extern bool k_gt_one(void);
    2424extern bool multiple_solution(void);
    25 extern bool retape(void);
     25extern bool retape_k1_l1(void);
     26extern bool retape_k1_l2(void);
    2627
    2728namespace {
     
    5152        ok &= Run( k_gt_one,            "k_get_one"          );
    5253        ok &= Run( multiple_solution,   "multiple_solution"  );
    53         ok &= Run( retape,              "retape"             );
     54        ok &= Run( retape_k1_l1,        "retape_k1_l1"       );
     55        ok &= Run( retape_k1_l2,        "retape_k1_l2"       );
    5456       
    5557        // check for errors
  • trunk/omh/whats_new_10.omh

    r1634 r1636  
    1313$begin whats_new_10$$
    1414$spell
     15        iostream
     16        obj_value
     17        std::cout
     18        endl
     19        gcc
     20        retape
    1521        hpp
    1622        ifdef
     
    2733The purpose of this section is to
    2834assist you in learning about changes between various versions of CppAD.
     35
     36$head 01-24$$
     37It appears that in $cref/cppad_ipopt_nlp/$$, when $code retape[k]$$ was true,
     38and $code L[k] > 1$$, it was possible to use the wrong operation sequence
     39in the calculations (though a test case that demonstrated this could not be
     40produced). This is because the argument value to $latex r_k (u)$$ depends
     41on the value of $latex \ell$$ in the expression
     42$latex \[
     43        r_k \circ [ J_{k, \ell} \otimes n ] (x)
     44\] $$
     45(even when the value of $latex x$$ does not change).
     46$pre
     47
     48$$
     49There was a bug in the $cref/ipopt_ode_check.cpp/$$ program,
     50for a long time,  that did not show up until now. Basically,
     51the check had code of the form:
     52$codep
     53        # include <iostream>
     54        int main()
     55        {       double obj_value = obj_value;
     56                std::cout << "obj_value = " << obj_value << std::endl;
     57        }
     58$$
     59The value of $code obj_value$$ is unspecified,
     60but gcc 4.4.2 (and previous versions) did not give any indication of this.
    2961
    3062$head 01-23$$
  • trunk/svn_status.sh

    r1632 r1636  
    6767        -e '/^[?] *cppad_ipopt\/example\/example$/d'          \
    6868        -e '/^[?] *cppad_ipopt\/speed\/speed$/d'              \
     69        -e '/^[?] *cppad_ipopt\/test\/test$/d'                \
    6970        -e '/^[?] *cppad_ipopt\/ipopt_ode_speed$/d'           \
    7071        -e '/^[?] *print_for\/print_for$/d'                   \
Note: See TracChangeset for help on using the changeset viewer.