void board::generation()
{
srand(time(0));
if (playerone.tosses<5)
{
playerone.x=rand()%10;
playerone.y=rand()%10;
if (pitch[playerone.y][playerone.x]=='P')
{
generation();
}
else
{
system("cls");
scoring();
pitch[playerone.y][playerone.x]='P';
playerone.tosses++;
showboard();
cout<<"Score for that throw "<<playerone.throwscore<<endl;
cout<<"Number of tosses "<<playerone.tosses<<"/5"<<endl;
wait();
system("pause");
generation();
}
}
else
{
system("cls");
}
}
void Worker::internal()
{
try {
reporter->startTiming();
primary();
if(generate) {
update();
generation();
}
reporter->setReturnCode(EXIT_SUCCESS);
#if USE_CGAL
} catch(CGAL::Failure_exception e) {
reporter->reportException(QString::fromStdString(e.what()));
#endif
} catch(...) {
reporter->reportException(tr("Unknown error."));
}
update();
finish();
}
/*
Construct a random dungeon
*/
void buildMap() {
int ii;
int jj;
mapTopX = 0;
mapTopY = 0;
initMap();
generations = 1;
fillprob = 35;
params = params_set = (generation_params*)malloc( sizeof(generation_params) * generations);
params->r1_cutoff = 24;
params->r2_cutoff = 5;
params->reps = 1;
params++;
params->r1_cutoff = 20;
params->r2_cutoff = 3;
params->reps = 1;
params++;
for(ii=0; ii<generations; ii++) {
params = ¶ms_set[ii];
for(jj=0; jj<params->reps; jj++)
generation();
}
free(params);
free(params_set);
}
void Generation::readGenerations(const string &file,
vector<GenerationPtr> &generations) {
XMLPlatformUtils::Initialize();
XercesDOMParser parser;
GenerationErrorHandler handler;
parser.setErrorHandler(&handler);
parser.setEntityResolver(&handler);
parser.parse(file.c_str());
DOMDocument *doc = parser.getDocument();
DOMElement *root = doc->getDocumentElement();
XMLCh tempStr[12];
XMLString::transcode("generation", tempStr, 11);
DOMNodeList *list = root->getElementsByTagName(tempStr);
int length = list->getLength();
for (int i = 0; i < length; ++i) {
DOMElement *item = (DOMElement *)list->item(i);
GenerationPtr generation(new Generation());
generation->m_impl->m_owner = generation.get();
generation->m_impl->getGeneration(item);
generation->m_impl->m_idx = i;
generations.push_back(generation);
}
}
void main_constz() {
string gen_name, det_name, root_name;
string gen_prefix = "events_z";
string det_prefix = "measures_z";
string root_prefix = "reconstruction_z";
string str_buff;
string str_dat = ".dat";
string str_root = ".root";
stringstream ss;
double z_val;
for (int i = 0; i <= 30; i++) {
z_val = double(i);
cout << "Starting analysis with z = " << z_val << "..." << endl;
ss << z_val;
ss >> str_buff;
gen_name = gen_prefix + str_buff;
det_name = det_prefix + str_buff;
root_name = root_prefix + str_buff;
ss.clear();
cout << '\t' << "Generation..." << '\n' << endl;
generation(gen_name.c_str(), "CONST Z");
cout << '\t' << "Detector response..." << '\n' << endl;
detector(gen_name.c_str(), det_name.c_str());
cout << '\t' << "Reconstruction..." << '\n' << endl;
reconstruction(gen_name.c_str(), det_name.c_str(), root_name.c_str());
cout << '\n' << "-------------------------" << '\n' << endl;
}
}
void ParScanClosure::do_oop_work(oop* p,
bool gc_barrier, bool only_two_gens,
bool root_scan,
bool jvmpi_slow_alloc) {
oop obj = *p;
assert((!Universe::heap()->is_in_reserved(p) ||
generation()->is_in_reserved(p))
&& (generation()->level() == 0 || gc_barrier),
"The gen must be right, and we must be doing the barrier "
"in older generations.");
if (obj != NULL) {
if ((HeapWord*)obj < _boundary) {
assert(!_g->to()->contains(obj), "Scanning field twice?");
// OK, we need to ensure that it is copied.
// We read the klass and mark in this order, so that we can reliably
// get the size of the object: if the mark we read is not a
// forwarding pointer, then the klass is valid: the klass is only
// overwritten with an overflow next pointer after the object is
// forwarded.
klassOop objK = obj->klass();
markOop m = obj->mark();
if (m->is_marked()) { // Contains forwarding pointer.
*p = ParNewGeneration::real_forwardee(obj);
} else {
size_t obj_sz = obj->size_given_klass(objK->klass_part());
*p = _g->copy_to_survivor_space(_par_scan_state, obj, obj_sz, m,
jvmpi_slow_alloc);
if (root_scan) {
// This may have pushed an object. If we have a root
// category with a lot of roots, can't let the queue get too
// full:
(void)_par_scan_state->trim_queues(10 * ParallelGCThreads);
}
}
if (gc_barrier && only_two_gens) {
// Now call parent closure
par_do_barrier(p);
}
}
if (gc_barrier && !only_two_gens) {
// Now call parent closure
par_do_barrier(p);
}
}
}
void ParScanClosure::par_do_barrier(oop* p) {
assert(generation()->is_in_reserved(p), "expected ref in generation");
oop obj = *p;
assert(obj != NULL, "expected non-null object");
// If p points to a younger generation, mark the card.
if ((HeapWord*)obj < gen_boundary()) {
rs()->write_ref_field_gc_par(p, obj);
}
}
int main()
{
input();
s_alph();
generation();
calculation();
output();
return 0;
}
template <class T> inline void ParScanClosure::par_do_barrier(T* p) {
assert(generation()->is_in_reserved(p), "expected ref in generation");
assert(!oopDesc::is_null(*p), "expected non-null object");
oop obj = oopDesc::load_decode_heap_oop_not_null(p);
// If p points to a younger generation, mark the card.
if ((HeapWord*)obj < gen_boundary()) {
rs()->write_ref_field_gc_par(p, obj);
}
}
void OopsInGenClosure::do_barrier(oop* p) {
assert(generation()->is_in_reserved(p), "expected ref in generation");
oop obj = *p;
assert(obj != NULL, "expected non-null object");
// If p points to a younger generation, mark the card.
if ((HeapWord*)obj < _gen_boundary) {
_rs->inline_write_ref_field_gc(p, obj);
}
}
template <class T> inline void OopsInGenClosure::do_barrier(T* p) {
assert(generation()->is_in_reserved(p), "expected ref in generation");
T heap_oop = oopDesc::load_heap_oop(p);
assert(!oopDesc::is_null(heap_oop), "expected non-null oop");
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
// If p points to a younger generation, mark the card.
if ((HeapWord*)obj < _gen_boundary) {
_rs->inline_write_ref_field_gc(p, obj);
}
}
int main(void){
t_case grille[N][N];
t_score Liste[1000];
int tailleListe;
generation(grille);
printf("\n\n\t RUZZLE SOLVER\n");
afficher_matrice(grille);
points = trouverListe(grille);
tri(Liste, &tailleListe);
printf("Voici la liste des mots trouve dans la grille et leur nombre de points :\n");
afficher_liste(tailleListe, Liste);
void test(void){
CU_ASSERT_EQUAL(points, 21);
}
void main()
{
initialize();
cout<<zuiyougeti->geti<<" "<<zuiyougeti->shiyingdu<<endl;/////////////
for(gen=1;gen<maxgen;gen++)
{ generation();
}
jingyingbaoliu();
cout<<setiosflags(ios::fixed)<<setprecision(6)<<zuiyougeti->geti<<" "<<setiosflags(ios::fixed)<<setprecision(6)<<(zuiyougeti->shiyingdu)<<endl;////////////////
delete [] newpop;
delete [] nowpop;
delete [] zuiyougeti;
system("pause");
}
int main()
{
int k = 0;
int m = 0;
int n = 0;
printf("Enter # of Homozygous dominant: ");
fscanf(stdin, "%d", &k);
printf("Enter # of Heterozygous: ");
fscanf(stdin, "%d", &m);
printf("Enter # of Homozygous recessive: ");
fscanf(stdin, "%d", &n);
float probability = generation(k,m,n);
printf("Probabily of displaying dominant phenotype: %f", probability);
}
cell* huffdecoditication::generation(QString Tree)
{
cell* Left;
cell* Right;
QString TreeLeft=TreeHuffmanDecodificationLeft(Tree);
QString TreeRight=TreeHuffmanDecodificationRight(Tree);
if(TreeLeft.size()>1)
{
Left = generation(TreeLeft);
}
else
{
Left=new cell(TreeLeft.at(0).toLatin1(),0);
}
if(TreeRight.size()>1)
{
Right = generation(TreeRight);
}
else
{
Right = new cell(TreeRight.at(0).toLatin1(),0);
}
return new cell(0,Left,Right);
}
void
run (void) {
while (1) {
message("Turn : %6d ; <Press any key to interrupt>", turn);
display();
if(key_pressed())
break;
generation();
turn++;
sleep(1);
}
}
static void display_variable(GtkTreeModel *Variables, GtkTreeIter *Iter, Std$Object$t *Value, Std$Object_t **Address) {
//printf("Address = 0x%x, Value = 0x%x\n", Address, Value);
const char *String;
if (Value->Type == Agg$Table$T) {
size_t OldGeneration, CurrentGeneration = Agg$Table$generation(Value);
gtk_tree_model_get(Variables, Iter, 5, &OldGeneration, -1);
//printf("OldGeneration = %d, CurrentGeneration = %d\n", OldGeneration, CurrentGeneration);
if (OldGeneration != CurrentGeneration) {
gtk_tree_store_set(Variables, Iter, 1, "{...}", 3, Value, 5, CurrentGeneration, -1);
GtkTreeIter Child;
while (gtk_tree_model_iter_children(Variables, &Child, Iter)) gtk_tree_store_remove(Variables, &Child);
if (Agg$Table$size(Value) < 100) {
Agg$Table$trav *Trav = Agg$Table$trav_new();
for (Std$Object$t *Node = Agg$Table$trav_first(Trav, Value); Node; Node = Agg$Table$trav_next(Trav)) {
gtk_tree_store_append(Variables, &Child, Iter);
gtk_tree_store_set(Variables, &Child, 0, to_string(Agg$Table$node_key(Node)) ?: "<key>", 5, -1, -1);
Std$Object$t **NodeAddress = Agg$Table$node_value_ref(Node);
display_variable(Variables, &Child, *NodeAddress, NodeAddress);
};
};
int main(int argc, char **argv)
{
int ii, jj;
if(argc < 7) {
printf("Usage: %s xsize ysize fill (r1 r2 count)+\n", argv[0]);
return 1;
}
size_x = atoi(argv[1]);
size_y = atoi(argv[2]);
fillprob = atoi(argv[3]);
generations = (argc-4)/3;
printf("gen: %d, %d\n",argc,generations);
params = params_set = (generation_params*)malloc( sizeof(generation_params) * generations );
for(ii=4; ii+2<argc; ii+=3)
{
params->r1_cutoff = atoi(argv[ii]);
params->r2_cutoff = atoi(argv[ii+1]);
params->reps = atoi(argv[ii+2]);
params++;
}
srand(time(NULL));
initmap();
for(ii=0; ii<generations; ii++)
{
params = ¶ms_set[ii];
for(jj=0; jj<params->reps; jj++)
generation();
}
printfunc();
printmap();
return 0;
}
main()
{
int gencount, xforms;
maprows = 64;
mapcols = 64;
srand48(time(NULL));
genmap();
gencount = 1;
while((xforms = generation()) > (maprows*mapcols/30)
&& gencount < 11)
fprintf(stderr,
"Generation %4d -- %5d Transforms\n", gencount++, xforms);
fprintf(stderr,
"Generation %4d -- %5d Transforms\n", gencount++, xforms);
savemap();
}
void affiche(void)
{
int xw, yw, ww, hw, pxy[4], x, y;
int wcell, hcell, attributs[10];
int dummy;
C_OBJ *obj;
vqt_attributes(VDIhandle, attributs);
wcell=attributs[8];
hcell=attributs[9];
/* Coordonn‚es zone de travail fenˆtre : */
wind_get (buf[3], WF_WORKXYWH, &xw, &yw, &ww, &hw);
vst_alignment (VDIhandle, 0, 5, &dummy, &dummy); /* Texte en haut … gauche */
x=xw-(prog.w_col-tab*generation(curr_aff))*wcell;
y=yw;
ecrit(curr_aff, x, &y, wcell, hcell, yw+hw);
if(curr_aff->pere) /* ce bloc traite le cas o— les parents de curr_aff ne sont pas affiche */
{
obj=curr_aff->pere;
while (y<yw+hw && obj->suivant)
{
x-=tab*wcell;
ecrit(obj->suivant, x, &y, wcell, hcell, yw+hw);
if (obj->pere)
obj=obj->pere;
else
y=yw+hw+1; /* cree un condition fausse pour sortir de la boucle */
}
}
}
TTEntry* TranspositionTable::probe(const Key key, bool& found
#if defined(USE_GLOBAL_OPTIONS)
, size_t thread_id
#endif
) const
{
ASSERT_LV3(clusterCount != 0);
#if defined(USE_GLOBAL_OPTIONS)
if (!GlobalOptions.use_hash_probe)
{
// 置換表にhitさせないモードであるなら、見つからなかったことにして
// つねに確保しているメモリの先頭要素を返せば良い。(ここに書き込まれたところで問題ない)
return found = false, first_entry(0);
}
#endif
// 最初のTT_ENTRYのアドレス(このアドレスからTT_ENTRYがClusterSize分だけ連なっている)
// keyの下位bitをいくつか使って、このアドレスを求めるので、自ずと下位bitはいくらかは一致していることになる。
TTEntry* tte;
u8 gen8;
#if !defined(USE_GLOBAL_OPTIONS)
tte = first_entry(key);
gen8 = generation();
#else
if (GlobalOptions.use_per_thread_tt)
{
// スレッドごとに置換表の異なるエリアを渡す必要がある。
// 置換表にはclusterCount個のクラスターがあるのでこれをスレッドの個数で均等に割って、
// そのthread_id番目のblockを使わせてあげる、的な考え。
//
// ただしkeyのbit0は手番bitであり、これはそのままindexのbit0に反映されている必要がある。
//
// また、blockは2の倍数になるように下丸めしておく。
// ・上丸めするとblock*max_thread > clusterCountになりかねない)
// ・2の倍数にしておかないと、(key % block)にkeyのbit0を反映させたときにこの値がblockと同じ値になる。
// (各スレッドが使えるのは、( 0～(block-1) ) + (thread_id * block)のTTEntryなので、これはまずい。
size_t block = (clusterCount / max_thread) & ~1;
size_t index = (((size_t)key % block) & ~1 ) | ((size_t)key & 1);
tte = &table[index + thread_id * block].entry[0];
} else {
tte = first_entry(key);
}
gen8 = generation(thread_id);
#endif
// 上位16bitが合致するTT_ENTRYを探す
const uint16_t key16 = key >> 48;
// クラスターのなかから、keyが合致するTT_ENTRYを探す
for (int i = 0; i < ClusterSize; ++i)
{
// returnする条件
// 1. 空のエントリーを見つけた(そこまではkeyが合致していないので、found==falseにして新規TT_ENTRYのアドレスとして返す)
// 2. keyが合致しているentryを見つけた。(found==trueにしてそのTT_ENTRYのアドレスを返す)
// Stockfishのコードだと、1.が成立したタイミングでもgenerationのrefreshをしているが、
// save()のときにgenerationを書き出すため、このケースにおいてrefreshは必要ない。
// 1.
if (!tte[i].key16)
return found = false, &tte[i];
// 2.
if (tte[i].key16 == key16)
{
#if defined(USE_GLOBAL_OPTIONS)
// 置換表とTTEntryの世代が異なるなら、信用できないと仮定するフラグ。
if (GlobalOptions.use_strict_generational_tt)
if (tte[i].generation() != gen8)
return found = false, &tte[i];
#endif
tte[i].set_generation(gen8); // Refresh
return found = true, &tte[i];
}
}
// 空きエントリーも、探していたkeyが格納されているentryが見当たらなかった。
// クラスター内のどれか一つを潰す必要がある。
TTEntry* replace = tte;
for (int i = 1; i < ClusterSize; ++i)
// ・深い探索の結果であるものほど価値があるので残しておきたい。depth8 × 重み1.0
// ・generationがいまの探索generationに近いものほど価値があるので残しておきたい。geration(4ずつ増える)×重み 2.0
// 以上に基いてスコアリングする。
// 以上の合計が一番小さいTTEntryを使う。
if (replace->depth8 - ((259 + gen8 - replace->genBound8) & 0xFC) * 2
> tte[i].depth8 - ((259 + gen8 - tte[i].genBound8) & 0xFC) * 2)
replace = &tte[i];
// generationは256になるとオーバーフローして0になるのでそれをうまく処理できなければならない。
// a,bが8bitであるとき ( 256 + a - b ) & 0xff のようにすれば、オーバーフローを考慮した引き算が出来る。
// このテクニックを用いる。
// いま、
// a := generationは下位2bitは用いていないので0。
// b := genBound8は下位2bitにはBoundが入っているのでこれはゴミと考える。
// ( 256 + a - b + c) & 0xfc として c = 3としても結果に影響は及ぼさない、かつ、このゴミを無視した計算が出来る。
return found = false, replace;
}
/* The main function */
int main(int argc, char const *argv[])
{
DBusError dbe;
struct state_st state;
/* Parse the command line. */
if (argv[1] && argv[1][0] == 'd')
{ /* Debug dump */
assert(loadstate(&state));
dumpop(&state);
return 0;
} else if (argv[1] && argv[1][0] == 'r')
{ /* Repair the GA state. */
unsigned i;
assert(loadstate(&state));
for (i = 0; i < G_N_ELEMENTS(state.pop); i++)
{ /* Ensure that genes are bounded. */
struct genome_st *g = &state.pop[i];
if (g->window > TIMEOUT)
g->window = TIMEOUT;
else if (g->window < 3)
g->window = 3;
if (g->threshold <= 0)
g->threshold = 0.1;
else if (g->threshold >= 1)
g->threshold = 0.9;
}
savestate(&state);
return 0;
}
/* Redirect stdio. */
assert((stderr = fopen(FNAME".err", "a")) != NULL);
assert((stdout = fopen(FNAME".log", "a")) != NULL);
/* Initialize infrastructure for the test. */
Loop = g_main_loop_new(0, 0);
DBus = dbus_bus_get(DBUS_BUS_SESSION, NULL);
dbus_connection_setup_with_g_main(DBus, g_main_context_default());
dbus_error_init(&dbe);
dbus_bus_add_match(DBus, "type='method_call',interface='com.nokia.HildonDesktop.AppMgr',member='LaunchApplication'", &dbe);
assert(!dbus_error_is_set(&dbe));
Dpy = XOpenDisplay(NULL);
assert(Dpy != NULL);
if (!loadstate(&state))
initpop(&state);
/* Test */
eval(&state.pop[state.idx++]);
if (state.idx >= G_N_ELEMENTS(state.pop))
generation(&state);
/* Done and reboot. */
savestate(&state);
if (argv[1])
system("echo reboot | sudo gainroot");
return 0;
} /* main */
template <class T> inline void do_oop_work(T* p) {
assert(generation()->is_in_reserved((void*)p), "Must be in!");
_boc.do_oop(p);
}
int main(int argc,char *argv[])
{
//Inicia MPI
inicializa_mpi(argc,argv);
// Obtiene rutas de trabajo y crea archivos generales
if(inicializa_archivos(argc, argv, rank) == -1) exit(-1);
#ifdef _PRINT_MIGRACION_
printf("#Bienvenido a MAPAPOC (MÁquina PAralela para Problemas de Optimización Combinatoria) en Rank %d... [OK]\n", rank);
#endif
if(rank != 0) {
//Inicializa semilla aleatoria
inicializa_semilla();
//Espera que nodo0 entregue dato runmax (cantidad de archivos a procesar)
for(;;){
MPI_Iprobe(nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &flag1, &status);
if(flag1 == true){
if (status.MPI_TAG == MSJ_RUNMAX){
MPI_Recv(&runmax, 1, MPI_INT, nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
flag1 = 0;
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Recibió desde Rank = 0 Mensaje RUNMAX = %d (cantidad máxima de instancias a resolver)...\n", rank, runmax);
#endif
break;
}//End else if
}//End if
}//End for
for(run=1; run<=runmax; run++) {
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Antes de generar semilla aleatoria...\n", rank);
#endif
//Nueva semilla aleatoria
for(rank_seed = 1; rank_seed <= rank; rank_seed++) {
int s = 0;
/*
s = atoi(argv[7]);
*/
if(s==0) {
do {
randomseed = nueva_semilla();
} while (randomseed == 0);
} else {
randomseed = (float)((s%10000)/10000.0);
}
}//End for
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Después de generar semilla aleatoria...\n", rank);
#endif
//Espera que nodo0 entregue información relevante para nodox
for(;;) {
MPI_Iprobe(nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &flag1, &status);
if(flag1 == true){
if (status.MPI_TAG == MSJ_LINEA_IN){
MPI_Recv(linea_in, 100, MPI_CHAR, nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
flag1 = 0;
//Asigna variables globales desde linea_in recibida desde Rank 0
//sscanf(linea_in,"%d %s %d %s %d %f %f %f %d %s %f", &tipo_problema, nomarch, &popsize, answer, &maxgen, &pcross, &pmutation, &pind_env_rec, &tasa_migracion, answer_mod_mig, &randomseed);
sscanf(linea_in,"%d %s %d %s %d %f %f %f %f %d %s %f", &tipo_problema, nomarch, &popsize, answer, &maxgen, &pcross, &pmutation, &pind_env, &pind_rec, &tasa_migracion, answer_mod_mig, &randomseed);
randomseed = randomseed + (rank * 0.001);
//printf("#Rank = %d estableción semilla : %f\n", rank, randomseed);
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Recibió desde Rank = 0 Mensaje LINEA_IN (PARAMETROS GLOBALES)...\n", rank);
#endif
} else if (status.MPI_TAG == MSJ_CANT_CHAR_A_REC) {
//cantidad_char_a_recibir es la variable que indica cuantos enteros recibirá nodox desde Rank 0
MPI_Recv(&cantidad_char_a_recibir, 1, MPI_INT, nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
flag1 = 0;
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Recibió desde Rank = 0 Mensaje MSJ_CANT_CHAR_A_REC...\n", rank);
#endif
break;
} else if (status.MPI_TAG == MSJ_ERROR_ARCHIVO_INSTANCIA) {
MPI_Recv(0, 0, MPI_INT, nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
flag1 = 0;
cantidad_char_a_recibir = -1; //setea a -1 para indicar que hubo error al leer archivo instancia
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Recibió desde Rank = 0 Mensaje MSJ_ERROR_ARCHIVO_INSTANCIA...\n", rank);
#endif
break;
}//End else if
}//End if
}//End for
//Setea variable printstrings
if(strncmp(answer,"n",1) == 0) printstrings = 0;
else printstrings = 1;
//Setea variables dependiendo de la cantidad de workers
popsize = popsize / workers;
if(popsize%2) popsize++;
//n_ind_a_enviar = (int) popsize * pind_env_rec; //% de la subpoblación se envía
//n_ind_a_recibir = (int) popsize * pind_env_rec; //% de la subpoblación se recibe
n_ind_a_enviar = (int) popsize * pind_env; //% de la subpoblación se envía
n_ind_a_recibir = (int) popsize * pind_rec; //% de la subpoblación se recibe
//tasa_migracion = maxgen / workers; //tasa de migración depende de la cantidad de generaciones
#ifdef _PRINT_MIGRACION_
printf("Rank = %d tiene popsize %d, n_ind_a_enviar %d, n_ind_a_recibir %d, tasa_migracion %d...\n", rank, popsize, n_ind_a_enviar, n_ind_a_recibir, tasa_migracion);
#endif
// nro. que identifica que migración está ocurriendo
n_migracion = 0;
//Inicializa contador de segundos de comunicación
time_comm = 0.0;
//Setea variable modelo_migracion
if(strncmp(answer_mod_mig,"A",1) == 0) modelo_migracion = 0; // Migración Asíncrona
else modelo_migracion = 1; //Migración Síncrona
#ifdef _PRINT_MIGRACION_
printf("Rank %d debería recibir %d caracteres representando la instancia a resolver...\n", rank, cantidad_char_a_recibir);
#endif
if(cantidad_char_a_recibir > 0) {
//Lee enteros con información del archivo instancia
if(lee_char_y_genera_achivo_instancia_tmp(tipo_problema, cantidad_char_a_recibir)) {
#ifdef _PRINT_MIGRACION_
printf("Espere, MAPAPOC en Rank %d está procesando archivo %s...\n", rank, nomarch);
#endif
//Actualiza Resultados Estadísticos Evolutivos para cada problema particular
fprintf(evofp, "\n\nCorrida : %d, PROBLEMA : %s\n", run, nomarch);
fprintf(evofp, "Migracion Generacion Minimo Maximo Media DesvEstandar TiempoTranscurrido GenMejor\n");
// Inicia la cuenta de Segundos
time_start = MPI_Wtime();
// Rutina de inicialización de variables globales
initialize();
// Ubica espacio malloc para las estructuras de datos globales
initmalloc();
// Define tipos de Individuos a Enviar y Recibir
Build_type_pop(envpop, &message_type_send, n_ind_a_enviar);
Build_type_pop(recpop, &message_type_receive, n_ind_a_recibir);
// Initializa la población de individuos y determina datos estadísticos
// y mejor individuo de la población
initpop(tipo_problema);
statistics(oldpop);
//Avisa a nodo0 que esté listo para comenzar evolución...
time_send = MPI_Wtime();
MPI_Isend(0, 0, MPI_INT, nodo0, MSJ_LISTO_PARA_COMENZAR, MPI_COMM_WORLD, &request);
for(;;){
MPI_Test(&request, &flag2, &status);
if(flag2 == true){
time_send = MPI_Wtime() - time_send;
time_comm += time_send;
#ifdef _PRINT_MIGRACION_
printf("Envió desde Rank = %d a Rank = 0 Mensaje Listo para comenzar...\n", rank);
#endif
break;
}//End If
}//End for
//Espera que nodo0 dé la partida para comenzar evolución...
for(;;){
MPI_Iprobe(nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &flag1, &status);
if(flag1 == true) {
if (status.MPI_TAG == MSJ_COMIENCE){
MPI_Recv(0, 0, MPI_INT, nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
flag1 = 0;
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Recibió desde Rank = 0 Mensaje de COMINECE, comienza evolución...\n", rank);
#endif
break;
}//End if
}//End if
}//End for
//Setea contador de generaciones para Migrar en Modelo de Migración Asíncrona
if (modelo_migracion == 0) cuenta_gen_para_migracion=1;
for(gen=0; gen<maxgen; gen++) {
if(printstrings == 1) fprintf(outfp,"\nGENERATION %d->%d\n",gen,maxgen);
// Crea una nueva generación
generation(tipo_problema);
/*
printf("generacion: %d de %d => %f\n",gen, maxgen, bestfit.fitness);
*/
// Efectúa estadísticas sobre nueva población y obtiene mejor individuo
statistics(newpop);
if (modelo_migracion == 0)
//Establece comunicación Asincrona con Coordinador
comunicacion_asincrona_con_coordinador();
else
//Establece comunicación sincrona con Coordinador
comunicacion_sincrona_con_coordinador();
/*
printf("rank %i gen %i best fitness: %f\n", rank, gen, bestfit.fitness);
*/
/*
if(bestfit.fitness < 107.0) {
printf("rank %i gen %i best fitness: %f done!\n", rank, gen, bestfit.fitness);
gen = maxgen;
}
*/
/*
printf("%i.%i=>%f\n", rank, gen, bestfit.fitness);
*/
// Avanza de Generación
temppop = oldpop;
oldpop = newpop;
newpop = temppop;
}//End for
// Libera memoria temporal
freeall();
//Libera memoria tipos creados por MPI
MPI_Type_free(&message_type_send);
MPI_Type_free(&message_type_receive);
} else
printf("!!! ADVERTENCIA ¡¡¡ Rank %d no procesó archivo de instancia ya que hubo problemas al leer enteros, generar o leer tmp...\n", rank);
} else
printf("!!! ADVERTENCIA ¡¡¡ Rank %d no procesó archivo de instancia ya que Rank 0 tuvo problemas al leerlo...\n", rank);
// Libera variables del problema
app_free(tipo_problema);
//Mensaje de término de procesamiento de archivo actual se envía a Rank = 0
MPI_Isend(&time_comm, 1, MPI_DOUBLE, nodo0, MSJ_TERMINO, MPI_COMM_WORLD, &request);
for(;;){
MPI_Test(&request, &flag2, &status);
if(flag2 == true){
#ifdef _PRINT_MIGRACION_
printf("Envió desde Rank = %d a Rank = 0 Mensaje de Término, archivo %s...\n", rank, nomarch);
#endif
break;
}//End If
}//End for
//Espera que nodo0 dé el OK para poder finalizar el procesamiento del archivo actual
for(;;){
MPI_Iprobe(nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &flag1, &status);
if(flag1 == true){
if(status.MPI_TAG == MSJ_TERMINO_CONFIRMADO){
MPI_Recv(0, 0, MPI_INT, nodo0, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
flag1 = 0;
#ifdef _PRINT_MIGRACION_
printf("Rank = %d Recibió desde Rank = 0 Mensaje de TERMINO_CONFIRMADO, pasa siguiente archivo o termina...\n", rank);
#endif
break;
}//End if
}//End if
}//End for
#ifdef _PRINT_MIGRACION_
printf("#Corrida %d, Archivo %s procesado por Rank %d... [OK]\n", run, nomarch, rank);
#endif
}//End for
if(runmax == 0){
//Que runmax = 0 significa que la consistencia del archivo arrojó un error
//=> rank debe mandar mensaje al Coordinador que va ha terminar el proceso...
//Mensaje de término de procesamiento de archivo actual se envía a Rank = 0
MPI_Isend(&time_comm, 1, MPI_DOUBLE, nodo0, MSJ_TERMINO, MPI_COMM_WORLD, &request);
for(;;){
MPI_Test(&request, &flag2, &status);
if(flag2 == true){
#ifdef _PRINT_MIGRACION_
printf("Envió desde Rank = %d a Rank = 0 Mensaje de Término, archivo %s...\n", rank, nomarch);
#endif
break;
}//End If
}//End for
printf("Proceso en Rank %d detenido ya que Rank 0 informa error en archivo de entrada... [OK]\n", rank);
}//End if
} else {
//Rank = 0 => Coordinador
/*
printf("#Bienvenido a Máquina Paralela para Problemas de Optimización Combinatoria, espere por favor...\n");
*/
// Revisa consistencia del archivo de entrada in.txt
runmax = consistenciaarchivo(workers);
//Envía runmax a cada Rank
envia_a_cada_rank(MSJ_RUNMAX);
for(run=1;run<=runmax;run++) {
//Lee archivo en infp con parametros (todos ya chequeados)
//OJO => Cada AG tendrá popsize/workers individuos => Población Total = popsize
//fscanf(infp,"%d %s %d %s %d %f %f %f %d %s %f", &tipo_problema, nomarch, &popsize, answer, &maxgen, &pcross, &pmutation, &pind_env_rec, &tasa_migracion, answer_mod_mig, &randomseed);
fscanf(infp,"%d %s %d %s %d %f %f %f %f %d %s %f", &tipo_problema, nomarch, &popsize, answer, &maxgen, &pcross, &pmutation, &pind_env, &pind_rec, &tasa_migracion, answer_mod_mig, &randomseed);
int i=0;
randomseed = (float)((atoi(argv[7])%100)/100.0);
/*
printf("argv[7]: %i\n", atoi(argv[7]));
printf("randomseed: %f\n", randomseed);
*/
for(i=0; i<argc; i++) {
// printf("argv[%i]: %s\n", i, argv[i]);
if(strcmp(argv[i], "-pr")==0) tipo_problema = atoi(argv[++i]);
if(strcmp(argv[i], "-po")==0) popsize = atoi(argv[++i]);
if(strcmp(argv[i], "-g")==0) maxgen = atoi(argv[++i]);
if(strcmp(argv[i], "-m")==0) pmutation = atof(argv[++i]);
if(strcmp(argv[i], "-c")==0) pcross = atof(argv[++i]);
if(strcmp(argv[i], "-pe")==0) pind_env = atof(argv[++i]);
if(strcmp(argv[i], "-pa")==0) pind_rec = atof(argv[++i]);
if(strcmp(argv[i], "-tm")==0) tasa_migracion = atoi(argv[++i]);
if(strcmp(argv[i], "-am")==0) sprintf(answer_mod_mig, "%s", argv[++i]);
if(strcmp(argv[i], "-f")==0) sprintf(nomarch, "%s", argv[++i]);
if(strcmp(argv[i], "-a")==0) sprintf(answer, "%s", argv[++i]);
}
// exit(0);
//Inicializa contador de segundos de comunicación
time_comm = 0.0;
//Llena con información linea_in para ser enviada a cada Rank
//sprintf(linea_in,"%d %s %d %s %d %f %f %f %d %s %f\n", tipo_problema, nomarch, popsize, answer, maxgen, pcross, pmutation, pind_env_rec, tasa_migracion, answer_mod_mig, randomseed);
sprintf(linea_in,"%d %s %d %s %d %f %f %f %f %d %s %f", tipo_problema, nomarch, popsize, answer, maxgen, pcross, pmutation, pind_env, pind_rec, tasa_migracion, answer_mod_mig, randomseed);
/*
printf("%d %s %d %s %d %f %f %f %f %d %s %f\n", tipo_problema, nomarch, popsize, answer, maxgen, pcross, pmutation, pind_env, pind_rec, tasa_migracion, answer_mod_mig, randomseed);
*/
#ifdef _PRINT_MIGRACION_
printf("Espere, MAPAPOC en Rank %d está enviando archivo %s a todos los rank...\n", rank, nomarch);
#endif
//Envía linea_in a cada Rank
envia_a_cada_rank(MSJ_LINEA_IN);
//Setea variable printstrings
if(strncmp(answer,"n",1) == 0) printstrings = 0;
else printstrings = 1;
//Setea variables dependiendo de la cantidad de workers
popsize = popsize / workers;
/*
printf("popsize: %i\n", popsize);
*/
if(popsize%2) popsize++;
//n_ind_a_enviar = (int) popsize * pind_env_rec; //% de la subpoblación se envía
//n_ind_a_recibir = (int) popsize * pind_env_rec; //% de la subpoblación se recibe
n_ind_a_enviar = (int) popsize * pind_env; //% de la subpoblación se envía
n_ind_a_recibir = (int) popsize * pind_rec; //% de la subpoblación se recibe
//tasa_migracion = maxgen / workers; //tasa de migración debende de la cantidad de generaciones
//Setea variable modelo_migracion
if(strncmp(answer_mod_mig,"A",1) == 0) modelo_migracion = 0; //Migración Asíncrona
else modelo_migracion = 1; //Migración Síncrona
if(app_leearchivo(tipo_problema, nomarch, rank)) {
if(almacena_archivo_instancia(nomarch)) {
//Determina cantidad_char_a_recibir por cada rank que coordinador enviará. Todos estos char determinan los datos del problema a resolver
cantidad_char_a_recibir = cantidad_char_que_determinan_instancia_del_problema;
//Envía a cada Rank cantidad de char a recibir del problema
envia_a_cada_rank(MSJ_CANT_CHAR_A_REC);
//Envía a cada Rank un grupo de char que determinan la estructura de una instancia del problema
envia_a_cada_rank(MSJ_CHAR_ARCHIVO_INSTANCIA);
// Rutina de inicialización de variables globales
// nro. individuos a enviar desde coord. a nodo AG
coord_ind_a_env = n_ind_a_recibir;
// nro. individuos a recibir desde cada nodo AG a coord
coord_ind_a_rec = n_ind_a_enviar;
// nro. individuos total recibidos => Población Global del Coordinador
coord_ind_global = workers * n_ind_a_enviar;
// nro. que identifica qué migración está ocurriendo
n_migracion = 1;
#ifdef _PRINT_MIGRACION_
printf("Espere, MAPAPOC en Rank %d está procesando archivo %s...\n", rank, nomarch);
printf("Rank = %d tiene popsize %d, coord_ind_a_env %d, coord_ind_a_rec %d, coord_ind_global % d, tasa_migracion %d...\n", rank, popsize, coord_ind_a_env, coord_ind_a_rec, coord_ind_global, tasa_migracion);
#endif
//Actualiza Resultados Estadísticos Evolutivos para cada problema particular
fprintf(evofp, "\n\nCorrida : %d, PROBLEMA : %s\n", run, nomarch);
fprintf(evofp, "Migracion Generacion Minimo Maximo Media DesvEstandar TiempoTranscurrido\n");
// Inicia la cuenta de Segundos
time_start = MPI_Wtime();
//Rutina de inicialización de variables globales
initialize();
//Dimensiona poblaciones de individuos que recibe y envía...
initmallocMaster(coord_ind_a_rec, coord_ind_a_env, coord_ind_global);
//Define tipos de Individuos a Enviar y Recibir
Build_type_pop(envpop, &message_type_send, coord_ind_a_env);
Build_type_pop(recpop, &message_type_receive, coord_ind_a_rec);
if (modelo_migracion == 0)
//Establece comunicación Asincrona con cada rank (AG)
comunicacion_asincrona_con_cada_rank();
else
//Establece comunicación sincrona con cada rank (AG)
comunicacion_sincrona_con_cada_rank();
// Calcula cantidad de segundos que demoró en cada Algoritmo Genético
time_end = MPI_Wtime() - time_start;
time_consumation.elapsed_time = time_end;
time_consumation.comm_time = time_comm;
time_consumation.cpu_time = time_end - time_comm;
//Graba datos en archivo de resultados del algoritmo
genera_resultados_algoritmo(run, tipo_problema, nomarch, &time_consumation);
//Graba datos en archivo de resultados del problema
app_genera_resultados_problema(run, tipo_problema, nomarch);
//IMPRIME SALIDA PARA PROGRAMA PARAMILS
/*
printf("RunsExecuted = 1\n");
printf("CPUTime_Mean = %f\n", time_consumation.elapsed_time);
printf("BestSolution_Mean = %f\n", bestfit.fitness);
*/
/*
printf("Result for ParamILS: SAT, %f, %i, %f, %s\n", -1.0, -1, bestfit.fitness, argv[7]);
*/
printf("Resultado: SAT, %s, %f, %f, %f, %f\n", nomarch, time_consumation.elapsed_time, time_consumation.cpu_time, bestfit.fitness, randomseed);
//Genera la Salida hacia archivo de Resultados LAYOUT
app_objfuncfinal(tipo_problema, &(bestfit));
//Libera memoria del Coordinador
freeallMaster(coord_ind_a_rec, coord_ind_a_env, coord_ind_global);
//Libera memoria tipos creados por MPI
MPI_Type_free(&message_type_send);
MPI_Type_free(&message_type_receive);
}//End if
else {
printf("!!! ERROR ¡¡¡ Rank 0, en datos del archivo de piezas <%s> => Archivo no procesado...\n", nomarch);
//Envía a cada Rank que ARCHIVO_INSTANCIA está con algún error
envia_a_cada_rank(MSJ_ERROR_ARCHIVO_INSTANCIA);
}//End else
}//End if
else {
printf("!!! ERROR ¡¡¡ Rank 0, en datos del archivo de piezas <%s> => Archivo no procesado...\n", nomarch);
//Envía a cada Rank que ARCHIVO_INSTANCIA está con algún error
envia_a_cada_rank(MSJ_ERROR_ARCHIVO_INSTANCIA);
}//End else
// Libera variables del problema
app_free(tipo_problema);
#ifdef _PRINT_MIGRACION_
printf("#Corrida %d, Archivo %s procesado por Coordinador... [OK]\n", run, nomarch);
#else
// printf("#Corrida %d, Archivo %s procesado... [OK]\n", run, nomarch);
#endif
}//End for
if(runmax == 0){
//Que runmax = 0 significa que la consistencia del archivo arrojó un error
printf("Archivo %s NO procesado por Rank %d debido a error... [OK]\n", nomarch, rank);
}//End if
}//End else
//Cierra archivos
cierra_archivos();
//Rutina para MPI
MPI_Finalize();
#ifdef _PRINT_MIGRACION_
printf("Terminó rank = %d...\n", rank);
#endif
exit(0);
}//End main
/* Creates a map for a level in the world list */
LEVELMAP* create_map(char *level_name, int level_id, int width, int height, boolean has_shops, int level_type) {
LEVELMAP *new_element;
generation_params *params;
generation_params *params_set;
int xi, yi, ii, jj;
int generations = 1;
if ( (new_element = (LEVELMAP *)malloc(sizeof(LEVELMAP))) == NULL) return NULL;
memset(new_element, 0, sizeof(LEVELMAP));
new_element->level_name = (char *)malloc(sizeof(char)*strlen(level_name)+1);
memset(new_element->level_name, 0, strlen(level_name) + 1);
if (level_name != NULL)
strcpy(new_element->level_name,level_name);
new_element->level_id = level_id;
if (width < MAP_DISPLAY_WIDTH * 3) width = MAP_DISPLAY_WIDTH * 3;
if (height < MAP_DISPLAY_HEIGHT * 3) height = MAP_DISPLAY_HEIGHT * 3;
new_element->width = width;
new_element->height = height;
new_element->has_shops = has_shops;
new_element->level_type = level_type;
new_element->portal_up_loc.x = new_element->portal_up_loc.y = new_element->portal_down_loc.x = new_element->portal_down_loc.y = new_element->shop_loc.x = new_element->shop_loc.y = 0;
new_element->next = NULL;
/*
Now we build up the level
*/
new_element->grid = (int**)malloc(sizeof(int*) * height);
/* Allocate for the scratch area */
grid2 = (int**)malloc(sizeof(int*) * height);
for(yi=0; yi < height; yi++) {
new_element->grid[yi] = (int*)malloc(sizeof(int) * width);
grid2[yi] = (int*)malloc(sizeof(int) * width);
}
for(yi=1; yi < height-1; yi++)
for(xi=1; xi < width-1; xi++)
new_element->grid[yi][xi] = mapPick(35);
for(yi=0; yi < height; yi++)
for(xi=0; xi < width; xi++)
grid2[yi][xi] = OUTERWALL;
for(yi=0; yi < height; yi++)
new_element->grid[yi][0] = new_element->grid[yi][new_element->width-1] = OUTERWALL;
for(xi=0; xi < width; xi++)
new_element->grid[0][xi] = new_element->grid[new_element->height-1][xi] = OUTERWALL;
params = params_set = (generation_params*)malloc( sizeof(generation_params) * generations);
params->r1_cutoff = 30;
params->r2_cutoff = 5;
params->reps = 5;
/*
params++;
params->r1_cutoff = 20;
params->r2_cutoff = 3;
params->reps = 1;
params++;
*/
for(ii=0; ii < generations; ii++) {
params = ¶ms_set[ii];
for(jj=0; jj < params->reps; jj++)
generation(new_element,params);
}
free(params);
free(params_set);
for (ii = 0; ii < new_element->height; ii++) {
free(grid2[ii]);
}
/* We're done with the secondary grid, deallocate it */
free(grid2);
/* If a shop needs to be placed place it */
if (new_element->has_shops) {
placeShop(new_element);
}
placePortal(new_element);
/* return the newly created element in memory */
return new_element;
}
void main()
{
void generation(int array_x[], int array_y[], int n);
void Normalize(double *point1);
void fcm_method(int x_second[], int y_third[], double *point2,double *point3);
srand((int)time(0));
// Generate information database
int data_x[TOTAL_NUM], data_y[TOTAL_NUM];
generation(data_x, data_y, TOTAL_NUM);
//Get the initial membership matrix
double u[3][50], *p1;
p1 = u[0];
Normalize(p1);
// FCM algorithm
int class_fcm[TOTAL_NUM] = {0};
double center_point[2][3];
double *p2, *p3;
p2 = u[0];
p3 = center_point[0];
fcm_method(data_x, data_y, p2, p3);
// proof
for(int i = 0; i < 3;i++)
{
for(int j = 0;j < 50;j++)
{
printf(" %f ",u[i][j]);
}
printf("\n");
}
for(int i = 0; i < 2;i++)
{
for(int j = 0;j < 3;j++)
{
printf(" %f ",center_point[i][j]);
}
printf("\n");
}
// Out put database and center_point as a text file!
FILE *fp;
if( (fp = fopen("data.txt","w")) == NULL )
{
printf("cannot open file\n");
exit(0);
}
fprintf(fp,"Measurement\n");
fprintf(fp,"x,y\n");
for(int i = 0;i < 50; i++)
{
fprintf(fp,"%d,%d\n",data_x[i],data_y[i]);
}
fprintf(fp,"Center\n");
fprintf(fp,"x,y\n");
for(int i = 0; i < 3 ; i++)
{
fprintf(fp,"%f,%f\n",center_point[0][i],center_point[1][i]);
}
fclose(fp);
FILE *fp_1;
if( (fp_1 = fopen("degree.txt","w")) == NULL )
{
printf("cannot open file\n");
exit(0);
}
for(int i = 0;i < 3; i++)
{
for(int j = 0;j < 50; j++)
{
fprintf(fp_1," %f ",u[i][j]);
}
fprintf(fp_1,"\n");
}
fclose(fp_1);
getchar();
}
void MockMediaSample::dump(PrintStream& out) const
{
out.print("{PTS(", presentationTime(), "), DTS(", decodeTime(), "), duration(", duration(), "), flags(", (int)flags(), "), generation(", generation(), ")}");
}
inline void ParScanClosure::do_oop_work(T* p,
bool gc_barrier,
bool root_scan) {
assert((!GenCollectedHeap::heap()->is_in_reserved(p) ||
generation()->is_in_reserved(p))
&& (GenCollectedHeap::heap()->is_young_gen(generation()) || gc_barrier),
"The gen must be right, and we must be doing the barrier "
"in older generations.");
T heap_oop = oopDesc::load_heap_oop(p);
if (!oopDesc::is_null(heap_oop)) {
oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
if ((HeapWord*)obj < _boundary) {
#ifndef PRODUCT
if (_g->to()->is_in_reserved(obj)) {
tty->print_cr("Scanning field (" PTR_FORMAT ") twice?", p2i(p));
GenCollectedHeap* gch = GenCollectedHeap::heap();
Space* sp = gch->space_containing(p);
oop obj = oop(sp->block_start(p));
assert((HeapWord*)obj < (HeapWord*)p, "Error");
tty->print_cr("Object: " PTR_FORMAT, p2i((void *)obj));
tty->print_cr("-------");
obj->print();
tty->print_cr("-----");
tty->print_cr("Heap:");
tty->print_cr("-----");
gch->print();
ShouldNotReachHere();
}
#endif
// OK, we need to ensure that it is copied.
// We read the klass and mark in this order, so that we can reliably
// get the size of the object: if the mark we read is not a
// forwarding pointer, then the klass is valid: the klass is only
// overwritten with an overflow next pointer after the object is
// forwarded.
Klass* objK = obj->klass();
markOop m = obj->mark();
oop new_obj;
if (m->is_marked()) { // Contains forwarding pointer.
new_obj = ParNewGeneration::real_forwardee(obj);
oopDesc::encode_store_heap_oop_not_null(p, new_obj);
#ifndef PRODUCT
if (TraceScavenge) {
gclog_or_tty->print_cr("{%s %s ( " PTR_FORMAT " ) " PTR_FORMAT " -> " PTR_FORMAT " (%d)}",
"forwarded ",
new_obj->klass()->internal_name(), p2i(p), p2i((void *)obj), p2i((void *)new_obj), new_obj->size());
}
#endif
} else {
size_t obj_sz = obj->size_given_klass(objK);
new_obj = _g->copy_to_survivor_space(_par_scan_state, obj, obj_sz, m);
oopDesc::encode_store_heap_oop_not_null(p, new_obj);
if (root_scan) {
// This may have pushed an object. If we have a root
// category with a lot of roots, can't let the queue get too
// full:
(void)_par_scan_state->trim_queues(10 * ParallelGCThreads);
}
}
if (is_scanning_a_klass()) {
do_klass_barrier();
} else if (gc_barrier) {
// Now call parent closure
par_do_barrier(p);
}
}
}
}
int main (int argc, char *argv[]){
int continuer = 10;
#ifdef GUI_ENABLE
int afficher;
#endif
char nom_file[1000];
Matrice mat = NULL;
FILE *input = NULL;
FILE *output = stdout;
FILE *nullstream = stdout;
nullstream = fopen ("nullstream", "w");
if (nullstream == NULL){
printf("probleme a l'ouverture du fichier\n");
exit(1);
}
if(argc >= 2){
output = fopen (argv[1], "w");
if (output == NULL){
printf("probleme a l'ouverture du fichier\n");
exit(1);
}
}
while (continuer){
printf("TSP : selectionner l'action a executer :\n");
printf("\t1 : generer une liste de ville\n");
printf("\t2 : appliquer l'algorithme prim à un fichier de ville\n");
#ifdef GUI_ENABLE
printf("\t3 : afficher une liste de ville (aucune action possible -> efficace pour de grand nombre de villes)\n");
#endif
printf("\t0 : quitter le programme\n");
scanf("%d", &continuer);
switch(continuer){
case 1 :
continuer = generation(nom_file, &mat);
break;
case 2 :
printf("entrer le nom du fichier :\n");
scanf("%s", nom_file);
input = fopen (nom_file, "r");
if (input == NULL)
{
printf("probleme a l'ouverture du fichier\n");
exit(1);
}
mat = matrice_of_coordonnees(input);
fclose(input);
TSP (mat,output);
fprintf(output,"\n");
continuer = 13;
break;
#ifdef GUI_ENABLE
case 3 :
printf("entrer le nom du fichier :\n");
scanf("%s", nom_file);
affichage_gui(nom_file);
break;
#endif
case 0 :
break;
default :
continuer = 10;
break;
}
#ifdef GUI_ENABLE
/*propose l'affichage graphique, et initialise la matrice en fonction des choix fait par l'utilisateur*/
afficher = 0;
switch(continuer){
case 13:
case 12:
case 11:
do{
printf("voulez vous afficher graphiquement le resultat ? (oui = 1, non = 0) ");
scanf("%d", &afficher);
}while (afficher != 0 && afficher != 1);
break;
}
if (afficher){
printf("\ncommande :\nla pression des touches suivantes permet d'afficher ou masquer : \n"
"c(ycle) : le chemin calculé par l'algorithme\n"
"t(ree) : l'arbre couvrant minimum\n"
"s(ommet) : les sommets representant les villes\n"
"Appuyez sur esc pour fermer l'interface graphique\n");
switch(continuer){
case 12://un fichier liste de ville (nom_file) vient d'etre cree.
input = fopen(nom_file, "r");
if (input == NULL)
{
printf("probleme a l'ouverture du fichier\n");
exit(1);
}
mat = matrice_of_coordonnees(input);
fclose(input);
//break omis volontairement
case 11:// la matrice est initialisee, il suffit d'afficher le cycle
TSP (mat, nullstream);
fprintf(nullstream,"\n");
//break omis volontairement
case 13:
gui(mat);
break;
}
}
#endif
if (mat){
liberer_mat(mat);
mat = NULL;
}
}
fclose(nullstream);
if (argc >= 2)fclose(output);
return 0;
}
void Entity::run()
{
if (age() == 1 && generation() > 50 && generation() % 50 == 0) {
mNeuralNetwork.optimize();
}
setHeatLevel(mMap->cell(mX, mY).mHeatLevel / 255.0);
int index = 0;
for (int y = -1; y <= 1; ++y) {
for (int x = -1; x <= 1; ++x) {
const Cell &cell = mMap->safeCell(mX + x, mY + y);
mNeuralNetwork.setInputValue(M_FOOD_LEVEL_PROPERTY_START + index, cell.mFoodLevelM / 255.0);
mNeuralNetwork.setInputValue(V_FOOD_LEVEL_PROPERTY_START + index, cell.mFoodLevelV / 255.0);
mNeuralNetwork.setInputValue(ENTITY_HEALTH_PROPERTY_START + index, cell.mEntity ? cell.mEntity->getHealth() : 0);
mNeuralNetwork.setInputValue(WATER_LEVEL_PROPERTY_START + index, cell.mWaterLevel / 255.0);
++index;
}
}
mNeuralNetwork.run();
const std::vector<NNType> &output = mNeuralNetwork.outputValues();
NNType moveLeft = output[0];
NNType moveRight = output[1];
NNType moveUp = output[2];
NNType moveDown = output[3];
NNType attackLeft = output[4];
NNType attackRight = output[5];
NNType attackUp = output[6];
NNType attackDown = output[7];
NNType eatV = output[8];
NNType eatM = output[9];
NNType drink = output[10];
NNType split = output[11];
setValueStore1(output[12]);
setValueStore2(output[13]);
setValueStore3(output[14]);
setValueStore4(output[15]);
setActionMoveLeft(moveLeft);
setActionMoveRight(moveRight);
setActionMoveUp(moveUp);
setActionMoveDown(moveDown);
setActionAttackLeft(attackLeft);
setActionAttackRight(attackRight);
setActionAttackUp(attackUp);
setActionAttackDown(attackDown);
setActionEatV(eatV);
setActionEatM(eatM);
setActionDrink(drink);
setActionSplit(split);
NNType bestVal = 0;
Action::Type actionType = Action::None;
#define MAX_ACTION(var, actionEnum) if (var > bestVal) { bestVal = var; actionType = actionEnum; }
MAX_ACTION(moveLeft, Action::MoveLeft);
MAX_ACTION(moveRight, Action::MoveRight);
MAX_ACTION(moveUp, Action::MoveUp);
MAX_ACTION(moveDown, Action::MoveDown);
MAX_ACTION(attackLeft, Action::AttackLeft);
MAX_ACTION(attackRight, Action::AttackRight);
MAX_ACTION(attackUp, Action::AttackUp);
MAX_ACTION(attackDown, Action::AttackDown);
MAX_ACTION(eatV, Action::EatV);
MAX_ACTION(eatM, Action::EatM);
MAX_ACTION(drink, Action::Drink);
MAX_ACTION(split, Action::Split);
++mAge;
mLastAction.mType = actionType;
}
