INDICE pág.

1- Introducción ………………………………………………………………...iii
2- Objetivo 8.………………………………………………………………..... 4
Planteamiento ………………………………………………………..... 4-6
3- Solución del Problema………………………………………………… 6
4- Generación de números aleatorios………………………………….. 7
5- Cambio de alelos ………………………………………………..... 7
6- Generación de número de Interacciones ………………………......... 9
7- Listado de iteraciones ………………………………………………….. 10
8- Respuestas planteamientos realizados ……………………………… 12
9- Listado de programa fuentes ……………………………………… 12-23
10- Conclusión……………………………………….....................................24

ii
 Introducción.

En los años 1970, de la mano de John Henry Holland, surgió una de las
líneas más prometedoras de la inteligencia artificial, la de los algoritmos
genéticos, (AG). Son llamados así porque se inspiran en la evolución
biológica y su base genético-molecular.
Estos algoritmos hacen evolucionar una población de individuos
sometiéndola a acciones aleatorias semejantes a las que actúan en
la evolución biológica (mutaciones y recombinaciones genéticas), así como
también a una selección de acuerdo con algún criterio, en función del cual se
decide cuáles son los individuos más adaptados, que sobreviven, y cuáles los
menos aptos, que son descartados.
Los algoritmos genéticos se enmarcan dentro de los algoritmos
evolutivos, que incluyen también las estrategias evolutivas, la programación
evolutiva y la programación genética.
La Universidad Nacional Abierta ofrece a los cursantes de la carrera
Ingeniería de Sistemas la materia computación evolutiva, la misma dentro de
su contenido deja claro el concepto de la programación de los cromosomas
con el objeto de crear individuos en torno a ciertas características que se
esperan, se ha elaborado una práctica que tiene como esencia mostrar en el
presente informe parte de los conocimientos adquiridos durante el estudio de
su contenido, la misma concluye con la elaboración de un programa que
satisface el planteamiento contenido en el mismo.

iii
 TRABAJO PRÁCTICO COMPUTACIÓN EVOLUTIVA (350)
OBJETIVO N° 8

Resolución del Problema del Agente Viajero (Travel Salesman

Problem) Mediante Estrategias Evolutivas

El propósito de este trabajo es iniciar al estudiante en la resolución

de problemas del mundo real mediante los principios de algoritmo
genético y estrategias evolutivas. El Problema del Agente Viajero
(TSP por sus siglas en inglés) trata de un vendedor ambulante que
debe visitar un conjunto de ciudades, pasando una sola vez por
cada una. El problema consiste en determinar el orden óptimo de
visitas al conjunto de ciudades, tal que el costo sea mínimo o que el
tiempo de recorrido sea mínimo o como en este ejercicio que la
distancia recorrida sea mínima, por tanto es un problema de
minimización.
Las especificaciones del problema se dan a
continuación:
• Se tienen diez (10) ciudades de Venezuela que deben ser
recorridas en la menor distancia posible para ello las ciudades
son enumerada (partiendo desde 0 hasta 9, esto es
especialmente útil a la hora de trabajar con arrays en la
programación) en la Tabla 1.

Numeración Ciudad
0 Caracas
1 Maracaibo
2 Barquisimeto
3 Valencia
4 Maracay
5 Mérida
6 Ciudad Bolívar
7 Los Teques
8 Barinas
9 Pto. La Cruz
Tabla 1
 CIUDAD DESTINO
(Km)
0 1 2 3 4 5 6 7 8 9
0 0 694 351 145 96 674 585 26 512 339
1 694 0 343 549 596 413 1178 668 455 1033
2 351 343 0 206 255 419 835 325 264 690
CIUDAD ORIGEN

3 145 549 206 0 49 529 668 119 367 484

4 96 596 255 49 0 578 626 70 416 435
5 674 413 419 529 578 0 1099 648 174 958
6 585 1178 835 668 626 1099 0 611 937 796
7 26 668 325 119 70 648 611 0 486 365
8 512 455 264 367 416 174 937 486 0 796
9 339 1033 690 484 435 958 796 365 796 0
Tabla 2

Para crear las rutas aleatorias (individuos) luego de la numeración

(0,1,..9) de las ciudades se debe generar diez (10) números aleatorios entre
0 y 9 y que no se repitan. Como todas las ciudades tienen las mismas
probabilidades de aparecer para generar el número aleatorio se debe
emplear la Distribución Uniforme.

Para obtener su fitness se deben sumar todas las distancias

recorridas entre las ciudades. Se requiere minimizar la distancia recorrida
(fitness) que a su vez permitiría minimizar los costos de transporte y reducir
el tiempo, para ello debe emplear la estrategia evolutiva (μ + 1) modificada,
ya que si se hacen cruces típicos entre individuos es posible obtener
ciudades repetidas en cada ruta, lo cual no conduciría a una solución. Por
lo tanto, en vez de seleccionar dos padres para el cruce, se debe
seleccionar un individuo al azar, luego se generan dos (2) números
aleatorios (0-9) que serán puntos al azar dentro del cromosoma. Se elimina
5
el alelo marcado por el primer valor aleatorio, se desplaza todos los alelos
hasta donde indica el segundo valor aleatorio y en este punto insertamos el
alelo eliminado. De esta manera resulta una nueva permutación. Como
recomendación para optimizar la generación de los dos (2) números
aleatorios de los alelos asegúrese que sean dos números diferentes.

Solución del Problema:

Se diseñó e implemento un programa que genera una población
tomando los datos suministrados como datos estáticos, el programa se
diseñó en su totalidad usando arreglos, estos contenedores tienen datos
estáticos como los son las rutas y las distancias que existen entre las
ciudades visitadas, esto se puede observar en la tablas 1 y en la tabla 2 (ver
lista de figuras N° 1 y N° 2), donde se evidencia que el programa contiene
los datos suministrados y en los mismos se cubre las exigencias realizadas.

Figura N°1 – Menú selector y Tabla 1

Figura N°2 – Distancias fijas en las rutas

6
Como se generaron los números aleatorios
Se desea generar una ruta aleatoria, sin repetir las rutas y sumar sus
distancias para generar el fitness, esto se evidencia a través de una de las
opciones la cual utiliza en principio el algoritmo suministrado con algunas
variantes ajustadas al diseño de arreglos, la generación de números aleatorios
se lleva a cabo a través de librerías propias de cada lenguaje, por lo general
las mimas se fundamentan en los algoritmos de Montecarlo, la función
aleatorio del lenguaje python, se basa en lo antes descrito. En el programa
que se entrega, esta función se utilizó para generar las diez ciudades a visitar
por el viajero calculando la distancia total, (ver figura N° 3).

Figura N°3 – Ruta generada a partir de 10 números aleatorios

Como se realizó el cambio de los alelos

Para continuar se pide que el programa genere dos números aleatorios
con un rango desde cero hasta 9, con el fin de aplicar un algoritmo genético.
El primer número aleatorio, indica el alelo inicial que se extraerá, y el
segundo número aleatorio apunta la casilla final o alelo final, en la casilla final
se ubicara el valor del alelo inicial, los pasos a seguir indican que al extraer el
primer alelo los sub-siguientes se corren de posición dejando libre el casillero
final, apuntado por el segundo número aleatorio, esta casilla será ocupada
por el valor extraído, ver resultados obtenidos en la Figura N° 4.
7
 Figura N° 4.Ruta aleatoria con los cambios hechos

Para finalizar los procesos se pide generar varias iteraciones, que

busque la ruta más corta a continuación se muestran varias figuras con varias
interacciones dando como resultado final la ruta más económica para el
viajero.

Generar número de Interacciones

El programa como se evidencia pide el número de interacciones que
se desean, en nuestro caso se generaron diez iteraciones, cuyos resultados
se muestran a continuación

8
Listado de Resultado de las diez iteraciones

9
10
 Como se observa al aplicar las diez simulaciones se obtiene la ruta más
económica como mejor fitness, ya que el objetivo es minimizar las distancias
a recorrer.
Respuestas planteamientos realizados
A continuación se da respuesta a las formulaciones presentes en la
propuesta realizada.
En lo que respecta a como se puede diseñar y emplear otra función
fitness, se sugiere crear y utilizar la función fitness al tratar de minimizar los
tiempos de ejecución de alguna obra o labor específica, identificando cada
uno de los procesos necesarios y el personal calificado para culminar la obra,
asignándoles el tiempo de realización por cada trabajador, de esta manera al
observar los tiempos de manufactura, teniendo la certeza de minimizar el
costo de elaboración.
En lo que se refiere al problema del agente viajero, el mismo se puede
resolver a través del uso del algoritmo de cumulo de partículas PSO, ya que
en el mismo se observa, que posee la estructura con datos que se necesitan
para resolver el mismo, esto es debido a que el PSO guarda el histórico de las
mejores rutas a seguir, en base a los sitios de mejores beneficios, En el mismo
se le indica al viajero cual es la mejor ruta que debe seguir, debido a la
experiencia que se guarda en los históricos, las variantes en dicho algoritmo
estarán marcadas en torno a las restricciones por los beneficios que se
desean conseguir.
El lenguaje utilizado para la ejecución del trabajo es Python 3.4.4, es
necesario indicar que a la fecha python posee una nueva versión python 3.6.1,
y en ambas se observan diferencias de sintaxis con mejoras hechas en la más
reciente, pero con el inconveniente que no trae compilador, el mismo es propio
de cada versión, el compilador que se utilizó es py2exe.exe, ambos se
encuentran en la página web, propia de python.
https://www.python.org/downloads/.

11
 Listado de programa fuente
#------------------------------------------------------------
# UNIVERSIDAD NACIONAL ABIERTA
# CENTRO LOCAL PORTUGUESA LAPSO ACADEMICO 2017-1
# ASIGNATURA :350-COMPUTACION EVOLUTIVA - TRABAJO PRACTICO
# ALUMNO:OSWALDO JOSE PEREZ MENDEZ CEDULA V-5.364.021
#------------------------------------------------------------
import os
from random import randrange
from _rutinas import
_iniarr,_dat0,_aleat,_tit0,_tab01,_tab02,_tab03_4,_tab05,_tab10,pause,opcion,_opcnum
#-----------------------------------------------------
_99ale,_ale00,_ale11,_alenw,_Ciud,_rtas,_Dist,_Fitn0 = _iniarr()
#-----------------------------------------------------
#------------- se crean arrays
_Ciud,_rtas,_Dist = _dat0(_Ciud,_rtas,_Dist)
#-------------------------------------------
#--- CREAN RUTA A PARTIR DE N° ALEATORIOS
#---------------------------------------
_ale00=_aleat(_ale00,randrange)
#---------------------------------------
# CALCULA Y MUESTRA
# REPORTES TABLA 1,2,3,4,5
#---------------------------------------
_0resp=0;_salir=False
while _salir==False:
os.system('cls')
_tit0()
print (" ----------------------")
print (" - <1> GENERA DATOS -")
print (" ----------------------")
print (" - <2> Tabla 1 -")
print (" - <3> Tabla 2 -")
print (" - <4> Tabla 3 y 4 -")
print (" - <5> Tabla 5 -")
print (" ----------------------")
print (" - <6> Genera -")
print (" - Iteracciones -")
print (" ----------------------")
print (" - <7> Fin <esc> -")
print (" ----------------------")
_sal=False
_opc=""
while _sal==False:
_opc=opcion()
if (_opc>chr(48) and _opc<chr(56)) or _opc<chr(27):
_sal=True
if _opc==chr(49):
#-------- GENERA DATOS
os.system('cls')
12
 pause()
if _opc==chr(50):
#-------- tablas 1
os.system('cls')
_tit0()
_tab01(_Ciud)
pause()
elif _opc==chr(51):
#-------- tablas 2
os.system('cls')
_tit0()
_tab02(_Dist)
pause()
elif _opc==chr(52):
#-------- tablas 3 y 4
os.system('cls')
_tit0()
_tab03_4(_ale00,_Ciud,_Dist,_rtas)
pause()
elif _opc==chr(53):
#-------- tablas 5
os.system('cls')
_tit0()
_tab05(_Dist,_ale00,_alenw,_Fitn0,randrange)
pause()
elif _opc==chr(54):
#-------- tablas 10
os.system('cls')
_tit0()
print ("------------------------------")
print ("- Indique N° de Interacciones-")
print ("------------------------------")
_Nointer=0
_Nointer=_opcnum()
_xx = _Nointer + 1
for x in range(_xx):
_ale00,_alenw=_tab10(_Dist,_ale00,_alenw,_Fitn0,randrange,x,_xx,os)
pause()
elif _opc==chr(55)or _opc==chr(27):
_salir=True
else:
_salir=False

13
#------------------------------------------------------------
# UNIVERSIDAD NACIONAL ABIERTA
# CENTRO LOCAL PORTUGUESA LAPSO ACADEMICO 2017-1
# ASIGNATURA :350-COMPUTACION EVOLUTIVA - TRABAJO PRACTICO
# ALUMNO:OSWALDO JOSE PEREZ MENDEZ CEDULA V-5.364.021
#------------------------------------------------------------
#--- MUESTRA ENCABEZADO
#---
def _tit0():
_titx=['','','','','']
_titx[0]='UNIVERSIDAD NACIONAL ABIERTA '
_titx[1]='CENTRO LOCAL PORTUGUESA LAPSO ACADEMICO 2017-1'
_titx[2]='ASIGNATURA :350-COMPUTACION EVOLUTIVA - TRABAJO PRACTICO'
_titx[3]='ALUMNO:OSWALDO JOSE PEREZ MENDEZ CEDULA V-5.364.021'
_titx[4]='--------------------------------------------------------'
for x in range(5):
print(_titx[x])
return _titx
#-----------------------------------------------
#-------- PAUSA
#-----------------------------------------------
def pause():
return input('Presiona ENTER para continuar')

def opcion():
return input("")

def _opcnum():
while True:
valor = input("")
try:
valor = int(valor)
return valor
except ValueError:
print("ATENCIÓN: Debe ingresar un número entero.")
return valor
#-----------------------------------------------
#---- inicializa arreglos
#-----------------------------------------------
def _iniarr():
_ale00= ['','','','','','','','','','']
_99ale= ['','','','','','','','','','']

_Fitn0= ['','','','','','','','','','']

_Ciud = ['','','','','','','','','','']

_rtas =[['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','','']]

_Dist =[['','','','','','','','','',''],
14
 ['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','','']]

_ale11 =[['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','','']]

_alenw =[['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','',''],
['','','','','','','','','','']]

return _99ale,_ale00,_ale11,_alenw,_Ciud,_rtas,_Dist,_Fitn0
#--------------------
#--- CREAN LOS ARRAYS
#--------------------
def _dat0(_Ciud,_rtas,_Dist):
_Ciud = ['Caracas ',
'Maracaibo ',
'Barquisimeto ',
'Valencia ',
'Maracay ',
'Merida ',
'Ciudad Bolivar',
'Los Teques ',
'Barinas ',
'Pto.la cruz ']

_rtas = [['Caracas - Caracas ',

'Caracas - Maracaibo ',
'Caracas - Barquisimeto ',
'Caracas - Valencia ',
'Caracas - Maracay ',
'Caracas - Merida ',
'Caracas - Ciudad Bolivar ',
'Caracas - Los Teques ',
'Caracas - Barinas ',
'Caracas - Pto.la cruz '],
['Maracaibo - Caracas ',
15
 'Maracaibo - Maracaibo ',
'Maracaibo - Barquisimeto ',
'Maracaibo - Valencia ',
'Maracaibo - Maracay ',
'Maracaibo - Merida ',
'Maracaibo - Ciudad Bolivar ',
'Maracaibo - Los Teques ',
'Maracaibo - Barinas ',
'Maracaibo - Pto.la cruz '],
['Barquisimeto - Caracas ',
'Barquisimeto - Maracaibo ',
'Barquisimeto - Barquisimeto ',
'Barquisimeto - Valencia ',
'Barquisimeto - Maracay ',
'Barquisimeto - Merida ',
'Barquisimeto - Ciudad Bolivar ',
'Barquisimeto - Los Teques ',
'Barquisimeto - Barinas ',
'Barquisimeto - Pto.la cruz '],
['Valencia - Caracas ',
'Valencia - Maracaibo ',
'Valencia - Barquisimeto ',
'Valencia - Valencia ',
'Valencia - Maracay ',
'Valencia - Merida ',
'Valencia - Ciudad Bolivar ',
'Valencia - Los Teques ',
'Valencia - Barinas ',
'Valencia - Pto.la cruz '],
['Maracay - Caracas ',
'Maracay - Maracaibo ',
'Maracay - Barquisimeto ',
'Maracay - Valencia ',
'Maracay - Maracay ',
'Maracay - Merida ',
'Maracay - Ciudad Bolivar ',
'Maracay - Los Teques ',
'Maracay - Barinas ',
'Maracay - Pto.la cruz '],
['Merida - Caracas ',
'Merida - Maracaibo ',
'Merida - Barquisimeto ',
'Merida - Valencia ',
'Merida - Maracay ',
'Merida - Merida ',
'Merida - Ciudad Bolivar ',
'Merida - Los Teques ',
'Merida - Barinas ',
'Merida - Pto.la cruz '],
['Ciudad Bolivar - Caracas ',
'Ciudad Bolivar - Maracaibo ',
'Ciudad Bolivar - Barquisimeto ',
'Ciudad Bolivar - Valencia ',
'Ciudad Bolivar - Maracay ',
'Ciudad Bolivar - Merida ',
'Ciudad Bolivar - Ciudad Bolivar',
'Ciudad Bolivar - Los Teques ',
'Ciudad Bolivar - Barinas ',
'Ciudad Bolivar - Pto.la cruz '],
16
 ['Los Teques - Caracas ',
'Los Teques - Maracaibo ',
'Los Teques - Barquisimeto ',
'Los Teques - Valencia ',
'Los Teques - Maracay ',
'Los Teques - Merida ',
'Los Teques - Ciudad Bolivar ',
'Los Teques - Los Teques ',
'Los Teques - Barinas ',
'Los Teques - Pto.la cruz '],
['Barinas - Caracas ',
'Barinas - Maracaibo ',
'Barinas - Barquisimeto ',
'Barinas - Valencia ',
'Barinas - Maracay ',
'Barinas - Merida ',
'Barinas - Ciudad Bolivar ',
'Barinas - Los Teques ',
'Barinas - Barinas ',
'Barinas - Pto.la cruz '],
['Pto.la cruz - Caracas ',
'Pto.la cruz - Maracaibo ',
'Pto.la cruz - Barquisimeto ',
'Pto.la cruz - Valencia ',
'Pto.la cruz - Maracay ',
'Pto.la cruz - Merida ',
'Pto.la cruz - Ciudad Bolivar ',
'Pto.la cruz - Los Teques ',
'Pto.la cruz - Barinas ',
'Pto.la cruz - Pto.la cruz ']]
#-------------------------------------------------------
_Dist=(( 0,694,351, 145, 96, 674, 585, 26, 512, 339),
(694, 0,343, 549, 596, 413,1178, 668, 455,1033),
(351, 343, 0, 206, 255, 419, 835, 325, 264, 690),
(145, 549,206, 0, 49, 529, 668, 119, 367, 484),
( 96, 596,255, 49, 0, 578, 626, 70, 416, 435),
(674, 413,419, 529, 578, 0,1099, 648, 174, 958),
(585,1178,835, 668, 626,1099, 0, 611, 937, 796),
(26, 668,325, 119, 70, 648, 611, 0, 486, 365),
(512, 455,264, 367, 416, 174, 937, 486, 0, 796),
(339,1033,690, 484, 435, 958, 796, 365, 796, 0))
#-------------------------------------------------------
return _Ciud,_rtas,_Dist

#---------------------------------------
#--- CREAN RUTA A PARTIR DE UN ALEATORIO
#---------------------------------------
def _aleat(_ale00,randrange):
#i=_ale00
#from random import randrange
x=0
while x<10:
cierto = True
while cierto and x<11:
_00ale = randrange(0,10); y = 0 ; cierto = False
while y<10:
if _00ale == _ale00[y]:
cierto = True
y=11
17
 else:
y=y+1
_ale00[x] = _00ale
x = x+1
return _ale00
#-------------------------------------
#-------- Tabla 1
def _tab01(_Ciud):
x =0
print ('- Numeracion Ciudad -- <----(TABLA 1)')
print ('-------------------------------')
x=0
for x in range(10):
print ('-- ',str(x).rjust(2," "),' ',_Ciud[x],' --')
print ('-------------------------------')
return
#-------------------------------------
#-------- Tabla 2
def _tab02(_Dist):
print (' Ciudad ! Ciudad Destino (TABLA 2) --')
print (' origen ! 0 1 2 3 4 5 6 7 8 9 --')
print ('-----------------------------------------------------------------------')
for x in range(10):
print( '--',
str(x).rjust(4),'!',
str(_Dist[x][0]).rjust(4," "),'',
str(_Dist[x][1]).rjust(4," "),'',
str(_Dist[x][2]).rjust(4," "),'',
str(_Dist[x][3]).rjust(4," "),'',
str(_Dist[x][4]).rjust(4," "),'',
str(_Dist[x][5]).rjust(4," "),'',
str(_Dist[x][6]).rjust(4," "),'',
str(_Dist[x][7]).rjust(4," "),'',
str(_Dist[x][8]).rjust(4," "),'',
str(_Dist[x][9]).rjust(4," "),'--')
print ('-----------------------------------------------------------------------')
return
#--------------------------------------------------------------------------------------
#-------- Tabla 3 y Tabla 4
#--------------------------------------------------------------------------------------
def _tab03_4(i,_Ciud,_Dist,_rtas):
print ('- N° (Tabla 3) -----------------------------------------------')
print ('- N° Aleatorio --- (Tabla 4) --')
print ('-- Orden Generado Ciudad ----------- Recorrido ----------- Distancia --')
print ('-------------------------------------------------------------------------------')
Fitn=0
for x in range(10):
_Enc =''
if x<1:
_Enc = '-- '+str(x+1).rjust(2," ")+' '+str(i[x]).rjust(2," ")+' '+_Ciud[i[x]]+' --- '
else:
_Enc = '-- '+str(x+1).rjust(2," ")+' '+str(i[x]).rjust(2," ")+' '+_Ciud[i[x]]+' '+(str(i[x-1])+'->'+str(i[x])).rjust(4)+'
'+_rtas[i[x-1]][i[x]]+' '+str(_Dist[i[x-1]][i[x]]).rjust(4)+' --'
Fitn= Fitn + _Dist[i[x-1]][i[x]]
print (_Enc)
print ('-------------------------------------------------------------------------------')
print (' Calculo del Fitness ---> ',str(Fitn).rjust(4),'Kms')
return

18
#---------------------------------
#--- Genera 2 N° Aleatorios
#--- para crear un nuevo individuo
#---------------------------------
def _Cnuev_i(_alenw,randrange):
#-------------------------
x0 =''; x1 =''
_c1=0;_c2 =0
#-------------------------
_inic = randrange(0,10)
_salida=False
while _salida==False:
_fin = randrange(0,10)
_salida=True
if _inic==_fin:
_salida=False
#---------------------------------
#-- ordenacion ascendente
#---------------------------------
x=0
if _inic > _fin:
x = _inic
_inic = _fin
_fin = x
#---------------------------------
_c1 = _inic
_c2 = _fin
#---------------------------------
#-- crea un nuevo individuo
#---------------------------------
x0 = _inic
x1 = _alenw[_inic]
#---------------------------------
for x0 in range(_inic,_fin):
_alenw[x0] = _alenw[x0+1]
_alenw[_fin] = x1
return _alenw,_c1,_c2

#-------------------------------------------------------
#----- Tabla 5
#-----
def _tab05(_Dist,_ale00,_alenw,_Fitn0,randrange):
#-----------------------------
#--------- totaliza el fitness
#---------
Fitn=0
E_Dist0='- '
for x in range(10):
if x < 9:
_Guion = " -"
if x==8:
_Guion = ""
Fitn = Fitn + _Dist[_ale00[x]][_ale00[x+1]]
E_Dist0= E_Dist0 + str(_Dist[_ale00[x]][_ale00[x+1]]).rjust(4," ") + _Guion
_Fitn0[0] = Fitn
x=0
#for x in range(1,10):
# _aletmp=["","","","","","","","","",""]
19
# _aletmp=_aleat(_aletmp,randrange)
# y=0
#----------------------------------------
#--- Genera 2 N° Aleatorios ----
#--- para crear un nuevo individuo ----
#--- ----
_alenw=["","","","","","","","","",""]
_c1 = 0; _c2 = 0
for x in range(10):
_alenw[x] = _ale00[x]
_alenw,_c1,_c2 = _Cnuev_i(_alenw,randrange)
#-------------------------------------------------------------
#-- facilita la muestra del cambio genetico en los alelos
#-------------------------------------------------------------
E_stit = ''
_aevol=['____','____','____','____','____','____','____','____','____','____']
if _c1==0:
_aevol[0]="[xx]"
if _c1==1 or _c2==1:
_aevol[1]="[xx]"
if _c1==2 or _c2==2:
_aevol[2]="[xx]"
if _c1==3 or _c2==3:
_aevol[3]="[xx]"
if _c1==4 or _c2==4:
_aevol[4]="[xx]"
if _c1==5 or _c2==5:
_aevol[5]="[xx]"
if _c1==6 or _c2==6:
_aevol[6]="[xx]"
if _c1==7 or _c2==7:
_aevol[7]="[xx]"
if _c1==8 or _c2==8:
_aevol[8]="[xx]"
if _c2==9:
_aevol[9]="[xx]"
#-------------------------------------------------------------
Fitn = 0
E_Distn = '- '
for x in range(10):
#---------------------------------------------------------------
E_stit = E_stit + '__' + _aevol[x] # <- ubica el cambio genetico
#---------------------------------------------------------------

for x in range(9):
_Guion = " -"
if x==8:
_Guion = ""
Fitn = Fitn + _Dist[_alenw[x]][_alenw[x+1]]
E_Distn= E_Distn + str(_Dist[_alenw[x]][_alenw[x+1]]).rjust(4," ") + _Guion
_Fitn0[1] = Fitn
#---------------------------------------
#---- CREACION DE REPORTES
#---- PARA INDIVIDUO ORIGINAL
#---- PARA NUEVO INDIVIDUO
#---------------------------------------
#-----
#----- ALELO DEL INDIVIDUO ORIGINAL
_0Enc = ''
20
 _0Enc = '- ' + str(_ale00[0]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[1]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[2]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[3]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[4]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[5]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[6]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[7]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[8]).center(4," ")
_0Enc = _0Enc + '->' + str(_ale00[9]).center(4," ")
#------------------------------------------------
#---- ALELO DEL NUEVO INDIVIDUO
_1Enc =''
_1Enc = '- ' + str(_alenw[0]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[1]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[2]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[3]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[4]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[5]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[6]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[7]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[8]).center(4," ")
_1Enc = _1Enc + '->' + str(_alenw[9]).center(4," ")
#--------------------------------------------------
#---- Escoje el mejor Fitness de los dos individuos
#---- la ruta mas corta y crea mensaje
#----
if _Fitn0[0]<_Fitn0[1]:
E_Dist0 = E_Dist0 + '=' + str(_Fitn0[0]).rjust(4," ") + '<-Mejor Fitness'
E_Distn = E_Distn + '=' + str(_Fitn0[1]).rjust(4," ") + '<-Rechazado'
else:
E_Dist0 = E_Dist0 + '=' + str(_Fitn0[0]).rjust(4," ") + '<-Rechazado'
E_Distn = E_Distn + '=' + str(_Fitn0[1]).rjust(4," ") + '<-Mejor Fitness'
#---------------------------------------------------------------------------
#- cromosoma (Tabla 5) -Fitness-
#0123456789012345678901234567890123456789012345678901234567890123456789
# 1 2 3 4 5 6 66
#---------------------------------------------------------------------------
print ('- cromosoma (Tabla 5) -Fitness-')
print (E_stit)
print (_0Enc)
print (E_Dist0)
print ('Nuevo Individuo'.center(66," "))
print (_1Enc)
print (E_Distn)
print ('----------------------------------------------------')
return

#-------------------------------------------------------
#----- Tabla 10
#-----
def _tab10(_Dist,_ale00,_alenw,_Fitn0,randrange,_Iter,_Niter,os):
#---------------
os.system('cls')
_tit0()
#-----------------------------
#--------- totaliza el fitness
#---------
#------------------------------------------------------------------------------
21
_Fitn0=0;_xxx=0;
E_Dist0=["","","","","","","","","",""]
E_Dist0[0]=0
for x in range(10):
_xxx = x;_xxx = _xxx + 1;
if x < 9:
_Fitn0 = _Fitn0 + _Dist[_ale00[x]][_ale00[x+1]]
E_Dist0[_xxx]= str(_Dist[_ale00[x]][_ale00[x+1]]).rjust(5," ")
#------------------------------------------------------------------------------
#-- crea nueva ruta
#----------------------------------------------
#for x in range(1,10):
# _aletmp=["","","","","","","","","",""]
# _aletmp=_aleat(_aletmp,randrange)
# y=0
#----------------------------------------
#--- Genera 2 N° Aleatorios ----
#--- para crear un nuevo individuo ----
#--- ----
_alenw=["","","","","","","","","",""]
_c1 = 0; _c2 = 0
for x in range(10):
_alenw[x] = _ale00[x]
_alenw,_c1,_c2 = _Cnuev_i(_alenw,randrange)
#-------------------------------------------------------------
#-- facilita la muestra del cambio genetico en los alelos
#-------------------------------------------------------------
_aevol=[' ',' ',' ',' ',' ',' ',' ',' ',' ',' ']
if _c1==0:
_aevol[0]="XX"
if _c1==1 or _c2==1:
_aevol[1]="XX"
if _c1==2 or _c2==2:
_aevol[2]="XX"
if _c1==3 or _c2==3:
_aevol[3]="XX"
if _c1==4 or _c2==4:
_aevol[4]="XX"
if _c1==5 or _c2==5:
_aevol[5]="XX"
if _c1==6 or _c2==6:
_aevol[6]="XX"
if _c1==7 or _c2==7:
_aevol[7]="XX"
if _c1==8 or _c2==8:
_aevol[8]="XX"
if _c2==9:
_aevol[9]="XX"
_Fitn1 = 0
E_Distn=["","","","","","","","","",""]
_xxx = 0;
E_Distn[0]=0
for x in range(10):
if x<9:
_Fitn1 = _Fitn1 + _Dist[_alenw[x]][_alenw[x+1]]
_xxx = x; _xxx=_xxx + 1;
E_Distn[_xxx]= str(_Dist[_alenw[x]][_alenw[x+1]]).rjust(5," ")
#--------------------------------------------------
#---- Escoje el mejor Fitness de los dos individuos
22
 #---- la ruta mas corta y crea mensaje
if _Fitn0<=_Fitn1:
E_Fitn0 = 'Mejor Fitness'
E_Fitnn = '- Rechazado -'
else:
E_Fitn0 = '- Rechazado -'
E_Fitnn = 'Mejor Fitness'
#---------------------------------------
#---- CREACION DE REPORTES
#---- PARA PADRES E HIJOS
#-----
#----- ALELO DEL INDIVIDUO ORIGINAL
_0Enc=["","","","","","","","","","","","",""]
_x=0;_xx="";
for x in range(10):
_x=x; _x = _x+1;
_xx = '-- ' + str(_x).rjust(2," ") + ' - ';
if x<10:
_0Enc[x] = _xx + _aevol[x] + ' -> ' + str(_ale00[x]).center(4," ") + ' ' + str(E_Dist0[x]).rjust(4," ") + '
->' + str(_alenw[x]).center(4," ") + ' ' + str(E_Distn[x]).rjust(4," ") + ' --';
_0Enc[10] ='----------------------------------------------------------'
_0Enc[11] =' ' + E_Fitn0 +' ' + str(_Fitn0).rjust(4," ") +' '+ E_Fitnn + ' ' + str(_Fitn1).rjust(4," ") +'--'
_0Enc[12] ='----------------------------------------------------------'
#- imprime reporte creado
#------------------------------------------------------------------
print ('-- Iteracción N°->',str(_Iter).center(4," "),' --')
print ('-- N° Padre Hijo --')
print ('-- Alelo - N.A. - Cromosomas Fitnes - Cromosomas Fitnes --')
print ('----------------------------------------------------------')
for x in range(13):
print (_0Enc[x])
print ('----------------------------------------------------------')
if _Fitn0>=_Fitn1:
_ale00= [0,0,0,0,0,0,0,0,0,0]
for x in range(10):
_ale00[x]=_alenw[x];
else:
_alenw = [0,0,0,0,0,0,0,0,0,0]
return _ale00,_alenw ////// FIN DE LISTADO

23
 Conclusiones
En el transcurso del semestre se pudo evidenciar la utilidad que se
logra en la búsqueda de obtener respuesta favorable en torno de cualquier
dificultad que se presente, al tener conocimientos de los innumerables
estudios realizados en torno a la implementación de esa inteligencia propia de
las especies que nos rodean, y que es proporcionada por la naturaleza, esta
habilidad se refleja en la aptitud presentada por las especies existentes, al
momento de afrontar alguna adversidad, por ejemplo al observar a las
hormigas o los insectos, como se comunican en la búsqueda de recursos,
minimizando el costo, esto lo logran a través de la feromona que segregan al
momento de buscar recursos, se concluye que a menor distancia, mayor será
la concentración de feromona, lo cual indicara cual será la ruta de menor costo
a seguir, en caso contrario si la distancia es mayor la misma se dispersara.
Otro caso que vale la pena reflexionar es el de las aves al observar el
comportamiento de ellas en el medio ambiente, una característica que resalta
es el liderazgo presente en todas, aunque su conducta refleja la necesidad de
un líder en su población, que tendrá como finalidad orientar a la especie en la
búsqueda de recursos en base a la experiencia acumulada.
Se indagó en el campo de la genética donde la incidencia que tienen
los cromosomas con sus alelos al definir los fenotipos y genotipos de las
especies, se observa al producir los cambios necesarios en sus alelos definen
la futura generación de excelencia, llama la atención como detrás de la
evolución de las especies existe la habilidad que tienen algunas a sobrevivir
a las condiciones ambientales y a las situaciones adversas, esta habilidad en
gran parte se debe a la programación de sus cromosomas que le permite
perdurar en el tiempo.
Las estrategias evolutivas serán los métodos a utilizar al generar
población, al seleccionar las muestras, y al aplicar la mutación en ellas,
seleccionando los mejores padres e hijos que cumplan con la condición de
estudio, este método se resume en sus tipos (1 + 1), (µ + 1), (µ + λ), (µ, λ).
Para finalizar los estudios realizados en el campo de la computación
evolutiva, tienen un punto de convergencia que es el algoritmo genético,
diseñado para imitar el comportamiento de las especies en estudio, estos
algoritmos son de mucha utilidad al ser implementados en la búsqueda de
soluciones para resolver, muchas de las problemáticas que se presentan en
labores cotidianas, en fin dichas secuencias no son nada despreciables en la
realización y puesta en marcha de futuros proyectos.

24