int main(int argc, char* argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
try {
/**********************************************************************************************/
/************************* CONSTRUCT ROL ALGORITHM ********************************************/
/**********************************************************************************************/
// Get ROL parameterlist
std::string filename = "input_01.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
Teuchos::ParameterList list = *parlist;
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Build vectors
unsigned dim = 4;
Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp( new std::vector<RealT>(dim,0.0) );
Teuchos::RCP<ROL::Vector<RealT> > x = Teuchos::rcp(new ROL::StdVector<RealT>(x_rcp));
Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp( new std::vector<RealT>(dim,0.0) );
Teuchos::RCP<ROL::Vector<RealT> > d = Teuchos::rcp(new ROL::StdVector<RealT>(d_rcp));
setRandomVector(*d_rcp);
// Build samplers
int nSamp = 1000;
unsigned sdim = dim + 2;
std::vector<RealT> tmp(2,0.); tmp[0] = -1.; tmp[1] = 1.;
std::vector<std::vector<RealT> > bounds(sdim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman =
Teuchos::rcp(new ROL::BatchManager<RealT>());
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler =
Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100));
// Build risk-averse objective function
Teuchos::RCP<ROL::ParametrizedObjective<RealT> > pObj =
Teuchos::rcp(new ParametrizedObjectiveEx1<RealT>);
// Build bound constraints
std::vector<RealT> l(dim,0.0);
std::vector<RealT> u(dim,1.0);
Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd =
Teuchos::rcp( new ROL::StdBoundConstraint<RealT>(l,u) );
bnd->deactivate();
// Test parametrized objective functions
*outStream << "Check Derivatives of Parametrized Objective Function\n";
pObj->setParameter(sampler->getMyPoint(0));
pObj->checkGradient(*x,*d,true,*outStream);
pObj->checkHessVec(*x,*d,true,*outStream);
/**********************************************************************************************/
/************************* MEAN VALUE *********************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN VALUE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Mean Value");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* RISK NEUTRAL *******************************************************/
/**********************************************************************************************/
*outStream << "\nRISK NEUTRAL\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Neutral");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS DEVIATION ************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS DEVIATION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation").set("Deviation Type","Absolute");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS VARIANCE *************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS VARIANCE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance").set("Deviation Type","Absolute");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS DEVIATION FROM TARGET ************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS DEVIATION FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation From Target").set("Deviation Type","Absolute");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS VARIANCE FROM TARGET *************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS VARIANCE FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance From Target").set("Deviation Type","Absolute");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIDEVIATION ********************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIDEVIATION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation").set("Deviation Type","Upper");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIVARIANCE *********************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIVARIANCE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance").set("Deviation Type","Upper");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIDEVIATION FROM TARGET ********************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIDEVIATION FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation From Target").set("Deviation Type","Upper");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIVARIANCE FROM TARGET *********************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIVARIANCE FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance From Target").set("Deviation Type","Upper");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS CVAR *****************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS CONDITIONAL VALUE AT RISK\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","CVaR");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS HMCR *****************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS HIGHER MOMENT COHERENT RISK\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","HMCR");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* SMOOTHED CVAR QUADRANGLE *******************************************/
/**********************************************************************************************/
*outStream << "\nQUANTILE-BASED QUADRANGLE RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Quantile-Based Quadrangle");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MIXED-QUANTILE QUADRANGLE ******************************************/
/**********************************************************************************************/
*outStream << "\nMIXED-QUANTILE QUADRANGLE RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mixed-Quantile Quadrangle");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* SUPER QUANTILE QUADRANGLE ******************************************/
/**********************************************************************************************/
*outStream << "\nSUPER QUANTILE QUADRANGLE RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Super Quantile Quadrangle");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* CHEBYSHEV 1 KUSUOKA ************************************************/
/**********************************************************************************************/
*outStream << "\nCHEBYSHEV 1 KUSUOKA RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Chebyshev-Kusuoka");
list.sublist("SOL").sublist("Risk Measure").sublist("Chebyshev-Kusuoka").set("Weight Type",1);
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* CHEBYSHEV 2 KUSUOKA ************************************************/
/**********************************************************************************************/
*outStream << "\nCHEBYSHEV 2 KUSUOKA RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Chebyshev-Kusuoka");
list.sublist("SOL").sublist("Risk Measure").sublist("Chebyshev-Kusuoka").set("Weight Type",2);
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* CHEBYSHEV 3 KUSUOKA ************************************************/
/**********************************************************************************************/
*outStream << "\nCHEBYSHEV 3 KUSUOKA RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Chebyshev-Kusuoka");
list.sublist("SOL").sublist("Risk Measure").sublist("Chebyshev-Kusuoka").set("Weight Type",3);
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* CHEBYSHEV 3 KUSUOKA ************************************************/
/**********************************************************************************************/
*outStream << "\nSINGLETON KUSUOKA RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Singleton Kusuoka");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN-VARIANCE QUADRANGLE *******************************************/
/**********************************************************************************************/
*outStream << "\nMEAN-VARIANCE QUADRANGLE RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean-Variance Quadrangle");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* QUANTILE-RANGE QUADRANGLE ******************************************/
/**********************************************************************************************/
*outStream << "\nQUANTILE-RADIUS QUADRANGLE RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Quantile-Radius Quadrangle");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* CHI-SQUARED DIVERGENCE *********************************************/
/**********************************************************************************************/
*outStream << "\nCHI-SQUARED DIVERGENCE DISTRIBUTIONALLY ROBUST\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Chi-Squared Divergence");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* KL DIVERGENCE ******************************************************/
/**********************************************************************************************/
*outStream << "\nKL DIVERGENCE DISTRIBUTIONALLY ROBUST\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","KL Divergence");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* COHERENT EXPONENTIAL UTILITY FUNCTION ******************************/
/**********************************************************************************************/
*outStream << "\nCOHERENT EXPONENTIAL UTILITY FUNCTION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Coherent Exponential Utility");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* EXPONENTIAL UTILITY FUNCTION ***************************************/
/**********************************************************************************************/
*outStream << "\nEXPONENTIAL UTILITY FUNCTION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Exponential Utility");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* CONVEX COMBINATION OF RISK MEASURES ********************************/
/**********************************************************************************************/
*outStream << "\nCONVEX COMBINATION OF RISK MEASURES\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Convex Combination Risk Measure");
setRandomVector(*x_rcp);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char* argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > commptr =
Teuchos::DefaultComm<int>::getComm();
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0 && commptr->getRank()==0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
try {
/**********************************************************************************************/
/************************* CONSTRUCT ROL ALGORITHM ********************************************/
/**********************************************************************************************/
// Get ROL parameterlist
std::string filename = "input_03.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
Teuchos::ParameterList list = *parlist;
// Build ROL algorithm
Teuchos::RCP<ROL::Algorithm<double> > algo;
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Build vectors
unsigned dim = 4;
Teuchos::RCP<std::vector<double> > x_rcp = Teuchos::rcp( new std::vector<double>(dim,0.0) );
Teuchos::RCP<ROL::Vector<double> > x = Teuchos::rcp(new ROL::StdVector<double>(x_rcp));
Teuchos::RCP<std::vector<double> > d_rcp = Teuchos::rcp( new std::vector<double>(dim,0.0) );
Teuchos::RCP<ROL::Vector<double> > d = Teuchos::rcp(new ROL::StdVector<double>(d_rcp));
setRandomVector(*x_rcp,commptr);
setRandomVector(*d_rcp,commptr);
// Build samplers
int nSamp = 1000;
unsigned sdim = dim + 2;
std::vector<double> tmp(2,0.); tmp[0] = -1.; tmp[1] = 1.;
std::vector<std::vector<double> > bounds(sdim,tmp);
Teuchos::RCP<ROL::BatchManager<double> > bman =
Teuchos::rcp(new ROL::StdTeuchosBatchManager<double,int>(commptr));
Teuchos::RCP<ROL::SampleGenerator<double> > sampler =
Teuchos::rcp(new ROL::MonteCarloGenerator<double>(nSamp,bounds,bman,false,false,100));
// Build risk-averse objective function
Teuchos::RCP<ROL::ParametrizedObjective<double> > pObj =
Teuchos::rcp(new ParametrizedObjectiveEx3<double>);
// Build bound constraints
std::vector<double> l(dim,0.0);
std::vector<double> u(dim,1.0);
Teuchos::RCP<ROL::BoundConstraint<double> > bnd =
Teuchos::rcp( new ROL::StdBoundConstraint<double>(l,u) );
bnd->deactivate();
// Test parametrized objective functions
*outStream << "Check Derivatives of Parametrized Objective Function\n";
pObj->setParameter(sampler->getMyPoint(0));
pObj->checkGradient(*x,*d,true,*outStream);
pObj->checkHessVec(*x,*d,true,*outStream);
/**********************************************************************************************/
/************************* MEAN VALUE *********************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN VALUE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Mean Value");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* RISK NEUTRAL *******************************************************/
/**********************************************************************************************/
*outStream << "\nRISK NEUTRAL\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Neutral");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS DEVIATION ************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS DEVIATION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation").set("Deviation Type","Absolute");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS VARIANCE *************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS VARIANCE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance").set("Deviation Type","Absolute");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS DEVIATION FROM TARGET ************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS DEVIATION FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation From Target").set("Deviation Type","Absolute");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS VARIANCE FROM TARGET *************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS VARIANCE FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance From Target").set("Deviation Type","Absolute");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIDEVIATION ********************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIDEVIATION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation").set("Deviation Type","Upper");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIVARIANCE *********************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIVARIANCE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance").set("Deviation Type","Upper");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIDEVIATION FROM TARGET ********************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIDEVIATION FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Deviation From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Deviation From Target").set("Deviation Type","Upper");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS SEMIVARIANCE FROM TARGET *********************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS SEMIVARIANCE FROM TARGET\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Mean Plus Variance From Target");
list.sublist("SOL").sublist("Risk Measure").sublist("Mean Plus Variance From Target").set("Deviation Type","Upper");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS CVAR *****************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS CONDITIONAL VALUE AT RISK\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","CVaR");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* SMOOTHED CVAR QUADRANGLE *******************************************/
/**********************************************************************************************/
*outStream << "\nQUANTILE-BASED QUADRANGLE RISK MEASURE\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Quantile-Based Quadrangle");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS HMCR *****************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS HIGHER MOMENT COHERENT RISK MEASURE\n";
list.sublist("SOL").sublist("Risk Measure").set("Name","HMCR");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* EXPONENTIAL UTILITY FUNCTION ***************************************/
/**********************************************************************************************/
*outStream << "\nEXPONENTIAL UTILITY FUNCTION\n";
list.sublist("SOL").set("Stochastic Optimization Type","Risk Averse");
list.sublist("SOL").sublist("Risk Measure").set("Name","Exponential Utility");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
/**********************************************************************************************/
/************************* BPOE ***************************************************************/
/**********************************************************************************************/
*outStream << "\nBUFFERED PROBABILITY OF EXCEEDANCE\n";
list.sublist("SOL").set("Stochastic Optimization Type","BPOE");
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
int main(int argc, char* argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > commptr =
Teuchos::DefaultComm<int>::getComm();
// This little trick lets us print to std::cout only if a (dummy) command-line argument is provided.
int iprint = argc - 1;
Teuchos::RCP<std::ostream> outStream;
Teuchos::oblackholestream bhs; // outputs nothing
if (iprint > 0 && commptr->getRank()==0)
outStream = Teuchos::rcp(&std::cout, false);
else
outStream = Teuchos::rcp(&bhs, false);
int errorFlag = 0;
try {
/**********************************************************************************************/
/************************* CONSTRUCT ROL ALGORITHM ********************************************/
/**********************************************************************************************/
// Get ROL parameterlist
std::string filename = "input_07.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
Teuchos::ParameterList list = *parlist;
// Build ROL algorithm
Teuchos::RCP<ROL::Algorithm<RealT> > algo;
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Build vectors
const unsigned dim = 4;
Teuchos::RCP<std::vector<RealT> > x_rcp = Teuchos::rcp(new std::vector<RealT>(dim));
Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp(new std::vector<RealT>(dim));
Teuchos::RCP<ROL::Vector<RealT> > x = Teuchos::rcp(new ROL::StdVector<RealT>(x_rcp));
Teuchos::RCP<ROL::Vector<RealT> > d = Teuchos::rcp(new ROL::StdVector<RealT>(d_rcp));
setRandomVector(*x_rcp,commptr);
setRandomVector(*d_rcp,commptr);
// Build samplers
const RealT zero(0), one(1);
const int nSamp = 1000;
const unsigned sdim = dim + 2;
std::vector<RealT> tmp = {-one, one};
std::vector<std::vector<RealT> > bounds(sdim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman =
Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(commptr));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler =
Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100));
// Build risk-averse objective function
Teuchos::RCP<ROL::ParametrizedObjective<RealT> > pObj =
Teuchos::rcp(new ParametrizedObjectiveEx7<RealT>);
// Build bound constraints
std::vector<RealT> l(dim,zero);
std::vector<RealT> u(dim,one);
Teuchos::RCP<ROL::BoundConstraint<RealT> > bnd =
Teuchos::rcp( new ROL::StdBoundConstraint<RealT>(l,u) );
bnd->deactivate();
// Test parametrized objective functions
*outStream << "Check Derivatives of Parametrized Objective Function\n";
pObj->setParameter(sampler->getMyPoint(0));
pObj->checkGradient(*x,*d,true,*outStream);
pObj->checkHessVec(*x,*d,true,*outStream);
/**********************************************************************************************/
/************************* MEAN PLUS HMCR *****************************************************/
/**********************************************************************************************/
*outStream << "\nMEAN PLUS HIGHER MOMENT COHERENT RISK MEASURE\n";
setRandomVector(*x_rcp,commptr);
setUpAndSolve(list,pObj,sampler,x,d,bnd,*outStream);
printSolution(*x_rcp,*outStream);
}
catch (std::logic_error err) {
*outStream << err.what() << "\n";
errorFlag = -1000;
}; // end try
if (errorFlag != 0)
std::cout << "End Result: TEST FAILED\n";
else
std::cout << "End Result: TEST PASSED\n";
return 0;
}
