Esempio n. 1
0
 public async Task CalculaAptidaoDaPopulacao(Populacao populacao)
 {
     foreach (var individuo in populacao.Individuos)
     {
         await _servicoDeIndividuo.CalcularAptidao(individuo);
     }
 }
Esempio n. 2
0
        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);
        }
Esempio n. 3
0
        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();
        }
Esempio n. 4
0
        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();
        }
Esempio n. 5
0
        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);
            }
        }
Esempio n. 6
0
        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);
            }
        }
Esempio n. 7
0
        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]);
            }
        }
Esempio n. 8
0
 private void btnCriarPop_Click(object sender, EventArgs e)
 {
     Configuracao.tamanhoPopulacao = int.Parse(labelTamamnhoPop.Text);
     populacao = new Populacao(gerarIndividuos());
     buttonExecutar.Enabled      = true;
     btnExecuteAndExport.Enabled = true;
 }
Esempio n. 9
0
        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);
        }
Esempio n. 10
0
 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));
 }
Esempio n. 12
0
        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());
        }
Esempio n. 14
0
        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());
        }
Esempio n. 15
0
        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);
        }
Esempio n. 16
0
    //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 + ")");
        }
    }
Esempio n. 17
0
        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;
        }
Esempio n. 19
0
        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);
        }
Esempio n. 20
0
        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();
        }
Esempio n. 22
0
        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);
            }
        }
Esempio n. 23
0
        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);
            }
        }
Esempio n. 24
0
        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() }));
            }
        }
Esempio n. 25
0
    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;
    }
Esempio n. 26
0
    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);
 }
Esempio n. 28
0
 public void OrdenarPopulacao()
 {
     Populacao     = Populacao.OrderByDescending(x => x.NotaAvaliacao).ToList();
     MelhorSolucao = Populacao[0];
 }