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));
}
}
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++;
}
}
}
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;
}
}
}
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();
}
}
}
