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; }