def test_threshold(self): p = Prim(TestPrimInitMethod.df, lambda x: x["x1"] * x["x2"] + 0.3 * x["x3"] > 0.5) box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def test_threshold(self): p = Prim(TestPrimInitMethod.df, lambda x : x["x1"]*x["x2"] + 0.3*x["x3"] > 0.5) box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def test_init_numpy(self): df = TestPrimInitMethod.df.to_records(index=False) response = TestPrimInitMethod.response.values p = Prim(df, response, threshold=0.5, threshold_type=">") box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def setUpClass(cls): cls.df = pd.DataFrame(np.random.rand(1000, 3), columns=["x1", "x2", "x3"]) cls.response = cls.df["x1"] * cls.df["x2"] + 0.3 * cls.df["x3"] p = Prim(cls.df, cls.response, threshold=0.5, threshold_type=">") box = p.find_box() cls.expected_output = str(box)
def setUpClass(cls): cls.df = pd.DataFrame(np.random.rand(1000, 3), columns=["x1", "x2", "x3"]) cls.response = cls.df["x1"]*cls.df["x2"] + 0.3*cls.df["x3"] p = Prim(cls.df, cls.response, threshold=0.5, threshold_type=">") box = p.find_box() cls.expected_output = str(box)
def test_function(self): p = Prim(TestPrimInitMethod.df, lambda x : x["x1"]*x["x2"] + 0.3*x["x3"], threshold=0.5, threshold_type=">") box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def test_string(self): df = copy.deepcopy(TestPrimInitMethod.df) df["y"] = df["x1"]*df["x2"] + 0.3*df["x3"] p = Prim(df, "y", threshold=0.5, threshold_type=">") box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def test_string(self): df = copy.deepcopy(TestPrimInitMethod.df) df["y"] = df["x1"] * df["x2"] + 0.3 * df["x3"] p = Prim(df, "y", threshold=0.5, threshold_type=">") box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def test_function(self): p = Prim(TestPrimInitMethod.df, lambda x: x["x1"] * x["x2"] + 0.3 * x["x3"], threshold=0.5, threshold_type=">") box = p.find_box() output = str(box) self.assertEqual(output, TestPrimInitMethod.expected_output)
def get_output_shared(config1): """Generate output in desired format given a configuration. Take into account that grid lines can be shared. """ prim = Prim(config1.batteries) output = [] for j, mst in enumerate(prim.mst_container): battery = config1.batteries[j] battery_info = { "locatie": f"{battery.x},{battery.y}", "capaciteit": f"{battery.real_capacity}", "huizen": [] } for branch in mst.keys(): x, y = branch.path kabels = [] for i in range(len(x)): coordinate = f"({x[i]},{y[i]})" kabels.append(coordinate) kabels.reverse() for house in config1.district: if (house.x, house.y) == (branch.end_x, branch.end_y): output = house.power break house_info = { "locatie": f"{branch.end_x},{branch.end_y}", "output": f"{output}", "kabels": kabels } battery_info["huizen"].append(house_info) output.append(battery_info) return output
def get_costs(self): """ Get costs for current configuration depending on grid sharing possibilities. """ costs = 0 if self.share_grid == False: for battery in self.batteries: for house in battery.houses: costs += (abs(house.x - battery.x) + abs(house.y - battery.y)) * 9 costs += battery.costs self.all_costs.append(costs) else: prim = Prim(self.batteries) for battery in self.batteries: costs += battery.costs self.all_costs.append(prim.costs + costs)
def test_categorical_paste(self): dtype = [('a', np.float), ('b', np.object)] x = np.empty((10, ), dtype=dtype) x['a'] = np.random.rand(10, ) x['b'] = ['a', 'b', 'a', 'b', 'a', 'a', 'b', 'a', 'b', 'a'] y = np.random.randint(0, 2, (10, )) y = y.astype(np.int) prim_obj = Prim(x, y, threshold=0.8) box_lims = np.array([(0, set(['a'])), (1, set(['a']))], dtype=dtype) yi = np.where(x['b'] == 'a') box = PrimBox(prim_obj, box_lims, yi) u = 'b' pastes = categorical_paste(prim_obj, box, u) self.assertEquals(len(pastes), 1) for paste in pastes: indices, box_lims = paste self.assertEquals(indices.shape[0], 10) self.assertEqual(box_lims[u][0], set(['a', 'b']))
def test_drop_restriction(self): x = np.array([(0, 1, 2), (2, 5, 6), (3, 2, 1)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) y = np.array([1, 1, 0]) prim_obj = Prim(x, y, threshold=0.8) box = PrimBox(prim_obj, prim_obj._box_init, prim_obj.yi) new_box_lim = np.array([(0, 1, 1), (2, 2, 6)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) indices = np.array([0, 1], dtype=np.int) box.update(new_box_lim, indices) box.drop_restriction('b') correct_box_lims = np.array([(0, 1, 1), (2, 5, 6)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) box_lims = box._box_lims[-1] names = recfunctions.get_names(correct_box_lims.dtype) for entry in names: lim_correct = correct_box_lims[entry] lim_box = box_lims[entry] for i in range(len(lim_correct)): self.assertEqual(lim_correct[i], lim_box[i]) self.assertEqual(box.peeling_trajectory['mean'][2], 1) self.assertEqual(box.peeling_trajectory['coverage'][2], 1) self.assertEqual(box.peeling_trajectory['density'][2], 1) self.assertEqual(box.peeling_trajectory['res dim'][2], 1) self.assertEqual(box.peeling_trajectory['mass'][2], 2 / 3)
def test(): # str2d = """ # 0 1 3 0 0 2 # 1 0 5 1 0 0 # 3 5 0 2 1 0 # 0 1 2 0 4 0 # 0 0 1 4 0 5 # 2 0 0 0 5 0 # """ str2d = """ 0 8 6 1 4 0 8 5 1 2 7 6 1 4 4 3 3 2 1 2 8 0 6 5 1 5 8 3 2 0 1 5 2 0 1 1 2 7 5 3 6 6 0 4 8 1 8 4 7 8 8 2 4 0 3 6 4 7 8 0 1 5 4 0 3 5 0 8 0 3 2 2 1 2 6 0 7 0 6 3 4 1 8 3 0 0 4 2 0 4 1 0 5 4 8 5 0 1 4 2 0 5 1 5 0 0 4 0 7 8 0 0 4 6 5 1 1 3 3 0 8 8 8 0 4 4 0 3 8 1 2 0 1 6 6 3 5 7 1 7 5 3 4 8 2 0 3 0 8 7 5 6 5 5 3 7 1 6 0 6 1 2 7 0 0 7 8 8 0 4 2 6 5 1 4 6 0 3 5 8 2 0 8 3 4 8 1 7 4 0 6 2 6 2 3 8 0 3 6 7 7 1 8 2 1 0 2 5 2 6 0 1 8 1 7 0 3 3 4 3 6 5 2 2 0 0 0 6 6 2 1 0 2 4 2 4 8 4 5 3 1 2 4 1 5 4 1 5 5 6 8 2 0 8 5 1 7 1 4 0 4 0 0 2 4 6 6 5 1 2 1 4 8 0 6 7 4 6 6 0 4 1 3 6 8 5 6 3 4 3 7 2 5 6 0 6 4 8 4 6 3 1 6 0 5 1 3 7 6 8 0 4 1 7 6 0 4 5 2 8 3 2 4 7 0 1 5 1 0 0 3 8 7 4 4 4 0 6 4 1 2 7 7 0 1 3 7 6 3 3 3 4 1 6 8 5 6 0 5 3 1 5 8 6 4 3 1 0 5 6 4 5 4 6 4 2 4 5 0 4 2 3 0 3 2 0 7 6 8 7 3 3 0 0 6 8 1 3 4 0 """ # str2d = """ # 0 2 0 6 0 # 2 0 3 8 5 # 0 3 0 0 7 # 6 8 0 0 9 # 0 5 7 9 0 # """ # ==== prepare data ==== rows = Utils.array2dFromStr(str2d) matrix = Matrix(rows) # print matrix.toString() # print matrix.hasEdge(1, 5) # print matrix.getWeight(3, 4) Prim.sequential(matrix)
def test_init(self): x = np.array([(0, 1, 2), (2, 5, 6), (3, 2, 1)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) y = np.array([0, 1, 2]) prim_obj = Prim(x, y, threshold=0.8) box = PrimBox(prim_obj, prim_obj._box_init, prim_obj.yi) self.assertTrue(box.peeling_trajectory.shape == (1, 5))
def make_plot(self, results_directory, optimization): """ Make plot based on given configuration and whether or not grid lines can be shared. """ figure_name = f"{self.type}_{self.district_nr}_{optimization}" colors = ['yellowgreen', 'yellow', 'violet', 'tomato', 'turquoise', 'sienna', 'blue', 'pink', 'teal', 'tan'] plt.figure() for battery in self.batteries: plt.plot(battery.x, battery.y, 'H', color=colors[battery.id - 1]) for house in battery.houses: plt.plot(house.x, house.y, 'k*') costs = 0 if self.share_grid == False: self.get_routes() i = 0 for battery in self.batteries: for x, y in self.routes[battery]: plt.plot(x, y, colors[i]) i += 1 for battery in self.batteries: for house in battery.houses: costs += (abs(house.x - battery.x) + abs(house.y - battery.y)) * 9 costs += battery.costs plt.title(f"Total costs:{costs}") else: i = 0 prim = Prim(self.batteries) for battery in self.batteries: costs += battery.costs for mst in prim.mst_container: for branch in mst.keys(): plt.plot(branch.path[0], branch.path[1], colors[i]) i += 1 plt.title(f"Total costs: {prim.costs + costs}") plt.xlim(-2, 55) plt.ylim(-2, 55) plt.savefig(results_directory + figure_name) plt.show()
def _prim(): # node: [(adjacent_node, cost)] graph = { 0: [(1,1), (2,2), (3,1), (4,1), (5,2), (6,1)], 1: [(0,1), (2,2), (6,2)], 2: [(0,2), (1,2), (3,1)], 3: [(0,1), (2,1), (4,2)], 4: [(0,1), (3,2), (5,2)], 5: [(0,2), (4,2), (6,1)], 6: [(0,1), (2,2), (5,1)] } g1 = Prim(0, graph) cost = g1.prim() print(cost)
def Otree(graph_ini, position=0, choice='Prim'): """Retourne un 1-tree de cout minimal.""" # les paremetres sont initialise cost_1 = float('inf') # cout modifie 1 cost_2 = float('inf') # cout modifie 1 real_1 = float('inf') # cout reel de l arete 1 real_2 = float('inf') # cout reel de l arete 2 key_1 = None # autre noeud de l arete 1 key_2 = None # autre noeud de l arete 2 G = deepcopy(graph_ini) # une copie du graphe original est faite mat = G.mat_adj # Les deux arretes de poids modifies minimales incidentes au noeud choisi # seront sauvegardes pour le 1-tree for node in G.get_neighbors(G.nodes[position]): if cost_1 > mat[G.nodes[position]][node].get_vcost(): # v cost_2 = deepcopy(cost_1) real_2 = deepcopy(real_1) key_2 = node cost_1 = deepcopy(mat[G.nodes[position]][node].get_vcost()) # v real_1 = deepcopy(mat[G.nodes[position]][node].cost) key_1, key_2 = key_2, key_1 elif cost_2 > mat[G.nodes[position]][node].get_vcost(): # v cost_2 = deepcopy(mat[G.nodes[position]][node].get_vcost()) # v real_2 = deepcopy(mat[G.nodes[position]][node].cost) key_2 = node # le noeud choisi est efface G.delete_node(G.nodes[position]) new_node = deepcopy(graph_ini.nodes[position]) # un arbre de recouvrement est fait selon le choix de lutilisateur if str.lower(choice) == 'kruskal': One_tree = Kruskal(G) elif str.lower(choice) == 'prim': if position >= len(G.nodes): position = len(G.nodes) - 1 One_tree = Prim(G, G.nodes[position]) # le noeud efface est rajoute au 1-tree One_tree[1].add_node(new_node) node_OT = One_tree[1].nodes for node in node_OT: if node.get_id() == key_1.get_id(): key_1 = node elif node.get_id() == key_2.get_id(): key_2 = node # les deux aretes minimales sont rajoute au 1-tree pour finir sa creation One_tree[1].add_edge(Edge(start=new_node, end=key_1, cost=real_1)) One_tree[1].add_edge(Edge(start=new_node, end=key_2, cost=real_2)) # le cout modifier ainsi que le graphe sont retourne return One_tree[1], One_tree[1].get_vcost()
def test_select(self): x = np.array([(0, 1, 2), (2, 5, 6), (3, 2, 1)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) y = np.array([1, 1, 0]) prim_obj = Prim(x, y, threshold=0.8) box = PrimBox(prim_obj, prim_obj._box_init, prim_obj.yi) new_box_lim = np.array([(0, 1, 1), (2, 5, 6)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) indices = np.array([0, 1], dtype=np.int) box.update(new_box_lim, indices) box.select(0) self.assertTrue(np.all(box.yi == prim_obj.yi))
def test_update(self): x = np.array([(0, 1, 2), (2, 5, 6), (3, 2, 1)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) y = np.array([1, 1, 0]) prim_obj = Prim(x, y, threshold=0.8) box = PrimBox(prim_obj, prim_obj._box_init, prim_obj.yi) new_box_lim = np.array([(0, 1, 1), (2, 5, 6)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) indices = np.array([0, 1], dtype=np.int) box.update(new_box_lim, indices) self.assertEqual(box.peeling_trajectory['mean'][1], 1) self.assertEqual(box.peeling_trajectory['coverage'][1], 1) self.assertEqual(box.peeling_trajectory['density'][1], 1) self.assertEqual(box.peeling_trajectory['res dim'][1], 1) self.assertEqual(box.peeling_trajectory['mass'][1], 2 / 3)
def TestPrim(): graph_dict = { "a": { "a": 0, "b": 3, "f": 5, "e": 2 }, "b": { "b": 0, "c": 1, "f": 4, "a": 3 }, "c": { "c": 0, "b": 1, "f": 4, "d": 6 }, "d": { "d": 0, "c": 6, "f": 5, "e": 8 }, "e": { "e": 0, "a": 6, "f": 2, "d": 8 }, "f": { "f": 0, "a": 5, "b": 4, "c": 4, "d": 5, "e": 2 }, } path = Prim(graph_dict, "a") print(path)
def test_categorical_peel(self): dtype = [('a', np.float), ('b', np.object)] x = np.empty((10, ), dtype=dtype) x['a'] = np.random.rand(10, ) x['b'] = ['a', 'b', 'a', 'b', 'a', 'a', 'b', 'a', 'b', 'a'] y = np.random.randint(0, 2, (10, )) y = y.astype(np.int) prim_obj = Prim(x, y, threshold=0.8) box_lims = np.array([(0, set(['a', 'b'])), (1, set(['a', 'b']))], dtype=dtype) box = PrimBox(prim_obj, box_lims, prim_obj.yi) u = 'b' peels = categorical_peel(prim_obj, box, u) self.assertEquals(len(peels), 2) for peel in peels: pl = peel[1][u] self.assertEquals(len(pl[0]), 1) self.assertEquals(len(pl[1]), 1)
def Rsl(G, root=None, choice='prim'): """Retourne le parcours en preordre de larbre de recouvrement mininmal.""" if str.lower(choice) == 'prim': cost, arbre_min = Prim(G, root) elif str.lower(choice) == 'kruskal': cost, arbre_min = Kruskal(G) if root is None: # si la racine nest pas donne le premier noeud est pris order, temp = dfs_visit(arbre_min, arbre_min.nodes[0]) else: order, temp = dfs_visit(arbre_min, root) c = 0 cycle = Graph() # un graphe est cree for node in order: # les noeuds sont ajouter au grpahe cycle.add_node(node) for i in xrange(len(order) - 1): # les aretes sont ajouter au graphe # a laide du cycle obtenue de dfs_visit temp_c = G.get_edge_copy(order[i], order[i + 1]).get_cost() cycle.add_edge(Edge(start=order[i], end=order[i + 1], cost=temp_c)) c += temp_c return cycle, c
def setUp(self): graph_file = "test_data/graph_data.txt" with open(graph_file) as stream: self.graph = Graph(stream) self.mst = Prim(self.graph).get_minimum_spaning_tree()
def hillclimbing(self): """ Find possible swaps between a randomly chosen house and all other houses. If there are multiple swaps possible given, pick a random swap when hillblimbing is stochastic, and pick the best swap when hillblimbing is steepest ascent. """ chosen_battery = choice(self.batteries) chosen_house = choice(chosen_battery.houses) swap_options = [] old_costs = self.all_costs[-1] for potential_battery in self.batteries: if potential_battery == chosen_battery: continue houses = potential_battery.houses for potential_house in houses: chosen_battery_capacity = chosen_battery.capacity + \ chosen_house.power if potential_house.power < chosen_battery_capacity and \ chosen_house.power < potential_battery.capacity + potential_house.power: if self.share_grid == True: swap(potential_house, potential_battery, chosen_house, chosen_battery) prim = Prim(self.batteries) battery_costs = 0 for battery in self.batteries: battery_costs += battery.costs new_costs = prim.costs + battery_costs cost_difference = old_costs - new_costs reverse_swap(potential_house, potential_battery, chosen_house, chosen_battery) else: potential_distance = get_distance(potential_house, potential_battery) + \ get_distance(chosen_house, chosen_battery) new_distance = get_distance(chosen_house, potential_battery) + \ get_distance(potential_house, chosen_battery) cost_difference = potential_distance - new_distance swap_options.append( (potential_battery, potential_house, cost_difference)) better_options = [option for option in swap_options if option[2] > 0] if better_options: if self.variant == "stochastic": battery, house, _ = random.choice(better_options) else: battery, house, _ = max(swap_options, key=lambda x: x[2]) swap(house, battery, chosen_house, chosen_battery)
# terminals = [654, 288, 315, 231, 312, 111, 609, 645, 434, 469, 186] terminals = [12, 88, 66, 77, 5, 33] suitability_graph = SuitabilityGraph() suitability_graph.append_graph(node_weighted) suitability_graph.extend_suitable_regions(seed, generator) suitability_graph.extend_suitable_regions(seed, generator) regions = suitability_graph.get_suitable_regions(generator) start_time = time.clock() terminals_mc = suitability_graph.build_metric_closure(terminals) mst_terminals_mc = Prim(terminals_mc).spanning_tree() excluded_edges = set(terminals_mc.get_edges()) - set( mst_terminals_mc.get_edges()) # suitable_nodes = suitability_graph.get_suitable_nodes(generator, excluded_nodes=terminals) # closures_edges = set() # msts_edges = set() # for sn in suitable_nodes: # t_sn = list(terminals) # t_sn.append(sn) # t_sn_mc = suitability_graph.build_metric_closure(t_sn) # mst_t_sn_mc = Prim(t_sn_mc).spanning_tree() # closures_edges.update(t_sn_mc.get_edges()) # msts_edges.update(mst_t_sn_mc.get_edges()) # ee = closures_edges - msts_edges # excluded_edges.update(ee)
""" main.py """ import graphviz import loader from dijkstra import Dijkstra from graph import Graph from kruskal import Kruskal from prim import Prim g = Graph(loader.load_graph_from_file('./graph_examples/graph.csv')) kruskal = Kruskal(g) dijkstra = Dijkstra(g) prim = Prim(g) algorithms = [kruskal, dijkstra, prim] for algorithm in algorithms: mst = algorithm.run() sum_weight = sum([int(edge.weight) for edge in mst]) print('Sum for {}: {}'.format(algorithm.__class__.__name__, sum_weight)) graph = graphviz.Graph(name=algorithm.__class__.__name__ + '_MST', format='pdf') for vertex in g.vertices: graph.node(vertex, label=vertex) for edge in mst: graph.edge(edge.v1, edge.v2, label=edge.weight) graph.render(directory='mst_output')
import matplotlib.pyplot as plt from kmeans import KMeans from kruskal import Kruskal from prim import Prim K = 7 input_data = open("data/data.txt", "r") data = np.loadtxt(input_data) input_classes = open("data/classes.txt", "r") classes = np.loadtxt(input_classes) methods = dict({ "Kruskal": Kruskal(data, K), "Prim": Prim(data, K), "KMeans": KMeans(data, K) }) # PRINT READABLE OUTPUT table_headers = [ "Method", "Silhouette Coefficient", "Rand Index", "Delta Time" ] output = [] for key, value in methods.items(): output.append([ key, value.silhouette, adjusted_rand_score(classes, value.classes), value.time ]) # # PLOT GRAPH
alg = 'kruskal' nclusters = 7 try: if(sys.argv[1] == 'prim'): alg= 'prim' nclusters = int(sys.argv[2]) except (IndexError, ValueError): pass if alg == 'kruskal': kk = Kruskall(edges, len(pv), nclusters) for c in kk.part.relabeled(): print(c) else: prim = Prim(adj) treev = np.array(prim.tree_edges, dtype=object) # numpy array for easer manipulation small = treev[treev[:,0].argsort(0)][:npoints-nclusters] # remove unwanted edges smal_adj = edges_to_adj(small, npoints) # adjacency list with only the relevant edges prim_part = find_components(smal_adj) # partition from the connected components for c in prim_part: print(c) sys.exit() # ## Clustering and Analysis
def test_box_init(self): # test init box without NANS x = np.array([(0, 1, 2), (2, 5, 6), (3, 2, 7)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) y = np.array([0, 1, 2]) prim_obj = Prim(x, y, threshold=0.5) box_init = prim_obj._box_init # some test on the box self.assertTrue(box_init['a'][0] == 0) self.assertTrue(box_init['a'][1] == 3) self.assertTrue(box_init['b'][0] == 1) self.assertTrue(box_init['b'][1] == 5) self.assertTrue(box_init['c'][0] == 2) self.assertTrue(box_init['c'][1] == 7) # test init box with NANS x = np.array([(0, 1, 2), (2, 5, np.NAN), (3, 2, 7)], dtype=[('a', np.float), ('b', np.float), ('c', np.float)]) y = np.array([0, 1, 2]) x = np.ma.array(x) x['a'] = np.ma.masked_invalid(x['a']) x['b'] = np.ma.masked_invalid(x['b']) x['c'] = np.ma.masked_invalid(x['c']) prim_obj = Prim(x, y, threshold=0.5) box_init = prim_obj._box_init # some test on the box self.assertTrue(box_init['a'][0] == 0) self.assertTrue(box_init['a'][1] == 3) self.assertTrue(box_init['b'][0] == 1) self.assertTrue(box_init['b'][1] == 5) self.assertTrue(box_init['c'][0] == 2) self.assertTrue(box_init['c'][1] == 7) # heterogenous without NAN dtype = [('a', np.float), ('b', np.int), ('c', np.object)] x = np.empty((10, ), dtype=dtype) x['a'] = [0.1, 0.2, 0.3, 0.4, 0.5, 0.5, 0.7, 0.8, 0.9, 1.0] x['b'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] x['c'] = [ 'a', 'b', 'a', 'b', 'a', 'a', 'b', 'a', 'b', 'a', ] prim_obj = Prim(x, y, threshold=0.5) box_init = prim_obj._box_init # some test on the box self.assertTrue(box_init['a'][0] == 0.1) self.assertTrue(box_init['a'][1] == 1.0) self.assertTrue(box_init['b'][0] == 0) self.assertTrue(box_init['b'][1] == 9) self.assertTrue(box_init['c'][0] == set(['a', 'b'])) self.assertTrue(box_init['c'][1] == set(['a', 'b'])) # heterogenous with NAN dtype = [('a', np.float), ('b', np.int), ('c', np.object)] x = np.empty((10, ), dtype=dtype) x[:] = np.NAN x['a'] = [0.1, 0.2, 0.3, 0.4, 0.5, 0.5, 0.7, 0.8, np.NAN, 1.0] x['b'] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] x['c'] = [ 'a', 'b', 'a', 'b', np.NAN, 'a', 'b', 'a', 'b', 'a', ] x = np.ma.array(x) x['a'] = np.ma.masked_invalid(x['a']) x['b'] = np.ma.masked_invalid(x['b']) x['c'][4] = np.ma.masked prim_obj = Prim(x, y, threshold=0.5) box_init = prim_obj._box_init # some test on the box self.assertTrue(box_init['a'][0] == 0.1) self.assertTrue(box_init['a'][1] == 1.0) self.assertTrue(box_init['b'][0] == 0) self.assertTrue(box_init['b'][1] == 9) self.assertTrue(box_init['c'][0] == set(['a', 'b'])) self.assertTrue(box_init['c'][1] == set(['a', 'b']))
def anneal(self): """Find possible swaps between a randomly chosen house and other houses. If there are multiple swaps possible, make the best swap if it is an improvement or accept a worse swap depending on an acceptance probability. This in turns depends on the temperature at that time, which decreases after each iteration using a cooling scheme. """ chosen_battery = random.choice(self.batteries) chosen_house = random.choice(chosen_battery.houses) swap_options = [] old_costs = self.all_costs[-1] for potential_battery in self.batteries: if potential_battery == chosen_battery: continue for potential_house in potential_battery.houses: chosen_capacity = chosen_battery.capacity + chosen_house.power potential_capacity = potential_battery.capacity + potential_house.power if potential_house.power < chosen_capacity and \ chosen_house.power < potential_capacity: if self.share_grid == False: potential_distance = get_distance(potential_house, potential_battery) + \ get_distance(chosen_house, chosen_battery) new_distance = get_distance(chosen_house, potential_battery) + \ get_distance(potential_house, chosen_battery) cost_difference = potential_distance - new_distance else: swap(potential_house, potential_battery, chosen_house, chosen_battery) prim = Prim(self.batteries) battery_costs = 0 for battery in self.batteries: battery_costs += battery.costs new_costs = prim.costs + battery_costs cost_difference = old_costs - new_costs reverse_swap(potential_house, potential_battery, chosen_house, chosen_battery) swap_options.append( (potential_battery, potential_house, cost_difference)) acceptance = 0 if swap_options: desired_battery, house_to_extract, cost_decrease = max( swap_options, key=lambda x: x[2]) if cost_decrease > 0: acceptance = 1 else: desired_battery, house_to_extract, cost_increase = random.choice( swap_options) acceptance = exp(cost_increase/self.temp) if acceptance > random.random(): swap(house_to_extract, desired_battery, chosen_house, chosen_battery)