MoochoPack : Framework for LargeScale Optimization Algorithms Version of the Day

The following is the contents of the file Moocho.opt.MoochoSolver
which are options specific to the class MoochoPack::MoochoSolver
. For options specific to the NLPAlgoConfigMamaJama
configuration class see the documentation for MoochoPack::NLPAlgoConfigMamaJama
.
*** 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: *** 1e8 : 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 reducedspace SQP configuration *** interior_point : configuration for a simple reducedspace 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 = 1e6; *** [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. *** 1e6 : 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 = 1e6; *** [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. *** 1e6 : 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 = 1e2; *** [default] *** (+dbl) Convergence tolerance for (scaled) step size x_k(+1)x_kinf. *** 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. *** 1e2 : 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*(nm)) output to journal (lots!) * null_space_journal_output_level = PRINT_ITERATION_QUANTITIES; * O(iter*(nm)^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 quasirange 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 = 1e14; *** [default] * error_tol = 1e10; *** [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 fortrancompatible 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 fillin? *** 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 fillin. 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