Changeset 3746


Ignore:
Timestamp:
Nov 8, 2015 11:50:27 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 57d3215cae5e9da7b4c92e89f038d70870ef7327
end hash code: 9aebc1ca2c0949dec7c2d156517db26e60f28159

commit 9aebc1ca2c0949dec7c2d156517db26e60f28159
Author: Brad Bell <bradbell@…>
Date: Sun Nov 8 20:15:38 2015 -0800

Remove invisible white space.

commit a92ac50e9f4c8d0007ea5a245b3e23145dfcebfe
Author: Brad Bell <bradbell@…>
Date: Sun Nov 8 20:15:31 2015 -0800

Use vectorBool with partial sparsity patterns per pass to reduce memory requirements.


solve_callback.hpp: remove invisible white space.
rev_sparse_jac.hpp: fix bug (argument transposed).
bool_sparsity.cpp: remove invisible white space.

commit c09744b13ba2c70d6ffa857206d45560154d800a
Author: Brad Bell <bradbell@…>
Date: Sun Nov 8 03:22:57 2015 -0800

check_for_nan.hpp: fix minor type in documentation.

Location:
trunk
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed
  • trunk/cppad/ipopt/solve_callback.hpp

    r3275 r3746  
    33# define CPPAD_SOLVE_CALLBACK_INCLUDED
    44/* --------------------------------------------------------------------------
    5 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     5CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    66
    77CppAD is distributed under multiple licenses. This distribution is under
    8 the terms of the 
     8the terms of the
    99                    Eclipse Public License Version 1.0.
    1010
     
    3434        { eval_f, eval_grad_f, eval_g, eval_jac_g, eval_h }
    3535\endverbatim
    36 Note that the bool return flag for the evaluations methods 
     36Note that the bool return flag for the evaluations methods
    3737does not appear in the Ipopt documentation.
    3838Looking at the code, it seems to be a flag telling Ipopt to abort
     
    4444private:
    4545        // ------------------------------------------------------------------
    46         // Types used by this class
     46        // Types used by this class
    4747        // ------------------------------------------------------------------
    4848        /// A Scalar value used by Ipopt
    4949        typedef Ipopt::Number                         Number;
    50         /// An index value used by Ipopt 
     50        /// An index value used by Ipopt
    5151        typedef Ipopt::Index                          Index;
    52         /// Indexing style used in Ipopt sparsity structure 
     52        /// Indexing style used in Ipopt sparsity structure
    5353        typedef Ipopt::TNLP::IndexStyleEnum           IndexStyleEnum;
    5454        // ------------------------------------------------------------------
    55         // Values directly passed in to constuctor
     55        // Values directly passed in to constuctor
    5656        // ------------------------------------------------------------------
    5757        /// dimension of the range space for f(x).
    58         /// The objective is sum_i f_i (x). 
     58        /// The objective is sum_i f_i (x).
    5959        /// Note that, at this point, there is no advantage having nf_ > 1.
    6060        const size_t                    nf_;
     
    6565        /// initial value for x
    6666        const Dvector&                  xi_;
    67         /// lower limit for x 
     67        /// lower limit for x
    6868        const Dvector&                  xl_;
    69         /// upper limit for x 
     69        /// upper limit for x
    7070        const Dvector&                  xu_;
    7171        /// lower limit for g(x)
     
    7878        bool                            retape_;
    7979        /// Should sparse methods be used to compute Jacobians and Hessians
    80         /// with forward mode used for Jacobian. 
     80        /// with forward mode used for Jacobian.
    8181        bool                            sparse_forward_;
    8282        /// Should sparse methods be used to compute Jacobians and Hessians
    83         /// with reverse mode used for Jacobian. 
     83        /// with reverse mode used for Jacobian.
    8484        bool                            sparse_reverse_;
    8585        /// final results are returned to this structure
    8686        solve_result<Dvector>&          solution_;
    8787        // ------------------------------------------------------------------
    88         // Values that are initilaized by the constructor
     88        // Values that are initilaized by the constructor
    8989        // ------------------------------------------------------------------
    9090        /// AD function object that evaluates x -> [ f(x) , g(x) ]
     
    102102        /// If sparse is true, this pattern set by constructor and does not change.
    103103        /// Otherwise this vector has size zero.
    104         CppAD::vector< std::set<size_t> > pattern_jac_;
     104        CppAD::vectorBool              pattern_jac_;
    105105        /// Row indices of [f(x), g(x)] for Jacobian of g(x) in row order.
    106106        /// (Set by constructor and not changed.)
     
    121121        /// If sparse is true, this pattern set by constructor and does not change.
    122122        /// Otherwise this vector has size zero.
    123         CppAD::vector< std::set<size_t> > pattern_hes_;
     123        CppAD::vectorBool              pattern_hes_;
    124124        /// Row indices of Hessian lower left triangle in row order.
    125125        /// (Set by constructor and not changed.)
     
    131131        CppAD::sparse_hessian_work      work_hes_;
    132132        // ------------------------------------------------------------------
    133         // Private member functions
     133        // Private member functions
    134134        // ------------------------------------------------------------------
    135135        /*!
     
    150150        If retape is false, the operation sequence is not changed.
    151151        The zero order Taylor coefficients for this function are set
    152         so they correspond to the argument x. 
     152        so they correspond to the argument x.
    153153        */
    154154        void cache_new_x(const Number* x)
     
    174174public:
    175175        // ----------------------------------------------------------------------
    176         /*! 
     176        /*!
    177177        Constructor for the interface between ipopt::solve and Ipopt
    178        
     178
    179179        \param nf
    180180        dimension of the range space for f(x)
    181        
     181
    182182        \param nx
    183183        dimension of the domain space for f(x) and g(x).
    184        
     184
    185185        \param ng
    186186        dimension of the range space for g(x)
    187        
     187
    188188        \param xi
    189189        initial value of x during the optimization procedure (size nx).
    190        
     190
    191191        \param xl
    192192        lower limit for x (size nx).
    193        
     193
    194194        \param xu
    195195        upper limit for x (size nx).
    196        
     196
    197197        \param gl
    198198        lower limit for g(x) (size ng).
    199        
     199
    200200        \param gu
    201201        upper limit for g(x) (size ng).
     
    215215        with reverse mode for Jacobian.
    216216        (sparse_forward and sparse_reverse cannot both be true).
    217        
     217
    218218        \param solution
    219219        object where final results are stored.
     
    221221        solve_callback(
    222222                size_t                 nf              ,
    223                 size_t                 nx              , 
     223                size_t                 nx              ,
    224224                size_t                 ng              ,
    225225                const Dvector&         xi              ,
     
    232232                bool                   sparse_forward  ,
    233233                bool                   sparse_reverse  ,
    234                 solve_result<Dvector>& solution ) : 
     234                solve_result<Dvector>& solution ) :
    235235        nf_ ( nf ),
    236236        nx_ ( nx ),
     
    270270                        adfun_.optimize();
    271271                }
    272                 if( sparse_forward_ | sparse_reverse_ )
    273                 {       CPPAD_ASSERT_UNKNOWN( ! retape );       
     272                if( sparse_forward_ | sparse_reverse_ )
     273                {       CPPAD_ASSERT_UNKNOWN( ! retape );
     274                        size_t m = nf_ + ng_;
     275                        //
    274276                        // -----------------------------------------------------------
    275277                        // Jacobian
    276                         pattern_jac_.resize(nf_ + ng_);
    277                         if( nx_ <= nf_ + ng_ )
     278                        pattern_jac_.resize( m * nx_ );
     279                        if( nx_ <= m )
    278280                        {       // use forward mode to compute sparsity
    279                                 CppAD::vector< std::set<size_t> > r(nx_);
    280                                 for(i = 0; i < nx_; i++)
    281                                 {       CPPAD_ASSERT_UNKNOWN( r[i].empty() );
    282                                         r[i].insert(i);
     281
     282                                // number of bits that are packed into one unit in vectorBool
     283                                size_t n_column = vectorBool::bit_per_unit();
     284
     285                                // sparsity patterns for current columns
     286                                vectorBool r(nx_ * n_column), s(m * n_column);
     287
     288                                // compute the sparsity pattern n_column columns at a time
     289                                size_t n_loop = (nx_ - 1) / n_column + 1;
     290                                for(size_t i_loop = 0; i_loop < n_loop; i_loop++)
     291                                {       // starting column index for this iteration
     292                                        size_t i_column = i_loop * n_column;
     293
     294                                        // pattern that picks out the appropriate columns
     295                                        for(i = 0; i < nx_; i++)
     296                                        {       for(j = 0; j < n_column; j++)
     297                                                        r[i * n_column + j] = (i == i_column + j);
     298                                        }
     299                                        s = adfun_.ForSparseJac(n_column, r);
     300
     301                                        // fill in the corresponding columns of total_sparsity
     302                                        for(i = 0; i < m; i++)
     303                                        {       for(j = 0; j < n_column; j++)
     304                                                {       if( i_column + j < nx_ )
     305                                                                pattern_jac_[i * nx_ + i_column + j] =
     306                                                                        s[i * n_column + j];
     307                                                }
     308                                        }
    283309                                }
    284                                 pattern_jac_ = adfun_.ForSparseJac(nx_, r);
    285310                        }
    286311                        else
    287312                        {       // use reverse mode to compute sparsity
    288                                 size_t m = nf_ + ng_;
    289                                 CppAD::vector< std::set<size_t> > s(m);
     313
     314                                // number of bits that are packed into one unit in vectorBool
     315                                size_t n_row = vectorBool::bit_per_unit();
     316
     317                                // sparsity patterns for current rows
     318                                vectorBool r(n_row * m), s(n_row * nx_);
     319
     320                                // compute the sparsity pattern n_row row at a time
     321                                size_t n_loop = (m - 1) / n_row + 1;
     322                                for(size_t i_loop = 0; i_loop < n_loop; i_loop++)
     323                                {       // starting row index for this iteration
     324                                        size_t i_row = i_loop * n_row;
     325
     326                                        // pattern that picks out the appropriate rows
     327                                        for(i = 0; i < n_row; i++)
     328                                        {       for(j = 0; j < m; j++)
     329                                                        r[i * m + j] = (i_row + i ==  j);
     330                                        }
     331                                        s = adfun_.RevSparseJac(n_row, r);
     332
     333                                        // fill in correspoding rows of total sparsity
     334                                        for(i = 0; i < n_row; i++)
     335                                        {       for(j = 0; j < nx_; j++)
     336                                                        if( i_row + i < m )
     337                                                                pattern_jac_[ (i_row + i) * nx_ + j ] =
     338                                                                        s[ i  * nx_ + j];
     339                                        }
     340                                }
     341                        }
     342                        /*
     343                        {       // use reverse mode to compute sparsity
     344                                CppAD::vectorBool s(m * m);
    290345                                for(i = 0; i < m; i++)
    291                                 {       CPPAD_ASSERT_UNKNOWN( s[i].empty() );
    292                                         s[i].insert(i);
     346                                {       for(j = 0; j < m; j++)
     347                                                s[i * m + j] = (i == j);
    293348                                }
    294349                                pattern_jac_ = adfun_.RevSparseJac(m, s);
    295350                        }
     351                        */
    296352                        // Set row and column indices in Jacoian of [f(x), g(x)]
    297353                        // for Jacobian of g(x). These indices are in row major order.
    298                         std::set<size_t>:: const_iterator itr, end;
    299354                        for(i = nf_; i < nfg; i++)
    300                         {       itr = pattern_jac_[i].begin();
    301                                 end = pattern_jac_[i].end();
    302                                 while( itr != end )
    303                                 {       j = *itr++;
    304                                         row_jac_.push_back(i);
    305                                         col_jac_.push_back(j);
     355                        {       for(j = 0; j < nx_; j++)
     356                                {       if( pattern_jac_[ i * nx_ + j ] )
     357                                        {       row_jac_.push_back(i);
     358                                                col_jac_.push_back(j);
     359                                        }
    306360                                }
    307361                        }
     362                        // Set row and column indices in Jacoian of [f(x), g(x)]
     363                        // for Jacobian of g(x). These indices are in row major order.
    308364                        // -----------------------------------------------------------
    309365                        // Hessian
    310                         pattern_hes_.resize(nx_);
    311                         CppAD::vector< std::set<size_t> > r(nx_);
    312                         for(i = 0; i < nx_; i++)
    313                         {       CPPAD_ASSERT_UNKNOWN( r[i].empty() );
    314                                 r[i].insert(i);
    315                         }
    316                         // forward Jacobian sparsity for fg
    317                         adfun_.ForSparseJac(nx_, r);
    318 
    319                         // The Lagragian can use any of the components of f(x), g(x)
    320                         CppAD::vector< std::set<size_t> > s(1);
    321                         CPPAD_ASSERT_UNKNOWN( s[0].empty() );
    322                         for(i = 0; i < nf_ + ng_; i++)
    323                                 s[0].insert(i);
    324                         pattern_hes_ = adfun_.RevSparseHes(nx_, s);
    325 
    326                         // Set row and column indices for Lower triangle of Hessian
     366                        pattern_hes_.resize(nx_ * nx_);
     367
     368                        // number of bits that are packed into one unit in vectorBool
     369                        size_t n_column = vectorBool::bit_per_unit();
     370
     371                        // sparsity patterns for current columns
     372                        vectorBool r(nx_ * n_column), h(nx_ * n_column);
     373
     374                        // sparsity pattern for range space of function
     375                        vectorBool s(m);
     376                        for(i = 0; i < m; i++)
     377                                s[i] = true;
     378
     379                        // compute the sparsity pattern n_column columns at a time
     380                        size_t n_loop = (nx_ - 1) / n_column + 1;
     381                        for(size_t i_loop = 0; i_loop < n_loop; i_loop++)
     382                        {       // starting column index for this iteration
     383                                size_t i_column = i_loop * n_column;
     384
     385                                // pattern that picks out the appropriate columns
     386                                for(i = 0; i < nx_; i++)
     387                                {       for(j = 0; j < n_column; j++)
     388                                                r[i * n_column + j] = (i == i_column + j);
     389                                }
     390                                adfun_.ForSparseJac(n_column, r);
     391
     392                                // sparsity pattern corresponding to paritls w.r.t. (theta, u)
     393                                // of partial w.r.t. the selected columns
     394                                bool transpose = true;
     395                                h = adfun_.RevSparseHes(n_column, s, transpose);
     396
     397                                // fill in the corresponding columns of total_sparsity
     398                                for(i = 0; i < nx_; i++)
     399                                {       for(j = 0; j < n_column; j++)
     400                                        {       if( i_column + j < nx_ )
     401                                                        pattern_hes_[i * nx_ + i_column + j] =
     402                                                                h[i * n_column + j];
     403                                        }
     404                                }
     405                        }
     406                        // Set row and column indices for Lower triangle of Hessian
    327407                        // of Lagragian.  These indices are in row major order.
    328408                        for(i = 0; i < nx_; i++)
    329                         {       itr = pattern_hes_[i].begin();
    330                                 end = pattern_hes_[i].end();
    331                                 while( itr != end )
    332                                 {       j = *itr++;
     409                        {       for(j = 0; j < nx_; j++)
     410                                {       if( pattern_hes_[ i * nx_ + j ] )
    333411                                        if( j <= i )
    334412                                        {       row_hes_.push_back(i);
     
    344422                        {       for(j = 0; j < nx_; j++)
    345423                                {       row_jac_.push_back(i);
    346                                         col_jac_.push_back(j); 
     424                                        col_jac_.push_back(j);
    347425                                }
    348426                        }
     
    364442        /*!
    365443        Return dimension information about optimization problem.
    366        
     444
    367445        \param[out] n
    368446        is set to the value nx_.
    369        
     447
    370448        \param[out] m
    371449        is set to the value ng_.
    372        
     450
    373451        \param[out] nnz_jac_g
    374         is set to ng_ * nx_ (sparsity not yet implemented) 
    375        
     452        is set to ng_ * nx_ (sparsity not yet implemented)
     453
    376454        \param[out] nnz_h_lag
    377455        is set to nx_*(nx_+1)/2 (sparsity not yet implemented)
    378        
     456
    379457        \param[out] index_style
    380458        is set to C_STYLE; i.e., zeoro based indexing is used in the
     
    382460        */
    383461        virtual bool get_nlp_info(
    384                 Index&          n            , 
    385                 Index&          m            , 
     462                Index&          n            ,
     463                Index&          m            ,
    386464                Index&          nnz_jac_g    ,
    387                 Index&          nnz_h_lag    , 
     465                Index&          nnz_h_lag    ,
    388466                IndexStyleEnum& index_style  )
    389467        {
     
    392470                nnz_jac_g = static_cast<Index>(row_jac_.size());
    393471                nnz_h_lag = static_cast<Index>(row_hes_.size());
    394        
     472
    395473# ifndef NDEBUG
    396474                if( ! (sparse_forward_ | sparse_reverse_) )
     
    403481# endif
    404482
    405                 // use the fortran index style for row/col entries
     483                // use the fortran index style for row/col entries
    406484                index_style = C_STYLE;
    407        
     485
    408486                return true;
    409487        }
     
    411489        /*!
    412490        Return bound information about optimization problem.
    413        
     491
    414492        \param[in] n
    415493        is the dimension of the domain space for f(x) and g(x); i.e.,
    416494        it must be equal to nx_.
    417        
     495
    418496        \param[out] x_l
    419497        is a vector of size nx_.
     
    421499        On output, it is a copy of the lower bound for \f$ x \f$; i.e.,
    422500        xl_.
    423        
     501
    424502        \param[out] x_u
    425503        is a vector of size nx_.
     
    427505        On output, it is a copy of the upper bound for \f$ x \f$; i.e.,
    428506        xu_.
    429        
     507
    430508        \param[in] m
    431509        is the dimension of the range space for g(x). i.e.,
    432510        it must be equal to ng_.
    433        
     511
    434512        \param[out] g_l
    435513        is a vector of size ng_.
    436514        The input value of its elements does not matter.
    437515        On output, it is a copy of the lower bound for \f$ g(x) \f$; i.e., gl_.
    438        
     516
    439517        \param[out] g_u
    440518        is a vector of size ng_.
     
    443521        */
    444522        virtual bool get_bounds_info(
    445                 Index       n        , 
    446                 Number*     x_l      , 
     523                Index       n        ,
     524                Number*     x_l      ,
    447525                Number*     x_u      ,
    448                 Index       m        , 
    449                 Number*     g_l      , 
     526                Index       m        ,
     527                Number*     g_l      ,
    450528                Number*     g_u      )
    451529        {       size_t i;
    452                 // here, the n and m we gave IPOPT in get_nlp_info are passed back 
     530                // here, the n and m we gave IPOPT in get_nlp_info are passed back
    453531                CPPAD_ASSERT_UNKNOWN(static_cast<size_t>(n) == nx_);
    454532                CPPAD_ASSERT_UNKNOWN(static_cast<size_t>(m) == ng_);
    455        
     533
    456534                // pass back bounds
    457535                for(i = 0; i < nx_; i++)
     
    463541                        g_u[i] = gu_[i];
    464542                }
    465                
     543
    466544                return true;
    467545        }
     
    469547        /*!
    470548        Return initial x value where optimiation is started.
    471        
     549
    472550        \param[in] n
    473551        must be equal to the domain dimension for f(x) and g(x); i.e.,
    474552        it must be equal to nx_.
    475        
     553
    476554        \param[in] init_x
    477555        must be equal to true.
    478        
     556
    479557        \param[out] x
    480558        is a vector of size nx_.
    481559        The input value of its elements does not matter.
    482560        On output, it is a copy of the initial value for \f$ x \f$; i.e. xi_.
    483        
     561
    484562        \param[in] init_z
    485563        must be equal to false.
    486        
     564
    487565        \param z_L
    488566        is not used.
    489        
     567
    490568        \param z_U
    491569        is not used.
    492        
     570
    493571        \param[in] m
    494572        must be equal to the domain dimension for f(x) and g(x); i.e.,
    495573        it must be equal to ng_.
    496        
     574
    497575        \param init_lambda
    498576        must be equal to false.
    499        
     577
    500578        \param lambda
    501579        is not used.
    502580        */
    503581        virtual bool get_starting_point(
    504                 Index           n            , 
    505                 bool            init_x       , 
     582                Index           n            ,
     583                bool            init_x       ,
    506584                Number*         x            ,
    507                 bool            init_z       , 
    508                 Number*         z_L          , 
     585                bool            init_z       ,
     586                Number*         z_L          ,
    509587                Number*         z_U          ,
    510                 Index           m            , 
     588                Index           m            ,
    511589                bool            init_lambda  ,
    512590                Number*         lambda       )
    513591        {       size_t j;
    514        
     592
    515593                CPPAD_ASSERT_UNKNOWN(static_cast<size_t>(n) == nx_ );
    516594                CPPAD_ASSERT_UNKNOWN(static_cast<size_t>(m) == ng_ );
     
    518596                CPPAD_ASSERT_UNKNOWN(init_z == false);
    519597                CPPAD_ASSERT_UNKNOWN(init_lambda == false);
    520        
     598
    521599                for(j = 0; j < nx_; j++)
    522600                        x[j] = xi_[j];
    523        
     601
    524602                return true;
    525603        }
     
    527605        /*!
    528606        Evaluate the objective fucntion f(x).
    529        
     607
    530608        \param[in] n
    531609        is the dimension of the argument space for f(x); i.e., must be equal nx_.
    532        
     610
    533611        \param[in] x
    534612        is a vector of size nx_ containing the point at which to evaluate
    535613        the function sum_i f_i (x).
    536        
     614
    537615        \param[in] new_x
    538         is false if the previous call to any one of the 
     616        is false if the previous call to any one of the
    539617        \ref Evaluation_Methods used the same value for x.
    540        
     618
    541619        \param[out] obj_value
    542620        is the value of the objective sum_i f_i (x) at this value of x.
    543        
     621
    544622        \return
    545623        The return value is always true; see \ref Evaluation_Methods.
    546624        */
    547625        virtual bool eval_f(
    548                 Index          n           , 
    549                 const Number*  x           , 
    550                 bool           new_x       , 
     626                Index          n           ,
     627                const Number*  x           ,
     628                bool           new_x       ,
    551629                Number&        obj_value   )
    552630        {       size_t i;
     
    563641        /*!
    564642        Evaluate the gradient of f(x).
    565        
     643
    566644        \param[in] n
    567645        is the dimension of the argument space for f(x); i.e., must be equal nx_.
    568        
     646
    569647        \param[in] x
    570648        has a vector of size nx_ containing the point at which to evaluate
    571649        the gradient of f(x).
    572        
     650
    573651        \param[in] new_x
    574         is false if the previous call to any one of the 
     652        is false if the previous call to any one of the
    575653        \ref Evaluation_Methods used the same value for x.
    576        
     654
    577655        \param[out] grad_f
    578656        is a vector of size nx_.
    579657        The input value of its elements does not matter.
    580         The output value of its elements is the gradient of f(x) 
     658        The output value of its elements is the gradient of f(x)
    581659        at this value of.
    582        
     660
    583661        \return
    584662        The return value is always true; see \ref Evaluation_Methods.
    585663        */
    586664        virtual bool eval_grad_f(
    587                 Index           n        , 
    588                 const Number*   x        , 
    589                 bool            new_x    , 
     665                Index           n        ,
     666                const Number*   x        ,
     667                bool            new_x    ,
    590668                Number*         grad_f   )
    591669        {       size_t i;
     
    606684        /*!
    607685        Evaluate the function g(x).
    608        
     686
    609687        \param[in] n
    610688        is the dimension of the argument space for g(x); i.e., must be equal nx_.
    611        
     689
    612690        \param[in] x
    613691        has a vector of size n containing the point at which to evaluate
    614692        the gradient of g(x).
    615        
     693
    616694        \param[in] new_x
    617         is false if the previous call to any one of the 
     695        is false if the previous call to any one of the
    618696        \ref Evaluation_Methods used the same value for x.
    619        
     697
    620698        \param[in] m
    621699        is the dimension of the range space for g(x); i.e., must be equal to ng_.
    622        
     700
    623701        \param[out] g
    624702        is a vector of size ng_.
    625703        The input value of its elements does not matter.
    626         The output value of its elements is 
     704        The output value of its elements is
    627705        the value of the function g(x) at this value of x.
    628        
     706
    629707        \return
    630708        The return value is always true; see \ref Evaluation_Methods.
    631709        */
    632710        virtual bool eval_g(
    633                 Index   n            , 
    634                 const   Number* x    , 
    635                 bool    new_x        , 
    636                 Index   m            , 
     711                Index   n            ,
     712                const   Number* x    ,
     713                bool    new_x        ,
     714                Index   m            ,
    637715                Number* g            )
    638716        {       size_t i;
     
    647725        /*!
    648726        Evaluate the Jacobian of g(x).
    649        
     727
    650728        \param[in] n
    651         is the dimension of the argument space for g(x); 
     729        is the dimension of the argument space for g(x);
    652730        i.e., must be equal nx_.
    653        
     731
    654732        \param x
    655733        If values is not NULL,
    656734        x is a vector of size nx_ containing the point at which to evaluate
    657735        the gradient of g(x).
    658        
     736
    659737        \param[in] new_x
    660         is false if the previous call to any one of the 
     738        is false if the previous call to any one of the
    661739        \ref Evaluation_Methods used the same value for  x.
    662        
     740
    663741        \param[in] m
    664         is the dimension of the range space for g(x); 
     742        is the dimension of the range space for g(x);
    665743        i.e., must be equal to ng_.
    666        
     744
    667745        \param[in] nele_jac
    668746        is the number of possibly non-zero elements in the Jacobian of g(x);
    669747        i.e., must be equal to ng_ * nx_.
    670        
     748
    671749        \param iRow
    672750        if values is not NULL, iRow is not defined.
     
    674752        is a vector with size nele_jac.
    675753        The input value of its elements does not matter.
    676         On output, 
    677         For <tt>k = 0 , ... , nele_jac-1, iRow[k]</tt> is the 
    678         base zero row index for the 
     754        On output,
     755        For <tt>k = 0 , ... , nele_jac-1, iRow[k]</tt> is the
     756        base zero row index for the
    679757        k-th possibly non-zero entry in the Jacobian of g(x).
    680        
     758
    681759        \param jCol
    682760        if values is not NULL, jCol is not defined.
     
    684762        is a vector with size nele_jac.
    685763        The input value of its elements does not matter.
    686         On output, 
    687         For <tt>k = 0 , ... , nele_jac-1, jCol[k]</tt> is the 
    688         base zero column index for the 
     764        On output,
     765        For <tt>k = 0 , ... , nele_jac-1, jCol[k]</tt> is the
     766        base zero column index for the
    689767        k-th possibly non-zero entry in the Jacobian of g(x).
    690        
     768
    691769        \param values
    692770        if \c values is not \c NULL, \c values
    693771        is a vector with size \c nele_jac.
    694772        The input value of its elements does not matter.
    695         On output, 
    696         For <tt>k = 0 , ... , nele_jac-1, values[k]</tt> is the 
    697         value for the 
     773        On output,
     774        For <tt>k = 0 , ... , nele_jac-1, values[k]</tt> is the
     775        value for the
    698776        k-th possibly non-zero entry in the Jacobian of g(x).
    699        
     777
    700778        \return
    701779        The return value is always true; see \ref Evaluation_Methods.
    702780        */
    703781        virtual bool eval_jac_g(
    704                 Index n, 
    705                 const Number* x, 
     782                Index n,
     783                const Number* x,
    706784                bool new_x,
    707                        
    708                 Index m, 
    709                 Index nele_jac, 
    710                 Index* iRow, 
     785
     786                Index m,
     787                Index nele_jac,
     788                Index* iRow,
    711789                Index *jCol,
    712                        
     790
    713791                Number* values)
    714792        {       size_t i, j, k, ell;
     
    777855                }
    778856                else
    779                 {       // user reverse mode   
     857                {       // user reverse mode
    780858                        size_t nfg = nf_ + ng_;
    781859                        // user reverse mode
     
    803881        /*!
    804882        Evaluate the Hessian of the Lagragian
    805        
     883
    806884        \section The_Hessian_of_the_Lagragian The Hessian of the Lagragian
    807885        The Hessian of the Lagragian is defined as
    808886        \f[
    809         H(x, \sigma, \lambda ) 
     887        H(x, \sigma, \lambda )
    810888        =
    811889        \sigma \nabla^2 f(x) + \sum_{i=0}^{m-1} \lambda_i \nabla^2 g(x)_i
    812890        \f]
    813        
     891
    814892        \param[in] n
    815         is the dimension of the argument space for g(x); 
     893        is the dimension of the argument space for g(x);
    816894        i.e., must be equal nx_.
    817        
     895
    818896        \param x
    819897        if values is not NULL, x
    820898        is a vector of size nx_ containing the point at which to evaluate
    821899        the Hessian of the Lagragian.
    822        
     900
    823901        \param[in] new_x
    824         is false if the previous call to any one of the 
     902        is false if the previous call to any one of the
    825903        \ref Evaluation_Methods used the same value for x.
    826        
     904
    827905        \param[in] obj_factor
    828906        the value \f$ \sigma \f$ multiplying the Hessian of
    829907        f(x) in the expression for \ref The_Hessian_of_the_Lagragian.
    830        
     908
    831909        \param[in] m
    832         is the dimension of the range space for g(x); 
     910        is the dimension of the range space for g(x);
    833911        i.e., must be equal to ng_.
    834        
     912
    835913        \param[in] lambda
    836914        if values is not NULL, lambda
    837915        is a vector of size ng_ specifing the value of \f$ \lambda \f$
    838916        in the expression for \ref The_Hessian_of_the_Lagragian.
    839        
     917
    840918        \param[in] new_lambda
    841919        is true if the previous call to eval_h had the same value for
    842920        lambda and false otherwise.
    843921        (Not currently used.)
    844        
     922
    845923        \param[in] nele_hess
    846         is the number of possibly non-zero elements in the 
     924        is the number of possibly non-zero elements in the
    847925        Hessian of the Lagragian;
    848926        i.e., must be equal to nx_*(nx_+1)/2.
    849        
     927
    850928        \param iRow
    851929        if values is not NULL, iRow is not defined.
     
    853931        is a vector with size nele_hess.
    854932        The input value of its elements does not matter.
    855         On output, 
    856         For <tt>k = 0 , ... , nele_hess-1, iRow[k]</tt> is the 
    857         base zero row index for the 
     933        On output,
     934        For <tt>k = 0 , ... , nele_hess-1, iRow[k]</tt> is the
     935        base zero row index for the
    858936        k-th possibly non-zero entry in the Hessian fo the Lagragian.
    859        
     937
    860938        \param jCol
    861939        if values is not NULL, jCol is not defined.
     
    863941        is a vector with size nele_hess.
    864942        The input value of its elements does not matter.
    865         On output, 
    866         For <tt>k = 0 , ... , nele_hess-1, jCol[k]</tt> is the 
    867         base zero column index for the 
     943        On output,
     944        For <tt>k = 0 , ... , nele_hess-1, jCol[k]</tt> is the
     945        base zero column index for the
    868946        k-th possibly non-zero entry in the Hessian of the Lagragian.
    869        
     947
    870948        \param values
    871949        if values is not NULL, it
    872950        is a vector with size nele_hess.
    873951        The input value of its elements does not matter.
    874         On output, 
    875         For <tt>k = 0 , ... , nele_hess-1, values[k]</tt> is the 
    876         value for the 
     952        On output,
     953        For <tt>k = 0 , ... , nele_hess-1, values[k]</tt> is the
     954        value for the
    877955        k-th possibly non-zero entry in the Hessian of the Lagragian.
    878        
     956
    879957        \return
    880958        The return value is always true; see \ref Evaluation_Methods.
     
    882960        virtual bool eval_h(
    883961                Index         n              ,
    884                 const Number* x              , 
     962                const Number* x              ,
    885963                bool          new_x          ,
    886                 Number        obj_factor     , 
     964                Number        obj_factor     ,
    887965                Index         m              ,
    888966                const Number* lambda         ,
    889                 bool          new_lambda     , 
    890                 Index         nele_hess      , 
     967                bool          new_lambda     ,
     968                Index         nele_hess      ,
    891969                Index*        iRow           ,
    892                 Index*        jCol           , 
     970                Index*        jCol           ,
    893971                Number*       values         )
    894972        {       size_t i, j, k;
     
    897975                //
    898976                size_t nk = row_hes_.size();
    899                 CPPAD_ASSERT_UNKNOWN( static_cast<size_t>(nele_hess) == nk ); 
     977                CPPAD_ASSERT_UNKNOWN( static_cast<size_t>(nele_hess) == nk );
    900978                //
    901979                if( new_x )
     
    9441022        /*!
    9451023        Pass solution information from Ipopt to users solution structure.
    946        
     1024
    9471025        \param[in] status
    9481026        is value that the Ipopt solution status
    949         which gets mapped to a correponding value for 
     1027        which gets mapped to a correponding value for
    9501028        \n
    9511029        <tt>solution_.status</tt>
    952        
     1030
    9531031        \param[in] n
    9541032        is the dimension of the domain space for f(x) and g(x); i.e.,
    9551033        it must be equal to nx_.
    956        
     1034
    9571035        \param[in] x
    9581036        is a vector with size nx_ specifing the final solution.
    9591037        This is the output value for
    9601038        \n
    961         <tt>solution_.x</tt> 
    962        
     1039        <tt>solution_.x</tt>
     1040
    9631041        \param[in] z_L
    9641042        is a vector with size nx_ specifing the Lagragian multipliers for the
     
    9671045        \n
    9681046        <tt>solution_.zl</tt>
    969        
     1047
    9701048        \param[in] z_U
    9711049        is a vector with size nx_ specifing the Lagragian multipliers for the
     
    9731051        This is the output value for
    9741052        \n
    975         <tt>solution_.zu</tt> 
    976        
     1053        <tt>solution_.zu</tt>
     1054
    9771055        \param[in] m
    9781056        is the dimension of the range space for g(x). i.e.,
    9791057        it must be equal to ng_.
    980        
     1058
    9811059        \param[in] g
    9821060        is a vector with size ng_ containing the value of the constraint function
     
    9841062        This is the output value for
    9851063        \n
    986         <tt>solution_.g</tt> 
    987        
     1064        <tt>solution_.g</tt>
     1065
    9881066        \param[in] lambda
    9891067        is a vector with size ng_ specifing the Lagragian multipliers for the
     
    9911069        This is the output value for
    9921070        \n
    993         <tt>solution_.lambda</tt> 
    994        
     1071        <tt>solution_.lambda</tt>
     1072
    9951073        \param[in] obj_value
    9961074        is the value of the objective function f(x) at the final solution x.
     
    9981076        \n
    9991077        <tt>solution_.obj_value</tt>
    1000        
     1078
    10011079        \param[in] ip_data
    10021080        is unspecified (by Ipopt) and hence not used.
    1003        
     1081
    10041082        \param[in] ip_cq
    10051083        is unspecified (by Ipopt) and hence not used.
    1006        
     1084
    10071085        \par solution_[out]
    10081086        this is a reference to the solution argument
     
    10131091        virtual void finalize_solution(
    10141092                Ipopt::SolverReturn               status    ,
    1015                 Index                             n         , 
    1016                 const Number*                     x         , 
    1017                 const Number*                     z_L       , 
     1093                Index                             n         ,
     1094                const Number*                     x         ,
     1095                const Number*                     z_L       ,
    10181096                const Number*                     z_U       ,
    1019                 Index                             m         , 
    1020                 const Number*                     g         , 
     1097                Index                             m         ,
     1098                const Number*                     g         ,
    10211099                const Number*                     lambda    ,
    10221100                Number                            obj_value ,
     
    10251103        )
    10261104        {       size_t i, j;
    1027        
     1105
    10281106                CPPAD_ASSERT_UNKNOWN(static_cast<size_t>(n) == nx_ );
    10291107                CPPAD_ASSERT_UNKNOWN(static_cast<size_t>(m) == ng_ );
    1030        
     1108
    10311109                switch(status)
    10321110                {       // convert status from Ipopt enum to solve_result<Dvector> enum
     
    10341112                        solution_.status = solve_result<Dvector>::success;
    10351113                        break;
    1036        
     1114
    10371115                        case Ipopt::MAXITER_EXCEEDED:
    1038                         solution_.status = 
     1116                        solution_.status =
    10391117                                solve_result<Dvector>::maxiter_exceeded;
    10401118                        break;
    1041        
     1119
    10421120                        case Ipopt::STOP_AT_TINY_STEP:
    1043                         solution_.status = 
     1121                        solution_.status =
    10441122                                solve_result<Dvector>::stop_at_tiny_step;
    10451123                        break;
    1046        
     1124
    10471125                        case Ipopt::STOP_AT_ACCEPTABLE_POINT:
    1048                         solution_.status = 
     1126                        solution_.status =
    10491127                                solve_result<Dvector>::stop_at_acceptable_point;
    10501128                        break;
    1051        
     1129
    10521130                        case Ipopt::LOCAL_INFEASIBILITY:
    1053                         solution_.status = 
     1131                        solution_.status =
    10541132                                solve_result<Dvector>::local_infeasibility;
    10551133                        break;
    1056        
     1134
    10571135                        case Ipopt::USER_REQUESTED_STOP:
    1058                         solution_.status = 
     1136                        solution_.status =
    10591137                                solve_result<Dvector>::user_requested_stop;
    10601138                        break;
    1061        
     1139
    10621140                        case Ipopt::DIVERGING_ITERATES:
    1063                         solution_.status = 
     1141                        solution_.status =
    10641142                                solve_result<Dvector>::diverging_iterates;
    10651143                        break;
    1066        
     1144
    10671145                        case Ipopt::RESTORATION_FAILURE:
    1068                         solution_.status = 
     1146                        solution_.status =
    10691147                                solve_result<Dvector>::restoration_failure;
    10701148                        break;
    1071        
     1149
    10721150                        case Ipopt::ERROR_IN_STEP_COMPUTATION:
    1073                         solution_.status = 
     1151                        solution_.status =
    10741152                                solve_result<Dvector>::error_in_step_computation;
    10751153                        break;
    1076        
     1154
    10771155                        case Ipopt::INVALID_NUMBER_DETECTED:
    1078                         solution_.status = 
     1156                        solution_.status =
    10791157                                solve_result<Dvector>::invalid_number_detected;
    10801158                        break;
    1081        
     1159
    10821160                        case Ipopt::INTERNAL_ERROR:
    1083                         solution_.status = 
     1161                        solution_.status =
    10841162                                solve_result<Dvector>::internal_error;
    10851163                        break;
    1086        
     1164
    10871165                        default:
    1088                         solution_.status = 
     1166                        solution_.status =
    10891167                                solve_result<Dvector>::unknown;
    10901168                }
    1091        
     1169
    10921170                solution_.x.resize(nx_);
    10931171                solution_.zl.resize(nx_);
  • trunk/cppad/local/check_for_nan.hpp

    r3744 r3746  
    6969the values of the independent variables that resulted in the $code nan$$
    7070are written to a temporary binary file.
    71 This is so that you are run the original source code with those values
     71This is so that you can run the original source code with those values
    7272to see what is causing the $code nan$$.
    7373
  • trunk/cppad/local/rev_sparse_jac.hpp

    r3718 r3746  
    283283        {       CPPAD_ASSERT_UNKNOWN( dep_taddr[i] < total_num_var );
    284284                if( transpose )
     285                {       for(j = 0; j < q; j++) if( r[ i * q + j ] )
     286                                var_sparsity.add_element( dep_taddr[i], j );
     287                }
     288                else
    285289                {       for(j = 0; j < q; j++) if( r[ j * m + i ] )
    286                                 var_sparsity.add_element( dep_taddr[i], j );
    287                 }
    288                 else
    289                 {       for(j = 0; j < q; j++) if( r[ i * q + j ] )
    290290                                var_sparsity.add_element( dep_taddr[i], j );
    291291                }
  • trunk/cppad/local/sparse.hpp

    r3718 r3746  
    2828        cppad/local/rev_sparse_jac.hpp%
    2929        example/dependency.cpp%
    30         cppad/local/rev_sparse_hes.hpp
     30        cppad/local/rev_sparse_hes.hpp%
     31        example/bool_sparsity.cpp
    3132%$$
    3233
  • trunk/cppad/vector.hpp

    r3720 r3746  
    226226(on the other hand, $code CppAD::vector<bool>$$ is expected to be faster
    227227than $code vectorBool$$).
     228
     229$subhead bit_per_unit$$
     230The static function call
     231$codei%
     232        %s% = vectorBool::bit_per_unit()
     233%$$
     234returns the $code size_t$$ value $icode s$$
     235which is equal to the number of boolean values (bits) that are
     236packed into one operational unit.
     237For example, a logical $code or$$
     238acts on this many boolean values with one operation.
    228239
    229240$subhead data$$
     
    673684        /// (note that non-const elements actually use vectorBoolElement)
    674685        typedef bool value_type;
     686
     687        // static member function
     688        static size_t bit_per_unit(void)
     689        {       return bit_per_unit_; }
    675690
    676691        /// default constructor (sets all member data to zero)
  • trunk/example/CMakeLists.txt

    r3738 r3746  
    9696        bender_quad.cpp
    9797        bool_fun.cpp
     98        bool_sparsity.cpp
    9899        capacity_order.cpp
    99100        change_param.cpp
  • trunk/example/example.cpp

    r3739 r3746  
    6464extern bool BenderQuad(void);
    6565extern bool BoolFun(void);
     66extern bool bool_sparsity(void);
    6667extern bool capacity_order(void);
    6768extern bool change_param(void);
     
    234235        ok &= Run( BenderQuad,        "BenderQuad"       );
    235236        ok &= Run( BoolFun,           "BoolFun"          );
     237        ok &= Run( bool_sparsity,     "bool_sparsity"    );
    236238        ok &= Run( capacity_order,    "capacity_order"   );
    237239        ok &= Run( change_param,      "change_param"     );
  • trunk/example/ipopt_solve/CMakeLists.txt

    r3116 r3746  
    11# $Id$
    22# -----------------------------------------------------------------------------
    3 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-14 Bradley M. Bell
     3# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44#
    55# CppAD is distributed under multiple licenses. This distribution is under
    6 # the terms of the 
     6# the terms of the
    77#                     Eclipse Public License Version 1.0.
    88#
     
    1010# Please visit http://www.coin-or.org/CppAD/ for information on other licenses.
    1111# -----------------------------------------------------------------------------
    12 # Build the example/ipopt_solve directory tests 
     12# Build the example/ipopt_solve directory tests
    1313
    14 # Specifies build type for this directory. Possible values are 
     14# Specifies build type for this directory. Possible values are
    1515# empty, Debug, Release, RelWithDebInfo and MinSizeRel
    1616SET(CMAKE_BUILD_TYPE DEBUG)
     
    3030ENDIF ( colpack_prefix )
    3131
     32# Copy a file to another location and modify its contents.
     33# configure_file(InputFile OutputFile [COPYONLY] [ESCAPE_QUOTES] [@ONLY])
     34CONFIGURE_FILE(
     35        ${CMAKE_CURRENT_SOURCE_DIR}/test_one.sh.in
     36        ${CMAKE_CURRENT_SOURCE_DIR}/test_one.sh
     37)
     38
    3239#
    33 ADD_EXECUTABLE(example_ipopt_solve EXCLUDE_FROM_ALL 
     40ADD_EXECUTABLE(example_ipopt_solve EXCLUDE_FROM_ALL
    3441        solve.cpp
    3542        get_started.cpp
     
    4249add_cppad_cxx_flags( example_ipopt_solve )
    4350
    44 # libraries to be linked into the specified target, 
     51# libraries to be linked into the specified target,
    4552# as determined by pkg-config for ipopt
    4653TARGET_LINK_LIBRARIES(example_ipopt_solve ${ipopt_LIBRARIES} ${colpack_libs})
    4754
    4855# Add the check_example_ipopt_solve target
    49 ADD_CUSTOM_TARGET(check_example_ipopt_solve 
    50         example_ipopt_solve 
    51         DEPENDS example_ipopt_solve 
     56ADD_CUSTOM_TARGET(check_example_ipopt_solve
     57        example_ipopt_solve
     58        DEPENDS example_ipopt_solve
    5259)
  • trunk/example/ipopt_solve/solve.cpp

    r2859 r3746  
    11/* $Id$ */
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-13 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
    6 the terms of the 
     6the terms of the
    77                    Eclipse Public License Version 1.0.
    88
     
    5252{       bool ok = true;
    5353
     54        // This line is used by test_one.sh
     55
    5456        // external compiled tests
    5557        ok &= Run( get_started,         "get_started"  );
    5658        ok &= Run( ode_inverse,         "ode_inverse"  );
    5759        ok &= Run( retape,              "retape"       );
    58        
     60
    5961        // check for errors
    6062        using std::cout;
  • trunk/example/makefile.am

    r3738 r3746  
    102102        bender_quad.cpp \
    103103        bool_fun.cpp \
     104        bool_sparsity.cpp \
    104105        capacity_order.cpp \
    105106        change_param.cpp \
  • trunk/example/makefile.in

    r3745 r3746  
    117117        atan.cpp atanh.cpp atan2.cpp azmul.cpp base_alloc.hpp \
    118118        base_require.cpp bender_quad.cpp bool_fun.cpp \
    119         capacity_order.cpp change_param.cpp check_for_nan.cpp \
    120         check_numeric_type.cpp check_simple_vector.cpp compare.cpp \
    121         compare_change.cpp complex_poly.cpp cond_exp.cpp conj_grad.cpp \
    122         cos.cpp cosh.cpp cppad_vector.cpp dependency.cpp div.cpp \
    123         div_eq.cpp equal_op_seq.cpp erf.cpp error_handler.cpp exp.cpp \
    124         expm1.cpp for_one.cpp for_two.cpp forward.cpp forward_dir.cpp \
     119        bool_sparsity.cpp capacity_order.cpp change_param.cpp \
     120        check_for_nan.cpp check_numeric_type.cpp \
     121        check_simple_vector.cpp compare.cpp compare_change.cpp \
     122        complex_poly.cpp cond_exp.cpp conj_grad.cpp cos.cpp cosh.cpp \
     123        cppad_vector.cpp dependency.cpp div.cpp div_eq.cpp \
     124        equal_op_seq.cpp erf.cpp error_handler.cpp exp.cpp expm1.cpp \
     125        for_one.cpp for_two.cpp forward.cpp forward_dir.cpp \
    125126        forward_order.cpp for_sparse_jac.cpp fun_assign.cpp \
    126127        fun_check.cpp hes_lagrangian.cpp hes_lu_det.cpp \
     
    156157        atan2.$(OBJEXT) azmul.$(OBJEXT) base_require.$(OBJEXT) \
    157158        bender_quad.$(OBJEXT) bool_fun.$(OBJEXT) \
    158         capacity_order.$(OBJEXT) change_param.$(OBJEXT) \
    159         check_for_nan.$(OBJEXT) check_numeric_type.$(OBJEXT) \
    160         check_simple_vector.$(OBJEXT) compare.$(OBJEXT) \
    161         compare_change.$(OBJEXT) complex_poly.$(OBJEXT) \
    162         cond_exp.$(OBJEXT) conj_grad.$(OBJEXT) cos.$(OBJEXT) \
    163         cosh.$(OBJEXT) cppad_vector.$(OBJEXT) dependency.$(OBJEXT) \
    164         div.$(OBJEXT) div_eq.$(OBJEXT) equal_op_seq.$(OBJEXT) \
    165         erf.$(OBJEXT) error_handler.$(OBJEXT) exp.$(OBJEXT) \
    166         expm1.$(OBJEXT) for_one.$(OBJEXT) for_two.$(OBJEXT) \
    167         forward.$(OBJEXT) forward_dir.$(OBJEXT) \
     159        bool_sparsity.$(OBJEXT) capacity_order.$(OBJEXT) \
     160        change_param.$(OBJEXT) check_for_nan.$(OBJEXT) \
     161        check_numeric_type.$(OBJEXT) check_simple_vector.$(OBJEXT) \
     162        compare.$(OBJEXT) compare_change.$(OBJEXT) \
     163        complex_poly.$(OBJEXT) cond_exp.$(OBJEXT) conj_grad.$(OBJEXT) \
     164        cos.$(OBJEXT) cosh.$(OBJEXT) cppad_vector.$(OBJEXT) \
     165        dependency.$(OBJEXT) div.$(OBJEXT) div_eq.$(OBJEXT) \
     166        equal_op_seq.$(OBJEXT) erf.$(OBJEXT) error_handler.$(OBJEXT) \
     167        exp.$(OBJEXT) expm1.$(OBJEXT) for_one.$(OBJEXT) \
     168        for_two.$(OBJEXT) forward.$(OBJEXT) forward_dir.$(OBJEXT) \
    168169        forward_order.$(OBJEXT) for_sparse_jac.$(OBJEXT) \
    169170        fun_assign.$(OBJEXT) fun_check.$(OBJEXT) \
     
    533534        bender_quad.cpp \
    534535        bool_fun.cpp \
     536        bool_sparsity.cpp \
    535537        capacity_order.cpp \
    536538        change_param.cpp \
     
    725727@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bender_quad.Po@am__quote@
    726728@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bool_fun.Po@am__quote@
     729@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bool_sparsity.Po@am__quote@
    727730@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/capacity_order.Po@am__quote@
    728731@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/change_param.Po@am__quote@
  • trunk/omh/example_list.omh

    r3740 r3746  
    111111$rref bender_quad.cpp$$
    112112$rref bool_fun.cpp$$
     113$rref bool_sparsity.cpp$$
    113114$rref capacity_order.cpp$$
    114115$rref change_param.cpp$$
  • trunk/omh/whats_new/whats_new_15.omh

    r3744 r3746  
    6565        unreferenced
    6666        azmul
     67        retape
    6768$$
    6869
     
    7475The purpose of this section is to
    7576assist you in learning about changes between various versions of CppAD.
     77
     78$head 11-08$$
     79$list number$$
     80Fixed a bug in the $cref RevSparseJac$$ routine.
     81To be specific, the argument $cref/r/RevSparseJac/r/$$
     82was transposed from what the documentation said.
     83(This has no effect in the usual case where $icode r$$ is the identity.)
     84$lnext
     85Added the $cref bool_sparsity.cpp$$ examples which show how
     86to conserve memory when computing sparsity patterns.
     87$lnext
     88Modified the $cref ipopt_solve$$ procedure to take
     89advantage of the memory conserving sparsity pattern calculations
     90when $cref/retape/ipopt_solve/options/Retape/$$ is false.
     91$lnext
     92Added the $cref/bit_per_unit/CppAD_vector/vectorBool/bit_per_unit/$$
     93function to the $code vectorBool$$ class.
     94(This aids the memory conservation mentioned above.)
     95$lend
     96
    7697
    7798$head 11-06$$
Note: See TracChangeset for help on using the changeset viewer.