All of the options with full documentation for a MoochoSolver

Below are all of the options that MOOCHO will accept for the the "MamaJama" algorithm configuration with full documentation. This is the file that is returned by generate-opt-file.pl with no options. To view these same options stripped of most of the comments see here.

*** Automatically generated options file

begin_options
*** Begin Moocho.opt.MoochoSolver

*************************************************************************************
*** All of these options can be used with the class MoochoSolver.
***
*** This file will be maintained and will include every option that
*** users can set.  Most of these options the user will want to
*** leave alone but they are there in any case.
***
*** For options specific to the NLPAlgoConfigMamaJama configuration
*** class see the file 'Moocho.opt.NLPAlgoConfigMamaJama'.
***

**********************************************************
*** Options specific for the MoochoSolver class.
***
*** These options work on the highest level in determining
*** what output files are allowed, workspace requirements,
*** objective function scaling etc.
***
options_group MoochoSolver {

*    workspace_MB = -1.0; *** [default]
     *** (+-dbl) If > 0, givens the number of megabytes that are allocated for
     *** temporary workspace for automatic arrays.  If < 0 then the
     *** this will be determined internally.  This value should be set by the
     *** user for whatever is appropriate for the computing environment.  See
     *** the summary output for statistics on memory allocation usage when the
     *** algorithm finishes.  Example values:
     *** -1.0 : (< 0) Allow the algorithm to decide how much to allocate.
     *** 100  : Allocate 100 MB of ram for this purpose

*    obj_scale = 1.0; *** [default]
     *** (+-dbl) Scale for the objective function.  This can have a dramatic impact
     *** on the behavior of the algorithm in some cases.  Changing this value
     *** does a lot to change the weight between minimizing the objective and converging
     *** the constraints.  Example values:
     *** 1e-8  : Really scale the objective down a lot!
     *** 1.0   : Leave the objective unscaled [default].
     *** 1e+8  : Really scale the objective up a lot!

*    test_nlp = true; *** [default]
*    test_nlp = false;
     *** If true then the NLP will be tested at the initial point.  The
     *** vector spaces (see options_group VectorSpaceTester),
     *** the NLP interface (see options_group NLPTester), and the gradients
     *** (see options_group NLPDirectTester and NLPFirstOrderInfoTester)
     *** will all be tested.  With all of the default options in place
     *** these tests are fairly cheap so it is recommended that you perform
     *** these tests when first getting started.

*    console_outputting = true; *** [default]
*    console_outputting = false;
     *** If true, then output from MoochoTrackerConsoleStd is sent to the
     *** console_out stream (which is std::cout by default) 

*    summary_outputting = true; *** [default]
*    summary_outputting = false;
     *** If true, then output from MoochoTrackerSummaryStd is sent to the
     *** summary_out stream (which is the file 'MoochoSummary.out' by default) 

*    journal_outputting = true; *** [default]
*    journal_outputting = false;
     *** If true, then output from the algorithm steps an other detailed testing
     *** output is set to the journal_out stream (which is the file
     *** 'MoochoJournal.out' by default) 

*    algo_outputting = true; *** [default]
*    algo_outputting = false;
     *** If true, then an algorithm description is sent to the algo_out stream
     *** (which is the file 'MoochoAlgo.out' by default) 

*    print_algo = true; *** [default]
*    print_algo = false;
     *** [algo_outputting == true]
     *** If true then the algorithm will be printed to the algo_out stream
     *** (the file 'NLPAlgo.out' by default).  In order to get more insight into
     *** what all of the options do it is a good idea to print the algorithm
     *** description out and search for the options you are curious about.

*    algo_timing = true; *** [default]
*    algo_timing = false;
     *** [summary_outputting == true]
     *** If true, then the steps in the algorithm will be timed and a table of the
     *** algorithm and step times will be sent to the summary_out stream (the file
     *** 'MoochoSummary.out' by default).  This feature is very useful in examining
     *** performance of the algorithm and can give more detailed information than you
     *** get from a profiler in may ways.

*    generate_stats_file = true;
*    generate_stats_file = false; *** [default]
     *** If true, then a MoochoTrackerStatsStd object will be used to generate
     *** statistics about the solution process to an NLP.  The track object
     *** will overwrite the file 'MoochoStats.out' in the current directory.

*    print_opt_grp_not_accessed = true; *** [default]
*    print_opt_grp_not_accessed = false;
     *** [algo_outputting == true]
     *** If true, then the options groups that are specified but are not read by
     *** some software entity are printed to the algo_out stream (the file 'MoochoAlgo.out'
     *** by default).  This may help you catch problems associated with spelling the name of
     *** an options group improperly and then having its default options used instead of the
     *** options that you set.  Note that some options groups are only looked for depending
     *** on option values from other options groups.

*    configuration = mama_jama; *** [default]
*    configuration = interior_point;
     *** decides which configuration object will be used:
     ***   mama_jama      : standard reduced-space SQP configuration
     ***   interior_point : configuration for a simple reduced-space interior point method

}

***********************************************************
*** Options for NLPSolverClientInterface
***
*** These are options that are used by every algorithm
*** configuration and they are available to the 
*** optimization steps.
***
*** These include basic algorithmic control parameters.
***
*** Note that an algorithm can be interrupted at any time
*** by pressing Ctrl+C.
***
options_group NLPSolverClientInterface {

*    max_iter = 1000;  *** [default]
     *** (+int) Maximum number of SQP iterations allowed.

*    max_run_time = 1e+10; *** In minutes [default]
     *** (+dbl) Maximum runtime for the SQP algorithm (in minutes).
     *** The default is to run forever.

*    opt_tol = 1e-6;  *** [default]
     *** (+dbl) Convergence tolerance for (scaled) KKT linear dependence of gradients.
     *** This is usually the hardest error to reduce.  The exact definition of this tolerance
     *** depends on the algorithms used and may use different scalings (see other options and
     *** outputted algorithm description for details).  Example values:
     *** 0.0   : The algorithm will never converge except in trivial cases.
     *** 1e-6  : Only converge when opt_kkt_err is below this value [default].
     *** 1e+50 : (big number) Converged when any of the other tolerances are satisfied.

*    feas_tol = 1e-6;  *** [default]
     *** (+dbl) Convergence tolerance for (scaled) feasibility of the equality constraints
     *** ||c(x)||inf.  The norm of the constraints ||c(x)||inf may be scaled (see other
     *** options and the outputted algorithm description).  Example values:
     *** 0.0   : Never converge the algorithm except in trivial cases.
     *** 1e-6  : Only converge when feas_kkt_err is below this value [default].
     *** 1e+50 : (big number)  Converged when any of the other tolerances are satisfied.

*    step_tol = 1e-2;  *** [default]
     *** (+dbl) Convergence tolerance for (scaled) step size ||x_k(+1)-x_k||inf.
     *** This tolerance is usually scaled by x is some way (see other output algorithm
     *** description).  Example values:
     *** 0.0   : Never converge the algorithm except in trivial cases.
     *** 1e-2  : Only converge when the max (scaled) step size is below this value [default].
     *** 1e+50 : (big number) Converged when any of the other tolerances are satisfied.

*    journal_output_level = PRINT_NOTHING;              * No output to journal from algorithm
*    journal_output_level = PRINT_BASIC_ALGORITHM_INFO; * O(1) information usually
*    journal_output_level = PRINT_ALGORITHM_STEPS;      * O(iter) output to journal     [default]
*    journal_output_level = PRINT_ACTIVE_SET;           * O(iter*nact) output to journal  
*    journal_output_level = PRINT_VECTORS;              * O(iter*n) output to journal   (lots!)
*    journal_output_level = PRINT_ITERATION_QUANTITIES; * O(iter*n*m) output to journal (big lots!)
     *** [MoochoSolver::journal_outputting == true]
     *** This option determines the type and amount of output to the journal_out stream
     *** (the file 'MoochoJournal.out' by default) that is generated while the algorithm runs.
     *** In general, each increasing value includes the same output from the lower options
     *** (i.e. PRINT_VECTORS includes all the output for PRINT_ACTIVE_SET and more).  Above,
     *** the identifier 'iter' is the number of total rSQP iterations (see max_iter above), 'nact'
     *** is the total number of active inequality constraints, 'n' is the total number
     *** of NLP variables, and 'm' is the total number of equality constraints.  The higher output
     *** values are generally used for debugging.  For most problems the value
     *** PRINT_ALGORITHM_STEPS is usually the most appropriate and will give a great deal
     *** of information about the algorithm without generating excessive output.
     *** For the fastest possible execution you should set this to PRINT_NOTHING.

*    null_space_journal_output_level = DEFAULT;                    * Set to journal_output_level [default]
*    null_space_journal_output_level = PRINT_ACTIVE_SET;           * O(iter*nact) output to journal  
*    null_space_journal_output_level = PRINT_VECTORS;              * O(iter*(n-m)) output to journal   (lots!)
*    null_space_journal_output_level = PRINT_ITERATION_QUANTITIES; * O(iter*(n-m)^2) output to journal (big lots!)
     *** [MoochoSolver::journal_outputting == true]
     *** This option determines the type and amount of output to the journal_out stream
     *** (the file 'MoochoJournal.out' by default) that is generated for quantities in the
     *** null space while the algorithm runs.  If null_space_journal_output_level is
     *** set to DEFAULT then it will default to the value of journal_output_level.
     *** If set to some other value then this value overrides journal_output_level
     *** for quantities in the null space.  For problems where the null space is small but
     *** the full space is much larger, setting the value of null_space_journal_output_level higher
     *** than journal_output_level can yield significantly more information while not generating
     *** too much output or impacting runtime to any great extent.

*    journal_print_digits = 6;  *** [default]
     *** [MoochoSolver::journal_outputting == true]
     *** (+int) Number of decimal significant figures to print to journal_out stream.
     *** With a higher number more significant figures will be printed.  This may be useful
     *** for debugging or in seeing the effects of subtle rounding differences.  For IEEE double
     *** precision, 18 is usually the maximum number of unique decimal significant figures.

*    check_results = true;  *** (costly?)
*    check_results = false; *** [default]
     *** If true then all computation that can be reasonably checked will be checked at runtime.
     *** When all of the other default testing options are used, this overhead usually will
     *** not dominate the cost of the algorithm so if speed is not critical then it is a
     *** good idea to turning testing on.  If your problem is not solving then you should
     *** definitely try turning this on and try to see if it will catch any errors.  However,
     *** for the fastest possible execution you should set this to 'false'.

*    calc_conditioning = true;  *** (costly?)
*    calc_conditioning = false; *** [default]
     *** If true then estimates of the condition numbers of all of the important nonsingular
     *** matrices used in the algorithm will be computed and printed.  Note that this can be
     *** a fairly expensive operation (especially when iterative solvers are being used)
     *** so it should be used with care.  Warning! see the option calc_matrix_info_null_space_only
     *** as it affects the behavior of this option.

*    calc_matrix_norms = true;  *** (costly?)
*    calc_matrix_norms = false; *** [default]
     *** If true, then estimates of the matrix norms of all of the important
     *** matrices used in the algorithm will be computed and printed.  Note that this can be
     *** a fairly expensive operation (especially if iterative solvers are being used) so
     *** it should be used with care.  Warning! see the option calc_matrix_info_null_space_only.

*    calc_matrix_info_null_space_only = true;  *** (costly?)
*    calc_matrix_info_null_space_only = false; *** [default]
     *** If true, then the options calc_conditioning and calc_matrix_norms will only
     *** apply to quantities in the null space and not the quasi-range space
     *** or the full space for which these options will be considered to be false.

}

************************************************************
*** Options for testing the NLP interface
***
*** [MoochoSolver::test_nlp == true]
***
options_group NLPTester {

*    print_all = true;
*    print_all = false; *** [default]
     *** If true, then everything about the NLP will be printed
     *** to journal_out (i.e. the file 'MoochoJournal.out').
     *** This is useful for initial debugging but not recommended
     *** for larger problems.

}

*************************************************************
*** Options for testing the vector spaces from the NLP object
***
*** [MoochoSolver::test_nlp == true]
***
options_group VectorSpaceTester {

*    print_all_tests = true;
*    print_all_tests = false;

*    print_vectors = true;
*    print_vectors = false;

*    throw_exception = true;
*    throw_exception = false;

*    num_random_tests = 4; *** [default]

*    warning_tol = 1e-14; *** [default]

*    error_tol   = 1e-10; *** [default]

}

***********************************************************
*** Options for the finite derivative testing for a
*** standard NLP.
***
*** See options_group NLPFirstDerivTester in
*** Moocho.opt.NLPAlgoConfigMamaJama
***

****************************************************************
*** Options for the finite difference derivative tester for a 
*** direct sensitivity NLP.
***
*** See options_group NLPDirectTester in
*** Moocho.opt.NLPAlgoConfigMamaJama
***

****************************************************************
*** Options for the BasisSystem tester used to validate the
*** basis of the constraints Jacobian.
***
*** See options_group BasisSystemTester in
*** Moocho.opt.DecompositionSystemStateStepBuilderStd
***

****************************************************************
*** Options for the default BasisSystem factory object for
*** the constraints of the Jacobian used by
*** NLPSerialPreprocessExplJac
***
options_group BasisSystemFactoryStd {

*    direct_linear_solver = DENSE;   *** Use LAPACK xGETRF()
*    direct_linear_solver = MA28;    *** Use Harwell MA28 (see options_group DirectSparseSolverMA28)
*    direct_linear_solver = MA48;    *** Not supported yet
*    direct_linear_solver = SUPERLU; *** Use SuperLU (see options_group DirectSparseSolverSuperLU)
     *** Direct fortran-compatible linear solver for the  basis of the Jacobian.
     *** When a general NLP is being solved this selects the sparse linear solver used.
     *** If the user specializes the BasisSystem object this option might be meaningless.

}

*****************************************************************
*** Set options for the MA28 solver.
***
*** [BasisSystemFactoryStd::direct_linear_solver == MA28]
***
options_group DirectSparseSolverMA28 {

*    estimated_fillin_ratio = 10.0; *** [default]
     *** (+dbl) Estimated amount of fillin ( > 1.0 ) for the
     *** the sparse LU factorization.  If this is too little
     *** then more storage will automatically be allocated
     *** on the fly (at the cost some wasted computations).
     *** This parameter is mostly problem dependent and can
     *** be adjusted to a proper size to reduce memory requirements.
     *** Example values:
     ***   1.0   : No fill-in?
     ***   10.0  : LU factors have three times the number of nonzeros

*    u = 0.1; *** [default]
     *** (+dbl) Control parameter (0 <= u <= 1.0) that us used
     *** to balance sparsity and accuracy.
     *** Example values:
     ***    0.0 : Pivot for sparsity only
     ***    0.1 : Balance sparsity and stability
     ***    1.0 : Pivot for stability only
 
*    grow = true;
*    grow = false; *** [default]
     *** See MA28 documentation.

*    nsrch = 4; *** [default]
     *** (+int) Number of columns that MA28 will search to find
     *** pivots to try to reduce fill-in.  Warning, setting a large
     *** value for 'nsrch' can greatly slow down the initial
     *** rSQP iteration.
     *** Example values:
     ***    0  : No columns are searched
     ***    4  : Four columns are searched
     *** 1000  : A thousand columns are searched

*    lbig = true;
*    lbig = false; *** [default]
     *** See MA28 documentation.

*    print_ma28_outputs = true;
*    print_ma28_outputs = false; *** [default]
     *** If true, then the values of the MA28 output will
     *** be dumped to the journal output stream
     *** (if journal_output_level >= PRINT_ALGORITHM_STEPS).

*    output_file_name = NONE; *** [default]
     *** Gives the file name that MA28 Fortran output is set to (from LP and MP).
     *** Example values:
     ***    NONE           : No output file
     ***    any_other_name : Output from MA28 will be sent to this file in the
     ***                     current directory

}

*** End Moocho.opt.MoochoSolver
*** Moocho.opt.DecompositionSystemStateStepBuilderStd 

**********************************************************************************
*** All of these options can be used with any NLPAlgoConfig
*** subclass that uses the standard DecompositionSystemStateStepBuilderStd
*** class.
***
*** This file will be maintained and will include every option that
*** users can set.  Most of these options the user will want to leave
*** alone but they are there in any case.
***

***********************************************************
*** Options for IterationPack::Algorithm
***
*** These are options that are used by every IterationPack::Algorithm
*** object that gets created and used.
***
options_group IterationPack_Algorithm {

*   interrupt_file_name = "";             *** Does not check for interrupt file [default]
*   interrupt_file_name = "interrupt.in"; *** checks for this file in current directory
    *** This specifies a file name that is looked for at the end of every
    *** step in a running algorithm.  If this file exists, it is read for
    *** algorithm termination criteria (see the class IterationPack::Algorithm
    *** and the option interrupt_file_name).  Using a file to interrupt an running
    *** algorithm allows the algorithm to be gracefully terminated when run in batch
    *** mode or when access to STDOUT or STDIN is not possible.

}

*****************************************************************
*** Options specific for the shared rSQP algorithm builder
*** class DecompositionSystemStateStepBuilderStd.
***
options_group DecompositionSystemStateStepBuilderStd {

*** Variable Reduction range/null space decomposition

*    null_space_matrix = AUTO;         *** Let the solver decide [default]
*    null_space_matrix = EXPLICIT;     *** Compute and store D = -inv(C)*N explicitly
*    null_space_matrix = IMPLICIT;     *** Perform operations implicitly with C, N (requires adjoints)
     *** This option is used to determine the type of implementation to use for
     *** the variable reduction null space matrix Z = [ -inv(C)*N; I ].
     ***    AUTO     : Let the algorithm decide.  The algorithm will take into
     ***               account the number of degrees of freedom in the problem
     ***               (n-r), the number of active inequality constraints and
     ***               other issues when deciding what implementation to use within
     ***               each iteration.  Warning!  These automatic tests are only
     ***               affective when a direct solver for C is used.
     ***    EXPLICIT : The matrix D = -inv(C)*N is computed and formed explicitly and is used
     ***               to form Z = [ D; I ].
     ***    IMPLICIT : The matrix D = -inv(C)*N is not formed explicitly but is
     ***               instead used implicitly in matrix-vector and other
     ***               related operations.

*    range_space_matrix = AUTO;        *** Let the algorithm decide dynamically [default]
*    range_space_matrix = COORDINATE;  *** Y = [ I; 0 ] (Cheaper computationally)
*    range_space_matrix = ORTHOGONAL;  *** Y = [ I; -N'*inv(C') ] (more stable)
     *** This option is used to determine the selection of the range space matrix Y.
     ***    AUTO      : Let the algorithm decide.  The algorithm will take into
     ***                account the number of degrees of freedom in the problem
     ***                (n-r) and other issues when deciding what representation to use.
     ***                Warning!  These automatic tests are only affective when a direct
     ***                solver for C is used.
     ***   COORDINATE : Use the coordinate decomposition Y = [ I; 0 ]
     ***   ORTHOGONAL : Use the orthogonal decomposition Y = [ I; N'*inv(C') ].
     ***                Warning!  For general NLPs this option costs approximately
     ***                O((n-r)^2*r) dense flops per rSQP iteration and will dominate
     ***                the runtime for large (n-r).  In addition, this option
     ***                assumes that you will be using null_space_matrix=EXPLICIT.

*** Reduced Hessian Approximations

*    max_dof_quasi_newton_dense = -1; *** [default]
     *** [quasi_newton == AUTO] (+-int)  This option is used to
     *** determine when the algorithm will switch from quasi_newton=BFGS
     *** to quasi_newton=LBFGS and from range_space_matrix=ORTHOGONAL
     *** to range_space_matrix=COORDINATE.
     *** Example values:
     ***  -1 : (< 0) Let the solver decide dynamically [default]
     ***   0 : Always use limited memory LBFGS and COORDINATE.
     *** 500 : Use LBFGS when n-r >= 500 and dense BFGS when n-m < 500
     ***       Use COORDINATE when (n-m)*r >= 500 and ORTHOGONAL when
     ***       (n-r)*r <= 500.
     *** 1e10: Always use the dense BFGS and the orthogonal decomposition.

}

***************************************************************
*** Options group for CalcFiniteDiffProd class
***
*** These options control how finite differences are computed
*** for testing and for other purposes.
***
options_group CalcFiniteDiffProd {

*    fd_method_order = FD_ORDER_ONE;          *** Use O(eps) one sided finite differences
*    fd_method_order = FD_ORDER_TWO;          *** Use O(eps^2) one sided finite differences
*    fd_method_order = FD_ORDER_TWO_CENTRAL;  *** Use O(eps^2) two sided central finite differences
*    fd_method_order = FD_ORDER_TWO_AUTO;     *** Uses FD_ORDER_TWO_CENTRAL or FD_ORDER_TWO
*    fd_method_order = FD_ORDER_FOUR;         *** Use O(eps^4) one sided finite differences
*    fd_method_order = FD_ORDER_FOUR_CENTRAL; *** Use O(eps^4) two sided central finite differences
*    fd_method_order = FD_ORDER_FOUR_AUTO;    *** [default] Use FD_ORDER_FOUR_CENTRAL or FD_ORDER_FOUR
     *** Selects the finite differencing method to use.  Several different
     *** methods of different orders are available.  For more accuracy use a higher order
     *** method, for faster execution time use a lower order method.

*    fd_step_select = FD_STEP_ABSOLUTE; *** [default] Use absolute step size fd_step_size
*    fd_step_select = FD_STEP_RELATIVE; *** Use relative step size fd_step_size * ||x||inf
     *** Determines how the actual finite difference step size that is used is selected.
     ***    FD_STEP_ABSOLUTE : The actual step size used is taken from fd_step_size or
     ***                       is determined by the implementation if fd_step_size < 0.0.
     ***                       Taking an absolute step size can result in inaccurate gradients
     ***                       for  badly scaled NLPs.
     ***    FD_STEP_RELATIVE : The actual step size used is taken from fd_step_size or
     ***                       is determined by the implementation if fd_step_size < 0.0
     ***                       and then multiplied by ||x||inf.  Taking a relative step
     ***                       will not always result in accurate gradients and the user
     ***                       may have to play with fd_step_size some.

*    fd_step_size = -1.0; *** [default] Let the implementation decide
     *** Determines what finite difference step size to use.  If fd_step_select=FD_STEP_ABSOLUTE
     *** then this is the absolute step size that is used.  If fd_step_select=FD_STEP_RELATIVE
     *** the actual step size used in fd_step_size * ||x||inf.
     *** Some common values are:
     ***   < 0.0   : let the implementation decide.
     ***   1e-8    : Optimal step size for FD_ORDER_ONE for IEEE double and perfect scaling?
     ***   1e-5    : Optimal step size for FD_ORDER_TWOx for IEEE double and perfect scaling?
     ***   1e-3    : Optimal step size for FD_ORDER_FOURx for IEEE double and perfect scaling?

*    fd_step_size_min = -1.0; *** [default] Let the implementation decide.
     *** Determines the minimum step size that will be taken to compute the finite differences.
     *** This option is used to forbid the computation of a finite difference with a very small
     *** step size as required by the variable bounds.  Computing finite difference derivatives
     *** for such small step sizes generally result in a lot of roundoff error.  If
     *** fd_step_size_min < 0.0, then the implementation will pick a default value that is
     *** smaller than the default value for fd_step_size.

*    fd_step_size_f = -1.0; *** [default] Let the implementation decide
     *** Determines what finite difference step size to use for the objective function
     *** f(x).  If fd_step_size_f < 0.0, then the selected value for fd_step_size will be
     *** used (see the options fd_step_size and fd_step_select).  This option allows
     *** fine-tuning of the finite difference computations.

*    fd_step_size_c = -1.0; *** [default] Let the implementation decide
     *** Determines what finite difference step size to use for the equality constraints
     *** c(x).  If fd_step_size_c < 0.0, then the selected value for fd_step_size will be
     *** used (see the options fd_step_size and fd_step_select).  This option allows
     *** fine-tuning of the finite difference computations.

*    fd_step_size_h = -1.0; *** [default] Let the implementation decide
     *** Determines what finite difference step size to use for the inequality constraints
     *** h(x).  If fd_step_size_h < 0.0, then the selected value for fd_step_size will be
     *** used (see the options fd_step_size and fd_step_select).  This option allows
     *** fine-tuning of the finite difference computations.

}

***************************************************************
*** Options for EvalNewPoint for NLPFirstOrder.
*** See options_group NLPFirstDerivTester
***
options_group EvalNewPointStd {

*    fd_deriv_testing = FD_DEFAULT; *** [default] Test if check_results==true (see above)
*    fd_deriv_testing = FD_TEST;    *** Always test
*    fd_deriv_testing = FD_NO_TEST; *** never test
     *** Determines if the derivatives of the NLP returned from the NLPFirstOrder interface
     *** are correct using finite differences (see the options_group NLPFirstDerivTester).
     *** Valid options include:
     ***    FD_DEFAULT : Perform the finite difference tests if check_results==true.
     ***    FD_TEST    : Always test, regardless of the value of check_results.
     ***    FD_NO_TEST : Never test, regardless of the value of check_results.

*    decomp_sys_testing = DST_DEFAULT; *** [default] Test if check_results==true (see above)
*    decomp_sys_testing = DST_TEST;    *** Always test
*    decomp_sys_testing = DST_NO_TEST; *** never test
     *** Determines if the range/null decomposition matrices from DecompositionSystem are
     *** tested or not (see the options_group DecompositionSystemTester).
     *** Valid options include:
     ***    FD_DEFAULT : Perform the tests if check_results==true.
     ***    FD_TEST    : Always test, regardless of the value of check_results.
     ***    FD_NO_TEST : Never test, regardless of the value of check_results.

*    decomp_sys_testing_print_level = DSPL_USE_GLOBAL;    *** [default] Use the value in journal_print_level (see above).
*    decomp_sys_testing_print_level = DSPL_LEAVE_DEFAULT; *** Leave whatever setting in already in use.
     *** This option allows the user to determine how the testing print level is determined.
     *** Valid options include:
     ***    DSLP_USE_GLOBAL    : The value of journal_print_level will be used to determine reasonable values for
     ***                         print_tests and dump_all.
     ***    DSLP_LEAVE_DEFAULT : Whatever values are currently set for DecompositionSystemTester::print_tests and
     ***                         DecompositionSystemTester::dump_all will be used (see the options_group
     ***                         DecompositionSystemTester).

}

***************************************************************
*** Options for determining if variable bounds
*** xL <= x <= xU are violated by
*** more than an acceptable tolerance.
***
options_group VariableBoundsTester {
*    warning_tol   = 1e-10; *** [default]
*    error_tol     = 1e-5; *** [default]
}

***********************************************************
*** Options for the finite difference testing of derivatives for a
*** standard NLP.
***
options_group NLPFirstDerivTester {
*    fd_testing_method = FD_COMPUTE_ALL; *** Compute all of the derivatives (O(m))
*    fd_testing_method = FD_DIRECTIONAL; *** [default] Only compute along random directions (O(1))
*    num_fd_directions = 1;   *** [fd_testing_method == DIRECTIONAL]
*    num_fd_directions = -1;  *** [fd_testing_method == DIRECTIONAL] Use single direction y=1.0
*    warning_tol   = 1e-8; *** [default]
*    warning_tol   = 0.0;  *** Show me all comparisons.
*    error_tol     = 1e-3; *** [default]
}

***************************************************************
*** Options for EvalNewPoint for a "Tailored Approach" NLP.
*** See options_group NLPDirectTester
***
options_group EvalNewPointTailoredApproach {
*    fd_deriv_testing   = FD_DEFAULT;  *** [default] Test if check_results==true (see above)
*    fd_deriv_testing   = FD_TEST;    *** Always test
*    fd_deriv_testing   = FD_NO_TEST; *** never test
}

****************************************************************
*** Options for the finite difference derivative tester for a 
*** direct sensitivity NLP.
***
options_group NLPDirectTester {
*    Gf_testing_method = FD_COMPUTE_ALL; *** Compute all of the derivatives (O(n))
*    Gf_testing_method = FD_DIRECTIONAL; *** [default] Only compute along random directions (O(1))
*    Gf_warning_tol   = 1e-10;
*    Gf_error_tol     = 1e-5;
*    Gc_testing_method = FD_COMPUTE_ALL; *** Compute all of the derivatives (O(n-m))
*    Gc_testing_method = FD_DIRECTIONAL; *** [default] Only compute along random directions (O(1))
*    Gc_warning_tol   = 1e-10;
*    Gc_error_tol     = 1e-5;
*    num_fd_directions = 1;  *** [testing_method == DIRECTIONAL]
*    dump_all = true;
*    dump_all = false; *** [default]
}

****************************************************************
*** Options for the BasisSystem tester used to validate the
*** basis of the constraints Jacobian.
***
options_group BasisSystemTester {
*    print_tests = PRINT_NONE;    *** [default]
*    print_tests = PRINT_BASIC;
*    print_tests = PRINT_MORE;
*    print_tests = PRINT_ALL;
*    dump_all = true;
*    dump_all = false;          *** [default]
*    num_random_tests = 1;      *** (+int) Number of sets of random tests to perform
*    warning_tol   = 1e-15;     *** (+dbl) Warning tolerance
*    error_tol     = 1e-12;     *** (+dbl) Error tolerance
}

****************************************************************
*** Options for the DecompositionSystem tester used to validate
*** range/null decomposition matrices (NLPFirstOrder only).
***
options_group DecompositionSystemTester {
*    print_tests = PRINT_NONE;    *** [default]
*    print_tests = PRINT_BASIC;
*    print_tests = PRINT_MORE;
*    print_tests = PRINT_ALL;
*    dump_all = true;             *** (costly)
*    dump_all = false;            *** [default]
*    num_random_tests   = 1;      *** (+int) Number of sets of random test to perform
*    mult_warning_tol   = 1e-14;  *** (+dbl) Warning tolerance for checking matrix-vector multiplication
*    mult_error_tol     = 1e-8;   *** (+dbl) Error tolerance for checking matrix-vector multiplication
*    solve_warning_tol  = 1e-14;  *** (+dbl) Warning tolerance for checking linear solves
*    solve_error_tol    = 1e-8;   *** (+dbl) Error tolerance for checking linear solves
}

*** End Moocho.opt.DecompositionSystemStateStepBuilderStd 
*** Begin Moocho.opt.NLPAlgoConfigMamaJama

*************************************************************************
*** All of these options can be used with the NLPAlgoConfigMamaJama
*** algorithm configuration class.
***
*** See the file Moocho.opt.DecompositionSystemStateStepBuilderStd
*** for more options that are used by this class.
***
*** This file will be maintained and will include every option that
*** users can set.  Most of these options the user will want to leave
*** alone but they are there in any case.
***

**********************************************************
*** Options specific for the rSQP algorithm configuration
*** class NLPAlgoConfigMamaJama.
***
options_group NLPAlgoConfigMamaJama {

*** Variable Reduction range/null space decomposition

*    max_basis_cond_change_frac = -1.0;  *** [default]
     *** (+-dbl) If < 0 then the solver will decide what value to use.
     *** Otherwise this is the change in a very inexact condition number estimate
     *** between iterations (see printed algorithm description) which triggers the
     *** selection of a new basis.
     *** Example values:
     ***    -1 : Allow solver to decide [default] 
     ***     0 : Switch to a new basis every iteration (not a good idea)
     ***   100 : Switch to a new basis when change is more that 100?
     *** 1e+50 : (big number) Never switch to a new basis.

*** Reduced Hessian Approximations

*    exact_reduced_hessian = true; *** Use NLP Hessian info if available
*    exact_reduced_hessian = false; *** Use quasi_newton [default]
     *** If true and if the NLP supports second order information
     *** (hessian of the lagrangian HL) then the exact reduced hessian
     *** rHL = Z'*HL*Z will be computed at each iteration.

*    quasi_newton = AUTO;   *** Let solver decide dynamically [default]
*    quasi_newton = BFGS;   *** Dense BFGS
*    quasi_newton = LBFGS;  *** Limited memory BFGS
     *** [exact_reduced_hessian == false]
     *** ToDo: Finish documentation!

*    num_lbfgs_updates_stored   = -1; *** [default]
     *** [quasi_newton == LBFGS] (+-int) If < 0 then let solver decide
     *** otherwise this is the maximum number of update vectors stored
     *** for limited memory LBFGS.

*    lbfgs_auto_scaling = true;  *** (default)
*    lbfgs_auto_scaling = false;
     *** [quasi_newton == LBFGS] If true then auto scaling of initial
     *** hessian approximation will be use for LBFGS.

*    hessian_initialization = AUTO;                       *** Let the solver decide dynamically [default]
*    hessian_initialization = SERIALIZE;                  *** rHL_{0} read from file (see ReducedHessianSerialization)
*    hessian_initialization = IDENTITY;                   *** rHL_{0} = I
*    hessian_initialization = FINITE_DIFF_SCALE_IDENTITY; *** rHL_{0} = ||fd|| * I
*    hessian_initialization = FINITE_DIFF_DIAGONAL;       *** rHL_{0} = diag(max(fd(i),small),i)
*    hessian_initialization = FINITE_DIFF_DIAGONAL_ABS;   *** rHL_{0} = diag(abs(fd(i))
     *** [exact_reduced_hessian == false] Determines how the quasi-newton hessian is initialized.
     *** ToDo: Finis documentation!

*** QP solvers

*    qp_solver = AUTO;    *** Let the solver decide dynamically
*    qp_solver = QPKWIK;  *** Primal-dual, active set, QR
*    qp_solver = QPOPT;   *** Primal, active set, null space, Gill et. al.
*    qp_solver = QPSOL;   *** Primal, active set, null space, Gill et. al.
*    qp_solver = QPSCHUR; *** [default] Primal-dual, active set, schur complement 
     *** QP solver to use to solve the reduced space QP subproblem (null
     *** space step).  Note that only QPSCHUR ships with MOOCHO by default.

*    reinit_hessian_on_qp_fail = true; *** [default]
*    reinit_hessian_on_qp_fail = false;
     *** If true, then if a QPFailure exception is thrown (see printed algorithm)
     *** then the Hessian approximation will be reinitialized and the QP solver will
     *** attempt to solve the QP again.

*** Line search methods

*    line_search_method = AUTO;               *** Let the solver decide dynamically [default]
*    line_search_method = NONE;               *** Take full steps at every iteration
*    line_search_method = DIRECT;             *** Use standard Armijo backtracking
*    line_search_method = 2ND_ORDER_CORRECT;  *** Like DIRECT except computes corrections for
*                                             *** c(x) before backtracking line search
*    line_search_method = WATCHDOG;           *** Like DIRECT except uses watchdog type trial steps
*    line_search_method = FILTER;             *** [default] Use the Filter line search method
     *** Options:
     *** AUTO : Let the solver decide dynamically what line search method to use (if any)
     *** NONE : Take full steps at every iteration.  For most problems this is a bad idea.
     ***     However, for some problems this can help when starting close to the solution usually.
     *** DIRECT : Use a standard Armijo backtracking line search at every iteration.
     *** 2ND_ORDER_CORRECT : Like DIRECT except computes corrections for before applying
     ***     the backtracking line search (see options_group LineSearch2ndOrderCorrect).
     ***     This can help greatly on some problems and can counter act the Maritos effect.
     *** FILTER : Use the filter line search.  Here we accept either a decrease in the
     ***     objective function for the constraints.  See "Global and Local Convergence of
     ***     Line Search Filter Methods for Nonlinear Programming" by Waechter and Biegler.

*    merit_function_type = AUTO;              *** [line_search_method != NONE] Let solver decide
*    merit_function_type = L1;                *** [line_search_method != NONE] phi(x) = f(x) + mu*||c(x)||1
*    merit_function_type = MODIFIED_L1;       *** [line_search_method != NONE] phi(x) = f(x) + sum{mu(j),|cj(x)|,j}
*    merit_function_type = MODIFIED_L1_INCR;  *** [line_search_method != NONE] Like MODIFIED_L1 except mu(j) are altered in order to take larger steps
     *** Determines the type of merit function used when the line search
     *** method uses a merit function.

*    l1_penalty_parameter_update = AUTO;      *** [merit_function_type == L1] let solver decide
*    l1_penalty_parameter_update = WITH_MULT; *** [merit_function_type == L1] Use Lagrange multipliers to update mu
*    l1_penalty_parameter_update = MULT_FREE; *** [merit_function_type == L1] Don't use Lagrange multipliers to update mu
     *** Determines how the penalty parameter is updated for the L1 merit function.
}

*********************************************************************
*** Options for serialization of the reduced Hessian
*** 
*** [NLPAlgoConfigMamaJama::hessian_initialization == SERIALIZE]
***
options_group ReducedHessianSerialization {

*   reduced_hessian_input_file_name = "reduced_hessian.in";   *** [default]
*   reduced_hessian_input_file_name = "";                     *** Does not read from file
    *** The name of a file that will be used to read in the reduced Hessian
    *** in a format that is compatible with the internal implementation.

*   reduced_hessian_output_file_name = "reduced_hessian.out"; *** [default]
*   reduced_hessian_output_file_name = "";                    *** Does not write to file
    *** The name of a file that will be used to write in the reduced Hessian.
    *** This reduced Hessian can then be read back in using the
    *** reduced_hessian_input_file_name option.

}

*********************************************************************
*** Options for finite difference initialization of reduced hessian.
*** 
*** [NLPAlgoConfigMamaJama::hessian_initialization == FINITE_DIFF_*]
***
options_group InitFinDiffReducedHessian {
*    initialization_method	= SCALE_IDENTITY;
*    initialization_method	= SCALE_DIAGONAL;
*    initialization_method	= SCALE_DIAGONAL_ABS;
*    max_cond			= 1e+1;
*    min_diag			= 1e-8;
*    step_scale			= 1e-1;
}

*********************************************************************
*** Options for checking for skipping the BFGS update.
***
*** [NLPAlgoConfigMamaJama::exact_hessian == false]
***
options_group CheckSkipBFGSUpdateStd {
*    skip_bfgs_prop_const = 10.0; *** (+dbl)
}

*********************************************************************
*** Options for BFGS updating (dense or limited memory)
*** 
*** [NLPAlgoConfigMamaJama::exact_hessian == false]
***
options_group BFGSUpdate {

*    rescale_init_identity = true;  *** [default]
*    rescale_init_identity = false;
     *** If true, then rescale the initial identity matrix at 2nd iteration

*    use_dampening = true;  *** [default]
*    use_dampening = false;
     *** Use dampened BFGS update

*    secant_testing          = DEFAULT;  *** Test secant condition if check_results==true (see above) [default]
*    secant_testing          = TEST;     *** Always test secant condition
*    secant_testing          = NO_TEST;  *** Never test secant condition

*    secant_warning_tol      = 1e-6; *** [default]
*    secant_error_tol        = 1e-1; *** [default]

}

*********************************************************************
*** Options for the convergence test.
***
*** See the printed step description (i.e. 'MoochoAlgo.out') for a
*** description of what these options do.
***
options_group CheckConvergenceStd {

*    scale_opt_error_by    = SCALE_BY_NORM_2_X;
*    scale_opt_error_by    = SCALE_BY_NORM_INF_X;
*    scale_opt_error_by    = SCALE_BY_ONE;        *** [default]

*    scale_feas_error_by   = SCALE_BY_NORM_2_X;
*    scale_feas_error_by   = SCALE_BY_NORM_INF_X;
*    scale_feas_error_by   = SCALE_BY_ONE;        *** [default]

*    scale_comp_error_by   = SCALE_BY_NORM_2_X;
*    scale_comp_error_by   = SCALE_BY_NORM_INF_X;
*    scale_comp_error_by   = SCALE_BY_ONE;        *** [default]

     *** Determines what all of the error measures are scaled by when checking convergence
     *** SCALE_BY_NORM_2_X   : Scale the optimality conditions by 1/(1+||x_k||2)
     *** SCALE_BY_NORM_INF_X : Scale the optimality conditions by 1/(1+||x_k||inf)
     *** SCALE_BY_ONE        : Scale the optimality conditions by 1

*    scale_opt_error_by_Gf = true; *** [default]
*    scale_opt_error_by_Gf = false;
     *** Determines if the linear dependence of gradients (i.e. ||rGL_k||inf or ||GL_k||inf)
     *** is scaled by the gradient of the objective function or not.
     *** true  : Scale ||rGL_k||inf or ||GL_k|| by an additional 1/(1+||Gf||inf)
     *** false : Scale ||rGL_k||inf or ||GL_k|| by an additional 1 (i.e. no extra scaling)

}

****************************************************************
*** Options for the primal-dual, active-set, schur-complement
*** QP solver QPSchur.
***
*** [NLPAlgoConfigMamaJama::qp_solver == QPSCHUR]
***
options_group QPSolverRelaxedQPSchur {

*** Convergence criteria and algorithm control options

*    max_qp_iter_frac  = 10.0;   *** (+dbl) max_qp_itr = max_qp_itr_frac * (# variables)

*    bounds_tol        = 1e-10;  *** (+dbl) feasibility tolerance for bound constraints

*    inequality_tol    = 1e-10;  *** (+dbl) feasibility tolerance for general inequality constraints

*    equality_tol      = 1e-10;  *** (+dbl) feasibility tolerance for general equality constraints

*    loose_feas_tol    = 1e-9;   *** (+dbl) (Expert use only)

*    dual_infeas_tol   = 1e-12;  *** (+dbl) allowable dual infeasibility before reporting an error

*    huge_primal_step  = 1e+20;  *** (+dbl) value of a near infinite primal step

*    huge_dual_step    = 1e+20;  *** (+dbl) value of a near infinite dual step

*    bigM              = 1e+10;  *** (+dbl) value or relaxation penalty in objective

*    iter_refine_at_solution = true;  *** [default]
*    iter_refine_at_solution = false;
     *** If true then iterative refinement will be performed at the solution of
     *** the QP in every case.

*    iter_refine_min_iter = 1; *** [default]
     *** Minimum number of iterative refinement iterations to perform when
     *** using iterative refinement.
     *** Example values:
     *** 0 : Don't perform any iterations of iterative refinement if you don't have to
     *** 1 : Perform at least one step if iterative refinement no matter what the
     ***     residual is.

*    iter_refine_max_iter = 3; *** [default]
     *** Maximum number of steps of iterative refinement to perform.
     *** This helps to keep down the cost of iterative refinement but
     *** can cause the QP method to fail due to ill-conditioning and roundoff.
     *** This number should be kept small since the target residuals may not
     *** be obtainable.
     *** Example values:
     ***   0 : Never perform any steps of iterative refinement
     ***   1 : Never perform more than one step of iterative refinement
     ***  10 : Never perform more than 10 steps of iterative refinement.

*    iter_refine_opt_tol  = 1e-12; *** [default]
     *** Iterative refinement convergence tolerance for the optimality
     *** conditions of the QP.  Specifically this is compared to the
     *** scaled linear dependence of gradients condition.
     *** Example values:
     ***   1e-50 : (very small number) Do iterative refinement until
     ***           iter_refine_max_iter is exceeded.
     ***   1e-12 : [default]
     ***   1e+50 : (very big number) Allow convergence of iterative refinement at
     ***           any time.

*    iter_refine_feas_tol = 1e-12; *** [default]
     *** Iterative refinement convergence tolerance for the feasibility
     *** conditions of the QP.  Specifically this is compared to the
     *** scaled residual of the active constraints (equalities and inequalities)
     *** Example values:
     ***   1e-50 : (very small number) Do iterative refinement until
     ***           iter_refine_max_iter is exceeded.
     ***   1e-12 : [default]
     ***   1e+50 : (very big number) Allow convergence of iterative refinement at
     ***           any time.

*    inequality_pick_policy = ADD_BOUNDS_THEN_MOST_VIOLATED_INEQUALITY; *** [default]
*    inequality_pick_policy = ADD_BOUNDS_THEN_FIRST_VIOLATED_INEQUALITY; *** not supported yet!
*    inequality_pick_policy = ADD_MOST_VIOLATED_BOUNDS_AND_INEQUALITY;

*** Warning and error tolerances

*    warning_tol   = 1e-10;  *** General testing warning tolerance

*    error_tol     = 1e-5;   *** General testing error tolerance

*    pivot_warning_tol = 1e-8;  *** [default]
     *** (+dbl) Minimum relative tolerance for a pivot element in the schur complement
     *** under which a warning message for near singularity will be printed
     *** (see MatrixSymAddDelUpdateable).
     ***  Example values:
     ***    0.0: Don't print any warning messages about near singularity.
     ***   1e-6: default
     ***    2.0: ( > 1 ) Show the pivot tolerance of every update!

*    pivot_singular_tol = 1e-11;  *** [default]
     *** (+dbl) Minimum relative tolerance for a pivot element in the schur complement
     *** under which the matrix is considered singular and an error message will be printed
     *** (see MatrixSymAddDelUpdateable).
     *** Example values:
     ***    0.0: Allow any numerically nonsingular matrix.
     ***   1e-8: default
     ***    2.0: ( > 1 ) Every matrix is singular (makes no sense!)

*    pivot_wrong_inertia_tol = 1e-11;  *** [default]
     *** (+dbl) Minimum relative tolerance for a pivot element in the schur complement
     *** over which the matrix is considered to have the wrong inertia rather than
     *** being singular and an error message will be printed
     *** (see MatrixSymAddDelUpdateable).
     *** Example values:
     ***    0.0: Any pivot with the wrong sign will be considered to have the wrong inertia
     ***   1e-8: default
     ***    2.0: ( > 1 ) Every matrix has the wrong inertia (makes no sense!)

*** Output control

*    print_level = USE_INPUT_ARG;  *** [default] Use the input argument to solve_qp(...)
*    print_level = NO_OUTPUT;
*    print_level = OUTPUT_BASIC_INFO;
*    print_level = OUTPUT_ITER_SUMMARY;
*    print_level = OUTPUT_ITER_STEPS;
*    print_level = OUTPUT_ACT_SET;
*    print_level = OUTPUT_ITER_QUANTITIES;
}

********************************************************************
*** Options for the direct line search object that is used in all the
*** line search methods for the SQP step.
***
*** [NLPAlgoConfigMamaJama::line_search_method != NONE]
***
*** See the MoochoAlgo.opt file for details.
***
options_group DirectLineSearchArmQuadSQPStep {
*    slope_frac       = 1.0e-4;
*    min_frac_step    = 0.1:
*    max_frac_step    = 0.5;
*    max_ls_iter      = 20;
}

*******************************************************************
*** Options for the watchdog line search.
*** 
*** [NLPAlgoConfigMamaJama::line_search_method = WATCHDOG]
***
*** Warning!  The watchdog option is not currently supported!
***
options_group LineSearchWatchDog {
*    opt_kkt_err_threshold	= 1e-3; *** (+dbl)
*    feas_kkt_err_threshold	= 1e-3; *** (+dbl)
     *** Start the watchdog linesearch when opt_kkt_err_k < opt_kkt_err_threshold and
     *** feas_kkt_err_k < feas_kkt_err_threshold
}

*******************************************************************
*** Options for the second order correction line search.
*** 
*** [NLPAlgoConfigMamaJama::line_search_method == 2ND_ORDER_CORRECT]
***
*** Warning!  The 2nd order correction option is not currently supported!
***
options_group LineSearch2ndOrderCorrect {

*    newton_olevel = PRINT_USE_DEFAULT;   *** O(?) output [default]
*    newton_olevel = PRINT_NOTHING;       *** No output
*    newton_olevel = PRINT_SUMMARY_INFO;  *** O(max_newton_iter) output
*    newton_olevel = PRINT_STEPS;         *** O(max_newton_iter) output
*    newton_olevel = PRINT_VECTORS;       *** O(max_newton_iter*n) output
     *** Determines the amount of output printed to the journal output stream.
     *** PRINT_USE_DEFAULT: Use the output level from the overall algorithm
     ***     to print comparable output (see journal_output_level).
     *** PRINT_NOTHING: Don't print anything (overrides default print level).
     *** PRINT_SUMMARY_INFO: Print a nice little summary table showing the sizes of the
     ***    newton steps used to compute a feasibility correction as well as what
     ***    progress is being made.
     *** PRINT_STEPS: Don't print a summary table and instead print some more detail
     ***    as to what computations are being performed etc.
     *** PRINT_VECTORS: Print out relevant vectors as well for the feasibility Newton
     ***     iterations.

*    constr_norm_threshold = 1.0; *** [default]
     *** (+dbl) Tolerance for ||c_k||inf below which a 2nd order correction step
     *** will be considered (see printed description).  Example values:
     ***    0.0: Never consider computing a correction.
     ***   1e-3: Consider a correction if and only if ||c_k||inf <= 1e-3
     ***  1e+50: (big number) Consider a correction regardless of ||c_k||inf.

*    constr_incr_ratio = 10.0; *** [default]
     *** (+dbl) Tolerance for ||c_kp1||inf/(1.0+||c_k||inf) below which a 2nd order
     *** correction step will be considered (see printed description).  Example values:
     ***   0.0: Consider computing a correction only if ||c_kp1||inf is zero.
     ***   10.0: Consider computing a correction if and only if
     ***        ||c_kp1||inf/(1.0+||c_k||inf) < 10.0.
     *** 1e+50: (big number) Consider a correction regardless how big ||c_kp1||inf is.

*    after_k_iter = 0; *** [default]
     *** (+int) Number of SQP iterations before a 2nd order correction will be considered
     *** (see printed description).  Example values:
     ***        0: Consider computing a correction right away at the first iteration.
     ***        2: Consider computing a correction when k >= 2.
     ***   999999: (big number) Never consider a 2nd order correction.

*    forced_constr_reduction = LESS_X_D;
*    forced_constr_reduction = LESS_X; *** [default]
     *** Determine the amount of reduction required for c(x_k+d+w).
     ***   LESS_X_D: phi(c(x_k+d+w)) < forced_reduct_ratio * phi(c(x_k+d)) is all that is required.
     ***             As long as a feasible step can be computed, only one newton
     ***             iteration should be required for this.
     ***   LESS_X:   phi(c(x_k+d+w)) < forced_reduct_ratio * phi(c(x_k)) is required.
     ***             In general, this may require several feasibility step calculations
     ***             and several newton iterations.  Of course the maximum number of
     ***             newton iterations may be exceeded before this is achieved.

*    forced_reduct_ratio = 1.0; *** [default]
     *** (+dbl) (< 1) Fraction of reduction in phi(c(x)) for required reduction.
     *** Example values:
     ***    0.0: The constraints must be fully converged and newton iterations will
     ***         performed until max_newton_itr is exceeded.
     ***    0.5: Require an extra 50% of the required reduction.
     ***    1.0: Don't require any extra reduction.

*    max_step_ratio = 1.0; *** [default]
     *** (+dbl) Maximum ratio of ||w^p||inf/||d||inf allowed for correction step w^p before
     *** a line search along phi(c(x_k+d+b*w^p)) is performed.  The purpose of this parameter
     *** is to limit the number of line search iterations needed for each feasibility
     *** step and to keep the full w = sum(w^p,p=1...) from getting too big. Example values:
     ***    0.0: Don't allow any correction step.
     ***    0.1: Allow ||w^p||inf/||d||inf <= 0.1.
     ***    1.0: Allow ||w^p||inf/||d||inf <= 1.0.
     ***  1e+50: (big number) Allow ||w^p||inf/||d||inf to be a big as possible.

*    max_newton_iter = 3; *** [default]
     *** (+int) Limit the number of newton feasibility iterations (with line searches)
     *** allowed.  Example values:
     ***       0: Don't allow any newton iterations (no 2nd order correction).
     ***       3: Allow 3 newton iterations
     ***  999999: Allow any number of newton iterations (not a good idea)

}

*******************************************************************
*** Options for the filter search.
*** 
*** [NLPAlgoConfigMamaJama::line_search_method = FILTER]
***
*** See the MoochoAlgo.out file for details
***
options_group LineSearchFilter {
*    gamma_theta      = 1e-5; *** [default]
*    gamma_f          = 1e-5; *** [default]
*    f_min            = UNBOUNDED; *** [default]
*    f_min            = 0.0;       *** If 0 is minimum ...
*    gamma_alpha      = 5e-2; *** [default]
*    delta            = 1e-4; *** [default]
*    s_theta          = 1.1;  *** [default]
*    s_f              = 2.3;	*** [default]
*    theta_small_fact = 1e-4; *** [default]
*    theta_max        = 1e10; *** [default]
*    eta_f            = 1e-4; *** [default]
*    back_track_frac  = 0.5;  *** [default]
}

*******************************************************************
*** Options for generating feasibility steps for reduced space.
*** 
*** [NLPAlgoConfigMamaJama::line_search_method == 2ND_ORDER_CORRECT]
***
*** Warning!  The 2nd order correction option is not currently supported!
***
options_group FeasibilityStepReducedStd {
*    qp_objective = OBJ_MIN_FULL_STEP;
*    qp_objective = OBJ_MIN_NULL_SPACE_STEP;
*    qp_objective = OBJ_RSQP;
*    qp_testing   = QP_TEST_DEFAULT;
*    qp_testing   = QP_TEST;
*    qp_testing   = QP_NO_TEST;
}

******************************************************************
*** Options for the direct line search object for
*** the newton steps of the 2nd order correction (see above).
*** 
*** [NLPAlgoConfigMamaJama::line_search_method == 2ND_ORDER_CORRECT]
***
*** Warning!  The 2nd order correction option is not currently supported!
***
options_group DirectLineSearchArmQuad2ndOrderCorrectNewton {
*    slope_frac       = 1.0e-4;
*    min_frac_step    = 0.1:
*    max_frac_step    = 0.5;
*    max_ls_iter      = 20;
}

******************************************************************
*** Change how the penalty parameters for the merit function
*** are adjusted.
*** 
*** [NLPAlgoConfigMamaJama::line_search_method != NONE]
***
options_group MeritFuncPenaltyParamUpdate {
*    small_mu     = 1e-6;
*    min_mu_ratio = 1e-8
*    mult_factor  = 7.5e-4;
*    kkt_near_sol = 1e-1;
}

*****************************************************************
*** Change how the penalty parameters for the modified
*** L1 merit function are increased.
***
*** [NLPAlgoConfigMamaJama::line_search_method != NONE]
*** [NLPAlgoConfigMamaJama::merit_function_type == MODIFIED_L1_INCR]
***
options_group MeritFuncModifiedL1LargerSteps {

*    after_k_iter                  = 3;
     *** (+int) Number of SQP iterations before considering increasing penalties.
     *** Set to 0 to start at the first iteration.

*    obj_increase_threshold        = 1e-4;
     *** (+-dbl) Consider increasing penalty parameters when the relative
     *** increase in the objective function is greater than this value.
     *** Set to a very large negative number (i.e. -1e+100) to always
     *** allow increasing the penalty parameters.

*    max_pos_penalty_increase      = 1.0;
     *** (+dbl) Ratio the multipliers are allowed to be increased.
     *** Set to a very large number (1e+100) to allow increasing the penalties
     *** to any value if it will help in taking a larger step.  This will
     *** in effect put all of the weight of the constraints and will force
     *** the algorithm to only minimize the infeasibility and ignore
     *** optimality.

*    pos_to_neg_penalty_increase   = 1.0;  *** (+dbl)

*    incr_mult_factor              = 1e-4; *** (+dbl)

}

*** End Moocho.opt.NLPAlgoConfigMamaJama

end_options

Generated on Wed May 12 21:51:20 2010 for MoochoPack : Framework for Large-Scale Optimization Algorithms by  doxygen 1.4.7