raise KeyboardInterrupt(best_sol)
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_gap_algorithm(seed_method="cones"):
algo_name = "FJ81-GAP"
algo_desc = "Fisher & Jaikumar (1981) generalized assignment problem heuristic"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return gap_init(points,
D,
d,
C,
L=L,
st=st,
K=None,
minimize_K=minimize_K,
seed_edge_weight_type=wtt,
find_optimal_seeds=(not single),
seed_method=seed_method)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_gap_algorithm())
])
sol = new_sol
c_lambda_incs = 0
except KeyboardInterrupt: # or SIGINT
# Pass on the current solution forced feasbile by splitting routes
# according to the constraints.
raise KeyboardInterrupt(_force_feasible(sol, D, d, C, L))
return without_empty_routes(sol)
# Wrapper for the command line user interface (CLI)
def get_lr3opt_algorithm():
algo_name = "SG84-LR3OPT"
algo_desc = "Stewart & Golden (1984) Lagrangian relaxed 3-opt* heuristic"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
if minimize_K:
raise NotImplementedError(
"LR3OPT does not support minimizing the number of vehicles")
return lr3opt_init(D, d, C, L)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_lr3opt_algorithm())
if not p1_better_than_p2 and p2_best_so_far:
best_sol = phase2_sol
best_f = phase2_f
best_K = phase2_K
if interrupted:
# pass on the current best solution
raise KeyboardInterrupt(best_sol)
# deterministic version, no retries
# stochastic version terminates as soon as phase2 succeeds
if (rr is None) or (phase2_sol is not None):
break
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_cmt2p_algorithm():
algo_name = "CMT79-2P"
algo_desc = "Christofides, Mingozzi & Toth (1979) two phase heuristic"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return cmt_2phase_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__=="__main__":
from shared_cli import cli
cli(*get_cmt2p_algorithm())
sol_K = sol.count(0) - 1
if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):
best_sol = sol
best_f = sol_f
best_K = sol_K
if interrupted:
# pass on the current best_sol
raise KeyboardInterrupt(best_sol)
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_gs_algorithm():
algo_name = r"Ga67-PS|pi+lamda"
algo_desc = r"Parallel savings algorithm with Gaskell (1967) $\pi$ and "+\
r"$\lambda$ criteria"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
savings_method = "both" if not single else "pi"
return gaskell_savings_init(D, d, C, L, minimize_K, savings_method)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_gs_algorithm())
best_K = auto_route_count
for k in range(2,auto_route_count+1):
sol = nearest_neighbor_init(D, d, C, L, emerging_route_count=k)
sol = without_empty_routes(sol)
sol_f = objf(sol,D)
sol_K = sol.count(0)-1
if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):
best_sol = sol
best_f = sol_f
best_K = sol_K
return best_sol
elif emerging_route_count>1:
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
if minimize_K:
# todo: remove this when supprot (see TODO notes in algo desc)
raise NotImplementedError("Nearest neighbor algorithm does "+
" not support minimizing the number"+
" of vehicles")
return nearest_neighbor_init(D, d, C, L, emerging_route_count)
else:
raise ValueError("Not a valid emerging_route_count value "+
"(%s) for parallel algorithm"%
str(emerging_route_count))
return (algo_name, algo_desc, call_init)
if __name__=="__main__":
from shared_cli import cli
cli(*get_pnn_algorithm())
emerging_route_nodes.append(0)
solution += emerging_route_nodes
emerging_route_nodes = None
except KeyboardInterrupt:
interrupted_solution = solution
if emerging_route_nodes:
emerging_route_nodes.append(0)
interrupted_solution += emerging_route_nodes
interrupted_solution += routes2sol([n] for n in unrouted)[1:]
raise KeyboardInterrupt(interrupted_solution)
return solution
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_ss_algorithm(lambda_multiplier='auto'):
algo_name = "We64-SS"
algo_desc = "Webb (1964) sequential savings algorithm"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return sequential_savings_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_ss_algorithm())
best_f = sol_f
best_K = sol_K
if interrupted:
raise KeyboardInterrupt(best_sol)
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
# (takes an extra argument for enabling parallel version)
def get_mj_algorithm():
algo_name = "MJ76-INS"
algo_desc = "Mole & Jameson (1976) sequential cheapest insertion "+\
"heuristic with a route improvement phase"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
if single:
return mole_jameson_insertion_init(
D, d, C, L, minimize_K, strain_criterion="clarke_wright")
else:
return mole_jameson_insertion_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_mj_algorithm())
minimize_K=minimize_K,
emerging_route_count=1)
one_eroute_K = sol_ci.count(0) - 1
return cheapest_insertion_init(D,
d,
C,
L=L,
minimize_K=minimize_K,
emerging_route_count=one_eroute_K)
elif emerging_route_count > 1:
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return cheapest_insertion_init(
D,
d,
C,
L=L,
minimize_K=minimize_K,
emerging_route_count=emerging_route_count)
else:
raise ValueError("Not a valid parameter value, has to be 'auto' or " +
"an integer > 1, (was %s)" %
str(emerging_route_count))
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_si_algorithm())
giant_tour_sol, giant_tour_l = tsp_gen_algo(D, list(range(1, N)))
if __debug__:
log(
DEBUG, "TSP tour solution %s (%.2f)" %
(str(giant_tour_sol), giant_tour_l))
route_cost_constant = giant_tour_l if minimize_K else 0.0
return _partition_to_routes_with_cost_matrix(D, d, C, L, giant_tour_sol,
route_cost_constant,
partition_tsp_opt_algo,
route_tsp_opt_algo)
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_rfcs_algorithm():
algo_name = "Be83-RFCS"
algo_desc = "Route-first-cluster-second heuristic of Beasley (1983)"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return route_first_cluster_second_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_rfcs_algorithm())
sol = parallel_savings_init(D, d, C, L, minimize_K)
sol = do_local_search(
[do_2opt_move], #, do_2optstar_move],
sol,
D,
d,
C,
L,
LSOPT.BEST_ACCEPT)
return sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_ps2o_algorithm():
algo_name = "RT79-CAWLIP"
algo_desc = "Robbins and Turner (1979) CAWLIP parallel "+\
"savings algorithm with 2-opt* improvement phase"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return cawlip_savings_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_ps2o_algorithm())
routes[left_route].extend(routes[right_route])
routes[right_route] = None
if __debug__:
dbg_sol = routes2sol(routes)
log(
DEBUG - 1, "Merged, resulting solution is %s (%.2f)" %
(str(dbg_sol), objf(dbg_sol, D)))
except KeyboardInterrupt: # or SIGINT
interrupted_sol = routes2sol(routes)
raise KeyboardInterrupt(interrupted_sol)
return routes2sol(routes)
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_ps_algorithm():
algo_name = "CW64-PS"
algo_desc = "Clarke & Wright (1964) parallel savings algorithm"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return parallel_savings_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_ps_algorithm())
routes[i], route_f = solve_tsp(D, routes[i][:-1])
if __debug__:
log(DEBUG - 2,
"Got TSP solution %s (%.2f)" % (str(routes[i]), route_f))
except KeyboardInterrupt: #or SIGINT
raise KeyboardInterrupt(solution)
return routes2sol(routes)
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_ty_algorithm():
algo_name = "Ty68-NN"
algo_desc = "Tyagi (1968) Nearest Neighbor construction heuristic"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
if minimize_K:
raise NotImplementedError(
"Nearest neighbor algorithm does not support minimizing the number of vehicles"
)
return tyagi_init(D, d, C, L)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_ty_algorithm())
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_ptl_algorithm():
algo_name = "FR76-1PTL"
algo_desc = "Foster & Ryan (1976) Petal set covering algorithm"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
if single:
return petal_init(points,
D,
d,
C,
L,
minimize_K=minimize_K,
required_iterations=1,
relaxe_SCP_solutions=False)
else:
return petal_init(points, D, d, C, L, minimize_K=minimize_K)
#minimize_K=True)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_ptl_algorithm())
log(DEBUG, "Previous sweep produced solution %s (%.2f)\n\n" %
(str(sol),sol_f))
if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):
best_sol = sol
best_f = sol_f
best_K = sol_K
except KeyboardInterrupt: # or SIGINT
raise KeyboardInterrupt(best_sol)
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_swp_algorithm():
algo_name = "Sweep"
algo_desc = "Sweep algorithm without route improvement heuristics"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
seed_search = SMALLEST_ANGLE if single else BEST_ALTERNATIVE
direction = "cw" if single else "both"
return sweep_init(points, D, d, C, L, minimize_K,
direction=direction, seed_node=seed_search)
return (algo_name, algo_desc, call_init)
if __name__=="__main__":
from shared_cli import cli
cli(*get_swp_algorithm())
if __debug__:
log(DEBUG, "Improved solution %s (%.2f)" % (sol, sol_f))
if is_better_sol(best_f, best_K, sol_f, sol_K, minimize_K):
best_sol = sol
best_f = sol_f
best_K = sol_K
if interrupted:
raise KeyboardInterrupt(best_sol)
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_wh_algorithm():
algo_name = "WH72-SwLS"
algo_desc = "Wren and Holliday (1972) Sweep heuristic"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
seed_node = 1 if single else BEST_OF_FOUR
return wren_holliday_init(points, D, d, C, L, minimize_K, seed_node)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_wh_algorithm())
seed_node,
routing_algo=solve_tsp,
prepare_callback_datastructures=_pack_datastructures_callback,
intra_route_improvement=_improvement_callback)
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_gm_algorithm():
algo_name = "GM74-SwRI"
algo_desc = "Gillett & Miller (1974) Sweep algorithm with emering "+\
"route improvement"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
if single:
direction = "ccw"
seed_node = 1 #first node
else:
direction = "both"
seed_node = BEST_ALTERNATIVE
return gillet_miller_init(points, D, d, C, L, minimize_K, direction,
seed_node)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_gm_algorithm())
except KeyboardInterrupt: #or SIGINT
interrupted_sol = _geedy_merge(D, d, C, L, W, savings, route_sets,
tsp_cache, demand_cache)
raise KeyboardInterrupt(interrupted_sol)
# the optimized TSP tours for the routes are cached, reuse
final_routes = [
_get_tsp_sol(rs, tsp_cache, D, solve_tsp)[0] for rs in route_sets
]
sol = [0] + [n for route in final_routes for n in route[1:]]
return sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_mm_algorithm():
algo_name = "DV89-MM"
algo_desc = "Desrochers and Verhoog (1989) maximum matching based "+\
"savings algorithm"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return mbsa_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_mm_algorithm())
if __debug__:
log(
DEBUG, "Best so far solution %s (%.2f) found with L'=%d" %
(sol, sol_f, Lcounter))
best_sol = sol
best_f = sol_f
best_K = sol_K
#best_sL = iterL
if interrupted:
raise KeyboardInterrupt(best_sol)
return best_sol
# ---------------------------------------------------------------------
# Wrapper for the command line user interface (CLI)
def get_ims_algorithm():
algo_name = "HP76-PS|IMS"
algo_desc = "Holmes & Parker (1976) parallel savings supression algorithm"
def call_init(points, D, d, C, L, st, wtt, single, minimize_K):
return suppression_savings_init(D, d, C, L, minimize_K)
return (algo_name, algo_desc, call_init)
if __name__ == "__main__":
from shared_cli import cli
cli(*get_ims_algorithm())
