/** Method to easily access Inexact calculated quantities */
InexactCq& InexCq()
{
InexactCq& inexact_cq =
static_cast<InexactCq&>(IpCq().AdditionalCq());
DBG_ASSERT(dynamic_cast<InexactCq*>(&IpCq().AdditionalCq()));
return inexact_cq;
}
void InexactLSAcceptor::ResetSlacks()
{
DBG_START_METH("InexactLSAcceptor::ResetSlacks",
dbg_verbosity);
DBG_PRINT_VECTOR(1, "sorig", *IpData().trial()->s());
DBG_PRINT_VECTOR(1, "dtrial", *IpCq().trial_d());
SmartPtr<Vector> new_s = IpData().trial()->s()->MakeNew();
SmartPtr<Vector> tmp_d = IpNLP().d_L()->MakeNew();
IpNLP().Pd_L()->TransMultVector(1., *IpCq().trial_d(), 0., *tmp_d);
SmartPtr<Vector> tmp_s = IpNLP().d_L()->MakeNew();
IpNLP().Pd_L()->TransMultVector(1., *IpData().trial()->s(), 0., *tmp_s);
tmp_s->ElementWiseMax(*tmp_d);
IpNLP().Pd_L()->MultVector(1., *tmp_s, 0., *new_s);
tmp_d = IpNLP().d_U()->MakeNew();
IpNLP().Pd_U()->TransMultVector(1., *IpCq().trial_d(), 0., *tmp_d);
tmp_s = IpNLP().d_U()->MakeNew();
IpNLP().Pd_U()->TransMultVector(1., *IpData().trial()->s(), 0., *tmp_s);
tmp_s->ElementWiseMin(*tmp_d);
IpNLP().Pd_U()->MultVector(1., *tmp_s, 1., *new_s);
SmartPtr<IteratesVector> trial = IpData().trial()->MakeNewContainer();
trial->Set_s(*new_s);
IpData().set_trial(trial);
DBG_PRINT_VECTOR(1, "new_s", *IpData().trial()->s());
}
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);
}
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 CGPenaltyLSAcceptor::MultipliersDiverged()
{
DBG_START_METH("CGPenaltyLSAcceptor::MultipliersDiverged",
dbg_verbosity);
bool diverged = false;
Number curr_inf = IpCq().curr_primal_infeasibility(NORM_2);
Number trial_inf = IpCq().trial_primal_infeasibility(NORM_2);
if (curr_inf > mult_diverg_feasibility_tol_
&& trial_inf > mult_diverg_feasibility_tol_
&& IpCq().curr_dual_infeasibility(NORM_MAX) > 1e4) {
Number y_ref_big_step = mult_diverg_y_tol_;
Number y_ref_tiny_step = 1e4;
Number alpha_ref = 1e-4;
/*
if (IpCq().trial_grad_f()->Amax() < IpData().tol()){
y_ref_big_step *= 1e4;
y_ref_tiny_step *= 1e4;
}
*/
Number y_Amax = CGPenCq().curr_scaled_y_Amax();
if ((y_Amax > y_ref_big_step &&
(IpData().curr()->z_L()->Dim() + IpData().curr()->z_U()->Dim() +
IpData().curr()->v_L()->Dim() + IpData().curr()->v_U()->Dim() +
IpData().curr()->y_d()->Dim() == 0 ||
CGPenData().PrimalStepSize() < 1e-2)) ||
(CGPenData().PrimalStepSize() < alpha_ref &&
y_Amax > y_ref_tiny_step)) {
diverged = true;
}
}
return diverged;
}
bool LoqoMuOracle::CalculateMu(Number mu_min, Number mu_max,
Number& new_mu)
{
DBG_START_METH("LoqoMuOracle::CalculateMu",
dbg_verbosity);
Number avrg_compl = IpCq().curr_avrg_compl();
Jnlst().Printf(J_DETAILED, J_BARRIER_UPDATE,
" Average complemantarity is %lf\n", avrg_compl);
Number xi = IpCq().curr_centrality_measure();
Jnlst().Printf(J_DETAILED, J_BARRIER_UPDATE,
" Xi (distance from uniformity) is %lf\n", xi);
//Number factor = 1.-tau_min_; //This is the original values
Number factor = 0.05; //This is the value I used otherwise
Number sigma = 0.1*pow(Min(factor*(1.-xi)/xi,2.),3.);
Number mu = sigma*avrg_compl;
Jnlst().Printf(J_DETAILED, J_BARRIER_UPDATE,
" Barrier parameter proposed by LOQO rule is %lf\n", mu);
// DELETEME
char ssigma[40];
sprintf(ssigma, " sigma=%8.2e", sigma);
IpData().Append_info_string(ssigma);
sprintf(ssigma, " xi=%8.2e ", IpCq().curr_centrality_measure());
IpData().Append_info_string(ssigma);
new_mu = Max(Min(mu_max, mu), mu_min);
return true;
}
/** Method to easily access CGPenalty calculated quantities */
CGPenaltyCq& CGPenCq()
{
CGPenaltyCq& cg_pen_cq =
static_cast<CGPenaltyCq&>(IpCq().AdditionalCq());
DBG_ASSERT(dynamic_cast<CGPenaltyCq*>(&IpCq().AdditionalCq()));
return cg_pen_cq;
}
bool CGPenaltyLSAcceptor::ArmijoHolds(Number alpha_primal_test)
{
DBG_START_METH("CGPenaltyLSAcceptor::ArmijoHolds",
dbg_verbosity);
bool accept = false;
Number trial_penalty_function = CGPenCq().trial_penalty_function();
DBG_ASSERT(IsFiniteNumber(trial_penalty_function));
Jnlst().Printf(J_DETAILED, J_LINE_SEARCH,
"Checking acceptability for trial step size alpha_primal_test=%13.6e:\n", alpha_primal_test);
Jnlst().Printf(J_DETAILED, J_LINE_SEARCH,
" New values of penalty function = %23.16e (reference %23.16e):\n", trial_penalty_function, reference_penalty_function_);
if (Jnlst().ProduceOutput(J_DETAILED, J_LINE_SEARCH)) {
Jnlst().Printf(J_DETAILED, J_LINE_SEARCH,
"curr_barr = %23.16e curr_inf = %23.16e\n",
IpCq().curr_barrier_obj(),
IpCq().curr_constraint_violation());
Jnlst().Printf(J_DETAILED, J_LINE_SEARCH,
"trial_barr = %23.16e trial_inf = %23.16e\n",
IpCq().trial_barrier_obj(),
IpCq().trial_constraint_violation());
}
// Now check the Armijo condition
accept = Compare_le(trial_penalty_function-reference_penalty_function_,
eta_penalty_*alpha_primal_test*reference_direct_deriv_penalty_function_,
reference_penalty_function_);
return accept;
}
char CGPenaltyLSAcceptor::UpdateForNextIteration(Number alpha_primal_test)
{
char info_alpha_primal_char='n';
if (pen_curr_mu_ > IpData().curr_mu()) {
pen_curr_mu_ = IpData().curr_mu();
best_KKT_error_ = -1.;
}
// See if the current iterate has the least KKT errors so far
// If so, store the current iterate
if (CurrentIsBest()) {
StoreBestPoint();
}
// update piecewise penalty parameters
PiecewisePenalty_.Print( Jnlst() );
if (!accepted_by_Armijo_) {
PiecewisePenalty_.UpdateEntry(IpCq().trial_barrier_obj(),
IpCq().trial_constraint_violation());
}
PiecewisePenalty_.Print( Jnlst() );
// update regular penalty parameter
if (CGPenData().CurrPenaltyPert() != 0) {
info_alpha_primal_char = UpdatePenaltyParameter();
}
return info_alpha_primal_char;
}
void
AdaptiveMuUpdate::RememberCurrentPointAsAccepted()
{
switch (adaptive_mu_globalization_) {
case KKT_ERROR : {
Number curr_error = quality_function_pd_system();
Index num_refs = (Index)refs_vals_.size();
if (num_refs >= num_refs_max_) {
refs_vals_.pop_front();
}
refs_vals_.push_back(curr_error);
if (Jnlst().ProduceOutput(J_MOREDETAILED, J_BARRIER_UPDATE)) {
Index num_refs = 0;
std::list<Number>::iterator iter;
for (iter = refs_vals_.begin(); iter != refs_vals_.end();
iter++) {
num_refs++;
Jnlst().Printf(J_MOREDETAILED, J_BARRIER_UPDATE,
"pd system reference[%2d] = %.6e\n", num_refs, *iter);
}
}
}
break;
case FILTER_OBJ_CONSTR : {
/*
Number theta = IpCq().curr_constraint_violation();
filter_.AddEntry(IpCq().curr_f() - filter_margin_fact_*theta,
IpCq().curr_constraint_violation() - filter_margin_fact_*theta,
IpData().iter_count());
filter_.Print(Jnlst());
*/
filter_.AddEntry(IpCq().curr_f(),
IpCq().curr_constraint_violation(),
IpData().iter_count());
filter_.Print(Jnlst());
}
break;
case NEVER_MONOTONE_MODE : {
// Nothing to be done
}
break;
default:
DBG_ASSERT(false && "Unknown corrector_type value.");
}
if (restore_accepted_iterate_) {
// Keep pointers to this iterate so that it could be restored
accepted_point_ = IpData().curr();
}
}
void ExactHessianUpdater::UpdateHessian()
{
DBG_START_METH("ExactHessianUpdater::UpdateHessian",
dbg_verbosity);
IpData().Set_W(IpCq().curr_exact_hessian());
}
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);
}
void CGPenaltyLSAcceptor::InitThisLineSearch(bool in_watchdog)
{
DBG_START_METH("CGPenaltyLSAcceptor::InitThisLineSearch",
dbg_verbosity);
accepted_by_Armijo_ = true;
ls_counter_ = 0;
// If the algorithm restarts from a previous iteration, reset line search parameters.
if (CGPenData().restor_iter() == IpData().iter_count()) {
Reset();
}
// Every time mu is decreased, reset line search parameters.
if (pen_curr_mu_ > IpData().curr_mu()) {
Reset();
}
if (reset_piecewise_penalty_) {
Number curr_barr = IpCq().curr_barrier_obj();
Number curr_infeasi = IpCq().curr_constraint_violation();
PiecewisePenalty_.InitPiecewisePenaltyList(0.,curr_barr, curr_infeasi);
reset_piecewise_penalty_ = false;
}
// Set the values for the reference point
if (!in_watchdog) {
reference_penalty_function_ = CGPenCq().curr_penalty_function();
reference_theta_ = IpCq().curr_constraint_violation();
if (CGPenData().HaveCgFastDeltas()) {
// use the fast step
reference_direct_deriv_penalty_function_ =
CGPenCq().curr_fast_direct_deriv_penalty_function();
}
else {
reference_direct_deriv_penalty_function_ =
CGPenCq().curr_direct_deriv_penalty_function();
}
}
else {
//reference_theta_ = watchdog_theta_;
reference_penalty_function_ = watchdog_penalty_function_;
reference_direct_deriv_penalty_function_ =
watchdog_direct_deriv_penalty_function_;
}
}
bool
AdaptiveMuUpdate::CheckSufficientProgress()
{
bool retval = true;
switch (adaptive_mu_globalization_) {
case KKT_ERROR : {
Index num_refs = (Index)refs_vals_.size();
if (num_refs >= num_refs_max_) {
retval = false;
Number curr_error = quality_function_pd_system();
std::list<Number>::iterator iter;
for (iter = refs_vals_.begin(); iter != refs_vals_.end();
iter++) {
if ( curr_error <= refs_red_fact_*(*iter) ) {
retval = true;
}
}
}
}
break;
case FILTER_OBJ_CONSTR : {
/*
retval = filter_.Acceptable(IpCq().curr_f(),
IpCq().curr_constraint_violation());
*/
// ToDo: Is curr_nlp_error really what we should use here?
Number curr_error = IpCq().curr_nlp_error();
Number margin = filter_margin_fact_*Min(filter_max_margin_, curr_error);
retval = filter_.Acceptable(IpCq().curr_f() + margin,
IpCq().curr_constraint_violation() + margin);
}
break;
case NEVER_MONOTONE_MODE :
retval = true;
break;
default:
DBG_ASSERT(false && "Unknown adaptive_mu_globalization value.");
}
return retval;
}
bool AugRestoSystemSolver::InitializeImpl(const OptionsList& options,
const std::string& prefix)
{
bool retval = true;
if (!skip_orig_aug_solver_init_) {
retval = orig_aug_solver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(),
options, prefix);
}
return retval;
}
bool CGPenaltyLSAcceptor::CurrentIsBest()
{
DBG_START_METH("CGPenaltyLSAcceptor::CurrentIsBest",
dbg_verbosity);
Number dual_inf = IpCq().unscaled_curr_dual_infeasibility(NORM_MAX);
Number constr_viol = IpCq().unscaled_curr_nlp_constraint_violation(NORM_MAX);
Number compl_inf = IpCq().unscaled_curr_complementarity(0., NORM_MAX);
Number KKT_error = Max(dual_inf,Max(constr_viol,compl_inf));
DBG_PRINT((1, "dual_inf = %e\n", dual_inf));
DBG_PRINT((1, "constr_viol = %e\n", constr_viol));
DBG_PRINT((1, "compl_inf = %e\n", compl_inf));
DBG_PRINT((1, "best_KKT_error_= %e\n", best_KKT_error_));
bool best = false;
if (KKT_error < best_KKT_error_ ||
best_KKT_error_ < 0.) {
best_KKT_error_ = KKT_error;
best = true;
}
return best;
}
bool CGPenaltyLSAcceptor::IsAcceptableToPiecewisePenalty(Number alpha_primal_test)
{
DBG_START_METH("CGPenaltyLSAcceptor::IsAcceptableToPiecewisePenalty",
dbg_verbosity);
// If the current infeasibility is small, we require the barrier to be decreased.
bool accept = false;
Number infeasibility = IpCq().curr_primal_infeasibility(NORM_MAX);
SmartPtr<const Vector> dx = IpData().delta()->x();
SmartPtr<const Vector> ds = IpData().delta()->s();
Number curr_barr = IpCq().curr_barrier_obj();
Number trial_barr = IpCq().trial_barrier_obj();
Number nrm_dx_ds = pow(dx->Nrm2(),2.) + pow(ds->Nrm2(),2.);
if (infeasibility < theta_min_) {
Number biggest_barr = PiecewisePenalty_.BiggestBarr();
accept = Compare_le(trial_barr-biggest_barr, -alpha_primal_test*
piecewisepenalty_gamma_obj_*nrm_dx_ds, curr_barr);
if (!accept) {
return false;
}
}
Number Fzconst, Fzlin;
Fzconst = IpCq().trial_barrier_obj() + alpha_primal_test *
piecewisepenalty_gamma_obj_ * nrm_dx_ds;
Fzlin = IpCq().trial_constraint_violation() + alpha_primal_test *
piecewisepenalty_gamma_infeasi_ * IpCq().curr_constraint_violation();
accept = PiecewisePenalty_.Acceptable(Fzconst, Fzlin);
return accept;
}
Number
AdaptiveMuUpdate::lower_mu_safeguard()
{
DBG_START_METH("AdaptiveMuUpdate::lower_mu_safeguard",
dbg_verbosity);
if (adaptive_mu_safeguard_factor_ == 0.)
return 0.;
Number dual_inf =
IpCq().curr_dual_infeasibility(NORM_1);
Number primal_inf =
IpCq().curr_primal_infeasibility(NORM_1);
Index n_dual = IpData().curr()->x()->Dim() + IpData().curr()->s()->Dim();
dual_inf /= (Number)n_dual;
Index n_pri = IpData().curr()->y_c()->Dim() + IpData().curr()->y_d()->Dim();
DBG_ASSERT(n_pri>0 || primal_inf==0.);
if (n_pri>0) {
primal_inf /= (Number)n_pri;
}
if (init_dual_inf_ < 0.) {
init_dual_inf_ = Max(1., dual_inf);
}
if (init_primal_inf_ < 0.) {
init_primal_inf_ = Max(1., primal_inf);
}
Number lower_mu_safeguard =
Max(adaptive_mu_safeguard_factor_ * (dual_inf/init_dual_inf_),
adaptive_mu_safeguard_factor_ * (primal_inf/init_primal_inf_));
DBG_PRINT((1,"dual_inf=%e init_dual_inf_=%e primal_inf=%e init_primal_inf_=%e\n", dual_inf, init_dual_inf_, primal_inf, init_primal_inf_));
if (adaptive_mu_globalization_==KKT_ERROR) {
lower_mu_safeguard = Min(lower_mu_safeguard, min_ref_val());
}
return lower_mu_safeguard;
}
bool LowRankAugSystemSolver::InitializeImpl(
const OptionsList& options,
const std::string& prefix
)
{
first_call_ = true;
J1_ = NULL;
J2_ = NULL;
Vtilde1_ = NULL;
Utilde2_ = NULL;
Wdiag_ = NULL;
compound_sol_vecspace_ = NULL;
return aug_system_solver_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(), options, prefix);
}
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 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);
// This is registered in OptimalityErrorConvergenceCheck
options.GetNumericValue("constr_viol_tol", constr_viol_tol_, 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);
}
if (!options.GetNumericValue("resto_failure_feasibility_threshold",
resto_failure_feasibility_threshold_, prefix)) {
resto_failure_feasibility_threshold_ = 1e2*IpData().tol();
}
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 GenAugSystemSolver::InitializeImpl(const OptionsList& options,
const std::string& prefix)
{
// This option is registered by OrigIpoptNLP
options.GetBoolValue("warm_start_same_structure",
warm_start_same_structure_, prefix);
if (!warm_start_same_structure_) {
delete [] dx_vals_copy_;
delete [] ds_vals_copy_;
delete [] dc_vals_copy_;
delete [] dd_vals_copy_;
}
return solver_interface_->Initialize(Jnlst(), IpNLP(), IpData(), IpCq(),
options, prefix);
}
bool RestoIterateInitializer::InitializeImpl(const OptionsList& options,
const std::string& prefix)
{
if (!options.GetNumericValue("constr_mult_init_max", constr_mult_init_max_, prefix)) {
// By default, we want to set this to zero. Seems to work better
// as initialization for the restoration phase
constr_mult_init_max_ = 0.;
}
bool retvalue = true;
if (IsValid(resto_eq_mult_calculator_)) {
retvalue = resto_eq_mult_calculator_->Initialize(Jnlst(),
IpNLP(), IpData(),
IpCq(), options, prefix);
}
return retvalue;
}
void IpoptAlgorithm::ComputeFeasibilityMultipliers()
{
DBG_START_METH("IpoptAlgorithm::ComputeFeasibilityMultipliers",
dbg_verbosity);
DBG_ASSERT(IpCq().IsSquareProblem());
// if we don't have an object for computing least square
// multipliers we don't compute them
if (IsNull(eq_multiplier_calculator_)) {
Jnlst().Printf(J_WARNING, J_SOLUTION,
"This is a square problem, but multipliers cannot be recomputed at solution, since no eq_mult_calculator object is available in IpoptAlgorithm\n");
return;
}
SmartPtr<IteratesVector> iterates = IpData().curr()->MakeNewContainer();
SmartPtr<Vector> tmp = iterates->z_L()->MakeNew();
tmp->Set(0.);
iterates->Set_z_L(*tmp);
tmp = iterates->z_U()->MakeNew();
tmp->Set(0.);
iterates->Set_z_U(*tmp);
tmp = iterates->v_L()->MakeNew();
tmp->Set(0.);
iterates->Set_v_L(*tmp);
tmp = iterates->v_U()->MakeNew();
tmp->Set(0.);
iterates->Set_v_U(*tmp);
SmartPtr<Vector> y_c = iterates->y_c()->MakeNew();
SmartPtr<Vector> y_d = iterates->y_d()->MakeNew();
IpData().set_trial(iterates);
IpData().AcceptTrialPoint();
bool retval = eq_multiplier_calculator_->CalculateMultipliers(*y_c, *y_d);
if (retval) {
//Check if following line is really necessary
iterates = IpData().curr()->MakeNewContainer();
iterates->Set_y_c(*y_c);
iterates->Set_y_d(*y_d);
IpData().set_trial(iterates);
IpData().AcceptTrialPoint();
}
else {
Jnlst().Printf(J_WARNING, J_SOLUTION,
"Cannot recompute multipliers for feasibility problem. Error in eq_mult_calculator\n");
}
}
Number
AdaptiveMuUpdate::NewFixedMu()
{
Number max_ref;
// ToDo: Decide whether we should impose an upper bound on
// mu based on the smallest reference value. For now, don't
// impose one.
max_ref = 1e20;
/*
switch (adaptive_mu_globalization_) {
case 1 :
max_ref = max_ref_val();
break;
case 2 : {
max_ref = 1e20;
}
break;
default:
DBG_ASSERT("Unknown corrector_type value.");
}
*/
Number new_mu;
bool have_mu = false;
;
if (IsValid(fix_mu_oracle_)) {
have_mu = fix_mu_oracle_->CalculateMu(Max(mu_min_, mu_target_),
mu_max_, new_mu);
if (!have_mu) {
Jnlst().Printf(J_DETAILED, J_LINE_SEARCH,
"New fixed value for mu could not be computed from the mu_oracle.\n");
}
}
if (!have_mu) {
new_mu = adaptive_mu_monotone_init_factor_*IpCq().curr_avrg_compl();
}
new_mu = Max(new_mu, lower_mu_safeguard());
new_mu = Min(new_mu, 0.1 * max_ref);
new_mu = Max(new_mu, mu_min_);
new_mu = Min(new_mu, mu_max_);
return new_mu;
}
void OrigIterationOutput::WriteOutput()
{
//////////////////////////////////////////////////////////////////////
// First print the summary line for the iteration //
//////////////////////////////////////////////////////////////////////
Index iter = IpData().iter_count();
std::string header =
"iter objective inf_pr inf_du lg(mu) ||d|| lg(rg) alpha_du alpha_pr ls\n";
Jnlst().Printf(J_DETAILED, J_MAIN,
"\n\n**************************************************\n");
Jnlst().Printf(J_DETAILED, J_MAIN,
"*** Summary of Iteration: %d:", IpData().iter_count());
Jnlst().Printf(J_DETAILED, J_MAIN,
"\n**************************************************\n\n");
if (iter%10 == 0 && !IpData().info_skip_output()) {
// output the header
Jnlst().Printf(J_ITERSUMMARY, J_MAIN, header.c_str());
}
else {
Jnlst().Printf(J_DETAILED, J_MAIN, header.c_str());
}
Number inf_pr = IpCq().curr_primal_infeasibility(NORM_MAX);
Number inf_du = IpCq().curr_dual_infeasibility(NORM_MAX);
Number mu = IpData().curr_mu();
Number dnrm;
if (IsValid(IpData().delta()) && IsValid(IpData().delta()->x()) && IsValid(IpData().delta()->s())) {
dnrm = Max(IpData().delta()->x()->Amax(), IpData().delta()->s()->Amax());
}
else {
// This is the first iteration - no search direction has been
// computed yet.
dnrm = 0.;
}
Number unscaled_f = IpCq().unscaled_curr_f();
// Retrieve some information set in the different parts of the algorithm
char info_iter=' ';
Number alpha_primal = IpData().info_alpha_primal();
char alpha_primal_char = IpData().info_alpha_primal_char();
Number alpha_dual = IpData().info_alpha_dual();
Number regu_x = IpData().info_regu_x();
char regu_x_buf[8];
char dashes[]=" - ";
char *regu_x_ptr;
if (regu_x==.0) {
regu_x_ptr = dashes;
}
else {
sprintf(regu_x_buf, "%5.1f", log10(regu_x));
regu_x_ptr = regu_x_buf;
}
Index ls_count = IpData().info_ls_count();
const std::string info_string = IpData().info_string();
if (!IpData().info_skip_output()) {
Jnlst().Printf(J_ITERSUMMARY, J_MAIN,
"%4d%c%14.7e %7.2e %7.2e %5.1f %7.2e %5s %7.2e %7.2e%c%3d",
iter, info_iter, unscaled_f, inf_pr, inf_du, log10(mu), dnrm, regu_x_ptr,
alpha_dual, alpha_primal, alpha_primal_char,
ls_count);
if (print_info_string_) {
Jnlst().Printf(J_ITERSUMMARY, J_MAIN, " %s", info_string.c_str());
}
else {
// TODO UNCOMMENT WHEN DONE TESTING
Jnlst().Printf(J_DETAILED, J_MAIN, " %s", info_string.c_str());
//printf(" %s",info_string.c_str());
}
Jnlst().Printf(J_ITERSUMMARY, J_MAIN, "\n");
}
//////////////////////////////////////////////////////////////////////
// Now if desired more detail on the iterates //
//////////////////////////////////////////////////////////////////////
if (Jnlst().ProduceOutput(J_DETAILED, J_MAIN)) {
Jnlst().Printf(J_DETAILED, J_MAIN,
"\n**************************************************\n");
Jnlst().Printf(J_DETAILED, J_MAIN,
"*** Beginning Iteration %d from the following point:",
IpData().iter_count());
Jnlst().Printf(J_DETAILED, J_MAIN,
"\n**************************************************\n\n");
Jnlst().Printf(J_DETAILED, J_MAIN,
"Current barrier parameter mu = %21.16e\n", IpData().curr_mu());
Jnlst().Printf(J_DETAILED, J_MAIN,
"Current fraction-to-the-boundary parameter tau = %21.16e\n\n",
IpData().curr_tau());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_x||_inf = %.16e\n", IpData().curr()->x()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_s||_inf = %.16e\n", IpData().curr()->s()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_y_c||_inf = %.16e\n", IpData().curr()->y_c()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_y_d||_inf = %.16e\n", IpData().curr()->y_d()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_z_L||_inf = %.16e\n", IpData().curr()->z_L()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_z_U||_inf = %.16e\n", IpData().curr()->z_U()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_v_L||_inf = %.16e\n", IpData().curr()->v_L()->Amax());
Jnlst().Printf(J_DETAILED, J_MAIN,
"||curr_v_U||_inf = %.16e\n", IpData().curr()->v_U()->Amax());
}
if (Jnlst().ProduceOutput(J_MOREDETAILED, J_MAIN)) {
if (IsValid(IpData().delta())) {
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"\n||delta_x||_inf = %.16e\n", IpData().delta()->x()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_s||_inf = %.16e\n", IpData().delta()->s()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_y_c||_inf = %.16e\n", IpData().delta()->y_c()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_y_d||_inf = %.16e\n", IpData().delta()->y_d()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_z_L||_inf = %.16e\n", IpData().delta()->z_L()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_z_U||_inf = %.16e\n", IpData().delta()->z_U()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_v_L||_inf = %.16e\n", IpData().delta()->v_L()->Amax());
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"||delta_v_U||_inf = %.16e\n", IpData().delta()->v_U()->Amax());
}
else {
Jnlst().Printf(J_MOREDETAILED, J_MAIN,
"\nNo search direction has been computed yet.\n");
}
}
if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
IpData().curr()->x()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_x");
IpData().curr()->s()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_s");
IpData().curr()->y_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_c");
IpData().curr()->y_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_y_d");
IpCq().curr_slack_x_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_L");
IpCq().curr_slack_x_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_x_U");
IpData().curr()->z_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_L");
IpData().curr()->z_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_z_U");
IpCq().curr_slack_s_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_L");
IpCq().curr_slack_s_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_slack_s_U");
IpData().curr()->v_L()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_L");
IpData().curr()->v_U()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_v_U");
}
if (Jnlst().ProduceOutput(J_MOREVECTOR, J_MAIN)) {
IpCq().curr_grad_lag_x()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_x");
IpCq().curr_grad_lag_s()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "curr_grad_lag_s");
if (IsValid(IpData().delta())) {
IpData().delta()->Print(Jnlst(), J_MOREVECTOR, J_MAIN, "delta");
}
}
if (Jnlst().ProduceOutput(J_DETAILED, J_MAIN)) {
Jnlst().Printf(J_DETAILED, J_MAIN,
"\n\n***Current NLP Values for Iteration %d:\n",
IpData().iter_count());
Jnlst().Printf(J_DETAILED, J_MAIN, "\n (scaled) (unscaled)\n");
Jnlst().Printf(J_DETAILED, J_MAIN, "Objective...............: %24.16e %24.16e\n", IpCq().curr_f(), IpCq().unscaled_curr_f());
Jnlst().Printf(J_DETAILED, J_MAIN, "Dual infeasibility......: %24.16e %24.16e\n", IpCq().curr_dual_infeasibility(NORM_MAX), IpCq().unscaled_curr_dual_infeasibility(NORM_MAX));
Jnlst().Printf(J_DETAILED, J_MAIN, "Constraint violation....: %24.16e %24.16e\n", IpCq().curr_nlp_constraint_violation(NORM_MAX), IpCq().unscaled_curr_nlp_constraint_violation(NORM_MAX));
Jnlst().Printf(J_DETAILED, J_MAIN, "Complementarity.........: %24.16e %24.16e\n", IpCq().curr_complementarity(0., NORM_MAX), IpCq().unscaled_curr_complementarity(0., NORM_MAX));
Jnlst().Printf(J_DETAILED, J_MAIN, "Overall NLP error.......: %24.16e %24.16e\n\n", IpCq().curr_nlp_error(), IpCq().unscaled_curr_nlp_error());
}
if (Jnlst().ProduceOutput(J_VECTOR, J_MAIN)) {
IpCq().curr_grad_f()->Print(Jnlst(), J_VECTOR, J_MAIN, "grad_f");
IpCq().curr_c()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_c");
IpCq().curr_d()->Print(Jnlst(), J_VECTOR, J_MAIN, "curr_d");
IpCq().curr_d_minus_s()->Print(Jnlst(), J_VECTOR, J_MAIN,
"curr_d - curr_s");
}
if (Jnlst().ProduceOutput(J_MATRIX, J_MAIN)) {
IpCq().curr_jac_c()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_c");
IpCq().curr_jac_d()->Print(Jnlst(), J_MATRIX, J_MAIN, "jac_d");
IpData().W()->Print(Jnlst(), J_MATRIX, J_MAIN, "W");
}
Jnlst().Printf(J_DETAILED, J_MAIN, "\n\n");
}
bool
RestoRestorationPhase::PerformRestoration()
{
DBG_START_METH("RestoRestorationPhase::PerformRestoration",
dbg_verbosity);
Jnlst().Printf(J_DETAILED, J_MAIN,
"Performing second level restoration phase for current constriant violation %8.2e\n", IpCq().curr_constraint_violation());
DBG_ASSERT(IpCq().curr_constraint_violation()>0.);
// Get a grip on the restoration phase NLP and obtain the pointers
// to the original NLP data
SmartPtr<RestoIpoptNLP> resto_ip_nlp =
static_cast<RestoIpoptNLP*> (&IpNLP());
DBG_ASSERT(dynamic_cast<RestoIpoptNLP*> (&IpNLP()));
SmartPtr<IpoptNLP> orig_ip_nlp =
static_cast<IpoptNLP*> (&resto_ip_nlp->OrigIpNLP());
DBG_ASSERT(dynamic_cast<IpoptNLP*> (&resto_ip_nlp->OrigIpNLP()));
// Get the current point and create a new vector for the result
SmartPtr<const CompoundVector> Ccurr_x =
static_cast<const CompoundVector*> (GetRawPtr(IpData().curr()->x()));
SmartPtr<Vector> new_x = IpData().curr()->x()->MakeNew();
SmartPtr<CompoundVector> Cnew_x =
static_cast<CompoundVector*> (GetRawPtr(new_x));
// The x values remain unchanged
SmartPtr<Vector> x = Cnew_x->GetCompNonConst(0);
x->Copy(*Ccurr_x->GetComp(0));
// ToDo in free mu mode - what to do here?
Number mu = IpData().curr_mu();
// Compute the initial values for the n and p variables for the
// equality constraints
Number rho = resto_ip_nlp->Rho();
SmartPtr<Vector> nc = Cnew_x->GetCompNonConst(1);
SmartPtr<Vector> pc = Cnew_x->GetCompNonConst(2);
SmartPtr<const Vector> cvec = orig_ip_nlp->c(*Ccurr_x->GetComp(0));
SmartPtr<Vector> a = nc->MakeNew();
SmartPtr<Vector> b = nc->MakeNew();
a->Set(mu/(2.*rho));
a->Axpy(-0.5, *cvec);
b->Copy(*cvec);
b->Scal(mu/(2.*rho));
solve_quadratic(*a, *b, *nc);
pc->Copy(*cvec);
pc->Axpy(1., *nc);
DBG_PRINT_VECTOR(2, "nc", *nc);
DBG_PRINT_VECTOR(2, "pc", *pc);
// initial values for the n and p variables for the inequality
// constraints
SmartPtr<Vector> nd = Cnew_x->GetCompNonConst(3);
SmartPtr<Vector> pd = Cnew_x->GetCompNonConst(4);
SmartPtr<Vector> dvec = pd->MakeNew();
dvec->Copy(*orig_ip_nlp->d(*Ccurr_x->GetComp(0)));
dvec->Axpy(-1., *IpData().curr()->s());
a = nd->MakeNew();
b = nd->MakeNew();
a->Set(mu/(2.*rho));
a->Axpy(-0.5, *dvec);
b->Copy(*dvec);
b->Scal(mu/(2.*rho));
solve_quadratic(*a, *b, *nd);
pd->Copy(*dvec);
pd->Axpy(1., *nd);
DBG_PRINT_VECTOR(2, "nd", *nd);
DBG_PRINT_VECTOR(2, "pd", *pd);
// Now set the trial point to the solution of the restoration phase
// s and all multipliers remain unchanged
SmartPtr<IteratesVector> new_trial = IpData().curr()->MakeNewContainer();
new_trial->Set_x(*new_x);
IpData().set_trial(new_trial);
IpData().Append_info_string("R");
return true;
}
bool RestoIterateInitializer::SetInitialIterates()
{
DBG_START_METH("RestoIterateInitializer::SetInitialIterates",
dbg_verbosity);
// Get a grip on the restoration phase NLP and obtain the pointers
// to the original NLP data
SmartPtr<RestoIpoptNLP> resto_ip_nlp =
static_cast<RestoIpoptNLP*> (&IpNLP());
SmartPtr<IpoptNLP> orig_ip_nlp =
static_cast<IpoptNLP*> (&resto_ip_nlp->OrigIpNLP());
SmartPtr<IpoptData> orig_ip_data =
static_cast<IpoptData*> (&resto_ip_nlp->OrigIpData());
SmartPtr<IpoptCalculatedQuantities> orig_ip_cq =
static_cast<IpoptCalculatedQuantities*> (&resto_ip_nlp->OrigIpCq());
// Set the value of the barrier parameter
Number resto_mu;
resto_mu = Max(orig_ip_data->curr_mu(),
orig_ip_cq->curr_c()->Amax(),
orig_ip_cq->curr_d_minus_s()->Amax());
IpData().Set_mu(resto_mu);
Jnlst().Printf(J_DETAILED, J_INITIALIZATION,
"Initial barrier parameter resto_mu = %e\n", resto_mu);
/////////////////////////////////////////////////////////////////////
// Initialize primal varialbes //
/////////////////////////////////////////////////////////////////////
// initialize the data structures in the restoration phase NLP
IpData().InitializeDataStructures(IpNLP(), false, false, false,
false, false);
SmartPtr<Vector> new_x = IpData().curr()->x()->MakeNew();
SmartPtr<CompoundVector> Cnew_x =
static_cast<CompoundVector*> (GetRawPtr(new_x));
// Set the trial x variables from the original NLP
Cnew_x->GetCompNonConst(0)->Copy(*orig_ip_data->curr()->x());
// Compute the initial values for the n and p variables for the
// equality constraints
Number rho = resto_ip_nlp->Rho();
DBG_PRINT((1,"rho = %e\n", rho));
SmartPtr<Vector> nc = Cnew_x->GetCompNonConst(1);
SmartPtr<Vector> pc = Cnew_x->GetCompNonConst(2);
SmartPtr<const Vector> cvec = orig_ip_cq->curr_c();
DBG_PRINT_VECTOR(2, "cvec", *cvec);
SmartPtr<Vector> a = nc->MakeNew();
SmartPtr<Vector> b = nc->MakeNew();
a->Set(resto_mu/(2.*rho));
a->Axpy(-0.5, *cvec);
b->Copy(*cvec);
b->Scal(resto_mu/(2.*rho));
DBG_PRINT_VECTOR(2, "a", *a);
DBG_PRINT_VECTOR(2, "b", *b);
solve_quadratic(*a, *b, *nc);
pc->Copy(*cvec);
pc->Axpy(1., *nc);
DBG_PRINT_VECTOR(2, "nc", *nc);
DBG_PRINT_VECTOR(2, "pc", *pc);
// initial values for the n and p variables for the inequality
// constraints
SmartPtr<Vector> nd = Cnew_x->GetCompNonConst(3);
SmartPtr<Vector> pd = Cnew_x->GetCompNonConst(4);
cvec = orig_ip_cq->curr_d_minus_s();
a = nd->MakeNew();
b = nd->MakeNew();
a->Set(resto_mu/(2.*rho));
a->Axpy(-0.5, *cvec);
b->Copy(*cvec);
b->Scal(resto_mu/(2.*rho));
solve_quadratic(*a, *b, *nd);
pd->Copy(*cvec);
pd->Axpy(1., *nd);
DBG_PRINT_VECTOR(2, "nd", *nd);
DBG_PRINT_VECTOR(2, "pd", *pd);
// Leave the slacks unchanged
SmartPtr<const Vector> new_s = orig_ip_data->curr()->s();
// Now set the primal trial variables
DBG_PRINT_VECTOR(2,"new_s",*new_s);
DBG_PRINT_VECTOR(2,"new_x",*new_x);
SmartPtr<IteratesVector> trial = IpData().curr()->MakeNewContainer();
trial->Set_primal(*new_x, *new_s);
IpData().set_trial(trial);
DBG_PRINT_VECTOR(2, "resto_c", *IpCq().trial_c());
DBG_PRINT_VECTOR(2, "resto_d_minus_s", *IpCq().trial_d_minus_s());
/////////////////////////////////////////////////////////////////////
// Initialize bound multipliers //
/////////////////////////////////////////////////////////////////////
SmartPtr<Vector> new_z_L = IpData().curr()->z_L()->MakeNew();
SmartPtr<CompoundVector> Cnew_z_L =
static_cast<CompoundVector*> (GetRawPtr(new_z_L));
DBG_ASSERT(IsValid(Cnew_z_L));
SmartPtr<Vector> new_z_U = IpData().curr()->z_U()->MakeNew();
SmartPtr<Vector> new_v_L = IpData().curr()->v_L()->MakeNew();
SmartPtr<Vector> new_v_U = IpData().curr()->v_U()->MakeNew();
// multipliers for the original bounds are
SmartPtr<const Vector> orig_z_L = orig_ip_data->curr()->z_L();
SmartPtr<const Vector> orig_z_U = orig_ip_data->curr()->z_U();
SmartPtr<const Vector> orig_v_L = orig_ip_data->curr()->v_L();
SmartPtr<const Vector> orig_v_U = orig_ip_data->curr()->v_U();
// Set the new multipliers to the min of the penalty parameter Rho
// and their current value
SmartPtr<Vector> Cnew_z_L0 = Cnew_z_L->GetCompNonConst(0);
Cnew_z_L0->Set(rho);
Cnew_z_L0->ElementWiseMin(*orig_z_L);
new_z_U->Set(rho);
new_z_U->ElementWiseMin(*orig_z_U);
new_v_L->Set(rho);
new_v_L->ElementWiseMin(*orig_v_L);
new_v_U->Set(rho);
new_v_U->ElementWiseMin(*orig_v_U);
// Set the multipliers for the p and n bounds to the "primal" multipliers
SmartPtr<Vector> Cnew_z_L1 = Cnew_z_L->GetCompNonConst(1);
Cnew_z_L1->Set(resto_mu);
Cnew_z_L1->ElementWiseDivide(*nc);
SmartPtr<Vector> Cnew_z_L2 = Cnew_z_L->GetCompNonConst(2);
Cnew_z_L2->Set(resto_mu);
Cnew_z_L2->ElementWiseDivide(*pc);
SmartPtr<Vector> Cnew_z_L3 = Cnew_z_L->GetCompNonConst(3);
Cnew_z_L3->Set(resto_mu);
Cnew_z_L3->ElementWiseDivide(*nd);
SmartPtr<Vector> Cnew_z_L4 = Cnew_z_L->GetCompNonConst(4);
Cnew_z_L4->Set(resto_mu);
Cnew_z_L4->ElementWiseDivide(*pd);
// Set those initial values to be the trial values in Data
trial = IpData().trial()->MakeNewContainer();
trial->Set_bound_mult(*new_z_L, *new_z_U, *new_v_L, *new_v_U);
IpData().set_trial(trial);
/////////////////////////////////////////////////////////////////////
// Initialize equality constraint multipliers //
/////////////////////////////////////////////////////////////////////
DefaultIterateInitializer::least_square_mults(
Jnlst(), IpNLP(), IpData(), IpCq(),
resto_eq_mult_calculator_, constr_mult_init_max_);
// upgrade the trial to the current point
IpData().AcceptTrialPoint();
DBG_PRINT_VECTOR(2, "y_c", *IpData().curr()->y_c());
DBG_PRINT_VECTOR(2, "y_d", *IpData().curr()->y_d());
DBG_PRINT_VECTOR(2, "z_L", *IpData().curr()->z_L());
DBG_PRINT_VECTOR(2, "z_U", *IpData().curr()->z_U());
DBG_PRINT_VECTOR(2, "v_L", *IpData().curr()->v_L());
DBG_PRINT_VECTOR(2, "v_U", *IpData().curr()->v_U());
return true;
}
ConvergenceCheck::ConvergenceStatus
OptimalityErrorConvergenceCheck::CheckConvergence(bool call_intermediate_callback /*= true*/)
{
DBG_START_METH("OptimalityErrorConvergenceCheck::CheckConvergence", dbg_verbosity);
if (call_intermediate_callback) {
// Check if user requested termination by calling the intermediate
// user callback function
AlgorithmMode mode = RegularMode;
// Gather the information also used in the iteration output
Index iter = IpData().iter_count();
Number inf_pr = IpCq().curr_primal_infeasibility(NORM_MAX);
Number inf_du = IpCq().curr_dual_infeasibility(NORM_MAX);
Number mu = IpData().curr_mu();
Number dnrm;
if (IsValid(IpData().delta()) && IsValid(IpData().delta()->x()) && IsValid(IpData().delta()->s())) {
dnrm = Max(IpData().delta()->x()->Amax(), IpData().delta()->s()->Amax());
}
else {
// This is the first iteration - no search direction has been
// computed yet.
dnrm = 0.;
}
Number alpha_primal = IpData().info_alpha_primal();
Number alpha_dual = IpData().info_alpha_dual();
Number regu_x = IpData().info_regu_x();
Number unscaled_f = IpCq().unscaled_curr_f();
Index ls_count = IpData().info_ls_count();
bool request_stop =
!IpNLP().IntermediateCallBack(mode, iter, unscaled_f, inf_pr, inf_du,
mu, dnrm, regu_x, alpha_dual,
alpha_primal, ls_count,
&IpData(), &IpCq());
if (request_stop) {
return ConvergenceCheck::USER_STOP;
}
}
if (IpData().iter_count() >= max_iterations_) {
return ConvergenceCheck::MAXITER_EXCEEDED;
}
Number overall_error = IpCq().curr_nlp_error();
Number dual_inf = IpCq().unscaled_curr_dual_infeasibility(NORM_MAX);
Number constr_viol = IpCq().unscaled_curr_nlp_constraint_violation(NORM_MAX);
Number compl_inf = IpCq().unscaled_curr_complementarity(0., NORM_MAX);
if (IpData().curr()->x()->Dim()==IpData().curr()->y_c()->Dim()) {
// the problem is square, there is no point in looking at dual
// infeasibility and complementarity as termination criterion
dual_inf_tol_ = 1e300;
compl_inf_tol_ = 1e300;
}
if (overall_error <= IpData().tol() &&
dual_inf <= dual_inf_tol_ &&
constr_viol <= constr_viol_tol_ &&
compl_inf <= compl_inf_tol_) {
return ConvergenceCheck::CONVERGED;
}
if (acceptable_iter_>0 && CurrentIsAcceptable()) {
IpData().Append_info_string("A");
acceptable_counter_++;
if (acceptable_counter_ >= acceptable_iter_) {
return ConvergenceCheck::CONVERGED_TO_ACCEPTABLE_POINT;
}
}
else {
acceptable_counter_ = 0;
}
if (IpData().curr()->x()->Amax() > diverging_iterates_tol_) {
return ConvergenceCheck::DIVERGING;
}
return ConvergenceCheck::CONTINUE;
}
bool IterativePardisoSolverInterface::InitializeImpl(const OptionsList& options,
const std::string& prefix)
{
Index enum_int;
options.GetEnumValue("pardiso_matching_strategy", enum_int, prefix);
match_strat_ = PardisoMatchingStrategy(enum_int);
options.GetBoolValue("pardiso_redo_symbolic_fact_only_if_inertia_wrong",
pardiso_redo_symbolic_fact_only_if_inertia_wrong_,
prefix);
options.GetBoolValue("pardiso_repeated_perturbation_means_singular",
pardiso_repeated_perturbation_means_singular_,
prefix);
Index pardiso_out_of_core_power;
options.GetIntegerValue("pardiso_out_of_core_power",
pardiso_out_of_core_power, prefix);
options.GetBoolValue("pardiso_skip_inertia_check",
skip_inertia_check_, prefix);
// PD system
options.GetIntegerValue("pardiso_max_iter", pardiso_max_iter_, prefix);
options.GetNumericValue("pardiso_iter_relative_tol",
pardiso_iter_relative_tol_, prefix);
options.GetIntegerValue("pardiso_iter_coarse_size",
pardiso_iter_coarse_size_, prefix);
options.GetIntegerValue("pardiso_iter_max_levels",
pardiso_iter_max_levels_, prefix);
options.GetNumericValue("pardiso_iter_dropping_factor",
pardiso_iter_dropping_factor_, prefix);
options.GetNumericValue("pardiso_iter_dropping_schur",
pardiso_iter_dropping_schur_, prefix);
options.GetIntegerValue("pardiso_iter_max_row_fill",
pardiso_iter_max_row_fill_, prefix);
options.GetNumericValue("pardiso_iter_inverse_norm_factor",
pardiso_iter_inverse_norm_factor_, prefix);
// Normal system
options.GetIntegerValue("pardiso_max_iter", normal_pardiso_max_iter_,
prefix+"normal.");
options.GetNumericValue("pardiso_iter_relative_tol",
normal_pardiso_iter_relative_tol_,
prefix+"normal.");
options.GetIntegerValue("pardiso_iter_coarse_size",
normal_pardiso_iter_coarse_size_,
prefix+"normal.");
options.GetIntegerValue("pardiso_iter_max_levels",
normal_pardiso_iter_max_levels_,
prefix+"normal.");
options.GetNumericValue("pardiso_iter_dropping_factor",
normal_pardiso_iter_dropping_factor_,
prefix+"normal.");
options.GetNumericValue("pardiso_iter_dropping_schur",
normal_pardiso_iter_dropping_schur_,
prefix+"normal.");
options.GetIntegerValue("pardiso_iter_max_row_fill",
normal_pardiso_iter_max_row_fill_,
prefix+"normal.");
options.GetNumericValue("pardiso_iter_inverse_norm_factor",
normal_pardiso_iter_inverse_norm_factor_,
prefix+"normal.");
int pardiso_msglvl;
options.GetIntegerValue("pardiso_msglvl", pardiso_msglvl, prefix);
options.GetIntegerValue("pardiso_max_droptol_corrections",
pardiso_max_droptol_corrections_, prefix);
// Number value = 0.0;
// Tell Pardiso to release all memory if it had been used before
if (initialized_) {
ipfint PHASE = -1;
ipfint N = dim_;
ipfint NRHS = 0;
ipfint ERROR;
ipfint idmy;
double ddmy;
F77_FUNC(pardiso,PARDISO)(PT_, &MAXFCT_, &MNUM_, &MTYPE_, &PHASE, &N,
&ddmy, &idmy, &idmy, &idmy, &NRHS, IPARM_,
&MSGLVL_, &ddmy, &ddmy, &ERROR, DPARM_) ;
DBG_ASSERT(ERROR==0);
}
// Reset all private data
dim_=0;
nonzeros_=0;
have_symbolic_factorization_=false;
initialized_=false;
delete[] a_;
a_ = NULL;
#ifdef HAVE_PARDISO_OLDINTERFACE
THROW_EXCEPTION(OPTION_INVALID, "The inexact version works only with a new version of Pardiso (at least 4.0)");
#endif
// Call Pardiso's initialization routine
IPARM_[0] = 0; // Tell it to fill IPARM with default values(?)
ipfint ERROR = 0;
ipfint SOLVER = 1; // initialze only direct solver
F77_FUNC(pardisoinit,PARDISOINIT)(PT_, &MTYPE_, &SOLVER,
IPARM_, DPARM_, &ERROR);
// Set some parameters for Pardiso
IPARM_[0] = 1; // Don't use the default values
#if defined(HAVE_PARDISO_PARALLEL) || ! defined(HAVE_PARDISO)
// Obtain the numbers of processors from the value of OMP_NUM_THREADS
char *var = getenv("OMP_NUM_THREADS");
int num_procs = 1;
if (var != NULL) {
sscanf( var, "%d", &num_procs );
if (num_procs < 1) {
Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA,
"Invalid value for OMP_NUM_THREADS (\"%s\").\n", var);
return false;
}
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"Using environment OMP_NUM_THREADS = %d as the number of processors.\n", num_procs);
}
#ifdef HAVE_PARDISO
// If we run Pardiso through the linear solver loader,
// we do not know whether it is the parallel version, so we do not report an error if OMP_NUM_THREADS is not set.
else {
Jnlst().Printf(J_ERROR, J_LINEAR_ALGEBRA,
"You need to set environment variable OMP_NUM_THREADS to the number of processors used in Pardiso (e.g., 1).\n\n");
return false;
}
#endif
IPARM_[2] = num_procs; // Set the number of processors
#else
IPARM_[2] = 1;
#endif
IPARM_[1] = 5;
IPARM_[5] = 1; // Overwrite right-hand side
// ToDo: decide if we need iterative refinement in Pardiso. For
// now, switch it off ?
IPARM_[7] = 0;
// Options suggested by Olaf Schenk
IPARM_[9] = 12;
IPARM_[10] = 2; // Results in better scaling
// Matching information: IPARM_[12] = 1 seems ok, but results in a
// large number of pivot perturbation
// Matching information: IPARM_[12] = 2 robust, but more expensive method
IPARM_[12] = (int)match_strat_;
Jnlst().Printf(J_DETAILED, J_LINEAR_ALGEBRA,
"Pardiso matching strategy (IPARM(13)): %d\n", IPARM_[12]);
IPARM_[20] = 3; // Results in better accuracy
IPARM_[23] = 1; // parallel fac
IPARM_[24] = 1; // parallel solve
IPARM_[28] = 0; // 32-bit factorization
IPARM_[29] = 1; // we need this for IPOPT interface
IPARM_[31] = 1 ; // iterative solver
MSGLVL_ = pardiso_msglvl;
pardiso_iter_dropping_factor_used_ = pardiso_iter_dropping_factor_;
pardiso_iter_dropping_schur_used_ = pardiso_iter_dropping_schur_;
normal_pardiso_iter_dropping_factor_used_ = normal_pardiso_iter_dropping_factor_;
normal_pardiso_iter_dropping_schur_used_ = normal_pardiso_iter_dropping_schur_;
// TODO Make option
decr_factor_ = 1./3.;
// Option for the out of core variant
// IPARM_[49] = pardiso_out_of_core_power;
SetIpoptCallbackFunction(&IpoptTerminationTest);
bool retval = normal_tester_->Initialize(Jnlst(), IpNLP(), IpData(),
IpCq(), options, prefix);
if (retval) {
retval = pd_tester_->Initialize(Jnlst(), IpNLP(), IpData(),
IpCq(), options, prefix);
}
return retval;
}