44 #ifndef ROL_BOUNDS_DEF_H
45 #define ROL_BOUNDS_DEF_H
58 template<
typename Real>
60 : scale_(scale), feasTol_(feasTol), mask_(x.clone()), min_diff_(
ROL_INF<Real>()) {
75 template<
typename Real>
77 const Real scale,
const Real feasTol)
78 : scale_(scale), feasTol_(feasTol), mask_(x_lo->clone()) {
81 const Real half(0.5), one(1);
90 template<
typename Real>
92 struct Lesser :
public Elementwise::BinaryFunction<Real> {
93 Real
apply(
const Real &xc,
const Real &yc)
const {
return xc<yc ? xc : yc; }
96 struct Greater :
public Elementwise::BinaryFunction<Real> {
97 Real
apply(
const Real &xc,
const Real &yc)
const {
return xc>yc ? xc : yc; }
108 template<
typename Real>
113 class LowerFeasible :
public Elementwise::BinaryFunction<Real> {
118 LowerFeasible(
const Real eps,
const Real diff)
119 : eps_(eps), diff_(diff) {}
120 Real
apply(
const Real &xc,
const Real &yc )
const {
121 const Real tol =
static_cast<Real
>(100)*ROL_EPSILON<Real>();
123 Real val = ((yc <-tol) ? yc*(one-eps_)
124 : ((yc > tol) ? yc*(one+eps_)
126 val = std::min(yc+eps_*diff_, val);
127 return xc < val ? val : xc;
130 x.
applyBinary(LowerFeasible(feasTol_,min_diff_), *lower_);
134 class UpperFeasible :
public Elementwise::BinaryFunction<Real> {
139 UpperFeasible(
const Real eps,
const Real diff)
140 : eps_(eps), diff_(diff) {}
141 Real
apply(
const Real &xc,
const Real &yc )
const {
142 const Real tol =
static_cast<Real
>(100)*ROL_EPSILON<Real>();
144 Real val = ((yc <-tol) ? yc*(one+eps_)
145 : ((yc > tol) ? yc*(one-eps_)
147 val = std::max(yc-eps_*diff_, val);
148 return xc > val ? val : xc;
151 x.
applyBinary(UpperFeasible(feasTol_,min_diff_), *upper_);
155 template<
typename Real>
158 Real one(1), epsn(std::min(scale_*eps,static_cast<Real>(0.1)*min_diff_));
168 template<
typename Real>
171 Real one(1), epsn(std::min(scale_*xeps,static_cast<Real>(0.1)*min_diff_));
177 mask_->applyBinary(op,g);
183 template<
typename Real>
186 Real one(1), epsn(std::min(scale_*eps,static_cast<Real>(0.1)*min_diff_));
189 mask_->axpy(-one,*lower_);
196 template<
typename Real>
199 Real one(1), epsn(std::min(scale_*xeps,static_cast<Real>(0.1)*min_diff_));
202 mask_->axpy(-one,*lower_);
205 mask_->applyBinary(op,g);
211 template<
typename Real>
213 const Real half(0.5);
214 bool flagU =
false, flagL =
false;
217 mask_->applyBinary(isGreater_,*upper_);
218 flagU = mask_->reduce(maximum_) > half ?
true :
false;
222 mask_->applyBinary(isGreater_,v);
223 flagL = mask_->reduce(maximum_) > half ?
true :
false;
225 return ((flagU || flagL) ?
false :
true);
228 template<
typename Real>
232 const Real
zero(0), one(1);
244 d.
axpy(-one,*upper_);
247 d.
axpy(-one,*lower_);
250 mask_->axpy(-one,*lower_);
251 mask_->applyBinary(Elementwise::Min<Real>(),g);
253 mask_->axpy(-one,*upper_);
256 mask_->applyBinary(Elementwise::Min<Real>(),d);
260 mask_->setScalar(one);
265 mask_->applyUnary(Elementwise::AbsoluteValue<Real>());
266 d.
applyBinary(Elementwise::Multiply<Real>(),*mask_);
273 mask_->axpy(-one,*lower_);
275 mask_->applyBinary(Elementwise::Min<Real>(),*upper_);
283 mask_->axpy(-one,*lower_);
284 mask_->applyUnary(buildC_);
288 template<
typename Real>
291 dv.
applyBinary(Elementwise::DivideAndInvert<Real>(),v);
294 template<
typename Real>
296 const Real one(1), two(2), three(3);
303 mask_->axpy(-one,*lower_);
304 mask_->applyUnary(buildC_);
305 mask_->axpy(-one,dv);
309 mask_->setScalar(three);
310 dv.
applyBinary(Elementwise::Multiply<Real>(),*mask_);
311 dv.
axpy(-one,*mask_);
315 mask_->applyUnary(Elementwise::Sign<Real>());
320 mask_->plus(*lower_);
322 mask_->applyUnary(Elementwise::Sign<Real>());
326 mask_->setScalar(one);
Ptr< Vector< Real > > upper_
virtual ROL::Ptr< Vector > clone() const =0
Clone to make a new (uninitialized) vector.
virtual void plus(const Vector &x)=0
Compute , where .
virtual void axpy(const Real alpha, const Vector &x)
Compute where .
void activateLower(void)
Turn on lower bound.
virtual void applyBinary(const Elementwise::BinaryFunction< Real > &f, const Vector &x)
void pruneUpperActive(Vector< Real > &v, const Vector< Real > &x, Real eps=Real(0)) override
Set variables to zero if they correspond to the upper -active set.
Defines the linear algebra or vector space interface.
Objective_SerialSimOpt(const Ptr< Obj > &obj, const V &ui) z0_ zero()
void project(Vector< Real > &x) override
Project optimization variables onto the bounds.
Elementwise::ReductionMin< Real > minimum_
void activateUpper(void)
Turn on upper bound.
Ptr< Vector< Real > > lower_
virtual void setScalar(const Real C)
Set where .
Bounds(const Vector< Real > &x, bool isLower=true, Real scale=1, Real feasTol=std::sqrt(ROL_EPSILON< Real >()))
void buildScalingFunction(Vector< Real > &d, const Vector< Real > &x, const Vector< Real > &g) const
bool isFeasible(const Vector< Real > &v) override
Check if the vector, v, is feasible.
Provides the interface to apply upper and lower bound constraints.
ROL::DiagonalOperator apply
virtual void set(const Vector &x)
Set where .
void applyInverseScalingFunction(Vector< Real > &dv, const Vector< Real > &v, const Vector< Real > &x, const Vector< Real > &g) const override
Apply inverse scaling function.
Ptr< Vector< Real > > mask_
void projectInterior(Vector< Real > &x) override
Project optimization variables into the interior of the feasible set.
void pruneLowerActive(Vector< Real > &v, const Vector< Real > &x, Real eps=Real(0)) override
Set variables to zero if they correspond to the lower -active set.
void applyScalingFunctionJacobian(Vector< Real > &dv, const Vector< Real > &v, const Vector< Real > &x, const Vector< Real > &g) const override
Apply scaling function Jacobian.