コード例 #1
0
        public override void Run()
        {
            int k = 0, k_max = 3;

            solucao = geraSolucaoAleatoria();

            while (k != k_max)
            {
                if (!pertuba(ref solucao, k))
                {
                    k++;
                }
                else
                {
                    k = 0;
                }

                Iteracoes.Add(avaliar(solucao));
            }
        }
コード例 #2
0
        private void crossover(int[][] solucoesIniciais, int i1, int i2)
        {
            int[] filho1 = new int[n], filho2 = new int[n];

            int i;

            for (i = 0; i < (int)n * taxaCruzamento; i++)
            {
                filho1[i] = solucoesIniciais[i1][i];
                filho2[i] = solucoesIniciais[i2][i];
            }

            for (; i < n; i++)
            {
                filho1[i] = solucoesIniciais[i2][i];
                filho2[i] = solucoesIniciais[i1][i];
            }

            mutacao(filho1);
            mutacao(filho2);

            List <int[]> solucoes = new List <int[]>();

            solucoes.Add(solucoesIniciais[i1]);
            solucoes.Add(solucoesIniciais[i2]);
            solucoes.Add(filho1);
            solucoes.Add(filho2);

            Task <double>[] tasks = solucoes.Select(p => new Task <double>(() => avaliar(p).Item1)).ToArray();

            foreach (Task task in tasks)
            {
                task.Start();
            }

            Task.WaitAll(tasks);

            int melhorPai;
            int melhorFilho;

            if (!minimizar)
            {
                melhorPai   = tasks[0].Result > tasks[1].Result ? 0 : 1;
                melhorFilho = tasks[2].Result > tasks[3].Result ? 2 : 3;
            }
            else
            {
                melhorPai   = tasks[0].Result < tasks[1].Result ? 0 : 1;
                melhorFilho = tasks[2].Result < tasks[3].Result ? 2 : 3;
            }

            if ((tasks[melhorFilho].Result > tasks[melhorPai].Result && !minimizar) ||
                (tasks[melhorFilho].Result < tasks[melhorPai].Result && minimizar))
            {
                Iteracoes.Add(avaliar(solucoes[melhorFilho]));

                tasks = solucoesIniciais.Select(p => new Task <double>(() => avaliar(p).Item1)).ToArray();

                foreach (Task task in tasks)
                {
                    task.Start();
                }

                Task.WaitAll(tasks);

                int min = 0;

                for (int k = 1; k < tasks.Length; k++)
                {
                    if ((tasks[k].Result < tasks[min].Result && !minimizar) ||
                        (tasks[k].Result > tasks[min].Result && minimizar))
                    {
                        min = k;
                    }
                }

                solucoesIniciais[min] = solucoes[melhorFilho];

                ultimaPopulacao = (int[][])solucoesIniciais.Clone();

                contIteracoes++;

                semMelhora = 0;
            }
            else
            {
                semMelhora++;

                if (semMelhora >= 100)
                {
                    solucoesIniciais = (int[][])ultimaPopulacao.Clone();

                    semMelhora = 0;
                    contIteracoes++;
                }
            }
        }
コード例 #3
0
        void pertubaEAvalia()
        {
            int[] novaSolucao = (int[])solucao.Clone();

            int rndPosicao = rand.Next(n);

            int rndPosicao2;

            if (opt == 2)
            {
                do
                {
                    rndPosicao2 = rand.Next(n);
                }while (rndPosicao2 == rndPosicao);

                Task <int>[] funcoes = new Task <int> [2];

                funcoes[0] = new Task <int>(() => selecionaPresc(ref novaSolucao, rndPosicao));
                funcoes[1] = new Task <int>(() => selecionaPresc(ref novaSolucao, rndPosicao2));

                foreach (var task in funcoes)
                {
                    task.Start();
                }

                Task.WaitAll(funcoes);

                novaSolucao[rndPosicao]  = funcoes[0].Result;
                novaSolucao[rndPosicao2] = funcoes[1].Result;
            }
            else
            {
                novaSolucao[rndPosicao] = selecionaPresc(ref novaSolucao, rndPosicao);
            }

            Task <double>[] avaliacoes = new Task <double> [2];

            avaliacoes[0] = new Task <double>(() => avaliar(solucao).Item1);
            avaliacoes[1] = new Task <double>(() => avaliar(novaSolucao).Item1);

            foreach (var task in avaliacoes)
            {
                task.Start();
            }

            Task.WaitAll(avaliacoes);

            double valorNovo = avaliacoes[1].Result, valorAtual = avaliacoes[0].Result;

            if ((valorNovo <= valorAtual && !minimizar) ||
                (valorNovo >= valorAtual && minimizar))
            {
                double z = metropolis(valorAtual, valorNovo);
                double r = rand.NextDouble();

                if (r < z)
                {
                    solucao = novaSolucao;

                    cont++;

                    if (cont >= contIteracao)
                    {
                        Iteracoes.Add(avaliar(solucao));

                        t = t * taxaResf;

                        cont = 0;
                    }
                }
            }
            else
            {
                solucao = novaSolucao;

                cont++;

                if (cont >= contIteracao)
                {
                    Iteracoes.Add(avaliar(solucao));

                    t = t * taxaResf;

                    cont = 0;
                }
            }
        }
コード例 #4
0
        public override void Run()
        {
            solucao = geraSolucaoGulosa(tipo, alfaGrasp);

            if (opt == 3)
            {
                int k = 0, k_max = 3;

                while (k != k_max)
                {
                    for (var i = 0; i < numIteracoesLocal; i++)
                    {
                        while (pertuba(ref solucao, k))
                        {
                            ;
                        }
                    }
                    k++;
                }

                Iteracoes.Add(avaliar(solucao));

                for (var i = 0; i < numIteracoesGuloso; i++)
                {
                    var novaSolucao = geraSolucaoGulosa(tipo, alfaGrasp);

                    k = 0;
                    while (k != k_max)
                    {
                        for (var j = 0; j < numIteracoesLocal; j++)
                        {
                            while (pertuba(ref novaSolucao, k))
                            {
                                ;
                            }
                        }
                        k++;
                    }

                    if ((avaliar(novaSolucao).Item1 > avaliar(solucao).Item1&& !minimizar) ||
                        (avaliar(novaSolucao).Item1 < avaliar(solucao).Item1&& minimizar))
                    {
                        solucao = novaSolucao;
                    }

                    Iteracoes.Add(avaliar(novaSolucao));
                }

                if (!minimizar)
                {
                    Iteracoes = Iteracoes.OrderBy(p => p.Item1).ToList();
                }
                else
                {
                    Iteracoes = Iteracoes.OrderBy(p => - p.Item1).ToList();
                }
            }
            else
            {
                int k = 0;

                for (var i = 0; i < numIteracoesLocal; i++)
                {
                    while (pertuba(ref solucao, k))
                    {
                        ;
                    }
                }

                Iteracoes.Add(avaliar(solucao));

                for (var i = 0; i < numIteracoesGuloso; i++)
                {
                    var novaSolucao = geraSolucaoGulosa(tipo, alfaGrasp);

                    for (var j = 0; j < numIteracoesLocal; j++)
                    {
                        while (pertuba(ref novaSolucao, k))
                        {
                            ;
                        }
                    }


                    if ((avaliar(novaSolucao).Item1 > avaliar(solucao).Item1&& !minimizar) ||
                        (avaliar(novaSolucao).Item1 < avaliar(solucao).Item1&& minimizar))
                    {
                        solucao = novaSolucao;
                    }

                    Iteracoes.Add(avaliar(novaSolucao));
                }

                if (!minimizar)
                {
                    Iteracoes = Iteracoes.OrderBy(p => p.Item1).ToList();
                }
                else
                {
                    Iteracoes = Iteracoes.OrderBy(p => - p.Item1).ToList();
                }
            }
        }