Changeset 3794


Ignore:
Timestamp:
Feb 29, 2016 3:42:44 PM (4 years ago)
Author:
bradbell
Message:

merge to branch: trunk
from repository: https://github.com/coin-or/CppAD
start hash code: 833d34533ed5aa34a589f0b17ffd5d8f7fa79e6c
end hash code: 36daa4bde653baef804f51224f9ab4d25baaa523

commit 36daa4bde653baef804f51224f9ab4d25baaa523
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 13:08:21 2016 -0700

makefile.in: update to corresponding makefile.am.

commit c11faa0acbe8333c99f21903afdc2aec08dccb21
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 13:00:22 2016 -0700

Remove invisible white space.

commit b56fe0bd79f1aee23e392c86a022664955154e3a
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 12:59:37 2016 -0700

Change the speed test to use one global variable for the list of options.
batch_edit.sh: script that made the changes.
whats_new_16.omh: edited by hand.
main.cpp: edited by hand.

commit 5bfc082c54a3a1bdf63633e75c5695c0f0048a0d
Author: Brad Bell <bradbell@…>
Date: Mon Feb 29 11:20:14 2016 -0700

load_op.hpp: add doxygen doc that was mistaken deleted.

Location:
trunk
Files:
42 edited

Legend:

Unmodified
Added
Removed
  • trunk/bin/batch_edit.sh

    r3793 r3794  
    1818#
    1919cat << EOF > junk.sed
    20 s|sparse_set, sparse_list|sparse_list|
    21 s|.c sparse_pack, .c sparse_set,* or .c sparse_list|sparse_pack or sparse_list|
     20/^extern bool/! b one
     21N
     22N
     23/global_onetape/! b one
     24s|^extern bool.*global_[a-z]*;|# include <map> \\
     25extern std::map<std::string, bool> global_option;|
     26: one
     27/^\\textern bool global_boolsparsity;$/d
     28s|global_onetape|global_option["onetape"]|
     29s|global_optimize|global_option["optimize"]|
     30s|global_atomic|global_option["atomic"]|
     31s|global_memory|global_option["memory"]|
     32s|global_boolsparsity|global_option["boolsparsity"]|
     33s|global_colpack|global_option["colpack"]|
     34#
     35s|/speed_main/option_list/|/speed_main/Global Options/|
    2236EOF
    2337# -----------------------------------------------------------------------------
  • trunk/cppad/local/load_op.hpp

    r3793 r3794  
    8383i_vec is defined by
    8484\verbatim
     85        i_vec = floor( taylor[ arg[1] * cap_order + 0 ] )
    8586\endverbatim
    8687where floor(c) is the greatest integer less that or equal c.
  • trunk/example/makefile.in

    r3793 r3794  
    314314# $Id$
    315315# -----------------------------------------------------------------------------
    316 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     316# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    317317#
    318318# CppAD is distributed under multiple licenses. This distribution is under
  • trunk/omh/whats_new/whats_new_09.omh

    r3779 r3794  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    275275In addition, all of the $codei%speed/cppad/%*%.cpp%$$ tests
    276276now check and use the speed test
    277 $cref/optimize/speed_main/option_list/optimize/$$ flag.
     277$cref/optimize/speed_main/Global Options/optimize/$$ flag.
    278278
    279279$subhead 08-11$$
  • trunk/omh/whats_new/whats_new_11.omh

    r3792 r3794  
    861861
    862862$head 02-22$$
    863 Add the $cref/atomic/speed_main/option_list/atomic/$$ option to the
     863Add the $cref/atomic/speed_main/Global Options/atomic/$$ option to the
    864864speed test program and use
    865865$cref old_mat_mul.hpp$$ during the
  • trunk/omh/whats_new/whats_new_12.omh

    r3793 r3794  
    399399$head 10-03$$
    400400Change the $code hold_memory$$ speed to option to just
    401 $cref/memory/speed_main/option_list/memory/$$.
     401$cref/memory/speed_main/Global Options/memory/$$.
    402402In addition, in the speed test output, include all of the options
    403403that are present in the output variable name;
     
    549549$head 06-10$$
    550550$list number$$
    551 Add the $cref/hold_memory/speed_main/option_list/memory/$$ option
     551Add the $cref/hold_memory/speed_main/Global Options/memory/$$ option
    552552to the speed test main program.
    553553This was changed to just $code memory$$; see
  • trunk/omh/whats_new/whats_new_14.omh

    r3760 r3794  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    343343mention which tests are not available.
    344344Note that the set of available tests can depend on the
    345 $cref/list of options/speed_main/option_list/$$.
     345$cref/list of options/speed_main/Global Options/$$.
    346346$lnext
    347347In the documentation for
     
    352352The $cref speed_cppad$$ tests were simplified by removing the printing
    353353of auxillary information related to the
    354 $cref/optimize/speed_main/option_list/optimize/$$ option.
     354$cref/optimize/speed_main/Global Options/optimize/$$ option.
    355355Future auxillary information will be passed back in a manner similar to
    356356$cref/n_sweep/link_sparse_jacobian/n_sweep/$$ for the sparse jacobian test.
     
    423423$lnext
    424424The $code retape$$ option what changed to
    425 $cref/onetape/speed_main/option_list/onetape/$$ so that the default
     425$cref/onetape/speed_main/Global Options/onetape/$$ so that the default
    426426is to retape (option not present).
    427427This was done because
     
    430430$lnext
    431431The documentation, and example source code, for all the speed
    432 $cref/options/speed_main/option_list/$$ was improved
     432$cref/options/speed_main/Global Options/$$ was improved
    433433(made clearer).
    434434$lnext
  • trunk/omh/whats_new/whats_new_15.omh

    r3778 r3794  
    11$Id$
    22/* --------------------------------------------------------------------------
    3 CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     3CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    44
    55CppAD is distributed under multiple licenses. This distribution is under
     
    876876(it used to be different for every repeat).
    877877This reduced the amount of computation not connected what is being tested.
    878 It also make the $cref/onetape/speed_main/option_list/onetape/$$ a valid
     878It also make the $cref/onetape/speed_main/Global Options/onetape/$$ a valid
    879879option for these tests.
    880880$lnext
  • trunk/omh/whats_new/whats_new_16.omh

    r3793 r3794  
    3636
    3737$head 02-29$$
     38$list number$$
    3839Merged sparse into master branch. This makes the
    3940$cref ForSparseHes$$ routine available for use.
     41$lnext
     42Changed the
     43$cref/global options/speed_main/Global Options/$$
     44in the speed test main program to use one global variable with prototype
     45$srccode%cpp%
     46        extern std::map<std::string, bool> global_option;
     47%$$
     48$lend
    4049
    4150
  • trunk/speed/adolc/det_lu.cpp

    r3788 r3794  
    4646
    4747// list of possible options
    48 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     48# include <map>
     49extern std::map<std::string, bool> global_option;
    4950
    5051bool link_det_lu(
     
    5556{
    5657        // speed test global option values
    57         if( global_onetape || global_atomic )
     58        if( global_option["onetape"] || global_option["atomic"] )
    5859                return false;
    59         if( global_memory || global_optimize )
     60        if( global_option["memory"] || global_option["optimize"] )
    6061                return false;
    6162        // -----------------------------------------------------
  • trunk/speed/adolc/det_minor.cpp

    r3788 r3794  
    4646
    4747// list of possible options
    48 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     48# include <map>
     49extern std::map<std::string, bool> global_option;
    4950
    5051bool link_det_minor(
     
    5556{
    5657        // speed test global option values
    57         if( global_atomic )
     58        if( global_option["atomic"] )
    5859                return false;
    59         if( global_memory || global_optimize )
     60        if( global_option["memory"] || global_option["optimize"] )
    6061                return false;
    6162        // -----------------------------------------------------
     
    9495
    9596        // ----------------------------------------------------------------------
    96         if( ! global_onetape ) while(repeat--)
     97        if( ! global_option["onetape"] ) while(repeat--)
    9798        {       // choose a matrix
    9899                CppAD::uniform_01(n, mat);
  • trunk/speed/adolc/mat_mul.cpp

    r3788 r3794  
    4545
    4646// list of possible options
    47 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     47# include <map>
     48extern std::map<std::string, bool> global_option;
    4849
    4950bool link_mat_mul(
     
    5556{
    5657        // speed test global option values
    57         if( global_memory || global_atomic || global_optimize )
     58        if( global_option["memory"] || global_option["atomic"] || global_option["optimize"] )
    5859                return false;
    5960        // -----------------------------------------------------
     
    9293
    9394        // ----------------------------------------------------------------------
    94         if( ! global_onetape ) while(repeat--)
     95        if( ! global_option["onetape"] ) while(repeat--)
    9596        {       // choose a matrix
    9697                CppAD::uniform_01(n, mat);
  • trunk/speed/adolc/ode.cpp

    r3788 r3794  
    4343
    4444// list of possible options
    45 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     45# include <map>
     46extern std::map<std::string, bool> global_option;
    4647
    4748bool link_ode(
     
    5354{
    5455        // speed test global option values
    55         if( global_atomic )
     56        if( global_option["atomic"] )
    5657                return false;
    57         if( global_memory || global_optimize )
     58        if( global_option["memory"] || global_option["optimize"] )
    5859                return false;
    5960        // -------------------------------------------------------------
     
    9091
    9192        // -------------------------------------------------------------
    92         if( ! global_onetape ) while(repeat--)
     93        if( ! global_option["onetape"] ) while(repeat--)
    9394        {       // choose next x value
    9495                uniform_01(n, x);
  • trunk/speed/adolc/poly.cpp

    r3788 r3794  
    5555
    5656// list of possible options
    57 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     57# include <map>
     58extern std::map<std::string, bool> global_option;
    5859
    5960bool link_poly(
     
    6465        CppAD::vector<double>     &ddp      )  // second derivative w.r.t z
    6566{
    66         if( global_atomic )
     67        if( global_option["atomic"] )
    6768                return false;
    68         if( global_memory || global_optimize )
     69        if( global_option["memory"] || global_option["optimize"] )
    6970                return false;
    7071        // -----------------------------------------------------
     
    104105
    105106        // ----------------------------------------------------------------------
    106         if( ! global_onetape ) while(repeat--)
     107        if( ! global_option["onetape"] ) while(repeat--)
    107108        {       // choose an argument value
    108109                CppAD::uniform_01(1, z);
  • trunk/speed/adolc/sparse_hessian.cpp

    r3788 r3794  
    5252
    5353// list of possible options
    54 extern bool global_memory, global_onetape, global_atomic, global_optimize;
    55 extern bool global_colpack, global_boolsparsity;
     54# include <map>
     55extern std::map<std::string, bool> global_option;
    5656
    5757bool link_sparse_hessian(
     
    6464        size_t&                          n_sweep )
    6565{
    66         if( global_atomic || (! global_colpack) )
     66        if( global_option["atomic"] || (! global_option["colpack"]) )
    6767                return false;
    68         if( global_memory || global_optimize || global_boolsparsity )
     68        if( global_option["memory"] || global_option["optimize"] || global_option["boolsparsity"] )
    6969                return false;
    7070        // -----------------------------------------------------
     
    108108
    109109        // ----------------------------------------------------------------------
    110         if( ! global_onetape ) while(repeat--)
     110        if( ! global_option["onetape"] ) while(repeat--)
    111111        {       // choose a value for x
    112112                CppAD::uniform_01(n, x);
  • trunk/speed/adolc/sparse_jacobian.cpp

    r3788 r3794  
    5252
    5353// list of possible options
    54 extern bool global_memory, global_onetape, global_atomic, global_optimize;
    55 extern bool global_colpack, global_boolsparsity;
     54# include <map>
     55extern std::map<std::string, bool> global_option;
    5656
    5757bool link_sparse_jacobian(
     
    6565              size_t&                    n_sweep  )
    6666{
    67         if( global_atomic || (! global_colpack) )
     67        if( global_option["atomic"] || (! global_option["colpack"]) )
    6868                return false;
    69         if( global_memory || global_optimize )
     69        if( global_option["memory"] || global_option["optimize"] )
    7070                return false;
    7171        // -----------------------------------------------------
     
    9898        // options that control sparse_jac
    9999        int        options[4];
    100         extern bool global_boolsparsity;
    101         if( global_boolsparsity )
     100        if( global_option["boolsparsity"] )
    102101                options[0] = 1;  // sparsity by propagation of bit pattern
    103102        else
     
    138137        options[2]       = 0;
    139138        // ----------------------------------------------------------------------
    140         if( ! global_onetape ) while(repeat--)
     139        if( ! global_option["onetape"] ) while(repeat--)
    141140        {       // choose a value for x
    142141                CppAD::uniform_01(n, x);
  • trunk/speed/cppad/det_lu.cpp

    r3788 r3794  
    4343# include <cppad/speed/uniform_01.hpp>
    4444
    45 // Note that CppAD uses global_memory at the main program level
    46 extern bool
    47         global_onetape, global_atomic, global_optimize;
     45// Note that CppAD uses global_option["memory"] at the main program level
     46# include <map>
     47extern std::map<std::string, bool> global_option;
    4848
    4949bool link_det_lu(
     
    5454{
    5555        // speed test global option values
    56         if( global_onetape || global_atomic )
     56        if( global_option["onetape"] || global_option["atomic"] )
    5757                return false;
    5858
     
    8989                // create function object f : A -> detA
    9090                f.Dependent(A, detA);
    91                 if( global_optimize )
     91                if( global_option["optimize"] )
    9292                        f.optimize();
    9393
  • trunk/speed/cppad/det_minor.cpp

    r3788 r3794  
    4444# include <cppad/speed/uniform_01.hpp>
    4545
    46 // Note that CppAD uses global_memory at the main program level
    47 extern bool
    48         global_onetape, global_atomic, global_optimize;
     46// Note that CppAD uses global_option["memory"] at the main program level
     47# include <map>
     48extern std::map<std::string, bool> global_option;
    4949
    5050bool link_det_minor(
     
    5555{
    5656        // speed test global option values
    57         if( global_atomic )
     57        if( global_option["atomic"] )
    5858                return false;
    5959
     
    8080
    8181        // ---------------------------------------------------------------------
    82         if( ! global_onetape ) while(repeat--)
     82        if( ! global_option["onetape"] ) while(repeat--)
    8383        {
    8484                // choose a matrix
     
    9696                f.Dependent(A, detA);
    9797
    98                 if( global_optimize )
     98                if( global_option["optimize"] )
    9999                        f.optimize();
    100100
     
    124124                f.Dependent(A, detA);
    125125
    126                 if( global_optimize )
     126                if( global_option["optimize"] )
    127127                        f.optimize();
    128128
  • trunk/speed/cppad/mat_mul.cpp

    r3788 r3794  
    4747# include <cppad/example/matrix_mul.hpp>
    4848
    49 // Note that CppAD uses global_memory at the main program level
    50 extern bool
    51         global_onetape, global_atomic, global_optimize, global_boolsparsity;
     49// Note that CppAD uses global_option["memory"] at the main program level
     50# include <map>
     51extern std::map<std::string, bool> global_option;
    5252
    5353bool link_mat_mul(
     
    8383        matrix_mul atom_mul(nr_result, n_middle, nc_result);
    8484        //
    85         if( global_boolsparsity )
     85        if( global_option["boolsparsity"] )
    8686                atom_mul.option( CppAD::atomic_base<double>::pack_sparsity_enum );
    8787        else
    8888                atom_mul.option( CppAD::atomic_base<double>::set_sparsity_enum );
    8989        // ------------------------------------------------------
    90         if( ! global_onetape ) while(repeat--)
     90        if( ! global_option["onetape"] ) while(repeat--)
    9191        {       // get the next matrix
    9292                CppAD::uniform_01(n, x);
     
    9898
    9999                // do computations
    100                 if( ! global_atomic )
     100                if( ! global_option["atomic"] )
    101101                        mat_sum_sq(size, X, Y, Z);
    102102                else
     
    114114                f.Dependent(X, Z);
    115115
    116                 if( global_optimize )
     116                if( global_option["optimize"] )
    117117                        f.optimize();
    118118
     
    134134
    135135                // do computations
    136                 if( ! global_atomic )
     136                if( ! global_option["atomic"] )
    137137                        mat_sum_sq(size, X, Y, Z);
    138138                else
     
    151151                f.Dependent(X, Z);
    152152
    153                 if( global_optimize )
     153                if( global_option["optimize"] )
    154154                        f.optimize();
    155155
  • trunk/speed/cppad/ode.cpp

    r3788 r3794  
    4444# include <cassert>
    4545
    46 // Note that CppAD uses global_memory at the main program level
    47 extern bool
    48         global_onetape, global_atomic, global_optimize;
     46// Note that CppAD uses global_option["memory"] at the main program level
     47# include <map>
     48extern std::map<std::string, bool> global_option;
    4949
    5050bool link_ode(
     
    5656{
    5757        // speed test global option values
    58         if( global_atomic )
     58        if( global_option["atomic"] )
    5959                return false;
    6060
     
    7575
    7676        // -------------------------------------------------------------
    77         if( ! global_onetape ) while(repeat--)
     77        if( ! global_option["onetape"] ) while(repeat--)
    7878        {       // choose next x value
    7979                uniform_01(n, x);
     
    9090                f.Dependent(X, Y);
    9191
    92                 if( global_optimize )
     92                if( global_option["optimize"] )
    9393                        f.optimize();
    9494
     
    113113                f.Dependent(X, Y);
    114114
    115                 if( global_optimize )
     115                if( global_option["optimize"] )
    116116                        f.optimize();
    117117
  • trunk/speed/cppad/poly.cpp

    r3788 r3794  
    4949# include <cppad/speed/uniform_01.hpp>
    5050
    51 // Note that CppAD uses global_memory at the main program level
    52 extern bool
    53         global_onetape, global_atomic, global_optimize;
     51// Note that CppAD uses global_option["memory"] at the main program level
     52# include <map>
     53extern std::map<std::string, bool> global_option;
    5454
    5555bool link_poly(
     
    6161{
    6262        // speed test global option values
    63         if( global_atomic )
     63        if( global_option["atomic"] )
    6464                return false;
    6565
     
    9292
    9393        // --------------------------------------------------------------------
    94         if( ! global_onetape ) while(repeat--)
     94        if( ! global_option["onetape"] ) while(repeat--)
    9595        {
    9696                // choose an argument value
     
    107107                f.Dependent(Z, P);
    108108
    109                 if( global_optimize )
     109                if( global_option["optimize"] )
    110110                        f.optimize();
    111111
     
    141141                f.Dependent(Z, P);
    142142
    143                 if( global_optimize )
     143                if( global_option["optimize"] )
    144144                        f.optimize();
    145145
  • trunk/speed/cppad/sparse_hessian.cpp

    r3788 r3794  
    5050# include <cppad/speed/sparse_hes_fun.hpp>
    5151
    52 // Note that CppAD uses global_memory at the main program level
    53 extern bool
    54         global_onetape, global_colpack,
    55         global_atomic, global_optimize, global_boolsparsity;
     52// Note that CppAD uses global_option["memory"] at the main program level
     53# include <map>
     54extern std::map<std::string, bool> global_option;
    5655
    5756namespace {
     
    104103        size_t&                          n_sweep  )
    105104{
    106         if( global_atomic )
     105        if( global_option["atomic"] )
    107106                return false;
    108107# ifndef CPPAD_COLPACK_SPEED
    109         if( global_colpack )
     108        if( global_option["colpack"] )
    110109                return false;
    111110# endif
     
    134133
    135134        // ------------------------------------------------------
    136         if( ! global_onetape ) while(repeat--)
     135        if( ! global_option["onetape"] ) while(repeat--)
    137136        {       // choose a value for x
    138137                CppAD::uniform_01(n, x);
     
    149148                f.Dependent(a_x, a_y);
    150149
    151                 if( global_optimize )
     150                if( global_option["optimize"] )
    152151                        f.optimize();
    153152
     
    156155
    157156                // calculate the Hessian sparsity pattern for this function
    158                 if( global_boolsparsity )
     157                if( global_option["boolsparsity"] )
    159158                        calc_sparsity(bool_sparsity, f);
    160159                else
     
    164163                CppAD::sparse_hessian_work work;
    165164# ifdef CPPAD_COLPACK_SPEED
    166                 if( global_colpack )
     165                if( global_option["colpack"] )
    167166                        work.color_method = "colpack.star";
    168167# endif
    169168                // calculate this Hessian at this x
    170                 if( global_boolsparsity) n_sweep = f.SparseHessian(
     169                if( global_option["boolsparsity"]) n_sweep = f.SparseHessian(
    171170                        x, w, bool_sparsity, row, col, hessian, work
    172171                );
     
    190189                f.Dependent(a_x, a_y);
    191190
    192                 if( global_optimize )
     191                if( global_option["optimize"] )
    193192                        f.optimize();
    194193
     
    197196
    198197                // calculate the Hessian sparsity pattern for this function
    199                 if( global_boolsparsity)
     198                if( global_option["boolsparsity"])
    200199                        calc_sparsity(bool_sparsity, f);
    201200                else
     
    205204                CppAD::sparse_hessian_work work;
    206205# ifdef CPPAD_COLPACK_SPEED
    207                 if( global_colpack )
     206                if( global_option["colpack"] )
    208207                        work.color_method = "colpack.star";
    209208# endif
     
    213212
    214213                        // calculate hessian at this x
    215                         if( global_boolsparsity ) n_sweep = f.SparseHessian(
     214                        if( global_option["boolsparsity"] ) n_sweep = f.SparseHessian(
    216215                                x, w, bool_sparsity, row, col, hessian, work
    217216                        );
  • trunk/speed/cppad/sparse_jacobian.cpp

    r3788 r3794  
    5151# include <cppad/speed/sparse_jac_fun.hpp>
    5252
    53 // Note that CppAD uses global_memory at the main program level
    54 extern bool
    55         global_onetape, global_colpack,
    56         global_atomic, global_optimize, global_boolsparsity;
     53// Note that CppAD uses global_option["memory"] at the main program level
     54# include <map>
     55extern std::map<std::string, bool> global_option;
    5756
    5857namespace {
     
    9291              size_t&                    n_sweep  )
    9392{
    94         if( global_atomic )
     93        if( global_option["atomic"] )
    9594                return false;
    9695# ifndef CPPAD_COLPACK_SPEED
    97         if( global_colpack )
     96        if( global_option["colpack"] )
    9897                return false;
    9998# endif
     
    116115
    117116        // ------------------------------------------------------
    118         if( ! global_onetape ) while(repeat--)
     117        if( ! global_option["onetape"] ) while(repeat--)
    119118        {       // choose a value for x
    120119                CppAD::uniform_01(n, x);
     
    131130                f.Dependent(a_x, a_y);
    132131
    133                 if( global_optimize )
     132                if( global_option["optimize"] )
    134133                        f.optimize();
    135134
     
    138137
    139138                // calculate the Jacobian sparsity pattern for this function
    140                 if( global_boolsparsity )
     139                if( global_option["boolsparsity"] )
    141140                        calc_sparsity(bool_sparsity, f);
    142141                else
     
    146145                CppAD::sparse_jacobian_work work;
    147146# ifdef CPPAD_COLPACK_SPEED
    148                 if( global_colpack )
     147                if( global_option["colpack"] )
    149148                        work.color_method = "colpack";
    150149# endif
    151150                // calculate the Jacobian at this x
    152151                // (use forward mode because m > n ?)
    153                 if( global_boolsparsity) n_sweep = f.SparseJacobianForward(
     152                if( global_option["boolsparsity"]) n_sweep = f.SparseJacobianForward(
    154153                                x, bool_sparsity, row, col, jacobian, work
    155154                );
     
    173172                f.Dependent(a_x, a_y);
    174173
    175                 if( global_optimize )
     174                if( global_option["optimize"] )
    176175                        f.optimize();
    177176
     
    180179
    181180                // calculate the Jacobian sparsity pattern for this function
    182                 if( global_boolsparsity )
     181                if( global_option["boolsparsity"] )
    183182                        calc_sparsity(bool_sparsity, f);
    184183                else
     
    188187                CppAD::sparse_jacobian_work work;
    189188# ifdef CPPAD_COLPACK_SPEED
    190                 if( global_colpack )
     189                if( global_option["colpack"] )
    191190                        work.color_method = "colpack";
    192191# endif
     
    197196                        // calculate the Jacobian at this x
    198197                        // (use forward mode because m > n ?)
    199                         if( global_boolsparsity ) n_sweep = f.SparseJacobianForward(
     198                        if( global_option["boolsparsity"] ) n_sweep = f.SparseJacobianForward(
    200199                                        x, bool_sparsity, row, col, jacobian, work
    201200                        );
  • trunk/speed/double/det_lu.cpp

    r3788 r3794  
    3535# include <cppad/speed/uniform_01.hpp>
    3636
    37 // Note that CppAD uses global_memory at the main program level
    38 extern bool
    39         global_onetape, global_atomic, global_optimize;
     37// Note that CppAD uses global_option["memory"] at the main program level
     38# include <map>
     39extern std::map<std::string, bool> global_option;
    4040
    4141bool link_det_lu(
     
    4545        CppAD::vector<double>           &det      )
    4646{
    47         if(global_onetape||global_atomic||global_optimize)
     47        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"])
    4848                return false;
    4949        // -----------------------------------------------------
  • trunk/speed/double/det_minor.cpp

    r3788 r3794  
    3636# include <cppad/speed/uniform_01.hpp>
    3737
    38 // Note that CppAD uses global_memory at the main program level
    39 extern bool
    40         global_onetape, global_atomic, global_optimize;
     38// Note that CppAD uses global_option["memory"] at the main program level
     39# include <map>
     40extern std::map<std::string, bool> global_option;
    4141
    4242bool link_det_minor(
     
    4646        CppAD::vector<double>     &det      )
    4747{
    48         if(global_onetape||global_atomic||global_optimize)
     48        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"])
    4949                return false;
    5050        // -----------------------------------------------------
  • trunk/speed/double/mat_mul.cpp

    r3788 r3794  
    3737# include <cppad/speed/uniform_01.hpp>
    3838
    39 // Note that CppAD uses global_memory at the main program level
    40 extern bool
    41         global_onetape, global_atomic, global_optimize;
     39// Note that CppAD uses global_option["memory"] at the main program level
     40# include <map>
     41extern std::map<std::string, bool> global_option;
    4242
    4343bool link_mat_mul(
     
    4949)
    5050{
    51         if(global_onetape||global_atomic||global_optimize)
     51        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"])
    5252                return false;
    5353        // -----------------------------------------------------
  • trunk/speed/double/ode.cpp

    r3788 r3794  
    4040# include <cppad/speed/uniform_01.hpp>
    4141
    42 // Note that CppAD uses global_memory at the main program level
    43 extern bool
    44         global_onetape, global_atomic, global_optimize;
     42// Note that CppAD uses global_option["memory"] at the main program level
     43# include <map>
     44extern std::map<std::string, bool> global_option;
    4545
    4646bool link_ode(
     
    5151)
    5252{
    53         if(global_onetape||global_atomic||global_optimize)
     53        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"])
    5454                return false;
    5555        // -------------------------------------------------------------
  • trunk/speed/double/poly.cpp

    r3788 r3794  
    3535# include <cppad/speed/uniform_01.hpp>
    3636
    37 // Note that CppAD uses global_memory at the main program level
    38 extern bool
    39         global_onetape, global_atomic, global_optimize;
     37// Note that CppAD uses global_option["memory"] at the main program level
     38# include <map>
     39extern std::map<std::string, bool> global_option;
    4040
    4141bool link_poly(
     
    4646        CppAD::vector<double>     &p        )  // second derivative w.r.t z
    4747{
    48         if(global_onetape||global_atomic||global_optimize)
     48        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"])
    4949                return false;
    5050        // -----------------------------------------------------
  • trunk/speed/double/sparse_hessian.cpp

    r3788 r3794  
    3737# include <cppad/speed/sparse_hes_fun.hpp>
    3838
    39 // Note that CppAD uses global_memory at the main program level
    40 extern bool
    41         global_onetape, global_atomic, global_optimize, global_boolsparsity;
     39// Note that CppAD uses global_option["memory"] at the main program level
     40# include <map>
     41extern std::map<std::string, bool> global_option;
    4242
    4343bool link_sparse_hessian(
     
    5050        size_t&                          n_sweep  )
    5151{
    52         if(global_onetape||global_atomic||global_optimize||global_boolsparsity)
     52        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"]||global_option["boolsparsity"])
    5353                return false;
    5454        // -----------------------------------------------------
  • trunk/speed/double/sparse_jacobian.cpp

    r3788 r3794  
    4343# include <cppad/speed/sparse_jac_fun.hpp>
    4444
    45 // Note that CppAD uses global_memory at the main program level
    46 extern bool
    47         global_onetape, global_atomic, global_optimize, global_boolsparsity;
     45// Note that CppAD uses global_option["memory"] at the main program level
     46# include <map>
     47extern std::map<std::string, bool> global_option;
    4848
    4949bool link_sparse_jacobian(
     
    5757              size_t&                    n_sweep  )
    5858{
    59         if(global_onetape||global_atomic||global_optimize||global_boolsparsity)
     59        if(global_option["onetape"]||global_option["atomic"]||global_option["optimize"]||global_option["boolsparsity"])
    6060                return false;
    6161        // -----------------------------------------------------
  • trunk/speed/fadbad/det_lu.cpp

    r3788 r3794  
    4343
    4444// list of possible options
    45 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     45# include <map>
     46extern std::map<std::string, bool> global_option;
    4647
    4748bool link_det_lu(
     
    5253{
    5354        // speed test global option values
    54         if( global_onetape || global_atomic )
     55        if( global_option["onetape"] || global_option["atomic"] )
    5556                return false;
    56         if( global_memory || global_optimize )
     57        if( global_option["memory"] || global_option["optimize"] )
    5758                return false;
    5859        // -----------------------------------------------------
  • trunk/speed/fadbad/det_minor.cpp

    r3788 r3794  
    4343
    4444// list of possible options
    45 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     45# include <map>
     46extern std::map<std::string, bool> global_option;
    4647
    4748bool link_det_minor(
     
    5253{
    5354        // speed test global option values
    54         if( global_atomic )
     55        if( global_option["atomic"] )
    5556                return false;
    56         if( global_memory || global_onetape || global_optimize )
     57        if( global_option["memory"] || global_option["onetape"] || global_option["optimize"] )
    5758                return false;
    5859        // -----------------------------------------------------
  • trunk/speed/fadbad/mat_mul.cpp

    r3788 r3794  
    4343
    4444// list of possible options
    45 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     45# include <map>
     46extern std::map<std::string, bool> global_option;
    4647
    4748bool link_mat_mul(
     
    5354{
    5455        // speed test global option values
    55         if( global_memory || global_onetape || global_atomic || global_optimize )
     56        if( global_option["memory"] || global_option["onetape"] || global_option["atomic"] || global_option["optimize"] )
    5657                return false;
    5758        // The correctness check for this test is failing, so abort (for now).
  • trunk/speed/fadbad/ode.cpp

    r3788 r3794  
    5050
    5151// list of possible options
    52 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     52# include <map>
     53extern std::map<std::string, bool> global_option;
    5354
    5455namespace fadbad {
     
    6667{
    6768        // speed test global option values
    68         if( global_atomic )
     69        if( global_option["atomic"] )
    6970                return false;
    70         if( global_memory || global_onetape || global_optimize )
     71        if( global_option["memory"] || global_option["onetape"] || global_option["optimize"] )
    7172                return false;
    7273        // -------------------------------------------------------------
  • trunk/speed/fadbad/poly.cpp

    r3788 r3794  
    5151
    5252// list of possible options
    53 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     53# include <map>
     54extern std::map<std::string, bool> global_option;
    5455
    5556bool link_poly(
     
    6061        CppAD::vector<double>     &ddp      )  // second derivative w.r.t z
    6162{
    62         if( global_atomic )
     63        if( global_option["atomic"] )
    6364                return false;
    64         if( global_memory || global_onetape || global_optimize )
     65        if( global_option["memory"] || global_option["onetape"] || global_option["optimize"] )
    6566                return false;
    6667        // -----------------------------------------------------
  • trunk/speed/main.cpp

    r3791 r3794  
    1717# include <iostream>
    1818# include <iomanip>
     19# include <map>
    1920# include <cppad/utility/vector.hpp>
    2021# include <cppad/speed/det_grad_33.hpp>
     
    144145before any of the testing routines (listed above) are called.
    145146
    146 $head option_list$$
    147 This is a list of options that follow $icode seed$$ value.
     147$head Global Options$$
     148This global variable has prototype
     149$srccode%cpp%
     150        extern std::map<std::string, bool> global_option;
     151%$$
     152This is true for each option that follows $icode seed$$.
    148153The order of the options does not matter and the list can be empty.
    149 Each option in the list, must be separate
     154Each option, must be separate
    150155command line argument to the main program.
    151156The documentation below specifics how CppAD uses these options,
     
    154159
    155160$subhead onetape$$
    156 If the option $code onetape$$ is present, the symbol
     161If the option $code onetape$$ is present,
    157162$codep
    158         extern bool global_onetape
     163        global_option["onetape"]
    159164$$
    160165is true and otherwise it is false.
     
    179184
    180185$subhead optimize$$
    181 If the option $code optimize$$ is present, the symbol
     186If the option $code optimize$$ is present,
    182187$codep
    183         extern bool global_optimize
     188        global_option["optimize"]
    184189$$
    185190is true and otherwise it is false.
     
    189194
    190195$subhead atomic$$
    191 If the option $code atomic$$ is present, the symbol
     196If the option $code atomic$$ is present,
    192197$codep
    193         extern bool global_atomic
     198        global_option["atomic"]
    194199$$
    195200is true and otherwise it is false.
     
    200205
    201206$subhead memory$$
    202 If the option $code memory$$ is present, the symbol
     207If the option $code memory$$ is present,
    203208$codep
    204         extern bool global_memory
     209        global_option["memory"]
    205210$$
    206211is true and otherwise it is false.
     
    218223
    219224$subhead boolsparsity$$
    220 If the option $code boolsparsity$$ is present, the symbol
     225If the option $code boolsparsity$$ is present,
    221226$codep
    222         extern bool global_boolsparsity
     227        global_option["boolsparsity"]
    223228$$
    224229is true and otherwise it is false.
     
    230235
    231236$subhead colpack$$
    232 If the option $code colpack$$ is present, the symbol
     237If the option $code colpack$$ is present,
    233238$codep
    234         extern bool global_colpack
     239        global_option["colpack"]
    235240$$
    236241is true and otherwise it is false.
     
    332337
    333338// --------------------------------------------------------------------------
    334 
    335 bool   global_onetape;
    336 bool   global_colpack;
    337 bool   global_optimize;
    338 bool   global_atomic;
    339 bool   global_memory;
    340 bool   global_boolsparsity;
     339std::map<std::string, bool> global_option;
     340// --------------------------------------------------------------------------
     341
    341342
    342343namespace {
    343344        using std::cout;
    344345        using std::endl;
     346        const char* option_list[] = {
     347                "onetape",
     348                "optimize",
     349                "atomic",
     350                "memory",
     351                "boolsparsity",
     352                "colpack",
     353        };
     354        size_t num_option = sizeof(option_list) / sizeof( option_list[0] );
    345355        // ----------------------------------------------------------------
    346356        // not available test message
     
    348358        {       cout << AD_PACKAGE << ": " << test_name;
    349359                cout << " is not availabe with " << endl;
    350                 cout << "onetape = " << global_onetape << endl;
    351                 cout << "colpack = " << global_colpack << endl;
    352                 cout << "optimize = " << global_optimize << endl;
    353                 cout << "atomic = " << global_atomic << endl;
    354                 cout << "memory = " << global_memory << endl;
    355                 cout << "boolsparsity = " << global_boolsparsity << endl;
    356         }
    357 
     360                for(size_t i = 0; i < num_option; i++)
     361                {       std::string option = option_list[i];
     362                        cout << option << " = " << global_option[option] << endl;
     363                }
     364        }
    358365        // ------------------------------------------------------
    359366        // output vector in form readable by octave or matlab
     
    389396                }
    390397                cout << AD_PACKAGE << "_" << case_name;
    391                 if( global_onetape )
    392                         cout << "_onetape";
    393                 if( global_colpack )
    394                         cout << "_colpack";
    395                 if( global_optimize )
    396                         cout << "_optimize";
    397                 if( global_atomic )
    398                         cout << "_atomic";
    399                 if( global_memory )
    400                         cout << "_memory";
    401                 if( global_boolsparsity )
    402                         cout << "_boolsparsity";
     398                for(size_t i = 0; i < num_option; i++)
     399                {       std::string option = option_list[i];
     400                        if( global_option[option]  )
     401                                cout << "_" << option;
     402                }
    403403                if( ! available )
    404404                {       cout << "_available = false" << endl;
     
    477477        const size_t n_test  = sizeof(test_list) / sizeof(test_list[0]);
    478478
    479         size_t i;
    480479        test_enum match = test_error;
    481480        int    iseed = 0;
    482481        bool   error = argc < 3;
    483482        if( ! error )
    484         {       for(i = 0; i < n_test; i++)
     483        {       for(size_t i = 0; i < n_test; i++)
    485484                        if( strcmp(test_list[i].name, argv[1]) == 0 )
    486485                                match = test_list[i].index;
     
    488487                iseed = std::atoi( argv[2] );
    489488                error |= iseed < 0;
    490                 global_onetape      = false;
    491                 global_colpack      = false;
    492                 global_optimize     = false;
    493                 global_atomic       = false;
    494                 global_memory       = false;
    495                 global_boolsparsity = false;
    496                 for(i = 3; i < size_t(argc); i++)
    497                 {       if( strcmp(argv[i], "onetape") == 0 )
    498                                 global_onetape = true;
    499                         else if( strcmp(argv[i], "colpack") == 0 )
    500                                 global_colpack = true;
    501                         else if( strcmp(argv[i], "optimize") == 0 )
    502                                 global_optimize = true;
    503                         else if( strcmp(argv[i], "atomic") == 0 )
    504                                 global_atomic = true;
    505                         else if( strcmp(argv[i], "memory") == 0 )
    506                                 global_memory = true;
    507                         else if( strcmp(argv[i], "boolsparsity") == 0 )
    508                                 global_boolsparsity = true;
    509                         else
    510                                 error = true;
     489                for(size_t i = 0; i < num_option; i++)
     490                        global_option[ option_list[i] ] = false;
     491                for(size_t i = 3; i < size_t(argc); i++)
     492                {       error = true;
     493                        for(size_t j = 0; j < num_option; j++)
     494                        {       if( strcmp(argv[i], option_list[j]) == 0 )
     495                                {       global_option[ option_list[j] ] = true;
     496                                        error = false;
     497                                }
     498                        }
    511499                }
    512500        }
     
    515503                     << AD_PACKAGE << " test seed option_list" << endl;
    516504                cout << "test choices: " << endl;
    517                 for(i = 0; i < n_test; i++)
     505                for(size_t i = 0; i < n_test; i++)
    518506                        cout << "\t" << test_list[i].name << endl;
    519                 cout << "seed choices: ";
    520                 cout << "a positive integer used as a random seed." << endl;
    521                 cout << "option choices: ";
    522                 cout << " \"onetape\",";
    523                 cout << " \"colpack\",";
    524                 cout << " \"optimize\",";
    525                 cout << " \"atomic\",";
    526                 cout << " \"memory\",";
    527                 cout << " \"boolsparsity\"." << endl << endl;
     507                cout << "seed: is a positive integer used as a random seed." << endl;
     508                cout << "option: is zero, one or more of the following:" << endl;
     509                for(size_t i = 0; i < num_option; i++)
     510                        cout << " " << option_list[i];
     511                cout << endl << endl;
    528512                return 1;
    529513        }
    530         if( global_memory )
     514        if( global_option["memory"] )
    531515                CppAD::thread_alloc::hold_memory(true);
    532516
     
    543527        CppAD::vector<size_t> size_sparse_hessian(n_size);
    544528        CppAD::vector<size_t> size_sparse_jacobian(n_size);
    545         for(i = 0; i < n_size; i++)
     529        for(size_t i = 0; i < n_size; i++)
    546530        {       size_det_minor[i]   = i + 1;
    547531                size_det_lu[i]      = 10 * i + 1;
     
    693677                );
    694678                cout << AD_PACKAGE << "_sparse_hessian_sweep = ";
    695                 for(i = 0; i < size_sparse_hessian.size(); i++)
     679                for(size_t i = 0; i < size_sparse_hessian.size(); i++)
    696680                {       if( i == 0 )
    697681                                cout << "[ ";
     
    719703                );
    720704                cout << AD_PACKAGE << "_sparse_jacobian_n_sweep = ";
    721                 for(i = 0; i < size_sparse_jacobian.size(); i++)
     705                for(size_t i = 0; i < size_sparse_jacobian.size(); i++)
    722706                {       if( i == 0 )
    723707                                cout << "[ ";
  • trunk/speed/sacado/det_lu.cpp

    r3788 r3794  
    4545
    4646// list of possible options
    47 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     47# include <map>
     48extern std::map<std::string, bool> global_option;
    4849
    4950bool link_det_lu(
     
    5455{
    5556        // speed test global option values
    56         if( global_onetape || global_atomic )
     57        if( global_option["onetape"] || global_option["atomic"] )
    5758                return false;
    58         if( global_memory || global_optimize )
     59        if( global_option["memory"] || global_option["optimize"] )
    5960                return false;
    6061        // -----------------------------------------------------
  • trunk/speed/sacado/det_minor.cpp

    r3788 r3794  
    4343
    4444// list of possible options
    45 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     45# include <map>
     46extern std::map<std::string, bool> global_option;
    4647
    4748bool link_det_minor(
     
    5253{
    5354        // speed test global option values
    54         if( global_atomic )
     55        if( global_option["atomic"] )
    5556                return false;
    56         if( global_memory || global_onetape || global_optimize )
     57        if( global_option["memory"] || global_option["onetape"] || global_option["optimize"] )
    5758                return false;
    5859        // -----------------------------------------------------
  • trunk/speed/sacado/mat_mul.cpp

    r3788 r3794  
    4242
    4343// list of possible options
    44 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     44# include <map>
     45extern std::map<std::string, bool> global_option;
    4546
    4647bool link_mat_mul(
     
    5253{
    5354        // speed test global option values
    54         if( global_memory || global_onetape || global_atomic || global_optimize )
     55        if( global_option["memory"] || global_option["onetape"] || global_option["atomic"] || global_option["optimize"] )
    5556                return false;
    5657        // -----------------------------------------------------
  • trunk/speed/sacado/ode.cpp

    r3788 r3794  
    4343
    4444// list of possible options
    45 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     45# include <map>
     46extern std::map<std::string, bool> global_option;
    4647
    4748bool link_ode(
     
    5354{
    5455        // speed test global option values
    55         if( global_atomic )
     56        if( global_option["atomic"] )
    5657                return false;
    57         if( global_memory || global_onetape || global_optimize )
     58        if( global_option["memory"] || global_option["onetape"] || global_option["optimize"] )
    5859                return false;
    5960        // -------------------------------------------------------------
  • trunk/speed/sacado/poly.cpp

    r3788 r3794  
    5353
    5454// list of possible options
    55 extern bool global_memory, global_onetape, global_atomic, global_optimize;
     55# include <map>
     56extern std::map<std::string, bool> global_option;
    5657
    5758bool link_poly(
     
    6263        CppAD::vector<double>     &ddp      )  // second derivative w.r.t z
    6364{
    64         if( global_atomic )
     65        if( global_option["atomic"] )
    6566                return false;
    66         if( global_memory || global_onetape || global_optimize )
     67        if( global_option["memory"] || global_option["onetape"] || global_option["optimize"] )
    6768                return false;
    6869        // -----------------------------------------------------
  • trunk/test_more/makefile.in

    r3793 r3794  
    120120        div.cpp div_eq.cpp div_zero_one.cpp erf.cpp exp.cpp expm1.cpp \
    121121        extern_value.cpp extern_value.hpp for_hess.cpp \
    122         for_sparse_jac.cpp forward.cpp forward_dir.cpp \
    123         forward_order.cpp from_base.cpp fun_check.cpp jacobian.cpp \
    124         num_limits.cpp log.cpp log1p.cpp log10.cpp mul.cpp \
    125         mul_cskip.cpp mul_eq.cpp mul_level.cpp mul_cond_rev.cpp \
    126         mul_zdouble.cpp mul_zero_one.cpp near_equal_ext.cpp neg.cpp \
    127         ode_err_control.cpp old_usead_2.cpp old_usead_1.cpp \
    128         old_tan.cpp old_reciprocal.cpp old_mat_mul.cpp old_mat_mul.hpp \
    129         omp_alloc.cpp optimize.cpp parameter.cpp poly.cpp pow.cpp \
    130         pow_int.cpp print_for.cpp romberg_one.cpp rosen_34.cpp \
    131         runge_45.cpp reverse.cpp rev_sparse_hes.cpp rev_sparse_jac.cpp \
     122        for_sparse_hes.cpp for_sparse_jac.cpp forward.cpp \
     123        forward_dir.cpp forward_order.cpp from_base.cpp fun_check.cpp \
     124        hes_sparsity.cpp jacobian.cpp num_limits.cpp log.cpp log1p.cpp \
     125        log10.cpp mul.cpp mul_cskip.cpp mul_eq.cpp mul_level.cpp \
     126        mul_cond_rev.cpp mul_zdouble.cpp mul_zero_one.cpp \
     127        near_equal_ext.cpp neg.cpp ode_err_control.cpp old_usead_2.cpp \
     128        old_usead_1.cpp old_tan.cpp old_reciprocal.cpp old_mat_mul.cpp \
     129        old_mat_mul.hpp omp_alloc.cpp optimize.cpp parameter.cpp \
     130        poly.cpp pow.cpp pow_int.cpp print_for.cpp romberg_one.cpp \
     131        rosen_34.cpp runge_45.cpp reverse.cpp rev_sparse_jac.cpp \
    132132        rev_two.cpp simple_vector.cpp sin.cpp sin_cos.cpp sinh.cpp \
    133133        sparse_hessian.cpp sparse_jacobian.cpp sparse_vec_ad.cpp \
     
    152152        erf.$(OBJEXT) exp.$(OBJEXT) expm1.$(OBJEXT) \
    153153        extern_value.$(OBJEXT) for_hess.$(OBJEXT) \
    154         for_sparse_jac.$(OBJEXT) forward.$(OBJEXT) \
    155         forward_dir.$(OBJEXT) forward_order.$(OBJEXT) \
    156         from_base.$(OBJEXT) fun_check.$(OBJEXT) jacobian.$(OBJEXT) \
     154        for_sparse_hes.$(OBJEXT) for_sparse_jac.$(OBJEXT) \
     155        forward.$(OBJEXT) forward_dir.$(OBJEXT) \
     156        forward_order.$(OBJEXT) from_base.$(OBJEXT) \
     157        fun_check.$(OBJEXT) hes_sparsity.$(OBJEXT) jacobian.$(OBJEXT) \
    157158        num_limits.$(OBJEXT) log.$(OBJEXT) log1p.$(OBJEXT) \
    158159        log10.$(OBJEXT) mul.$(OBJEXT) mul_cskip.$(OBJEXT) \
     
    166167        poly.$(OBJEXT) pow.$(OBJEXT) pow_int.$(OBJEXT) \
    167168        print_for.$(OBJEXT) romberg_one.$(OBJEXT) rosen_34.$(OBJEXT) \
    168         runge_45.$(OBJEXT) reverse.$(OBJEXT) rev_sparse_hes.$(OBJEXT) \
    169         rev_sparse_jac.$(OBJEXT) rev_two.$(OBJEXT) \
    170         simple_vector.$(OBJEXT) sin.$(OBJEXT) sin_cos.$(OBJEXT) \
    171         sinh.$(OBJEXT) sparse_hessian.$(OBJEXT) \
     169        runge_45.$(OBJEXT) reverse.$(OBJEXT) rev_sparse_jac.$(OBJEXT) \
     170        rev_two.$(OBJEXT) simple_vector.$(OBJEXT) sin.$(OBJEXT) \
     171        sin_cos.$(OBJEXT) sinh.$(OBJEXT) sparse_hessian.$(OBJEXT) \
    172172        sparse_jacobian.$(OBJEXT) sparse_vec_ad.$(OBJEXT) \
    173173        sqrt.$(OBJEXT) std_math.$(OBJEXT) sub.$(OBJEXT) \
     
    290290# $Id$
    291291# -----------------------------------------------------------------------------
    292 # CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-15 Bradley M. Bell
     292# CppAD: C++ Algorithmic Differentiation: Copyright (C) 2003-16 Bradley M. Bell
    293293#
    294294# CppAD is distributed under multiple licenses. This distribution is under
     
    534534        extern_value.hpp \
    535535        for_hess.cpp \
     536        for_sparse_hes.cpp \
    536537        for_sparse_jac.cpp \
    537538        forward.cpp \
     
    540541        from_base.cpp \
    541542        fun_check.cpp \
     543        hes_sparsity.cpp \
    542544        jacobian.cpp \
    543545        num_limits.cpp \
     
    572574        runge_45.cpp \
    573575        reverse.cpp \
    574         rev_sparse_hes.cpp \
    575576        rev_sparse_jac.cpp \
    576577        rev_two.cpp \
     
    690691@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/extern_value.Po@am__quote@
    691692@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_hess.Po@am__quote@
     693@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_sparse_hes.Po@am__quote@
    692694@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/for_sparse_jac.Po@am__quote@
    693695@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/forward.Po@am__quote@
     
    696698@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/from_base.Po@am__quote@
    697699@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fun_check.Po@am__quote@
     700@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/hes_sparsity.Po@am__quote@
    698701@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ipopt_solve.Po@am__quote@
    699702@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/jacobian.Po@am__quote@
     
    725728@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pow_int.Po@am__quote@
    726729@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print_for.Po@am__quote@
    727 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rev_sparse_hes.Po@am__quote@
    728730@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rev_sparse_jac.Po@am__quote@
    729731@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rev_two.Po@am__quote@
Note: See TracChangeset for help on using the changeset viewer.