def test_all_instances(dim):
size = (dim * (dim - 1)) / 2
total = int(math.pow(2, size))
toolow = 0
toohigh = 0
formatter = '0' + str(int(size)) + 'b'
fileout = open("n=" + str(dim), "w")
for i in range(int(math.pow(2, size))):
m = Matrix()
m.createMatrixfromString(dim, format(i, formatter))
s = BruteForcer(m)
s.solve()
lb = DynamicProgramming(m, 0).compute(0, dim - 1)
ub = DynamicProgramming(m, 1).compute(0, dim - 1)
g = Greedy(m)
g.solve()
if lb != s.get_best():
toolow += 1
if ub != s.get_best():
toohigh += 1
fileout.write(
str(s.get_best()) + ";" + str(lb) + ";" + str(ub) + ";" +
str(g.get_opt_val()) + "\n")
fileout.close()
print("Total instances:", total)
print("Too low:", toolow)
print("Too high:", toohigh)
def __init__(self, stones, nPlayers, port):
self.PORT = port
self.NUMBER_OF_PLAYERS = nPlayers
self.s.connect((self.HOST, self.PORT))
self.maxStones = stones
self.greedy = Greedy(self.STRIDE, self.maxStones)
self.stones = []
self.stones.append([])
self.stones.append([])
def calc_greedy_similarity(host, port, dbindex):
logger.debug('calculating similarity...');
begin_time = datetime.now()
logger.debug('Similarity calculation started at : '+str(begin_time))
dur = begin_time-begin_time
redisconn=redis.StrictRedis(host=host, port=port, db=dbindex)
#term_weight_fetcher=TermWeightFetcher(lucene_dir_path)
term_vector_fetcher=TermVectorFetcher(redisconn, None)
greedy=Greedy()
result=[]
for request in requests:
for candidate in request.candidates:
cand_loc =readInfo.getLocation(candidate)
cand_text=getText(cand_loc)
cand_tokens=cleansetokenize(cand_text)
print cand_tokens
cand_term_vector_list=term_vector_fetcher.get_termvectors(cand_tokens, False)
for preference in request.preferences:
pref_loc =readInfo.getLocation(preference.docID)
pref_text=getText(pref_loc)
pref_tokens=cleansetokenize(pref_text)
pref_term_vector_list=term_vector_fetcher.get_termvectors(pref_tokens, False)
check_time=datetime.now()
similarity_normal=greedy.calc_normal(cand_term_vector_list, pref_term_vector_list)
result.append(request.id+','+candidate.docID+','+preference.docID+','+str(similarity_normal[0]))
dur += datetime.now() - check_time
finish_time=datetime.now()
logger.debug('All duration : '+str(finish_time-begin_time))
logger.debug('Similarity calculation duration : '+str(dur))
logger.debug('Others duration : '+str(finish_time-begin_time-dur))
#writing the output file normal
f = open('result.txt','w')
#f = open('/data/nrekabsaz/mediaeval-diversity/runs/greedy/'+runname+'.run','w')
#for tcnt, topic in enumerate(topics):
# topic.photos.sort(key=operator.attrgetter("similarity_normal"), reverse=True)
# for i,photo in enumerate(topic.photos):
# trecLine=str(topic.number) + " Q0 " + str(photo.id) + " " + str(i+1) + " " + str(photo.similarity_normal) + " l2r_mediaeval";
# f.write(trecLine+'\n')
# if i==49:
# break
#f.close()
finish_time=datetime.now()
dur = finish_time - begin_time
logger.info('Similarity calculation finished at : '+str(finish_time))
logger.info('All duration : '+str(finish_time-begin_time))
logger.info('Similarity calculation duration : '+str(dur))
logger.info('Others duration : '+str(finish_time-begin_time-dur))
def move(self, state, timeLimit):
print("{0}'s turn. {0} is {1}".format(self.name, self.color))
if self.difficulty == 6:
m = AlphaBeta(state)
start = time.clock()
best_move, value, depth = m.bestMove(30, state, self.color,
timeLimit)
print("Alpha: ", value)
print("Elapsed:", time.clock() - start)
print("Depth Reached:", depth)
return best_move, depth
elif self.difficulty == 7:
m = Greedy(state)
time.sleep(randrange(8, 17, 1) / 10.0)
best_move = m.best_move(state, self.color)
print("guess greedy worked")
return best_move, 1
else:
m = Minimax(state)
start = time.clock()
best_move, value, depth = m.bestMove(30, state, self.color,
timeLimit)
print("Alpha: ", value)
print("Elapsed:", time.clock() - start)
print("Depth Reached:", depth)
return best_move, depth
def find_solver(self, algorithm):
solver = None
while solver is None:
if algorithm == 'depth_first' or algorithm == 'dfs':
solver = Depth_first(self.map)
elif algorithm == 'breadth_first' or algorithm == 'bf' or algorithm == 'bfs':
solver = Breadth_first(self.map)
elif algorithm == 'astar' or algorithm == 'a*':
solver = AStar(self.map)
elif algorithm == 'greedy_best_first' or algorithm == 'gbf' or algorithm == 'gbfs':
solver = Greedy_best_first(self.map)
elif algorithm == 'iterative_deepening' or algorithm == 'id' or algorithm == 'ids':
solver = Iterative_deepening(self.map)
elif algorithm == 'greedy' or algorithm == 'g' or algorithm == 'gs':
solver = Greedy(self.map)
#Iterative astar works, but it does not work well.
#I did not research it much before building it, and I got a few key details wrong.
#I decided to scrap it and use a different informed custom search (greedy), as it would have taken me far too long to redo it.
#But I figured it would still be a valuable thing to include just to show my progress.
elif algorithm == 'iterative_astar' or algorithm == 'ia*':
solver = Iterative_astar(self.map)
else:
print(
'Valid searches are: dfs (depth first), bfs (breadth first), A*, greedy, ids (iterative deepening) or gbfs (greedy best first)'
)
print('Please enter an algorithm:')
algorithm = input()
return solver
def sa_algorithm(self):
ga = Greedy(self.cities_matrix, self.number_of_cities)
solution = ga.greedy_algorithm()
starting_temp = 100
current_temperature = starting_temp
min_length = self.tour_length(solution)
best_solution = []
i = 0
coolingRate = 0.00015 #this is the best I've found: 0.0002
cool_count = 0
lengths = []
loop_count = []
lo = 0
average_distance = self.cities_matrix.sum() / self.number_of_cities**3
print(average_distance)
diff_frac = 0.01 * average_distance**0.5
print('Diff_frac' + str(diff_frac))
while current_temperature > 0.05:
i += 1
solution = self.optimise(self.cities_matrix, solution,
self.number_of_cities,
current_temperature, diff_frac)
if i >= 150:
i = 0 #reset i
cool_count += 1
currentLength = self.tour_length(solution)
#Exponential multiplicative cooling:
current_temperature = starting_temp * (
1 - coolingRate)**cool_count #t *= 1 - coolingRate
#current_temperature = starting_temp*math.exp( -( 0.001*1.2*cool_count**1.15 ) )
# current_temperature = starting_temp/(1+1.8*math.log(1+0.001*cool_count))
lo += 1
loop_count.append(lo)
lengths.append(currentLength)
if currentLength < min_length:
min_length = currentLength
best_solution = solution[:]
# plt.plot(loop_count, lengths, 'b.')
# filename = 'city'+str(number_of_cities)
# plt.savefig(filename, format='svg', dpi=1200)
# plt.show()
return best_solution
def MipSolver(facilities: [], customers: []):
# Create the mip solver with the CBC backend.
solver = pywraplp.Solver('simple_mip_program',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
m = len(facilities)
n = len(customers)
#define vars
x = np.empty(m, dtype=object)
y = np.empty((m, n), dtype=object)
for i in range(m):
x[i] = solver.IntVar(0, 1, 'X[%d]' % i)
for j in range(n):
y[i][j] = solver.IntVar(0, 1,
'Y[%d' % i + ']' + '[' + str(j) + ']')
#define the constraint
# rang buoc ve demand and capacity
for i in range(m):
constraint_capacity = solver.RowConstraint(0, facilities[i].capacity,
'')
for j in range(n):
constraint_capacity.SetCoefficient(y[i][j], customers[j].demand)
for i in range(m):
constraint1 = solver.RowConstraint(0, n, '')
constraint1.SetCoefficient(x[i], n)
for j in range(n):
constraint1.SetCoefficient(y[i][j], -1)
for j in range(n):
constaint = solver.Constraint(1, 1, '')
for i in range(m):
constaint.SetCoefficient(y[i][j], 1)
# minimum
objective = solver.Objective()
for j in range(m):
objective.SetCoefficient(x[j], facilities[j].setup_cost)
for i in range(m):
for j in range(n):
twc = length(facilities[i].location, customers[j].location)
objective.SetCoefficient(y[i][j], twc)
objective.SetMinimization()
status = solver.Solve()
if status == pywraplp.Solver.OPTIMAL:
obj = solver.Objective().Value()
solution = np.empty(n, dtype=int)
for j in range(n):
for i in range(m):
if (y[i][j].solution_value() == 1):
solution[j] = i
return obj, solution
else:
return Greedy(customers, facilities)
class Voronoi:
HOST = 'localhost'
PORT = 9000
STRIDE = 60
NUMBER_OF_PLAYERS = 2
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
def __init__(self, stones, nPlayers, port):
self.PORT = port
self.NUMBER_OF_PLAYERS = nPlayers
self.s.connect((self.HOST, self.PORT))
self.maxStones = stones
self.greedy = Greedy(self.STRIDE, self.maxStones)
self.stones = []
self.stones.append([])
self.stones.append([])
def start(self):
while 1:
serverResponse = self.s.recv(1024)
data = serverResponse.split()
# Check if the game has ended
if int(data[0]) == 1:
break
self.noOfMoves = int(data[1]) - 1
self.playersMovedTillNow = int(data[1])
if (self.playersMovedTillNow < self.NUMBER_OF_PLAYERS):
for i in range(0, self.playersMovedTillNow):
self.lastMoveOfOpponent_x = int(data[2 + i * 3])
self.lastMoveOfOpponent_y = int(data[2 + i * 3 + 1])
self.stones[1].append(
Stone(self.lastMoveOfOpponent_x,
self.lastMoveOfOpponent_y))
self.greedy.updatePull(self.stones, 1)
else:
startIndex = self.playersMovedTillNow - self.NUMBER_OF_PLAYERS + 1
for i in range(startIndex, self.playersMovedTillNow):
self.lastMoveOfOpponent_x = int(data[2 + i * 3])
self.lastMoveOfOpponent_y = int(data[2 + i * 3 + 1])
self.stones[1].append(
Stone(self.lastMoveOfOpponent_x,
self.lastMoveOfOpponent_y))
self.greedy.updatePull(self.stones, 1)
nextMove = self.greedy.move(self.stones)
self.stones[0].append(Stone(nextMove.x, nextMove.y))
self.greedy.updatePull(self.stones, 0)
self.s.sendall(str(nextMove.x) + " " + str(nextMove.y))
self.s.close()
def main():
if (len(sys.argv) != 4):
print(
"Parametros incorrectos, debe especificar grilla, estrategia y lanzaderas"
)
print("Estrategias reconocidas: 'g' Greedy,\t 'd' Dinamica")
print("Greedy: python battleship.py grid.txt g 2")
print("Dinamica: python battleship.py grid.txt d 2")
exit(1)
grid, ships = read_grid(sys.argv[1]) # Archivo
lanzaderas = int(sys.argv[3])
new_grid = realocate_ships(grid)
if (sys.argv[2] == 'g'):
strategy = Greedy(grid, lanzaderas, ships)
new_strategy = Greedy(new_grid, lanzaderas, ships)
elif (sys.argv[2] == 'd'):
strategy = Dinamica(grid, lanzaderas, ships)
new_strategy = Dinamica(new_grid, lanzaderas, ships)
else:
print(
"Estrategia no reconocida, utilice 'g' para Greedy y 'd' para Dinamica"
)
exit(2)
print("Configuracion de juego:")
print("Estrategia " + str(strategy) + " con " + str(strategy.lanzaderas) +
" lanzaderas ")
print_board(grid, ships)
game(grid, list(ships), strategy)
print("Utilizando estrategia para reubicar barcos para que duren mas\n\n")
print("Antes")
print_board(grid, ships)
print("Reubicados")
print_board(new_grid, ships)
sleep(3)
game(new_grid, list(ships), new_strategy)
def measure_greedy():
greedy = Greedy(Graph(0))
avg_memory_consumption = []
for i in range(START_COUNTING_FROM_NODE, NUM_OF_NODES):
mem_usage_data = []
print(f"Measuring Greedy for {i} nodes.")
for j in range(NUM_OF_SAMPLES):
graph = Graph(i)
greedy.graph = graph
starting_node = next(iter(graph.graph))
mem_usage = memory_usage((greedy.greedy_approach, (), {
'start_node': starting_node
}))
mem_usage_data.append(mem_usage[-1])
avg_memory_consumption.append(sum(mem_usage_data) / NUM_OF_SAMPLES)
return avg_memory_consumption
def test_random():
"""
Test all approaches on random graph.
"""
num_of_nodes = 7
graph = Graph(num_of_nodes)
starting_node = next(iter(graph.graph))
print("{:-^100}".format(" TESTING RANDOM PATH "))
dfs = DFS(graph)
paths_dfs = dfs.depth_first_search(starting_node)
print("DEPTH FIRST SEARCH")
print("Number of Hamilton Cycles found:", len(paths_dfs))
print("Shortest path:", graph.get_shortest_path(paths_dfs), end="\n\n")
bfs = BFS(graph)
paths_bfs = bfs.breadth_first_search(starting_node)
print("BREADTH FIRST SEARCH")
print("Number of Hamilton Cycles found:", len(paths_bfs))
print("Shortest path:", graph.get_shortest_path(paths_bfs), end="\n\n")
greedy = Greedy(graph)
path_greedy = greedy.greedy_approach(starting_node)
print("GREEDY APPROACH")
print("Path length:",
(path_greedy, graph.calculate_path_length(path_greedy)),
end="\n\n")
a_star_custom = AStarCustom(graph)
path_a_star = a_star_custom.a_star(starting_node)
print("A* APPROACH")
print("Path length:",
(path_a_star, graph.calculate_path_length(path_a_star)),
end="\n")
print("{:-^100}".format(" END OF TEST "), end="\n\n")
def run_test(difficulty, algorithm, output_name): genotype = get_test_data_path(difficulty) if algorithm == 'greedy': g = Greedy(genotype) t = Tester(g, None, genotype, output_name) t.run_analysis() elif algorithm == 'optimal': o = Optimal(genotype) t = Tester(o, None, genotype, output_name) t.run_analysis() elif algorithm == 'exhaustive': e = Exhaustive(genotype) t = Tester(e, None, genotype, output_name) t.run_analysis()
def run_training(difficulty, algorithm, output_name): genotype, haplotype = get_training_file_paths(difficulty) if algorithm == 'greedy': g = Greedy(genotype) t = Tester(g, haplotype, genotype, output_name) t.run_analysis() elif algorithm == 'optimal': o = Optimal(genotype) t = Tester(o, haplotype, genotype, output_name) t.run_analysis() elif algorithm == 'exhaustive': e = Exhaustive(genotype) t = Tester(e, haplotype, genotype, output_name) t.run_analysis()
def main():
#For argument passing
fileargs = argparse.ArgumentParser()
fileargs.add_argument('file', help="file number to run", type=int)
args = fileargs.parse_args()
#Initialize Knapsack Objects for tasks
weights = []
values = []
valueIndices = [] #Copy of the original order of values
heapWeights = []
heapValues = []
#Concate checks and balances
if args.file < 10:
c_file = "./KnapsackTestData/p0" + str(args.file) + "_c.txt"
w_file = "./KnapsackTestData/p0" + str(args.file) + "_w.txt"
v_file = "./KnapsackTestData/p0" + str(args.file) + "_v.txt"
else:
c_file = "./KnapsackTestData/p" + str(args.file) + "_c.txt"
w_file = "./KnapsackTestData/p" + str(args.file) + "_w.txt"
v_file = "./KnapsackTestData/p" + str(args.file) + "_v.txt"
print("File containing the capacity, weights, and values are:",
c_file[19:] + ", " + w_file[19:] + ", " + v_file[19:])
print()
#Read in from files
file = open(c_file)
#Max weight
maxCapacity = int(file.readline())
file.close()
#Weights
file = open(w_file)
for line in file:
weights.append(int(line))
heapWeights.append(int(line))
file.close()
#Values
file = open(v_file)
for line in file:
valueIndices.append(int(line))
values.append(int(line))
heapValues.append(int(line))
file.close()
totalWeights = len(weights)
totalValues = len(values)
print("Knapsack capacity =", maxCapacity, ". Total number of items =",
totalWeights)
print()
#Dynamic Programming
dynamicClass = Dynamic()
dpTable = [[0 for x in range(maxCapacity + 1)]
for x in range(totalWeights + 1)]
begin = time.time()
dpResult = dynamicClass.dynamicApproach(weights, values, maxCapacity,
totalWeights, dpTable)
dpOptimal = dynamicClass.dynamicOptimal(weights, maxCapacity, totalWeights,
dpTable)
dpTime = time.time() - begin
print("Traditional Dynamic Programming Optimal value:", dpResult)
print("Traditional Dynamic Programming Optimal subset:", dpOptimal)
print("Traditional Dynamic Programming Time Taken:", dpTime)
print()
#Greedy approach using in-built sorting
greedyOptSubset = []
greedyOptValues = []
greedyClass = Greedy()
greedyClass.quickSort(0, totalValues - 1, values, weights)
greedyResult = greedyClass.greedyApproach(values, maxCapacity, weights,
greedyOptValues)
greedyOptSubset = optimalSubset(valueIndices, greedyOptValues)
print("Greedy Approach Optimal value:", greedyResult)
print("Greedy Approach Optimal subset:", greedyOptSubset)
print("Greedy Approach Number of Operations:",
greedyClass.greedyOperations)
print()
#Greedy approach using a max-heap
heapOptSubset = []
heapOptValues = []
totalHeapValues = len(heapValues)
heapClass = Heap()
heapClass.heapSort(heapValues, heapWeights, totalHeapValues)
heapOptValue = heapClass.heapApproach(heapValues, heapWeights, maxCapacity,
heapOptValues)
heapOptSubset = optimalSubset(valueIndices, heapOptValues)
print("Heap-based Greedy Approach Optimal value:", heapOptValue)
print("Heap-based Greedy Approach Optimal subset:", heapOptSubset)
print("Heap-based Approach Number of Operations:",
heapClass.heapOperations)
print()
graphMaker()
def test_exercise_progress():
db = mongoengine.connect(config.db_name)
db.drop_database(config.db_name)
# Editor user
u = utils.sample_user()
u.save()
exe = model.exercise.Exercise(author=u, title="An exercise's title", description="## This is an exercise\n\n* El1\n* El2",
boilerplate_code='b', reference_code='#', tags=['sort','trees'])
test = model.exercise.Test(input='1\n', output='1')
test.save()
exe.tests.append(test)
test = model.exercise.Test(input='2\n', output='2')
test.save()
exe.tests.append(test)
test = model.exercise.Test(input='3\n', output='3')
test.save()
exe.tests.append(test)
exe.save()
wrong_code = '\n'.join([
'#include <iostream>',
'',
'int main() {',
'int i;',
'std::cin >> i;',
'if (i > 2) std::cout << i;',
'return 0;',
'}'
])
working_code = '\n'.join([
'#include <iostream>',
'',
'int main() {',
'int i;',
'std::cin >> i;',
'std::cout << i;',
'return 0;',
'}'
])
u = model.user.User(email='test@{}'.format(config.email_domain), username='******', secret_hash='hash', salt='salt')
u.save()
submission = job.Submission(exercise=exe, code=wrong_code, user=u)
submission.save()
submission = job.Submission(exercise=exe, code=working_code, user=u)
submission.save()
submission = job.Submission(exercise=exe, code="nothing at all", user=u)
submission.save()
greedy_app = Greedy(db)
greedy_app.fetch_and_process()
# Progression for this user
progress, created = model.exercise.ExerciseProgress.objects.get_or_create(user=u, exercise=exe)
assert progress.best_results[0].passed == True
assert progress.best_results[1].passed == True
assert progress.best_results[2].passed == True
assert progress.score <= 42
def main():
print('============================================')
print(
'Program ini menunjukan kota-kota yang bisa \nanda kunjungi saat piknik antar kota dengan keluarga \ndan menunjukan kota-kota dengan jarak antar kota terpendek'
)
print(
'sehingga memudahkan anda untuk mendapatkan kota untuk singgah \natau memperbanyak tujuan piknik anda'
)
print('-------------------------------------------')
print(
'This program shows cities that can be visited \non your family trip and help you to get the list of cities that have shortest distance between them.'
)
print(
'So by using this program you can get some cities for stop by \nor multiply your destination for your trip'
)
print('============================================')
print(
'Berikut adalah daftar kota yang kami sediakan:\n(Here the list of the cities that we provide)\n'
)
#List Kota
kota = set([
'Cilegon', 'Tangerang', 'Jakarta', 'Bogor', 'Cikampek', 'Bekasi',
'Bandung', 'Cirebon', 'Cimahi', 'Cianjur', 'Garut', 'Sumedang',
'Subang', 'Tasikmalaya', 'Purwokerto', 'Magelang', 'Semarang', 'Jogja',
'Surabaya', 'Malang'
])
#adjacency list city in Java
jarak = {
'Cilegon': {
'Tanggerang': 84
},
'Tanggerang': {
'Jakarta': 35,
'Cilegon': 84
},
'Jakarta': {
'Bogor': 54,
'Cikampek': 76,
'Bekasi': 50,
'Tanggerang': 35
},
'Bekasi': {
'Cikampek': 41,
'Jakarta': 50
},
'Cikampek': {
'Bandung': 80,
'Cirebon': 146,
'Jakarta': 76,
'Bekasi': 41
},
'Bogor': {
'Bandung': 182,
'Jakarta': 54
},
'Bandung': {
'Tasikmalaya': 124,
'Cimahi': 14,
'Cianjur': 67,
'Garut': 71,
'Sumedang': 76,
'Subang': 54,
'Cikampek': 80,
'Bogor': 182
},
'Tasikmalaya': {
'Purwokerto': 144,
'Bandung': 124,
'Garut': 53
},
'Cimahi': {
'Bandung': 14
},
'Cianjur': {
'Bandung': 67
},
'Garut': {
'Bandung': 71,
'Tasikmalaya': 53
},
'Sumedang': {
'Bandung': 76
},
'Subang': {
'Bandung': 54
},
'Purwokerto': {
'Magelang': 145,
'Tasikmalaya': 144
},
'Magelang': {
'Semarang': 72,
'Jogja': 53,
'Surabaya': 339,
'Purwokerto': 145
},
'Cirebon': {
'Tegal': 88,
'Cikampek': 146
},
'Tegal': {
'Semarang': 160,
'Cirebon': 88
},
'Semarang': {
'Jogja': 129,
'Surabaya': 348,
'Magelang': 72,
'Tegal': 160
},
'Jogja': {
'Surabaya': 324,
'Magelang': 53,
'Semarang': 129
},
'Surabaya': {
'Malang': 94,
'Magelang': 339,
'Semarang': 348,
'Jogja': 324
},
'Malang': {
'Surabaya': 94
}
}
finish = ' '
daftarkota(kota)
print('============================================')
print(
'Tulis nama kota asal dan tujuan anda dengan \nhuruf kapital pada huruf pertama (contohnya: Bekasi)'
)
print('-------------------------------------------')
print(
'Please write your departure city and destination with a capital letter in the first letter (example: Bekasi)'
)
start = input('Kota Anda Sekarang : ').strip()
start = start.lower()
start = ''.join(start[0].upper() + start[1:])
if start not in kota:
print(
'\n Format Nama Kota Yang Anda Masukkan Salah atau Tidak Terdaftar'
)
finish = input('Kota Tujuan Anda : ')
path = Greedy(jarak, start, finish)
print('Kota Asal = ', start)
if (path):
print('Urutan Kota Berdasar Algoritma Greedy : ', end='')
for i in path:
print(i, end='>')
else:
print('Tidak Ditemukan Jalan')
def try_all_approaches(num_of_samples: int, num_of_nodes: int):
"""
Execute all approaches on the same graphs for given number of nodes and samples (the more samples the more
statistically accurate results).
Returns: Achieved path lengths and execution times for all approaches.
"""
graph = Graph(0)
dfs = DFS(graph)
dfs_path_lengths = []
dfs_execution_times = []
bfs = BFS(graph)
bfs_path_lengths = []
bfs_execution_times = []
greedy = Greedy(graph)
greedy_path_lengths = []
greedy_execution_times = []
a_star_custom = AStarCustom(graph)
a_star_path_lengths = []
a_star_execution_times = []
for i in range(a_star_custom.num_of_heuristics):
a_star_path_lengths.append([])
a_star_execution_times.append([])
for j in range(num_of_samples):
graph = Graph(num_of_nodes)
starting_node = next(iter(graph.graph))
start = time.time()
dfs.graph = graph
paths_dfs = dfs.depth_first_search(starting_node)
dfs_path_lengths.append(Graph.get_shortest_path(paths_dfs)[1])
execution_time = time.time() - start
dfs_execution_times.append(execution_time)
start = time.time()
bfs.graph = graph
paths_bfs = bfs.breadth_first_search(starting_node)
bfs_path_lengths.append(Graph.get_shortest_path(paths_bfs)[1])
execution_time = time.time() - start
bfs_execution_times.append(execution_time)
start = time.time()
greedy.graph = graph
path_greedy = greedy.greedy_approach(starting_node)
greedy_path_lengths.append(Graph.calculate_path_length(path_greedy))
execution_time = time.time() - start
greedy_execution_times.append(execution_time)
for i in range(a_star_custom.num_of_heuristics):
start = time.time()
a_star_custom.graph = graph
a_star_custom.heuristic_choice = i
path_a_star = a_star_custom.a_star(starting_node)
execution_time = time.time() - start
a_star_path_lengths[i].append(
Graph.calculate_path_length(path_a_star))
a_star_execution_times[i].append(execution_time)
dfs_avg_results = sum(dfs_path_lengths) / num_of_samples, sum(
dfs_execution_times) / num_of_nodes, "DFS Recurrent"
bfs_avg_results = sum(bfs_path_lengths) / num_of_samples, sum(
bfs_execution_times) / num_of_nodes, "BFS"
greedy_avg_results = sum(greedy_path_lengths) / num_of_samples, sum(
greedy_execution_times) / num_of_nodes, "Greedy"
a_star_avg_results = []
for i in range(a_star_custom.num_of_heuristics):
label = "A* heuristic " + str(i)
a_star_avg_results.append(
(sum(a_star_path_lengths[i]) / num_of_samples,
sum(a_star_execution_times[i]) / num_of_samples, label))
data = [dfs_avg_results, bfs_avg_results, greedy_avg_results]
data.extend(a_star_avg_results)
return data
def solve_it(input_data):
lines = input_data.split('\n')
parts = lines[0].split()
facility_count = int(parts[0])
customer_count = int(parts[1])
facilities = []
for i in range(1, facility_count + 1):
parts = lines[i].split()
facilities.append(
Facility(i - 1, float(parts[0]), int(parts[1]),
Point(float(parts[2]), float(parts[3]))))
customers = []
for i in range(facility_count + 1, facility_count + 1 + customer_count):
parts = lines[i].split()
customers.append(
Customer(i - 1 - facility_count, int(parts[0]),
Point(float(parts[1]), float(parts[2]))))
# distance_matrix[i][j] is the distance between the i-th customer and the j-th facility.
distance_matrix = [[((customer.location.x - facility.location.x) ** 2 + (customer.location.y - facility.location.y) ** 2) ** 0.5 \
for facility in facilities] for customer in customers]
# distance_matrix_facilities[i][j] is the distance between the i-th facility and the j-th facility.
distance_matrix_facilities = [[((fa.location.x - fb.location.x) ** 2 + (fa.location.y - fb.location.y) ** 2) ** 0.5 \
for fb in facilities] for fa in facilities]
# distance_matrix_facilities_indice[i] contains the indice of the nearest facilities for the i-th facility.
distance_matrix_facilities_indice = [[i for i in range(len(facilities))]
for j in range(len(facilities))]
for i, row in enumerate(distance_matrix_facilities_indice):
row.sort(key=lambda x: distance_matrix_facilities[i][x])
# read initial solution generated by Guided Local Search.
objective_init, assignment_init = Greedy(customers, facilities)
best_objective = objective_init
best_assignment = assignment_init
best_facility_open = [0] * len(facilities)
for index in best_assignment:
best_facility_open[index] = 1
best_output = None
# number of facilities to form a sub-problem.
n_sub_facilities = 50
round_limit = 10000
for round in range(round_limit):
start_time = time.time()
# Randomly choose a facility and its top-n nearest neighbor facilities.
sub_facilities = np.random.choice(len(facilities))
sub_facilities = distance_matrix_facilities_indice[
sub_facilities][:n_sub_facilities]
sub_facilities_set = set(sub_facilities)
# Select all customers that are served by the above facilities.
sub_customers = [
i for i in range(len(customers))
if best_assignment[i] in sub_facilities_set
]
objective_old = 0.0
for customer in sub_customers:
objective_old += distance_matrix[customer][
best_assignment[customer]]
for facility in sub_facilities:
objective_old += best_facility_open[facility] * facilities[
facility].setup_cost
solver = pywraplp.Solver('SolveIntegerProblem',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
sub_assignment = [[
solver.IntVar(0.0, 1.0, 'a' + str(i) + ',' + str(j))
for j in range(len(sub_facilities))
] for i in range(len(sub_customers))]
sub_facility_open = [
solver.IntVar(0.0, 1.0, 'f' + str(j))
for j in range(len(sub_facilities))
]
# Constraint: each customer must be assigned to exactly one facility.
for i in range(len(sub_customers)):
solver.Add(
sum([sub_assignment[i][j]
for j in range(len(sub_facilities))]) == 1)
# Constraint: a customer must be assigned to an open facility.
for i in range(len(sub_customers)):
for j in range(len(sub_facilities)):
solver.Add(sub_assignment[i][j] <= sub_facility_open[j])
# Constraint: the capacity of each facility must not be exceeded.
for j in range(len(sub_facilities)):
solver.Add(sum([sub_assignment[i][j] * customers[sub_customers[i]].demand \
for i in range(len(sub_customers))]) <= facilities[sub_facilities[j]].capacity)
objective = solver.Objective()
# Objective: sum all the distance.
for i in range(len(sub_customers)):
for j in range(len(sub_facilities)):
objective.SetCoefficient(
sub_assignment[i][j],
distance_matrix[sub_customers[i]][sub_facilities[j]])
# Objective: sum all the setup cost.
for j in range(len(sub_facilities)):
objective.SetCoefficient(sub_facility_open[j],
facilities[sub_facilities[j]].setup_cost)
objective.SetMinimization()
"""Solve the problem and print the solution."""
SEC = 100
MIN = 60 * SEC
solver.SetTimeLimit(1 * MIN)
result_status = solver.Solve()
end_time = time.time()
if result_status != solver.OPTIMAL and result_status != solver.FEASIBLE:
print('[Round %9d/%9d] [N-Sub-Facilities %4d] [Best Objective %f] [Old Objective %f] [New Objective N/A] [Time %f]' % \
(round + 1, round_limit, n_sub_facilities, best_objective, objective_old, end_time - start_time))
continue
objective_new = solver.Objective().Value()
assignment_new = []
for i in range(len(sub_customers)):
for j in range(len(sub_facilities)):
if sub_assignment[i][j].solution_value() == 1:
assignment_new.append(sub_facilities[j])
break
print('[Round %9d/%9d] [N-Sub-Facilities %4d] [Best Objective %f] [Old Objective %f] [New Objective %f] [Time %f] %s' % \
(round + 1, round_limit, n_sub_facilities, best_objective, objective_old, objective_new, end_time - start_time, \
'best model found' if objective_old >= objective_new + 1 else ''))
if objective_old >= objective_new + 1:
best_objective -= objective_old - objective_new
for i, j in enumerate(assignment_new):
best_assignment[sub_customers[i]] = j
best_facility_open = [0] * len(facilities)
for index in best_assignment:
best_facility_open[index] = 1
best_output = str(best_objective) + ' ' + '0' + '\n' + ' '.join(
[str(assign) for assign in best_assignment])
with open("mip-output.txt", 'w') as best_mip_output_file:
best_mip_output_file.write(best_output)
return best_output
def what_to_run(self, wijk, algo, sec_algo, NoT, vis):
''' Kijkt welke variant van greedy'''
wijk = "wijk" + wijk
load = Load(wijk, wijk)
print()
print("INNITIAL UPPER & LOWERBOUND (before k-means and/or HAC)")
print()
print(wijk)
Solution.bounds(Solution, load.batteries, load.houses)
if algo == "random":
random = Random_connect(load.houses, load.batteries)
elif algo == "greedy_output":
greedy = Greedy(load.houses, load.batteries, "output")
elif algo == "greedy_distance":
greedy = Greedy(load.houses, load.batteries, "distance")
elif algo == "greedy_priority":
greedy = Greedy(load.houses, load.batteries, "priority")
elif algo == "k_means_output":
k_means = K_means2(load.houses, load.batteries, "output", "")
k_means.results()
elif algo == "k_means_distance":
k_means = K_means2(load.houses, load.batteries, "distance", "")
k_means.results()
elif algo == "k_means_priority":
k_means = K_means2(load.houses, load.batteries, "priority", "")
k_means.results()
elif algo == "HAC":
splitter = Cluster_merge(load.houses)
sec_algo = "escape"
grid_visualisatie = Grid_visualizer(splitter.houses, splitter.batteries, "gridview", "Hierarchical Agglomerative Clustering", splitter.solutions, splitter.best_solution)
else:
print("Error running algorithm")
if sec_algo == "hill_climber" and algo == "greedy_output" or sec_algo == "hill_climber" and algo == "greedy_distance" or sec_algo == "hill_climber" and algo == "greedy_priority":
hill_climber = Hill_climber(greedy.houses, greedy.batteries, NoT, 1)
if vis == 'True':
grid_visualisatie = Grid_visualizer(hill_climber.houses, hill_climber.batteries, "gridview", "Greedy + Hill Climber")
elif sec_algo == "hill_climber" and algo == "k_means_output" or sec_algo == "hill_climber" and algo == "k_means_distance" or sec_algo == "hill_climber" and algo == "k_means_priority":
hill_climber = Hill_climber(k_means.houses, k_means.batteries, NoT, 1)
if vis == 'True':
grid_visualisatie = Grid_visualizer(hill_climber.houses, hill_climber.batteries, "gridview", "K-Means + Hill Climber")
elif sec_algo == "simulated_annealing" and algo == "greedy_output" or sec_algo == "simulated_annealing" and algo == "greedy_distance" or sec_algo == "simulated_annealing" and algo == "greedy_priority":
sim = Simulated_annealing(greedy.houses, greedy.batteries, NoT, 1)
if vis == 'True':
grid_visualisatie = Grid_visualizer(sim.houses, sim.batteries, "gridview", "Greedy + Simulated Annealing")
elif sec_algo == "simulated_annealing" and algo == "k_means_output" or sec_algo == "simulated_annealing" and algo == "k_means_distance" or sec_algo == "simulated_annealing" and algo == "k_means_priority":
sim = Simulated_annealing(k_means.houses, k_means.batteries, NoT, 1)
if vis == 'True':
grid_visualisatie = Grid_visualizer(sim.houses, sim.batteries, "gridview", "K-Means + Simulated Annealing")
elif sec_algo == "simulated_annealing" and algo == "HAC":
sim = Simulated_annealing(splitter.houses, splitter.batteries, NoT, 1)
if vis == 'True':
grid_visualisatie = Grid_visualizer(splitter.houses, splitter.batteries, "gridview", "Hierarchical Agglomerative Clustering", splitter.solutions, splitter.best_solution)
elif sec_algo == "hill_climber" and algo == "HAC":
sim = Hill_climber(splitter.houses, splitter.batteries, NoT, 1)
if vis == 'True':
grid_visualisatie = Grid_visualizer(splitter.houses, splitter.batteries, "gridview", "Hierarchical Agglomerative Clustering", splitter.solutions, splitter.best_solution)
elif sec_algo == "escape":
pass
else:
print("Error running secondary algorithm")
from backtracking import Backtracking
from breadth import Breadth
from greedy import Greedy
from graph import Graph
from insert import GraphPopulator
import time
if __name__ == '__main__':
# graph = Graph('all')
# populator = GraphPopulator(graph)
# populator.insert()
# backtracking = Backtracking(graph)
# backtracking.run()
graph = Graph('north')
populator = GraphPopulator(graph)
populator.insert_north()
# breadth = Breadth(graph)
# breadth.breadth()
greedy = Greedy(graph)
greedy.greedy()
# graph.print_graph_with_colors()
from greedy import Greedy
from annealing import Annealing
# A call to initialize an instance of the network class
# will create a new map with new cities
# change the N parameter to adjust how many cities appear, annealer does better with fewer
n = Network(N=15)
# Calls the greedy and annealer algorithms on the network created in the above block.
# Visualizes results for comparison.
print("Greedy")
g = Greedy(n)
g.run()
n.draw_route(g.route, text=" - Greedy")
print()
print("Annealing")
a = Annealing(
n, T=50,
c=0.9995) # larger T means more time exploring and less time descending
# If you make T much bigger, add more nines to c so you
# don't get a zero division error
a.run(n_times=12000) # can be slow
n.draw_route(a.route, text=" - Annealing")
a.score_plot()
#!/usr/bin/env python
from greedy import Greedy
from stabu_search import SimpleTabooSearch
from simulated_annealing import SimulatedAnnealing
from ant_colony import AntColony
# Generate simple example
from helpers import gen_dists, compute_cost, gen_random
#dists1 = gen_dists([(0,0), (-4,0), (1,4), (3,4), (3,2), (8,-6), (-2,-3), (-4,-3)])
dists1 = gen_dists(gen_random(128))
#print(dists1)
# example usage of greedy algorithm sovle
greedy = Greedy(dists1)
g_sol = greedy.solve()
print("GREEDY SOLUTION:\t\t\t"+str(g_sol)+" ---> " + str(greedy.cost))
# example usage of SimpleTabooSearch find solution at once
sts = SimpleTabooSearch(dists1)
sts_sol = sts.solve()
print("SIMPLE TABOO SEARCH SOLUTION:\t\t"+ str(sts_sol)+ " ---> "+ str(sts.cost))
san = SimulatedAnnealing(dists1,g_sol)
san_sol = san.solve()
print("GREEDY - SIMULATED ANNEALING SOLUTION:\t\t"+ str(san_sol)+ " ---> "+ str(san.cost))
san2 = SimulatedAnnealing(dists1,sts_sol)
san_sol2 = san2.solve()
print("SIMPLE TABOO - SIMULATED ANNEALING SOLUTION:\t\t"+ str(san_sol2)+ " ---> "+ str(san2.cost))
def dqn_evaluation(player, dqn, nb_episodes):
player.reset_battles()
dqn.test(player, nb_episodes=nb_episodes, visualize=False, verbose=False)
print(
"DQN Evaluation: %d victories out of %d episodes"
% (player.n_won_battles, nb_episodes)
)
def create_model(n_action=None,load=None):
if load is not None:
pass
if __name__=='__main__':
env_player = SimpleRLPlayer(battle_format="gen8randombattle")
opponent = Greedy(battle_format="gen8randombattle")
# Output dimension
n_action = len(env_player.action_space)
model = Sequential()
model.add(Dense(128, activation="elu", input_shape=(1, 10)))
# Our embedding have shape (1, 10), which affects our hidden layer
# dimension and output dimension
# Flattening resolve potential issues that would arise otherwise
model.add(Flatten())
model.add(Dense(64, activation="elu"))
model.add(Dense(n_action, activation="linear"))
memory = SequentialMemory(limit=10000, window_length=1)
async def main():
player = Greedy(player_configuration=PlayerConfiguration('a very greedy bot', 'password'),
server_configuration=ShowdownServerConfiguration
)
await player.accept_challenges(None, 10)
def main():
print('============================================')
print(
'This program shows cities that can be visited \nSo by using this program you can get some cities for stop by \nor multiply your destination for your trip\n'
)
print('-------------------------------------------')
print(
' \non your family trip and help you to get the list of cities that have shortest distance between them.\n'
)
print('============================================')
print('Here the list of the cities that we provide:\n')
#List Kota
kota = set([
'Cilegon', 'Tangerang', 'Jakarta', 'Bogor', 'Cikampek', 'Bekasi',
'Bandung', 'Cirebon', 'Cimahi', 'Cianjur', 'Garut', 'Sumedang',
'Subang', 'Tasikmalaya', 'Purwokerto', 'Magelang', 'Semarang', 'Jogja',
'Surabaya', 'Malang'
])
#adjacency list city in Java
jarak = {
'Cilegon': {
'Tanggerang': 84
},
'Tanggerang': {
'Jakarta': 35,
'Cilegon': 84
},
'Jakarta': {
'Bogor': 54,
'Cikampek': 76,
'Bekasi': 50,
'Tanggerang': 35
},
'Bekasi': {
'Cikampek': 41,
'Jakarta': 50
},
'Cikampek': {
'Bandung': 80,
'Cirebon': 146,
'Jakarta': 76,
'Bekasi': 41
},
'Bogor': {
'Bandung': 182,
'Jakarta': 54
},
'Bandung': {
'Tasikmalaya': 124,
'Cimahi': 14,
'Cianjur': 67,
'Garut': 71,
'Sumedang': 76,
'Subang': 54,
'Cikampek': 80,
'Bogor': 182
},
'Tasikmalaya': {
'Purwokerto': 144,
'Bandung': 124,
'Garut': 53
},
'Cimahi': {
'Bandung': 14
},
'Cianjur': {
'Bandung': 67
},
'Garut': {
'Bandung': 71,
'Tasikmalaya': 53
},
'Sumedang': {
'Bandung': 76
},
'Subang': {
'Bandung': 54
},
'Purwokerto': {
'Magelang': 145,
'Tasikmalaya': 144
},
'Magelang': {
'Semarang': 72,
'Jogja': 53,
'Surabaya': 339,
'Purwokerto': 145
},
'Cirebon': {
'Tegal': 88,
'Cikampek': 146
},
'Tegal': {
'Semarang': 160,
'Cirebon': 88
},
'Semarang': {
'Jogja': 129,
'Surabaya': 348,
'Magelang': 72,
'Tegal': 160
},
'Jogja': {
'Surabaya': 324,
'Magelang': 53,
'Semarang': 129
},
'Surabaya': {
'Malang': 94,
'Magelang': 339,
'Semarang': 348,
'Jogja': 324
},
'Malang': {
'Surabaya': 94
}
}
finish = ' '
daftarkota(kota)
print('============================================')
print(
'Please write your departure city and destination with a capital letter in the first letter (example: Bekasi)'
)
print('-------------------------------------------')
start = input('Your Current City : ').strip()
start = start.lower()
start = ''.join(start[0].upper() + start[1:])
if start not in kota:
print(
'\n The Format Name of City You Enter is Incorrect or Unregistered'
)
finish = input('Your Destination City : ')
path = Greedy(jarak, start, finish)
print('Current City = ', start)
if (path):
print('City Order Based On Algoritma Greedy : ', end='')
for i in path:
print(i, end=' -> ')
else:
print('Path Not Found')
best_nodice = [0, None]
for choice in values:
if choice[0] > best_choice[0] and choice[1] > self.n_dice:
best_choice = choice
elif choice[0] > best_nodice[0]:
best_nodice[0] = choice[0]
if best_choice[0] == 0: # Never updated
return best_nodice
return best_choice
### We'll make some basic strategies
if __name__ == "__main__":
gd = Greedy(num_dice=NUM_DICE)
al500 = DiceBasic(2)
al250 = RealBasic(200)
best_game = ['', 1000]
best_values = []
wins = {al500.name: 0, al250.name: 0}
num_turns = 0
for game_num in range(50000):
print("GAMES :: {}".format(wins), end='\r')
current_points = {al500.name: 0, al250.name: 0}
has_won = False
this_game = 0
these_values1 = []
these_values2 = []
def clustering(self, houses, batteries, counter):
''' Use K-means to cluster and assign houses to batteries '''
# count clustering iterations
counter += 1
# capacitated clustering
greedy = Greedy(houses, batteries, self.greedy)
houses = copy.deepcopy(greedy.houses)
batteries = copy.deepcopy(greedy.batteries)
# Save solution
solution = Solution(copy.deepcopy(houses), copy.deepcopy(batteries))
self.solutions.append(solution)
for battery in batteries:
houses = Sort.distance(Sort, houses, battery)
# calculate cable costs
cable_costs = Helper.houses_costs(Helper, batteries, houses)
battery_costs = 0
for battery in batteries:
battery_costs += battery.cost
costs = cable_costs + battery_costs
# for each cluster, new centre = means of all connected houses coördinates
for battery in batteries:
x = 0
y = 0
count = 0
for house in battery.connected:
x += house.x
y += house.y
count += 1
# Avoid dividing by zero battery is not connected to any house (HAC)
if count != 0:
# average
mean_x = round(x / count)
mean_y = round(y / count)
# new centre
battery.x = mean_x
battery.y = mean_y
# Stops when costs haven't changed
if costs < self.costs:
self.costs = costs
# disconnect
for battery in batteries:
battery.connected = []
battery.current_usage = 0
for house in houses:
house.connected = False
house.connection = False
house.costs = 0
# --> Solution
self.batteries = batteries
self.houses = houses
# try again
self.clustering(houses, batteries, counter)
else:
pass
def genetic(self):
#init
ga = Greedy(self.cities_matrix, self.tourlength)
initial = ga.greedy_algorithm()
current_pop = []
for i in range(100):
baby = initial[:]
#swap a few in initial
if random.random() < 0.95:
baby = self.rnd_swap(baby)
if random.random() < 0.7:
baby = self.rnd_swap(baby)
if random.random() < 0.4:
baby = self.rnd_swap(baby)
#current.shuffle()#shuffle to a certain degree
# current = random.sample(range(1, tourlength + 1), tourlength)
current_pop.append((baby, self.tour_length(baby)))
# print("currentpopppppp"+str(len(current_pop)))
min_length = min(list(map(lambda x: x[1], current_pop)))
curr_best = list(filter(lambda x: x[1] == min_length, current_pop))[0]
# print(curr_best)
########################
new_best = curr_best[:]
checker = 0
new_pop = []
while checker < 20: #while not(max fitness hasn't improved in x generations)
for i in range(100):
parents = self.select_parents(current_pop)
dad, mum = parents[0], parents[1]
#SPLICE
rand_index = random.randint(0, self.tourlength - 1)
#take the prefix of dad and add the suffix of mum
child_with_duplicates = dad[0][:rand_index] + mum[0][
rand_index:]
#MUTATE
for j in range(len(child_with_duplicates)):
#for city in child_with_duplicates:
if random.random(
) < 0.01: #with a 1% chance randomly mutate each city
#city = random.sample(range(1, tourlength + 1), tourlength)[0]
child_with_duplicates[j] = random.randint(
1, self.tourlength)
#make a set of all the cities not included
not_included = [x for x in range(1, self.tourlength + 1)]
for c in child_with_duplicates:
if c in not_included:
not_included.remove(c)
random.shuffle(not_included)
#check over for repetitions, if there is: add the first from the set
child = []
for c in child_with_duplicates:
if c in child:
child.append(not_included[0])
not_included.pop(0)
else:
child.append(c)
#add child to current_pop[i]
new_pop.append((child, self.tour_length(child)))
current_pop = new_pop
new_pop = []
min_length = min(list(map(lambda x: x[1], current_pop)))
new_best = list(filter(lambda x: x[1] == min_length,
current_pop))[0]
# print("new_best: " + str(new_best[1]) + "curr_best: " + str(curr_best[1]))
# print("curr_best[1] > new_best[1] : " + str(curr_best[1] > new_best[1]))
########################
if curr_best[1] > new_best[1]:
curr_best = new_best
checker == 0
elif curr_best[1] == new_best[1]:
checker += 1
# else :
# checker == 0
# print("new_best: " + str(new_best[1]))
# print("Fittest in generation: " + str(curr_best[0]))
# print("Length: " + str(curr_best[1]))
# print("checker:" + str(checker))
return curr_best[0]
def graphMaker():
#Initializing lists
nonHeap_x = []
nonHeap_y = []
heap_x = []
heap_y = []
#For 8 files 0 through 8
for i in range(9):
#Initialize
weights_list = []
values_list = []
heap_weight = []
heap_values = []
used_vals = []
used_Heapvals = []
#Reopening and initailizing files
c_file = "./KnapsackTestData/p0" + str(i) + "_c.txt"
w_file = "./KnapsackTestData/p0" + str(i) + "_w.txt"
v_file = "./KnapsackTestData/p0" + str(i) + "_v.txt"
#Capacity
file = open(c_file)
maxCap = int(file.readline())
file.close()
#Weights
file = open(w_file)
for line in file:
weights_list.append(int(line))
heap_weight.append(int(line))
file.close()
#Values
file = open(v_file)
for line in file:
values_list.append(int(line))
heap_values.append(int(line))
file.close()
#Greedy non heap
greedyClass = Greedy()
greedyClass.quickSort(0,
len(values_list) - 1, values_list, weights_list)
greedyClass.greedyApproach(values_list, maxCap, weights_list,
used_vals)
greedyOps = greedyClass.greedyOperations
nonHeap_x.append(len(values_list))
nonHeap_y.append(greedyOps)
#Greedy heap
heapClass = Heap()
heapClass.heapSort(heap_values, heap_weight, len(heap_values))
heapClass.heapApproach(heap_values, heap_weight, maxCap, used_Heapvals)
heapGredOps = heapClass.heapOperations
heap_x.append(len(values_list))
heap_y.append(heapGredOps)
#Printing the two graphs one by one.
print("Printing Non-Heap Greedy")
plt.title("Greedy Non-Heap")
plt.xlabel("n")
plt.ylabel("Time (B-ops)")
plt.plot(nonHeap_x, nonHeap_y, 'bo')
plt.show()
print("Printing Heap Greedy")
plt.title("Heap Greedy")
plt.xlabel("n")
plt.ylabel("Time (B-ops)")
plt.plot(heap_x, heap_y, 'go')
plt.show()
[visited_steep1, visited_gre1, visited_steep2, visited_gre2])
return np.array(all_distance), np.array(all_visited), np.array(all_time)
def statistic(all_distance):
best = all_distance.argmin(axis=0)
mean = all_distance.mean(axis=0)
worst = all_distance.max(axis=0)
return best, worst, mean
matrixA, coordsA = prepare_coords_and_matrix(pathA)
matrixB, coordsB = prepare_coords_and_matrix(pathB)
steep = Steepest()
gre = Greedy()
all_distanceA, all_visitedA, all_timeA = do(matrixA, steep, gre, coordsA)
all_distanceB, all_visitedB, all_timeB = do(matrixB, steep, gre, coordsB)
best, worst, mean = statistic(all_distanceA)
bestT, worstT, meanT = statistic(all_timeA)
print("Best distances for korA100:")
print("Steepest Vert | Greedy Vert | Steepest Edges | Greedy Edges")
print(all_distanceA[best[0]][0], " ", all_distanceA[best[1]][1],
" ", all_distanceA[best[2]][2], " ",
all_distanceA[best[3]][3])
print("Worst distances for kroA100:")
print("Steepest Vert | Greedy Vert | Steepest Edges | Greedy Edges")
print(worst[0], " ", worst[1], " ", worst[2],
" ", worst[3])
print("Means distances for kroA100:")
def solve_it(input_data):
# Modify this code to run your optimization algorithm
# parse the input
lines = input_data.split('\n')
parts = lines[0].split()
facility_count = int(parts[0])
customer_count = int(parts[1])
facilities = []
for i in range(1, facility_count + 1):
parts = lines[i].split()
facilities.append(
Facility(i - 1, float(parts[0]), int(parts[1]),
Point(float(parts[2]), float(parts[3]))))
customers = []
for i in range(facility_count + 1, facility_count + 1 + customer_count):
parts = lines[i].split()
customers.append(
Customer(i - 1 - facility_count, int(parts[0]),
Point(float(parts[1]), float(parts[2]))))
# distance_matrix[i][j] is the distance between the i-th customer and the j-th facility.
distance_matrix = [[((customer.location.x - facility.location.x) ** 2 + (customer.location.y - facility.location.y) ** 2) ** 0.5 \
for facility in facilities] for customer in customers]
# read initial solution generated by Guided Local Search.
objective_init, assignment_init = Greedy(customers, facilities)
best_objective = objective_init
best_assignment = assignment_init
best_non_empty_facilities_set = set([assign for assign in best_assignment])
best_non_empty_facilities = [
facility for facility in best_non_empty_facilities_set
]
best_empty_facilities = [
facility for facility in range(len(facilities))
if facility not in best_non_empty_facilities_set
]
best_facility_open = [0] * len(facilities)
for index in best_assignment:
best_facility_open[index] = 1
best_output = None
#-------------------------------------------------------------------------------------------------------------------
#-------------------------------------------------------------------------------------------------------------------
# number of open facilities in the sub-problem
n_non_empty_sub_facilities = 3
# number of closed facilities in the sub-problem
n_empty_sub_facilities = 10
# number of facilities in the sub-problem
n_sub_facilities = n_non_empty_sub_facilities + n_empty_sub_facilities
round_limit = 10000000
for round in range(round_limit):
has_improvement = False
while True:
# for sub_facilities in itertools.combinations(range(len(facilities)), n_sub_facilities):
start_time = time.time()
# Randomly sample n_non_empty_sub_facilities facilities from open facilities
sub_facilities_a = np.random.choice(best_non_empty_facilities,
n_non_empty_sub_facilities,
replace=False)
# Randomly sample n_non_empty_sub_facilities facilities from closed facilities
sub_facilities_b = np.random.choice(best_empty_facilities,
n_empty_sub_facilities,
replace=False)
# merge the above two groups of facilities
sub_facilities = np.append(sub_facilities_a, sub_facilities_b)
sub_facilities_set = set(sub_facilities)
# Select all customers that are served by the above facilities.
sub_customers = [
i for i in range(len(customers))
if best_assignment[i] in sub_facilities_set
]
objective_old = 0.0
for customer in sub_customers:
objective_old += distance_matrix[customer][
best_assignment[customer]]
for facility in sub_facilities:
objective_old += best_facility_open[facility] * facilities[
facility].setup_cost
solver = pywraplp.Solver(
'SolveIntegerProblem',
pywraplp.Solver.CBC_MIXED_INTEGER_PROGRAMMING)
sub_assignment = [[
solver.IntVar(0.0, 1.0, 'a' + str(i) + ',' + str(j))
for j in range(len(sub_facilities))
] for i in range(len(sub_customers))]
sub_facility_open = [
solver.IntVar(0.0, 1.0, 'f' + str(j))
for j in range(len(sub_facilities))
]
# Constraint: each customer must be assigned to exactly one facility.
for i in range(len(sub_customers)):
solver.Add(
sum([
sub_assignment[i][j]
for j in range(len(sub_facilities))
]) == 1)
# Constraint: a customer must be assigned to an open facility.
for i in range(len(sub_customers)):
for j in range(len(sub_facilities)):
solver.Add(sub_assignment[i][j] <= sub_facility_open[j])
# Constraint: the capacity of each facility must not be exceeded.
for j in range(len(sub_facilities)):
solver.Add(sum([sub_assignment[i][j] * customers[sub_customers[i]].demand \
for i in range(len(sub_customers))]) <= facilities[sub_facilities[j]].capacity)
objective = solver.Objective()
# Objective: sum all the distance.
for i in range(len(sub_customers)):
for j in range(len(sub_facilities)):
objective.SetCoefficient(
sub_assignment[i][j],
distance_matrix[sub_customers[i]][sub_facilities[j]])
# Objective: sum all the setup cost.
for j in range(len(sub_facilities)):
objective.SetCoefficient(
sub_facility_open[j],
facilities[sub_facilities[j]].setup_cost)
objective.SetMinimization()
"""Solve the problem and print the solution."""
SEC = 1000
MIN = 60 * SEC
solver.SetTimeLimit(1 * MIN)
result_status = solver.Solve()
end_time = time.time()
if result_status != solver.OPTIMAL and result_status != solver.FEASIBLE:
print('[Round %9d/%9d] [N-Sub-Facilities %4d] [Best Objective %f] [Old Objective %f] [New Objective N/A] [Time %f]' % \
(round + 1, round_limit, n_sub_facilities, best_objective, objective_old, end_time - start_time))
continue
objective_new = solver.Objective().Value()
assignment_new = []
for i in range(len(sub_customers)):
for j in range(len(sub_facilities)):
if sub_assignment[i][j].solution_value() == 1:
assignment_new.append(sub_facilities[j])
break
print('[Round %9d/%9d] [N-Sub-Facilities %4d] [Best Objective %f] [Old Objective %f] [New Objective %f] [Time %f] %s' % \
(round + 1, round_limit, n_sub_facilities, best_objective, objective_old, objective_new, end_time - start_time, \
'best model found' if objective_old >= objective_new + 1 else ''))
if objective_old >= objective_new + 1:
best_objective -= objective_old - objective_new
for i, j in enumerate(assignment_new):
best_assignment[sub_customers[i]] = j
best_non_empty_facilities_set = set(
[assign for assign in best_assignment])
best_non_empty_facilities = [
facility for facility in best_non_empty_facilities_set
]
best_empty_facilities = [
facility for facility in range(len(facilities))
if facility not in best_non_empty_facilities_set
]
best_facility_open = [0] * len(facilities)
for index in best_assignment:
best_facility_open[index] = 1
best_output = str(
best_objective) + ' ' + '0' + '\n' + ' '.join(
[str(assign) for assign in best_assignment])
with open("mip-output.txt", 'w') as best_mip_output_file:
best_mip_output_file.write(best_output)
has_improvement = True
if not has_improvement:
n_sub_facilities += 1
return best_output
