public Cromosoma CrearCromosoma(List <String> lista, List <Rectangulo> miListaPiezas)
{
Cromosoma test = new Cromosoma(lista);
CalcularCromosoma(test, miListaPiezas);
return(test);
}
/// <summary>
/// Este evento se lanza al dar click en el botón de iniciar simulación
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void bIniciarSimulacion_Click(object sender, EventArgs e)
{
// Revisamos si existen los puntos a evaluar
if (puntos != null)
{
delay = Int32.Parse(tbDelay.Text);
poblacionInicial = Int32.Parse(tbPoblacionSize.Text);
mutacion = Double.Parse(tbPMutacion.Text) / 100;
maxGeneraciones = Int32.Parse(tbMaxGeneraciones.Text);
variedad = Int32.Parse(tbVariacion.Text);
poblacionParaCruza = poblacionInicial / 2;
poblacionFavorecida = poblacionParaCruza / 2;
longitudCorte = numeroCiudades / 5;
conjuntoSolucion = new Cromosoma[poblacionInicial];
for (int i = 0; i < poblacionInicial; i++)
{
conjuntoSolucion[i] = new Cromosoma(puntos, mutacion, longitudCorte);
conjuntoSolucion[i].CalculaCosto();
}
Cromosoma.QuickSort(conjuntoSolucion, 0, conjuntoSolucion.Length - 1);
mapArea.Invalidate();
generacion = 0;
Simular();
}
else
{
MessageBox.Show("¡Debes generar las ciudades antes!");
}
}
public void CalcularCromosoma(Cromosoma cromosoma, List <Rectangulo> listaPiezas)
{
cromosoma.Arbol = Utilitarios.ConstruirArbolYCalcularPosicionesAPartirDeLista(cromosoma.ListaGenes, listaPiezas);
AlgoritmoStocks algoritmoStocks = new AlgoritmoStocks(listaStocks, cromosoma.Arbol);
cromosoma.Fitness = Utilitarios.CalcularDesperdicio(listaStocks, listaPiezas);
//cromosoma.Fitness = Utilitarios.CalcularFitness(cromosoma.Arbol, listaPiezas, pesoFactorMinimizacion, pesoFactorCuadratura);
}
public void Debug_prueba(List <Rectangulo> milistaPiezas)
{
//Cromosoma test = new Cromosoma(new List<string>() { "3", "4", "H", "1", "2", "V", "H"});
Cromosoma test = new Cromosoma(new List <string>()
{
"7N", "3R", "H", "4R", "H", "8N", "V", "6N", "V", "10N", "2R", "H", "5R", "V", "9R", "V", "1R", "H", "H"
});
CalcularCromosoma(test, milistaPiezas);
mejorCromosoma = test;
}
public Cromosoma UnirOperadoresYPiezas(List <String> listaOperadores, List <String> listaPiezas)
{
Cromosoma descendiente = new Cromosoma();
for (int i = 0; i < listaOperadores.Count; ++i)
{
if (listaOperadores[i] == "") // si el espacio es de una pieza
{
listaOperadores[i] = listaPiezas[0];
listaPiezas.RemoveAt(0);
}
}
descendiente.ListaGenes = listaOperadores;
return(descendiente);
}
private List<Cromosoma> obtenerPoblacionInicial(int population)
{
List<Cromosoma> initPop = new List<Cromosoma>();
GeneticAlgo RandomGen = new GeneticAlgo();
for (int i = 0; i < population; i++)
{
List<int> genes = new List<int>(new int[] {0, 1, 2, 3, 4, 5, 6, 7});
Cromosoma chromosome = new Cromosoma();
chromosome.genes = new int[8];
for (int j = 0; j < 8; j++)
{
int geneIndex = (int)(RandomGen.obtenerAleatorio(0,genes.Count-1)+0.5);
chromosome.genes[j] = genes[geneIndex];
genes.RemoveAt(geneIndex);
}
initPop.Add(chromosome);
}
return initPop;
}
public AlgoritmoGenetico(int numMaxGeneraciones, List <Rectangulo> listaPiezas, double probabilidadMutacion,
int tamanhoPoblacion, double pesoFactorMinimizacion, double pesoFactorCuadratura,
int cantElitismo, List <Stock> listaStocks, BackgroundWorker worker)
{
// Iniciar parámetros del algoritmo
System.Random rnd = new System.Random();
this.worker = worker;
this.pesoFactorMinimizacion = pesoFactorMinimizacion;
this.pesoFactorCuadratura = pesoFactorCuadratura;
this.listaStocks = listaStocks;
// Crear la poblacion inicial
Poblacion poblacion = CalcularPoblacionInicial(tamanhoPoblacion, probabilidadMutacion, listaPiezas, rnd);
this.mejorCromosoma = poblacion.ListaCromosomas[0];
// Calcular hasta un maximo de generaciones (o agregar condicion de parada de Nilton)
for (int i = 0; i < numMaxGeneraciones; ++i)
{
// Calculo la nueva poblacion a partir de la anterior
poblacion = CalcularSiguienteGeneracion(poblacion, cantElitismo, probabilidadMutacion, tamanhoPoblacion, rnd);
// Luego, calculo sus posiciones y area. Esto es netamente cálculo, nada del algoritmo u aleatorio
foreach (Cromosoma cromosoma in poblacion.ListaCromosomas)
{
CalcularCromosoma(cromosoma, listaPiezas);
}
poblacion.OrdenarPoblacionPorFitness();
// Codigo para indicar el porcentaje de avance en la barra de cargando
int progreso = (int)(i * 1.0 / (numMaxGeneraciones - 1) * 100);
worker.ReportProgress(progreso);
}
this.mejorCromosoma = poblacion.ListaCromosomas[0];
//List<String> listaDebug = new List<string>() { "2R", "3R", "6R", "H", "H", "1N", "4N", "10R", "9R", "V", "8N", "H", "5N", "7N", "H", "V", "V", "V", "H" };
//List<String> listaDebug = new List<string>() { "4N", "6N", "V", "2N", "V", "3N", "V", "1R", "9R", "7R", "H", "10R", "H", "5N", "V", "8N", "V", "H", "H" };
//List<String> listaDebug = new List<string>() { "8R", "2R", "H", "4N", "V", "10R", "5N", "H", "7N", "6N", "H", "9N", "1N", "3N", "V", "H", "V", "V", "V" };
//this.mejorCromosoma = CrearCromosoma(listaDebug, listaPiezas);
}
private void SepararPiezasYOperadores(Cromosoma progenitor, out List <String> listaPiezas, out List <String> listaOperadores)
{
listaPiezas = new List <String>();
listaOperadores = new List <String>();
int n;
foreach (String gen in progenitor.ListaGenes)
{
// Si es una pieza
if (Utilitarios.EsPieza(gen, out n))
{
// Agrega dicho gen a la lista de piezas
listaPiezas.Add(gen);
// Agregar un espacio (cadena vacía) a la lista de operadores
listaOperadores.Add("");
}
else
{
// Agregar un operador a la lista de operadores
listaOperadores.Add(gen);
}
}
}
static List <double> GeneticSolution(int dimentions, int populations, ref double better)
{
Cromosoma[] population = new Cromosoma[populations];
List <double> path = new List <double>();
double max = double.MinValue;
double min = double.MaxValue;
for (int i = 0; i < populations; i++)
{
population[i] = new Cromosoma(dimentions);
//population[i].value = FunctionContinuosI(population[i].population);
population[i].value = FunctionContinuosII(population[i].population);
max = population[i].value > max ? population[i].value : max;
min = population[i].value < min ? population[i].value : min;
}
for (int i = 0; i < population.Length; i++)
{
population[i].prob = (max - population[i].value) / (max - min);
}
int count = 0;
Array.Sort(population);
while (count++ < 1000)
{
Console.WriteLine("Hola " + count);
//seleccion:
List <Cromosoma> selected = new List <Cromosoma>();
int temp = 0;
while (temp++ < 50)
{
double p = r.NextDouble();
double acum = 0;
for (int i = 0; i < population.Length; i++)
{
acum += population[i].prob;
if (!population[i].have_partner && acum >= p)
{
selected.Add(population[i]);
population[i].have_partner = true;
}
}
}
for (int i = 0; i < selected.Count - 1; i++)
{
Make_Crossover(selected[i].population, selected[i + 1].population);
Make_Mutation(selected[i].population);
}
Make_Mutation(selected[selected.Count - 1].population);
population = new Cromosoma[selected.Count];
for (int i = 0; i < selected.Count; i++)
{
population[i] = new Cromosoma(dimentions);
selected[i].population.CopyTo(population[i].population, 0);
//population[i].value = FunctionContinuosI(population[i].population);
population[i].value = FunctionContinuosII(population[i].population);
max = population[i].value > max ? population[i].value : max;
min = population[i].value < min ? population[i].value : min;
}
for (int i = 0; i < population.Length; i++)
{
population[i].prob = (max - population[i].value) / (max - min);
}
Array.Sort(population);
if (population[0].value < better)
{
path = new List <double>();
better = population[0].value;
for (int i = 0; i < population[0].population.Length; i++)
{
path.Add(population[0].population[i]);
}
}
}
return(path);
}
/// <summary>
/// Método diagnóstico, imprime un cromosoma y su costo total
/// </summary>
/// <param name="generacion"></param>
public void debug(Cromosoma[] generacion)
{
foreach (Cromosoma c in generacion)
{
debug(c.ToString() + " : " + c.Costo);
}
}
public FormResultadoStockInfinito(Cromosoma cromosoma)
{
InitializeComponent();
InicializarColores();
this.cromosoma = cromosoma;
}
bool isgray = false; //variable para saber si se quiere obtener un fenotipo en codigo gray
public Individuo(int longitgen) //se recibe la longitud del gen del individuo para inicializar su cromosoma
{
cromosoma = new Cromosoma(longitgen); //se instancia el cromosoma
cromosoma.inicializa(new Random(Guid.NewGuid().GetHashCode())); //se llama a inicializar el cromosoma
}
public bool Mutacion(Cromosoma cromosoma, System.Random rnd)
{
List <String> listaGenes = cromosoma.ListaGenes;
// Escoger 2 diferentes posiciones de genes aleatorios
int posGen1 = rnd.Next(0, listaGenes.Count - 1);
int posGen2 = rnd.Next(posGen1 + 1, listaGenes.Count);
// Ahora, revisamos que son
// Si ambos genes son piezas, podemos intercambiarlos sin problemas
if (Utilitarios.EsPieza(listaGenes[posGen1]) && Utilitarios.EsPieza(listaGenes[posGen2]))
{
String aux = listaGenes[posGen1];
listaGenes[posGen1] = listaGenes[posGen2];
listaGenes[posGen2] = aux;
}
else if (!Utilitarios.EsPieza(listaGenes[posGen1]))
{
String aux = listaGenes[posGen1];
listaGenes[posGen1] = listaGenes[posGen2];
listaGenes[posGen2] = aux;
}
// Si el gen1 es pieza y el gen2 es un operador
else if (Utilitarios.EsPieza(listaGenes[posGen1]) && !Utilitarios.EsPieza(listaGenes[posGen2]))
{
int cantOperadores = 0;
int cantPiezas = 0;
// Debemos verificar que cada posición entre los genes p1 y p2 verifica que No <= Np - 3
for (int i = 0; i < listaGenes.Count; ++i)
{
if (Utilitarios.EsPieza(listaGenes[i]))
{
++cantPiezas;
}
else
{
++cantOperadores;
}
if (i >= posGen1 && i <= posGen2)
{
if (!(cantOperadores <= cantPiezas - 3))
{
return(false);
}
}
}
// Si se cumple la condición, entonces el intrecambio es posible
String aux = listaGenes[posGen1];
listaGenes[posGen1] = listaGenes[posGen2];
listaGenes[posGen2] = aux;
}
listaGenes[posGen1] = Utilitarios.RotarPiezaAleatorio(listaGenes[posGen1], rnd);
listaGenes[posGen2] = Utilitarios.RotarPiezaAleatorio(listaGenes[posGen2], rnd);
cromosoma.ListaGenes = listaGenes;
return(true);
}
public List <Cromosoma> Cruce(Cromosoma progenitor1, Cromosoma progenitor2, System.Random rnd)
{
String aux;
// Lista de piezas de cada progenitor (no tendrán espacios y solo representan un orden entre las piezas de dicho progenitor)
// Lista de operadores de cada progenitor (tendrá espacios en los que colocaremos las piezas)
// Separar la parte de piezas de la parte de operadores para el progenitor1
List <String> progenitor1_listaPiezas, progenitor1_listaOperadores;
SepararPiezasYOperadores(progenitor1, out progenitor1_listaPiezas, out progenitor1_listaOperadores);
// Separar la parte de piezas de la parte de operadores para el progenitor2
List <String> progenitor2_listaPiezas, progenitor2_listaOperadores;
SepararPiezasYOperadores(progenitor2, out progenitor2_listaPiezas, out progenitor2_listaOperadores);
// Se crea un diccionario vacio cuyas claves son cadenas y los valores son listas de cadenas,
// solo iterando la lista de piezas
Dictionary <string, List <string> > mapping_relaciones = new Dictionary <string, List <string> >();
// Inicializar el diccionario con listas vacias en los valores de los keys
foreach (string genPieza in progenitor1_listaPiezas)
{
mapping_relaciones.Add(genPieza.Substring(0, genPieza.Length - 1), new List <string>());
}
// Ahora, escoger dos número que delimitarán el segmento aleatorio de la lista
// de piezas que serán intercambiados entre los progenitores para formar un hijo
// el segundo numero debe ser mayor al primero!!
int primerCorte = rnd.Next(0, progenitor1_listaPiezas.Count - 2);
int segundoCorte = rnd.Next(primerCorte, progenitor1_listaPiezas.Count - 1);
// -----------------------------------------------------------------------------------
// Crossover para los operadores: Debe ser ordenado
// -----------------------------------------------------------------------------------
// Determinar qué operadores del primer progenitor serán intercambiados con los operadores en el segundo
List <bool> paraIntercambiar = new List <bool>();
int cantPiezas = 0; // Esto contará las piezas
for (int i = 0; i < progenitor1_listaOperadores.Count; ++i)
{
if (progenitor1_listaOperadores[i] == "")
{
++cantPiezas;
}
if (cantPiezas >= primerCorte && cantPiezas < segundoCorte && progenitor1_listaOperadores[i] != "")
{
paraIntercambiar.Add(true);
}
else
{
paraIntercambiar.Add(false);
}
}
int cantOperadoresEncontrados;
for (int i = 0; i < progenitor1_listaOperadores.Count; ++i)
{
if (paraIntercambiar[i])
{
// Cuenta el número de operadores que tiene el gen hasta aquí (variable i)
cantOperadoresEncontrados = 0;
for (int j = 0; j <= i; ++j)
{
if (progenitor1_listaOperadores[j] != "")
{
++cantOperadoresEncontrados;
}
}
// Una vez contados, obtenemos el operador que será intercambiado en el segundo progenitor
for (int j = 0; j < progenitor2_listaOperadores.Count; ++j)
{
// Primero, revisar si es un operador, si lo es, restamos 1 de la cantidad de operadores encontrados
if (progenitor2_listaOperadores[j] != "")
{
--cantOperadoresEncontrados;
}
if (cantOperadoresEncontrados == 0)
{
// intercambiar
aux = progenitor1_listaOperadores[i];
progenitor1_listaOperadores[i] = progenitor2_listaOperadores[j];
progenitor2_listaOperadores[j] = aux;
break;
}
}
}
}
// -----------------------------------------------------------------------------------
// Crossover para las piezas
// -----------------------------------------------------------------------------------
// Intercambia un subgrupo entre los progenitores
for (int i = primerCorte; i <= segundoCorte; ++i)
{
// Guardar la pieza del 1er progenitor antes de removerlo
aux = progenitor1_listaPiezas[i];
progenitor1_listaPiezas.RemoveAt(i);
// Insertar la pieza del 2do progenitor en la posición removida del 1er progenitor
progenitor1_listaPiezas.Insert(i, progenitor2_listaPiezas[i]);
// Remueve la pieza del 2do progenitor
progenitor2_listaPiezas.RemoveAt(i);
// Insertar la pieza del 1er progenitor en la posición removida del 2do progenitor
progenitor2_listaPiezas.Insert(i, aux);
}
// Una vez intercambios, se deben corregir para evitar soluciones no validas
// Determinar las relaciones de ambos progenitores usando el diccionario mapping_relaciones
for (int i = primerCorte; i <= segundoCorte; ++i)
{
//mapping_relaciones[progenitor1_listaPiezas[i]].Add(progenitor2_listaPiezas[i]);
//mapping_relaciones[progenitor2_listaPiezas[i]].Add(progenitor1_listaPiezas[i]);
mapping_relaciones[progenitor1_listaPiezas[i].Substring(0, progenitor1_listaPiezas[i].Length - 1)].Add(progenitor2_listaPiezas[i]);
mapping_relaciones[progenitor2_listaPiezas[i].Substring(0, progenitor2_listaPiezas[i].Length - 1)].Add(progenitor1_listaPiezas[i]);
}
Utilitarios.unfold_relationships(mapping_relaciones);
// Las piezas desde [0; primerCorte-1] y del [segundoCorte+1; tamListaPiezas-1] van a cambiar* si están en el rango [primerCorte, segundoCorte],
// con el fin de no tener piezas repetidas en un mismo cromosoma
// * Serán cambiadas por un número (pieza) de su mapping_relaciones que no esté en toda la lista de genes de piezas
// Segmento izquierdo
CorregirPiezas(progenitor1_listaPiezas, progenitor2_listaPiezas, mapping_relaciones, primerCorte, segundoCorte, 0, primerCorte - 1);
// Segmento derecho
CorregirPiezas(progenitor1_listaPiezas, progenitor2_listaPiezas, mapping_relaciones, primerCorte, segundoCorte, segundoCorte + 1, progenitor1_listaPiezas.Count - 1);
// -----------------------------------------------------------------------------------------
// Unir la lista de operadores con la lista de piezas para fomar los nuevos descendientes
// -----------------------------------------------------------------------------------------
// Insertar la lista de piezas en los espacios de la lista de operadores del progenitor 1
Cromosoma descendiente1 = UnirOperadoresYPiezas(progenitor1_listaOperadores, progenitor1_listaPiezas);
// Insertar la lista de piezas en los espacios de la lista de operadores del progenitor 2
Cromosoma descendiente2 = UnirOperadoresYPiezas(progenitor2_listaOperadores, progenitor2_listaPiezas);
List <Cromosoma> descendientes = new List <Cromosoma>();
descendientes.Add(descendiente1);
descendientes.Add(descendiente2);
return(descendientes);
}
