Execute formiga. Corre

Este artigo discute o processo de criação de um modelo de simulação do comportamento de uma colônia de formigas (pode ser lido na Wikipedia ) no ambiente de simulação "AnyLogic". Este artigo é prático. Ele considerará o uso do algoritmo formiga para resolver o problema do vendedor ambulante (você pode ler aqui ).



Brevemente sobre a essência


A essência do problema do vendedor ambulante é que o vendedor ambulante (vendedor) deve visitar N cidades depois de visitar cada uma delas apenas uma vez no caminho mais curto. Como essa tarefa é complexa em NP e o número de opções para todas as rotas possíveis entre N cidades é calculado como “N!”, O menor tempo de busca de rotas aumentará exponencialmente com um aumento de N. Assim, o menor tempo de busca de rotas (solução) usando o algoritmo "Pesquisa exaustiva" (que fornece uma solução exata) com o número de cidades N> 16 aumenta acentuadamente (é exponencial). Portanto, não procuraremos a rota mais curta em comprimento, mas aproximar-nos (racionalmente) em um tempo finito usando o “algoritmo ant”.

Algumas palavras sobre o AnyLogic é uma ferramenta poderosa que permite criar modelos de simulação de complexidade variável. Ele implementa várias abordagens de simulação. Analisaremos apenas uma das abordagens, a modelagem “agente”. É implementado na linguagem de programação Java, que complementa as ferramentas existentes. A principal desvantagem do “AnyLogic” é a limitação da versão gratuita do número de agentes criados; seu número não pode exceder 50.000. “Agent” é a unidade básica do sistema de simulação AnyLogic. Mais informações podem ser encontradas no site www.anylogic.ru

Ferramentas


1. Anylogic - faça o download da versão gratuita aqui www.anylogic.ru/downloads
Introdução inicial do

AnyLogic : A interface do AnyLogic é mostrada na Figura 1. Inclui:
  • a área verde é o espaço do agente no qual criaremos;
  • área vermelha - propriedades do objeto que está em foco;
  • paleta - ferramentas que você pode usar ao criar um modelo;
  • projetos - a estrutura do modelo desenvolvido.



FIG. 1- Janela pop-up do AnyLogic

Criação de projeto


Tudo é simples aqui. Clique no item de menu “Arquivo” ao lado de “Criar” e depois em “Modelo”, digite o nome do modelo e clique no botão “Concluir” (Fig. 2).


FIG. 2- Criando um modelo

Criar cidades


Bem, vamos começar. A primeira coisa que faremos é criar as chamadas cidades (partes superiores do gráfico) que a formiga visitará. Por que abrimos a guia "Agente" na paleta e arrastamos o círculo vermelho com o homenzinho para o agente "Principal" a partir daí, como mostra a Figura 3.


Fig. 3- Criando cidades

Após soltar o botão do mouse, uma caixa de diálogo é exibida ("Etapa 1"), solicitando a criação de um agente. Onde será necessário selecionar o item "Agent Population" e clicar no botão "Next".


FIG. 4- Criando cidades

A seguinte caixa de diálogo é exibida (Etapa 2), na qual você precisará digitar o nome do novo tipo de agente e o nome da população de agentes. Digite o tipo "MyTown" e o nome da população "myTowns" e clique no botão "Next".


FIG. 4a - Digite o nome do novo agente

Em seguida, a seguinte janela aparecerá (Etapa 4.). Aqui, selecionamos “2D Agent Animation” e o ícone com a inscrição “Plant” e clique no botão “Finish” (Fig. 5).


FIG. 5- Adicione animação para o agente

Agora crie uma variável que determinará o número inicial de cidades em nosso modelo. Por que, na "Paleta", arraste o ícone com a inscrição "Variável" para o agente "Principal" e digite o nome "numberTown". Em seguida, clique no ícone da nossa variável e, na guia Propriedades, insira seu valor inicial igual a, por exemplo, 10 e selecione o tipo “int” (Fig. 6).


FIG. 6- Criando uma variável

Agora, definimos o valor inicial da população da nossa cidade “myTowns”, para o qual clicamos em seu ícone e na guia “Propriedades” no campo “Número inicial de agentes”, escreva o nome da variável que criamos anteriormente (Fig. 7).


FIG. 7 - Alterando as propriedades da população “myTowns” A seguir, traçaremos a

conclusão de nossas cidades no agente “Main” em um local aleatório. O espaço é limitado a um quadrado de 400x400 pixels. Por que, na guia "Projetos", selecione o agente "Principal" com o mouse e na guia "Propriedades", no campo "Na inicialização", adicione o seguinte código Java (Fig. 7a):
for (int i=0; i<myTowns.size(); i++) {
	myTowns.get(i).setXY(uniform(0,400), uniform(0,400));
}

Onde:
  • myTowns.size () - o número de cidades criadas;
  • myTowns.get (i) .setXY (uniforme (0,400), uniforme (0,400)) - defina as coordenadas X e Y para a i-ésima cidade;
  • uniforme (0,400) - uma função que retorna um número aleatório no intervalo de 0 a 400, de acordo com a lei de distribuição igualmente provável de uma variável aleatória. O ambiente AnyLogic possui um extenso kit de ferramentas para trabalhar com várias distribuições de variáveis ​​aleatórias. Existe um construtor interno de distribuições de probabilidade, que está disponível na barra de ferramentas.

Onde:
  • myTowns.size () - o número de cidades criadas;
  • myTowns.get (i) .setXY (uniforme (0,400), uniforme (0,400)) - defina as coordenadas X e Y para a i-ésima cidade;
  • uniform(0,400) – , 0 400 . AnyLogic . .



FIG. 7a - Organizamos as cidades,

depois já podemos ver o que fizemos e iniciar nosso modelo. Para fazer isso, use a tecla "F5", clique nela e a janela para iniciar o experimento é iniciada, como mostra a Figura 8.


Fig. 8 - Inicie o experimento

Em seguida, clique no botão "Executar" no canto inferior esquerdo da janela e o experimento inicia. Você deve obter uma janela com o conteúdo na tela, como mostra a Figura 9.


Fig. 9 - O resultado do experimento

Então, nesta etapa, criamos 10 cidades e as colocamos em um local aleatório (estocástico) em nossa tela. Agora vamos à criação de nossas "formigas"

Crie uma formiga


Portanto, a principal unidade de combate do nosso modelo será uma formiga. Em primeiro lugar, devemos criá-lo e depois modelar seu comportamento.

Criar uma formiga é semelhante a criar uma cidade. Na "Paleta", selecione "Agente" e arraste-o para "Principal". Selecione "População de agentes", depois "Quero criar um novo tipo de agente", digite "Nome do novo tipo" e "Nome da população" "MyAnt" "myAnts" e clique em "Avançar". Depois disso, selecionamos a animação “2D” e, por exemplo, o ícone com a inscrição “Fighter” pressiona “Finish” e deve aparecer como mostra a Figura 10.


Fig. 10 - Crie formigas

Concordo, o avião não se parece com uma formiga, então vamos consertá-lo. Entramos no mecanismo de busca à procura de uma imagem que retrate uma formiga e mudamos o avião para uma formiga. Por que clicamos duas vezes no círculo vermelho próximo a "myAnts". Depois disso, a aba “myAnt” abrirá onde você precisa remover o avião e colocar a formiga em seu lugar (Fig. 11).


FIG. 11 - Guia MyAnt

Selecione o avião com o mouse e pressione "Del". Em seguida, vá para a guia "Apresentação" e arraste o elemento "Imagem" de lá. Depois disso, uma caixa de diálogo será aberta automaticamente para selecionar um arquivo. Selecione o arquivo com a nossa formiga (Fig. 12) e clique em OK.


FIG. 12 - Guia MyAnt com formiga e já sem avião

Ir em frente. Escale a formiga e mova-a para o local onde o avião costumava estar. Ele deve aparecer como mostrado na Figura 12a. Todas essas operações são executadas usando o mouse.


FIG. 12a - guia MyAnt com formiga

Revivemos a formiga


Agora precisamos ensinar nossa formiga recém-assada a rastejar entre as cidades. É verdade, até agora sem levar em conta o modelo matemático, mas ainda assim deixá-lo funcionar. E assim, abra o diagrama “State diagram” na “Palette” e continue. Transferimos os seguintes blocos e os conectamos:
  • O início do diagrama de estados é o ponto de partida do ciclo de vida da nossa formiga;
  • Estado - este bloco irá caracterizar o estado do ciclo de vida da nossa formiga. Esses blocos são necessários em pedaços.
  • Transição - uma flecha que conectará nossos "Estados" e realizará a transição de um "Estado" para outro "Estado" sob certas condições.

Como resultado, deve aparecer algo como mostrado na Figura 13.


Fig. 13 - A lógica do comportamento da formiga

Agora vamos escrever a lógica inicial do diagrama da formiga. Selecionamos com o mouse a seta que sai do bloco com o nome "Selecionar cidade" e adicionamos o seguinte código no campo "Ação" na guia "Propriedades" (Fig. 14):
for (int i=0; i<main.myTowns.size(); i++) {
	if (randomTrue(0.5)) {
		this.moveTo(main.myTowns.get(i));
		break;
	} 
}

Aqui tudo é muito simples, percorremos o ciclo em todas as cidades e jogamos uma moeda (geramos uma variável aleatória com probabilidade 0,5) se seu valor é verdadeiro (águia), enviamos a formiga para essa cidade que sai do ciclo. A expressão "this.moveTo (main.myTowns.get (i))" é uma função que envia um agente para outro.


FIG. 14 - Defina a lógica inicial do movimento da formiga.

Em seguida, clique na seta que sai do bloco "Movimento" e, na guia "Propriedades", no campo "Ocorre", defina o valor "Ao receber uma mensagem" e selecione "Ao receber a mensagem especificada" no campo "Ocorre". »Como mostrado na Figura 15.


Fig. 15 - Defina a lógica para a transição entre "Movimento" e "Ignorou tudo"

Agora configure a última seta que sai do bloco "Motion". Nós o selecionamos com o mouse e, na guia "Propriedades", no campo de transição, definimos "Na chegada do agente". A vista final do "Diagrama de estado" deve ser mostrada na Figura 16.


Fig. 16 - Diagrama de estado com transições configuradas entre blocos

Então, vejamos como o "Diagrama de estado" do comportamento da formiga funciona:
  1. O primeiro estado em que a formiga cai é "Vybor_city", até agora nenhuma ação foi especificada.
  2. Então ele vai para o próximo estado após a transição. Nesta transição, adicionamos um código que inicia um ciclo por todas as montanhas e faz as formigas correrem pelas cidades.
  3. O bloco "Movimento" é o local em que a formiga fica localizada até chegar à cidade selecionada anteriormente.
  4. Além disso, ele tem duas maneiras. Primeiro, ele volta ao bloco "City_Choice" e tudo se repete novamente. No segundo caminho, ele terá que seguir quando já tiver visitado todas as cidades. Até agora, o segundo caminho não está configurado conosco. Nós vamos lidar com eles um pouco mais tarde.



FIG. 17 - Operação do diagrama de estados

Agora podemos pressionar "F5" para ver o que aconteceu (Fig. 18).


FIG. 18 - O renascimento das formigas

Definir os critérios


Então, quais são esses critérios (regras):
  1. Uma formiga deve visitar cada cidade apenas uma vez.
  2. Ant, quando ele visitou todas as cidades, encerra seu movimento na última cidade.

Esses critérios são ditados a nós pela condição do problema do vendedor ambulante. Cada formiga estará conosco um tipo de vendedor ambulante que viaja pelas cidades.

Vamos ensinar a formiga a cumprir essas regras. Por que, na "Paleta", na guia "Agente", transfira a "Coleção" e "Variável" para a guia "MyAnt" e chame-as de primeira como "isVisited" e a segunda como "distância". O primeiro levará em conta as cidades que já visitamos e o segundo a distância percorrida pela formiga.


FIG. 19 - Adicionar variáveis

Configure a coleção isVisited. Por que o selecionamos com o mouse e configuramos o "Tipo" dos elementos "int" na guia "Propriedades", como mostra a Figura 20.
Para a variável "distance" em suas propriedades, no campo "Valor inicial", defina "0" e o tipo de variável "double" "


FIG. 20 - Coleção do tipo "int"

Agora selecione a seta que sai do bloco "City_block" e altere o código no campo "Ação" para o abaixo:
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;
	} 
}

No código acima, adicionamos uma verificação das cidades nas quais já conseguimos visitar, levando em consideração as cidades que visitamos e também consideramos a distância percorrida. O código é bastante simples, acho que não será difícil para você entender.

Você pode tentar lançar “F5” nosso modelo e ver o que aconteceu. Agora as formigas passarão por todas as cidades apenas uma vez e completarão seu movimento no quarteirão.

Alterar o posicionamento inicial das formigas


Nesta etapa, determinaremos para cada formiga escolheremos aleatoriamente uma cidade da qual ele começará sua jornada. Por que, na guia "Projetos", selecione o agente "Principal" com o mouse e, na guia "Propriedades", adicione o seguinte código ao campo "Na inicialização" (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);
}



FIG. 20a - Organizando formigas por cidade

, apliquei uma seleção aleatória da cidade inicial. Você pode identificar inicialmente todas as formigas em apenas uma cidade.

Tornar as formigas imprevisíveis


Vamos introduzir a seguinte fórmula em nosso modelo:



onde Pi é a probabilidade de transição ao longo do caminho do i-ésimo caminho, li é o comprimento da i-ésima transição, fi é a quantidade de feromônio na i-ésima transição, q é o valor que determina a “ganância” do algoritmo, p - o valor que determina o "rebanho" do algoritmo, com q + p = 1.

Peguei emprestada essa fórmula do site .

Em termos simples, essa fórmula permite calcular a probabilidade com que a formiga terá que fazer a transição para uma cidade específica.

Agora precisamos adicionar várias variáveis ​​sem as quais não podemos fazer. Por que voltar para a guia “Principal”, figura 21.


Fig. 21 - Guia "Principal"

Então, adicionamos a variável "numberAnt", na qual armazenaremos o tamanho da colônia de formigas. Definimos seu tipo como "int" e o valor inicial é 100.


Fig. 21 - Variável “numberAnt” A

seguir, selecione a população “myAnts” e defina o campo “Número inicial de agentes” para “numberAnt”.

A variável "p", que determinará a reorganização do algoritmo. Seu tipo é duplo e o valor inicial é 0,5.

A variável "q", que determinará a ganância do algoritmo. Seu tipo é duplo e o valor inicial é 0,5.


FIG. 22 - Variáveis ​​"q e p"

Então, agora vamos definir um valor de feromônio aleatório para cada aresta (estrada) entre as cidades. Por que criar uma variável (matriz bidimensional) "matrixF". Defina-o na guia “Propriedades” no campo “Tipo”, selecione o valor “Outros” e escreva “duplo [] []” no campo o valor inicial “novo duplo [numberTown] [numberTown]” (Fig. 23).


FIG. 23 - Criando uma matriz bidimensional "matrixF". Matriz de Feromônios

Em seguida, precisamos inicializar essa matriz. Em outras palavras, preencha-o com valores aleatórios. Tomamos o valor de feromônio aleatoriamente no intervalo de 0,1 a
1. Para isso, na guia "Projetos", selecione o agente "Principal" com o mouse e, na guia "Propriedades", adicione o seguinte código ao campo "Na inicialização" (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);
	}
} 



FIG. 23a - Código de inicialização da matriz de feromônios

Agora retornamos à guia “MyAnt” e procedemos ao cálculo da probabilidade de transição de acordo com a fórmula acima. Selecione a transição entre "City_Choice" e "Motion" e altere o código no campo Action para o seguinte (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;
	} 
}



FIG. 24 - Definimos o comportamento da formiga com base na expressão analítica do item acima.

Agora , vou explicar um pouco o que é o que:
  • li - this.distanceTo (main.myTowns.get (i)), o valor do comprimento entre a posição atual da formiga e a cidade “i”;
  • fi - main.matrixF [currentPos] [i], o valor do nível de feromônio entre a cidade atual e a cidade “i”;
  • denominador - denominador + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.matrixF [currentPos] [i], main.p)); Pi
  • Pi - Pi + (Math.pow (this.distanceTo (main.myTowns.get (i)), main.q) * Math.pow (main.myTowns.get (i) .f, main.p)) / denominador, a probabilidade da formiga se mover da cidade atual para a cidade “i”.

Em seguida, selecionamos a transição entre os blocos "Movimento" e "Todos ignorados" com o mouse e selecionamos "Quando a condição for atendida" no campo "Ocorre" e, no campo de condição, escrevemos a condição para a formiga parar "isVisited.size () == main.myTowns.size ()" (fig. 25).


FIG. 25 - Determine as condições para parar a formiga e, em

seguida, execute o modelo “F5” e veja o que aconteceu. As formigas viajam entre cidades com uma probabilidade calculada de acordo com a expressão analítica acima.

Atualizando o valor do feromônio


Agora vamos fazer duas coisas. A primeira ação é aumentar o valor de feromônio na borda entre as cidades pelas quais a formiga passou. O segundo é a evaporação do feromônio nas bordas entre as cidades, que consiste em reduzir o valor dos feromônios em relação ao tempo de simulação.

Portanto, para começar com a primeira ação, atualizaremos o valor do feromônio da costela entre a cidade em que a formiga está localizada e aonde ele irá. O valor pelo qual aumentaremos o valor atual das bordas dos feromônios entre as cidades será calculado muito, muito simples. Tomamos nosso valor inicial máximo do valor de feromônio = 1 cu e divida-o pela distância entre a cidade em que a formiga está localizada e a cidade para onde ele irá. Consequentemente, quanto menor a distância, entre as cidades, maior será o valor pelo qual o nível do feromônio da costela será aumentado. Por que selecionamos o agente MyAnt na guia Projetos, use o mouse para selecionar a transição entre os blocos "City_title" e "Movement" e adicione o seguinte código ao campo de ação: "main.matrixF [currentPos] [i] = main.matrixF [currentPos] [i ] + 1 / this.distanceTo (main.myTowns.get (i); ”.O resultado deve ser como mostrado na Figura 26


FIG. 26 - Atualize o valor do nível de feromônios das costelas que a formiga passou:

Agora vamos para o passo 2 e criamos um evento que simula a evaporação do feromônio nas costelas entre as cidades. Por que, na guia Projetos, selecione o agente "Principal" e crie mais algumas variáveis ​​lá. A primeira é a "intensidade" - determinará a taxa (intensidade) de evaporação dos feromônios (valor inicial "0,5", tipo "duplo"). A segunda "Parte" - caracterizará a fração pela qual o valor do feromônio na borda diminuirá (Valor inicial "0,9", digite "duplo").


FIG. 27 - Crie as variáveis ​​"intensidade" e "Parte"

Em seguida, pegamos o elemento "Event" na "Palette" da guia "Agent" e transferimos para o agente "Main" e chamamos de "evaporação" - esse elemento simula a evaporação do feromônio nas bordas. Clique nele com o mouse e, em "Propriedades", no campo "Tipo de evento", selecione o valor "Com uma determinada intensidade" no campo "Intensidade", escreva o nome da variável que armazena o valor de intensidade "intensidade". O tempo de resposta é de segundos. Em seguida, adicione o código abaixo à ação:
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;
	}
}

Quando o evento "evaporação" é acionado, os níveis de feromônio na matriz matrixF serão atualizados. Como resultado, você deve conseguir fazer o que é mostrado na Figura 28.


Fig. 28 - Crie o evento "evaporação"

Determinar o vencedor


Nesta etapa, adicionaremos um código que determinará o vencedor da nossa maratona de formigas. O vencedor será aquele que formou a rota mais curta. Além de tudo, após o final da maratona, traçamos essa rota na tela. Para conseguir isso, criaremos três variáveis ​​"bestAnt", "bestDistance" e "numberFinish" no agente "Main". Na variável "bestAnt", armazenaremos o índice da formiga "mais rápida", o tipo da variável será "int" e o valor inicial será definido como "-1". Na variável "bestDistance", armazenaremos o valor atual da melhor extensão de rota entre cidades, o tipo da variável será "double" e o valor inicial será definido como infinito "infinito". Na variável "numberFinish", armazenaremos o número de formigas que terminaram em nossa maratona,o tipo da variável será "int" e o valor inicial é "0" (Fig. 29).


FIG. 29 - Criar um evento de variáveis ​​A

seguir, criamos uma função que, após finalizar todas as formigas, traçará as linhas da melhor rota entre as cidades. Por que a partir da "Paleta" arrastamos para o agente "Principal" um elemento com a função de nome. Defina o nome da função como drawPath e, na guia Propriedades, no campo Corpo da função, adicione o seguinte 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, você deve conseguir fazer o que é mostrado na Figura 29a.


FIG. 29a - Crie a função “drawPath”

Agora voltamos às nossas formigas e adicionamos um código que determinará a formiga do vencedor, o comprimento da melhor rota e traçamos essa rota entre as cidades. Por que, na guia "Projetos", selecione o agente "MyAnt", selecione o bloco "Todos ignorados" e adicione o seguinte código ao campo "Ação de logon":
//    
main.numberFinish++;
//      
if (main.bestDistance>distance) {
	//           
	//      
	main.bestDistance=distance;
	//    
	main.bestAnt = this.getIndex();
}
//         Main   
if (main.numberFinish==main.myAnts.size()) main.drawPath();

Ele deve sair como mostrado na Figura 30.


Fig. 30 - Adicionando lógica ao bloco “All Bypassed”.

Depois, você pode pressionar “F5” e executar o modelo. As formigas correm em busca de rotas e, quando as cidades terminam, a linha azul se conecta, qual é a melhor rota.

Adicionar um histograma ao modelo


Para que o modelo se torne mais científico, você deve adicionar um gráfico. Portanto, adicionaremos não apenas um gráfico e um histograma que nos mostrem a distribuição do comprimento das rotas que as formigas superaram. Por que, na guia "Projetos", selecione o agente "Principal" e vá para o seu espaço. Além disso, na "Paleta", vamos para a guia "Estatísticas" e, de lá, para o agente "Principal", transferimos o elemento "Dados do histograma" e diretamente o próprio "Histograma". Em seguida, selecionamos os histogramas com o mouse e, na guia "Propriedades", no campo "Dados", especificamos o nome dos nossos "Dados do histograma", ou seja, "Dados".

Ele deve aparecer como mostrado na Figura 31


. 31 - Construindo um cronograma

Depois disso, teremos que retornar novamente à nossa formiga e fazê-la preencher o "Histograma" com os valores do comprimento da rota. Por que, na guia Projetos, selecione o agente "MyAnt" e vá para o seu espaço. Em seguida, selecione o bloco "All Bypass" e adicione uma linha a ele "main.data.add (distance);". Ele deve sair como mostrado na Figura 32.


Fig. 32 - Construindo um gráfico

Em seguida, pressione "F5" e prossiga para estudar o comportamento do algoritmo ant. Deverá resultar em algo, como mostrado na Figura 33.


Fig. 33 - Modelagem

Conclusão


E, no final, recomendo adicionar mais imprevisibilidade ao modelo. Para isso, na guia "Projetos", selecione o elemento "Simulação: principal" com o mouse e defina o parâmetro "Aleatoriedade" como "Número inicial aleatório (execuções únicas)" na guia de propriedades - isso fará com que cada modelo seja único (Fig. 34).


FIG. 34 - Fazendo execuções aleatórias

Obrigado pela atenção! O código-fonte pode ser baixado no GitHub

All Articles