Corre hormiga. correr

Este artículo analiza el proceso de creación de un modelo de simulación del comportamiento de una colonia de hormigas (se puede leer en Wikipedia ) en el entorno de simulación "AnyLogic". Este artículo es práctico. Considerará el uso del algoritmo de hormigas para resolver el problema del vendedor ambulante (puede leer aquí ).



Brevemente sobre la esencia.


La esencia del problema del vendedor ambulante es que el vendedor ambulante (vendedor) debe visitar N ciudades después de visitar cada una de ellas solo por la ruta más corta. Dado que este problema es complejo NP y el número de opciones para todas las rutas posibles entre N ciudades se calcula como “N!”, El tiempo de búsqueda de ruta más corto aumentará exponencialmente con un aumento en N. Por consiguiente, el tiempo de búsqueda de ruta (solución) más corto usando el algoritmo La “búsqueda exhaustiva” (que da una solución exacta) con el número de ciudades N> 16 aumenta bruscamente (es exponencial). Por lo tanto, no buscaremos la ruta más corta en longitud, sino que la acercaremos (racionalmente) en un tiempo finito utilizando el "algoritmo ant".

Algunas palabras sobre AnyLogic es una poderosa herramienta que le permite crear modelos de simulación de diversa complejidad. Implementa varios enfoques de simulación. Analizaremos solo uno de los enfoques, a saber, el modelado de "Agente". Se implementa en el lenguaje de programación Java, que complementa las herramientas existentes. La principal desventaja de "AnyLogic" es la limitación de la versión gratuita en el número de agentes creados, su número no puede exceder de 50,000. "Agente" es la unidad básica del sistema de simulación AnyLogic. Se puede encontrar más información en el sitio web www.anylogic.ru

Herramientas


1. Anylogic: descargue la versión gratuita desde aquí www.anylogic.ru/downloads Conocimiento
inicial de

AnyLogic : la interfaz de AnyLogic se muestra en la Figura 1. Incluye:
  • el área verde es el espacio del agente en el que crearemos;
  • área roja: propiedades del objeto que está enfocado;
  • paleta: herramientas que puede usar al crear un modelo;
  • proyectos: la estructura del modelo desarrollado.



Higo. 1- ventana emergente AnyLogic

Creación de proyectos


Todo es simple aquí. Haga clic en el elemento del menú "Archivo" junto a "Crear" y luego en "Modelo", ingrese el nombre del modelo y haga clic en el botón "Finalizar" (Fig. 2).


Higo. 2- Creando un modelo

Crear ciudades


Bueno, empecemos. Lo primero que haremos es crear las llamadas ciudades (partes superiores del gráfico) que visitará la hormiga. ¿Por qué abrimos la pestaña "Agente" en la paleta y arrastramos el círculo rojo con el hombrecito al agente "Principal" desde allí, como se muestra en la Figura 3.


Fig. 3- Crear ciudades

Después de soltar el botón del mouse, aparece un cuadro de diálogo ("Paso 1"), que le solicita que cree un agente. Donde será necesario seleccionar el elemento "Población de agentes" y hacer clic en el botón "Siguiente".


Higo. 4- Creación de ciudades

Aparece el siguiente cuadro de diálogo (Paso 2) donde deberá ingresar el nombre del nuevo tipo de agente y el nombre de la población de agentes. Ingrese el tipo "MyTown" y el nombre de la población "myTowns" y haga clic en el botón "Siguiente".


Higo. 4a - Ingrese el nombre del nuevo agente

Luego aparecerá la siguiente ventana (Paso 4). Aquí seleccionamos "Animación de agente 2D" y el ícono con la inscripción "Planta" y hacemos clic en el botón "Finalizar" (Fig. 5).


Higo. 5- Agregar animación para el agente

Ahora cree una variable que determinará el número inicial de ciudades en nuestro modelo. Por qué, desde la "Paleta", arrastre el icono con la inscripción "Variable" al agente "Principal" e ingrese su nombre "numberTown". Luego, haga clic en el icono de nuestra variable y en la pestaña Propiedades, ingrese su valor inicial igual a, por ejemplo, 10 y seleccione su tipo "int" (Fig. 6).


Higo. 6- Crear una variable

Ahora establecemos el valor inicial de nuestra población de ciudad "myTowns", para lo cual hacemos clic en su icono y en la pestaña "Propiedades" en el campo "Número inicial de agentes" escribimos el nombre de la variable que creamos anteriormente (Fig. 7).


Higo. 7 - Cambiar las propiedades de la población de "myTowns" A continuación, sacaremos la

conclusión de nuestras ciudades en el agente "Principal" en un lugar aleatorio. El espacio está limitado a un cuadrado de 400x400 píxeles. Por qué, en la pestaña "Proyectos", seleccione el agente "Principal" con el mouse y en la pestaña "Propiedades", en el campo "Al inicio", agregue el siguiente código Java (Fig. 7a):
for (int i=0; i<myTowns.size(); i++) {
	myTowns.get(i).setXY(uniform(0,400), uniform(0,400));
}

Dónde:
  • myTowns.size () - el número de ciudades creadas;
  • myTowns.get (i) .setXY (uniforme (0.400), uniforme (0.400)) - establece las coordenadas X e Y para la i-ésima ciudad;
  • uniforme (0,400): una función que devuelve un número aleatorio en el rango de 0 a 400 de acuerdo con la ley de distribución igualmente probable de una variable aleatoria. El entorno AnyLogic tiene un extenso juego de herramientas para trabajar con varias distribuciones de variables aleatorias. Hay un constructor incorporado de distribuciones de probabilidad, está disponible en la barra de herramientas.

Dónde:
  • myTowns.size () - el número de ciudades creadas;
  • myTowns.get (i) .setXY (uniforme (0.400), uniforme (0.400)) - establece las coordenadas X e Y para la i-ésima ciudad;
  • uniform(0,400) – , 0 400 . AnyLogic . .



Higo. 7a - Organizamos las ciudades.

Entonces ya podemos ver lo que hicimos y comenzar nuestro modelo. Para hacer esto, use la tecla "F5", haga clic y la ventana para iniciar el experimento se inicia como se muestra en la Figura 8.


Fig. 8 - Inicie el experimento

A continuación, haga clic en el botón "Ejecutar" en la esquina inferior izquierda de la ventana y comenzará el experimento. Debería obtener una ventana con el contenido en la pantalla como se muestra en la Figura 9.


Fig. 9 - El resultado del experimento

Entonces, en este paso creamos 10 ciudades y las colocamos en un lugar aleatorio (estocástico) en nuestra pantalla. Ahora pasemos a la creación de nuestras "hormigas"

Crear una hormiga


Entonces, la unidad de combate principal de nuestro modelo será una hormiga. Primero debemos crearlo y luego modelar su comportamiento.

Crear una hormiga es similar a crear una ciudad. En la "Paleta", seleccione "Agente" y arrástrelo a "Principal". Seleccione “Población de agentes”, luego “Deseo crear un nuevo tipo de agente”, luego ingrese “Nombre del nuevo tipo” y “Nombre de población” “MyAnt” “myAnts” y haga clic en “Siguiente”. Después de eso, seleccionamos la animación "2D" y, por ejemplo, el icono con la inscripción "Luchador" presiona "Finalizar" y debería aparecer como se muestra en la Figura 10.


Fig. 10 - Crea hormigas

De acuerdo, el avión no parece una hormiga, así que lo arreglaremos. Entramos en el motor de búsqueda en busca de una imagen que representa una hormiga y cambiamos el avión a una hormiga. ¿Por qué hacemos doble clic en el círculo rojo cerca de "myAnts"? Después de eso, la pestaña "myAnt" se abrirá donde necesite quitar el avión y colocar la hormiga en su lugar (Fig. 11).


Higo. 11 - Ficha MyAnt

Seleccione el avión con el mouse y presione "Del". A continuación, vaya a la pestaña "Presentación" y arrastre el elemento "Imagen" desde allí. Después de eso, se abrirá automáticamente un cuadro de diálogo para seleccionar un archivo. Seleccione el archivo con nuestra hormiga (Fig. 12) y haga clic en Aceptar.


Higo. 12 - pestaña MyAnt con hormiga y ya sin avión

Siga adelante. Escale la hormiga y muévala al lugar donde solía estar el avión. Debería resultar como se muestra en la Figura 12a. Todas estas operaciones se realizan con el mouse.


Higo. 12a - pestaña MyAnt con hormiga

Revivimos la hormiga


Ahora tenemos que enseñarle a nuestra hormiga recién horneada a gatear entre ciudades. Es cierto, hasta ahora sin tener en cuenta el modelo matemático, pero aún así lo dejo correr. Y así, abra el diagrama "Diagrama de estado" en la "Paleta" y continúe. Transferimos los siguientes bloques y los conectamos:
  • El comienzo del diagrama de estado es el punto de partida del ciclo de vida de nuestra hormiga;
  • Estado: este bloque caracterizará el estado del ciclo de vida de nuestra hormiga. Tales bloques se requieren en piezas.
  • Transición: una flecha que conectará nuestros "Estados" entre sí y realizará la transición de un "Estado" a otro "Estado" bajo ciertas condiciones.

Como resultado, debería resultar algo así como se muestra en la Figura 13.


Fig. 13 - La lógica del comportamiento de la hormiga

Ahora escribamos la lógica inicial del diagrama de la hormiga. Seleccionamos con el mouse la flecha que sale del bloque bajo el nombre "Seleccionar ciudad" y agregamos el siguiente código en el campo "Acción" en la pestaña "Propiedades" (Fig. 14):
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.5)) {
		this.moveTo(main.myTowns.get(i));
		break;
	} 
}

Aquí, todo es muy simple, pasamos por el ciclo en todas las ciudades y lanzamos una moneda (generamos una variable aleatoria con probabilidad. 0.5) si su valor es verdadero (águila), luego enviamos la hormiga a esta ciudad dejando el ciclo. La expresión "this.moveTo (main.myTowns.get (i))" es una función que envía un agente a otro.


Higo. 14 - Establezca la lógica inicial del movimiento de la hormiga.

A continuación, haga clic en la flecha que sale del bloque "Movimiento" y en la pestaña "Propiedades", en el campo "Ocurre", establezca el valor "Al recibir un mensaje" y seleccione "Al recibir el mensaje especificado" en el campo "Ocurre". »Como se muestra en la Figura 15.


Fig. 15 - Establezca la lógica para la transición entre "Movimiento" y "Omitió todo"

Ahora configure la última flecha que sale del bloque "Movimiento". Lo seleccionamos con el mouse y en la pestaña "Propiedades", en el campo de transición, establecemos "Al llegar el agente". La vista final del "diagrama de estado" debe ser como se muestra en la Figura 16.


Fig. 16 - Diagrama de estado con transiciones configuradas entre bloques

Entonces, veamos cómo funciona el "Diagrama de estado" del comportamiento de las hormigas:
  1. El primer estado en el que cae la hormiga es "Vybor_city", hasta ahora no se ha explicado ninguna acción.
  2. Luego pasa al siguiente estado después de la transición. En esta transición, agregamos un código que inicia un ciclo a través de todas las montañas y hace que las hormigas corran por las ciudades.
  3. El bloque "Movimiento" es donde se encuentra la hormiga hasta que llega a la ciudad previamente seleccionada.
  4. Además, tiene dos formas. Primero, regresa al bloque "City_Choice" y todo se repite nuevamente. En el segundo camino tendrá que ir cuando ya haya visitado todas las ciudades. Hasta ahora, la segunda forma no está configurada con nosotros. Nos ocuparemos de ellos un poco más tarde.



Higo. 17 - Operación del diagrama de estado

Ahora podemos presionar "F5" para ver qué sucedió (Fig. 18).


Higo. 18 - El avivamiento de las hormigas

Definir los criterios.


Entonces, ¿cuáles son estos criterios (reglas):
  1. Una hormiga debe visitar cada ciudad solo una vez.
  2. Ant, cuando visitó todas las ciudades termina su movimiento en la última ciudad.

Estos criterios nos los dicta la condición del problema del vendedor ambulante. Cada hormiga estará con nosotros como una especie de vendedor ambulante que viaja por las ciudades.

Enseñemos a la hormiga a cumplir con estas reglas. Por qué, desde la pestaña "Paleta", "Agente", transfiera la "Colección" y la "Variable" a la pestaña "MiAnt" y llámelas la primera como "se ha visitado" y la segunda como "distancia". El primero tendrá en cuenta las ciudades que ya hemos visitado, y el segundo la distancia recorrida por la hormiga.


Higo. 19 - Agregar variables

Configure la colección isVisited. ¿Por qué lo seleccionamos con el mouse y establecemos el "Tipo" de los elementos "int" en la pestaña "Propiedades" como se muestra en la Figura 20.
Para la variable "distancia" en sus propiedades, en el campo "Valor inicial", establezca "0" y el tipo de variable "doble" ".


Higo. 20 - Colección del tipo "int"

Ahora seleccione la flecha que sale del bloque "City_block" y cambie el código en el campo "Acción" al siguiente:
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.9) && isVisited.indexOf(i)==-1) {
		this.moveTo(main.myTowns.get(i));
		distance=distance+this.distanceTo(main.myTowns.get(i));
		isVisited.add(i);
		break;
	} 
}

En el código anterior, agregamos un cheque para las ciudades en las que ya hemos logrado visitar, y teniendo en cuenta las ciudades que visitamos, y también consideramos la distancia recorrida. El código es bastante simple, creo que no será difícil de entender.

Puede intentar lanzar "F5" nuestro modelo y ver qué sucedió. Ahora las hormigas pasarán por todas las ciudades solo una vez y completarán su movimiento en el bloque.

Cambiar la colocación inicial de hormigas


En este paso, determinaremos para cada hormiga que elegiremos al azar una ciudad desde la que comenzará su viaje. Por qué, en la pestaña "Proyectos", seleccione el agente "Principal" con el mouse y luego en la pestaña "Propiedades" agregue el siguiente código al campo "Al inicio" (Fig. 20a):
for (int i=0; i<myAnts.size(); i++) {
	//        
	int startTown = uniform_discr(0,myTowns-1);
	//     
	myAnts.get(i).setPosition(myTowns.get(startTown));
	//      
	myAnts.get(i).isVisited.add(startTown);
}



Higo. 20a - Organizando hormigas por ciudad

Apliqué una selección aleatoria de la ciudad inicial. Inicialmente puedes identificar todas las hormigas en una sola ciudad.

Hacer que las hormigas sean impredecibles


Presentemos la siguiente fórmula en nuestro modelo:



donde Pi es la probabilidad de transición a lo largo de la ruta i-ésima, li es la longitud de la transición i-ésima, fi es la cantidad de feromona en la transición i-ésima, q es el valor que determina la "codicia" del algoritmo, p - el valor que determina el "rebaño" del algoritmo, con q + p = 1.

Tomé prestada esta fórmula del sitio .

En términos simples, esta fórmula le permite calcular la probabilidad con la que la hormiga tendrá que hacer la transición a una ciudad en particular.

Ahora necesitamos agregar varias variables sin las cuales no podemos hacer. ¿Por qué volver a la pestaña "Principal", figura 21.


Fig. 21 - Pestaña "Principal"

Entonces, agregamos la variable "numberAnt", en la que almacenaremos el tamaño de la colonia de hormigas. Establecemos su tipo en "int" y el valor inicial es 100.


Fig. 21 - Variable "numberAnt"

A continuación, seleccione la población "myAnts" y configure el campo "Número inicial de agentes" en "numberAnt".

La variable "p", que determinará el rebaño del algoritmo. Su tipo es doble y el valor inicial es 0.5.

La variable "q", que determinará la codicia del algoritmo. Su tipo es doble y el valor inicial es 0.5.


Higo. 22 - Variables "q y p"

Entonces, ahora estableceremos un valor de feromona aleatorio para cada borde (carretera) entre las ciudades. ¿Por qué crear una variable (matriz bidimensional) "matrixF"? Ajústelo en la pestaña “Propiedades” en el campo “Tipo”, seleccione el valor “Otro” y escriba “doble [] []” en el campo el valor inicial “nuevo doble [númeroTown] [númeroTown]” (Fig. 23).


Higo. 23 - Crear una matriz bidimensional "matrixF". Matriz de feromonas

A continuación, necesitamos inicializar esta matriz. En otras palabras, llénalo con valores aleatorios. Tomamos el valor de feromona al azar en el rango de 0.1 a
1. Para esto, en la pestaña "Proyectos", seleccione el agente "Principal" con el mouse y luego en la pestaña "Propiedades" agregue el siguiente código al campo "Al inicio" (Fig. 23a):
for (int i=0; i<myTowns.size(); i++) {
	for (int j=0; j<myTowns.size(); j++) {
		matrixF[i][j]=uniform(0.1,1);
	}
} 



Higo. 23a - Código de inicialización de la matriz de feromonas

Ahora volvemos a la pestaña "MyAnt" y procedemos a calcular la probabilidad de transición de acuerdo con la fórmula anterior. Seleccione la transición entre "City_Choice" y "Motion" y cambie el código en el campo Acción a lo siguiente (Fig. 24):
//       
double denominator=0; 
//          
for (int i=0; i<main.myTowns.size(); i++) {
	if (isVisited.indexOf(i)==-1) {	//     
	    //  i   
		denominator=denominator+(Math.pow(this.distanceTo(main.myTowns.get(i)), main.q)*Math.pow(main.myTowns.get(i).f, main.p));
	} 
}
//      i 
double Pi=0;
//    
double probility=uniform(0,1);
for (int i=0; i<main.myTowns.size(); i++) {
	//        Pi
	if (isVisited.indexOf(i)==-1) {
		//     i-      
		Pi=Pi+(Math.pow(this.distanceTo(main.myTowns.get(i)), main.q)*Math.pow(main.myTowns.get(i).f, main.p))/denominator;
	}
	//      Pi      probility
	if (probility<Pi && isVisited.indexOf(i)==-1) {
		//       i  
		this.moveTo(main.myTowns.get(i));
		//     
		distance=distance+this.distanceTo(main.myTowns.get(i));
		//           
		isVisited.add(i);
		break;
	} 
}



Higo. 24 - Establecemos el comportamiento de la hormiga en función de la expresión analítica de lo anterior.

Así que ahora explicaré un poco qué es qué:
  • li - this.distanceTo (main.myTowns.get (i)), el valor de longitud entre la posición actual de la hormiga y la ciudad "i";
  • fi - main.matrixF [currentPos] [i], el valor del nivel de feromona entre la ciudad actual y la ciudad "i";
  • denominador - denominador + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.matrixF [currentPos] [i], main.p));, denominador Pi
  • Pi - Pi + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.myTowns.get (i) .f, main.p)) / denominador, La probabilidad de que la hormiga se mueva de la ciudad actual a la ciudad "i".

A continuación, seleccionamos la transición entre los bloques "Movimiento" y "Todos anulados" con el mouse y seleccionamos "Cuando se cumple la condición" en el campo "Ocurre", y en el campo condición escribimos la condición para que la hormiga pare "isVisited.size () == main.myTowns.size ()" (fig. 25).


Higo. 25 - Determine las condiciones para detener la hormiga,

luego puede ejecutar el modelo "F5" y ver qué sucedió. Las hormigas viajarán entre ciudades con una probabilidad calculada de acuerdo con la expresión analítica anterior.

Actualización del valor de feromona


Ahora hagamos dos cosas. La primera acción es aumentar el valor de feromona en el borde entre las ciudades a lo largo de las cuales pasó la hormiga. El segundo es la evaporación de feromonas en los bordes entre ciudades, que consiste en reducir el valor de las feromonas en relación con el tiempo de simulación.

Entonces, para comenzar con la primera acción, actualizaremos el valor de la feromona de la costilla entre la ciudad en la que se encuentra la hormiga y a la que irá. El valor por el cual aumentaremos el valor actual de los bordes de feromonas entre ciudades se calculará de manera muy, muy simple. Tomamos nuestro valor inicial máximo del valor de feromona = 1 cu y divídalo por la distancia entre la ciudad en la que se encuentra la hormiga y la ciudad a la que irá. En consecuencia, cuanto menor sea la distancia, entre las ciudades, mayor será el valor por el cual se incrementará el nivel de feromona de la costilla. ¿Por qué seleccionamos el agente MyAnt en la pestaña Proyectos? Usamos el mouse para seleccionar la transición entre los bloques "City_title" y "Movimiento" y agregamos el siguiente código al campo de acción: "main.matrixF [currentPos] [i] = main.matrixF [currentPos] [i ] + 1 / this.distanceTo (main.myTowns.get (i); ".El resultado debe ser como se muestra en la Figura 26


Higo. 26 - Actualice el valor del nivel de feromonas de las costillas por las que pasó la hormiga.

Ahora procedemos al paso 2 y creamos un evento que simulará la evaporación de la feromona en las costillas entre ciudades. Por qué, en la pestaña de proyectos, seleccione el agente "Principal" y cree allí un par de variables más. El primero es "intensidad": determinará la velocidad (intensidad) de evaporación de feromona (valor inicial "0.5", tipo "doble"). La segunda "Parte" - caracterizará la fracción por la cual el valor de la feromona en el borde disminuirá (Valor inicial "0.9", tipo "doble").


Higo. 27 - Crea las variables "intensidad" y "Parte"

Luego, tomamos el elemento "Evento" de la "Paleta" de la pestaña "Agente" y lo transferimos al agente "Principal" y lo llamamos "evaporación": este elemento simulará la evaporación de feromona en los bordes. Haga clic con el mouse y en "Propiedades" en el campo "Tipo de evento", seleccione el valor "Con una intensidad dada" en el campo "Intensidad", escriba el nombre de la variable que almacena el valor de intensidad "intensidad". El tiempo de respuesta es segundos. A continuación, agregue el siguiente código a la acción:
for (int i=0; i<myTowns.size(); i++) {
	for (int j=0; j<myTowns.size(); j++) {
		matrixF[i][j]=matrixF[i][j]*Part;
		if (matrixF[i][j]<0.1) matrixF[i][j]=0.1;
	}
}

Cuando se activa el evento de “evaporación”, se actualizarán los niveles de feromona en la matriz matrixF. Como resultado, debería poder hacer lo que se muestra en la Figura 28.


Fig. 28 - Crear el evento de "evaporación"

Determina el ganador


En este paso, agregaremos un código que determinará el ganador de nuestro maratón de hormigas. El ganador será una de las hormigas que corrió la ruta más corta. Además de todo, después del final del maratón, dibujamos esta ruta en la pantalla. Para lograr esto, crearemos tres variables "bestAnt", "bestDistance" y "numberFinish" en el agente "Main". En la variable "bestAnt" almacenaremos el índice de la hormiga "más rápida", el tipo de la variable será "int" y el valor inicial se establecerá en "-1". En la variable "bestDistance" almacenaremos el valor actual de la mejor longitud de ruta entre ciudades, el tipo de la variable será "doble" y el valor inicial se establecerá en infinito "infinito". En la variable "numberFinish" almacenaremos el número de hormigas que han terminado en nuestro maratón,el tipo de la variable será "int" y el valor inicial es "0" (Fig. 29).


Higo. 29 - Crear un evento de variables

A continuación, creamos una función que, después de terminar todas las hormigas, dibujará las líneas de la mejor ruta entre las ciudades. Por qué desde la "Paleta" arrastramos al agente "Principal" un elemento con la función de nombre. Establezca el nombre de la función en drawPath y, en la pestaña Propiedades, en el campo del cuerpo de la función, agregue el siguiente código:
//        
for (int i=0; i<myAnts.get(bestAnt).isVisited.size()-1; i++) {
	//    
	ShapeLine myLine = new ShapeLine();
	//            i
	myLine.setX(myTowns.get(myAnts.get(bestAnt).isVisited.get(i)).getX());
	myLine.setY(myTowns.get(myAnts.get(bestAnt).isVisited.get(i)).getY());
	//            i+1
	myLine.setEndX(myTowns.get(myAnts.get(bestAnt).isVisited.get(i+1)).getX());
	myLine.setEndY(myTowns.get(myAnts.get(bestAnt).isVisited.get(i+1)).getY());
	//    ""
	myLine.setColor(blue);
	//   
	myLine.setLineStyle(LINE_STYLE_SOLID );
	//   
	myLine.setLineWidth(1);
	//    
	presentation.add(myLine);	
}
	//           
	ShapeLine myLine = new ShapeLine();
	myLine.setX(myTowns.get(myAnts.get(bestAnt).isVisited.get(myAnts.get(bestAnt).isVisited.size()-1)).getX());
	myLine.setY(myTowns.get(myAnts.get(bestAnt).isVisited.get(myAnts.get(bestAnt).isVisited.size()-1)).getY());
	myLine.setEndX(myTowns.get(myAnts.get(bestAnt).isVisited.get(0)).getX());
	myLine.setEndY(myTowns.get(myAnts.get(bestAnt).isVisited.get(0)).getY());
	myLine.setColor(blue);
	myLine.setLineStyle(LINE_STYLE_SOLID );
	myLine.setLineWidth(1);
	presentation.add(myLine);

Como resultado, debería poder hacer lo que se muestra en la Figura 29a.


Higo. 29a - Crear la función "dibujar Ruta"

Ahora volvemos a nuestras hormigas y agregamos un código que determinará la hormiga del ganador, la longitud de la mejor ruta y dibuja esta ruta entre ciudades. Por qué, en la pestaña "Proyectos", seleccione el agente "MyAnt", luego seleccione el bloque "Todos anulados" y agregue el siguiente código al campo "Acción de inicio de sesión":
//    
main.numberFinish++;
//      
if (main.bestDistance>distance) {
	//           
	//      
	main.bestDistance=distance;
	//    
	main.bestAnt = this.getIndex();
}
//         Main   
if (main.numberFinish==main.myAnts.size()) main.drawPath();

Debería resultar como se muestra en la Figura 30.


Fig. 30 - Agregar lógica al bloque "Todos anulados".

Luego puede presionar "F5" y ejecutar el modelo. Las hormigas correrán en busca de rutas, y cuando las ciudades terminen, la línea azul se conectará, que es la mejor ruta.

Agregar un histograma al modelo


Para que el modelo se vuelva más científico, debe agregar un gráfico. Por lo tanto, agregaremos no solo un gráfico y un histograma que nos mostrará la distribución de la longitud de las rutas que las hormigas han superado. ¿Por qué en la pestaña "Proyectos", seleccione el agente "Principal" y vaya a su espacio. Además, en la "Paleta" vamos a la pestaña "Estadísticas" y de allí al agente "Principal" transferimos el elemento "Datos de histograma" y directamente el "Histograma" mismo. Luego seleccionamos los histogramas con el mouse y en la pestaña "Propiedades", en el campo "Datos", especificamos el nombre de nuestros "Datos de histograma", es decir "Datos".

Debería resultar como se muestra en la Figura 31


. 31 - Construyendo un horario

Después de lo cual nuevamente tendremos que volver a nuestra hormiga y hacer que llene el "Histograma" con los valores de la longitud de la ruta. Por qué, en la pestaña de proyectos, seleccione el agente "MyAnt" y vaya a su espacio. Luego, seleccione el bloque "All Bypass" y agregue una línea "main.data.add (distance);". Debería resultar como se muestra en la Figura 32.


Fig. 32 - Construyendo un gráfico

Luego, presione "F5" y proceda a estudiar el comportamiento del algoritmo de hormigas. Debería resultar algo, algo como se muestra en la Figura 33.


Fig. 33 - Modelado

Conclusión


Y al final, recomiendo agregar más imprevisibilidad al modelo. Para esto, en la pestaña "Proyectos", seleccione el elemento "Simulación: Principal" con el mouse y establezca el parámetro "Aleatoriedad" en "Número inicial aleatorio (ejecuciones únicas)" en la pestaña de propiedades; esto hará que cada lanzamiento de modelo sea único (Fig. 34).


Higo. 34 - Hacer carreras aleatorias ¡

Gracias por su atención! El código fuente se puede descargar desde GitHub

All Articles