EJEMPLO DE APLICACIN MODIFICADO A LA MONEDA DE ECUADOR Clase CambioMinimo.

java

package practica1;

/** * * @compilado luis * modf Cristian Quinteros */

import java.io.File; import org.jgap.Chromosome; import org.jgap.Configuration; import org.jgap.FitnessFunction; import org.jgap.Gene; import org.jgap.Genotype; import org.jgap.IChromosome; import org.jgap.data.DataTreeBuilder; import org.jgap.data.IDataCreators; import org.jgap.impl.DefaultConfiguration; import org.jgap.impl.IntegerGene; import org.jgap.xml.XMLDocumentBuilder; import org.jgap.xml.XMLManager; import org.w3c.dom.Document;

/** * En este ejemplo se muestra como resolver un problema clasico de algoritmos * genticos utilizando el framework JGAP. El problema consiste en lograr juntar * el monto de dinero ingresado a la aplicacion por parametro con la menor * cantidad de monedas posibles. Para resolver el problema nos basamos en la * moneda del ecuador que es el dolar * Moneda de 1 Dolar ( equivale a 100 centavos) Moneda de 50 Centavos Moneda de 25 Centavos * Moneda de 10 Centavos Moneda de 5 Centavos y Moneda de 1 Centavo * @author Gabriel Veloso * @author Ruben Arce * @since 1.0 * modf Cristian Quinteros */

public class CambioMinimo { /** * The total number of times we'll let the population evolve. */ private static final int MAX_EVOLUCIONES_PERMITIDAS = 2200;

/** * Calcula utilizando algoritmos geneticos la solucin al problema y la * imprime por pantalla * * @param Monto * Monto que se desea descomponer en la menor cantidad de monedas

* posibles * @throws Exception * * @author Gabriel Veloso * @author Ruben Arce * @since 1.0 *modf Cristian Quinteros */ public static void calcularCambioMinimo(int Monto)throws Exception { // Se crea una configuracion con valores predeterminados. // ------------------------------------------------------------Configuration conf = new DefaultConfiguration(); // Se indica en la configuracion que el elemento mas apto siempre pase a // la proxima generacion // ------------------------------------------------------------conf.setPreservFittestIndividual(true); // Se Crea la funcion de aptitud y se setea en la configuracion // --------------------------------------------------------FitnessFunction myFunc = new CambioMinimoFuncionAptitud(Monto); conf.setFitnessFunction(myFunc); // Ahora se debe indicar a la configuracion como seran los cromosomas: en // este caso tendran 6 genes (uno para cada tipo de moneda) con un valor // entero (cantidad de monedas de ese tipo). // Se debe crear un cromosoma de ejemplo y cargarlo en la configuracion // Cada gen tendra un valor maximo y minimo que debe setearse. // --------------------------------------------------------------

Gene[] sampleGenes = new Gene[6]; sampleGenes[0] = new IntegerGene(conf, Math.round(CambioMinimoFuncionAptitud.MAX_MONTO/100)); // Moneda 1 Dolar sampleGenes[1] = new IntegerGene(conf, 0, 10); // Moneda 50 centavos sampleGenes[2] = new IntegerGene(conf, 0, 10); // Moneda 25 centavos sampleGenes[3] = new IntegerGene(conf, 0, 10); // Moneda 10 centavos sampleGenes[4] = new IntegerGene(conf, 0, 10); // Moneda 5 centimos sampleGenes[5] = new IntegerGene(conf, 0, 10); // Moneda 1 centimo IChromosome sampleChromosome = new Chromosome(conf, sampleGenes); conf.setSampleChromosome(sampleChromosome); // Por ultimo se debe indicar el tamao de la poblacion en la // configuracion // -----------------------------------------------------------conf.setPopulationSize(200); Genotype Poblacion; // El framework permite obtener la poblacion inicial de archivos xml // pero para este caso particular resulta mejor crear una poblacion // aleatoria, para ello se utiliza el metodo randomInitialGenotype que // devuelve la poblacion random creada Poblacion = Genotype.randomInitialGenotype(conf); // La Poblacion debe evolucionar para obtener resultados mas aptos // --------------------------------------------------------------long TiempoComienzo = System.currentTimeMillis(); for (int i = 0; i < MAX_EVOLUCIONES_PERMITIDAS; i++) { Poblacion.evolve(); } 0,

long TiempoFin = System.currentTimeMillis(); System.out.println("Tiempo total de evolucion: " + (TiempoFin - TiempoComienzo) + " ms"); guardarPoblacion(Poblacion); // Una vez que la poblacion evoluciono es necesario obtener el cromosoma // mas apto para mostrarlo como solucion al problema planteado para ello // se utiliza el metodo getFittestChromosome IChromosome cromosomaMasApto = Poblacion.getFittestChromosome(); System.out.println("El cromosoma mas apto encontrado tiene un valor de aptitud de: " + cromosomaMasApto.getFitnessValue()); System.out.println("Y esta formado por la siguiente distribucion de monedas: "); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 1 Dolar"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 50 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 25 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 10 centavos"); System.out.println("\t" CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 5 centavos"); System.out.println("\t" + CambioMinimoFuncionAptitud.getNumeroDeComendasDeGen(cromosomaMasApto, Moneda 1 centavo");

0)

"

1)

"

2)

"

3)

"

4)

+ "

5)

"

System.out.println("Para un total de "+ CambioMinimoFuncionAptitud.montoCambioMoneda(cromosomaMasApto) + " centavos en " + CambioMinimoFuncionAptitud.getNumeroTotalMonedas(cromosomaMasApto) + " monedas.");

/** * Metodo principal: Recibe el monto en dinero por parametro para determinar * la cantidad minima de monedas necesarias para formarlo * * @param args * Monto de dinero * @throws Exception * * @author Gabriel Veloso * @author Ruben Arce * @since 1.0 */

public static void main(String[] args) throws Exception { int amount = 323; try { //amount = Integer.parseInt(args[0]); } catch (NumberFormatException e) { System.out.println("El (Monto de dinero) debe ser un numero entero valido"); System.exit(1); } if (amount CambioMinimoFuncionAptitud.MAX_MONTO) { < 1 || amount >=

System.out.println("El monto de dinero debe estar entre 1 y "+ (CambioMinimoFuncionAptitud.MAX_MONTO - 1)+ "."); } else { calcularCambioMinimo(amount); }

// --------------------------------------------------------------------// Este metodo permite guardar en un xml la ultima poblacion calculada // ---------------------------------------------------------------------

public static void guardarPoblacion(Genotype Poblacion) throws Exception { DataTreeBuilder builder = DataTreeBuilder.getInstance(); IDataCreators doc2 = builder.representGenotypeAsDocument(Poblacion); // create XML document from generated tree XMLDocumentBuilder docbuilder = new XMLDocumentBuilder(); Document xmlDoc = (Document) docbuilder.buildDocument(doc2); XMLManager.writeFile(xmlDoc, new File("PoblacionCambioMinimo.xml")); } }

CambioMinimoFuncionAptitud.java package practica1;

/** * * @compilado luis */

import org.jgap.*;

/** * Funcion de Aptitud para Cambio Minimo * * @author Garbiel Veloso * @author Ruben Arce * @since 1.0 * mod cristian quinteros */

public class CambioMinimoFuncionAptitud extends FitnessFunction{ private final int montoObjetivo; // Maximo monto posible 1000 Centavos = 10 Dolares public static final int MAX_MONTO = 1000; // Maxima cantidad de monedas posibles. Es igual al Monto maximo en // centavos, ya que si se utilizan monedas de un centavo se llegaria al // monton con la mayor cantidad posible de monedas

public static final int MAX_CANT_MONEDAS = MAX_MONTO; // El constructor de la funcion de aptitud debe recibir el monto objetivo // del problema y almacenarlo en un atributo. Si el monto es invalido arroja // una excepcion public CambioMinimoFuncionAptitud(int monto) { if (monto < 1 || monto >= MAX_MONTO) { throw new IllegalArgumentException("El monto debe ser un numero entre + " centavos");

1 y " + MAX_MONTO }

montoObjetivo = monto; }

/** * El metodo evaluate es el metodo que se debe sobrecargar para que devuelva * el valor de aptitud asociado al cromosoma que se recibe por parametro. * * * @param cromosoma * El cromosoma a evaluar * * @return El valor de aptitud de ese cromosoma * @author Gabriel Veloso, Ruben Arce * modf Cristian Quinteros */ public double evaluate(IChromosome cromosoma) { // Se debe tener en cuenta el evaluador que se esta usando. El evaluador

// estandar le asigna un valor mas apto a los valores mas altos de // aptitud. Tambien hay otros evaluadores que asignan mejor aptitud a // los valores mas bajos. // Es por esto que se chequea si 2 es mas apto que 1. Si esto es asi // entonces el valor mas apto sera el mayor y el menos apto el 0 boolean evaluadorEstandard cromosoma.getConfiguration().getFitnessEvaluator().isFitter(2, 1); int montoCambioMonedas = montoCambioMoneda(cromosoma); int totalMonedas = getNumeroTotalMonedas(cromosoma); int diferenciaMonto = Math.abs(montoObjetivo - montoCambioMonedas); // El primer paso es asignar la menor aptitud a aquellos cromosomas cuyo // monto no sea el monto objetivo. Es decir una descomposicion en // monedas que no sea del monto ingresado if (evaluadorEstandard) { if (diferenciaMonto != 0) return 0.0d; } else { if (diferenciaMonto != 0) return MAX_CANT_MONEDAS; } // luego se debe asignar mas aptitud a aquellos cromosomas que posean // menor cantidad de monedas. if (evaluadorEstandard) { // Se debe asegurar devolver un valor de aptitud positivo siempre. // Si el valor es negativo se devuelve MAX_CANT_MONEDAS ( elemento // menos apto ) =

return Math.max(0.0d, MAX_CANT_MONEDAS - totalMonedas); } else { // Se debe asgurar devolver un valor de aptitud positivo siempre. // Si el valor es negativo se devuelve 0 ( elemento menos apto ) return Math.max(0.0d, totalMonedas); } }

/** * Calcula el monto total que suman todas las monedas de un cromosoma * * * @param cromosoma * El cromosoma a evaluar * @return Retorna el monto en centimos compuesto por la suma de las monedas * de ese cromosoma * * @author Gabriel Veloso, Ruben Arce *modf Cristian Quinteros */

public static int montoCambioMoneda(IChromosome cromosoma) { int Moneda1Dolar = getNumeroDeComendasDeGen(cromosoma, 0); int Moneda50Centavos = getNumeroDeComendasDeGen(cromosoma, 1); int Moneda25Centavos = getNumeroDeComendasDeGen(cromosoma, 2); int Moneda10Centavos = getNumeroDeComendasDeGen(cromosoma, 3);

int Moneda5Centavos = getNumeroDeComendasDeGen(cromosoma, 4); int Moneda1Centavo = getNumeroDeComendasDeGen(cromosoma, 5);

return (Moneda1Dolar * 100) + (Moneda50Centavos * 50) + (Moneda10Centavos * 10) + (Moneda5Centavos * 5) + Moneda1Centavo;

/** * Calcula la cantidad de monedas de determinado tipo (gen) de un cromosoma * Ejemplo. Cantidad de monedas de 25 centavos de es cromosoma * * @param cromosoma * El cromosoma a evaluar * @param numeroGen * El numero gen (tipo de moneda) de que se desea averiguar la * cantidad * @return Devuelve la cantidad de monedas de ese tipo de ese cromosoma * * * @author Gabriel Veloso, Ruben Arce * modf Cristian Quinteros */

public numeroGen) {

static

int

getNumeroDeComendasDeGen(IChromosome

cromosoma,int

Integer numMonedas cromosoma.getGene(numeroGen).getAllele();

(Integer)

return numMonedas.intValue(); }

/** * Calcula el total de monedas que tiene esa solucion. Este valor se utiliza * para calcular la aptitud del cromosoma ya que el objetivo es minimizar la * cantidad de monedas de la solucion * * * @param cromosoma * El cromosoma a evaluar * @return El total de monedas que tiene esa solucion * * @author Gabriel Veloso, Ruben Arce * modf Cristian Quinteros */

public static int getNumeroTotalMonedas(IChromosome cromosoma) { int totalMonedas = 0; int numberOfGenes = cromosoma.size(); for (int i = 0; i < numberOfGenes; i++) { totalMonedas += getNumeroDeComendasDeGen(cromosoma, i); }

return totalMonedas; } }