def first_objective(self, package_amount):
simulator = Simulator()
start = time.time()
min_mean = 100000000000
best_config = []
simulation_amount = 0
for i in range(1, 31):
for j in range(1, 32):
for w in range(1, 73):
for o in range(1, 14):
config = [i, j, w, o]
if simulator.get_config_cost(config) <= 1000:
simulation_amount += 1
sr = simulator.simulate(config, package_amount, i + j + w + o)
mean = (sr[0] + sr[1] + sr[2] + sr[3]) / (4.0 * package_amount)
if mean < min_mean:
min_mean = mean
best_config = config
end = time.time()
print("Duro: " + str(end - start))
print("Media minima: " + str(min_mean))
print("Mejor configuracion: " + str(best_config))
print("Costo de la configuracion: " + str(simulator.get_config_cost(best_config)))
print("Cantidad de simulaciones: " + str(simulation_amount))
def main(self):
server_costs = [29.4, 28.3, 12.1, 69.6]
phase = 4
inc = 1
s = Simulator()
config = [107, 860, 235, 121]
initial_mean = 69331.61131299718
sr = s.simulate(config, 1000, 1)
mean = (sr[0] + sr[1] + sr[2] + sr[3]) / (1000.0 * 4)
diff = initial_mean - mean
grade = diff / (server_costs[phase - 1] * inc)
print(grade)
print(mean)
def post(self):
parser = reqparse.RequestParser()
parser.add_argument("number_of_requests", type=int, required=True)
parser.add_argument("region_id", type=str, required=True)
args = parser.parse_args()
regions = self.__fetch_region(args["region_id"])
if (len(regions) > 0):
result = Simulator(regions[0]).simulate(args["number_of_requests"])
self.__insert_booking_distance(args["region_id"],
result["booking_distance_bins"])
return result, 200
else:
return {"message": "Region not found"}, 404
import pandas as pd
import numpy as np
from sklearn.cluster import KMeans
from datetime import timedelta
import os
import zipfile
import io
import shutil
from services.simulator import Simulator
from constants import *
app = Flask(__name__)
CORS(app)
simulator = Simulator()
def get_stations():
stations = []
for station_snapshot in simulator.station_snapshots.values():
station_response = {}
station = station_snapshot.station
station_response['name'] = station.name
station_response['id'] = station.id
station_response['coordinates'] = station.coordinates
station_response['capacity'] = station.capacity
station_response['count'] = station_snapshot.current_bike_count
stations.append(station_response)
return stations
def __init__(self):
self.generation_package_amount = 0
self.current_generation = 1
self.simulator = Simulator()
self.max_servers = []
self.best_individuals = []
class Genetic(metaclass=ABCMeta):
def __init__(self):
self.generation_package_amount = 0
self.current_generation = 1
self.simulator = Simulator()
self.max_servers = []
self.best_individuals = []
def get_individual(self):
individual = []
for i in range(0, 4):
individual.append(random.randint(1, self.max_servers[i]))
return individual
def get_first_generation(self, size):
population = []
for i in range(0, size):
population.append(self.get_individual())
return population
@abstractmethod
def mutate(self, individual):
pass
@abstractmethod
def crossover(self, individual1, individual2):
pass
def get_next_generation(self, population, best_individual):
size = len(population)
new_population = []
for i in range(0, size):
cross = self.crossover(population[i], best_individual)
mutatation_probability = random.random()
if mutatation_probability < 0.05:
cross = self.mutate(cross)
new_population.append(cross)
self.current_generation += 1
return new_population
@abstractmethod
def get_fitness(self):
pass
def get_best_individual(self, population):
max_grade = -10000000
best_ind = []
for ind in population:
grade = self.get_fitness(ind)
if grade > max_grade:
max_grade = grade
best_ind = ind
return [best_ind, grade]
def start(self, generations):
generations_copy = generations
size = 80
population = self.get_first_generation(size)
while generations > 0:
print("Generacion #" + str((generations_copy-generations)+1))
best_individual = self.get_best_individual(population)
self.best_individuals.append(best_individual)
population = self.get_next_generation(population, best_individual[0])
generations -= 1
optimum = self.get_optimum_individual()
optimum_cost = self.simulator.get_config_cost(optimum[0])
optimum_diff = 999999999.0/(optimum[1]*optimum_cost)
print("Optimum: " + str(optimum[0]))
print("Cost: " + str(optimum_cost))
print("Diff: " + str(optimum_diff))
def get_optimum_individual(self):
best_grade = -10000
best_individual = []
best_individual_index = -1
for i in range(0, len(self.best_individuals)):
if self.best_individuals[i][1] > best_grade:
best_grade = self.best_individuals[i][1]
best_individual = self.best_individuals[i]
best_individual_index = i
print("Indice del mejor individuo: " + str(best_individual_index))
return best_individual
def on_open(ws):
print("### OPEN ###")
if simulation is True:
simulator = Simulator(ws)
simulator.start_simulation()
print("-----------------------------------------------")
print("now enter the angel of projectile:(rad)")
angel = float(input())
print("-----------------------------------------------")
print("it's time for air to play its role, enter radius of ball:(m)")
radius = float(input())
print("-----------------------------------------------")
print("ohh we forget about mass :), enter the mass of projectile:(kg)")
mass = float(input())
print("-----------------------------------------------")
print(
"at the end enter time duration:(s) *[the less time duration is the accurate your graphs will be]*"
)
delta_t = float(input())
simulator = Simulator(mass, initial_velocity, angel, radius, delta_t)
simulator.simulate()
Plotter.plot(simulator.y_components, simulator.x_components, r'$y\/(m)$',
r'$x\/(m)$', "[y-x]graph")
Plotter.plot(simulator.x_components, simulator.time, r'$x\/(m)$', r'$t\/(s)$',
"[x-t]graph")
Plotter.plot(simulator.y_components, simulator.time, r'$y\/(m)$', r'$t\/(s)$',
"[y-t]graph")
Plotter.plot(simulator.v_x_components, simulator.time, r'$\.x\/(m/s)$',
r'$t\/(s)$', "[xdot-t]graph")
Plotter.plot(simulator.v_y_components, simulator.time, r'$\.y\/(m/s)$',
r'$t\/(s)$', "[ydot-t]graph")
Plotter.plot(simulator.v_x_components, simulator.x_components, r'$\.x\/(m/s)$',
r'$x\/(m)$', "[xdot-x]graph")
Plotter.plot(simulator.v_y_components, simulator.y_components, r'$\.y\/(m/s)$',
r'$y\/(m)$', "[ydot-y]graph")
