void nextPopulation(Individual **population, int populationSize)
{
int i;
int nullCount = 0;
int indA, indB;
int mutationCount = 0;
int* nullIndexes = (int*) malloc(sizeof(int) * populationSize);
if (!nullIndexes)
{
printf("Memory allocation failed.\n");
return;
}
// Selecting the individuals that will be moved to the next population.
// This will be done based only in probability.
for (i = 0; i < populationSize; ++i)
{
// Individuals with good fitness have more probability to be selected.
if (rand() % WORST_FITNESS < -(population[i]->fitness))
{
free(population[i]->solution);
free(population[i]);
population[i] = NULL;
nullIndexes[nullCount++] = i;
}
}
for (i = 0; i < nullCount; ++i)
{
do
{
indA = rand() % populationSize;
} while(population[indA] == NULL);
do
{
indB = rand() % populationSize;
} while(population[indB] == NULL || indA == indB);
population[nullIndexes[i]] = crossover(population[indA], population[indB]);
}
for (i = 0; i < populationSize; ++i)
{
if (rand() % 1000 < 5)
{
mutation(population[i]);
++mutationCount;
}
}
if (verboseMode)
{
printf("copied: %d born: %d mutation: %.2f%% best: ", populationSize - nullCount, nullCount, (double) mutationCount / populationSize * 100);
printIndividual(population[0]);
}
free(nullIndexes);
}
int main(int argc, char * argv[]){
Population * pop, * selected;
Individual * best_solution;
int generation_num;
initParameters(argc, argv);
pop = genSeededPopulation(POP_SIZE);
#if (defined DIVERSITY)
printGeneComposition(pop);
#endif
determineFitness(pop);
sortByFitness(pop);
generation_num = 0;
while(generation_num < MAX_NUM_GENERATIONS){
#if (defined VERBOSE || defined DIVERSITY)
fprintf(stdout, "\n----------------- GENERATION %d -----------------\n", generation_num + 1);
printPopulation(pop);
#endif
// FIX - use function pointers instead of flags + if statement
if(selection_type == 1)
selected = tournamentSelection(pop);
else
selected = randomSelection(pop);
// FIX - use function pointers instead of flags + if statement
evolvePopulation(selected, crossover_type, mutation_type);
determineFitness(selected);
// FIX - use function pointers instead of flags + if statement
if(replacement_type == 1)
pop = replaceAll(pop, selected);
else
pop = retainBest(pop, selected);
generation_num++;
}
fprintf(stdout, "\nFINAL RESULT:\n");
printPopulation(pop);
fprintf(stdout, "\nBEST SOLUTION:\n");
best_solution = findBest(pop);
printIndividual(best_solution);
freePopulation(pop);
freeParameters();
return EXIT_SUCCESS;
}
int main (int argc, char *argv[])
{
int len;
EIBConnection *eibcon;
eibaddr_t eibdest;
eibaddr_t eibsrc;
uchar eibbuf[200];
int tmpeibval;
int sw_verbose = -1;
FILE *fh_cfg_file = NULL; // Файл с соответствиями KNX телеграммы <-> IPкоманды
listGroupAddr myListGA[LENGTH_OF_LIST_OF_GADDR];
eibaddr_t testga;
int index_gaddr; // index for group address array
char *parsed_cfg_str; // Будет равна LENGTH_OF_CMD_STR
char mcom[] = "next\n";
int size_of_list_gaddr; // real length of list of group address - counting due to read
if (argc < 3)
die ("usage: %s Url(ip:localhost:6720) file(with list of cmd)", argv[0]);
//Prepare KNX connection
if (argc > 3)
sw_verbose = strncmp(argv[3], "--v", 3); // Выводить сообщения в stdout если присутствует ключ --v
else
sw_verbose = 1;
eibcon = EIBSocketURL (argv[1]);
if (!eibcon)
die ("Open failed");
if (EIBOpen_GroupSocket (eibcon, 0) == -1)
die ("Connect failed");
//Fill array from file
if((fh_cfg_file = fopen(argv[2], "r")) == NULL)
die ("Error Open file with list of group address");
// Читаем командные строки из конфигурационного файла и заполняем массив структур myListGA
index_gaddr = 0;
parsed_cfg_str = (char*)malloc(LENGTH_OF_CMD_STR * sizeof(char));
while(fgets(parsed_cfg_str, LENGTH_OF_CMD_STR, fh_cfg_file) != NULL) {
// Здесь парсим строку
convert_str_to_myListGA(parsed_cfg_str, myListGA, index_gaddr);
index_gaddr++;
if(index_gaddr == LENGTH_OF_LIST_OF_GADDR)
break;
}
free(parsed_cfg_str);
size_of_list_gaddr=index_gaddr; // real number of monitoring group address
if(sw_verbose == 0) {
for(index_gaddr=0; index_gaddr != size_of_list_gaddr; index_gaddr++)
printf("Result N:%d -> %s - %d - %s - %d - %s - %X\n", index_gaddr, myListGA[index_gaddr].group_addr,\
myListGA[index_gaddr].value, myListGA[index_gaddr].send_to_ip, myListGA[index_gaddr].send_to_port,\
myListGA[index_gaddr].cmd_string, myListGA[index_gaddr].group_addr_in_hex);
}
fclose(fh_cfg_file);
while (1) {
len = EIBGetGroup_Src (eibcon, sizeof (eibbuf), eibbuf, &eibsrc, &eibdest);
if (len == -1)
die ("Read failed");
if (len < 2)
die ("Invalid Packet");
if ((eibbuf[0] & 0x3) || (eibbuf[1] & 0xC0) == 0xC0) {
if(sw_verbose == 0) {
printf ("Unknown APDU from ");
printIndividual (eibsrc);
printf (" to ");
printGroup (eibdest);
printf (": ");
printHex (len, eibbuf);
printf ("\n");
}
}
else {
if(sw_verbose == 0) {
switch (eibbuf[1] & 0xC0) {
case 0x00:
printf ("Read");
break;
case 0x40:
printf ("Response");
break;
case 0x80:
printf ("Write");
break;
}
printf (" from ");
printIndividual (eibsrc);
printf (" to ");
printGroup (eibdest);
if (eibbuf[1] & 0xC0) {
printf (": ");
if (len == 2) {
printf ("%02X", eibbuf[1] & 0x3F);
}
else
printHex (len - 2, eibbuf + 2);
}
printf(" Destination in HEX is -> %X ", eibdest);
}
tmpeibval = eibbuf[1] & 0x3F;
for(index_gaddr=0; index_gaddr != size_of_list_gaddr; index_gaddr++) {
if((myListGA[index_gaddr].group_addr_in_hex == eibdest) && (myListGA[index_gaddr].value == tmpeibval)) {
if(sw_verbose == 0) {
printf("\n Caught command => %s \n", myListGA[index_gaddr].cmd_string);
}
mpdControl(myListGA[index_gaddr].cmd_string, myListGA[index_gaddr].send_to_ip, myListGA[index_gaddr].send_to_port, sw_verbose);
}
}
fflush (stdout);
}
}
EIBClose (eibcon);
return 0;
}
int main() {
struct Ordered_container* people;
struct Ordered_container* rooms;
people = OC_create_container((OC_comp_fp_t)comparePeople);
rooms = OC_create_container((OC_comp_fp_t)compareRooms);
while (1) {
char cmd1;
char cmd2;
printf("\nEnter command: ");
scanf(" %c", &cmd1);
scanf("%c", &cmd2);
switch (cmd1) {
case 'p':
switch (cmd2) {
case 'i':
printIndividual(people);
break;
case 'r':
printRoom(rooms);
break;
case 'm':
printMeeting(rooms);
break;
case 's':
printSchedule(rooms);
break;
case 'g':
printGroup(people);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 'a':
switch (cmd2) {
case 'i':
addIndividual(people);
break;
case 'r':
addRoom(rooms);
break;
case 'm':
addMeeting(rooms);
break;
case 'p':
addParticipant(rooms, people);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 'r':
switch (cmd2) {
case 'm':
rescheduleMeeting(rooms);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 'd':
switch (cmd2) {
case 'i':
deleteIndividual(people, rooms);
break;
case 'r':
deleteRoom(rooms);
break;
case 'm':
deleteMeeting(rooms);
break;
case 'p':
deleteParticipant(rooms, people);
break;
case 's':
deleteSchedule(rooms);
break;
case 'g':
deleteGroup(rooms, people);
break;
case 'a':
deleteAll(rooms, people);
break;
default:
printErrUnrecCmd();
break;
}
break;
case 's':
break;
case 'l':
break;
case 'q':
switch (cmd2) {
case 'q' :
printf("All meetings deleted\n");
printf("All rooms deleted\n");
printf("All persons deleted\n");
printf("Done\n");
return 0;
break;
default:
printErrUnrecCmd();
break;
}
break;
default:
printErrUnrecCmd();
break;
}
}
return 0;
}
int main(int argc, char** argv)
{
int i, j;
Individual **population;
int individualCount;
int numSteps;
int maxSolutions = 1;
srand(time(NULL));
if (argc < 4)
{
printf("\n\nInvalid parameters. Use: %s N_QUEENS POPULATION_SIZE STEPS MAX_SOLUTIONS\n\n", argv[0]);
return 0;
}
nQueens = atoi(argv[1]);
individualCount = atoi(argv[2]);
numSteps = atoi(argv[3]);
if (argc > 4)
{
maxSolutions = atoi(argv[4]);
}
if (argc > 5)
{
if (!strcmp("-v", argv[5]))
verboseMode = 1;
}
if (nQueens % 2)
{
printf("\nNUM_QUEENS must be an even number.\n");
return 0;
}
printf("-----------------------------------------------\n");
printf("Solving %d queens problem.\n", nQueens);
printf("Population size: %d\n", individualCount);
printf("Max number of generation(s): %d\n", numSteps);
printf("Will stop after finding %d solution(s)\n", maxSolutions);
printf("-----------------------------------------------\n");
population = (Individual**) malloc (sizeof(Individual*) * individualCount);
for (i = 0; i < individualCount; ++i)
{
population[i] = createIndividual();
}
for (i = 0; i < numSteps; ++i)
{
qsort(population, individualCount, sizeof(Individual*), compareIndividuals);
j = 0;
while (population[j]->fitness == 0)
++j;
if (j >= maxSolutions)
{
printf("Population #%d.\n", i + 1);
j = 0;
while (population[j]->fitness == 0 && j < maxSolutions)
{
printf("Solution %d: ", j + 1);
printIndividual(population[j++]);
}
break;
}
if (verboseMode)
{
printf("Building population %d: ", i);
}
nextPopulation(population, individualCount);
}
printf("\n");
for (i = 0; i < individualCount; ++i)
{
free(population[i]->solution);
free(population[i]);
}
free(population);
return 0;
}
int main(int argc, char **argv){
tspsMap_t map;
tspsConfig_t config;
tspsPopulation_t population;
unsigned long int numGenerations = 0;
int mpiNumProcs = 0;
double start, end;
//starting MPI directives
MPI_Init(NULL,NULL);
MPI_Comm_size(MPI_COMM_WORLD,&mpiNumProcs);
MPI_Comm_rank(MPI_COMM_WORLD,&mpiId);
logg("* Starting tspgen...\n");
// parse the command line args
if(readConfig(&config, argc, argv) != TSPS_RC_SUCCESS){
return TSPS_RC_FAILURE;
}
// parse the map
logg("* Parsing map...\n");
if(parseMap(&map) != TSPS_RC_SUCCESS){
logg("Error! Unable to read map 'maps/brazil58.tsp'!\n");
return TSPS_RC_FAILURE;
}
// initialize random seed:
srand ( time(NULL)*mpiId );
logg("* Generating population...\n");
if(generatePopulation(&population, &config) != TSPS_RC_SUCCESS){
logg("Error! Failed to create a new random population!");
return TSPS_RC_FAILURE;
}
// start a timer (mpi_barrier + mpi_wtime)
MPI_Barrier(MPI_COMM_WORLD);
start = MPI_Wtime();
logg("* Initializing reproduction loop...\n");
while(1){
numGenerations++;
calculateFitnessPopulation(&population, &map);
if(numGenerations % 500 == 0){
logg("- Generation %d...\n", numGenerations);
printIndividual(&population.individuals[0], "Current Top Individual");
}
sortPopulation(&population);
if(config.numGenerations > 0 && numGenerations == config.numGenerations){
logg("* Max number of generations [%d] reached!\n", config.numGenerations);
break;
}
crossoverPopulation(&population, &config);
mutatePopulation(&population, &config);
// migrate population at every n generation
if(numGenerations % config.migrationRate == 0){
migrateIndividuals(&population, mpiId, mpiNumProcs, &config);
}
}
// join all the populations
joinPopulations(&population, mpiId, mpiNumProcs);
sortPopulation(&population);
// get the best inidividual and print it
printIndividual(&population.individuals[0], "Top Individual");
printIndividual(&population.individuals[config.populationSize-1], "Worst (of the top ones) Individual");
// stop the timer
MPI_Barrier(MPI_COMM_WORLD); /* IMPORTANT */
end = MPI_Wtime();
if(mpiId == 0) { /* use time on master node */
printf("* Runtime = %f\n", end-start);
}
logg("* tspgen finished!\n");
free(population.individuals);
free(map.nodes);
MPI_Finalize();
return TSPS_RC_SUCCESS;
}
