SmartPtr<const Vector> AugRestoSystemSolver::Rhs_cR(const Vector& rhs_c, const SmartPtr<const Vector>& sigma_tilde_n_c_inv, const Vector& rhs_n_c, const SmartPtr<const Vector>& sigma_tilde_p_c_inv, const Vector& rhs_p_c) { DBG_START_METH("AugRestoSystemSolver::Rhs_cR",dbg_verbosity); SmartPtr<Vector> retVec; std::vector<const TaggedObject*> deps(5); std::vector<Number> scalar_deps; deps[0] = &rhs_c; deps[1] = GetRawPtr(sigma_tilde_n_c_inv); deps[2] = &rhs_n_c; deps[3] = GetRawPtr(sigma_tilde_p_c_inv); deps[4] = &rhs_p_c; if (!rhs_cR_cache_.GetCachedResult(retVec, deps, scalar_deps)) { DBG_PRINT((1,"Not found in cache\n")); retVec = rhs_c.MakeNew(); retVec->Copy(rhs_c); SmartPtr<Vector> tmp = retVec->MakeNew(); if (IsValid(sigma_tilde_n_c_inv)) { tmp->Copy(*sigma_tilde_n_c_inv); tmp->ElementWiseMultiply(rhs_n_c); retVec->Axpy(-1.0, *tmp); } if (IsValid(sigma_tilde_p_c_inv)) { tmp->Copy(*sigma_tilde_p_c_inv); tmp->ElementWiseMultiply(rhs_p_c); retVec->Axpy(1.0, *tmp); } rhs_cR_cache_.AddCachedResult(retVec, deps, scalar_deps); } return ConstPtr(retVec); }
SmartPtr<const Vector> AugRestoSystemSolver::Rhs_dR(const Vector& rhs_d, const SmartPtr<const Vector>& sigma_tilde_n_d_inv, const Vector& rhs_n_d, const Matrix& pd_L, const SmartPtr<const Vector>& sigma_tilde_p_d_inv, const Vector& rhs_p_d, const Matrix& neg_pd_U) { DBG_START_METH("AugRestoSystemSolver::Rhs_dR",dbg_verbosity); SmartPtr<Vector> retVec; std::vector<const TaggedObject*> deps(7); std::vector<Number> scalar_deps; deps[0] = &rhs_d; deps[1] = GetRawPtr(sigma_tilde_n_d_inv); deps[2] = &rhs_n_d; deps[3] = &pd_L; deps[4] = GetRawPtr(sigma_tilde_p_d_inv); deps[5] = &rhs_p_d; deps[6] = &neg_pd_U; if (!rhs_dR_cache_.GetCachedResult(retVec, deps, scalar_deps)) { DBG_PRINT((1,"Not found in cache\n")); retVec = rhs_d.MakeNew(); retVec->Copy(rhs_d); if (IsValid(sigma_tilde_n_d_inv)) { SmartPtr<Vector> tmpn = sigma_tilde_n_d_inv->MakeNew(); tmpn->Copy(*sigma_tilde_n_d_inv); tmpn->ElementWiseMultiply(rhs_n_d); pd_L.MultVector(-1.0, *tmpn, 1.0, *retVec); } if (IsValid(sigma_tilde_p_d_inv)) { SmartPtr<Vector> tmpp = sigma_tilde_p_d_inv->MakeNew(); tmpp->Copy(*sigma_tilde_p_d_inv); tmpp->ElementWiseMultiply(rhs_p_d); neg_pd_U.MultVector(-1.0, *tmpp, 1.0, *retVec); } rhs_dR_cache_.AddCachedResult(retVec, deps, scalar_deps); } return ConstPtr(retVec); }
void Vector::AddVectorQuotientImpl(Number a, const Vector& z, const Vector& s, Number c) { DBG_ASSERT(Dim() == z.Dim()); DBG_ASSERT(Dim() == s.Dim()); if (c==0.) { AddOneVector(a, z, 0.); ElementWiseDivide(s); } else { SmartPtr<Vector> tmp = MakeNew(); tmp->Copy(z); tmp->ElementWiseDivide(s); AddOneVector(a, *tmp, c); } }
SmartPtr<const Vector> AugRestoSystemSolver::Neg_Omega_d_plus_D_d( const Matrix& Pd_L, const SmartPtr<const Vector>& sigma_tilde_n_d_inv, const Matrix& neg_Pd_U, const SmartPtr<const Vector>& sigma_tilde_p_d_inv, const Vector* D_d, const Vector& any_vec_in_d) { DBG_START_METH("AugRestoSystemSolver::Neg_Omega_d_plus_D_d",dbg_verbosity); SmartPtr<Vector> retVec; if (IsValid(sigma_tilde_n_d_inv) || IsValid(sigma_tilde_p_d_inv) || D_d) { std::vector<const TaggedObject*> deps(5); std::vector<Number> scalar_deps; deps[0] = &Pd_L; deps[1] = GetRawPtr(sigma_tilde_n_d_inv); deps[2] = &neg_Pd_U; deps[3] = GetRawPtr(sigma_tilde_p_d_inv); deps[4] = D_d; if (!neg_omega_d_plus_D_d_cache_. GetCachedResult(retVec, deps, scalar_deps)) { DBG_PRINT((1,"Not found in cache\n")); retVec = any_vec_in_d.MakeNew(); retVec->Set(0.0); if (IsValid(sigma_tilde_n_d_inv)) { Pd_L.MultVector(-1.0, *sigma_tilde_n_d_inv, 1.0, *retVec); } if (IsValid(sigma_tilde_p_d_inv)) { neg_Pd_U.MultVector(1.0, *sigma_tilde_p_d_inv, 1.0, *retVec); } if (D_d) { retVec->Copy(*D_d); } neg_omega_d_plus_D_d_cache_. AddCachedResult(retVec, deps, scalar_deps); } } return ConstPtr(retVec); }
SmartPtr<const Vector> AugRestoSystemSolver::Sigma_tilde_n_c_inv( const SmartPtr<const Vector>& sigma_n_c, Number delta_x, const Vector& any_vec_in_c) { DBG_START_METH("AugRestoSystemSolver::Sigma_tilde_n_c_inv",dbg_verbosity); SmartPtr<Vector> retVec; if (IsValid(sigma_n_c) || delta_x != 0.0) { std::vector<const TaggedObject*> deps(1); std::vector<Number> scalar_deps(1); deps[0] = GetRawPtr(sigma_n_c); scalar_deps[0] = delta_x; if (!sigma_tilde_n_c_inv_cache_.GetCachedResult(retVec, deps, scalar_deps)) { DBG_PRINT((1,"Not found in cache\n")); retVec = any_vec_in_c.MakeNew(); if (IsValid(sigma_n_c)) { if (delta_x != 0.) { retVec->Copy(*sigma_n_c); retVec->AddScalar(delta_x); retVec->ElementWiseReciprocal(); } else { // Given a "homogenous vector" implementation (such as in // DenseVector) the following should be more efficient retVec->Set(1.); retVec->ElementWiseDivide(*sigma_n_c); } } else { retVec->Set(1./delta_x); } sigma_tilde_n_c_inv_cache_.AddCachedResult(retVec, deps, scalar_deps); } } return ConstPtr(retVec); }
SmartPtr<const Vector> AugRestoSystemSolver::Sigma_tilde_p_d_inv( const SmartPtr<const Vector>& sigma_p_d, Number delta_x, const Vector& any_vec_in_p_d) { DBG_START_METH("AugRestoSystemSolver::Sigma_tilde_p_d_inv",dbg_verbosity); SmartPtr<Vector> retVec; if (IsValid(sigma_p_d) || delta_x != 0) { std::vector<const TaggedObject*> deps(1); std::vector<Number> scalar_deps(1); deps[0] = GetRawPtr(sigma_p_d); scalar_deps[0] = delta_x; if (!sigma_tilde_p_d_inv_cache_.GetCachedResult(retVec, deps, scalar_deps)) { DBG_PRINT((1,"Not found in cache\n")); retVec = any_vec_in_p_d.MakeNew(); if (IsValid(sigma_p_d)) { if (delta_x != 0.) { retVec->Copy(*sigma_p_d); retVec->AddScalar(delta_x); retVec->ElementWiseReciprocal(); } else { retVec->Set(1.); retVec->ElementWiseDivide(*sigma_p_d); } } else { retVec->Set(1./delta_x); } sigma_tilde_p_d_inv_cache_.AddCachedResult(retVec, deps, scalar_deps); } } return ConstPtr(retVec); }
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; }
/** Use this method to create a new iterates vector with a copy of * all the data. */ SmartPtr<IteratesVector> MakeNewIteratesVectorCopy() const { SmartPtr<IteratesVector> ret = MakeNewIteratesVector(true); ret->Copy(*this); return ret; }
bool RestoIpoptNLP::InitializeStructures( SmartPtr<Vector>& x, bool init_x, SmartPtr<Vector>& y_c, bool init_y_c, SmartPtr<Vector>& y_d, bool init_y_d, SmartPtr<Vector>& z_L, bool init_z_L, SmartPtr<Vector>& z_U, bool init_z_U, SmartPtr<Vector>& v_L, SmartPtr<Vector>& v_U) { DBG_START_METH("RestoIpoptNLP::InitializeStructures", 0); DBG_ASSERT(initialized_); /////////////////////////////////////////////////////////// // Get the vector/matrix spaces for the original problem // /////////////////////////////////////////////////////////// SmartPtr<const VectorSpace> orig_x_space; SmartPtr<const VectorSpace> orig_c_space; SmartPtr<const VectorSpace> orig_d_space; SmartPtr<const VectorSpace> orig_x_l_space; SmartPtr<const MatrixSpace> orig_px_l_space; SmartPtr<const VectorSpace> orig_x_u_space; SmartPtr<const MatrixSpace> orig_px_u_space; SmartPtr<const VectorSpace> orig_d_l_space; SmartPtr<const MatrixSpace> orig_pd_l_space; SmartPtr<const VectorSpace> orig_d_u_space; SmartPtr<const MatrixSpace> orig_pd_u_space; SmartPtr<const MatrixSpace> orig_jac_c_space; SmartPtr<const MatrixSpace> orig_jac_d_space; SmartPtr<const SymMatrixSpace> orig_h_space; orig_ip_nlp_->GetSpaces(orig_x_space, orig_c_space, orig_d_space, orig_x_l_space, orig_px_l_space, orig_x_u_space, orig_px_u_space, orig_d_l_space, orig_pd_l_space, orig_d_u_space, orig_pd_u_space, orig_jac_c_space, orig_jac_d_space, orig_h_space); // Create the restoration phase problem vector/matrix spaces, based // on the original spaces (pretty inconvenient with all the // matrix spaces, isn't it?!?) DBG_PRINT((1, "Creating the x_space_\n")); // vector x Index total_dim = orig_x_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); x_space_ = new CompoundVectorSpace(5, total_dim); x_space_->SetCompSpace(0, *orig_x_space); x_space_->SetCompSpace(1, *orig_c_space); // n_c x_space_->SetCompSpace(2, *orig_c_space); // p_c x_space_->SetCompSpace(3, *orig_d_space); // n_d x_space_->SetCompSpace(4, *orig_d_space); // p_d DBG_PRINT((1, "Setting the c_space_\n")); // vector c //c_space_ = orig_c_space; c_space_ = new CompoundVectorSpace(1, orig_c_space->Dim()); c_space_->SetCompSpace(0, *orig_c_space); DBG_PRINT((1, "Setting the d_space_\n")); // vector d //d_space_ = orig_d_space; d_space_ = new CompoundVectorSpace(1, orig_d_space->Dim()); d_space_->SetCompSpace(0, *orig_d_space); DBG_PRINT((1, "Creating the x_l_space_\n")); // vector x_L total_dim = orig_x_l_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); x_l_space_ = new CompoundVectorSpace(5, total_dim); x_l_space_->SetCompSpace(0, *orig_x_l_space); x_l_space_->SetCompSpace(1, *orig_c_space); // n_c >=0 x_l_space_->SetCompSpace(2, *orig_c_space); // p_c >=0 x_l_space_->SetCompSpace(3, *orig_d_space); // n_d >=0 x_l_space_->SetCompSpace(4, *orig_d_space); // p_d >=0 DBG_PRINT((1, "Setting the x_u_space_\n")); // vector x_U x_u_space_ = new CompoundVectorSpace(1, orig_x_u_space->Dim()); x_u_space_->SetCompSpace(0, *orig_x_u_space); DBG_PRINT((1, "Creating the px_l_space_\n")); // matrix px_l Index total_rows = orig_x_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); Index total_cols = orig_x_l_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); px_l_space_ = new CompoundMatrixSpace(5, 5, total_rows, total_cols); px_l_space_->SetBlockRows(0, orig_x_space->Dim()); px_l_space_->SetBlockRows(1, orig_c_space->Dim()); px_l_space_->SetBlockRows(2, orig_c_space->Dim()); px_l_space_->SetBlockRows(3, orig_d_space->Dim()); px_l_space_->SetBlockRows(4, orig_d_space->Dim()); px_l_space_->SetBlockCols(0, orig_x_l_space->Dim()); px_l_space_->SetBlockCols(1, orig_c_space->Dim()); px_l_space_->SetBlockCols(2, orig_c_space->Dim()); px_l_space_->SetBlockCols(3, orig_d_space->Dim()); px_l_space_->SetBlockCols(4, orig_d_space->Dim()); px_l_space_->SetCompSpace(0, 0, *orig_px_l_space); // now setup the identity matrix // This could be changed to be something like... // px_l_space_->SetBlockToIdentity(1,1,1.0); // px_l_space_->SetBlockToIdentity(2,2,other_factor); // ... etc with some simple changes to the CompoundMatrixSpace // to allow this (space should auto create the matrices) // // for now, we use the new feature and set the true flag for this block // to say that the matrices should be auto_allocated SmartPtr<const MatrixSpace> identity_mat_space_nc = new IdentityMatrixSpace(orig_c_space->Dim()); px_l_space_->SetCompSpace(1, 1, *identity_mat_space_nc, true); px_l_space_->SetCompSpace(2, 2, *identity_mat_space_nc, true); SmartPtr<const MatrixSpace> identity_mat_space_nd = new IdentityMatrixSpace(orig_d_space->Dim()); px_l_space_->SetCompSpace(3, 3, *identity_mat_space_nd, true); px_l_space_->SetCompSpace(4, 4, *identity_mat_space_nd, true); DBG_PRINT((1, "Creating the px_u_space_\n")); // matrix px_u total_rows = orig_x_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); total_cols = orig_x_u_space->Dim(); DBG_PRINT((1, "total_rows = %d, total_cols = %d\n", total_rows, total_cols)); px_u_space_ = new CompoundMatrixSpace(5, 1, total_rows, total_cols); px_u_space_->SetBlockRows(0, orig_x_space->Dim()); px_u_space_->SetBlockRows(1, orig_c_space->Dim()); px_u_space_->SetBlockRows(2, orig_c_space->Dim()); px_u_space_->SetBlockRows(3, orig_d_space->Dim()); px_u_space_->SetBlockRows(4, orig_d_space->Dim()); px_u_space_->SetBlockCols(0, orig_x_u_space->Dim()); px_u_space_->SetCompSpace(0, 0, *orig_px_u_space); // other matrices are zero'ed out // vector d_L //d_l_space_ = orig_d_l_space; d_l_space_ = new CompoundVectorSpace(1, orig_d_l_space->Dim()); d_l_space_->SetCompSpace(0, *orig_d_l_space); // vector d_U //d_u_space_ = orig_d_u_space; d_u_space_ = new CompoundVectorSpace(1, orig_d_u_space->Dim()); d_u_space_->SetCompSpace(0, *orig_d_u_space); // matrix pd_L //pd_l_space_ = orig_pd_l_space; pd_l_space_ = new CompoundMatrixSpace(1, 1, orig_pd_l_space->NRows(), orig_pd_l_space->NCols()); pd_l_space_->SetBlockRows(0, orig_pd_l_space->NRows()); pd_l_space_->SetBlockCols(0, orig_pd_l_space->NCols()); pd_l_space_->SetCompSpace(0, 0, *orig_pd_l_space); // matrix pd_U //pd_u_space_ = orig_pd_u_space; pd_u_space_ = new CompoundMatrixSpace(1, 1, orig_pd_u_space->NRows(), orig_pd_u_space->NCols()); pd_u_space_->SetBlockRows(0, orig_pd_u_space->NRows()); pd_u_space_->SetBlockCols(0, orig_pd_u_space->NCols()); pd_u_space_->SetCompSpace(0, 0, *orig_pd_u_space); DBG_PRINT((1, "Creating the jac_c_space_\n")); // matrix jac_c total_rows = orig_c_space->Dim(); total_cols = orig_x_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); jac_c_space_ = new CompoundMatrixSpace(1, 5, total_rows, total_cols); jac_c_space_->SetBlockRows(0, orig_c_space->Dim()); jac_c_space_->SetBlockCols(0, orig_x_space->Dim()); jac_c_space_->SetBlockCols(1, orig_c_space->Dim()); jac_c_space_->SetBlockCols(2, orig_c_space->Dim()); jac_c_space_->SetBlockCols(3, orig_d_space->Dim()); jac_c_space_->SetBlockCols(4, orig_d_space->Dim()); jac_c_space_->SetCompSpace(0, 0, *orig_jac_c_space); // **NOTE: By placing "flat" identity matrices here, we are creating // potential issues for linalg operations that arise when the original // NLP has a "compound" c_space. To avoid problems like this, // we place all unmodified component spaces in trivial (size 1) // "compound" spaces. jac_c_space_->SetCompSpace(0, 1, *identity_mat_space_nc, true); jac_c_space_->SetCompSpace(0, 2, *identity_mat_space_nc, true); // remaining blocks are zero'ed DBG_PRINT((1, "Creating the jac_d_space_\n")); // matrix jac_d total_rows = orig_d_space->Dim(); total_cols = orig_x_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); jac_d_space_ = new CompoundMatrixSpace(1, 5, total_rows, total_cols); jac_d_space_->SetBlockRows(0, orig_d_space->Dim()); jac_d_space_->SetBlockCols(0, orig_x_space->Dim()); jac_d_space_->SetBlockCols(1, orig_c_space->Dim()); jac_d_space_->SetBlockCols(2, orig_c_space->Dim()); jac_d_space_->SetBlockCols(3, orig_d_space->Dim()); jac_d_space_->SetBlockCols(4, orig_d_space->Dim()); jac_d_space_->SetCompSpace(0, 0, *orig_jac_d_space); DBG_PRINT((1, "orig_jac_d_space = %x\n", GetRawPtr(orig_jac_d_space))) // Blocks (0,1) and (0,2) are zero'ed out // **NOTE: By placing "flat" identity matrices here, we are creating // potential issues for linalg operations that arise when the original // NLP has a "compound" d_space. To avoid problems like this, // we place all unmodified component spaces in trivial (size 1) // "compound" spaces. jac_d_space_->SetCompSpace(0, 3, *identity_mat_space_nd, true); jac_d_space_->SetCompSpace(0, 4, *identity_mat_space_nd, true); DBG_PRINT((1, "Creating the h_space_\n")); // matrix h total_dim = orig_x_space->Dim() + 2 * orig_c_space->Dim() + 2 * orig_d_space->Dim(); h_space_ = new CompoundSymMatrixSpace(5, total_dim); h_space_->SetBlockDim(0, orig_x_space->Dim()); h_space_->SetBlockDim(1, orig_c_space->Dim()); h_space_->SetBlockDim(2, orig_c_space->Dim()); h_space_->SetBlockDim(3, orig_d_space->Dim()); h_space_->SetBlockDim(4, orig_d_space->Dim()); SmartPtr<DiagMatrixSpace> DR_x_space = new DiagMatrixSpace(orig_x_space->Dim()); if( hessian_approximation_ == LIMITED_MEMORY ) { const LowRankUpdateSymMatrixSpace* LR_h_space = static_cast<const LowRankUpdateSymMatrixSpace*>(GetRawPtr( orig_h_space)); DBG_ASSERT(LR_h_space); SmartPtr<LowRankUpdateSymMatrixSpace> new_orig_h_space = new LowRankUpdateSymMatrixSpace(LR_h_space->Dim(), NULL, orig_x_space, false); h_space_->SetCompSpace(0, 0, *new_orig_h_space, true); } else { SmartPtr<SumSymMatrixSpace> sumsym_mat_space = new SumSymMatrixSpace(orig_x_space->Dim(), 2); sumsym_mat_space->SetTermSpace(0, *orig_h_space); sumsym_mat_space->SetTermSpace(1, *DR_x_space); h_space_->SetCompSpace(0, 0, *sumsym_mat_space, true); // All remaining blocks are zero'ed out } /////////////////////////// // Create the bound data // /////////////////////////// // x_L x_L_ = x_l_space_->MakeNewCompoundVector(); x_L_->SetComp(0, *orig_ip_nlp_->x_L()); // x >= x_L x_L_->GetCompNonConst(1)->Set(0.0); // n_c >= 0 x_L_->GetCompNonConst(2)->Set(0.0); // p_c >= 0 x_L_->GetCompNonConst(3)->Set(0.0); // n_d >= 0 x_L_->GetCompNonConst(4)->Set(0.0); // p_d >= 0 DBG_PRINT_VECTOR(2, "resto_x_L", *x_L_); // x_U x_U_ = x_u_space_->MakeNewCompoundVector(); x_U_->SetComp(0, *orig_ip_nlp_->x_U()); // d_L d_L_ = d_l_space_->MakeNewCompoundVector(); d_L_->SetComp(0, *orig_ip_nlp_->d_L()); // d_U d_U_ = d_u_space_->MakeNewCompoundVector(); d_U_->SetComp(0, *orig_ip_nlp_->d_U()); // Px_L Px_L_ = px_l_space_->MakeNewCompoundMatrix(); Px_L_->SetComp(0, 0, *orig_ip_nlp_->Px_L()); // Identities are auto-created (true flag passed into SetCompSpace) // Px_U Px_U_ = px_u_space_->MakeNewCompoundMatrix(); Px_U_->SetComp(0, 0, *orig_ip_nlp_->Px_U()); // Remaining matrices will be zero'ed out // Pd_L //Pd_L_ = orig_ip_nlp_->Pd_L(); Pd_L_ = pd_l_space_->MakeNewCompoundMatrix(); Pd_L_->SetComp(0, 0, *orig_ip_nlp_->Pd_L()); // Pd_U //Pd_U_ = orig_ip_nlp_->Pd_U(); Pd_U_ = pd_u_space_->MakeNewCompoundMatrix(); Pd_U_->SetComp(0, 0, *orig_ip_nlp_->Pd_U()); // Getting the NLP scaling SmartPtr<const MatrixSpace> scaled_jac_c_space; SmartPtr<const MatrixSpace> scaled_jac_d_space; SmartPtr<const SymMatrixSpace> scaled_h_space; NLP_scaling()->DetermineScaling(GetRawPtr(x_space_), c_space_, d_space_, GetRawPtr(jac_c_space_), GetRawPtr(jac_d_space_), GetRawPtr(h_space_), scaled_jac_c_space, scaled_jac_d_space, scaled_h_space, *Px_L_, *x_L_, *Px_U_, *x_U_); // For now we assume that no scaling is done inside the NLP_Scaling DBG_ASSERT(scaled_jac_c_space == jac_c_space_); DBG_ASSERT(scaled_jac_d_space == jac_d_space_); DBG_ASSERT(scaled_h_space == h_space_); ///////////////////////////////////////////////////////////////////////// // Create and initialize the vectors for the restoration phase problem // ///////////////////////////////////////////////////////////////////////// // Vector x SmartPtr<CompoundVector> comp_x = x_space_->MakeNewCompoundVector(); if( init_x ) { comp_x->GetCompNonConst(0)->Copy(*orig_ip_data_->curr()->x()); comp_x->GetCompNonConst(1)->Set(1.0); comp_x->GetCompNonConst(2)->Set(1.0); comp_x->GetCompNonConst(3)->Set(1.0); comp_x->GetCompNonConst(4)->Set(1.0); } x = GetRawPtr(comp_x); // Vector y_c y_c = c_space_->MakeNew(); if( init_y_c ) { y_c->Set(0.0); // ToDo } // Vector y_d y_d = d_space_->MakeNew(); if( init_y_d ) { y_d->Set(0.0); } // Vector z_L z_L = x_l_space_->MakeNew(); if( init_z_L ) { z_L->Set(1.0); } // Vector z_U z_U = x_u_space_->MakeNew(); if( init_z_U ) { z_U->Set(1.0); } // Vector v_L v_L = d_l_space_->MakeNew(); // Vector v_U v_U = d_u_space_->MakeNew(); // Initialize other data needed by the restoration nlp. x_ref is // the point to reference to which we based the regularization // term x_ref_ = orig_x_space->MakeNew(); x_ref_->Copy(*orig_ip_data_->curr()->x()); dr_x_ = orig_x_space->MakeNew(); dr_x_->Set(1.0); SmartPtr<Vector> tmp = dr_x_->MakeNew(); tmp->Copy(*x_ref_); dr_x_->ElementWiseMax(*tmp); tmp->Scal(-1.); dr_x_->ElementWiseMax(*tmp); dr_x_->ElementWiseReciprocal(); DBG_PRINT_VECTOR(2, "dr_x_", *dr_x_); DR_x_ = DR_x_space->MakeNewDiagMatrix(); DR_x_->SetDiag(*dr_x_); return true; }