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;
}
