44 #ifndef ROL_OPTIMIZATIONPROBLEM_HPP
45 #define ROL_OPTIMIZATIONPROBLEM_HPP
97 std::vector<Ptr<BatchManager<Real>>>
ecbman_;
99 std::vector<Ptr<BatchManager<Real>>>
icbman_;
106 Ptr<BoundConstraint<Real>>
bnd_;
130 int esize =
static_cast<int>(econ.size());
131 int isize =
static_cast<int>(icon.size());
132 std::vector<Ptr<Constraint<Real>>> cvec;
133 std::vector<Ptr<Vector<Real>>> lvec;
134 std::vector<Ptr<BoundConstraint<Real>>> bvec;
135 for (
int i = 0; i < esize; ++i) {
136 if ( econ[i] != nullPtr ) {
141 cvec.push_back(econ[i]);
143 lvec.push_back(emul[i]);
144 bvec.push_back(nullPtr);
147 for (
int i = 0; i < isize; ++i) {
148 if ( icon[i] != nullPtr ) {
153 cvec.push_back(icon[i]);
155 lvec.push_back(imul[i]);
156 bvec.push_back(ibnd[i]);
160 conManager_ = makePtr<ConstraintManager<Real>>(cvec,lvec,bvec,x,bnd);
165 Ptr<Objective<Real>> obj0;
173 obj_ = makePtr<SlacklessObjective<Real>>(obj0);
180 if(
bnd_ == nullPtr || !
bnd_->isActivated() ) {
188 if(
bnd_ == nullPtr || !
bnd_->isActivated() ) {
201 return makePtr<RiskLessConstraint<Real>>(con);
210 return makePtr<RiskLessObjective<Real>>(obj);
219 int dim = sampler->getMyPoint(0).size(), nsamp = sampler->numMySamples();
220 std::vector<Real> loc(dim), mean(dim), pt(dim);
222 for (
int i = 0; i < nsamp; i++) {
223 pt = sampler->getMyPoint(i);
224 wt = sampler->getMyWeight(i);
225 for (
int j = 0; j < dim; j++) {
229 sampler->sumAll(&loc[0],&mean[0],dim);
257 if (parlistObj_ != nullPtr) {
258 Real statObj = parlistObj_->sublist(
"SOL").get(
"Initial Statistic",1.0);
262 for (
int i = 0; i < nc; ++i) {
263 if (parlistCon_[i] != nullPtr) {
264 Real statCon = parlistCon_[i]->sublist(
"SOL").get(
"Initial Statistic",1.0);
314 std::vector<Ptr<Constraint<Real>>> econ0(1,econ);
315 std::vector<Ptr<Vector<Real>>> emul0(1,emul);
335 std::vector<Ptr<Constraint<Real>>> icon0(1,icon);
336 std::vector<Ptr<Vector<Real>>> imul0(1,imul);
337 std::vector<Ptr<BoundConstraint<Real>>> ibnd0(1,ibnd);
357 std::vector<Ptr<Constraint<Real>>> econ0(1,econ);
358 std::vector<Ptr<Vector<Real>>> emul0(1,emul);
359 std::vector<Ptr<Constraint<Real>>> icon0(1,icon);
360 std::vector<Ptr<Vector<Real>>> imul0(1,imul);
361 std::vector<Ptr<BoundConstraint<Real>>> ibnd0(1,ibnd);
553 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setMeanValueObjective: Objective function value sampler is null!");
582 const bool storage =
true) {
588 if ( gsampler == nullPtr ) {
591 if ( hsampler == nullPtr ) {
596 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setRiskNeutralObjective: Objective function value sampler is null!");
630 if ( gsampler == nullPtr ) {
633 if ( hsampler == nullPtr ) {
638 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setRiskAverseObjective: Objective function value sampler is null!");
658 std::string type = parlist.sublist(
"SOL").get(
"Stochastic Component Type",
"Risk Neutral");
659 if ( type ==
"Risk Neutral" ) {
660 bool storage = parlist.sublist(
"SOL").get(
"Store Sampled Value and Gradient",
true);
663 else if ( type ==
"Risk Averse" ||
664 type ==
"Deviation" ||
667 type ==
"Probability" ) {
670 else if ( type ==
"Mean Value" ) {
674 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setStochasticObjective: Invalid stochastic optimization type!");
687 if (
INPUT_econ_[index] != nullPtr && sampler != nullPtr ) {
694 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setMeanValueEquality: Either SampleGenerator or Constraint is NULL!");
705 const int index = 0) {
710 && xsampler != nullPtr
711 && cbman != nullPtr ) {
713 = makePtr<RiskNeutralConstraint<Real>>(
INPUT_econ_[index],xsampler,cbman);
717 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetRiskNeutralEquality: Either SampleGenerator, Constraint or BatchManager is NULL!");
727 const int index = 0) {
730 if (
INPUT_econ_[index] != nullPtr && sampler != nullPtr ) {
731 int nsamp = sampler->numMySamples();
733 = makePtr<AlmostSureConstraint<Real>>(sampler,
INPUT_econ_[index]);
734 std::vector<Ptr<Vector<Real>>> emul(nsamp,nullPtr);
735 for (
int j = 0; j < nsamp; ++j) {
740 = makePtr<DualSimulatedVector<Real>>(emul, sampler->getBatchManager(), sampler);
743 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetAlmostSureEquality: Either SampleGenerator or Constraint is NULL!");
758 if ( nc != static_cast<int>(xsampler.size()) || nc != static_cast<int>(cbman.size()) ) {
759 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setStochasticEquality: Constraint vector and SampleGenerator vector are not the same size!");
761 for (
int i = 0; i < nc; ++i) {
762 if (xsampler[i] != nullPtr) {
763 std::string type = parlist[i].sublist(
"SOL").get(
"Stochastic Component Type",
"Risk Neutral");
764 if ( type ==
"Risk Neutral" ) {
767 else if ( type ==
"Almost Sure" ) {
770 else if ( type ==
"Mean Value" ) {
774 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetStochasticEquality: Invalid stochastic constraint type!");
792 std::vector<ParameterList> cparlist(1,parlist);
793 std::vector<Ptr<SampleGenerator<Real>>> cxsampler(1,xsampler);
794 std::vector<Ptr<BatchManager<Real>>> ccbman(1,cbman);
800 const int index = 0) {
803 if (
INPUT_icon_[index] != nullPtr && sampler != nullPtr ) {
811 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetMeanValueInequality: Either Constraint or SampleGenerator is NULL!");
822 const int index = 0) {
827 && xsampler != nullPtr
828 && cbman != nullPtr ) {
830 = makePtr<RiskNeutralConstraint<Real>>(
INPUT_icon_[index],xsampler,cbman);
835 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetRiskNeutralInequality: Either Constraint, SampleGenerator or BatchManager is NULL!");
846 const int index = 0) {
849 if (
INPUT_icon_[index] != nullPtr && sampler != nullPtr ) {
853 = makePtr<StochasticConstraint<Real>>(
INPUT_icon_[index],sampler,parlist,index);
858 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetRiskAverseInequality: Either Constraint or SampleGenerator is NULL!");
868 const int index = 0) {
871 if (
INPUT_icon_[index] != nullPtr && sampler != nullPtr ) {
872 int nsamp = sampler->numMySamples();
874 = makePtr<AlmostSureConstraint<Real>>(sampler,
INPUT_icon_[index]);
875 std::vector<Ptr<Vector<Real>>> imul(nsamp,nullPtr);
876 for (
int j = 0; j < nsamp; ++j) {
881 = makePtr<DualSimulatedVector<Real>>(imul, sampler->getBatchManager(), sampler);
883 = makePtr<SimulatedBoundConstraint<Real>>(sampler,
INPUT_ibnd_[index]);
886 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetAlmostSureInequality: Either Constraint or SampleGenerator is NULL!");
900 if ( nc != static_cast<int>(xsampler.size()) || nc != static_cast<int>(cbman.size()) ) {
901 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::setStochasticInequality: Constraint vector and SampleGenerator vector are not the same size!");
903 for (
int i = 0; i < nc; ++i) {
904 if ( xsampler[i] != nullPtr ) {
905 std::string type = parlist[i].sublist(
"SOL").get(
"Stochastic Component Type",
"Risk Neutral");
906 if ( type ==
"Risk Neutral" ) {
909 else if ( type ==
"Risk Averse" ||
910 type ==
"Deviation" ||
913 type ==
"Probability" ) {
916 else if ( type ==
"Almost Sure" ) {
919 else if ( type ==
"Mean Value" ) {
923 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::SetStochasticInequality: Invalid stochastic constraint type!");
942 std::vector<ParameterList> cparlist(1,parlist);
943 std::vector<Ptr<SampleGenerator<Real>>> cxsampler(1,xsampler);
944 std::vector<Ptr<BatchManager<Real>>> ccbman(1,cbman);
959 catch (std::exception &e) {
960 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::getSolutionStatistic: Objective does not have computeStatistic function!");
963 else if (comp == 1) {
965 if (np <= index || index < 0) {
971 catch (std::exception &e) {
972 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::getSolutionStatistic: Constraint does not have computeStatistic function!");
983 Ptr<std::vector<Real>> stat
985 if (stat != nullPtr) {
989 std::vector<Real> empty;
993 catch (std::exception &e) {
994 std::vector<Real> empty;
1001 Ptr<std::vector<Real>> stat
1003 if (stat != nullPtr) {
1007 std::vector<Real> empty;
1011 catch (std::exception &e) {
1012 std::vector<Real> empty;
1028 std::ostream &outStream = std::cout ) {
1032 if (
obj_ != nullPtr) {
1033 outStream <<
"\nPerforming OptimizationProblem diagnostics." << std::endl << std::endl;
1035 outStream <<
"Checking vector operations in optimization vector space X." << std::endl;
1043 std::ostream &outStream = std::cout,
1045 const int order = 1 ) {
1049 if (
obj_ != nullPtr) {
1050 outStream <<
"\nPerforming OptimizationProblem diagnostics." << std::endl << std::endl;
1052 outStream <<
"Checking objective function." << std::endl;
1053 obj_->checkGradient(x,v,
true,outStream,numSteps,order); outStream << std::endl;
1054 obj_->checkHessVec(x,u,
true,outStream,numSteps,order); outStream << std::endl;
1055 obj_->checkHessSym(x,u,v,
true,outStream); outStream << std::endl;
1062 std::ostream &outStream = std::cout ) {
1066 if(
con_ != nullPtr) {
1067 outStream <<
"\nPerforming OptimizationProblem diagnostics." << std::endl << std::endl;
1069 outStream <<
"Checking vector operations in constraint multiplier space C*." << std::endl;
1079 std::ostream &outStream = std::cout,
1081 const int order = 1 ) {
1085 if(
con_ != nullPtr) {
1086 outStream <<
"\nPerforming OptimizationProblem diagnostics." << std::endl << std::endl;
1088 outStream <<
"Checking equality constraint." << std::endl;
1089 con_->checkApplyJacobian(x,v,c,
true,outStream,numSteps,order); outStream << std::endl;
1090 con_->checkAdjointConsistencyJacobian(l,u,x,
true,outStream); outStream << std::endl;
1091 con_->checkApplyAdjointHessian(x,l,v,u,
true,outStream,numSteps,order); outStream << std::endl;
1096 void check( std::ostream &outStream = std::cout,
1098 const int order = 1 ) {
1103 Ptr<Vector<Real>> x, y, u, v;
1105 x =
sol_->clone(); x->randomize();
1106 y =
sol_->clone(); y->randomize();
1107 u =
sol_->clone(); u->randomize();
1108 v =
sol_->clone(); v->randomize();
1113 catch (std::exception &e) {
1117 if(
con_ != nullPtr) {
1118 Ptr<Vector<Real>> c, l, w, q;
1120 c =
mul_->dual().clone(); c->randomize();
1121 l =
mul_->clone(); l->randomize();
1122 w =
mul_->clone(); w->randomize();
1123 q =
mul_->clone(); q->randomize();
1128 catch (std::exception &e) {
1129 throw Exception::NotImplemented(
">>> ROL::OptimizationProblem::check: Elementwise is not implemented for constraint space vectors");
1138 #endif // ROL_OPTIMIZATIONPROBLEM_HPP
Ptr< Vector< Real > > INTERMEDIATE_sol_
Provides the interface to evaluate objective functions.
void setRiskNeutralObjective(const Ptr< SampleGenerator< Real >> &vsampler, const Ptr< SampleGenerator< Real >> &gsampler=nullPtr, const Ptr< SampleGenerator< Real >> &hsampler=nullPtr, const bool storage=true)
Set objective function to risk neutral objective.
Ptr< Constraint< Real > > con_
std::vector< Ptr< Vector< Real > > > INTERMEDIATE_imul_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd)
void checkObjective(Vector< Real > &x, Vector< Real > &u, Vector< Real > &v, std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
std::vector< Ptr< BoundConstraint< Real > > > INPUT_ibnd_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< Constraint< Real >> &econ, const Ptr< Vector< Real >> &emul, const Ptr< Constraint< Real >> &icon, const Ptr< Vector< Real >> &imul, const Ptr< BoundConstraint< Real >> &ibnd)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x)
void setRiskNeutralEquality(const Ptr< SampleGenerator< Real >> &xsampler, const Ptr< BatchManager< Real >> &cbman, const int index=0)
Ptr< SampleGenerator< Real > > hsampler_
std::vector< Ptr< Constraint< Real > > > INTERMEDIATE_econ_
void checkMultiplierVector(Vector< Real > &w, Vector< Real > &q, Vector< Real > &l, std::ostream &outStream=std::cout)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul, const Ptr< Constraint< Real >> &icon, const Ptr< Vector< Real >> &imul, const Ptr< BoundConstraint< Real >> &ibnd)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul, const Ptr< Constraint< Real >> &icon, const Ptr< Vector< Real >> &imul, const Ptr< BoundConstraint< Real >> &ibnd)
void initStochastic(void)
void setRiskNeutralInequality(const Ptr< SampleGenerator< Real >> &xsampler, const Ptr< BatchManager< Real >> &cbman, const int index=0)
std::vector< Ptr< SampleGenerator< Real > > > ixsampler_
virtual Ptr< Objective< Real > > getObjective(void)
void setMeanValueInequality(const Ptr< SampleGenerator< Real >> &sampler, const int index=0)
virtual Ptr< BoundConstraint< Real > > getBoundConstraint(void)
void setStochasticInequality(std::vector< ParameterList > &parlist, const std::vector< Ptr< SampleGenerator< Real >>> &xsampler, const std::vector< Ptr< BatchManager< Real >>> &cbman)
void setStochasticObjective(ParameterList &parlist, const Ptr< SampleGenerator< Real >> &vsampler, const Ptr< SampleGenerator< Real >> &gsampler=nullPtr, const Ptr< SampleGenerator< Real >> &hsampler=nullPtr)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
OptimizationProblem(void)
void setAlmostSureEquality(const Ptr< SampleGenerator< Real >> &sampler, const int index=0)
void setStochasticEquality(std::vector< ParameterList > &parlist, const std::vector< Ptr< SampleGenerator< Real >>> &xsampler, const std::vector< Ptr< BatchManager< Real >>> &cbman)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< Constraint< Real >> &econ, const Ptr< Vector< Real >> &emul, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
virtual std::vector< Real > checkVector(const Vector< Real > &x, const Vector< Real > &y, const bool printToStream=true, std::ostream &outStream=std::cout) const
Verify vector-space methods.
std::vector< Ptr< Vector< Real > > > INTERMEDIATE_emul_
std::vector< Ptr< ParameterList > > parlistCon_
std::vector< Ptr< BoundConstraint< Real > > > INTERMEDIATE_ibnd_
Defines the linear algebra or vector space interface.
std::vector< Ptr< SampleGenerator< Real > > > exsampler_
Ptr< Vector< Real > > INPUT_sol_
Ptr< BoundConstraint< Real > > INPUT_bnd_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul)
void setAlmostSureInequality(const Ptr< SampleGenerator< Real >> &sampler, const int index=0)
std::vector< Ptr< Constraint< Real > > > INTERMEDIATE_icon_
std::vector< Ptr< Constraint< Real > > > INPUT_econ_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const Ptr< Constraint< Real >> &econ, const Ptr< Vector< Real >> &emul)
std::vector< bool > needRiskLessEcon_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
void setMeanValueObjective(const Ptr< SampleGenerator< Real >> &sampler)
Set objective function to mean value objective.
Ptr< Objective< Real > > INPUT_obj_
Real getSolutionStatistic(int comp=0, int index=0)
Returns the statistic from the soluton vector.
void initialize(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
virtual Ptr< Vector< Real > > getSolutionVector(void)
void buildRiskBnd(Ptr< BoundConstraint< Real >> &bnd)
Ptr< Vector< Real > > sol_
Ptr< ConstraintManager< Real > > conManager_
void setMeanValueEquality(const Ptr< SampleGenerator< Real >> &sampler, const int index=0)
Ptr< SampleGenerator< Real > > vsampler_
virtual ~OptimizationProblem(void)
void setRiskAverseObjective(ParameterList &parlist, const Ptr< SampleGenerator< Real >> &vsampler, const Ptr< SampleGenerator< Real >> &gsampler=nullPtr, const Ptr< SampleGenerator< Real >> &hsampler=nullPtr)
Set objective function to risk averse objective.
void checkConstraint(Vector< Real > &x, Vector< Real > &u, Vector< Real > &v, Vector< Real > &c, Vector< Real > &l, std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
Ptr< ParameterList > parlistObj_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const Ptr< Constraint< Real >> &econ, const Ptr< Vector< Real >> &emul, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
virtual Ptr< Vector< Real > > getMultiplierVector(void)
EProblem getProblemType(void)
void setStochasticInequality(ParameterList &parlist, const Ptr< SampleGenerator< Real >> &xsampler, const Ptr< BatchManager< Real >> &cbman)
std::vector< Real > getObjectiveStatistic(void) const
Provides the interface to apply upper and lower bound constraints.
Ptr< BoundConstraint< Real > > bnd_
#define ROL_NUM_CHECKDERIV_STEPS
Number of steps for derivative checks.
std::vector< Real > getConstraintStatistic(const int index=0) const
Ptr< Objective< Real > > obj_
void setRiskAverseInequality(ParameterList &parlist, const Ptr< SampleGenerator< Real >> &sampler, const int index=0)
std::vector< Ptr< Vector< Real > > > INPUT_imul_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const Ptr< Constraint< Real >> &econ, const Ptr< Vector< Real >> &emul, const Ptr< Constraint< Real >> &icon, const Ptr< Vector< Real >> &imul, const Ptr< BoundConstraint< Real >> &ibnd)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< BoundConstraint< Real >> &bnd, const Ptr< Constraint< Real >> &icon, const Ptr< Vector< Real >> &imul, const Ptr< BoundConstraint< Real >> &ibnd)
Ptr< Vector< Real > > mul_
void buildRiskVec(Ptr< Vector< Real >> &x)
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul, const std::vector< Ptr< Constraint< Real >>> &icon, const std::vector< Ptr< Vector< Real >>> &imul, const std::vector< Ptr< BoundConstraint< Real >>> &ibnd)
void checkSolutionVector(Vector< Real > &x, Vector< Real > &y, Vector< Real > &u, std::ostream &outStream=std::cout)
const Ptr< Constraint< Real > > setRiskLessCon(const Ptr< Constraint< Real >> &con, const bool needRiskLess) const
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const std::vector< Ptr< Constraint< Real >>> &econ, const std::vector< Ptr< Vector< Real >>> &emul)
Ptr< SampleGenerator< Real > > gsampler_
void check(std::ostream &outStream=std::cout, const int numSteps=ROL_NUM_CHECKDERIV_STEPS, const int order=1)
std::vector< Ptr< BatchManager< Real > > > ecbman_
Ptr< Objective< Real > > INTERMEDIATE_obj_
void setStochasticEquality(ParameterList &parlist, const Ptr< SampleGenerator< Real >> &xsampler, const Ptr< BatchManager< Real >> &cbman)
std::vector< Ptr< Vector< Real > > > INPUT_emul_
std::vector< Real > computeSampleMean(const Ptr< SampleGenerator< Real >> &sampler) const
std::vector< Ptr< Constraint< Real > > > INPUT_icon_
Defines the general constraint operator interface.
const Ptr< Objective< Real > > setRiskLessObj(const Ptr< Objective< Real >> &obj, const bool needRiskLess) const
std::vector< bool > needRiskLessIcon_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< Constraint< Real >> &icon, const Ptr< Vector< Real >> &imul, const Ptr< BoundConstraint< Real >> &ibnd)
Ptr< BoundConstraint< Real > > INTERMEDIATE_bnd_
virtual Ptr< Constraint< Real > > getConstraint(void)
std::vector< Ptr< BatchManager< Real > > > icbman_
OptimizationProblem(const Ptr< Objective< Real >> &obj, const Ptr< Vector< Real >> &x, const Ptr< Constraint< Real >> &econ, const Ptr< Vector< Real >> &emul)