main(int argc, char* argv[]) {
int p[n], i, j, k;
double a[n][n], mu, t;
initmatrix(a, 5.0);
printmatrix(a);
for (k = 0; k<=n-2; k+=1) {
p[k] = k;
mu = abs(a[k][k]);
for (i = k+1; i <= n-1; i+=1) {
if (mu < abs(a[i][ k])) {
mu = abs(a[i][k]);
p[k] = i;
}
}
for (j = k; j <= n-1; j+=1) {
t = a[k][j];
a[k][j] = a[p[k]][j];
a[p[k]][j] = t;
}
for (i = k+1; i <= n-1; i+=1) {
a[i][k] = a[i][k]/a[k][k];
}
for (j = k+1; j <=n-1; j+=1) {
for (i = k+1; i <=n-1; i+=1) {
a[i][j] = a[i][j] - a[i][k]*a[k][j];
}
}
}
printmatrix(a);
}
int main()
{
matrix m, n, r, t;
m = initmatrix(4,5);
printf("matrix m:\n");
printMatrix(&m);
n = initmatrix(4,4);
unitMatrix(&n);
printf("matrix n:\n");
printMatrix(&n);
r = initmatrix(6,6);
unitMatrix(&r);
printf("matrix r:\n");
printMatrix(&r);
t = initmatrix(6,6);
// t = initMatrix(6,6);
printf("enter row num: ");
int rown, coln, val;
scanf("%d", &rown);
printf("\nenter col num: ");
scanf("%d", &coln);
printf("\nenter value: ");
scanf("%d", &val);
if (rown >= 6 || coln >= 6)
{
printf("row or col number out of bounds!\n");
return 1;
}
t.data[rown][coln] = val;
//t.data[2][2] = 1;
printf("matrix t:\n");
printMatrix(&t);
}
void inline MATRIX7 (struct timespec *ts, struct timespec *te){
register int *matrix_ptr;
/* ### starts measuring ### */
rdtscb_getticks ( ts );
initmatrix();
/* ### ends measuring ### */
rdtscb_getticks ( te );
}
/* The main thing - compute the nmf */
int gsl_matrix_nmf(gsl_matrix *v, int cols, gsl_matrix **w, gsl_matrix **h)
{
double dist = 1;
int iter = 1;
double min, max;
#ifdef DEBUG
printf("\nCols: %d\nv:\n", cols);
pp(v);
#endif
gsl_matrix_minmax(v, &min, &max);
#ifdef DEBUG
printf("Min: %f, Max: %f\n", min, max);
#endif
*w = gsl_matrix_alloc(v->size1, cols);
initmatrix(*w, min, max/2); // the multiplicative rules tend to increase w
*h = gsl_matrix_alloc(cols, v->size2);
initmatrix(*h, min, max);
while(dist >= THRESH && iter < MAXITER)
{
dist = update(v, *w, *h);
#ifdef DEBUG
printf("Iteration: %d, distance: %f\n", iter, dist);
printf("\nw:\n");
pp(*w);
printf("\nh:\n");
pp(*h);
printf("\n");
#endif
iter++;
}
#ifdef DEBUG
printf("Ended\n");
#endif
return GSL_SUCCESS;
}
int readmatrix(FILE* infile, _MATRIX* mx){
uint32_t i;
fread(&mx->header,sizeof(MATRIX_HEADER),1,infile);
if(memcmp(mx->header.sig,MATRIX_MAGIC,8)){
return ERR_NOTAMATRIX;
}
if(initmatrix(mx)!=ERR_OK){
return ERR_OUTOFMEM;
}
for(i=0;i<mx->header.height;i++){
fread(mx->data[i],sizeof(double),mx->header.width,infile);
}
return ERR_OK;
}
int main (int argc, char *argv[])
{
/*************************
* Initialisation de MPI *
*************************/
boost::mpi::environment env(argc, argv, MPI_THREAD_MULTIPLE, true);
boost::mpi::communicator world;
/****************************
* Il faut au moins 4 nœuds *
****************************/
const size_t ALL = world.size();
const size_t RANK = world.rank();
/************************
* Initialisation de EO *
************************/
eoParser parser(argc, argv);
eoState state; // keeps all things allocated
dim::core::State state_dim; // keeps all things allocated
/*****************************
* Definition des paramètres *
*****************************/
bool sync = parser.createParam(bool(true), "sync", "sync", 0, "Islands Model").value();
bool smp = parser.createParam(bool(true), "smp", "smp", 0, "Islands Model").value();
unsigned nislands = parser.createParam(unsigned(4), "nislands", "Number of islands (see --smp)", 0, "Islands Model").value();
// a
double alphaP = parser.createParam(double(0.2), "alpha", "Alpha Probability", 'a', "Islands Model").value();
double alphaF = parser.createParam(double(0.01), "alphaF", "Alpha Fitness", 'A', "Islands Model").value();
// b
double betaP = parser.createParam(double(0.01), "beta", "Beta Probability", 'b', "Islands Model").value();
// d
double probaSame = parser.createParam(double(100./(smp ? nislands : ALL)), "probaSame", "Probability for an individual to stay in the same island", 'd', "Islands Model").value();
// I
bool initG = parser.createParam(bool(true), "initG", "initG", 'I', "Islands Model").value();
bool update = parser.createParam(bool(true), "update", "update", 'U', "Islands Model").value();
bool feedback = parser.createParam(bool(true), "feedback", "feedback", 'F', "Islands Model").value();
bool migrate = parser.createParam(bool(true), "migrate", "migrate", 'M', "Islands Model").value();
unsigned nmigrations = parser.createParam(unsigned(1), "nmigrations", "Number of migrations to do at each generation (0=all individuals are migrated)", 0, "Islands Model").value();
unsigned stepTimer = parser.createParam(unsigned(1000), "stepTimer", "stepTimer", 0, "Islands Model").value();
bool deltaUpdate = parser.createParam(bool(true), "deltaUpdate", "deltaUpdate", 0, "Islands Model").value();
bool deltaFeedback = parser.createParam(bool(true), "deltaFeedback", "deltaFeedback", 0, "Islands Model").value();
double sensitivity = 1 / parser.createParam(double(1.), "sensitivity", "sensitivity of delta{t} (1/sensitivity)", 0, "Islands Model").value();
std::string rewardStrategy = parser.createParam(std::string("avg"), "rewardStrategy", "Strategy of rewarding: best or avg", 0, "Islands Model").value();
std::vector<double> rewards(smp ? nislands : ALL, 1.);
std::vector<double> timeouts(smp ? nislands : ALL, 1.);
for (size_t i = 0; i < (smp ? nislands : ALL); ++i)
{
std::ostringstream ss;
ss << "reward" << i;
rewards[i] = parser.createParam(double(1.), ss.str(), ss.str(), 0, "Islands Model").value();
ss.str("");
ss << "timeout" << i;
timeouts[i] = parser.createParam(double(1.), ss.str(), ss.str(), 0, "Islands Model").value();
}
/*********************************
* Déclaration des composants EO *
*********************************/
unsigned chromSize = parser.getORcreateParam(unsigned(0), "chromSize", "The length of the bitstrings", 'n',"Problem").value();
eoInit<EOT>& init = dim::do_make::genotype(parser, state, EOT(), 0);
eoEvalFunc<EOT>* ptEval = NULL;
ptEval = new SimulatedEval( rewards[RANK] );
state.storeFunctor(ptEval);
eoEvalFuncCounter<EOT> eval(*ptEval);
unsigned popSize = parser.getORcreateParam(unsigned(100), "popSize", "Population Size", 'P', "Evolution Engine").value();
dim::core::Pop<EOT>& pop = dim::do_make::detail::pop(parser, state, init);
double targetFitness = parser.getORcreateParam(double(1000), "targetFitness", "Stop when fitness reaches",'T', "Stopping criterion").value();
unsigned maxGen = parser.getORcreateParam(unsigned(0), "maxGen", "Maximum number of generations () = none)",'G',"Stopping criterion").value();
dim::continuator::Base<EOT>& continuator = dim::do_make::continuator<EOT>(parser, state, eval);
dim::core::IslandData<EOT> data(smp ? nislands : -1);
std::string monitorPrefix = parser.getORcreateParam(std::string("result"), "monitorPrefix", "Monitor prefix filenames", '\0', "Output").value();
dim::utils::CheckPoint<EOT>& checkpoint = dim::do_make::checkpoint<EOT>(parser, state, continuator, data, 1, stepTimer);
/**************
* EO routine *
**************/
make_parallel(parser);
make_verbose(parser);
make_help(parser);
if (!smp) // no smp enabled use mpi instead
{
/****************************************
* Distribution des opérateurs aux iles *
****************************************/
eoMonOp<EOT>* ptMon = NULL;
if (sync)
{
ptMon = new DummyOp;
}
else
{
ptMon = new SimulatedOp( timeouts[RANK] );
}
state.storeFunctor(ptMon);
/**********************************
* Déclaration des composants DIM *
**********************************/
dim::core::ThreadsRunner< EOT > tr;
dim::evolver::Easy<EOT> evolver( /*eval*/*ptEval, *ptMon, false );
dim::feedbacker::Base<EOT>* ptFeedbacker = NULL;
if (feedback)
{
if (sync)
{
ptFeedbacker = new dim::feedbacker::sync::Easy<EOT>(alphaF);
}
else
{
ptFeedbacker = new dim::feedbacker::async::Easy<EOT>(alphaF, sensitivity, deltaFeedback);
}
}
else
{
ptFeedbacker = new dim::algo::Easy<EOT>::DummyFeedbacker();
}
state_dim.storeFunctor(ptFeedbacker);
dim::vectorupdater::Base<EOT>* ptUpdater = NULL;
if (update)
{
dim::vectorupdater::Reward<EOT>* ptReward = NULL;
if (rewardStrategy == "best")
{
ptReward = new dim::vectorupdater::Best<EOT>(alphaP, betaP);
}
else
{
ptReward = new dim::vectorupdater::Average<EOT>(alphaP, betaP, sensitivity, sync ? false : deltaUpdate);
}
state_dim.storeFunctor(ptReward);
ptUpdater = new dim::vectorupdater::Easy<EOT>(*ptReward);
}
else
{
ptUpdater = new dim::algo::Easy<EOT>::DummyVectorUpdater();
}
state_dim.storeFunctor(ptUpdater);
dim::memorizer::Easy<EOT> memorizer;
dim::migrator::Base<EOT>* ptMigrator = NULL;
if (migrate)
{
if (sync)
{
ptMigrator = new dim::migrator::sync::Easy<EOT>();
}
else
{
ptMigrator = new dim::migrator::async::Easy<EOT>(nmigrations);
}
}
else
{
ptMigrator = new dim::algo::Easy<EOT>::DummyMigrator();
}
state_dim.storeFunctor(ptMigrator);
dim::algo::Easy<EOT> island( evolver, *ptFeedbacker, *ptUpdater, memorizer, *ptMigrator, checkpoint, monitorPrefix );
if (!sync)
{
tr.addHandler(*ptFeedbacker).addHandler(*ptMigrator).add(island);
}
/***************
* Rock & Roll *
***************/
/******************************************************************************
* Création de la matrice de transition et distribution aux iles des vecteurs *
******************************************************************************/
dim::core::MigrationMatrix probabilities( ALL );
dim::core::InitMatrix initmatrix( initG, probaSame );
if ( 0 == RANK )
{
initmatrix( probabilities );
std::cout << probabilities;
data.proba = probabilities(RANK);
for (size_t i = 1; i < ALL; ++i)
{
world.send( i, 100, probabilities(i) );
}
std::cout << "Island Model Parameters:" << std::endl
<< "alphaP: " << alphaP << std::endl
<< "alphaF: " << alphaF << std::endl
<< "betaP: " << betaP << std::endl
<< "probaSame: " << probaSame << std::endl
<< "initG: " << initG << std::endl
<< "update: " << update << std::endl
<< "feedback: " << feedback << std::endl
<< "migrate: " << migrate << std::endl
<< "sync: " << sync << std::endl
<< "stepTimer: " << stepTimer << std::endl
<< "deltaUpdate: " << deltaUpdate << std::endl
<< "deltaFeedback: " << deltaFeedback << std::endl
<< "sensitivity: " << sensitivity << std::endl
<< "chromSize: " << chromSize << std::endl
<< "popSize: " << popSize << std::endl
<< "targetFitness: " << targetFitness << std::endl
<< "maxGen: " << maxGen << std::endl
;
}
else
{
world.recv( 0, 100, data.proba );
}
/******************************************
* Get the population size of all islands *
******************************************/
world.barrier();
dim::utils::print_sum(pop);
FitnessInit fitInit;
apply<EOT>(fitInit, pop);
if (sync)
{
island( pop, data );
}
else
{
tr( pop, data );
}
world.abort(0);
return 0 ;
}
// smp
/**********************************
* Déclaration des composants DIM *
**********************************/
dim::core::ThreadsRunner< EOT > tr;
std::vector< dim::core::Pop<EOT> > islandPop(nislands);
std::vector< dim::core::IslandData<EOT> > islandData(nislands);
dim::core::MigrationMatrix probabilities( nislands );
dim::core::InitMatrix initmatrix( initG, probaSame );
initmatrix( probabilities );
std::cout << probabilities;
FitnessInit fitInit;
for (size_t i = 0; i < nislands; ++i)
{
std::cout << "island " << i << std::endl;
islandPop[i].append(popSize, init);
apply<EOT>(fitInit, islandPop[i]);
islandData[i] = dim::core::IslandData<EOT>(nislands, i);
std::cout << islandData[i].size() << " " << islandData[i].rank() << std::endl;
islandData[i].proba = probabilities(i);
apply<EOT>(eval, islandPop[i]);
/****************************************
* Distribution des opérateurs aux iles *
****************************************/
eoMonOp<EOT>* ptMon = NULL;
ptMon = new SimulatedOp( timeouts[islandData[i].rank()] );
state.storeFunctor(ptMon);
eoEvalFunc<EOT>* __ptEval = NULL;
__ptEval = new SimulatedEval( rewards[islandData[i].rank()] );
state.storeFunctor(__ptEval);
dim::evolver::Base<EOT>* ptEvolver = new dim::evolver::Easy<EOT>( /*eval*/*__ptEval, *ptMon, false );
state_dim.storeFunctor(ptEvolver);
dim::feedbacker::Base<EOT>* ptFeedbacker = new dim::feedbacker::smp::Easy<EOT>(islandPop, islandData, alphaF);
state_dim.storeFunctor(ptFeedbacker);
dim::vectorupdater::Reward<EOT>* ptReward = NULL;
if (rewardStrategy == "best")
{
ptReward = new dim::vectorupdater::Best<EOT>(alphaP, betaP);
}
else
{
ptReward = new dim::vectorupdater::Average<EOT>(alphaP, betaP, sensitivity, sync ? false : deltaUpdate);
}
state_dim.storeFunctor(ptReward);
dim::vectorupdater::Base<EOT>* ptUpdater = new dim::vectorupdater::Easy<EOT>(*ptReward);
state_dim.storeFunctor(ptUpdater);
dim::memorizer::Base<EOT>* ptMemorizer = new dim::memorizer::Easy<EOT>();
state_dim.storeFunctor(ptMemorizer);
dim::migrator::Base<EOT>* ptMigrator = new dim::migrator::smp::Easy<EOT>(islandPop, islandData, monitorPrefix);
state_dim.storeFunctor(ptMigrator);
dim::utils::CheckPoint<EOT>& checkpoint = dim::do_make::checkpoint<EOT>(parser, state, continuator, islandData[i], 1, stepTimer);
dim::algo::Base<EOT>* ptIsland = new dim::algo::smp::Easy<EOT>( *ptEvolver, *ptFeedbacker, *ptUpdater, *ptMemorizer, *ptMigrator, checkpoint, islandPop, islandData, monitorPrefix );
state_dim.storeFunctor(ptIsland);
ptEvolver->size(nislands);
ptFeedbacker->size(nislands);
ptReward->size(nislands);
ptUpdater->size(nislands);
ptMemorizer->size(nislands);
ptMigrator->size(nislands);
ptIsland->size(nislands);
ptEvolver->rank(i);
ptFeedbacker->rank(i);
ptReward->rank(i);
ptUpdater->rank(i);
ptMemorizer->rank(i);
ptMigrator->rank(i);
ptIsland->rank(i);
tr.add(*ptIsland);
}
tr(pop, data);
return 0 ;
}
