public MenusPOO(IBanco banco, ITelespectador telespectador, IIndividuo individuo, IPoo poo)
{
_banco = banco;
_telespectador = telespectador;
_individuo = individuo;
_poo = poo;
}
public IIndividuo GenerarDescendencia(IIndividuo individuo)
{
var descendiente = new IndividuoBase(individuo.Cromosoma.CantidadGenes);
descendiente.Genotipo = individuo.Genotipo;
return descendiente;
}
public override float CalculaFitness(IIndividuo ind)
{
float fitness = 0;
List<String> profs = new List<string>();
for (int cromossomo = 0; cromossomo < TamanhoIndividuo; cromossomo++)
{
String prof = (String)ind.Cromossomos[cromossomo];
String hor = Horarios[cromossomo];
profs.Add(prof);
if (profs.Count(x => x == prof) < 3)
{
if (Restricoes.Contains(prof + "_" + hor))
fitness = fitness - 1;
else
fitness++;
}
else
{
fitness = fitness - 1;
}
}
return fitness;
}
public override float CalculaFitness(IIndividuo ind)
{
float fitness = 0;
List <String> profs = new List <string>();
for (int cromossomo = 0; cromossomo < TamanhoIndividuo; cromossomo++)
{
String prof = (String)ind.Cromossomos[cromossomo];
String hor = Horarios[cromossomo];
profs.Add(prof);
if (profs.Count(x => x == prof) < 3)
{
if (Restricoes.Contains(prof + "_" + hor))
{
fitness = fitness - 1;
}
else
{
fitness++;
}
}
else
{
fitness = fitness - 1;
}
}
return(fitness);
}
private void MutarIndividuo(IIndividuo individuo)
{
var indiceGen = new Random((int)DateTime.Now.Ticks).Next(0, individuo.Cromosoma.CantidadGenes -1);
var genMutado = individuo.Cromosoma.Genes.GetValue(indiceGen) as IGen;
genMutado.Mutar(_parametrosMutacion.IndiceMutacion);
}
private Tuple<IIndividuo, IIndividuo> CruzarIndividuos(IIndividuo individuo1, IIndividuo individuo2)
{
IIndividuo hijo1 = individuo1.GenerarDescendencia(individuo1);
for (int indiceGen = 0; indiceGen < individuo1.Cromosoma.CantidadGenes; indiceGen++)
{
if (_generador.Next(0, 100) >= 50)
{
var genPadre = individuo1.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo1.Cromosoma.Genes.SetValue(genPadre.Clonar(), indiceGen);
}
else
{
var genMadre = individuo2.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo1.Cromosoma.Genes.SetValue(genMadre.Clonar(), indiceGen);
}
}
IIndividuo hijo2 = individuo1.GenerarDescendencia(individuo1);
for (int indiceGen = 0; indiceGen < individuo1.Cromosoma.CantidadGenes; indiceGen++)
{
if (_generador.Next(0, 100) >= 50)
{
var genPadre = individuo1.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo2.Cromosoma.Genes.SetValue(genPadre.Clonar(), indiceGen);
}
else
{
var genMadre = individuo2.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo2.Cromosoma.Genes.SetValue(genMadre.Clonar(), indiceGen);
}
}
return new Tuple<IIndividuo, IIndividuo>(hijo1, hijo2);
}
private Tuple<IIndividuo, IIndividuo> CruzarIndividuos(IIndividuo individuo1, IIndividuo individuo2)
{
IIndividuo hijo1 = individuo1.GenerarDescendencia(individuo1);
IIndividuo hijo2 = individuo1.GenerarDescendencia(individuo1);
for (int indiceGen = 0; indiceGen <= _parametrosCruzamiento.Mascara.Length - 1; indiceGen++)
{
if (_parametrosCruzamiento.Mascara[indiceGen] == 'P')
{
var genPadre = individuo1.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo1.Cromosoma.Genes.SetValue(genPadre.Clonar(), indiceGen);
var genMadre = individuo1.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo2.Cromosoma.Genes.SetValue(genMadre.Clonar(), indiceGen);
}
else
{
var genMadre = individuo1.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo1.Cromosoma.Genes.SetValue(genMadre.Clonar(), indiceGen);
var genPadre = individuo1.Cromosoma.Genes.GetValue(indiceGen) as IGen;
hijo2.Cromosoma.Genes.SetValue(genPadre.Clonar(), indiceGen);
}
}
return new Tuple<IIndividuo, IIndividuo>(hijo1, hijo2);
}
private void CargarPoblacionInicial()
{
var genes1 = Array.CreateInstance(typeof(IGen), 3);
var genBasico1A = MockRepository.GenerateMock<IGen>();
var genBasico1B = MockRepository.GenerateMock<IGen>();
var genBasico1C = MockRepository.GenerateMock<IGen>();
genes1.SetValue(genBasico1A, 0);
genes1.SetValue(genBasico1A, 1);
genes1.SetValue(genBasico1A, 2);
this._individuo1h = MockRepository.GenerateMock<IIndividuo>();
this._individuo1h.Expect(e => e.Cromosoma).Return(new Cromosoma(Array.CreateInstance(typeof(IGen), 3))).Repeat.Any();
this._individuo1 = MockRepository.GenerateMock<IIndividuo>();
this._individuo1.Expect(e => e.Cromosoma).Return(new Cromosoma(genes1)).Repeat.Any();
this._individuo1.Expect(e => e.GenerarDescendencia(_individuo1)).Return(_individuo1h);
var genes2 = Array.CreateInstance(typeof(IGen), 3);
var genBasico2A = MockRepository.GenerateMock<IGen>();
var genBasico2B = MockRepository.GenerateMock<IGen>();
var genBasico2C = MockRepository.GenerateMock<IGen>();
genes2.SetValue(genBasico2A, 0);
genes2.SetValue(genBasico2A, 1);
genes2.SetValue(genBasico2A, 2);
this._individuo2h = MockRepository.GenerateMock<IIndividuo>();
this._individuo2h.Expect(e => e.Cromosoma).Return(new Cromosoma(Array.CreateInstance(typeof(IGen), 3))).Repeat.Any();
this._individuo2 = MockRepository.GenerateMock<IIndividuo>();
this._individuo2.Expect(e => e.Cromosoma).Return(new Cromosoma(genes2)).Repeat.Any();
this._individuo2.Expect(e => e.GenerarDescendencia(_individuo2)).Return(_individuo2h);
var genes3 = Array.CreateInstance(typeof(IGen), 3);
var genBasico3A = MockRepository.GenerateMock<IGen>();
var genBasico3B = MockRepository.GenerateMock<IGen>();
var genBasico3C = MockRepository.GenerateMock<IGen>();
genes3.SetValue(genBasico3A, 0);
genes3.SetValue(genBasico3A, 1);
genes3.SetValue(genBasico3A, 2);
this._individuo3h = MockRepository.GenerateMock<IIndividuo>();
this._individuo3h.Expect(e => e.Cromosoma).Return(new Cromosoma(Array.CreateInstance(typeof(IGen), 3))).Repeat.Any();
this._individuo3 = MockRepository.GenerateMock<IIndividuo>();
this._individuo3.Expect(e => e.Cromosoma).Return(new Cromosoma(genes3)).Repeat.Any();
this._individuo3.Expect(e => e.GenerarDescendencia(_individuo3)).Return(_individuo3h);
var genes4 = Array.CreateInstance(typeof(IGen), 3);
var genBasico4A = MockRepository.GenerateMock<IGen>();
var genBasico4B = MockRepository.GenerateMock<IGen>();
var genBasico4C = MockRepository.GenerateMock<IGen>();
genes4.SetValue(genBasico1A, 0);
genes4.SetValue(genBasico1A, 1);
genes4.SetValue(genBasico1A, 2);
this._individuo4h = MockRepository.GenerateMock<IIndividuo>();
this._individuo4h.Expect(e => e.Cromosoma).Return(new Cromosoma(Array.CreateInstance(typeof(IGen), 3))).Repeat.Any();
this._individuo4 = MockRepository.GenerateMock<IIndividuo>();
this._individuo4.Expect(e => e.Cromosoma).Return(new Cromosoma(genes4)).Repeat.Any();
this._individuo4.Expect(e => e.GenerarDescendencia(_individuo4)).Return(_individuo4h);
this._individuos = new List<IIndividuo>() { this._individuo1, this._individuo2, this._individuo3, this._individuo4 };
this._poblacion = new Poblacion(_individuos);
this._poblacion.CantidadIndividuos = 4;
}
private void AtualizaFitness()
{
foreach (IIndividuo individuo in Populacao)
{
individuo.Fitness = CalculaFitness(individuo);
if (Solucao.Fitness < individuo.Fitness)
{
Solucao = individuo;
}
}
}
public decimal Evaluar(IIndividuo individuo)
{
if (individuo.Genotipo == typeof(IndividuoTablero))
{
return this.AnalizarReinas(individuo.Cromosoma);
}
else
{
return 0;
}
}
public decimal Evaluar(IIndividuo columna)
{
if (columna.Genotipo != typeof(IndividuoColumna))
{
return 0;
}
else
{
var alto = ((IGen)columna.Cromosoma.Genes.GetValue(0)).Valor;
var largo =((IGen)columna.Cromosoma.Genes.GetValue(1)).Valor;
var peso = ((IGen)columna.Cromosoma.Genes.GetValue(2)).Valor;
var salto = ((decimal)alto + ((decimal)largo / ((decimal)largo + (decimal)alto))) * (1 / (decimal)peso);
return salto;
}
}
public override IIndividuo RealizarCruzamento(IIndividuo a, IIndividuo b)
{
IIndividuo novo = new QuadroHorarios(TamanhoIndividuo);
int modulo = TamanhoIndividuo % 2;
int metade = (TamanhoIndividuo - modulo) / 2;
for (int indice = 0; indice < metade; indice++)
{
novo.Cromossomos[indice] = a.Cromossomos[indice];
}
for (int indice = metade; indice < TamanhoIndividuo; indice++)
{
novo.Cromossomos[indice] = b.Cromossomos[indice];
}
return(novo);
}
public override float CalculaFitness(IIndividuo ind)
{
int peso = 0;
int utilidade = 0;
float fitness = 0;
for (int cromossomo = 0; cromossomo < TamanhoIndividuo; cromossomo++)
{
if ((int)ind.Cromossomos[cromossomo] > 0)
{
peso = peso + Itens[cromossomo].Peso;
utilidade = utilidade + Itens[cromossomo].Utilidade;
}
}
((Mochila)ind).Peso = peso;
((Mochila)ind).Utilidade = utilidade;
fitness = (float)utilidade;
if (peso > CapacidadeMochila)
fitness = -fitness;
return fitness;
}
public override float CalculaFitness(IIndividuo ind)
{
int peso = 0;
int utilidade = 0;
float fitness = 0;
for (int cromossomo = 0; cromossomo < TamanhoIndividuo; cromossomo++)
{
if ((int)ind.Cromossomos[cromossomo] > 0)
{
peso = peso + Itens[cromossomo].Peso;
utilidade = utilidade + Itens[cromossomo].Utilidade;
}
}
((Mochila)ind).Peso = peso;
((Mochila)ind).Utilidade = utilidade;
fitness = (float)utilidade;
if (peso > CapacidadeMochila)
{
fitness = -fitness;
}
return(fitness);
}
public void RegistrarIndividuo(IIndividuo individuo)
{
_individuosRegistrados.Add(individuo.Genotipo, individuo);
}
public override void RealizarMutacao(IIndividuo a)
{
Random rnd = new Random();
int p;
do
{
p = rnd.Next(10);
} while (p == 0);
a.Cromossomos[rnd.Next(TamanhoIndividuo - 1)] = p;
}
public abstract void RealizarMutacao(IIndividuo a);
public abstract float CalculaFitness(IIndividuo ind);
public abstract void RealizarMutacao(IIndividuo a);
public abstract IIndividuo RealizarCruzamento(IIndividuo a, IIndividuo b);
public override void RealizarMutacao(IIndividuo a)
{
Random rnd = new Random();
a.Cromossomos[rnd.Next(TamanhoIndividuo)] = rnd.Next(2);
}
public abstract float CalculaFitness(IIndividuo ind);
public override void RealizarMutacao(IIndividuo a)
{
Random rnd = new Random();
a.Cromossomos[rnd.Next(TamanhoIndividuo)] = rnd.Next(2);
}
public override IIndividuo RealizarCruzamento(IIndividuo a, IIndividuo b)
{
IIndividuo novo = new Mochila(TamanhoIndividuo);
int modulo = TamanhoIndividuo % 2;
int metade = (TamanhoIndividuo - modulo) / 2;
for (int indice = 0; indice < metade; indice++)
novo.Cromossomos[indice] = a.Cromossomos[indice];
for (int indice = metade; indice < TamanhoIndividuo; indice++)
novo.Cromossomos[indice] = b.Cromossomos[indice];
return novo;
}
public abstract IIndividuo RealizarCruzamento(IIndividuo a, IIndividuo b);
public override void RealizarMutacao(IIndividuo a)
{
Random rnd = new Random();
a.Cromossomos[rnd.Next(TamanhoIndividuo - 1)] = Professores[rnd.Next(Professores.Count)];
}
public bool verificaRepetidoColuna(int elemento, int posIndividuo, IIndividuo ind)
{
if ((posIndividuo > 8))
{
int cont = posIndividuo - 9;
bool continua = true;
int number;
while (continua)
{
number = (int)ind.Cromossomos[cont];
if (number == elemento)
{
return true;
}
if (cont % 9 < 9)
{
continua = false;
return false;
}
cont = cont - 9;
}
}
return false;
}
public bool verificaRepetidoLinha(int elemento, int posIndividuo, IIndividuo ind)
{
if((posIndividuo % 9 != 0))
{
int cont = posIndividuo-1;
bool continua = true;
int number;
while (continua)
{
number = (int)ind.Cromossomos[cont];
if (number == elemento)
{
return true;
}
if (cont % 9 == 0)
{
continua = false;
return false;
}
cont--;
}
}
return false;
}
public override float CalculaFitness(IIndividuo ind)
{
int posSudoku = 0;
float fitness = 0;
//Percorrendo cada quadro do sudoku
for (int qtdQuadrado = 1; qtdQuadrado < 10; qtdQuadrado++)
{
int[] vetorValidacao = new int[10];
//zerando vetor que será utilizado para calcular o fitness do indivíduo
for (int i = 0; i < 10; i++)
{
vetorValidacao[i] = 0;
}
//percorrendo elementos do quadrado
int pos = posSudoku;
for (int elemento = 1; elemento < 10; elemento++)
{
//verifica se o número não é repetido
if (vetorValidacao[(int)ind.Cromossomos[pos]] == 0)
vetorValidacao[(int)ind.Cromossomos[pos]]++;
else//em caso do número for repetido
{
fitness--;
break;
}
//se chegar a este ponto, é pq o quadrado não possui números repetidos
if (elemento == 9)
fitness++;
//se tiver percorrido uma linha completa do quadro, pula para a próxima
if ((elemento) % 3 == 0)
pos = pos + 7;
else
pos++;
}
if (qtdQuadrado % 3 == 0)
posSudoku = posSudoku + 21;
else
posSudoku = posSudoku + 3;
}
//percorrendo cada linha do sudoku
posSudoku = 0;
for (int linha = 1; linha < 10; linha++)
{
int[] vetorValidacao = new int[10];
//zerando vetor que será utilizado para calcular o fitness do indivíduo
for (int i = 0; i < 10; i++)
{
vetorValidacao[i] = 0;
}
//percorrendo os elementos da linha
int pos = posSudoku;
for (int elemento = 0; elemento < 9; elemento++)
{
if (vetorValidacao[(int)ind.Cromossomos[pos]] == 0)
vetorValidacao[(int)ind.Cromossomos[pos]]++;
else
{
fitness--;
break;
}
pos++;
if (elemento == 8)
fitness++;
}
posSudoku = posSudoku + 9;
}
//Percorrendo cada coluna do sudoku
posSudoku = 0;
for (int coluna = 0; coluna < 9; coluna++)
{
int[] vetorValidacao = new int[10];
//zerando vetor que será utilizado para calcular o fitness do indivíduo
for (int i = 0; i < 10; i++)
{
vetorValidacao[i] = 0;
}
//percorrendo os elementos da coluna
int pos = coluna;
for (int elemento = 0; elemento < 9; elemento++)
{
if (vetorValidacao[(int)ind.Cromossomos[pos]] == 0)
vetorValidacao[(int)ind.Cromossomos[pos]]++;
else
{
fitness--;
break;
}
posSudoku = posSudoku + 9;
if (elemento == 8)
fitness++;
}
}
return fitness;
}
public override void RealizarMutacao(IIndividuo a)
{
Random rnd = new Random();
a.Cromossomos[rnd.Next(TamanhoIndividuo - 1)] = Professores[rnd.Next(Professores.Count)];
}
public ItemDeMenuRepresentarPessoa(IIndividuo individuo)
{
_individuo = individuo;
}
