int main()
{
std::cout << "[moeoNSGAII]" << std::endl;
TestEval eval;
eoPopLoopEval <Solution> popEval(eval);
eoQuadCloneOp < Solution > xover;
eoUniformMutation < Solution > mutation(0.05);
eoRealVectorBounds bounds(1, 1.0, 2.0);
eoRealInitBounded < Solution > init(bounds);
eoPop < Solution > pop(20, init);
eoQuadGenOp <Solution> genOp(xover);
eoSGATransform < Solution > transform(xover, 0.1, mutation, 0.1);
eoGenContinue <Solution > continuator(10);
// build NSGA-II
moeoNSGAII < Solution > algo(20, eval, xover, 1.0, mutation, 1.0);
moeoNSGAII < Solution > algo2(continuator, eval, genOp);
moeoNSGAII < Solution > algo3(continuator, popEval, genOp);
moeoNSGAII < Solution > algo4(continuator, eval, transform);
moeoNSGAII < Solution > algo5(continuator, popEval, transform);
// run the algo
algo(pop);
// final pop
std::cout << "Final population" << std::endl;
std::cout << pop << std::endl;
std::cout << "[moeoNSGAII] OK" << std::endl;
return EXIT_SUCCESS;
}
/* programme principal */
int main()
{
int i;
srand(0);
/* srand(4); */
init_damier(); /* tirage des bombes et comptage des cases */
display_damier();
init_jeu(); /* initialisation table recherche 1 */
i=select_depart(); /* on triche un peu en prenant pour case
de d‚part une case contenant un 0 */
joue_case(i);
algo1();
if (modifie !=0) display_jeu();
for(;;)
{
modifie = 0;
algo2();
if (modifie == 0) break;
display_jeu();
algo1();
if (modifie == 0) break;
display_jeu();
}
printf("fini...\n");
getchar();
return 0;
}
//int main(void){
int main(int argc, char *argv[]){
float startTime, endTime, timeElapsed;
int i;
startTime = (float)clock()/CLOCKS_PER_SEC;
/** Do work **/
for (i=0; i<3; i++){
algo2();
algo3();
}
endTime = (float)clock()/CLOCKS_PER_SEC;
timeElapsed = endTime - startTime;
printf("time elapsed: %f \n", timeElapsed);
}
int main()
{
std::cout << "[moeoSEEA]" << std::endl;
TestEval eval;
eoQuadCloneOp < Solution > xover;
eoUniformMutation < Solution > mutation(0.05);
eoRealVectorBounds bounds(2, 1.0, 2.0);
eoRealInitBounded < Solution > init(bounds);
eoPop < Solution > pop(20, init);
eoQuadGenOp <Solution> genOp(xover);
eoSGATransform < Solution > transform(xover, 0.1, mutation, 0.1);
eoGenContinue <Solution > continuator(20);
moeoUnboundedArchive < Solution > archive;
eoPopLoopEval <Solution> loopEval(eval);
eoPopEvalFunc <Solution>& popEval(loopEval);
// build SEEA
moeoSEEA < Solution > algo1(20, eval, xover, 1.0, mutation, 1.0, archive);
moeoSEEA < Solution > algo2(continuator, eval, genOp, archive);
moeoSEEA < Solution > algo3(continuator, popEval, genOp, archive);
moeoSEEA < Solution > algo4(continuator, eval, transform, archive);
moeoSEEA < Solution > algo5(continuator, popEval, transform, archive);
// run the algo
algo5(pop);
// final archive
std::cout << "Final archive" << std::endl;
std::cout << archive << std::endl;
std::cout << "[moeoSEEA] OK" << std::endl;
return EXIT_SUCCESS;
}
double TimGraph::KptEstimation(){
double ept=algo2();
ept/=2;
return ept;
}
int main(int argc, char* argv[]) {
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<const Teuchos::Comm<int> > comm
= 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 && Teuchos::rank<int>(*comm)==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.xml";
Teuchos::RCP<Teuchos::ParameterList> parlist = Teuchos::rcp( new Teuchos::ParameterList() );
Teuchos::updateParametersFromXmlFile( filename, parlist.ptr() );
RealT initZ = parlist->sublist("Problem Description").get("Initial Control Guess", 0.0);
RealT cvarLevel = parlist->sublist("Problem Description").get("CVaR Level", 0.8);
RealT pfuncSmoothing = parlist->sublist("Problem Description").get("Plus Function Smoothing Parameter", 1e-2);
/**********************************************************************************************/
/************************* CONSTRUCT VECTORS **************************************************/
/**********************************************************************************************/
// Build control vectors
int nx = 256;
Teuchos::RCP<std::vector<RealT> > x1_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
//ROL::StdVector<RealT> x1(x1_rcp);
Teuchos::RCP<ROL::StdVector<RealT> > x1 = Teuchos::rcp(new ROL::StdVector<RealT>(x1_rcp));
Teuchos::RCP<std::vector<RealT> > x2_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
ROL::StdVector<RealT> x2(x2_rcp);
Teuchos::RCP<std::vector<RealT> > x3_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
ROL::StdVector<RealT> x3(x3_rcp);
Teuchos::RCP<std::vector<RealT> > z_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
//ROL::StdVector<RealT> z(z_rcp);
Teuchos::RCP<ROL::StdVector<RealT> > z = Teuchos::rcp(new ROL::StdVector<RealT>(z_rcp));
Teuchos::RCP<std::vector<RealT> > xr_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
ROL::StdVector<RealT> xr(xr_rcp);
Teuchos::RCP<std::vector<RealT> > d_rcp = Teuchos::rcp( new std::vector<RealT>(nx+2,0.0) );
//ROL::StdVector<RealT> d(d_rcp);
Teuchos::RCP<ROL::StdVector<RealT> > d = Teuchos::rcp(new ROL::StdVector<RealT>(d_rcp));
for ( int i = 0; i < nx+2; i++ ) {
(*xr_rcp)[i] = random<RealT>(comm);
(*d_rcp)[i] = random<RealT>(comm);
(*z_rcp)[i] = initZ;
}
ROL::RiskVector<RealT> zR(z,true), x1R(x1,true), dR(d,true);
// Build state and adjoint vectors
Teuchos::RCP<std::vector<RealT> > u_rcp = Teuchos::rcp( new std::vector<RealT>(nx,1.0) );
ROL::StdVector<RealT> u(u_rcp);
Teuchos::RCP<std::vector<RealT> > p_rcp = Teuchos::rcp( new std::vector<RealT>(nx,0.0) );
ROL::StdVector<RealT> p(p_rcp);
Teuchos::RCP<ROL::Vector<RealT> > up = Teuchos::rcp(&u,false);
Teuchos::RCP<ROL::Vector<RealT> > pp = Teuchos::rcp(&p,false);
/**********************************************************************************************/
/************************* CONSTRUCT SOL COMPONENTS *******************************************/
/**********************************************************************************************/
// Build samplers
int dim = 4;
int nSamp = parlist->sublist("Problem Description").get("Number of Samples", 20);
std::vector<RealT> tmp(2,0.0); tmp[0] = -1.0; tmp[1] = 1.0;
std::vector<std::vector<RealT> > bounds(dim,tmp);
Teuchos::RCP<ROL::BatchManager<RealT> > bman
= Teuchos::rcp(new ROL::StdTeuchosBatchManager<RealT,int>(comm));
Teuchos::RCP<ROL::SampleGenerator<RealT> > sampler
= Teuchos::rcp(new ROL::MonteCarloGenerator<RealT>(nSamp,bounds,bman,false,false,100));
/**********************************************************************************************/
/************************* CONSTRUCT OBJECTIVE FUNCTION ***************************************/
/**********************************************************************************************/
// Build risk-averse objective function
RealT alpha = 1.e-3;
Teuchos::RCP<ROL::ParametrizedObjective_SimOpt<RealT> > pobjSimOpt
= Teuchos::rcp(new Objective_BurgersControl<RealT>(alpha,nx));
Teuchos::RCP<ROL::ParametrizedEqualityConstraint_SimOpt<RealT> > pconSimOpt
= Teuchos::rcp(new EqualityConstraint_BurgersControl<RealT>(nx));
Teuchos::RCP<ROL::ParametrizedObjective<RealT> > pObj
= Teuchos::rcp(new ROL::Reduced_ParametrizedObjective_SimOpt<RealT>(pobjSimOpt,pconSimOpt,up,pp));
//Teuchos::RCP<ROL::Objective<RealT> > obj = Teuchos::rcp(new ROL::RiskNeutralObjective<RealT>(pObj, sampler, true));
Teuchos::RCP<ROL::Distribution<RealT> > dist = Teuchos::rcp(new ROL::Parabolic<RealT>(-0.5, 0.5));
Teuchos::RCP<ROL::PlusFunction<RealT> > pfunc = Teuchos::rcp(new ROL::PlusFunction<RealT>(dist, pfuncSmoothing));
Teuchos::RCP<ROL::RiskMeasure<RealT> > rmeas = Teuchos::rcp(new ROL::CVaR<RealT>(cvarLevel, 1.0, pfunc));
Teuchos::RCP<ROL::Objective<RealT> > obj = Teuchos::rcp(new ROL::RiskAverseObjective<RealT>(pObj, rmeas, sampler));
// Test parametrized objective functions
*outStream << "Check Derivatives of Parametrized Objective Function\n";
//x1.set(xr);
x1->set(xr);
pObj->setParameter(sampler->getMyPoint(0));
//pObj->checkGradient(x1,d,true,*outStream);
pObj->checkGradient(*x1,*d,true,*outStream);
//pObj->checkHessVec(x1,d,true,*outStream);
pObj->checkHessVec(*x1,*d,true,*outStream);
//obj->checkGradient(x1,d,true,*outStream);
obj->checkGradient(x1R,dR,true,*outStream);
//obj->checkHessVec(x1,d,true,*outStream);
obj->checkHessVec(x1R,dR,true,*outStream);
ROL::Algorithm<RealT> algors("Trust Region", *parlist);
//algors.run(z, *obj, true, *outStream);
algors.run(zR, *obj, true, *outStream);
/**********************************************************************************************/
/****************** CONSTRUCT SIMULATED CONSTRAINT AND VECTORS ********************************/
/**********************************************************************************************/
// Construct SimulatedEqualityConstraint.
int useW = parlist->sublist("Problem Description").get("Use Constraint Weights", true);
ROL::SimulatedEqualityConstraint<RealT> simcon(sampler, pconSimOpt, useW);
// Construct SimulatedObjective.
ROL::SimulatedObjectiveCVaR<RealT> simobj(sampler, pobjSimOpt, pfunc, cvarLevel);
// Simulated vectors.
std::vector<Teuchos::RCP<ROL::Vector<RealT> > > xu_rcp;
std::vector<Teuchos::RCP<ROL::Vector<RealT> > > vu_rcp;
int nvecloc = sampler->numMySamples();
RealT right = 1, left = 0;
for( int k=0; k<nvecloc; ++k ) {
Teuchos::RCP<std::vector<RealT> > xuk_rcp = Teuchos::rcp( new std::vector<RealT>(nx,1.0) );
Teuchos::RCP<std::vector<RealT> > vuk_rcp = Teuchos::rcp( new std::vector<RealT>(nx,1.0) );
Teuchos::RCP<ROL::Vector<RealT> > xuk = Teuchos::rcp( new ROL::StdVector<RealT>( xuk_rcp ) );
Teuchos::RCP<ROL::Vector<RealT> > vuk = Teuchos::rcp( new ROL::StdVector<RealT>( vuk_rcp ) );
for( int i=0; i<nx; ++i ) {
(*xuk_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
(*vuk_rcp)[i] = ( (RealT)rand() / (RealT)RAND_MAX ) * (right - left) + left;
}
xu_rcp.push_back(xuk);
vu_rcp.push_back(vuk);
}
Teuchos::RCP<ROL::SimulatedVector<RealT> > xu = Teuchos::rcp(new ROL::SimulatedVector<RealT>(xu_rcp, bman));
Teuchos::RCP<ROL::SimulatedVector<RealT> > vu = Teuchos::rcp(new ROL::SimulatedVector<RealT>(vu_rcp, bman));
// SimOpt vectors.
Teuchos::RCP<std::vector<RealT> > zvec_rcp = Teuchos::rcp(new std::vector<RealT>(nx+2,0.0));
Teuchos::RCP<ROL::StdVector<RealT> > zvec = Teuchos::rcp(new ROL::StdVector<RealT>(zvec_rcp));
Teuchos::RCP<std::vector<RealT> > dvec_rcp = Teuchos::rcp(new std::vector<RealT>(nx+2,0.0));
Teuchos::RCP<ROL::StdVector<RealT> > dvec = Teuchos::rcp(new ROL::StdVector<RealT>(dvec_rcp));
for ( int i = 0; i < nx+2; i++ ) {
(*zvec_rcp)[i] = random<RealT>(comm);
(*dvec_rcp)[i] = random<RealT>(comm);
}
Teuchos::RCP<ROL::RiskVector<RealT> > rz = Teuchos::rcp(new ROL::RiskVector<RealT>(zvec, true));
Teuchos::RCP<ROL::RiskVector<RealT> > rd = Teuchos::rcp(new ROL::RiskVector<RealT>(dvec, true));
ROL::Vector_SimOpt<RealT> x(xu, rz);
ROL::Vector_SimOpt<RealT> v(vu, rd);
*outStream << std::endl << "TESTING SimulatedEqualityConstraint" << std::endl;
simcon.checkApplyJacobian(x, v, *vu, true, *outStream);
simcon.checkAdjointConsistencyJacobian(*vu, v, x, *vu, x, true, *outStream);
simcon.checkApplyAdjointHessian(x, *vu, v, x, true, *outStream);
*outStream << std::endl << "TESTING SimulatedObjective" << std::endl;
RealT tol = 1e-8;
simobj.value(x, tol);
simobj.checkGradient(x, v, true, *outStream);
simobj.checkHessVec(x, v, true, *outStream);
ROL::Algorithm<RealT> algo("Composite Step", *parlist);
ROL::Algorithm<RealT> algo2("Composite Step", *parlist);
ROL::Algorithm<RealT> algo3("Composite Step", *parlist);
ROL::Algorithm<RealT> algo4("Composite Step", *parlist);
ROL::Algorithm<RealT> algo5("Composite Step", *parlist);
vu->zero();
for ( int i = 0; i < nx+2; i++ ) {
(*zvec_rcp)[i] = initZ;
}
ROL::SimulatedObjectiveCVaR<RealT> simobjExpval(sampler, pobjSimOpt, pfunc, 0.0);
ROL::SimulatedObjectiveCVaR<RealT> simobjCVaR3(sampler, pobjSimOpt, pfunc, 0.3);
ROL::SimulatedObjectiveCVaR<RealT> simobjCVaR6(sampler, pobjSimOpt, pfunc, 0.6);
ROL::SimulatedObjectiveCVaR<RealT> simobjCVaR7(sampler, pobjSimOpt, pfunc, 0.6);
algo2.run(x, *vu, simobjExpval, simcon, true, *outStream);
algo3.run(x, *vu, simobjCVaR3, simcon, true, *outStream);
algo4.run(x, *vu, simobjCVaR6, simcon, true, *outStream);
algo5.run(x, *vu, simobjCVaR7, simcon, true, *outStream);
algo.run(x, *vu, simobj, simcon, true, *outStream);
// Output control to file.
if (Teuchos::rank<int>(*comm)==0) {
std::ofstream file;
file.open("control-fs-cvar.txt");
for ( int i = 0; i < nx+2; ++i ) {
file << (*zvec_rcp)[i] << "\n";
}
file.close();
}
ROL::RiskVector<RealT> &rxfz = Teuchos::dyn_cast<ROL::RiskVector<RealT> >(*(x.get_2()));
Teuchos::RCP<ROL::Vector<RealT> > rfz = rxfz.getVector();
ROL::StdVector<RealT> &rfz_std = Teuchos::dyn_cast<ROL::StdVector<RealT> >(*rfz);
z->set(rfz_std);
ROL::Algorithm<RealT> algors2("Trust Region", *parlist);
algors2.run(zR, *obj, true, *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;
}
