ALGORITMO GENÉTICO

Andrés Hurtado Pasquel, Wendy Estupiñan Estupiñan

angel.andrew.hurtad@gmail.com, wendy.paola.estupinan@gmail.com,
Pontificia Universidad Católica del Ecuador, Sede Esmeraldas-Ecuador
Resumen- El hombre siempre está tratando de adaptarse a los cambios inherentes a él, creando
soluciones a los problemas de la vida diaria. Esta misma lógica han tomado los sistemas de
control, los cuales han ido modificando su proceso mediante un control adaptativo.
Un ejemplo claro de esto son los algoritmos genéticos para ello toman una población de
individuos cada uno de los cuales representa una solución factible a un problema dado. A cada
individuo se le asigna un valor o puntuación, relacionado con la bondad de dicha solución. En
la naturaleza esto equivaldría al grado de efectividad de un organismo para competir por unos
determinados recursos. [1]
Palabras Clave - Algoritmo Genético, control adaptativo, optimización.
requerida. [3]
I. INTRODUCCIÓN
Los algoritmos genéticos (AG) son II. FUNDAMENTACIÓN TEÓRICA
métodos adaptativos utilizados para la A. Algoritmo Genético
resolución de problemas demostrando ser Los algoritmos genéticos
un método de optimización con algunas constituyen una técnica de
ventajas respecto de métodos búsqueda fundamentada en el
convencionales, basados en el proceso proceso de evolución natural en la
genético de los organismos vivos, creando cual los individuos más adaptados
soluciones para problemas del mundo real. tienen mayores probabilidades de
Un algoritmo genético mantiene un sobrevivir y de transferir su material
conjunto de soluciones potenciales en cada genético a las siguientes
generación. Su popularidad se puede generaciones. La idea fundamental
atribuir a la aplicación de problemas de de los algoritmos genéticos consiste
optimización continuos y discretos, así en encontrar una solución aceptable
como su naturaleza probabilística y menor a un problema por medio del
probabilidad de quedar atrapado en óptimos mejoramiento de un conjunto de
locales que se presentan en muchos individuos, cuya función de
problemas prácticos de optimización [2]. evaluación corresponde a una
solución del problema. Esta
Para alcanzar la solución a un problema se optimización se realiza mediante
parte de un conjunto inicial de individuos, procesos selectivos y de
llamado población, generado de manera intercambio de información
aleatoria. Cada uno de estos individuos genética. Dichos procesos están
representa una posible solución al dados por operadores genéticos, que
problema. Estos individuos evolucionarán definen la estructura de un
tomando como base los esquemas algoritmo genético. [2][4]
propuestos por Darwin sobre la selección
natural, y se adaptarán en mayor medida Un algoritmo genético consiste en
tras el paso de cada generación a la solución una función matemática o una
rutina de software que toma como
 entradas a los ejemplares y retorna
como salidas cuáles de ellos deben
generar descendencia para la nueva
generación.
Los Algoritmos Genéticos usan los
siguientes mecanismos:
1. La sobrevivencia de los
organismos con mejor
capacidad dentro de una
población.
2. Uso de secuencias de
caracteres (generalmente 1s
y 0s) en strings como
representación del ADN de
estos organismos.
3. El uso de métodos aleatorios
(random) para la generación
de la población y para su
reproducción.
B. Características del Algoritmo
Genético
Los algoritmos genéticos se
caracterizan por la evolución de una
población inicial (conjunto de
soluciones) que lleva a mejores
soluciones por medio de las
iteraciones, permitiendo a los
individuos más aptos reproducirse y
dejar que los individuos menos
aptos mueran.
● Inicialización: Se genera
aleatoriamente la población inicial,
que está constituida por un conjunto
de cromosomas los cuales
representan las posibles soluciones
del problema. En caso de no hacerlo
aleatoriamente, es importante
garantizar que dentro de la
población inicial, se tenga la
diversidad estructural de estas
soluciones para tener una
representación de la mayor parte de
la población posible o al menos
evitar la convergencia prematura.
● Evaluación: A cada uno de los
cromosomas de esta población se
aplicará la función de aptitud para
saber qué tan "buena" es la solución
que se está codificando.
● Condición de término El AG se
deberá detener cuando se alcance la
solución óptima, pero ésta
generalmente se desconoce, por lo
que se deben utilizar otros criterios
de detención. Normalmente se usan
dos criterios: correr el AG un
número máximo de iteraciones
(generaciones) o detenerlo cuando
no haya cambios en la población.
C. Funcionamiento del Algoritmo
Genético
Los Algoritmos Genéticos trabajan
sobre una población de individuos.
Cada uno de ellos representa una
posible solución al problema que se
desea resolver.
Todo individuo tiene asociado un
ajuste de acuerdo a la bondad con
respecto al problema de la solución
que representa (en la naturaleza el
equivalente sería una medida de la
eficiencia del individuo en la lucha
por los recursos).
Una generación se obtiene a partir
de la anterior por medio de los
operadores de reproducción.
Existen 2 tipos:
● Cruce. Se trata de una
reproducción de tipo sexual.
Se genera una descendencia
a partir del mismo número
de individuos (generalmente
2) de la generación anterior.
Existen varios tipos que se
detallarán en un punto
posterior.
● Copia. Se trata de una
reproducción de tipo
asexual. Un determinado
 número de individuos pasa
sin sufrir ninguna variación
directamente a la siguiente
generación.
D. Obtención de la población inicial
La población inicial se escoge
dependiendo de la naturaleza del
problema, normalmente se obtiene
generando series al azar
permitiendo una gama de posibles
soluciones.
En algunos casos la población
inicial no ha sido obtenida de
manera aleatoria sino como
resultado de alguna técnica
heurística o de optimización local,
de esta aplicación existen pocos
trabajos lo cual puede acelerar la
concentración del Algoritmo
Genético. Sin embargo en algunos
casos la desventaja resulta ser la
prematura concentración del
algoritmo, queriendo indicar con
esto la convergencia hacia óptimos
locales.
En la siguiente figura se aprecia un
ejemplo de la obtención de la
población inicial
Figura 1: Creación Población Inicial Aleatoria
Este parámetro nos indica el
número de cromosomas que
tenemos en nuestra población para
una generación determinada. En
caso de que esta medida sea
insuficiente, el algoritmo genético
tiene pocas posibilidades de realizar
reproducciones con lo que se
realizaría una búsqueda de
soluciones escasa y poco óptima.
Por otro lado si la población es
excesiva, el algoritmo genético será
excesivamente lento. De hecho
estudios revelan que hay un límite a
partir del cual es ineficiente elevar
el tamaño de la población puesto
que no se consigue una mayor
velocidad en la resolución del
problema.
E. Función de evaluación
Es la responsable de evaluar a los
individuos y asignarle valores altos
de adaptación; ya que es una
función completamente
dependiente del problema, puede
determinar qué tan buenos o malos
serán los resultados y la
convergencia o no del método.
La función de evaluación es la que
mide cuál de los individuos
involucrados en el proceso es el más
apto y por tanto se acerca a la
solución más óptima. Esta también
ayuda al desempeño óptimo del
Algoritmo Genético evaluando
cada uno de los individuos de cada
generación, además de que también
puede ser utilizada para encontrar el
peor individuo, conocer el
promedio de todos los individuos o
su desviación estándar. [5]
F. Función Objetivo
La función objetivo proporciona
una medida de desempeño del
sistema asociado a cierto individuo
en la población. Esta también
establece una medida que debe
determinar la calidad de la solución
postulada, que después será
reutilizada por el Algoritmo
 Genético como guía para obtener
las mejores soluciones, en un
tiempo futuro.
La función objetivo pretende
encontrar una solución aceptable
mediante el análisis y la evaluación
de los Algoritmos Genéticos, que en
combinación optimizan los recursos
en diferentes escenarios. [12]
G. Operadores genéticos
Una de las características
principales que presentan los
Algoritmos Genéticos, son sus
operadores, que facilitan la
optimización de procesos; entre
ellos se encuentran [1]:
Operador de Selección: el proceso
de selección busca escoger ciertos
individuos de la población, quienes
darán origen a las futuras
generaciones. Por lo general, la
selección depende del valor de la
función de evaluación de cada
individuo. Existen algunas formas
de Selección:
● Selección por Rueda de
Ruleta: Se crea una ruleta
con los cromosomas donde
cada uno tendrá una función
mayor o menor, luego se
hace girar la ruleta y se
selección el cromosoma con
mayores probabilidades de
salir.
Operador de Cruce: consiste en
mezclar la información genética de
dos individuos, a fin de generar
nuevos individuos. De esta manera,
el punto de cruce se establece en
cuatro distintas formas:
● Se toma la primera mitad del
cromosoma del padre y se
toma la segunda mitad del
cromosoma madre para
generar un nuevo hijo.
● Se toma la primera mitad del
cromosoma de la madre y se
toma la segunda mitad del
cromosoma del padre para
generar un nuevo hijo.
● Se divide el cromosoma en 4
partes y se le asigna una
sección menor del padre y
una mayor de la madre.
● Se divide el cromosoma en 4
partes y se le asigna la
sección mayor del padre y
una menor de la madre.
Los operadores de cruce sirven para
combinar las características de dos
padres y así crear un nuevo
cromosoma hijo que se convierte en
la próxima generación con mayor
calidad de población y fuerza de
convergencia. Los operadores de
Cruce habitualmente se se cruzan de
las siguientes maneras:
- Operador de Cruce PMX
o 1 Punto: Este operador
selecciona dos cromosomas
padres que se cortan por un
punto. La información
genética de uno de los
padres se copia desde el
inicio hasta el punto de
cruce y el resto de la
información genética del
padre restante. Esta es
considerada una de las
formas más clásicas de
cruce dada por los
algoritmos Genéticos. [6]

Figura 2: Representación Gráfica del Operador
PMX [6]
- Operador de Cruce OX o 2
Puntos: En este caso los
progenitores se cortan por
dos puntos, se toma la
información genética del
primer progenitor hasta el
primer punto de cruce, luego
se toma la información
genética del segundo
progenitor hasta el segundo
punto de cruce y por último
se copia del segundo punto
de cruce hasta el final la
información genética.
Figura 3: Representación Gráfica del Operador
OX [6]
Operador de Mutación: consiste
en alterar las características
genéticas de un individuo, con el
objeto de aumentar la probabilidad
de exploración del espacio de
búsqueda y disminuir el riesgo de
estancamiento del algoritmo en
óptimos locales.
- Operador de Mutación
Swap: Este operador de
mutación elige dos
posiciones diferentes de
manera aleatoria entre 1 y n
genes de cada posición de
manera intercalada. [5]
Figura 4: Representación Gráfica de Mutación
Swap
Figura 5: Estructura de un algoritmo genético
simple
III. DESARROLLO Y RESULTADOS
Desarrolle un algoritmo genético para
encontrar el máximo y el mínimo de la
función
Partiendo de la función x^3/3+C, donde
queremos encontrar el valor de x cuando
alcanza su valor máximo y mínimo,
restringiendo a la variable x la misma que
toma valores comprendidos entre -25 (valor
mínimo) y 25 (valor máximo).
Luego codificamos las posibles soluciones
(posibles valores de x), la manera de
codificarlo sería convertir los valores del -
25 al 25 en números binarios.
 Decimal Binario Decimal Binario

1 0001 13 1101

14 1110
2 0010
15 1111
3 0011
16 10000
4 0100
17 10001
5 0101
18 10010
6 0110
19 10011
7 0111
20 10100
8 1000
21 10101
9 1001
22 10110
10 1010
23 10111
11 1011 24 11000
12 1100 25 11001

A cada posible valor de la variable x en primer individuo. Repite ahora la secuencia

representación binaria le vamos a llamar anterior para generar los individuos de la
individuo. Una colección de individuos población restantes. En total tienes que
constituye lo que se denomina población y lanzar 5 * 6 = 30 veces la moneda.
el número de individuos que la componen
Nuestro siguiente paso es hacer competir a
es el tamaño de la población.
los individuos entre sí. Este proceso se
El tamaño de la población es de 50, conoce como selección. La tabla 1 resume
comprendida de 25 números positivos y 25 el proceso donde cada fila está Asociada a
negativos. un individuo de la población inicial.
Una vez que tenemos codificada la Tabla 1: Tabla de selección de individuos
solución, debemos escoger un tamaño de aleatoriamente.
población (muestra) con la que
TABLA DE SELECCIÓN
trabajaremos. Para este ejemplo ilustrativo
vamos a escoger 6 individuos. Nº
Individuo Valor
Valor F(x) Parej.
en binario de X
Debemos partir de una población inicial.
1 10111 23 4055.666 3
Una manera de generarla es aleatoriamente:
coge una moneda y lánzala al aire; si sale 2 10101 21 3087.0 6
cara, la primera componente del primer
3 01111 15 1125.0 1
individuo es un 0 y en caso contrario un 1.
Repite el lanzamiento de la moneda y 4 01101 13 732.333 5
tendremos la segunda componente del
5 10011 19 2286.3333 4
primer individuo (un 0 si sale cara y un 1 si
sale cruz). Así hasta 5 veces y obtendrás el 6 00001 1 0.333333 2
Podemos observar que el mayor es el mientras que el otro hijo de la pareja
individuo 1, número 23 y f(x)=4055,66 y el conserva los tres primeros bits de la madre
mínimo es el individuo 6, número 1 y y hereda los dos últimos del padre. La
f(x)=0,3333. población resultante se muestra en la
columna (2) de la tabla 3.
En cuanto a la columna de Parejas, se
realiza un proceso de selección, el mismo Tabla 3: Población resultante tras el cruce.
que es un torneo entre 2 individuos. A cada
POBLACIÓN TRAS EL CRUCE
individuo de la población se le asigna una
pareja y entre ellos se establece un torneo: # Individuos Bits Valor x Valor f(x)
el mejor genera dos copias y el peor se
desecha. La columna Parejas indica la 1 10101 1 21 3087
pareja asignada a cada individuo, lo cual se
2 10111 1 23 4055,666
ha realizado aleatoriamente.
3 10011 1 19 2286,333
Después de realizar el proceso de selección,
la población que tenemos es la mostrada en 4 10111 1 23 4055,666
la columna (2) de la tabla 2. Observa, por
ejemplo, que en el torneo entre el individuo 5 10101 1 21 3087
1 y el 6 de la población inicial, el primero 6 10011 1 19 2286,333
de ellos ha recibido dos copias, mientras
que el segundo cae en el olvido.
Tabla 2: Representación del cruce entre los En esta tabla podemos notar que el máximo
individuos. lo determina el número 23 con
f(x)=4055,666, y el mínimo el número 19
TABLA DE CRUCE
con f(x)=2286,333.
# Individuos Bits
10101 1
Esto determina que el individuo después del
1
cruce en el máximo se mantuvo, pero en el
2 10111 1
mínimo aumentó su valor.
3 10011 1
Este procedimiento se realiza hasta el
4 10111 1
número de generaciones que hayamos
5 10101 1
especificado.
6 10011 1
En realidad un algoritmo genético no te
garantiza la obtención del óptimo pero, si
Tras realizar la selección, se realiza el está bien construido, te proporcionará una
cruce. Una manera de hacerlo es mediante solución razonablemente buena. Puede que
el cruce 1X: se forman parejas entre los obtengas el óptimo, pero el algoritmo no te
individuos aleatoriamente de forma similar confirma que lo sea.
a la selección. Dados dos individuos pareja
se establece un punto de cruce aleatorio,
que no es más que un número aleatorio
IV. APLICACIÓN
entre 1 y 4 (la longitud del individuo menos
1). Por ejemplo, en la pareja 2-3 el punto de Se desarrolló una aplicación para el uso y
cruce es 3, lo que significa que un hijo de la conocimiento profundo del funcionamiento
pareja conserva los tres primeros bits del del Algoritmo Genético, la aplicación fue
padre y hereda los dos últimos de la madre, desarrollada en el lenguaje de
programación Java Server Page o mejor
conocido como JSP que permite desarrollar
páginas web dinámicas basadas en HTML
y XML, siendo así un poco similar al
lenguaje de programación PHP, pero en
Java.
La Aplicación cuenta con diferentes
casillas donde se colocarán los datos de una
función para así ser encontrados, a través
del algoritmo genético, los valores
máximos y mínimos que posee X en dicha
función.
Figura 6: Interfaz de la Aplicación Algoritmo
Genético
Para observar el funcionamiento de la
aplicación, se debe colocar la función en la
casilla marcada como tal, luego se
colocarán los límites máximos y mínimos,
posteriormente se irán colocando los
parámetros propios del algoritmo como
son: número de individuos, número de
generaciones, porcentaje de cruce y
porcentaje de mutación.
Al dar clic en el botón “Calcular” este
abrirá una nueva ventana con los resultados
del algoritmo genético de tal manera que se
podrá observar el Máximo y el Mínimo
valor que obtuvo X en dicha función y con
dichos límites.
V. CÓDIGO
CONTROLADOR
package controlador;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import modelo.Algoritmo;
import modelo.funcion;
import org.nfunk.jep.ParseException;
@WebServlet(name = "controlAlgoritmo", urlPatterns =
{"/controlAlgoritmo.do"})
public class controlAlgoritmo extends HttpServlet {
/**
* Processes requests for both HTTP <code>GET</code> and
<code>POST</code>
* methods.
*
* @param request servlet request
* @param response servlet response
* @throws ServletException if a servlet-specific error occurs
* @throws IOException if an I/O error occurs
*/
protected void processRequest(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException, ParseException {
// $num_individuos = !empty($_POST["individuos"]) ?
trim($_POST["individuos"])%2==0?trim($_POST["individuos"
]):($G->error .= "El numero de individuos debe ser par.<br/>") :
($G->error .= "Falta individuo.<br/>");
// $valor_minimo = !empty($_POST["minvalor"]) ?
trim($_POST["minvalor"]) : ($_POST["minvalor"] == 0) ?
trim($_POST["minvalor"]) : ($G->error .= "Falta el valor
minimo.<br/>");
// $valor_maximo = !empty($_POST["maxvalor"]) ?
trim($_POST["maxvalor"]) : ($_POST["maxvalor"] == 0) ?
trim($_POST["maxvalor"]) : ($G->error .= "Falta el valor
maximo.<br/>");
// $funcion = !empty($_POST["fx"]) ? trim($_POST["fx"]) :
($G->error .= "Falta la funcion.<br/>");
// $cruce = !empty($_POST["cruce"]) ? trim($_POST["cruce"])
: ($G->error .= "Falta cruce.<br/>");
// $num_generaciones = !empty($_POST["generaciones"]) ? errores.add("Debe ingresar el cruce");
trim($_POST["generaciones"]) : ($G->error .= "Falta numero de }
generaciones.<br/>"); try {
// $mutacion = !empty($_POST["mutacion"]) ? generaciones = Integer.parseInt(strgeneraciones);
trim($_POST["mutacion"]) : ($G->error .= "Falta
mutacion.<br/>"); } catch (NumberFormatException ex) {
// if ($G->error == "ok") { errores.add("Debe ingresar las generaciones");
// $G->algoritmo = new algoritmo(); }
// $G->algoritmo->setNum_individuos($num_individuos); try {
// $G->algoritmo- mutacion = Integer.parseInt(strmutacion);
>setNum_generaciones($num_generaciones); } catch (NumberFormatException ex) {
// $G->algoritmo->setValor_maximo($valor_maximo); errores.add("Debe ingresar la mutacion");
// $G->algoritmo->setValor_minimo($valor_minimo); }
// $G->algoritmo->setMutacion($mutacion); if (errores.isEmpty()) {
// $G->algoritmo->setCruce($cruce); Algoritmo ag;
// $G->algoritmo->setFx($funcion); ag = new Algoritmo();
// $G->algoritmo->generarIndividuos(); url = "ag.jsp";
// $G->algoritmo->calculo(); // $G->algoritmo-
// } >setNum_individuos($num_individuos);
ArrayList errores = new ArrayList(); // $G->algoritmo-
ArrayList datos = new ArrayList(); >setNum_generaciones($num_generaciones);
String strindividuos = // $G->algoritmo->setValor_maximo($valor_maximo);
request.getParameter("txtindividuos"); // $G->algoritmo->setValor_minimo($valor_minimo);
String strval_min = request.getParameter("txtval_min"); // $G->algoritmo->setMutacion($mutacion);
String strval_max = request.getParameter("txtval_max"); // $G->algoritmo->setCruce($cruce);
String strfuncion = request.getParameter("txtfuncion"); // $G->algoritmo->setFx($funcion);
String strcruce = request.getParameter("txtcruce"); ag.setIndividuosTotal(individuos);
String strgeneraciones = ag.setGeneracionesTotal(generaciones);
request.getParameter("txtgeneraciones"); ag.setVal_max(val_max);
String strmutacion = request.getParameter("txtmutacion"); ag.setVal_min(val_min);
String url = ""; ag.setPorcentajeMutacion(mutacion);
int individuos = 0; ag.setPorcentajeCruce(cruce);
int val_min = 0; ag.setFuncion(strfuncion);
int val_max = 0; ag.SizeMatrices();
double fx = 0; ag.generarIndividuos();
int cruce = 0; ag.Calculo_del_Algoritmo();
int generaciones = 0; request.setAttribute("ag",ag);
int mutacion = 0; } else {
if (strfuncion.isEmpty()) { url = "error.jsp";
errores.add("Debe ingresar la funcion"); //guardar el mensaje en el ambito de la solicitud
} else { request.setAttribute("errores", errores);
funcion func = new funcion(strfuncion);
try { }
fx = func.EvaluarFuncion(1); RequestDispatcher vista =
} catch (NumberFormatException ex) { request.getRequestDispatcher(url);
errores.add("Debe ingresar la funcion correcta "); vista.include(request, response);
} }
}
try { // <editor-fold defaultstate="collapsed" desc="HttpServlet
individuos = Integer.parseInt(strindividuos); methods. Click on the + sign on the left to edit the code.">
if(individuos %2!=0){ /**
errores.add("Debe ingresar numero de individuos * Handles the HTTP <code>GET</code> method.
pares"); *
} * @param request servlet request
} catch (NumberFormatException ex) { * @param response servlet response
errores.add("Debe ingresar individuos"); * @throws ServletException if a servlet-specific error occurs
} * @throws IOException if an I/O error occurs
try { */
val_min = Integer.parseInt(strval_min); @Override
} catch (NumberFormatException ex) { protected void doGet(HttpServletRequest request,
errores.add("Debe ingresar el valor minimo"); HttpServletResponse response)
} throws ServletException, IOException {
try { try {
val_max = Integer.parseInt(strval_max); processRequest(request, response);
} catch (NumberFormatException ex) { } catch (ParseException ex) {
errores.add("Debe ingresar el valor maximo");
} Logger.getLogger(controlAlgoritmo.class.getName()).log(Level
.SEVERE, null, ex);
try { }
cruce = Integer.parseInt(strcruce); }
} catch (NumberFormatException ex) {
 /** public int[][] individuos = new
* Handles the HTTP <code>POST</code> method. int[getIndividuosTotal()][Longitud_del_Cromo()];
* // public double[] valorIndividuos = new
* @param request servlet request double[getIndividuosTotal()];
* @param response servlet response // public double[][] tramosSeleccion = new
* @throws ServletException if a servlet-specific error occurs double[getIndividuosTotal()][2];
* @throws IOException if an I/O error occurs // public double[][] tramosCorte = new
*/ double[getCromosomasTotal()][2];
@Override int[] IDpareja = new int[getIndividuosTotal()];
protected void doPost(HttpServletRequest request, // int[] IDcruce = new int[getIndividuosTotal()];
HttpServletResponse response)
throws ServletException, IOException { public Algoritmo() {
try { this.funcion = "";
processRequest(request, response); this.individuosTotal = 0;
} catch (ParseException ex) { this.val_min = 0;
this.val_max = 0;
Logger.getLogger(controlAlgoritmo.class.getName()).log(Level this.PorcentajeCruce = 0;
.SEVERE, null, ex); this.PorcentajeMutacion = 0;
} this.generacionesTotal = 0;
} }

/** public void SizeMatrices() {

* Returns a short description of the servlet. this.fxParse.setFuncion(this.funcion);
* this.matriz_pareja = new int[this.getIndividuosTotal() /
* @return a String containing servlet description 2][2];
*/ this.matriz_pareja_2 = new int[this.getIndividuosTotal() /
@Override 2][2];
public String getServletInfo() { this.columna_x = new int[this.getIndividuosTotal()];
return "Short description"; this.matriz_generacion = new
}// </editor-fold> String[this.getIndividuosTotal()][5];
this.matriz_mutacion = new
} String[this.getIndividuosTotal()][3];
ALGORITMO this.matriz_cruce = new
package modelo; String[this.getIndividuosTotal()][3];
this.matriz_duplicado = new
import static java.lang.Math.pow; String[this.getIndividuosTotal()][3];
import java.math.BigDecimal; this.individuos = new
import java.math.RoundingMode; int[this.getIndividuosTotal()][this.Longitud_del_Cromo()];
import java.sql.PreparedStatement; this.max_valor = new double[this.getGeneracionesTotal()];
import java.sql.ResultSet; this.min_valor = new double[this.getGeneracionesTotal()];
import java.util.ArrayList; }
import java.util.Random;
import java.util.logging.Level; public String[][] getMatriz_duplicado() {
import java.util.logging.Logger; return matriz_duplicado;
import org.lsmp.djep.djep.DJep; }
import org.nfunk.jep.Node;
import org.nfunk.jep.ParseException; public void setMatriz_duplicado(String[][] matriz_duplicado)
import modelo.funcion; {
this.matriz_duplicado = matriz_duplicado;
public class Algoritmo { }

private int individuosTotal; public int[] getIDpareja() {

private int generacionesTotal; return IDpareja;
private int val_min; }
private int val_max;
public int PorcentajeCruce; public void setIDpareja(int[] IDpareja) {
public int PorcentajeMutacion; this.IDpareja = IDpareja;
private String funcion; }
public funcion fxParse = new funcion();
Random genAlea = new Random(); public int getIndividuosTotal() {
private int[][] matriz_pareja; return individuosTotal;
private int[][] matriz_pareja_2; }
private int[] columna_x;
private String[][] matriz_generacion; public void setIndividuosTotal(int individuosTotal) {
private String[][] matriz_mutacion; this.individuosTotal = individuosTotal;
private String[][] matriz_cruce; }
private String[][] matriz_duplicado;
private double[] max_valor; public int getGeneracionesTotal() {
private double[] min_valor; return generacionesTotal;
}
public void setGeneracionesTotal(int generacionesTotal) {
this.generacionesTotal = generacionesTotal; public void setMatriz_generacion(String[][]
} matriz_generacion) {
this.matriz_generacion = matriz_generacion;
public int getVal_min() { }
return val_min;
} public int[][] getMatriz_pareja_2() {
return matriz_pareja_2;
public void setVal_min(int val_min) { }
this.val_min = val_min;
} public void setMatriz_pareja_2(int[][] matriz_pareja_2) {
this.matriz_pareja_2 = matriz_pareja_2;
public int getVal_max() { }
return val_max;
} public int[][] getMatriz_pareja_2_Antigua() {
return matriz_pareja_2;
public void setVal_max(int val_max) { }
this.val_max = val_max;
} public int[] getIdParejaAntigua() {
return IDpareja;
public int getPorcentajeCruce() { }
return PorcentajeCruce;
} public String[][] getMatriz_cruce() {
return matriz_cruce;
public void setPorcentajeCruce(int PorcentajeCruce) { }
this.PorcentajeCruce = PorcentajeCruce;
} public void setMatriz_cruce(String[][] matriz_cruce) {
this.matriz_cruce = matriz_cruce;
public int getPorcentajeMutacion() { }
return PorcentajeMutacion;
} public String[][] getMatriz_mutacion() {
return matriz_mutacion;
public void setPorcentajeMutacion(int PorcentajeMutacion) { }
this.PorcentajeMutacion = PorcentajeMutacion;
} public void setMatriz_mutacion(String[][] matriz_mutacion) {
this.matriz_mutacion = matriz_mutacion;
public String getFuncion() { }
return funcion;
} public double[] getMax_valor() {
return max_valor;
public void setFuncion(String funcion) { }
this.funcion = funcion;
} public void setMax_valor(double[] max_valor) {
this.max_valor = max_valor;
public int[][] getIndividuos() { }
return individuos;
} public double[] getMin_valor() {
return min_valor;
public void setIndividuos(int[][] individuos) { }
this.individuos = individuos;
} public void setMin_valor(double[] min_valor) {
this.min_valor = min_valor;
public int[][] getMatriz_pareja() { }
return matriz_pareja;
} public void Calculo_del_Algoritmo() throws ParseException {

public void setMatriz_pareja(int[][] matriz_pareja) { this.setMatriz_pareja(this.emparejamiento());

this.matriz_pareja = matriz_pareja; int x = 0;
} int[] binario = new int[this.Longitud_del_Cromo()];
for (int i = 0; i < getIndividuosTotal(); i++) {
public int[] getColumna_x() { for (int j = 0; j < this.Longitud_del_Cromo(); j++) {
return columna_x; binario[j] = this.getIndividuos()[i][j];
} }

public void setColumna_x(int[] columna_x) { this.columna_x[i] = binariyToInteger(binario);

this.columna_x = columna_x;
} }

public String[][] getMatriz_generacion() { this.generacion_Principal();

return matriz_generacion; //this.castigo_2();
} this.generacion_duplicada();
 this.cruce_individuos(); }
//this.mutacion_individuos();
this.Mutar(); }

// for (int i = 0; i < this.getGeneracionesTotal(); i++) {

} vector_max[i] = max;
}
public void generarIndividuos() {
int[] binario = new int[this.Longitud_del_Cromo()]; this.setMax_valor(vector_max);
int valor = 0;
int[][] individuos = new return max;
int[this.getIndividuosTotal()][this.Longitud_del_Cromo()]; }
for (int i = 0; i < this.getIndividuosTotal(); i++) {
for (int j = 0; j < this.Longitud_del_Cromo(); j++) { public double valor_max_gen() {
individuos[i][j] = genAlea.nextInt(2); double[] vector_max = new
} double[this.getGeneracionesTotal()];
for (int x = 0; x < this.Longitud_del_Cromo(); x++) { vector_max = this.getMax_valor();
binario[x] = individuos[i][x]; double max = 0;
} for (int i = 0; i < this.getGeneracionesTotal(); i++) {
valor = binariyToInteger(binario); if (vector_max[i] > max) {
if (valor >= this.getVal_max()) { max = vector_max[i];
i--; }
}
} vector_max[i] = max;
this.setIndividuos(individuos); }
}
return max;
public String[][] generacion_Principal() throws }
ParseException {
int[] matriz_pareja = new int[this.getIndividuosTotal()];
String[][] matriz_generacion = new public Double ValorMin() {
String[this.getIndividuosTotal()][5]; String[][] matriz_generacion = new
int[][] parejas = new int[this.getIndividuosTotal() / 2][2]; String[this.getIndividuosTotal()][5];
parejas = this.getMatriz_pareja(); matriz_generacion = this.getMatriz_generacion();
double[] vector_min = new
for (int i = 1; i <= this.getIndividuosTotal(); i++) { double[this.getGeneracionesTotal()];
matriz_pareja[i - 1] = this.matriz_parejas(i, parejas); String num_min;
} double min =
for (int x = 0; x < this.getIndividuosTotal(); x++) { Double.parseDouble(matriz_generacion[0][3]);
String individuo = ""; for (int x = 0; x < this.getIndividuosTotal(); x++) {
for (int i = 0; i < this.Longitud_del_Cromo(); i++) {
individuo += this.getIndividuos()[x][i]; double pos1 =
} Double.parseDouble(matriz_generacion[x][3]);

matriz_generacion[x][0] = (x + 1) + ""; if (pos1 < min) {

matriz_generacion[x][1] = individuo; min = pos1;
matriz_generacion[x][2] = this.columna_x[x] + ""; }
matriz_generacion[x][3] =
this.fxParse.EvaluarFuncion(this.columna_x[x]) + ""; }
matriz_generacion[x][4] = matriz_pareja[x] + "";
} for (int i = 0; i < this.getGeneracionesTotal(); i++) {
this.setMatriz_generacion(matriz_generacion); vector_min[i] = min;
return this.getMatriz_generacion(); }

} this.setMax_valor(vector_min);

public Double ValorMax() { return min;

String[][] matriz_generacion = new }
String[this.getIndividuosTotal()][5];
matriz_generacion = this.getMatriz_generacion(); public double valor_min_gen() {
double[] vector_max = new double[] vector_min = new
double[this.getGeneracionesTotal()]; double[this.getGeneracionesTotal()];
String num_max; vector_min = this.getMin_valor();
double max = 0; double min = vector_min[0];
for (int x = 0; x < this.getIndividuosTotal(); x++) { for (int i = 0; i < this.getGeneracionesTotal(); i++) {
if (vector_min[i] < min) {
double pos1 = min = vector_min[i];
Double.parseDouble(matriz_generacion[x][3]); }

if (pos1 > max) { vector_min[i] = min;

max = pos1; }
 if (i == cromosomas) {
return min; if
} (String.valueOf(aux_matriz_mutacion[indi][1].charAt(i)).equals
("1")) {
np += "0";
public void nueva_poblacion() { } else {
int[][] individuos = new np += "1";
int[this.getIndividuosTotal()][this.Longitud_del_Cromo()]; }
for (int i = 0; i < this.getIndividuosTotal(); i++) { } else {
for (int j = 0; j < this.Longitud_del_Cromo(); j++) { np +=
String.valueOf(aux_matriz_mutacion[indi][1].charAt(i));
int com = (int) }
this.getMatriz_mutacion()[i][1].charAt(j); }
if (com == 48) { int[] ints = new int[np.length()];
individuos[i][j] = 0; for (int y = 0; y < np.length(); y++) {
} else { ints[y] =
individuos[i][j] = 1; Integer.parseInt(String.valueOf(np.charAt(y)));
} }
}
} bin = this.binariyToInteger(ints);
this.setIndividuos(individuos); if (bin > this.getVal_max()) {
} j--;
} else {
public String[][] cruce_individuos() { aux_matriz_mutacion[indi][1] = np ;
int[] matriz_pareja = new int[this.getIndividuosTotal()]; }
String[][] matriz_cruce = new
String[this.getIndividuosTotal()][3]; }
int[][] parejas_individuos = new
int[this.getIndividuosTotal() / 2][2]; this.setMatriz_mutacion(aux_matriz_mutacion);
parejas_individuos = this.getMatriz_pareja_2_Antigua(); return this.getMatriz_mutacion();
matriz_pareja[0] = parejas_individuos[0][1]; }
for (int i = 1; i <= this.getIndividuosTotal(); i++) {
matriz_pareja[i - 1] = this.matriz_parejas(i, public String[][] generacion_duplicada() {
parejas_individuos); int[] matriz_pareja = new int[this.getIndividuosTotal()];
} String[][] matriz_duplicado = new
for (int j = 0; j < this.getIndividuosTotal(); j++) { String[this.getIndividuosTotal()][3];
matriz_cruce[j][0] = (j + 1) + ""; String[] individuo = new String[this.getIndividuosTotal()];
matriz_cruce[j][1] = String[][] aux_MGeneracion = new
this.getMatriz_duplicado()[j][1].substring(0, String[this.getIndividuosTotal()][5];
this.PorcentajeCruce()) + aux_MGeneracion = this.getMatriz_generacion();
this.getMatriz_duplicado()[matriz_pareja[j] - for (int i = 0; i < this.getIndividuosTotal(); i++) {
1][1].substring(this.PorcentajeCruce(), int val_1 = Integer.parseInt(aux_MGeneracion[i][4]);//3
this.Longitud_del_Cromo()); int val_2 = Integer.parseInt(aux_MGeneracion[val_1 -
} 1][4]);//1
this.setMatriz_cruce(matriz_cruce); String id1 = aux_MGeneracion[val_1 - 1][1];//00110
return this.getMatriz_cruce(); String id2 = aux_MGeneracion[val_2 - 1][1];//00010
}
double pos1 =
public String[][] Mutar() { Double.parseDouble(aux_MGeneracion[val_1 - 1][3]);//36
int[] matriz_pareja = new int[this.getIndividuosTotal()]; double pos2 =
String[][] aux_matriz_mutacion = new Double.parseDouble(aux_MGeneracion[val_2 - 1][3]);//4
String[this.getIndividuosTotal()][3]; if (pos1 >= pos2) {
int aleatorio_in = this.PorcentajeMutacion(); individuo[i] = id1;
} else {
for (int i = 0; i < this.getIndividuosTotal(); i++) { individuo[i] = id2;
}
aux_matriz_mutacion[i][0] = (i + 1) + ""; }
aux_matriz_mutacion[i][1] =
this.getMatriz_cruce()[i][1]; int[][] parejas = new int[this.getIndividuosTotal() / 2][2];
} parejas = this.emparejamiento();
String np = ""; this.setMatriz_pareja_2(parejas);
for (int j = 0; j < aleatorio_in; j++) { matriz_pareja[0] = parejas[0][1];
np = ""; for (int i = 1; i <= this.getIndividuosTotal(); i++) {
int bin = 0; matriz_pareja[i - 1] = this.matriz_parejas(i, parejas);
}
int indi = (int) (Math.random() * for (int j = 0; j < this.getIndividuosTotal(); j++) {
(this.getIndividuosTotal() - 1));
int cromosomas = (int) (Math.random() * matriz_duplicado[j][0] = (j + 1) + "";
(this.Longitud_del_Cromo() - 1)); matriz_duplicado[j][1] = individuo[j];
for (int i = 0; i < aux_matriz_mutacion[indi][1].length(); matriz_duplicado[j][2] = matriz_pareja[j] + "";
i++) { }
 this.setMatriz_duplicado(matriz_duplicado); }
return this.getMatriz_duplicado();
} public int PorcentajeCruce() {
int cruce = this.Longitud_del_Cromo() *
public int matriz_parejas(int i, int[][] matriz) { this.getPorcentajeCruce() / 100;
for (int j = 0; j < this.getIndividuosTotal() / 2; j++) { //* (this.getPorcentajeCruce() / 100)
if (matriz[j][0] == i) { return cruce;
return matriz[j][1]; }
} else if (matriz[j][1] == i) {
return matriz[j][0]; public int PorcentajeMutacion() {
} int mutacion = this.getIndividuosTotal() *
} this.getPorcentajeMutacion() / 100;
return i; return mutacion;
} }
}
public int[][] emparejamiento() {
int[][] matriz = new int[this.getIndividuosTotal() / 2][2]; FUNCIONES
matriz[0][1] = (int) (Math.random() *
package modelo;
((this.getIndividuosTotal()) - 1)) + 2;
import org.lsmp.djep.djep.DJep;
matriz[0][0] = 1;
import org.nfunk.jep.Node;
for (int i = 1; i < this.getIndividuosTotal() / 2; i++) {
import org.nfunk.jep.ParseException;
int id = (int) (Math.random() *
((this.getIndividuosTotal()) - 1)) + 2;
matriz[i][1] = -1;
public class funcion {
matriz[i][0] = i + 1;
matriz[i][0] = this.emparejar_individuos(i + 1, matriz);
private DJep fxParse;
matriz[i][1] = this.emparejar_individuos(id, matriz);
private String funcion;
}
return matriz;
public funcion() {
}
{
fxParse = new DJep();
public int emparejar_individuos(int num, int[][] array) {
fxParse.addStandardConstants();
if (!this.pareja(num, array)) {
//agrega constantes estandares, pi, e, etc
return num;
fxParse.addStandardFunctions();
} else {
//agrega funciones estandares cos(x), sin(x)
return this.emparejar_individuos((int) (Math.random() *
fxParse.addComplex();
((this.getIndividuosTotal()) - 1)) + 2, array);
//por si existe algun numero complejo
}
fxParse.setAllowUndeclared(true);
}
//permite variables no declarables
fxParse.setAllowAssignment(true);
public boolean pareja(int id, int[][] array) {
//permite asignaciones
for (int i = 0; i < array.length; i++) {
fxParse.setImplicitMul(true);
if (array[i][0] == id || array[i][1] == id) {
//regla de multiplicacion o para sustraccion y sumas
return true;
fxParse.addStandardDiffRules();
}
}
}
}
return false;
}
public funcion(String f) {
fxParse = new DJep();
public int binariyToInteger(int[] Bit_Vector) {
this.funcion = f;
int resultado = 0;
fxParse.addStandardConstants();
/* Resultado en entero */
//agrega constantes estandares, pi, e, etc
fxParse.addStandardFunctions();
int lon = Bit_Vector.length - 1;
//agrega funciones estandares cos(x), sin(x)
fxParse.addComplex();
for (int i = 0; i < Bit_Vector.length; i++) {
//por si existe algun numero complejo
if (Bit_Vector[i] == 1) {
fxParse.setAllowUndeclared(true);
resultado += Math.pow(2, lon - i);
//permite variables no declarables
}
fxParse.setAllowAssignment(true);
}
//permite asignaciones
return resultado;
fxParse.setImplicitMul(true);
}
//regla de multiplicacion o para sustraccion y sumas
fxParse.addStandardDiffRules();
public int Longitud_del_Cromo() {
}
int longitud = 0;
for (int i = 1; i <= this.getVal_max(); i++) {
public String getFuncion() {
if (pow(2, i) <= this.getVal_max()) {
return funcion;
longitud = i;
}
}
}
public void setFuncion(String funcion) {
return longitud + 1;
 this.funcion = funcion; en cambiar algunos(s) bit(s) de 1 a 0 ó de 0
}
a 1.
public Double EvaluarFuncion(double x) throws
ParseException {
Node re;
String val; REFERENCIAS
fxParse.addVariable("x", x);
re = fxParse.parse(this.getFuncion());
[1] Ruge,, I. and Alvis, M. (2009).
val = (fxParse.evaluate(re)).toString(); Aplicación de los algoritmos genéticos para
return Double.parseDouble(val);
el diseño de un controlador PID adaptativo.
} Tecnura, [online] 13(25), pp.81-87.
}
Recuperado de:
http://www.redalyc.org/articulo.oa?id=257
VI. CONCLUSIÓN
020617008 [Accessed 31 May 2017].
Los algoritmos genéticos poseen
características que los hacen altamente [2] A.A. Javadi, R. Farmani and T.P. Tan.
robustos para resolver problemas de “A hybrid intelligent genetic algorithm”.
optimización, toma de decisiones, diseño y Advanced Engineering Informatics. Vol.
otros usos en la ingeniería. Cuando 19, Issue 4, pp. 255-262. 2005.
efectuamos la comparación con métodos
[3] Gestal, M., Rivero, D., Rabuñal, J.,
tradicionales de optimización, y se observa
Dorado, J. and Pazos, A. (2010).
que en general, se sacrifica eficacia para
Introducción a los algoritmos genéticos y la
ganar más eficiencia y robustez.
programación genética. 1st ed. Coruña:
El extendido aprovechamiento que se le Universidade da Coruña, Servizo de
está dando a los algoritmos genéticos es Publicacións, p.11.
real. No obstante, para la ingeniería en
[4] D. Goldberg. Genetic Algorithms in
nuestro país, todavía no se ha explotado
Search, Optimization, and Machine
esta útil herramienta, como ocurre en
Learning. Ed. Addison-Wesley.
muchos países del mundo.
[5] H. Tabares y J. Hernández, «Pronóstico
En problemas reales en los que se aplican
puntos críticos de la serie temporal
los algoritmos genéticos, existe la tendencia
“consumo de energía eléctrica del sector
a la homogeneización de la población, es
industrial en la ciudad de Medellín,”,
decir a que todos los individuos de la misma
usando algoritmos genéticos,» Revista
sean idénticos. Esto impide que el
Facultad de Ingeniería, nº 40, pp. 95-105,
algoritmo siga explorando nuevas
2007.
soluciones, con lo que podemos quedar
estancados en un mínimo local no muy [6] Salazar Hornig, E. and Sarzuri
bueno. Guarachi, R. (2015). Algoritmo genético
mejorado para la minimización de la
Existen técnicas para contrarrestar esta
tardanza total en un flowshop flexible con
"deriva genética". El mecanismo más
tiempos de preparación dependientes de la
elemental, aunque no siempre
secuencia. Ingeniare. Revista chilena de
suficientemente eficaz, es introducir una
ingeniería, 23(1), pp.118-127.
mutación tras la selección y el cruce. Una
vez que has realizado la selección y el cruce [7] S. Luke, "Two fast tree-creation
escoges un número determinado de bits de algorithms for genetic programming",
la población y los alteras aleatoriamente. IEEE Transactions on Evolutionary
En nuestro ejemplo consiste simplemente Computation, vol. 4, no. 3, pp. 274-283,
2000.
[8] J. Holland, Adaptation in Natural and
Artificial Systems - An Introductory, 1st ed.
Ann Arbor: The University of Michigan
Press, 1975.
[9] D. Goldberg, The design of innovation,
1st ed. Boston: Kluwer Academic
Publishers, 2002.
[10] I. Rechenberg, Evolutionsstrategie:
Optimierung technischer Systeme nach
Prinzipien der biologischen Evolution, 1st
ed. [Stuttgart-Bad Cannstatt]: Frommann-
Holzboog, 1973.
[11] L. Fogel, A. Owens and M. Walsh,
Artificial intelligence through simulated
evolution [by] Lawrence J. Fogel, Alvin J.
Owens [and] Michael J. Walsh, 1st ed. New
York: Wiley, 1966.
[12] D. Molina, D. Pandolfi y A. Villagra,
«Aplicación y evaluación de diferentes
algoritmos genéticos canónicos en el diseño
eficiente de redes de radio frecuencia en
comunicaciones inalámbricas,»
Laboratorio de Tecnologías Emergentes, nº
1121, pp. 135-161, 2013.
[13] Z. Michalewicz, Genetic algorithms +
data structures =, 1st ed. Berlin: Springer,
2011.
[14] B. Buckles and F. Petry, Genetic
algorithms, 1st ed. Los Alamitos, Calif:
IEEE Computer Society Press, 1993.
[15] M. Ison, J. Sitt y M. Trevisan,
«Algoritmos gen´eticos: aplicaci´on en
MATLAB,» 25 11 2005. [En línea].
Available:
http://users.df.uba.ar/ariel/materias/FT3_2
2006/Guias/old/guia_ga.pdf. [Último
acceso: 1 Junio 2017].
[16] Pino, E., Cornejo, L. and Román, C.
(2014). USO DE ALGORITMOS
GENÉTICOS PARA LA CALIBRACIÓN
DE UN MODELO HIDROLÓGICO
PRECIPITACIÓN-ESCORRENTIA EN
LA CUENCA DEL CAPLINA. Ciencia
&Desarrollo Taena, 18, pp.45-50.
[17] Sánchez, I. (2016). Aplicación de
Algoritmos Genéticos para la optimización
del corte de material.
http://hdl.handle.net/10251/68440.
[18] YU, J. (2009). Application of Genetic
Algorithms-based Fuzzy Comprehensive
Evaluation in Psychological Measurement.
Acta Psychologica Sinica, 41(10), pp.1015-
1023.
[19] Carrión, J., Cuenca, J. and Orellana, D.
(2016). Evaluación del Impacto que Genera
la Introducción Masiva de Cocinas de
Inducción en los Transformadores de
Distribución Usando Algoritmos
Genéticos. Revista Técnica Energía,
[online] 12(9), pp.191-199. Available at:
http://web.b.ebscohost.com [Accessed 1
Jun. 2017].
[20] "ALGORITMO GENÉTICO PARA
LA UBICACIÓN ÓPTIMA DE
SENSORES EN UN ROBOT SEGUIDOR
DE LÍNEA", Scientia Et Technica, vol., no.
41, , pp. 87-92, 2009.
[21] D. Molina, "Aplicación y evaluación
de diferentes algoritmos genéticos
canónicos en el diseño eficiente de redes de
radio frecuencia en comunicaciones
inalámbricas", Revista de Informes
Científicos - Técnicos UNPA, vol. 5, no. 3,
2013.
[22] H. Tabares and J. Hernández,
"Pronóstico puntos críticos de la serie
temporal “consumo de energía eléctrica del
sector industrial en la ciudad de Medellín,”,
usando algoritmos genéticos", Revista
Facultad de Ingeniería, no. 40, pp. 95-105,
2007.