def costWithNode(self,customer,index):
cost = 0.0
load = self._totalDemand + customer.get_demand()
duration = self._totalDuration + customer.get_duration()
length = len(self._tour)
if length == 0: #lista vazia:
cost = 2 * dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),customer.get_x_coord(),customer.get_y_coord())
load = customer.get_demand()
duration = customer.get_duration()
#verificar se ele ligará ao depósito
elif index == 0:
cost = self._cost - dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),self._tour[0].get_x_coord(),self._tour[0].get_y_coord()) + \
dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),customer.get_x_coord(),customer.get_y_coord()) + \
dist.euclidianDistance(customer.get_x_coord(),customer.get_y_coord(),self._tour[0].get_x_coord(),self._tour[0].get_y_coord())
elif index == length:
cost = self._cost - dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),self._tour[length-1].get_x_coord(),self._tour[length-1].get_y_coord()) + \
dist.euclidianDistance(self._tour[length-1].get_x_coord(),self._tour[length-1].get_y_coord(),customer.get_x_coord(),customer.get_y_coord()) + \
dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),customer.get_x_coord(),customer.get_y_coord())
#está entre dois clientes
else:
cost = self._cost - dist.euclidianDistance(self._tour[index-1].get_x_coord(),self._tour[index-1].get_y_coord(),self._tour[index].get_x_coord(),self._tour[index].get_y_coord()) + \
dist.euclidianDistance(self._tour[index-1].get_x_coord(),self._tour[index-1].get_y_coord(),customer.get_x_coord(),customer.get_y_coord()) + \
dist.euclidianDistance(customer.get_x_coord(),customer.get_y_coord(),self._tour[index].get_x_coord(),self._tour[index].get_y_coord())
#verificar se há penalizações
costTotal = cost
if load > self._depot.get_loadVehicle():
costTotal += 1000 * (load - self._depot.get_loadVehicle())
if duration > self._depot.get_durationRoute():
costTotal += 1000 * (duration - self._depot.get_durationRoute())
return [costTotal,cost,load,duration]
def main():
np.random.seed(7890)
# recebendo instâncias
r = ReadingDatas("dat/p01")
r.readFile()
# adicionando clientes
Customers.addCustomers(r)
# for cst in Customers.get_customersList().values():
# print(cst)
# adicionando depósitos
Depots.addDepots(r)
# print("\n\n\n\")
# for dpt in Depots.get_depotsList().values():
# print(dpt)
# cálculo das distâncias
Distances.euclidianDistanceAll(Customers.get_customersList(),
Depots.get_depotsList())
# for cst in Customers.get_customersList():
# print(cst)
# print(Customers.get_customersList()[cst].get_depotsDistances())
# print("\n\n\n")
# for cst in Customers.get_customersList():
# print(cst)
# print(Customers.get_customersList()[cst].get_neighborsDistances())
ga = GA()
ga.GA()
def calculeCost(self):
cost = 0.0
demand = 0.0
duration = 0.0
length = len(self._tour)
#custo do depósito ao primeiro cliente
customer = self._tour[0]
cost += dist.euclidianDistance(customer.get_x_coord(),customer.get_y_coord(),self._depot.get_x_coord(),self._depot.get_y_coord())
demand += customer.get_demand()
duration += customer.get_duration()
#custo do último cliente ao depósito
customer = self._tour[length-1]
cost += dist.euclidianDistance(customer.get_x_coord(),customer.get_y_coord(),self._depot.get_x_coord(),self._depot.get_y_coord())
demand += customer.get_demand()
duration += customer.get_duration()
#custo dos clientes intermediários
for i in range(length):
if i+1 < length:
customer = self._tour[i]
nextCustomer = self._tour[i+1]
cost += dist.euclidianDistance(customer.get_x_coord(),customer.get_y_coord(),nextCustomer.get_x_coord(),nextCustomer.get_y_coord())
if i>0 and i<length-1:
demand += customer.get_demand()
duration += customer.get_duration()
self._totalDemand = demand
self._totalDuration = duration
self._cost = cost
self.updatePenalty()
def splitRoute(self, path, depot):
n = len(path)
# print("path")
# print(path)
# print(depot)
vehicleCapacity = depot.get_loadVehicle() # máximo carregamento
durationRoute = depot.get_durationRoute() # máxima duração
v = [] # custo do menor caminho do depósito até o ponto.
predecessor = [] # predecessores de cada idCsts neste caminho
predecessor.append(-1) # depósito não tem precedente
v.append(0.0)
# print("n = {}".format(len(path)))
for i in range(n):
v.append(SplitAlgorithms._infinite)
# pior hipótese - número de rotas = número clientes
predecessor.append(0)
for i in range(1, n + 1):
load = 0.0
cost = 0.0
j = i
while (j <= n) and (load < vehicleCapacity) and (
cost < 2 * durationRoute):
customer = path[j - 1]
load += customer.get_demand()
if i == j:
# custo de ida e volta
cost = 2 * dist.euclidianDistance(
customer.get_x_coord(), customer.get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord()) + customer.get_service()
else:
previewCustomer = path[j - 2]
cost = cost - dist.euclidianDistance(
previewCustomer.get_x_coord(),
previewCustomer.get_y_coord(), depot.get_x_coord(),
depot.get_y_coord()) + dist.euclidianDistance(
previewCustomer.get_x_coord(),
previewCustomer.get_y_coord(),
customer.get_x_coord(), customer.get_y_coord()
) + customer.get_service() + dist.euclidianDistance(
customer.get_x_coord(), customer.get_y_coord(),
depot.get_x_coord(), depot.get_y_coord())
if (load <= vehicleCapacity) and (cost <= 2 * durationRoute):
if (v[i - 1] + cost) < v[j]:
v[j] = v[i - 1] + cost
predecessor[j] = i - 1
j += 1
# print("cost: {} load: {}".format(cost, load))
# print("pred: {}".format(predecessor))
# print("v: {}".format(v))
# print("\n")
# print(predecessor)
return predecessor
def test_shouldHaveFrontDistanceSensorWhenEnabledInSettings(self):
# given
self.settings.hasFrontDistanceSensor.return_value = True
# when
self.distances = Distances(self.settings)
# then
self.assertIsNotNone(self.distances.distance_sensor_front)
self.settings.getFrontDistanceSensorAddress.assert_called_once()
def test_shouldNotHaveFrontDistanceSensorWhenDisabledInSettings(self):
# given
self.settings.hasFrontDistanceSensor.return_value = False
# when
self.distances = Distances(self.settings)
# then
self.assertIsNone(self.distances.distance_sensor_front)
self.settings.getFrontDistanceSensorAddress.assert_not_called()
def costWithoutNode(self, indexCst):
cost = 0.0
load = self._totalDemand - self._tour[indexCst].get_demand()
service = self._totalService - self._tour[indexCst].get_service()
length = len(self._tour)
if length == 1: #só tem esse cliente
return [0, 0, 0, 0]
#verificar se ele liga ao depósito
elif indexCst == 0:
cost = self._cost - dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),self._tour[indexCst].get_x_coord(),self._tour[indexCst].get_y_coord()) + \
dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),self._tour[1].get_x_coord(),self._tour[1].get_y_coord()) - \
dist.euclidianDistance(self._tour[indexCst].get_x_coord(),self._tour[indexCst].get_y_coord(),self._tour[1].get_x_coord(),self._tour[1].get_y_coord())
elif indexCst == length - 1:
cost = self._cost - dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),self._tour[indexCst].get_x_coord(),self._tour[indexCst].get_y_coord()) + \
dist.euclidianDistance(self._depot.get_x_coord(),self._depot.get_y_coord(),self._tour[length-2].get_x_coord(),self._tour[length-2].get_y_coord()) - \
dist.euclidianDistance(self._tour[indexCst].get_x_coord(),self._tour[indexCst].get_y_coord(),self._tour[length-2].get_x_coord(),self._tour[length-2].get_y_coord())
#está entre dois clientes
else:
cost = self._cost - dist.euclidianDistance(self._tour[indexCst-1].get_x_coord(),self._tour[indexCst-1].get_y_coord(),self._tour[indexCst].get_x_coord(),self._tour[indexCst].get_y_coord()) - \
dist.euclidianDistance(self._tour[indexCst].get_x_coord(),self._tour[indexCst].get_y_coord(),self._tour[indexCst+1].get_x_coord(),self._tour[indexCst+1].get_y_coord()) + \
dist.euclidianDistance(self._tour[indexCst-1].get_x_coord(),self._tour[indexCst-1].get_y_coord(),self._tour[indexCst+1].get_x_coord(),self._tour[indexCst+1].get_y_coord())
#verificar se há penalizações
costTotal = cost
if load > self._depot.get_loadVehicle():
costTotal += 1000 * (load - self._depot.get_loadVehicle())
if cost + service > self._depot.get_durationRoute():
costTotal += 1000 * abs(service - self._depot.get_durationRoute())
return [costTotal, cost, load, service]
def test_shouldReadDistanceSensorSettingsFromSettings(self):
# given
# when
self.distances = Distances(self.settings)
# then
self.settings.getRightDistanceSensorAddress.assert_called_once()
self.settings.getLeftDistanceSensorAddress.assert_called_once()
self.assertIsNotNone(self.distances.distance_sensor_right)
self.assertIsNotNone(self.distances.distance_sensor_left)
def propagatek(i, j, k, listCst, sumDistance, potential, depot):
distDeptNextI = dist.euclidianDistance(
listCst[i].get_x_coord(), listCst[i].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord()) # distancia de i+1 até o depósito
distDeptJ = dist.euclidianDistance(
listCst[j - 1].get_x_coord(), listCst[j - 1].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord()) # distancia de j até o depósito
return potential[k][i] + sumDistance[j] - sumDistance[
i + 1] + distDeptNextI + distDeptJ
def dominates(i, j, listCst, sumDistance, potential, sumLoad, depot):
distDeptNextJ = dist.euclidianDistance(listCst[j].get_x_coord(),
listCst[j].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord())
distDeptNextI = dist.euclidianDistance(listCst[i].get_x_coord(),
listCst[i].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord())
return sumLoad[i] == sumLoad[j] and (potential[j] + distDeptNextJ) > (
potential[i] + distDeptNextI + sumDistance[j + 1] -
sumDistance[i + 1] - 0.0001)
def dominatesRightk(i, j, k, listCst, sumDistance, potential, depot):
distDeptNextJ = dist.euclidianDistance(listCst[j].get_x_coord(),
listCst[j].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord())
distDeptNextI = dist.euclidianDistance(listCst[i].get_x_coord(),
listCst[i].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord())
return (potential[k][j] + distDeptNextJ) < (
potential[k][i] + distDeptNextI + sumDistance[j + 1] -
sumDistance[i + 1] + 0.0001)
def distances(self):
distances = Distances(self)
frontier = [self]
while len(frontier) > 0:
new_frontier = []
for cell in frontier:
for link in cell.get_links():
if not link in distances.cells:
distances.cells[link] = distances.cells[cell] + 1
new_frontier.append(link)
frontier = new_frontier
return distances
def distances(self):
distances = Distances(self)
frontier = [self]
while len(frontier) is not 0:
new_frontier = []
for cell in frontier:
for linked in cell.links():
if linked in distances.keys():
continue
distances[linked] = distances[cell] + 1
new_frontier.append(linked)
frontier = new_frontier
return distances
def splitRoute(path, depot):
n = len(path)
vehicleCapacity = depot.get_loadVehicle()
durationRoute = depot.get_durationRoute()
v = [] # custo do menor caminho do depósito até o ponto.
predecessor = [] # predecessores de cada idCsts neste caminho
predecessor.append(-1) # depósito não tem precedente
v.append(0.0)
for i in range(n):
v.append(SplitAlgorithms._infinite)
predecessor.append("")
for i in range(1, n + 1):
load = 0.0
cost = 0.0
j = i
duration = 0
while (j <= n) and (load <= vehicleCapacity) and (duration <=
durationRoute):
customer = path[j - 1]
load += customer.get_demand()
if i == j:
# custo de ida e volta
duration += customer.get_duration()
cost = 2 * dist.euclidianDistance(
customer.get_x_coord(), customer.get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord()) + customer.get_duration()
else:
duration += customer.get_duration()
previewCustomer = path[j - 2]
cost = cost - dist.euclidianDistance(
previewCustomer.get_x_coord(),
previewCustomer.get_y_coord(), depot.get_x_coord(),
depot.get_y_coord()) + dist.euclidianDistance(
previewCustomer.get_x_coord(),
previewCustomer.get_y_coord(),
customer.get_x_coord(), customer.get_y_coord()
) + customer.get_duration() + dist.euclidianDistance(
customer.get_x_coord(), customer.get_y_coord(),
depot.get_x_coord(), depot.get_y_coord())
if (load <= vehicleCapacity) and (duration <= durationRoute):
if (v[i - 1] + cost) < v[j]:
v[j] = v[i - 1] + cost
predecessor[j] = i - 1
j += 1
return predecessor
def test_shouldReturnCorrectDistanceValuesWhenFrontSensorDisabled(self):
# given
self.settings.hasFrontDistanceSensor.return_value = False
self.distances = Distances(self.settings)
self.distances.distance_sensor_right = MagicMock()
self.distances.distance_sensor_left = MagicMock()
self.distances.distance_sensor_right.value.return_value = 111
self.distances.distance_sensor_left.value.return_value = 222
# when
actual_distances = self.distances.getDistances()
# then
self.assertEqual(11, actual_distances.get('right'))
self.assertEqual(22, actual_distances.get('left'))
self.assertFalse('front' in actual_distances)
def test_shouldReturnCorrectDistanceValues(self):
# given
self.distances = Distances(self.settings)
self.distances.distance_sensor_right = MagicMock()
self.distances.distance_sensor_left = MagicMock()
self.distances.distance_sensor_front = MagicMock()
self.distances.distance_sensor_right.value.return_value = 111
self.distances.distance_sensor_left.value.return_value = 222
self.distances.distance_sensor_front.value.return_value = 333
# when
actual_distances = self.distances.getDistances()
# then
self.assertEqual(11, actual_distances.get('right'))
self.assertEqual(22, actual_distances.get('left'))
self.assertEqual(33, actual_distances.get('front'))
def main(SEED, POP, DESC, PROB_MUT, PROB_LS_POP, PROB_LS, PROB_LSB, PROB_LSBP,
GEN_ILS, GEN_ILSA, DATFILE, INSTANCE):
# redefinindo variáveis conforme Package Irace
# config.FRAC_MAX_DISTRIBUTION = FRAC
config.SIZE_POP = POP
config.SIZE_DESC = DESC
config.PROB_MUTATION = PROB_MUT
config.PROB_LS_POP = PROB_LS_POP
config.PROB_LS = PROB_LS
config.PROB_LS_BEST = PROB_LSB
config.PROB_LS_BEST_P = PROB_LSBP
config.GEN_ILS = GEN_ILS
config.GEN_ILSA = GEN_ILSA
seed = SEED
timeIni = time.time()
# exit(0)
# recebendo instâncias
r = ReadingDatas(INSTANCE)
r.readFile()
# adicionando clientes
Customers.addCustomers(r)
# adicionando depósitos
Depots.addDepots(r)
# cálculo das distâncias
Distances.euclidianDistanceAll(Customers.get_customersList(),
Depots.get_depotsList())
ga = GA()
best = ga.GA(seed)
cost = best.get_cost()
timeEnd = (time.time() - timeIni) / 60.0
logging.debug("Melhor indivíduo: %s" % best)
logging.debug("tempo total: " + str(timeEnd) + " minutos.")
logging.debug("------------fim algoritmo genético-----------")
with open(DATFILE, 'w') as f:
f.write(str(cost))
def run(from_file,
to_file,
from_colname,
to_colname,
db_name,
metric,
threshold):
client = Distances(db_name)
from_df = get_from_adresser(from_file)
to_df = get_to_addresser(to_file)
client.import_data_from_df(from_df, from_column=from_colname)
client.import_data_from_df(to_df, to_column=to_colname)
output_df = client.output_distances()
merged_data = merge_dfs(from_df, to_df, output_df)
min_distance = calculate_min_distance(merged_data)
over_threshold = min_distance[min_distance[metric] <= threshold]
under_threshold = min_distance[min_distance[metric] > threshold]
writer = pd.ExcelWriter(f'results_max_{metric}_{threshold}.xlsx')
over_threshold.to_excel(writer, sheet_name=f'Over {threshold}', index=False)
under_threshold.to_excel(writer, sheet_name=f'Under {threshold}', index=False)
writer.save()
def get_all_angular_distances(self, max_distance=None):
stars = self.stars
distances = Distances()
for i, star in enumerate(stars):
other_stars = stars[i + 1:]
for other_star in other_stars:
distances.add_distance(star, other_star, max_distance)
distances.sort()
return distances
def __init__(self, acceptable_delay):
self.buffer = dict()
self.distances = Distances()
# acceptable delay is in seconds
self.acceptable_delay = acceptable_delay
self.buffer_counter = 0
self.trips_out_counter = 0
self.extra_trips_combined = 0
self.unmodified_durations = 0
self.modified_durations = 0
self.requests_assigned = {}
def calculeCost(self):
cost = 0.0
demand = 0.0
service = 0.0
length = len(self._tour)
#custo do depósito ao primeiro cliente
customer = self._tour[0]
cost += dist.euclidianDistance(customer.get_x_coord(),
customer.get_y_coord(),
self._depot.get_x_coord(),
self._depot.get_y_coord())
#custo do último cliente ao depósito
customer = self._tour[length - 1]
cost += dist.euclidianDistance(customer.get_x_coord(),
customer.get_y_coord(),
self._depot.get_x_coord(),
self._depot.get_y_coord())
#custo dos clientes intermediários
for i in range(length):
customer = self._tour[i]
demand += customer.get_demand()
service += customer.get_service()
if i + 1 < length:
nextCustomer = self._tour[i + 1]
cost += dist.euclidianDistance(customer.get_x_coord(),
customer.get_y_coord(),
nextCustomer.get_x_coord(),
nextCustomer.get_y_coord())
self._totalDemand = demand
self._totalService = service
self._cost = cost
self.updatePenalty()
def distances(self):
distances = Distances(self)
frontier = [self]
while len(frontier) > 0:
new_frontier = []
for cell in frontier:
for linked in cell.links:
if linked not in distances:
distances[linked] = distances[cell] + 1
new_frontier.append(linked)
frontier = new_frontier
return distances
def distances(self):
weights = Distances(self)
pending = [ self ]
while pending:
cell = sorted(pending, key=lambda c: weights[c])[0]
pending.remove(cell)
for neighbor in cell.links:
total_weight = weights[cell] + neighbor.weight
if not weights[neighbor] or total_weight < weights[neighbor]:
pending.append(neighbor)
weights[neighbor] = total_weight
return weights
def distances(self):
distances = Distances(self)
frontier = [self]
while frontier:
new_frontier = []
for cell in frontier:
for linked in cell.links:
if distances[linked] != None:
continue
distances[linked] = distances[cell] + 1
new_frontier.append(linked)
frontier = new_frontier
return distances
def get_matrix_loss(self, q, d, m, distance="dot", loss="mse", symmetric=False):
query_part = self.call_query(q)
if not symmetric:
doc_part = self.call_doc(d)
else:
doc_part = (
query_part
if (d is None) or (d is q) else
self.call_query(d)
)
if isinstance(distance, str):
dist = Distances(distance)(query_part, doc_part)
elif hasattr(distance, "__call__"):
if symmetric:
assert query_part is doc_part # debug
dist = distance(query_part, doc_part)
else:
raise RuntimeError("suspicious distance")
if loss == "mse":
delta = (m - dist)
loss = tf.reduce_mean(delta ** 2)
elif loss == "distortion":
loss = metrics.distortion_loss(dist=dist, m=m)
elif loss == "softmax":
loss = metrics.softmax_proba_loss(dist, r=m)
elif loss == "softmax_1/dist":
loss = metrics.softmax_proba_inverted_dist_loss(dist, r=m)
elif loss == "1/dist":
loss = metrics.proba_inverted_dist_loss(dist, r=m)
elif loss is None:
return dist
elif hasattr(metrics, loss + "_loss"):
loss = getattr(metrics, loss + "_loss")(dist, m=m)
else:
raise NotImplementedError("Unknown loss")
return loss
def main():
parser = argparse.ArgumentParser(description='Cluster data using Nearest'
' Neighbor algorithm.')
parser.add_argument('--datafile',
dest='data_file',
type=str,
required=True,
help='absolute or relative path to data file')
parser.add_argument('--datainfofile',
dest='data_info_file',
type=str,
required=True,
help='absolute or relative path to data info file')
parser.add_argument('--threshold',
dest='threshold',
type=float,
required=True,
help='threshold to be used by the algorithm'
' (should be value between 0..1)')
parser.add_argument('--outputfile',
dest='output_file',
type=str,
help='absolute or relative path to file where'
' results should be written (if not'
' specified results are printed in stdout)')
args = parser.parse_args()
data, data_info = prepare_data(args.data_file, args.data_info_file)
distances = Distances(data, data_info).get_distances()
clusters = NearestNeighbor(data, distances, args.threshold).get_clusters()
printed_clusters = pretty_print_clusters(clusters)
if args.output_file:
with open(args.output_file, 'w') as f:
f.write(printed_clusters)
f.close()
else:
print printed_clusters
def M10(self, solution):
solution1 = copy.deepcopy(solution)
depots = dpts.get_depotsList()
#escolha da rota
routes = solution1.get_routes()
idRoute = np.random.randint(len(routes))
route = copy.deepcopy(routes[idRoute])
length = len(route.get_tour()) # comprimento da rota
oldDepot = route.get_depot()
costWithoutRoute = solution1.get_cost() - route.get_totalCost()
penalty = route.get_totalCost() - route.get_costWithoutPenalty()
extraPenalty = 0
# print(penalty)
cont = 0
bestRoute = copy.deepcopy(route)
# print("tamanho de rotas")
# print(len(routes))
# print("route")
# print(route)
if length > 0:
route1 = copy.deepcopy(route)
#rotação da rota
for i in range(length):
#rotacionar
# print(route1)
aux = route1.get_tour()[0]
# print(aux)
cost = route1.costWithoutNode(0)
route1.removeCustomer(aux)
route1.set_cost(cost[1], cost[2], cost[3])
cost = route1.costWithNode(aux, length - 1)
route1.addCustomer(aux)
route1.set_cost(cost[1], cost[2], cost[3])
# print(route1)
# print("-----")
# verificar se rota gerada é melhor (considerando mesmo depósito)
if bestRoute.get_totalCost() > route1.get_totalCost():
extraPenalty = 0
bestRoute = copy.deepcopy(route1)
cont = 1
# verificar transferência da rota em outro depósito
for dpt in depots.values():
if str(dpt) != str(oldDepot):
# verificar rota para o novo depósito
tour = route1.get_tour()
# tirar o custo associado ao depósito
cost1 = route1.get_totalCost() - dist.euclidianDistance(tour[0].get_x_coord(),
tour[0].get_y_coord(), oldDepot.get_x_coord(), oldDepot.get_y_coord()) - \
dist.euclidianDistance(tour[length-1].get_x_coord(),
tour[length-1].get_y_coord(), oldDepot.get_x_coord(), oldDepot.get_y_coord())
# computar custo com o novo depósito
newCost = cost1 + dist.euclidianDistance(tour[0].get_x_coord(),
tour[0].get_y_coord(), dpt.get_x_coord(), dpt.get_y_coord()) + \
dist.euclidianDistance(tour[length-1].get_x_coord(),
tour[length-1].get_y_coord(), dpt.get_x_coord(), dpt.get_y_coord())
if bestRoute.get_totalCost() > newCost:
# verifica número de veículos utilizados pelo depósito
nVehicles = 0
for r in solution1.get_routes():
if r.get_depot() == dpt:
nVehicles += 1
if nVehicles < dpt.get_numberVehicles():
if (costWithoutRoute + newCost
) < solution1.get_cost(): # é melhor
extraPenalty = 0
bestRoute = copy.deepcopy(route1)
bestRoute.set_depot(dpt)
newCost1 = newCost - penalty
bestRoute.set_cost(
newCost1, bestRoute.get_totalDemand(),
bestRoute.get_totalService())
cont = 1
# else:
# if (costWithoutRoute + newCost + 1000) < solution1.get_cost(): # ainda é melhor
# extraPenalty = 1000 #penalização por rota a mais
# bestRoute.set_depot(dpt)
# newCost1 = newCost - penalty
# bestRoute.set_cost(newCost1, bestRoute.get_totalDemand(),
# bestRoute.get_totalService())
# cont = 1
if cont == 1:
# print(penalty)
# # print(bestRoute.get_totalCost())
# print(route)
# # print("best")
# print(bestRoute)
solution1.setRoute(bestRoute, idRoute)
solution1.formGiantTour()
solution1.calculateCost(extraPenalty)
return solution1
return solution
def getSteeringPIDDerivativeGain(self):
return 0.0008
def getSteeringPIDIntegralTermLimit(self):
return -1.0
if __name__ == "__main__":
log_message_queue_listener.start()
logging.info('Loading')
ev3.Sound.beep().wait()
ev3.Sound.beep().wait()
settings = Settings()
bumpers = Bumpers(settings.getFrontBumperAddress()) if (settings.hasFrontBumper()) else None
steering = Steering(
settings.getSteeringMotorAddress(),
settings.getSteeringMotorSpeedFactor(),
settings.getSteeringSpeed(),
settings.getSteeringMaxRange(),
settings.getSteeringMotorPositionFactor(),
settings.getDoCenterSteeringWhenInitializing()
)
folkracer = Folkracer(steering, Engine(settings), Distances(settings), bumpers, Buttons(), settings, None, None, LightsAndSounds())
folkracer.start()
folkracer.join()
logging.info('Shutting down.')
log_message_queue_listener.stop()
ev3.Sound.beep().wait()
ev3.Sound.beep().wait()
def distance():
os.environ['API_KEY'] = 'AIzaasdf'
return Distances('sqlite:///:memory:')
def testEuclidean(self):
r1 = {'value1':5}
r2 = {'value2':5}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.EUCLIDEAN)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(50, distance)
r1 = {'value1':5}
r2 = {'value1':5}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.EUCLIDEAN)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(0, distance)
r1 = {'value1':5}
r2 = {'value1':3}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.EUCLIDEAN)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(4, distance)
r1 = {'value1':1, 'value2':2, 'value3':3}
r2 = {'value1':5, 'value2':6, 'value3':5}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.EUCLIDEAN)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(36, distance)
def testChiSquare(self):
r1 = {'value1':5}
r2 = {'value1':5}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.CHI_SQUARE)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(0, distance)
r1 = {'value1':5}
r2 = {'value2':5}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.CHI_SQUARE)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(10, distance)
r1 = {'value1':5}
r2 = {'value1':3}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.CHI_SQUARE)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(0.5, distance)
r1 = {'value2':2, 'value3':3}
r2 = {'value2':6, 'value3':5}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.CHI_SQUARE)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(2.5, distance)
r1 = {'value1':1, 'value2':2, 'value3':3}
r2 = {'value2':6, 'value3':5, 'value4':2}
distanceCalculator = Distances()
distanceCalculator.set_type(Distances.CHI_SQUARE)
distance = distanceCalculator.calculate(r1, r2)
self.assertEqual(5.5, distance)
def splitLinearBounded(solution):
solution1 = copy.deepcopy(solution)
solution2 = copy.deepcopy(solution)
depotsList = dpts.get_depotsList()
customers = solution1.get_giantTour()
depots = solution1.get_depots()
for dpt in depotsList:
listCst = []
depot = depotsList[dpt]
for j in range(len(customers)):
if dpt == str(depots[j].get_id()):
listCst.append(customers[j])
sumDistance = [0.0 for x in range(len(listCst) + 1)]
sumLoad = [0.0 for x in range(len(listCst) + 1)]
sumDistance[0] = 0 # distancia do depósito
# distância do depósito ao primeiro nó
sumDistance[1] = dist.euclidianDistance(listCst[0].get_x_coord(),
listCst[0].get_y_coord(),
depot.get_x_coord(),
depot.get_y_coord())
sumLoad[0] = 0
sumLoad[1] = customers[0].get_demand()
# inicializar com o somatório distancia de i-1 a i e a demanda de i-1 a i
for i in range(2, len(listCst) + 1):
sumDistance[i] = sumDistance[i - 1] + dist.euclidianDistance(
listCst[i - 2].get_x_coord(), listCst[i - 2].get_y_coord(),
listCst[i - 1].get_x_coord(), listCst[i - 1].get_y_coord())
sumLoad[i] = sumLoad[i - 1] + listCst[i - 1].get_demand()
potential = []
pred = []
for k in range(depot.get_numberVehicles() + 1):
potential.append([1.e30 for x in range(len(listCst) + 1)])
pred.append([-1 for x in range(len(listCst) + 1)])
potential[0][0] = 0
for k in range(depot.get_numberVehicles()):
queue = [k]
i = k + 1
while (i <= len(listCst)) and (len(queue) > 0):
# o primeiro da fila será o melhor predecessor de i
potential[k + 1][i] = SplitAlgorithms.propagatek(
queue[0], i, k, listCst, sumDistance, potential,
depot) # calcula custo de i a j
pred[k + 1][i] = queue[0]
# se i não é dominado pelo último da pilha
if i < len(listCst):
if not (SplitAlgorithms.dominatesk(
queue[len(queue) - 1], i, k, listCst,
sumDistance, potential, sumLoad, depot)):
# então i será inserido, precisando remover quem ele domina
while len(
queue
) > 0 and SplitAlgorithms.dominatesRightk(
queue[len(queue) - 1], i, k, listCst,
sumDistance, potential, depot):
del queue[len(queue) - 1]
queue.append(i)
# Verifica se a frente consegue chegar ao próximo nó, caso contrário ele desaparecerá.
while len(queue) > 0 and (
sumLoad[i + 1] - sumLoad[queue[0]]) > (
depot.get_loadVehicle() + 0.0001):
del queue[0]
i += 1
if potential[depot.get_numberVehicles()][len(listCst)] > 1.e29:
# print("ERRO: nenhuma solução de divisão foi propagada até o último nó")
del solution1
return SplitAlgorithms.mountRoutes(solution2)
else:
# achando o número ótimo de rotas
minCost = 1.e30
nRoutes = 0
for k in range(1, depot.get_numberVehicles() + 1):
if potential[k][len(listCst)] < minCost:
minCost = potential[k][len(listCst)]
# print("minCost "+str(minCost))
nRoutes = k
cour = len(listCst)
for i in range(nRoutes - 1, -1, -1):
route = Route(depot)
j = pred[i + 1][cour]
for k in range(j + 1, cour + 1):
route.addCustomer(listCst[k - 1])
cour = j
# calcular custo da rota formada
route.startValues()
route.calculeCost()
solution1.addRoutes(route)
solution1.formGiantTour()
solution1.calculateCost()
# print(solution)
return solution1
