def main():
def utility(pop):
'''
X**2 = 2
:param pop:
:return:
'''
util = -abs((pop**2 - 2))
return util
def dist(v1, v2):
return np.linalg.norm(v1 - v2, 2)
firefly = Firefly(population_size=10,
n_dims=1,
n_iterations=50,
utility=utility,
distance=dist)
firefly.fit(verbose=True)
pop = firefly.population
util = firefly.utilities_
ordering = np.argsort(util)
pop = pop[ordering][::-1]
util = util[ordering][::-1]
print(pop.tolist())
print(util.tolist())
def init_population(self, size):
"""Basic initialisation function for a random population of agents."""
population = list()
if self.heuristic_init:
heuristic_tour = self.get_heuristic_tour()
for _ in range(0, size):
population.append(Firefly(heuristic_tour))
else:
for _ in range(0, size):
population.append(Firefly())
self.population = population
def get_default_account(update, context):
token = update.message.text
firefly = Firefly(hostname=context.user_data.get("firefly_url"),
auth_token=token)
accounts = firefly.get_accounts(account_type="asset").get("data")
accounts_keyboard = []
for account in accounts:
account_name = account.get("attributes").get("name")
accounts_keyboard.append([
InlineKeyboardButton(account_name, callback_data=account.get("id"))
])
reply_markup = InlineKeyboardMarkup(accounts_keyboard)
context.user_data['firefly_token'] = update.message.text
update.message.reply_text('Please choose:', reply_markup=reply_markup)
return DEFAULT_WITHDRAW_ACCOUNT
def mutation_normal():
new_agents = []
for _ in range(0, self.m):
# generate random starting index and random length step
step = rng.choice(range(2, len(current_agent.tour)))
index = rng.choice(range(0, len(current_agent.tour)))
new_agents.append(
Firefly(current_agent.inverse_mutation(index, step)))
# add to population and remove overall worst m agents
self.population.extend(new_agents)
self.population = sorted(self.population, key=lambda agent: agent.weight)[
: self.size
]
def init_swarm(self):
"""Initialize random swarm population of fireflies. """
swarm_population = []
for i in range(self.n_fireflies):
firefly = Firefly(dim=self.dim,
bounds=self.bounds,
alpha=self.alpha,
gamma=self.gamma,
beta_min=self.beta_min,
distance=self.distance,
beta_0=self.beta_0,
f_function=self.f_function)
swarm_population.append(firefly)
return swarm_population
def main():
complete = 0
for counter in range(100):
lines = [
line.rstrip('\n')
for line in open("puzzles/" + difficulty +
str(counter + 1).zfill(3) + ".txt")
]
size = int(lines[0].split()[0])
islands = []
variables = []
intersections = []
firefly = [None] * population
createIslands(lines, islands)
generateVariables(size, islands, variables)
findIntersections(islands, variables, intersections)
for i in range(population):
firefly[i] = Firefly(i, copy.deepcopy(variables), random.random())
firefly[i].randomizeSolution()
firefly[i].determineBrightness(islands, intersections)
firefly = sorted(firefly, key=lambda x: x.brightness)
for j in range(iterations):
for i in range(1, len(firefly)):
firefly[i].performLocalWalk(firefly[0].variables,
exploitChance)
firefly[i].performRandomWalk(exploreChance)
firefly[i].determineBrightness(islands, intersections)
firefly = sorted(firefly, key=lambda x: x.brightness)
if firefly[0].brightness == 0:
complete += 1
break
print("Number of accomplished puzzles: " + str(complete))
algorithmPrams['ub'] = [
50,
50,
50,
50,
50,
50,
50,
50,
50,
] + [360.0] * p
algorithmPrams['lb'] = [-50, -50, -50, -50, 0, 0, 0, 0, 0] + [0.0] * p
algorithmPrams['maxGen'] = 1500
algorithmPrams['report'] = 100
t0 = timeit.default_timer()
f = Firefly(mechanismObj, **algorithmPrams)
time_and_fitness, fitnessParameter = f.run()
t1 = timeit.default_timer()
print('total cost time: %d' % (t1 - t0, ))
a = [
k for k in map(lambda x: [float(i) for i in x.split(',')[1::]],
[e for e in time_and_fitness.split(';')[0:-1]])
]
b = [float(e) for e in fitnessParameter.split(',')]
print(a)
print(b)
algorithmPrams = dict()
algorithmPrams['strategy'] = 1
algorithmPrams['D'] = 19
algorithmPrams['NP'] = 190
def add_flies(flies, num_flies):
for _ in range(num_flies):
flies.add(Firefly())
# Import standard modules.
import argparse
import configparser
import sys
# Import non-standard modules.
import pygame as pg
from pygame.locals import *
# Import local modules
from firefly import Firefly
# Read and apply config settings
config_file = configparser.ConfigParser()
config_file.read('config.ini')
Firefly.config(config_file['firefly'])
CONFIG = {
'title': config_file.get('main', 'title'),
'logo': config_file.get('main', 'logo'),
'count': config_file.getint('main', 'count'),
'geometry': config_file.get('main', 'geometry')
}
def update(dt, flies):
"""
Update game. Called once per frame.
dt is the amount of time passed since last frame.
If you want to have constant apparent movement no matter your framerate,
what you can do is something like
def get_firefly(context):
return Firefly(hostname=context.user_data.get("firefly_url"),
auth_token=context.user_data.get("firefly_token"))
from firefly import Firefly
from helpers import setup_sentry
setup_sentry()
app = Firefly()
@app.function
def fib(n):
if n==0 or n==1: return n
if n>10: raise ValueError('n greater than 10 not allowed')
return fib(n-1) + fib(n-2)
if __name__ == "__main__":
app.run()
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import csv
from datetime import datetime
import shutil
import os
import functions
from firefly import Firefly
import settings
if __name__ == "__main__":
firefly = Firefly(n=settings.N,
nff=settings.Nff,
alpha=settings.Alpha,
gamma=settings.Gamma,
t=settings.T)
firefly.response_model(k=settings.k * np.pi,
angle_increment=settings.Nphi,
peakWidth=np.deg2rad(settings.Pwdes),
sidelobeHeight=settings.Slhdes)
time = datetime.__str__(datetime.today())
# time = time[:-10]
time = time[0:10] + "_" + time[11:13] + "." + time[14:16]
filepath = "data/" + time + "/"
if not os.path.exists(filepath):
os.makedirs(filepath)
shutil.copyfile("./settings.py", filepath + "settings.txt")
def __init__(self, n, scheduler):
self.fireflies = []
self.scheduler = scheduler
for i in range(n):
for j in range(n):
self.fireflies.append(Firefly(i, j, self.scheduler))
def create_firefly():
for index in range(DIM_SIZE):
Location_Array[index] = random.uniform(LB, UB)
return Firefly(Location_Array)
def main():
generate_fireflies()
orginal = Fitnesses.copy()
print('Searching ...')
for _ in range(MAX_GEN):
for i in range(POP_SIZE):
moved = True
for j in range(POP_SIZE):
distance = Firefly_List[i].calc_distance(Firefly_List[j])
if Firefly_List[i].fitness > Firefly_List[j].fitness:
new_firefly = Firefly(Firefly_List[i].location)
new_firefly.update_location(Firefly_List[j], distance)
while drone_is_inside(new_firefly):
new_firefly = Firefly(Firefly_List[i].location)
new_firefly.update_location(Firefly_List[j], distance)
new_firefly.fitness = new_firefly.update_fitness()
moved = True
if new_firefly.fitness < Firefly_List[
i].fitness and not drone_is_inside(new_firefly):
Firefly_List[i] = new_firefly
Fitnesses[i] = new_firefly.fitness
if not moved:
new_firefly = Firefly(Firefly_List[i].location)
new_firefly.move_randomly()
while drone_is_inside(new_firefly):
new_firefly = Firefly(Firefly_List[i].location)
new_firefly.move_randomly()
new_firefly.fitness = new_firefly.update_fitness()
if new_firefly.fitness < Firefly_List[
i].fitness and not drone_is_inside(new_firefly):
Firefly_List[i] = new_firefly
Fitnesses[i] = new_firefly.fitness
Firefly_List[i].check_bounds()
Firefly_List[i].fitness = Firefly_List[i].update_fitness()
# for index in range(POP_SIZE):
# print(">>> FF[{}]: {} >>> {}".format(index, Firefly_List[index].fitness, orginal[index]))
rank_fireflies()
plot()
