44 #ifndef ROL_NEW_CONSTRAINT_MANAGER_DEF_H
45 #define ROL_NEW_CONSTRAINT_MANAGER_DEF_H
49 template<
typename Real>
55 Real tol = std::sqrt(ROL_EPSILON<Real>());
56 con->value(*s,*x,tol);
60 template<
typename Real>
66 Ptr<BoundConstraint<Real>> bnd0;
67 if ( bnd == nullPtr ) {
68 bnd0 = makePtr<BoundConstraint<Real>>(*xprim);
75 psvec_.clear(); psvec_.push_back(xprim);
76 dsvec_.clear(); dsvec_.push_back(xdual);
77 sbnd_.clear(); sbnd_.push_back(bnd0);
78 cvec_.clear(); lvec_.clear(); rvec_.clear();
79 isInequality_.clear();
80 int cnt = 1, cnt_con = 0;
82 hasInequality_ =
false;
83 for (
auto it = input_con.begin(); it != input_con.end(); ++it) {
84 Ptr<Constraint<Real>> con = it->second.constraint;
85 Ptr<Vector<Real>> l = it->second.multiplier;
86 Ptr<Vector<Real>> r = it->second.residual;
87 Ptr<BoundConstraint<Real>> cbnd = it->second.bounds;
89 if ( con->isActivated() ) {
91 isInequality_.push_back(
false);
96 if (cbnd != nullPtr) {
97 if ( cbnd->isActivated() ) {
99 isInequality_.back() =
true;
101 psvec_.push_back(r->clone());
102 dsvec_.push_back(l->clone());
103 initializeSlackVariable(con,cbnd,psvec_[cnt],xprim);
105 sbnd_.push_back(cbnd);
108 hasInequality_ =
true;
118 if ( cnt_con > 1 || hasInequality_ ) {
119 con_ = makePtr<Constraint_Partitioned<Real>>(cvec_,isInequality_);
120 mul_ = makePtr<PartitionedVector<Real>>(lvec_);
121 res_ = makePtr<PartitionedVector<Real>>(rvec_);
135 if ( hasInequality_ ) {
136 xprim_ = makePtr<PartitionedVector<Real>>(psvec_);
137 xdual_ = makePtr<PartitionedVector<Real>>(dsvec_);
138 bnd_ = makePtr<BoundConstraint_Partitioned<Real>>(sbnd_,psvec_);
147 template<
typename Real>
154 Ptr<BoundConstraint<Real>> bnd0;
155 if ( bnd == nullPtr ) {
156 bnd0 = makePtr<BoundConstraint<Real>>(*xprim);
163 psvec_.clear(); psvec_.push_back(xprim);
164 dsvec_.clear(); dsvec_.push_back(xdual);
165 sbnd_.clear(); sbnd_.push_back(bnd0);
166 cvec_.clear(); lvec_.clear(); rvec_.clear();
167 lcvec_.clear(); llvec_.clear(); lrvec_.clear();
168 isInequality_.clear(); isLinearInequality_.clear();
169 int cnt = 1, cnt_con = 0, cnt_lcon = 0;
171 hasInequality_ =
false;
172 for (
auto it = input_con.begin(); it != input_con.end(); ++it) {
173 Ptr<Constraint<Real>> con = it->second.constraint;
174 Ptr<Vector<Real>> l = it->second.multiplier;
175 Ptr<Vector<Real>> r = it->second.residual;
176 Ptr<BoundConstraint<Real>> cbnd = it->second.bounds;
177 if (con != nullPtr) {
178 if ( con->isActivated() ) {
180 isInequality_.push_back(
false);
182 cvec_.push_back(con);
185 if (cbnd != nullPtr) {
186 if ( cbnd->isActivated() ) {
188 isInequality_.back() =
true;
190 psvec_.push_back(r->clone());
191 dsvec_.push_back(l->clone());
192 initializeSlackVariable(con,cbnd,psvec_[cnt],xprim);
194 sbnd_.push_back(cbnd);
197 hasInequality_ =
true;
205 for (
auto it = input_lcon.begin(); it != input_lcon.end(); ++it) {
206 Ptr<Constraint<Real>> con = it->second.constraint;
207 Ptr<Vector<Real>> l = it->second.multiplier;
208 Ptr<Vector<Real>> r = it->second.residual;
209 Ptr<BoundConstraint<Real>> cbnd = it->second.bounds;
210 if (con != nullPtr) {
211 if ( con->isActivated() ) {
213 isLinearInequality_.push_back(
false);
215 lcvec_.push_back(con);
218 if (cbnd != nullPtr) {
219 if ( cbnd->isActivated() ) {
221 isLinearInequality_.back() =
true;
223 psvec_.push_back(r->clone());
224 dsvec_.push_back(l->clone());
225 initializeSlackVariable(con,cbnd,psvec_[cnt],xprim);
227 sbnd_.push_back(cbnd);
230 hasInequality_ =
true;
240 if ( cnt_con > 1 || hasInequality_ ) {
241 con_ = makePtr<Constraint_Partitioned<Real>>(cvec_,isInequality_);
242 mul_ = makePtr<PartitionedVector<Real>>(lvec_);
243 res_ = makePtr<PartitionedVector<Real>>(rvec_);
250 if ( cnt_lcon > 1 || hasInequality_ ) {
251 linear_con_ = makePtr<Constraint_Partitioned<Real>>(lcvec_,isLinearInequality_,cnt_con);
252 linear_mul_ = makePtr<PartitionedVector<Real>>(llvec_);
253 linear_res_ = makePtr<PartitionedVector<Real>>(lrvec_);
256 linear_con_ = lcvec_[0];
257 linear_mul_ = llvec_[0];
258 linear_res_ = lrvec_[0];
265 linear_con_ = nullPtr;
266 linear_mul_ = nullPtr;
267 linear_res_ = nullPtr;
270 if ( hasInequality_ ) {
271 xprim_ = makePtr<PartitionedVector<Real>>(psvec_);
272 xdual_ = makePtr<PartitionedVector<Real>>(dsvec_);
273 bnd_ = makePtr<BoundConstraint_Partitioned<Real>>(sbnd_,psvec_);
282 template<
typename Real>
287 : isNull_(true), hasInequality_(false) {
291 template<
typename Real>
297 : isNull_(true), hasInequality_(false) {
301 template<
typename Real>
306 template<
typename Real>
311 template<
typename Real>
316 template<
typename Real>
321 template<
typename Real>
326 template<
typename Real>
331 template<
typename Real>
336 template<
typename Real>
341 template<
typename Real>
346 template<
typename Real>
351 template<
typename Real>
353 return hasInequality_;
356 template<
typename Real>
358 if (hasInequality_) {
359 int size =
static_cast<int>(cvec_.size());
361 for (
int i = 0; i < size; ++i) {
362 if (isInequality_[i]) {
364 initializeSlackVariable(cvec_[i],sbnd_[cnt],psvec_[cnt],psvec_[0]);
368 size =
static_cast<int>(lcvec_.size());
369 for (
int i = 0; i < size; ++i) {
370 if (isLinearInequality_[i]) {
372 initializeSlackVariable(lcvec_[i],sbnd_[cnt],psvec_[cnt],psvec_[0]);
void resetSlackVariables(void)
const Ptr< Constraint< Real > > getLinearConstraint(void) const
NewConstraintManager(const std::unordered_map< std::string, ConstraintData< Real >> &con, const Ptr< Vector< Real >> &xprim, const Ptr< Vector< Real >> &xdual, const Ptr< BoundConstraint< Real >> &bnd=nullPtr)
Defines the linear algebra or vector space interface.
void initializeSlackVariable(const Ptr< Constraint< Real >> &con, const Ptr< BoundConstraint< Real >> &cbnd, const Ptr< Vector< Real >> &s, const Ptr< Vector< Real >> &x) const
const Ptr< Vector< Real > > getMultiplier(void) const
const Ptr< Vector< Real > > getOptVector(void) const
const Ptr< Vector< Real > > getLinearMultiplier(void) const
bool hasInequality(void) const
void initialize(const std::unordered_map< std::string, ConstraintData< Real >> &input_con, const Ptr< Vector< Real >> &xprim, const Ptr< Vector< Real >> &xdual, const Ptr< BoundConstraint< Real >> &bnd)
const Ptr< Vector< Real > > getDualOptVector(void) const
const Ptr< Vector< Real > > getResidual(void) const
Provides the interface to apply upper and lower bound constraints.
const Ptr< Vector< Real > > getLinearResidual(void) const
const Ptr< Constraint< Real > > getConstraint(void) const
const Ptr< BoundConstraint< Real > > getBoundConstraint(void) const
Defines the general constraint operator interface.