def aco(max_it, alpha, beta, rho, N, e, q, tal, b, localizacoes):
#inicializando elementos.
mapa = Mapa(e, tal, localizacoes, alpha, beta, rho, q)
formigas = np.full(e, Formiga())
iteracao = 0
while iteracao < max_it:
##localizando a melhor rota.
# Para cada numero de formigas é construido uma rota aplicando o seguinte passo.
for formiga in formigas:
for i in enumerate(range(e - 1)):
proximaCidade = mapa.calculaProbabilidades(
formiga.cidadesNVisitadas, formiga.cidadeAtual)
formiga.adicionaRota(proximaCidade, mapa)
# Avalia o tamanho da rota construída por cada formiga, se uma rota mais curta for encontrada a
# melhor rota será atualizada.
for formiga in formigas:
if formiga.tamanhoRota < lmenor:
lmenor = formiga.tamanhoRota
melhor = formiga.rota
#Atualiza os feromonios nas rotas que as formigas passaram.
for formiga in formigas:
mapa.atualizaFeromonios(formiga.rota)
iteracao += iteracao
return melhor, lmenor
def __init__(self):
self.memoria = Mapa()
self.posicaoAtual = [0,0]
self.posicaoSupostaOuro = []
self.supostaPosicaoPocos = []
self.sensacoes = []
def main():
wumppus = Wumppus()
mapa = Mapa()
#cria o wumppus
mapa.criarWumppus(wumppus)
#cria os pocos
mapa.criarPocos(wumppus)
#seta o ouro
mapa.inserirOuro()
mapa.printMapa()
#debug
for i in range(0, len(mapa.listaDePocos)):
print mapa.listaDePocos[i]
#cria Guerreiro
guerreiro = Guerreiro()
while True:
listaSensacao = mapa.pegarSensacao(guerreiro)
guerreiro.agir(listaSensacao)
input()
def carregaMapas(self):
self.listaMapas = []
#para cada um dos mapas informados cria-se um novo objeto e adciona a uma lista
#print("Carregando Mapas")
for i in range(self.dados.DIRETORIO_MAPAS.__len__()):
newMapa = Mapa(i, self.dados.DIRETORIO_MAPAS[i],
self.dados.DIRETORIO_MAPAS_FOGO[i],
self.dados.DIRETORIO_MAPAS_VENTO[i],
self.filtraTeleportes(i), self.dados)
self.listaMapas.append(newMapa)
if self.dados.FLAG_ATIVACAO_FOGO:
self.listaFogo.append([])
self.objetivo = objetivo
self.fronteira = Pilha(20)
self.fronteira.empilhar(inicio)
self.achou = False
def buscar(self):
topo = self.fronteira.getTopo()
print('Topo: {}'.format(topo.nome))
if topo == self.objetivo:
self.achou = True
else:
'''For para percorrer todos os vertices do topo'''
for a in topo.adjacentes:
if self.achou == False:
print('Verificando se já visitado: {}'.format(
a.cidade.nome))
if a.cidade.visitado == False:
a.cidade.visitado = True
self.fronteira.empilhar(a.cidade)
Profundidade.buscar(self)
print('Desempilhou: {}'.format(self.fronteira.desempilhar().nome))
from Mapa import Mapa
mapa = Mapa()
profundidade = Profundidade(mapa.portoUniao, mapa.curitiba)
profundidade.buscar()
from Mapa import Mapa
from VetorOrdenado import VetorOrdenado
class Gulosa:
def __init__(self, objetivo):
self.objetivo = objetivo
self.achou = False
def buscar(self, atual):
print('\nAtual->{}'.format(atual.nome))
atual.visitado = True
if (atual == self.objetivo):
self.achou = True
else:
self.fronteira = VetorOrdenado(len(atual.adjacentes))
for a in atual.adjacentes:
if a.cidade.visitado == False:
a.cidade.visitado = True
self.fronteira.inserir(a.cidade)
self.fronteira.mostrar()
if (self.fronteira.getPrimeiro() != None):
Gulosa.buscar(self, self.fronteira.getPrimeiro())
map = Mapa()
gulosa = Gulosa(map.curitiba)
gulosa.buscar(map.portoUniao)
def __init__(self):
self.mapa = Mapa()
self.l = []
def __init__(self, size, req_points):
self.counter = 0
self.mapa = Mapa(size) # ustawienie wielkości mapy
self.req_points = req_points
self.city_population = {}
map_y_sqms_count = 11
screen_dimension_game = {
'x': 32 * map_x_sqms_count,
'y': 32 * map_y_sqms_count
}
pygame.init()
font_name = pygame.font.get_default_font()
name_font = pygame.font.SysFont(font_name, 16)
screen = pygame.display.set_mode(
(screen_dimension_game['x'], screen_dimension_game['y']), 0, 32)
clock = pygame.time.Clock()
mapa = Mapa(map_x_sqms_count, map_y_sqms_count)
player = Player(randrange(0, map_x_sqms_count), randrange(0, map_y_sqms_count),
'Arrois')
walk_player = WalkPlayer(player, 1)
player_walking = False
def player_walk_for(direction: WalkDirection, speed):
global walk_player
try:
walk_player.speed = speed
walk_player.set_direction_to_walk(direction)
walk_player.start()
except RuntimeError:
walk_player = WalkPlayer(player, speed)
def executar(self):
resultados = pd.DataFrame({
'melhores': [],
'piores': []
}) # Cria o DF para armazenar os resultados
mapa = Mapa(
self.__mapa) # Instancia e lê as coordenadas do mapa escolhido
cidades = mapa.ler_coordenadas()
pop = Populacao(self.__num_cel, self.__validade, cidades,
0) # Instancia uma nova população
populacao = pop.gerar_populacao() # Gera o DF da população
populacao.sort_values(
by='fitness',
inplace=True) # Ordena a população de acordo com o fitness
populacao.index = range(
populacao.shape[0]) # Ajusta o índice da população
mem = Memoria(populacao[:self.__tamanho_mem].copy()
) # Armazena na memória uma parcela da população
mem.ordenar_memoria() # Ordena a memória
for geracao in range(self.__num_ger): # Para cada geração:
# Clona a população de acordo com a quantidade estipulada de clones
populacao = clonar(populacao, self.__num_clones, geracao,
self.__validade, cidades)
populacao = pd.DataFrame(populacao)
# Ordena os valores da população de acordo com o 'fitness'
populacao.sort_values(by='fitness', inplace=True)
populacao.index = range(populacao.shape[0])
# Cria um data set temporário para a memória
memoria = pd.DataFrame(mem.get_memoria())
# Verifica uma a uma as células presentes na memória
for index, celula in populacao.iterrows():
# Armazena o pior valor de fitness
pior_fit = memoria.fitness.max()
# Verifica quais células já estão presentes na memória de acordo com o fitness
talvez_exista = memoria.fitness == celula.fitness
existe = False
for possibilidade in talvez_exista:
if possibilidade:
existe = True
# Armazena somente as células que não estão presentes na memória e possuem um 'fitness' melhor do que o
# pior já armazenado
if (celula.fitness < pior_fit) and (not existe):
memoria.drop([memoria.shape[0] - 1],
inplace=True) # Remove a última célula
memoria = memoria.append(
celula, ignore_index=True) # Adiciona a célula nova
memoria.sort_values(
by='fitness', inplace=True
) # Ordena a população de acordo com o fitness
memoria.index = range(
memoria.shape[0]) # Ajusta o índice da população
# Armazena o melhor fitness da memória e o pior fitness da população
resultados = resultados.append(
{
'melhores': memoria.fitness.min().copy(),
'piores': populacao.fitness.max().copy()
},
ignore_index=True)
# Diminui a validade das células
memoria.validade -= 1
# Verifica uma a uma as células presentes na memória
for index, row in memoria.iterrows():
if row.validade < 0: # Modifica o fitness se a validade for menor que zero
memoria.loc[index, 'fitness'] += row.fitness * 0.5
populacao = memoria.copy()
populacao = clonar(populacao,
int(self.__num_cel / self.__tamanho_mem - 1),
geracao, self.__validade, cidades)
populacao.sort_values(by='fitness', inplace=True)
populacao.index = range(populacao.shape[0])
mem.set_memoria(memoria.copy())
mem.ordenar_memoria()
print(
f'\n### {geracao} - {self.__execucao} ###\n{populacao.loc[0, "fitness"]}'
)
return resultados
