bool PDFullSpaceSolver::InitializeImpl(const OptionsList& options, const std::string& prefix) { // Check for the algorithm options options.GetIntegerValue("min_refinement_steps", min_refinement_steps_, prefix); options.GetIntegerValue("max_refinement_steps", max_refinement_steps_, prefix); ASSERT_EXCEPTION(max_refinement_steps_ >= min_refinement_steps_, OPTION_INVALID, "Option \"max_refinement_steps\": This value must be larger than or equal to min_refinement_steps (default 1)"); options.GetNumericValue("residual_ratio_max", residual_ratio_max_, prefix); options.GetNumericValue("residual_ratio_singular", residual_ratio_singular_, prefix); ASSERT_EXCEPTION(residual_ratio_singular_ >= residual_ratio_max_, OPTION_INVALID, "Option \"residual_ratio_singular\": This value must be not smaller than residual_ratio_max."); options.GetNumericValue("residual_improvement_factor", residual_improvement_factor_, prefix); options.GetNumericValue("neg_curv_test_tol", neg_curv_test_tol_, prefix); // Reset internal flags and data augsys_improved_ = false; if (!augSysSolver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix)) { return false; } return perturbHandler_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); }
bool IpoptData::Initialize(const Journalist& jnlst, const OptionsList& options, const std::string& prefix) { if (prefix=="resto.") { // The default for the restoration phase is 1e-2 time the value // for the regular algorithm if (!options.GetNumericValue("resto.tol", tol_, "")) { options.GetNumericValue("tol", tol_, prefix); tol_ *= 1e-2; } } else { options.GetNumericValue("tol", tol_, prefix); } iter_count_ = 0; curr_mu_ = -1.; mu_initialized_ = false; curr_tau_ = -1.; tau_initialized_ = false; have_prototypes_ = false; have_deltas_ = false; have_affine_deltas_ = false; free_mu_mode_ = false; tiny_step_flag_ = false; ResetInfo(); initialize_called_ = true; return cgpen_data_->Initialize(jnlst, options, prefix); }
bool InexactSearchDirCalculator::InitializeImpl( const OptionsList& options, const std::string& prefix ) { options.GetNumericValue("local_inf_Ac_tol", local_inf_Ac_tol_, prefix); Index enum_int; options.GetEnumValue("inexact_step_decomposition", enum_int, prefix); decomposition_type_ = DecompositionTypeEnum(enum_int); bool compute_normal = false; switch( decomposition_type_ ) { case ALWAYS: compute_normal = true; break; case ADAPTIVE: case SWITCH_ONCE: compute_normal = false; break; } InexData().set_compute_normal(compute_normal); InexData().set_next_compute_normal(compute_normal); bool retval = inexact_pd_solver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); if( !retval ) { return false; } return normal_step_calculator_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); }
void AgentConfiguration::initialize(int aArgc, const char *aArgv[]) { MTConnectService::initialize(aArgc, aArgv); const char *configFile = "agent.cfg"; OptionsList optionList; optionList.append(new Option(0, configFile, "The configuration file", "file", false)); optionList.parse(aArgc, (const char**) aArgv); mConfigFile = configFile; try { configureLogger(); ifstream file(mConfigFile.c_str()); loadConfig(file); } catch (std::exception & e) { sLogger << LFATAL << "Agent failed to load: " << e.what(); cerr << "Agent failed to load: " << e.what() << std::endl; optionList.usage(); } }
SmartPtr<AugSystemSolver> AlgorithmBuilder::AugSystemSolverFactory( const Journalist& jnlst, const OptionsList& options, const std::string& prefix ) { SmartPtr<AugSystemSolver> AugSolver; std::string linear_solver; options.GetStringValue("linear_solver", linear_solver, prefix); if( linear_solver == "custom" ) { ASSERT_EXCEPTION(IsValid(custom_solver_), OPTION_INVALID, "Selected linear solver CUSTOM not available."); AugSolver = custom_solver_; } else { AugSolver = new StdAugSystemSolver(*GetSymLinearSolver(jnlst, options, prefix)); } Index enum_int; options.GetEnumValue("hessian_approximation", enum_int, prefix); HessianApproximationType hessian_approximation = HessianApproximationType(enum_int); if( hessian_approximation == LIMITED_MEMORY ) { std::string lm_aug_solver; options.GetStringValue("limited_memory_aug_solver", lm_aug_solver, prefix); if( lm_aug_solver == "sherman-morrison" ) { AugSolver = new LowRankAugSystemSolver(*AugSolver); } else if( lm_aug_solver == "extended" ) { Index lm_history; options.GetIntegerValue("limited_memory_max_history", lm_history, prefix); Index max_rank; std::string lm_type; options.GetStringValue("limited_memory_update_type", lm_type, prefix); if( lm_type == "bfgs" ) { max_rank = 2 * lm_history; } else if( lm_type == "sr1" ) { max_rank = lm_history; } else { THROW_EXCEPTION(OPTION_INVALID, "Unknown value for option \"limited_memory_update_type\"."); } AugSolver = new LowRankSSAugSystemSolver(*AugSolver, max_rank); } else { THROW_EXCEPTION(OPTION_INVALID, "Unknown value for option \"limited_memory_aug_solver\"."); } } return AugSolver; }
bool PDSearchDirCalculator::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("fast_step_computation", fast_step_computation_, prefix); options.GetBoolValue("mehrotra_algorithm", mehrotra_algorithm_, prefix); return pd_solver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); }
bool StdStepCalculator::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("sens_bound_eps", bound_eps_, prefix); options.GetBoolValue("sens_kkt_residuals", kkt_residuals_, prefix); SensitivityStepCalculator::InitializeImpl(options, prefix); return true; }
bool IpoptData::Initialize(const Journalist& jnlst, const OptionsList& options, const std::string& prefix) { #if 0 // I (AW) took the following heuristic out again, since it seemed // that the restoration phase tolerance became too tight by // default. I originally probably put it in to avoid that a claim // of infeasibility is made prematurely... let's see if someone // starts screaming... if (prefix=="resto.") { // The default for the restoration phase is 1e-2 time the value // for the regular algorithm if (!options.GetNumericValue("resto.tol", tol_, "")) { options.GetNumericValue("tol", tol_, prefix); tol_ *= 1e-2; } } else { options.GetNumericValue("tol", tol_, prefix); } #else options.GetNumericValue("tol", tol_, prefix); #endif iter_count_ = 0; curr_mu_ = -1.; mu_initialized_ = false; curr_tau_ = -1.; tau_initialized_ = false; have_prototypes_ = false; have_deltas_ = false; have_affine_deltas_ = false; free_mu_mode_ = false; tiny_step_flag_ = false; info_ls_count_ = 0; ResetInfo(); info_last_output_ = -1.; info_iters_since_header_ = 1000; // need to be larger 10 initialize_called_ = true; if (cpu_time_start_==-1.) { cpu_time_start_ = CpuTime(); } bool retval = true; if (IsValid(add_data_)) { retval = add_data_->Initialize(jnlst, options, prefix); } return retval; }
bool OrigIterationOutput::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("print_info_string", print_info_string_, prefix); Index enum_int; options.GetEnumValue("inf_pr_output", enum_int, prefix); inf_pr_output_ = InfPrOutput(enum_int); return true; }
void parseThreadSpecificOptions(OptionsList& threadOptions, const Options& opts) { unsigned numThreads = opts.getThreads(); for(unsigned i = 0; i < numThreads; ++i) { threadOptions.push_back_copy(opts); Options& tOpts = threadOptions.back(); // Set thread identifier tOpts.setThreadId(i); const std::vector<std::string>& optThreadArgvs = opts.getThreadArgv(); if(i < optThreadArgvs.size() && (! optThreadArgvs[i].empty())) { // separate out the thread's individual configuration string stringstream optidss; optidss << "--thread" << i; string optid = optidss.str(); int targc = 1; char* tbuf = strdup(optThreadArgvs[i].c_str()); char* p = tbuf; // string length is certainly an upper bound on size needed char** targv = new char*[optThreadArgvs[i].size()]; char** vp = targv; *vp++ = strdup(optid.c_str()); p = strtok(p, " "); while(p != NULL) { *vp++ = p; ++targc; p = strtok(NULL, " "); } *vp++ = NULL; if(targc > 1) { // this is necessary in case you do e.g. --thread0=" " try { Options::parseOptions(&tOpts, targc, targv); } catch(OptionException& e) { stringstream ss; ss << optid << ": " << e.getMessage(); throw OptionException(ss.str()); } if(tOpts.getThreads() != numThreads || tOpts.getThreadArgv() != opts.getThreadArgv()) { stringstream ss; ss << "not allowed to set thread options in " << optid << " !"; throw OptionException(ss.str()); } } free(targv[0]); delete [] targv; free(tbuf); } } assert(numThreads >= 1); //do we need this? }
void AlgorithmBuilder::BuildIpoptObjects( const Journalist& jnlst, const OptionsList& options, const std::string& prefix, const SmartPtr<NLP>& nlp, SmartPtr<IpoptNLP>& ip_nlp, SmartPtr<IpoptData>& ip_data, SmartPtr<IpoptCalculatedQuantities>& ip_cq ) { DBG_ASSERT(prefix == ""); SmartPtr<NLPScalingObject> nlp_scaling; std::string nlp_scaling_method; options.GetStringValue("nlp_scaling_method", nlp_scaling_method, ""); if( nlp_scaling_method == "user-scaling" ) { nlp_scaling = new UserScaling(ConstPtr(nlp)); } else if( nlp_scaling_method == "gradient-based" ) { nlp_scaling = new GradientScaling(nlp); } else if( nlp_scaling_method == "equilibration-based" ) { nlp_scaling = new EquilibrationScaling(nlp); } else { nlp_scaling = new NoNLPScalingObject(); } ip_nlp = new OrigIpoptNLP(&jnlst, GetRawPtr(nlp), nlp_scaling); // Create the IpoptData. Check if there is additional data that // is needed std::string lsmethod; SmartPtr<IpoptAdditionalData> add_data; options.GetStringValue("line_search_method", lsmethod, prefix); if( lsmethod == "cg-penalty" ) { add_data = new CGPenaltyData(); } ip_data = new IpoptData(add_data); // Create the IpoptCalculators. Check if there are additional // calculated quantities that are needed ip_cq = new IpoptCalculatedQuantities(ip_nlp, ip_data); if( lsmethod == "cg-penalty" ) { SmartPtr<IpoptAdditionalCq> add_cq = new CGPenaltyCq(GetRawPtr(ip_nlp), GetRawPtr(ip_data), GetRawPtr(ip_cq)); ip_cq->SetAddCq(add_cq); } }
bool GradientScaling::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("nlp_scaling_max_gradient", scaling_max_gradient_, prefix); options.GetNumericValue("nlp_scaling_obj_target_gradient", scaling_obj_target_gradient_, prefix); options.GetNumericValue("nlp_scaling_constr_target_gradient", scaling_constr_target_gradient_, prefix); options.GetNumericValue("nlp_scaling_min_value", scaling_min_value_, prefix); return StandardScalingBase::InitializeImpl(options, prefix); }
bool Ma86SolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { ma86_default_control(&control_); control_.f_arrays = 1; // Use Fortran numbering (faster) /* Note: we can't set control_.action = false as we need to know the * intertia. (Otherwise we just enter the restoration phase and fail) */ options.GetIntegerValue("ma86_print_level", control_.diagnostics_level, prefix); options.GetIntegerValue("ma86_nemin", control_.nemin, prefix); options.GetNumericValue("ma86_small", control_.small_, prefix); options.GetNumericValue("ma86_static", control_.static_, prefix); options.GetNumericValue("ma86_u", control_.u, prefix); options.GetNumericValue("ma86_umax", umax_, prefix); std::string order_method, scaling_method; options.GetStringValue("ma86_order", order_method, prefix); if(order_method == "metis") { ordering_ = ORDER_METIS; } else if(order_method == "amd") { ordering_ = ORDER_AMD; } else { ordering_ = ORDER_AUTO; } options.GetStringValue("ma86_scaling", scaling_method, prefix); if(scaling_method == "mc64") { control_.scaling = 1; } else if(scaling_method == "mc77") { control_.scaling = 2; } else { control_.scaling = 0; } return true; // All is well }
bool RestoConvergenceCheck::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("required_infeasibility_reduction", kappa_resto_, prefix); options.GetIntegerValue("max_iter", maximum_iters_, prefix); options.GetIntegerValue("max_resto_iter", maximum_resto_iters_, prefix); // The original constraint violation tolerance options.GetNumericValue("constr_viol_tol", orig_constr_viol_tol_, ""); first_resto_iter_ = true; successive_resto_iter_ = 0; return OptimalityErrorConvergenceCheck::InitializeImpl(options, prefix); }
bool RestoIpoptNLP::Initialize( const Journalist& jnlst, const OptionsList& options, const std::string& prefix ) { options.GetBoolValue("evaluate_orig_obj_at_resto_trial", evaluate_orig_obj_at_resto_trial_, prefix); options.GetNumericValue("resto_penalty_parameter", rho_, prefix); Index enum_int; options.GetEnumValue("hessian_approximation", enum_int, prefix); hessian_approximation_ = HessianApproximationType(enum_int); options.GetNumericValue("resto_proximity_weight", eta_factor_, prefix); initialized_ = true; return IpoptNLP::Initialize(jnlst, options, prefix); }
bool OrigIterationOutput::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("print_info_string", print_info_string_, prefix); return true; }
bool RestoIterationOutput::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetBoolValue("print_info_string", print_info_string_, prefix); Index enum_int; options.GetEnumValue("inf_pr_output", enum_int, prefix); inf_pr_output_ = InfPrOutput(enum_int); bool retval = true; if (IsValid(resto_orig_iteration_output_)) { retval = resto_orig_iteration_output_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); } return retval; }
bool StandardScalingBase::InitializeImpl( const OptionsList& options, const std::string& prefix ) { options.GetNumericValue("obj_scaling_factor", obj_scaling_factor_, prefix); return true; }
bool EquilibrationScaling:: InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("point_perturbation_radius", point_perturbation_radius_, prefix); return StandardScalingBase::InitializeImpl(options, prefix); }
DateFormatPtr DatePatternConverter::getDateFormat(const OptionsList& options) { DateFormatPtr df; int maximumCacheValidity = 1000000; if (options.size() == 0) { df = new ISO8601DateFormat(); } else { LogString dateFormatStr(options[0]); if(dateFormatStr.empty() || StringHelper::equalsIgnoreCase(dateFormatStr, LOG4CXX_STR("ISO8601"), LOG4CXX_STR("iso8601"))) { df = new ISO8601DateFormat(); } else if(StringHelper::equalsIgnoreCase(dateFormatStr, LOG4CXX_STR("ABSOLUTE"), LOG4CXX_STR("absolute"))) { df = new AbsoluteTimeDateFormat(); } else if(StringHelper::equalsIgnoreCase(dateFormatStr, LOG4CXX_STR("DATE"), LOG4CXX_STR("date"))) { df = new DateTimeDateFormat(); } else { if (dateFormatStr.find(0x25 /*'%'*/) == std::string::npos) { try { df = new SimpleDateFormat(dateFormatStr); maximumCacheValidity = CachedDateFormat::getMaximumCacheValidity(dateFormatStr); } catch(IllegalArgumentException& e) { df = new ISO8601DateFormat(); LogLog::warn(((LogString) LOG4CXX_STR("Could not instantiate SimpleDateFormat with pattern ")) + dateFormatStr, e); } } else { df = new StrftimeDateFormat(dateFormatStr); } } if (options.size() >= 2) { TimeZonePtr tz(TimeZone::getTimeZone(options[1])); if (tz != NULL) { df->setTimeZone(tz); } } } if (maximumCacheValidity > 0) { df = new CachedDateFormat(df, maximumCacheValidity); } return df; }
bool MonotoneMuUpdate::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("mu_init", mu_init_, prefix); options.GetNumericValue("barrier_tol_factor", barrier_tol_factor_, prefix); options.GetNumericValue("mu_linear_decrease_factor", mu_linear_decrease_factor_, prefix); options.GetNumericValue("mu_superlinear_decrease_power", mu_superlinear_decrease_power_, prefix); options.GetBoolValue("mu_allow_fast_monotone_decrease", mu_allow_fast_monotone_decrease_, prefix); options.GetNumericValue("tau_min", tau_min_, prefix); options.GetNumericValue("compl_inf_tol", compl_inf_tol_, prefix); IpData().Set_mu(mu_init_); Number tau = Max(tau_min_, 1.0 - mu_init_); IpData().Set_tau(tau); initialized_ = false; //TODO we need to clean up the mu-update for the restoration phase if (prefix=="resto.") { first_iter_resto_ = true; } else { first_iter_resto_ = false; } return true; }
bool OptimalityErrorConvergenceCheck::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetIntegerValue("max_iter", max_iterations_, prefix); options.GetNumericValue("dual_inf_tol", dual_inf_tol_, prefix); options.GetNumericValue("constr_viol_tol", constr_viol_tol_, prefix); options.GetNumericValue("compl_inf_tol", compl_inf_tol_, prefix); options.GetIntegerValue("acceptable_iter", acceptable_iter_, prefix); options.GetNumericValue("acceptable_tol", acceptable_tol_, prefix); options.GetNumericValue("acceptable_dual_inf_tol", acceptable_dual_inf_tol_, prefix); options.GetNumericValue("acceptable_constr_viol_tol", acceptable_constr_viol_tol_, prefix); options.GetNumericValue("acceptable_compl_inf_tol", acceptable_compl_inf_tol_, prefix); options.GetNumericValue("diverging_iterates_tol", diverging_iterates_tol_, prefix); acceptable_counter_ = 0; return true; }
bool ProbingMuOracle::InitializeImpl( const OptionsList& options, const std::string& prefix ) { options.GetNumericValue("sigma_max", sigma_max_, prefix); return true; }
void ServerProxy::setOptions() { // parse OptionsList options; ProtocolUtil::readf(m_stream, kMsgDSetOptions + 4, &options); LOG((CLOG_DEBUG1 "recv set options size=%d", options.size())); // forward m_client->setOptions(options); // update modifier table for (UInt32 i = 0, n = (UInt32)options.size(); i < n; i += 2) { KeyModifierID id = kKeyModifierIDNull; if (options[i] == kOptionModifierMapForShift) { id = kKeyModifierIDShift; } else if (options[i] == kOptionModifierMapForControl) { id = kKeyModifierIDControl; } else if (options[i] == kOptionModifierMapForAlt) { id = kKeyModifierIDAlt; } else if (options[i] == kOptionModifierMapForAltGr) { id = kKeyModifierIDAltGr; } else if (options[i] == kOptionModifierMapForMeta) { id = kKeyModifierIDMeta; } else if (options[i] == kOptionModifierMapForSuper) { id = kKeyModifierIDSuper; } else if (options[i] == kOptionHeartbeat) { // update keep alive setKeepAliveRate(1.0e-3 * static_cast<double>(options[i + 1])); } if (id != kKeyModifierIDNull) { m_modifierTranslationTable[id] = static_cast<KeyModifierID>(options[i + 1]); LOG((CLOG_DEBUG1 "modifier %d mapped to %d", id, m_modifierTranslationTable[id])); } } }
void ClientProxy1_0::setOptions(const OptionsList& options) { LOG((CLOG_DEBUG1 "send set options to \"%s\" size=%d", getName().c_str(), options.size())); ProtocolUtil::writef(getStream(), kMsgDSetOptions, &options); // check options for (UInt32 i = 0, n = (UInt32)options.size(); i < n; i += 2) { if (options[i] == kOptionHeartbeat) { double rate = 1.0e-3 * static_cast<double>(options[i + 1]); if (rate <= 0.0) { rate = -1.0; } setHeartbeatRate(rate, rate * kHeartBeatsUntilDeath); removeHeartbeatTimer(); addHeartbeatTimer(); } } }
void Screen::setOptions(const OptionsList& options) { // update options bool oldScreenSaverSync = m_screenSaverSync; for (UInt32 i = 0, n = (UInt32)options.size(); i < n; i += 2) { if (options[i] == kOptionScreenSaverSync) { m_screenSaverSync = (options[i + 1] != 0); LOG((CLOG_DEBUG1 "screen saver synchronization %s", m_screenSaverSync ? "on" : "off")); } else if (options[i] == kOptionHalfDuplexCapsLock) { if (options[i + 1] != 0) { m_halfDuplex |= KeyModifierCapsLock; } else { m_halfDuplex &= ~KeyModifierCapsLock; } LOG((CLOG_DEBUG1 "half-duplex caps-lock %s", ((m_halfDuplex & KeyModifierCapsLock) != 0) ? "on" : "off")); } else if (options[i] == kOptionHalfDuplexNumLock) { if (options[i + 1] != 0) { m_halfDuplex |= KeyModifierNumLock; } else { m_halfDuplex &= ~KeyModifierNumLock; } LOG((CLOG_DEBUG1 "half-duplex num-lock %s", ((m_halfDuplex & KeyModifierNumLock) != 0) ? "on" : "off")); } else if (options[i] == kOptionHalfDuplexScrollLock) { if (options[i + 1] != 0) { m_halfDuplex |= KeyModifierScrollLock; } else { m_halfDuplex &= ~KeyModifierScrollLock; } LOG((CLOG_DEBUG1 "half-duplex scroll-lock %s", ((m_halfDuplex & KeyModifierScrollLock) != 0) ? "on" : "off")); } } // update half-duplex options m_screen->setHalfDuplexMask(m_halfDuplex); // update screen saver synchronization if (!m_isPrimary && oldScreenSaverSync != m_screenSaverSync) { if (m_screenSaverSync) { m_screen->openScreensaver(false); } else { m_screen->closeScreensaver(); } } // let screen handle its own options m_screen->setOptions(options); }
bool Ma27TSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("ma27_pivtol", pivtol_, prefix); if (options.GetNumericValue("ma27_pivtolmax", pivtolmax_, prefix)) { ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID, "Option \"ma27_pivtolmax\": This value must be between " "ma27_pivtol and 1."); } else { pivtolmax_ = Max(pivtolmax_, pivtol_); } options.GetNumericValue("ma27_liw_init_factor", liw_init_factor_, prefix); options.GetNumericValue("ma27_la_init_factor", la_init_factor_, prefix); options.GetNumericValue("ma27_meminc_factor", meminc_factor_, prefix); options.GetBoolValue("ma27_skip_inertia_check", skip_inertia_check_, prefix); options.GetBoolValue("ma27_ignore_singularity", ignore_singularity_, prefix); // The following option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); /* Set the default options for MA27 */ F77_FUNC(ma27id,MA27ID)(icntl_, cntl_); #if COIN_IPOPT_VERBOSITY == 0 icntl_[0] = 0; // Suppress error messages icntl_[1] = 0; // Suppress diagnostic messages #endif // Reset all private data initialized_=false; pivtol_changed_ = false; refactorize_ = false; la_increase_=false; liw_increase_=false; if (!warm_start_same_structure_) { dim_=0; nonzeros_=0; } else { ASSERT_EXCEPTION(dim_>0 && nonzeros_>0, INVALID_WARMSTART, "Ma27TSolverInterface called with warm_start_same_structure, but the problem is solved for the first time."); } return true; }
bool PDPerturbationHandler::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("max_hessian_perturbation", delta_xs_max_, prefix); options.GetNumericValue("min_hessian_perturbation", delta_xs_min_, prefix); options.GetNumericValue("perturb_inc_fact_first", delta_xs_first_inc_fact_, prefix); options.GetNumericValue("perturb_inc_fact", delta_xs_inc_fact_, prefix); options.GetNumericValue("perturb_dec_fact", delta_xs_dec_fact_, prefix); options.GetNumericValue("first_hessian_perturbation", delta_xs_init_, prefix); options.GetNumericValue("jacobian_regularization_value", delta_cd_val_, prefix); options.GetNumericValue("jacobian_regularization_exponent", delta_cd_exp_, prefix); hess_degenerate_ = NOT_YET_DETERMINED; jac_degenerate_ = NOT_YET_DETERMINED; degen_iters_ = 0; delta_x_curr_ = 0.; delta_s_curr_ = 0.; delta_c_curr_ = 0.; delta_d_curr_ = 0.; delta_x_last_ = 0.; delta_s_last_ = 0.; delta_c_last_ = 0.; delta_d_last_ = 0.; test_status_ = NO_TEST; return true; }
bool MinC_1NrmRestorationPhase::InitializeImpl(const OptionsList& options, const std::string& prefix) { // keep a copy of these options to use when setting up the // restoration phase resto_options_ = new OptionsList(options); options.GetNumericValue("constr_mult_reset_threshold", constr_mult_reset_threshold_, prefix); options.GetNumericValue("bound_mult_reset_threshold", bound_mult_reset_threshold_, prefix); options.GetBoolValue("expect_infeasible_problem", expect_infeasible_problem_, prefix); // Avoid that the restoration phase is trigged by user option in // first iteration of the restoration phase resto_options_->SetStringValue("resto.start_with_resto", "no"); // We want the default for the theta_max_fact in the restoration // phase higher than for the regular phase Number theta_max_fact; if (!options.GetNumericValue("resto.theta_max_fact", theta_max_fact, "")) { resto_options_->SetNumericValue("resto.theta_max_fact", 1e8); } count_restorations_ = 0; bool retvalue = true; if (IsValid(eq_mult_calculator_)) { retvalue = eq_mult_calculator_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix); } return retvalue; }
bool MumpsSolverInterface::InitializeImpl(const OptionsList& options, const std::string& prefix) { options.GetNumericValue("mumps_pivtol", pivtol_, prefix); if (options.GetNumericValue("mumps_pivtolmax", pivtolmax_, prefix)) { ASSERT_EXCEPTION(pivtolmax_>=pivtol_, OPTION_INVALID, "Option \"mumps_pivtolmax\": This value must be between " "mumps_pivtol and 1."); } else { pivtolmax_ = Max(pivtolmax_, pivtol_); } options.GetIntegerValue("mumps_mem_percent", mem_percent_, prefix); // The following option is registered by OrigIpoptNLP options.GetBoolValue("warm_start_same_structure", warm_start_same_structure_, prefix); options.GetIntegerValue("mumps_permuting_scaling", mumps_permuting_scaling_, prefix); options.GetIntegerValue("mumps_pivot_order", mumps_pivot_order_, prefix); options.GetIntegerValue("mumps_scaling", mumps_scaling_, prefix); options.GetNumericValue("mumps_dep_tol", mumps_dep_tol_, prefix); // Reset all private data initialized_ = false; pivtol_changed_ = false; refactorize_ = false; have_symbolic_factorization_ = false; DMUMPS_STRUC_C* mumps_ = (DMUMPS_STRUC_C*)mumps_ptr_; if (!warm_start_same_structure_) { mumps_->n = 0; mumps_->nz = 0; } else { ASSERT_EXCEPTION(mumps_->n>0 && mumps_->nz>0, INVALID_WARMSTART, "MumpsSolverInterface called with warm_start_same_structure, but the problem is solved for the first time."); } return true; }