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")