Genetic-Algorithm/main.c at master · ThiagoLAMF/Genetic-Algorithm · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "util.h"
#include "selecao.h"
#include "defines.h"
#include "crossover.h"
#include "populacao.h"

/** DEC. FUNÇÕES **/
int ag();
/** MAIN **/
int main()
{
    srand(time(NULL));
    int i;
    int contador = 0;

    for(i = 0; i< N_ITERACOES;i++)
    {
        if(ag())
        {
            contador++;
        }
    }

    printf("\n----------AG-----------------\n");
    printf("GERACOES: %d\n",N_GERACOES);
    printf("ITERACOES: %d\n",N_ITERACOES);
    printf("RESULTADO: %d PC\n",(contador));
    return 0;
}

/** FUNÇÕES **/
int ag()
{
    int i;
    int j;

    // GERA POPULAÇÃO:
    int somaAvaliacao;
    int **geracao = GeraPopulacao(&somaAvaliacao);

    for(j = 0; j< N_GERACOES;j++)
    {
        // AG:
        //Ordena os pais(Usado no Elitismo):
        if(ELITISMO)
        {
            quickSort(geracao, 0,TAM_GERACAO-1);
            //printg(geracao);
            //getchar();
        }

        if(ROLETA)
        {
            //Calcula FREQ para seleção. //Usado METODO ROLETA
            CalculaFrequenciaAcumulada(geracao);
        }

        int qtdFilhos = TX_CROSSOVER; //QTD de filhos a serem gerados

        for(i=0;i<qtdFilhos;i= i+2)
        {
            //SELECIONA PAIS PARA CROSSOVER
            int pai1;
            int pai2;
            //TORNEIO:
            if(TORNEIO)
            {
                pai1 = SelecionaTorneio(geracao,3);
                pai2 = SelecionaTorneio(geracao,3);
            }
            if(ROLETA)
            {
                pai1 = SelecionaRoleta(geracao);
                pai2 = SelecionaRoleta(geracao);
                //printf("ROLETA: %d %d\n",pai1,pai2);
            }

            //CROSSOVER
            CrossOverCiclico(geracao[pai1],geracao[pai2],geracao[TAM_GERACAO + i],geracao[TAM_GERACAO + (i+1)] );
            //printf("\n[CROSSOVER] %i \tX %i \tPOS: %i",pai1,pai2,pontoCrossOver);

            //CalculaAvaliacao(geracao[TAM_GERACAO + i]);//alteracao questao 2
            //CalculaAvaliacao(geracao[TAM_GERACAO + (i+1)]);//alteracao questao 2
            //alteracao questao 2
            Mutacao(geracao[TAM_GERACAO + i]);
            Mutacao(geracao[TAM_GERACAO + (i+1)] );
        }
        //MUTAÇÃO
        //MutacaoFilhos(geracao,TX_MUTACAO,qtdFilhos);//alteracao questao 2

        //Elitismo
        if(ELITISMO)
        {
            //Vetor de pais já está ordenado// Mantem os 20 primeiros
            SobeFilhos(geracao,TX_ELITISMO,qtdFilhos,TAM_GERACAO);
        }

        if(MELHORPAISFILHOS)
        {
            //SELECIONA MELHORES:
            quickSort(geracao, 0,TAM_GERACAO+qtdFilhos-1);
        }

        //printg(geracao);
        //getchar();
        if(geracao[0][AVAL] == 0)
        {
            //printind(geracao[0]);
            FreePopulacao(geracao);
            return 1;
        }
    }


    if(VerificaMatriz(geracao))
    {
        //printind(geracao[0]);
        //getchar();
        FreePopulacao(geracao);
        return 1;
    }

    FreePopulacao(geracao);
    return 0;
}