public async Task CalculaAptidaoDaPopulacao(Populacao populacao)
{
foreach (var individuo in populacao.Individuos)
{
await _servicoDeIndividuo.CalcularAptidao(individuo);
}
}
public async Task <Populacao> NovaGeracao(Populacao populacao)
{
var tamanhoPopulacao = populacao.TamanhoDaPopulacao;
var novaPopulacao = new Populacao();
if (_algoritimo.Elitismo)
{
novaPopulacao.Individuos.Add(populacao.Individuos.OrderBy(x => x.Aptidao).FirstOrDefault());
}
while (novaPopulacao.TamanhoDaPopulacao < tamanhoPopulacao)
{
var pais = SelecaoPorTorneio(populacao);
if (new Random().NextDouble() <= (double)_algoritimo.TaxaDeCrossover)
{
novaPopulacao.Individuos.Add(Crossover(pais[0], pais[1]));
}
else
{
novaPopulacao.Individuos.Add(new Individuo(pais[0].Genes, _algoritimo.Inicio, _algoritimo.TaxaDeMutacao));
novaPopulacao.Individuos.Add(new Individuo(pais[1].Genes, _algoritimo.Inicio, _algoritimo.TaxaDeMutacao));
}
}
await CalculaAptidaoDaPopulacao(novaPopulacao);
return(novaPopulacao);
}
private void btnLimpar_Click(object sender, EventArgs e)
{
pontoCount = 0;
evolucoes = 0;
labelEvolucoes.Text = "00";
populacao.geracao = 0;
contagemEvolucao = 0;
Configuracao.tamanhoPopulacao = 0;
if (!isExportacao)
{
mapa.limpar();
}
populacao = null;
labelQtdeCidades.Text = "--";
buttonCriarPop.Enabled = false;
buttonExecutar.Enabled = false;
buttonLimpar.Enabled = false;
botaoExportarMelhorIndiv.Enabled = false;
btnExecuteAndExport.Enabled = false;
g.Clear(Color.White);
count = 0;
mediaPopulacao.Clear();
zedMedia.Refresh();
}
private void button3_Click(object sender, EventArgs e)
{
random = new Random();
tamanhoDaPopulação = int.Parse(textBox2.Text);
tamanhoDoDNA = textBox1.Text.Length;
elitismo = int.Parse(textBox3.Text);
geneChar = new Gene(getRandomChar);
genesShakespeare = new List <Gene>(tamanhoDoDNA);
for (int i = 0; i < tamanhoDoDNA; i++)
{
genesShakespeare.Add(new Gene(getRandomChar));
}
dnaShakespeare = new DNA(genesShakespeare, fitnessFunction);
populacaoShakespeare = new Populacao(tamanhoDaPopulação, dnaShakespeare, elitismo);
populacaoShakespeare.classificarPopulacao();
listBox1.DataSource = populacaoShakespeare.individuos;
label1.Text = populacaoShakespeare.geracao.ToString();
label2.Text = populacaoShakespeare.melhorIndividuoDeTodasAsGeracoes.ToString();
label3.Text = populacaoShakespeare.melhorIndividuoDeTodasAsGeracoes.fitness.ToString();
}
public Shakespeare(int dnaSize, int populacaoSize, int elitismo, float taxaDeMutacao, string target, Random random)
{
random = new Random();
this.target = target;
this.dna.size = dnaSize;
geneChar = new Gene();
geneChar.getRandomGene = this.getRandomChar();
individuo = new Individuo();
individuo.fitnessFunction = this.avaliarIndividuo(target);
populacao = new Populacao();
populacao.individuo = individuo;
populacao.size = populacaoSize;
populacao.elitismo = elitismo;
populacao.taxaDeMutacao = taxaDeMutacao;
populacao.random = populacao.random;
for (int j = 0; j < populacaoSize; j++)
{
dna = new DNA();
dna.size = dnaSize;
for (int i = 0; i < dnaSize; i++)
{
dna.genes[i] = geneChar.getRandomGene();
}
individuo.dna = dna;
populacao.individuos.Add(individuo);
}
}
public void Cruzamento()
{
int qtdCruzamento = (int)((float)TamanhoPopulacao * TaxaCruzamento);
int qtdReposicao = (int)((float)TamanhoPopulacao * TaxaSelecao);
int modulo = qtdReposicao % 2;
List <IIndividuo> elite = Populacao.Take(qtdCruzamento).ToList();
for (int filho = 0; filho < qtdReposicao; filho += 2)
{
if (filho + 1 < qtdCruzamento)
{
Populacao.Add(RealizarCruzamento(elite[filho], elite[filho + 1]));
Populacao.Add(RealizarCruzamento(elite[filho + 1], elite[filho]));
}
else
{
Populacao.Add(RealizarCruzamento(elite[filho], elite[0]));
Populacao.Add(RealizarCruzamento(elite[0], elite[filho]));
}
}
if (modulo > 0)
{
Populacao.RemoveAt(Populacao.Count - 1);
}
}
private void desenharLinhas(Populacao pop, Color cor)
{
Pen caneta = new Pen(cor, 4);
int geneA, geneB;
Individuo melhor = pop.getMelhorIndividuo();
for (int i = 0; i < Configuracao.tamanhoCromossomo; i++)
{
if (i < Configuracao.tamanhoCromossomo - 1)
{
geneA = melhor.cromossomo[i];
geneB = melhor.cromossomo[i + 1];
}
else
{
geneA = melhor.cromossomo[i];
geneB = melhor.cromossomo[0];
}
int[] coordenadaA = mapa.getCordenadas(geneA);
int[] coordenadaB = mapa.getCordenadas(geneB);
g.DrawLine(caneta, coordenadaA[0], coordenadaA[1], coordenadaB[0], coordenadaB[1]);
}
}
private void btnCriarPop_Click(object sender, EventArgs e)
{
Configuracao.tamanhoPopulacao = int.Parse(labelTamamnhoPop.Text);
populacao = new Populacao(gerarIndividuos());
buttonExecutar.Enabled = true;
btnExecuteAndExport.Enabled = true;
}
public List <string> Resolver(double taxaMutacao, int numeroGeracoes, List <double> espacos, List <double> valores, double limiteEspacos)
{
InicializarPopulacao(espacos, valores, limiteEspacos);
for (int geracao = 0; geracao < numeroGeracoes; geracao++)
{
var somaAvaliacao = SomaAvaliacoes();
List <Individuo> novaPopulacao = new List <Individuo>();
for (int i = 0; i < TamanhoPopulacao; i += 2)
{
var pai1 = SelecionaIndicePai(somaAvaliacao);
var pai2 = SelecionaIndicePai(somaAvaliacao);
var filhos = Populacao[pai1].Crossover(Populacao[pai2]);
novaPopulacao.Add(filhos[0].Mutacao(taxaMutacao));
novaPopulacao.Add(filhos[1].Mutacao(taxaMutacao));
}
Populacao = novaPopulacao;
Populacao.ForEach(x => x.Avaliacao());
OrdenarPopulacao();
MelhorSolucao = Populacao.First();
ListaSolucoes.Add(MelhorSolucao.NotaAvaliacao);
MelhorIndividuo(MelhorSolucao);
}
return(MelhorSolucao.Cromossomo);
}
public void substituir(Populacao populacao, List <Individuo> individuos)
{
for (int i = 0; i < populacao.tamanho; i++)
{
populacao.individuos[i] = individuos[i];
populacao.individuos[i].index = i;
}
}
public Individuo selecionar(Populacao populacao)
{
Individuo[] competidores = new Individuo[this.quantidadeCompetidores];
for (int i = 0; i < competidores.Length; i++)
{
competidores[i] = populacao.individuos[this.random.Next(0, populacao.tamanho - 1)];
}
return(torneio(competidores));
}
public void Selecao()
{
int qtdDescarte = (int)((float)TamanhoPopulacao * TaxaSelecao);
int count = 0;
Populacao = Populacao
.OrderByDescending(x => x.Fitness)
.Take(TamanhoPopulacao - qtdDescarte)
.ToList();
}
public void GerarPopulacao()
{
AlgoritmoGen algoritmoGen = new AlgoritmoGen(0.8, 0.01);
Populacao populacao = new Populacao();
Populacao novaPopulacao = algoritmoGen.ExecutaAG(populacao);
Assert.NotEqual(populacao, novaPopulacao);
Assert.NotEqual(populacao.ToString(), novaPopulacao.ToString());
}
private Individuo[] SelecaoPorTorneio(Populacao populacao)
{
IList <Individuo> individuos = new List <Individuo>()
{
ObterIndividuoAleatorio(populacao),
ObterIndividuoAleatorio(populacao),
ObterIndividuoAleatorio(populacao)
};
return(individuos.OrderBy(x => x.Aptidao).Take(2).ToArray());
}
public void InicializarPopulacao(List <double> espacos, List <double> valores, double limiteEspacos)
{
for (int i = 0; i < TamanhoPopulacao; i++)
{
Populacao.Add(new Individuo(espacos, valores, limiteEspacos));
}
Populacao.ForEach(x => x.Avaliacao());
this.OrdenarPopulacao();
MelhorSolucao = Populacao.First();
ListaSolucoes.Add(MelhorSolucao.NotaAvaliacao);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: public static void main(String[] args) throws java.sql.SQLException
public static void Main(string[] args)
{
//Define a solu��o
Algoritimo.Solucao = 300;
// Ler o arquivo com os genes e respectivos valores e configura as vari�veis de Jobs e Maquinas que est�o no arquivo TXT
Algoritimo.lerArquivo();
//taxa de crossover de 60%
Algoritimo.TaxaDeCrossover = 0.6;
//taxa de muta��o de 3%
Algoritimo.TaxaDeMutacao = 0.3;
//elitismo
bool eltismo = true;
//tamanho da popula��o
int tamPop = 300;
//numero m�ximo de gera��es
int numMaxGeracoes = 5000;
//define o n�mero de genes do indiv�duo baseado na solu��o
int numGenes = Algoritimo.Jobs.Length;
//cria a primeira popula��o aleat�ria
Populacao populacao = new Populacao(numGenes, tamPop);
bool temSolucao = false;
int geracao = 0;
Console.WriteLine("Iniciando... Aptid�o da solu��o: " + Algoritimo.Solucao);
//loop at� o crit�rio de parada
while (!temSolucao && geracao < numMaxGeracoes)
{
geracao++;
//cria nova populacao
populacao = Algoritimo.novaGeracao(populacao, eltismo);
Console.WriteLine("Gera��o " + geracao + " | Aptid�o: " + populacao.getIndivduo(0).Aptidao + " | Melhor: " + populacao.getIndivduo(0).Genes);
//verifica se tem a solucao
temSolucao = populacao.temSolocao(Algoritimo.Solucao);
}
if (geracao == numMaxGeracoes)
{
Console.WriteLine("N�mero Maximo de Gera��es | " + populacao.getIndivduo(0).Genes + " " + populacao.getIndivduo(0).Aptidao);
}
if (temSolucao)
{
Console.WriteLine("Encontrado resultado na gera��o " + geracao + " | " + populacao.getIndivduo(0).Genes + " (Aptid�o: " + populacao.getIndivduo(0).Aptidao + ")");
}
}
public async Task Processar(CancellationToken token)
{
var temSolucao = false;
var populacao = new Populacao(_algoritimo.NumeroDeGenes, _algoritimo.TamanhoDaPopulacao, _algoritimo.Inicio);
await _servicoDePopulacao.CalculaAptidaoDaPopulacao(populacao);
int?melhorAptidao = null;
for (int i = 1; !temSolucao && i <= _algoritimo.MaximoDeGeracoes && !token.IsCancellationRequested; i++)
{
await _servicoDeAtualizacaoDeInterface.IncrementarGeracao();
populacao = await _servicoDePopulacao.NovaGeracao(populacao);
var melhorIndividuoLocal = populacao.Individuos.OrderBy(x => x.Aptidao).FirstOrDefault();
await _servicoDeAtualizacaoDeInterface.DefinirMelhorAptidaoDaGeracao(melhorIndividuoLocal.Aptidao);
await _servicoDeAtualizacaoDeInterface.DefineMelhorCaminhoDaGeracao(melhorIndividuoLocal.Genes);
if (melhorIndividuoLocal.Localizacao == _algoritimo.Solucao)
{
temSolucao = true;
}
if (melhorAptidao >= melhorIndividuoLocal.Aptidao || melhorAptidao == null)
{
melhorAptidao = melhorIndividuoLocal.Aptidao;
await _servicoDeAtualizacaoDeInterface.DefinirMelhorAptidaoGeral(melhorAptidao.Value);
await _servicoDeAtualizacaoDeInterface.DefineMelhorCaminhoGeral(melhorIndividuoLocal.Genes);
}
}
var melhorIndividuo = populacao.Individuos.OrderBy(x => x.Aptidao).FirstOrDefault();
if (_ponto != null)
{
await _ponto.DefinirLocalizacao(melhorIndividuo);
await _servicoDeAtualizacaoDeInterface.DefinirMelhorAptidaoGeral(melhorIndividuo.Aptidao);
await _servicoDeAtualizacaoDeInterface.DefineMelhorCaminhoGeral(melhorIndividuo.Genes);
}
if (!token.IsCancellationRequested)
{
await _servicoDeAtualizacaoDeInterface.FinalizaExecucao();
}
}
private void btnExecucao_Click(object sender, System.EventArgs e)
{
btnExecucao.Enabled = btnPopulacao.Enabled = false;
algoritmoGen = new AlgoritmoGen((double)txtCrossover.Value, (double)txtMutacao.Value);
for (int i = 0; i < txtIteracao.Value; i++)
{
populacao = algoritmoGen.ExecutaAG(populacao);
mediaPopulacao.Add(i, populacao.Media);
grafPopulacao.GraphPane.CurveList.Clear();
grafPopulacao.GraphPane.GraphObjList.Clear();
grafMediaPopulacao.GraphPane.CurveList.Clear();
grafMediaPopulacao.GraphPane.GraphObjList.Clear();
populacaoGrafico = new PointPairList();
for (int j = 0; j < Constantes.TamanhoPopulacao; j++)
{
populacaoGrafico.Add(populacao[j].Valor, populacao[j].Aptidao);
}
LineItem media = paneMediaPopulacao.AddCurve("Média", mediaPopulacao, Color.Red, SymbolType.None);
LineItem func = panePopulacao.AddCurve("Função", curvaGrafico, Color.Red, SymbolType.None);
LineItem individuos = panePopulacao.AddStick("Indivíduos", populacaoGrafico, Color.Blue);
AtualizarGraficoPopulacao();
AtualizarGraficoMediaPopulacao();
}
populacao.OrdenarPopulacao();
StringBuilder pioresIndividuos = new StringBuilder();
for (int i = 0; i < 10; i++)
{
pioresIndividuos.AppendLine(populacao[i].ToString());
}
StringBuilder melhoresIndividuos = new StringBuilder();
for (int i = Constantes.TamanhoPopulacao - 1; i > (Constantes.TamanhoPopulacao - 1) - 10; i--)
{
melhoresIndividuos.AppendLine(populacao[i].ToString());
}
txtMelhoresIndividuos.Text = melhoresIndividuos.ToString();
txtPioresIndividuos.Text = pioresIndividuos.ToString();
btnExecucao.Enabled = btnPopulacao.Enabled = true;
}
public FormShakespeare(FormHome formHome)
{
this.formHome = formHome;
InitializeComponent();
progressBar1.Minimum = 0;
progressBar1.Maximum = 100;
textBox1.Text = "Insira sua frase aqui!";
textBox2.Text = "200";
textBox3.Text = "5";
textBox4.Text = "1";
random = new System.Random();
populacaoTexto = new Populacao();
ag = new Algoritmo(populacaoTexto, random);
}
private Individuo ObterIndividuoAleatorio(Populacao populacao)
{
Random rndElement = new Random();
int index;
if (populacao.Individuos.Count > 1)
{
index = rndElement.Next(0, populacao.Individuos.Count - 1);
return(populacao.Individuos[index]);
}
else
{
return(null);
}
}
private void btnPopulacao_Click(object sender, System.EventArgs e)
{
btnExecucao.Enabled = true;
populacao = new Populacao();
populacaoGrafico = new PointPairList();
for (int i = 0; i < Constantes.TamanhoPopulacao; i++)
{
populacaoGrafico.Add(populacao[i].Valor, populacao[i].Aptidao);
}
LineItem lineItem = panePopulacao.AddStick("Indivíduos", populacaoGrafico, Color.Blue);
AtualizarGraficoPopulacao();
}
public override void GerarPopulacaoInicial()
{
Random rnd = new Random();
int modulo = TamanhoIndividuo % 2;
int metade = (TamanhoIndividuo - modulo) / 2;
for (int individuo = 0; individuo < TamanhoPopulacao; individuo++)
{
IIndividuo ind = new Mochila(TamanhoIndividuo);
for (int cromossomo = 0; cromossomo < metade; cromossomo++)
{
if (((Mochila)ind).Peso < CapacidadeMochila)
{
int ativa = rnd.Next(2);
ind.Cromossomos[cromossomo] = ativa;
if (ativa > 0)
{
((Mochila)ind).Peso += Itens[cromossomo].Peso;
}
ativa = rnd.Next(2);
ind.Cromossomos[cromossomo + metade] = ativa;
if (ativa > 0)
{
((Mochila)ind).Peso += Itens[cromossomo + metade].Peso;
}
}
else
{
ind.Cromossomos[cromossomo] = 0;
ind.Cromossomos[cromossomo + metade] = 0;
}
if (modulo > 0)
{
int ativa = rnd.Next(2);
ind.Cromossomos[TamanhoIndividuo - 1] = ativa;
if (ativa > 0)
{
((Mochila)ind).Peso += Itens[TamanhoIndividuo - 1].Peso;
}
}
}
Populacao.Add(ind);
}
}
public override void GerarPopulacaoInicial()
{
Random rnd = new Random();
for (int individuo = 0; individuo < TamanhoPopulacao; individuo++)
{
List <String> profs = new List <string>();
IIndividuo ind = new QuadroHorarios(TamanhoIndividuo);
for (int cromossomo = 0; cromossomo < TamanhoIndividuo; cromossomo++)
{
String p;
do
{
p = Professores[rnd.Next(Professores.Count)];
}while(profs.Count(x => x == p) > 1);
profs.Add(p);
ind.Cromossomos[cromossomo] = p;
}
Populacao.Add(ind);
}
}
public ActionResult Cadastrar(VMPopulacao entidade)
{
if (ModelState.IsValid)
{
try
{
DateTime dataNasc = DateTime.ParseExact(entidade.DataNascimento, "dd/MM/yyyy", CultureInfo.InvariantCulture);
Populacao obj = PopulacaoBusiness.Consulta.FirstOrDefault(a => string.IsNullOrEmpty(a.UsuarioExclusao) && a.Nome.Equals(entidade.Nome) && a.DataNascimento.Equals(dataNasc));
if (obj == null)
{
obj = new Populacao()
{
UniqueKey = Guid.NewGuid().ToString(),
DataNascimento = dataNasc,
Nome = entidade.Nome,
Sexo = entidade.Sexo,
UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login
};
PopulacaoBusiness.Inserir(obj);
}
IncidenteVeiculoPopulacao rel = new IncidenteVeiculoPopulacao()
{
UKIncidenteVeiculo = entidade.UKIncidenteVeiculo,
UKPopulacao = obj.UniqueKey,
UsuarioInclusao = CustomAuthorizationProvider.UsuarioAutenticado.Login,
AgenteCausador = entidade.AgenteCausador,
Atividade = entidade.Atividade,
Causa = entidade.Causa,
Custo = entidade.Custo,
Lesao = entidade.Lesao,
Natureza = entidade.Natureza,
NivelTensao = entidade.NivelTensao,
SituacaoRede = entidade.SituacaoRede,
TipoAcidente = entidade.TipoAcidente
};
IncidenteVeiculoPopulacaoBusiness.Inserir(rel);
return(Json(new { resultado = new RetornoJSON()
{
Sucesso = "Pessoa cadastrada com sucesso"
} }));
}
catch (Exception ex)
{
if (ex.GetBaseException() == null)
{
return(Json(new { resultado = new RetornoJSON()
{
Erro = ex.Message
} }));
}
else
{
return(Json(new { resultado = new RetornoJSON()
{
Erro = ex.GetBaseException().Message
} }));
}
}
}
else
{
return(Json(new { resultado = TratarRetornoValidacaoToJSON() }));
}
}
public static Individuo[] selecaoTorneio(Populacao populacao)
{
Random r = new Random();
Populacao populacaoIntermediaria = new Populacao(3);
//seleciona 3 indiv�duos aleat�riamente na popula��o
populacaoIntermediaria.Individuo = populacao.getIndivduo(r.Next(populacao.TamPopulacao));
populacaoIntermediaria.Individuo = populacao.getIndivduo(r.Next(populacao.TamPopulacao));
populacaoIntermediaria.Individuo = populacao.getIndivduo(r.Next(populacao.TamPopulacao));
//ordena a popula��o
populacaoIntermediaria.ordenaPopulacao();
Individuo[] pais = new Individuo[2];
//seleciona os 2 melhores deste popula��o
pais[0] = populacaoIntermediaria.getIndivduo(0);
pais[1] = populacaoIntermediaria.getIndivduo(1);
return pais;
}
public static Populacao novaGeracao(Populacao populacao, bool elitismo)
{
Random r = new Random();
//nova popula��o do mesmo tamanho da antiga
Populacao novaPopulacao = new Populacao(populacao.TamPopulacao);
//se tiver elitismo, mant�m o melhor indiv�duo da gera��o atual
if (elitismo)
{
novaPopulacao.Individuo = populacao.getIndivduo(0);
}
//insere novos indiv�duos na nova popula��o, at� atingir o tamanho m�ximo
while (novaPopulacao.NumIndividuos < novaPopulacao.TamPopulacao)
{
//seleciona os 2 pais por torneio
Individuo[] pais = selecaoTorneio(populacao);
Individuo[] filhos = new Individuo[2];
//verifica a taxa de crossover, se sim realiza o crossover, se n�o, mant�m os pais selecionados para a pr�xima gera��o
if (r.NextDouble() <= taxaDeCrossover)
{
filhos = crossover(pais[1], pais[0]);
}
else
{
filhos[0] = new Individuo(pais[0].Genes);
filhos[1] = new Individuo(pais[1].Genes);
}
//adiciona os filhos na nova gera��o
novaPopulacao.Individuo = filhos[0];
novaPopulacao.Individuo = filhos[1];
}
//ordena a nova popula��o
novaPopulacao.ordenaPopulacao();
return novaPopulacao;
}
public bool solucionado(Populacao populacao)
{
return(populacao.geracao >= limite);
}
public void OrdenarPopulacao()
{
Populacao = Populacao.OrderByDescending(x => x.NotaAvaliacao).ToList();
MelhorSolucao = Populacao[0];
}
