🌌 👲🏽 🎣 Exécutez la fourmi. Courir 👨‍👩‍👧 🛄 ♣️

Cet article traite du processus de création d'un modèle de simulation du comportement d'une colonie de fourmis (peut être lu sur Wikipedia ) dans l'environnement de simulation "AnyLogic". Cet article est pratique. Il considérera l'utilisation de l'algorithme des fourmis pour résoudre le problème des vendeurs ambulants (vous pouvez lire ici ).

En bref sur l'essence

L'essence du problème des vendeurs ambulants est que le vendeur ambulant (vendeur) doit visiter N villes après avoir visité chacune d'elles une seule fois le long de l'itinéraire le plus court. Étant donné que cette tâche est complexe NP et que le nombre d'options pour tous les itinéraires possibles entre N villes est calculé comme «N!», Le temps de recherche d'itinéraire le plus court augmentera exponentiellement avec une augmentation de N. En conséquence, le temps de recherche d'itinéraire le plus court (solution) utilisant l'algorithme La «recherche exhaustive» (qui donne une solution exacte) avec le nombre de villes N> 16 augmente fortement (est exponentielle). Par conséquent, nous ne rechercherons pas la route la plus courte en longueur, mais nous la fermerons (rationnelle) dans un temps fini en utilisant «l'algorithme ant».

Quelques mots sur AnyLogic est un outil puissant qui vous permet de créer des modèles de simulation de complexité variable. Il met en œuvre différentes approches de simulation. Nous n'analyserons qu'une seule des approches, à savoir la modélisation «agent». Il est implémenté dans le langage de programmation Java, qui complète les outils existants. Le principal inconvénient de "AnyLogic" est la limitation de la version gratuite sur le nombre d'agents créés, leur nombre ne peut pas dépasser 50 000. "Agent" est l'unité de base du système de simulation AnyLogic. Plus d'informations peuvent être trouvées sur le site www.anylogic.ru

Outils

1. Anylogic - téléchargez la version gratuite ici www.anylogic.ru/downloads Introduction
initiale d'

AnyLogic : L' interface d'AnyLogic est montrée dans la figure 1. Elle comprend:

la zone verte est l'espace de l'agent dans lequel nous allons créer;
zone rouge - propriétés de l'objet mis au point;
palette - outils que vous pouvez utiliser lors de la création d'un modèle;
projets - la structure du modèle développé.

Figure. 1- Fenêtre popup AnyLogic

Création de projet

Ici, tout est simple. Cliquez sur l'élément de menu "Fichier" à côté de "Créer" puis "Modèle", entrez le nom du modèle et cliquez sur le bouton "Terminer" (Fig. 2).

Figure. 2- Création d'un modèle

Créer des villes

Eh bien, commençons. La première chose que nous ferons est de créer les soi-disant villes (haut du graphique) que la fourmi visitera. Pourquoi ouvrons-nous l'onglet «Agent» dans la palette et faisons glisser le cercle rouge avec le petit homme dans l'agent «Principal» à partir de là, comme le montre la figure 3.

Fig. 3- Création de villes

Après avoir relâché le bouton de la souris, une boîte de dialogue apparaît ("Étape 1"), vous invitant à créer un agent. Où il sera nécessaire de sélectionner l'élément "Population d'agents" et de cliquer sur le bouton "Suivant".

Figure. 4- Création de villes

La boîte de dialogue suivante apparaît (étape 2) où vous devrez saisir le nom du nouveau type d'agent et le nom de la population d'agents. Entrez le type "MyTown" et le nom de la population "myTowns" et cliquez sur le bouton "Suivant".

Figure. 4a - Entrez le nom du nouvel agent

Ensuite, la fenêtre suivante apparaîtra (étape 4.). Ici, nous sélectionnons «2D Agent Animation» et l'icône avec l'inscription «Plant» et cliquez sur le bouton «Finish» (Fig. 5).

Figure. 5- Ajouter une animation pour l'agent

Créez maintenant une variable qui déterminera le nombre initial de villes dans notre modèle. Pourquoi, depuis la "Palette", faites glisser l'icône avec l'inscription "Variable" dans l'agent "Principal" et entrez son nom "numberTown". Ensuite, cliquez sur l'icône de notre variable et dans l'onglet Propriétés, saisissez sa valeur initiale égale, par exemple, à 10 et sélectionnez son type «int» (Fig. 6).

Figure. 6- Création d'une variable

Maintenant, nous définissons la valeur initiale de la population de notre ville «myTowns», pour laquelle nous cliquons sur son icône et dans l'onglet «Propriétés» dans le champ «Nombre initial d'agents», écrivez le nom de la variable que nous avons créée précédemment (Fig. 7).

Figure. 7 - Changer les propriétés de la population «myTowns» Ensuite,

nous tirerons la conclusion de nos villes dans l'agent «Main» à un endroit aléatoire. L'espace est limité à un carré de 400x400 pixels. Pourquoi, dans l'onglet «Projets», sélectionner l'agent «Principal» avec la souris et dans l'onglet «Propriétés», dans le champ «Au démarrage», ajouter le code Java suivant (Fig. 7a):

for (int i=0; i<myTowns.size(); i++) {
	myTowns.get(i).setXY(uniform(0,400), uniform(0,400));
}

Où:

myTowns.size () - le nombre de villes créées;
myTowns.get (i) .setXY (uniforme (0,400), uniforme (0,400)) - définit les coordonnées X et Y pour la i-ème ville;
uniforme (0,400) - une fonction qui renvoie un nombre aléatoire dans la plage de 0 à 400 selon la loi de distribution également probable d'une variable aléatoire. L'environnement AnyLogic possède une boîte à outils étendue pour travailler avec diverses distributions de variables aléatoires. Il existe un constructeur intégré de distributions de probabilités, il est disponible dans la barre d'outils.

Où:

myTowns.size () - le nombre de villes créées;
myTowns.get (i) .setXY (uniforme (0,400), uniforme (0,400)) - définit les coordonnées X et Y pour la i-ème ville;
uniform(0,400) – , 0 400 . AnyLogic . .

Figure. 7a - Nous organisons les villes,

puis nous pouvons déjà voir ce que nous avons fait et commencer notre modèle. Pour ce faire, utilisez la touche "F5", cliquez dessus et la fenêtre de lancement de l'expérience est lancée comme le montre la figure 8.

Fig. 8 - Lancer l'expérience

Ensuite, cliquez sur le bouton "Exécuter" dans le coin inférieur gauche de la fenêtre et l'expérience démarre. Vous devriez obtenir une fenêtre avec le contenu à l'écran comme le montre la figure 9.

Fig. 9 - Le résultat de l'expérience

Donc, à cette étape, nous avons créé 10 villes et les avons placées dans un endroit aléatoire (stochastique) sur notre écran. Passons maintenant à la création de nos "fourmis"

Créer une fourmi

Ainsi, l'unité de combat principale de notre modèle sera une fourmi. Il faut d'abord le créer, puis modéliser son comportement.

La création d'une fourmi est similaire à la création d'une ville. Dans la "Palette", sélectionnez "Agent" et faites-le glisser vers "Principal". Sélectionnez «Population d'agents», puis «Je veux créer un nouveau type d'agent», puis entrez «Nom du nouveau type» et «Nom de la population» «MyAnt» «myAnts» et cliquez sur «Suivant». Après cela, nous sélectionnons l'animation «2D» et, par exemple, l'icône avec l'inscription «Fighter» appuyez sur «Terminer» et cela devrait tourner comme indiqué sur la figure 10.

Fig. 10 - Créer des fourmis

D'accord, l'avion ne ressemble pas à une fourmi, nous allons donc le réparer. Nous allons dans le moteur de recherche à la recherche d'une image qui représente une fourmi et changeons l'avion en fourmi. Pourquoi double-cliquez-vous sur le cercle rouge près de "myAnts". Après cela, l'onglet «myAnt» s'ouvrira où vous devrez retirer l'avion et placer la fourmi à sa place (Fig. 11).

Figure. 11 - Onglet MyAnt

Sélectionnez le plan avec la souris et appuyez sur "Suppr". Ensuite, allez dans l'onglet «Présentation» et faites glisser l'élément «Image» à partir de là. Après cela, une boîte de dialogue s'ouvrira automatiquement pour sélectionner un fichier. Sélectionnez le fichier avec notre fourmi (Fig.12) et cliquez sur OK.

Figure. 12 - Onglet MyAnt avec fourmi et déjà sans avion

Passez. Mettez la fourmi à l'échelle et déplacez-la à l'endroit où se trouvait l'avion. Il devrait tourner comme indiqué sur la figure 12a. Toutes ces opérations sont effectuées à l'aide de la souris.

Figure. 12a - Onglet MyAnt avec fourmi

On fait revivre la fourmi

Maintenant, nous devons apprendre à notre fourmi fraîchement préparée à ramper entre les villes. Certes, jusqu'à présent sans prendre en compte le modèle mathématique, mais laissez-le toujours fonctionner. Et donc, ouvrez le diagramme "Diagramme d'état" dans la "Palette" et continuez. Nous transférons les blocs suivants et les connectons ensemble:

Le début du diagramme d'état est le point de départ du cycle de vie de notre fourmi;
État - ce bloc caractérisera l'état du cycle de vie de notre fourmi. Ces blocs sont nécessaires en morceaux.
Transition - une flèche qui reliera nos «États» les uns aux autres et effectuera la transition d'un «État» à un autre «État» sous certaines conditions.

En conséquence, il devrait se révéler quelque chose comme le montre la figure 13.

Fig. 13 - La logique du comportement de la fourmi Écrivons

maintenant la logique initiale du diagramme de la fourmi. Nous sélectionnons avec la souris la flèche qui sort du bloc sous le nom «Select City» et ajoutons le code suivant dans le champ «Action» de l'onglet «Properties» (Fig. 14):

for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.5)) {
		this.moveTo(main.myTowns.get(i));
		break;
	} 
}

Ici, tout est très simple, nous traversons le cycle dans toutes les villes et lançons une pièce (nous générons une variable aléatoire avec probabilité 0,5) si sa valeur est vraie (aigle), puis nous envoyons la fourmi dans cette ville en quittant le cycle. L'expression «this.moveTo (main.myTowns.get (i))» est une fonction qui envoie un agent à un autre.

Figure. 14 - Définissez la logique initiale du mouvement de la fourmi.

Ensuite, cliquez sur la flèche qui quitte le bloc "Mouvement" et dans l'onglet "Propriétés", dans le champ "Se produit", définissez la valeur "A la réception d'un message" et sélectionnez "A la réception du message spécifié" dans le champ "Se produit". »Comme le montre la figure 15.

Fig. 15 - Définir la logique de la transition entre «Mouvement» et «Tout contourné»

Configurez maintenant la dernière flèche qui sort du bloc "Motion". Nous le sélectionnons avec la souris et dans l'onglet "Propriétés", dans le champ de transition, définissez "A l'arrivée de l'agent". La vue finale du «diagramme d'état» doit être celle illustrée à la figure 16.

Fig. 16 - Diagramme d'état avec transitions configurées entre les blocs

Alors, regardons comment fonctionne le "Diagramme d'état" du comportement des fourmis:

Le premier état dans lequel la fourmi tombe est "Vybor_city", jusqu'à présent aucune action n'a été énoncée.
Il passe ensuite à l'état suivant lors de la transition. Dans cette transition, nous avons ajouté un code qui démarre un cycle à travers toutes les montagnes et fait courir les fourmis dans les villes.
Le bloc "Mouvement" est l'endroit où se trouve la fourmi jusqu'à son arrivée dans la ville précédemment sélectionnée.
De plus, il a deux façons. D'abord, il revient au bloc "City_Choice" et tout se répète à nouveau. Sur le deuxième chemin, il devra partir quand il aura déjà visité toutes les villes. Jusqu'à présent, la deuxième voie n'est pas mise en place avec nous. Nous les traiterons un peu plus tard.

Figure. 17 - Fonctionnement du diagramme d'état

Maintenant, nous pouvons appuyer sur "F5" pour voir ce qui s'est passé (Fig. 18).

Figure. 18 - Le renouveau des fourmis

Définissez les critères

Alors, quels sont ces critères (règles):

Une fourmi ne devrait visiter chaque ville qu'une seule fois.
Ant, quand il a visité toutes les villes, met fin à son mouvement dans la dernière ville.

Ces critères nous sont dictés par l'état du problème du voyageur de commerce. Chaque fourmi sera avec nous une sorte de vendeur ambulant qui sillonne les villes.

Apprenons à la fourmi à respecter ces règles. Pourquoi, depuis la "Palette", l'onglet "Agent", transférez les "Collection" et "Variable" vers l'onglet "MyAnt" et nommez-les d'abord "isVisited" et le second comme "distance". La première prendra en compte les villes que nous avons déjà visitées, et la seconde la distance parcourue par la fourmi.

Figure. 19 - Ajouter des variables

Configurez la collection isVisited. Pourquoi le sélectionnons-nous avec la souris et définissons-nous le «Type» des éléments «int» dans l'onglet «Propriétés» comme illustré à la figure 20.
Pour la variable «distance» dans ses propriétés, dans le champ «Valeur initiale», définissez «0» et le type de variable «double» ".

Figure. 20 - Collection de type "int"

Sélectionnez maintenant la flèche sortant du bloc "City_block" et changez le code du champ "Action" en celui ci-dessous:

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;
	} 
}

Dans le code ci-dessus, nous avons ajouté un chèque pour les villes dans lesquelles nous avons déjà réussi à visiter, en tenant compte des villes que nous avons visitées et en tenant également compte de la distance parcourue. Le code est assez simple, je pense qu'il ne sera pas difficile à comprendre.

Vous pouvez essayer de lancer «F5» notre modèle et voir ce qui s'est passé. Maintenant, les fourmis ne traverseront toutes les villes qu'une seule fois et termineront leur mouvement dans le bloc.

Changer le placement initial des fourmis

À cette étape, nous déterminerons pour chaque fourmi que nous choisirons au hasard une ville à partir de laquelle il commencera son voyage. Pourquoi, dans l'onglet «Projets», sélectionner l'agent «Principal» avec la souris puis dans l'onglet «Propriétés» ajouter le code suivant au champ «Au démarrage» (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);
}

Figure. 20a - Disposition des fourmis par ville

J'ai appliqué une sélection aléatoire de la ville initiale. Vous pouvez initialement identifier toutes les fourmis dans une seule ville.

Rendre les fourmis imprévisibles

Introduisons la formule suivante dans notre modèle:

où Pi est la probabilité de transition le long du chemin du i-ème chemin, li est la longueur de la i-ème transition, fi est la quantité de phéromone à la i-ème transition, q est la valeur qui détermine la «cupidité» de l'algorithme, p - la valeur qui détermine le "troupeau" de l'algorithme, avec q + p = 1.

J'ai emprunté cette formule sur le site .

En termes simples, cette formule vous permet de calculer la probabilité avec laquelle la fourmi devra effectuer la transition vers une ville particulière.

Maintenant, nous devons ajouter plusieurs variables sans lesquelles nous ne pouvons pas le faire. Pourquoi revenir à l'onglet «Principal», figure 21.

Fig. 21 - Onglet «Principal»

Ainsi, nous ajoutons la variable "numberAnt", dans laquelle nous allons stocker la taille de la colonie de fourmis. Nous définissons son type sur "int" et la valeur initiale est 100.

Fig. 21 - Variable «numberAnt»

Sélectionnez ensuite la population «myAnts» et réglez le champ «Initial number of agents» sur «numberAnt».

La variable "p", qui déterminera le troupeau de l'algorithme. Son type est double et la valeur initiale est 0,5.

La variable "q", qui déterminera la cupidité de l'algorithme. Son type est double et la valeur initiale est 0,5.

Figure. 22 - Variables "q et p"

Donc, maintenant, nous allons définir une valeur aléatoire de phéromone pour chaque bord (route) entre les villes. Pourquoi créer une variable (tableau bidimensionnel) "matrixF". Réglez-le dans l'onglet «Propriétés» dans le champ «Type», sélectionnez la valeur «Autre» et écrivez «double [] []» dans le champ la valeur initiale «nouveau double [numberTown] [numberTown]» (Fig. 23).

Figure. 23 - Création d'un tableau bidimensionnel "matrixF". Matrice de phéromones

Ensuite, nous devons initialiser cette matrice. En d'autres termes, remplissez-le avec des valeurs aléatoires. Nous prenons la valeur de la phéromone au hasard dans la plage de 0,1 à
1. Pour cela, sur l'onglet "Projets", sélectionnez l'agent "Principal" avec la souris puis dans l'onglet "Propriétés" ajoutez le code suivant au champ "Au démarrage" (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);
	}
}

Figure. 23a - Code d'initialisation de la matrice de phéromones

Maintenant, nous revenons à l'onglet «MyAnt» et procédons au calcul de la probabilité de transition conformément à la formule ci-dessus. Sélectionnez la transition entre "City_Choice" et "Motion" et modifiez le code dans le champ Action comme suit (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;
	} 
}

Figure. 24 - Nous définissons le comportement de la fourmi sur la base de l'expression analytique de ce qui précède.

Alors maintenant, je vais expliquer un peu ce qui est quoi:

li - this.distanceTo (main.myTowns.get (i)), la valeur de la longueur entre la position actuelle de la fourmi et la ville «i»;
fi - main.matrixF [currentPos] [i], la valeur du niveau de phéromone entre la ville actuelle et la ville "i";
dénominateur - dénominateur + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.matrixF [currentPos] [i], main.p));, dénominateur Pi
Pi - Pi + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.myTowns.get (i) .f, main.p)) / dénominateur, la probabilité que la fourmi se déplace de la ville actuelle vers la ville «i».

Ensuite, nous sélectionnons la transition entre les blocs "Motion" et "All-bypass" avec la souris et sélectionnons "Quand la condition est remplie" dans le champ "Occurs", et dans le champ condition nous écrivons la condition pour que la fourmi s'arrête "isVisited.size () == main.myTowns.size ()" (fig.25).

Figure. 25 - Déterminez les conditions d'arrêt de la fourmi,

puis lancez le modèle «F5» et voyez ce qui s'est passé. Les fourmis voyageront entre les villes avec une probabilité calculée selon l'expression analytique ci-dessus.

Mettre à jour la valeur de la phéromone

Maintenant, faisons deux choses. La première action consiste à augmenter la valeur des phéromones sur le bord entre les villes le long desquelles la fourmi est passée. La seconde est l'évaporation des phéromones sur les bords entre les villes, qui consiste à réduire la valeur des phéromones par rapport au temps de simulation.

Ainsi, pour commencer par la première action, nous mettrons à jour la valeur de la phéromone de la côte entre la ville dans laquelle se trouve la fourmi et dans laquelle il ira. La valeur par laquelle nous augmenterons la valeur actuelle des bords des phéromones entre les villes sera calculée très, très simplement. Nous prenons notre valeur initiale maximale de la valeur des phéromones = 1 cu et le diviser par la distance entre la ville où se trouve la fourmi et la ville où il va se rendre. En conséquence, plus la distance entre les villes est petite, plus la valeur augmentera le niveau de la phéromone de la côte. Pourquoi sélectionnons-nous l'agent MyAnt dans l'onglet Projets, utilisez la souris pour sélectionner la transition entre les blocs "City_title" et "Movement" et ajoutons le code suivant au champ d'action: "main.matrixF [currentPos] [i] = main.matrixF [currentPos] [i ] + 1 / this.distanceTo (main.myTowns.get (i); ”.Le résultat doit être comme le montre la figure 26

Figure. 26 - Mise à jour de la valeur du niveau de phéromones des côtes le long desquelles la fourmi est passée

Maintenant passons à l'action n ° 2 et créons un événement qui simulera l'évaporation des phéromones sur les bords entre les villes. Pourquoi, dans l'onglet projets, sélectionnez l'agent «principal» et créez-y quelques variables supplémentaires. Le premier est «intensité» - il déterminera le taux (intensité) d'évaporation des phéromones (valeur initiale «0,5», type «double»). La deuxième «partie» - caractérisera la fraction par laquelle la valeur de la phéromone sur le bord diminuera (valeur initiale «0,9», tapez «double»).

Figure. 27 - Créer les variables "intensité" et "Part"

Ensuite, nous prenons l'élément "Event" de la "Palette" de l'onglet "Agent" et le transférons vers l'agent "Main" et l'appelons "évaporation" - cet élément simulera l'évaporation de la phéromone sur les bords. On clique dessus avec la souris et dans les "Propriétés" du champ "Type d'événement", on sélectionne la valeur "Avec une intensité donnée" dans le champ "Intensité", on écrit le nom de la variable qui stocke la valeur "intensité". Le temps de réponse est de quelques secondes. Ensuite, ajoutez le code ci-dessous à l'action:

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;
	}
}

Lorsque l'événement «évaporation» est déclenché, les niveaux de phéromones dans la matrice matrixF seront mis à jour. Par conséquent, vous devriez pouvoir faire comme indiqué sur la figure 28.

Fig. 28 - Créer l'événement «évaporation»

Déterminer le gagnant

À cette étape, nous ajouterons un code qui déterminera le gagnant de notre fourmi marathon. Le vainqueur sera celui des fourmis ayant parcouru le parcours le plus court. En plus de tout, après la fin du marathon, nous dessinons cette route à l'écran. Pour ce faire, nous allons créer trois variables «bestAnt», «bestDistance» et «numberFinish» dans l'agent «Main». Dans la variable "bestAnt", nous stockons l'index de la fourmi "la plus rapide", le type de la variable sera "int" et la valeur initiale sera définie sur "-1". Dans la variable "bestDistance", nous enregistrerons la valeur actuelle de la meilleure longueur d'itinéraire entre les villes, le type de la variable sera "double" et la valeur initiale sera définie sur l'infini "infinity". Dans la variable "numberFinish", nous enregistrerons le nombre de fourmis qui ont terminé notre marathon,le type de la variable sera "int" et la valeur initiale est "0" (Fig. 29).

Figure. 29 - Créer un événement de variables

Ensuite, nous créons une fonction qui, après avoir terminé toutes les fourmis, dessinera les lignes du meilleur itinéraire entre les villes. Pourquoi depuis la "Palette" nous glissons dans l'agent "Main" un élément avec la fonction name. Définissez le nom de la fonction sur drawPath et, dans l'onglet Propriétés, dans le champ du corps de la fonction, ajoutez le code suivant:

//        
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);

Par conséquent, vous devriez pouvoir faire comme indiqué dans la figure 29a.

Figure. 29a - Créer la fonction "drawPath"

Maintenant, revenons à nos fourmis et ajoutons un code qui déterminera la fourmi du vainqueur, la longueur du meilleur itinéraire et tracer cet itinéraire entre les villes. Pourquoi, dans l'onglet «Projets», sélectionnez l'agent «MyAnt», puis sélectionnez le bloc «All Bypassed» et ajoutez le code suivant au champ «Logon Action»:

//    
main.numberFinish++;
//      
if (main.bestDistance>distance) {
	//           
	//      
	main.bestDistance=distance;
	//    
	main.bestAnt = this.getIndex();
}
//         Main   
if (main.numberFinish==main.myAnts.size()) main.drawPath();

Il devrait tourner comme indiqué dans la figure 30.

Fig. 30 - Ajout de logique au bloc "All Bypassed".

Ensuite, vous pouvez appuyer sur "F5" et lancer le modèle. Les fourmis courront à la recherche d'itinéraires et une fois les villes terminées, la ligne bleue se connectera, ce qui est le meilleur itinéraire.

Ajouter un histogramme au modèle

Pour que le modèle devienne plus scientifique, vous devez ajouter un graphique. Par conséquent, nous ajouterons non seulement un graphique et un histogramme qui nous montreront la distribution de la longueur des routes que les fourmis ont surmontées. Pourquoi dans l'onglet "Projets" sélectionner l'agent "Principal" et aller dans son espace. De plus, dans la "Palette" nous allons dans l'onglet "Statistiques" et de là à l'agent "Principal" nous transférons l'élément "Données d'histogramme" et directement l '"Histogramme" lui-même. Ensuite, nous sélectionnons les histogrammes avec la souris et dans l'onglet «Propriétés», dans le champ «Données», spécifiez le nom de nos «Données d'histogramme» c'est-à-dire "Les données".

Il devrait tourner comme indiqué dans la figure 31

. 31 - Construire un horaire

Après quoi nous devrons de nouveau retourner chez notre fourmi et lui faire remplir l '"Histogramme" avec les valeurs de la longueur de la route. Pourquoi, dans l'onglet projets, sélectionnez l'agent "MyAnt" et accédez à son espace. Ensuite, sélectionnez le bloc "All Bypass" et ajoutez-y une ligne "main.data.add (distance);". Il devrait tourner comme indiqué sur la figure 32.

Fig. 32 - Construire un graphe

Ensuite, appuyez sur "F5" et procédez à l'étude du comportement de l'algorithme de fourmi. Il devrait en résulter quelque chose, quelque chose comme le montre la figure 33.

Fig. 33 - Modélisation

Conclusion

Et à la fin, je recommande d'ajouter plus d'imprévisibilité au modèle. Pour cela, dans l'onglet «Projets», sélectionnez l'élément «Simulation: Main» avec la souris et réglez le paramètre «Randomness» sur «Randomness initial number (unique runs)» dans l'onglet properties - cela rendra chaque lancement de modèle unique (Fig. 34).

Figure. 34 - Faire des runs aléatoires

Merci de votre attention! Le code source peut être téléchargé depuis GitHub

Exécutez la fourmi. Courir