solutions[sol_num][2]):\n\t\t\topt = []\n\n\t\t\twaste_min = solutions[sol_num][2]\n\t\t\tn = solutions[sol_num][0]\n\t\t\tm = solutions[sol_num][1]\n\n\t\t\topt.append(waste_min)\n\t\t\topt.append(n)\n\t\t\topt.append(m)\n\n\treturn opt","def search_for_maximum(self):\n return self.maximise_aquisition(self.expected_improvement)","def min_target(board, depth, alpha, beta):\n if terminal(board) or depth == DEPTH:\n return utility(board)\n\n best_val = math.inf\n for action in actions(board):\n val = max_target(result(board, action), depth+1, alpha, beta)\n best_val = min(val, best_val)\n beta = min(beta, best_val)\n if beta <= alpha:\n break\n\n return best_val","def bestVectorIndex(self):\n return min(range(len(self.costs)), key=self.costs.__getitem__)","def get_interval_from_minflow(self, wide=False):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.arc_info[arc][\"start\"],\n # self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.arc_info[arc][\"destin\"],\n # self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # x,\n # self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.source(),\n # x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.sink(),\n # x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # x,\n # self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".\n # format(s_prime, v, int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".\n # format(v, t_prime, int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n # s_prime,\n # x,\n # int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n # x,\n # t_prime,\n # int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i],\n capacities[i],\n unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n # print('Minimum cost:', min_cost_flow.OptimalCost())\n # print('')\n # print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n # cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n # print('%1s -> %1s %3s / %3s %3s' % (\n # min_cost_flow.Tail(i),\n # min_cost_flow.Head(i),\n # min_cost_flow.Flow(i),\n # min_cost_flow.Capacity(i),\n # cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n # print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n # print(\"Has become ({}, {}) with sup {}\".format(start,\n # destin,\n # sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in\n self.arc_info[arc].keys()):\n # print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n bound_1 = old_flow + sup_flow\n bound_2 = old_flow - sup_flow\n new_lb = max(0, int(min(bound_1, bound_2)))\n new_ub = int(max(bound_1, bound_2))\n if wide:\n if new_lb == new_ub:\n # print(\"We had a zero interval\")\n new_lb = int(new_lb*0.8)\n new_ub = int(new_ub*1.2)\n if new_lb == 0:\n # print(\"We got a zero lower bound\")\n new_ub = 5\n # print(\"But now we're doing {} {}\".\n # format(new_lb, new_ub))\n\n self.arc_info[arc][\"lower_bound\"] = new_lb\n self.arc_info[arc][\"upper_bound\"] = new_ub\n # print(\"Edge ({},{}) bounds are [{},{}]\".format(\n # start,\n # destin,\n # self.arc_info[arc][\"lower_bound\"],\n # self.arc_info[arc][\"upper_bound\"]))\n # print(self.arc_info[arc])\n else:\n print('There was an issue with the min cost flow input.')\n # self.check_conservation_of_flow() # check that solution is valid","def best_upper_bound(self):\n if self._all_nodes:\n return min(node.upper_bound for node in self._all_nodes)\n else:\n return np.inf","def get_smallest_h_cost_unvisited_node(self):\n node_list = []\n for column in self.grid:\n for node in column:\n if node.pos in self.unvisited_pos:\n node_list.append(node)\n return min(node_list, key=lambda x: x.h_cost)","def __dijkstra_max_prob_tree(unit_rules_graph, source_var):\n variables = unit_rules_graph.vertices\n dist = {var: -1.0 for var in variables}\n dist[source_var] = 1.0\n tree_nodes = {var: ParseTreeNode(var) for var in variables}\n pending_vars = set(variables)\n while pending_vars:\n max_dist, max_dist_var = max((d, v) for v, d in dist.items() if v in pending_vars)\n pending_vars.remove(max_dist_var)\n for neighbor, prob in unit_rules_graph.neighbors[max_dist_var]:\n if neighbor not in pending_vars:\n continue\n alt_dist = dist[max_dist_var] * prob\n if dist[neighbor] is None or alt_dist > dist[neighbor]:\n dist[neighbor] = alt_dist\n tree_nodes[max_dist_var].children.append(tree_nodes[neighbor])\n return ParseTree(tree_nodes[source_var])","def get_smallest_f_cost_unvisited_node(self):\n node_list = []\n for column in self.grid:\n for node in column:\n if node.pos in self.unvisited_pos:\n node_list.append(node)\n min_f_cost_node = min(node_list, key=lambda x: x.g_cost)\n min_f_cost_list = []\n for column in self.grid:\n for node in column:\n if (\n node.f_cost == min_f_cost_node.f_cost\n and node.pos in self.unvisited_pos\n ):\n min_f_cost_list.append(node)\n return min_f_cost_node, len(min_f_cost_list)","def min_neighbor_node(g):\r\n return min(g.degree_iter(),key = lambda item:item[1])[0]","def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\n # set availbandwidth to the maximal value\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\n if d.type == 'STATIC':\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\n # subtract the reserved link and internal (inside Infras) bandwidth\n if mode == self.MODE_ADD:\n for d in self.infras:\n for p in d.ports:\n for fr in p.flowrules:\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\n # Flowrules are cummulatively subtracted from the switching \n # capacity of the node.\n d.availres['bandwidth'] -= fr.bandwidth\n if d.availres['bandwidth'] < 0:\n raise RuntimeError(\"The node bandwidth of %s got below zero \"\n \"during available resource calculation!\" %\n d.id)\n # Get all the mapped paths of all SGHops from the NFFG\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\n for sg_hop_id, data in sg_map.iteritems():\n src, dst, flowclass, bandwidth, delay, path = data\n if bandwidth is not None:\n for link in path:\n link.availbandwidth -= bandwidth\n if link.availbandwidth < 0:\n raise RuntimeError(\n \"The link bandwidth of %s got below zero during\"\n \"available resource calculation!\" % link.id)","def fmax(func_to_maximize, initial_guess=0.5*V):\n func_to_minimize = lambda x : -func_to_maximize(x)\n return fmin(func_to_minimize, initial_guess, disp=False)[0]","def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,\n best_path):\n path[0] = path[0] + [start]\n \n if digraph.has_node(Node(start)) == False or digraph.has_node(Node(end)) == False:\n raise ValueError('Start or end node are not valid')\n elif start == end :\n return path\n else:\n for edge in digraph.get_edges_for_node(Node(start)):\n \n node = str(edge.get_destination())\n tot_distance = edge.get_total_distance() + path[1]\n tot_outdoors = edge.get_outdoor_distance() + path[2]\n\n if node not in path[0] and tot_distance <= best_dist and tot_outdoors <= max_dist_outdoors :\n updated_path = [path[0], tot_distance, tot_outdoors]\n new_path = get_best_path(digraph, node, end, updated_path, max_dist_outdoors, best_dist, best_path)\n \n if new_path:\n if not best_dist or new_path[1] < best_dist: \n best_path = new_path[0]\n best_dist = new_path[1]\n\n return best_path, best_dist","def optimal_synthesis_decreasing_cost(self, max_cost=35, min_cost=10, precision=0.1, msw=0, max_depth=False):\n cost = max_cost\n result_file_names = []\n\n if not max_depth:\n max_depth = self.num_modes\n\n while cost >= min_cost:\n self.edit_cost(cost)\n result_file_name = self.call_solver(precision, cost, ' --ode-opts --continue-after-not-reaching-horizon', msw=msw, max_depth=max_depth)\n result_file_names.append(result_file_name)\n cost -= 1\n return result_file_names","def get_maximum_fitness(self) -> float:\n anticipated_change_cls = [cl for cl in self\n if cl.does_anticipate_change()]\n\n if len(anticipated_change_cls) > 0:\n best_cl = max(anticipated_change_cls, key=lambda cl: cl.fitness)\n return best_cl.fitness\n\n return 0.0","def calculate_min_max_tiles(self):","def get_road_to(network, start, end):\n roads_common = list( set(network[1][start][0]).intersection(network[1][end][1]) )\n\n minimum = None\n if 0 < len(roads_common):\n minimum = roads_common[0]\n \n for road in roads_common:\n if get_length(network,minimum) > get_length(network,road):\n minimum = road\n \n return minimum","def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\n #print slink_dict\n #print \"FIND\"\n failed_dict = model.failed_dict\n #print failed_dict, limit\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n bw_matrix = model.cost_dict['bw']\n #cpu_vector = model.cost_dict['cpu']\n selected_dict = {}\n \n # get aggregated residual bw for all substrate nodes, and store it as a list\n snode_bw_list = total_bw(bw_matrix)\n \n # get total capacity and used bw for each snode\n node_port_list, used_bw_list = total_port(model)\n #vnet_set = model.vnets\n sorted_vn = sort_vnet(model)\n\n #for vnet in vnet_set:\n if w_m[2] >= 10*w_m[1]:\n threshold = 0.8\n else:\n threshold = 0.8\n snode_traffic = {}\n for vn_traffic in sorted_vn:\n vnet = vn_traffic[0]\n failed_vr = failed_dict[vnet.vnet_id]\n if failed_vr != -1: \n # this node is failed\n standby_list = vnet.get_standby_ids()\n standby_cost = {}\n for s_vr in standby_list:\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\n failed_node = vnet.vnodes[failed_vr]\n vneighbors = failed_node.vneighbors\n dist_k = 0\n rtt_k = 0\n for k in vneighbors:\n dist_k += float(dist_matrix[s_vr][k + 1])\n rtt_k += float(rtt_matrix[s_vr][k + 1])\n\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\n w_b[1] * rtt_k\n res_cost = snode_bw_list[s_vr]\n req_bw = sum(failed_node.neighbor_traffic.values())\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\n standby_cost[s_vr] = total\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\n #print \"SORTED\", sorted_x\n \n for item in sorted_x:\n if item[0] not in snode_traffic:\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n else:\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n #print utilization\n # Link-Path selsection add-on\n path_alloc = 1\n for k in vneighbors:\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\n item[0] + 1, k + 1)\n demand = demand_dict[demand_id]['capacity']\n find, path = find_path(demand_path, demand_id, \n slink_dict, demand) \n if find == 0:\n print \"No available path between svr and nbr on the substrate network\" \n path_alloc = 0\n #print \"FIND PATH\", find, path\n # End link-path block \n #print \"ALLOCATED: \", path_alloc\n if path_alloc == 1:\n if selected_dict.values().count(item[0]) < limit:\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\n if item[0] not in snode_traffic: \n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] = vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break;\n else:\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \n if min_id == item[0]:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n #threshold = (threshold + 0.01)/2\n break\n elif utilization < threshold:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n if item[0] not in snode_traffic: \n snode_traffic[item[0]] = vn_traffic[1]\n else:\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break\n else:\n print \"does not satisfy the threshold\" \n # if a svr is selected -- item[0]\n \n \n \n else:\n print \"cannot allocate paths\"\n \n #print slink_dict \n return selected_dict, slink_dict","def DRFindMinimalEdge(self, flow, edge_lst):\n\t\tarr_time = flow[3]\n\t\tend_time = flow[3] + flow[4]\n\t\tmin_cum_size = float('inf')\n\t\tmin_edge = (-1, -1)\n\t\tfor e in edge_lst:\n\t\t\tprev_time = arr_time\n\t\t\tprev_rate = 0\n\t\t\tcum_size = 0\n\t\t\tfor time, rate in sorted(self.rate_lst[e].items()):\n\t\t\t\tif time > arr_time:\n\t\t\t\t\tif time < end_time:\n\t\t\t\t\t\tcum_size += prev_rate * (time - prev_time)\n\t\t\t\t\telse:\n\t\t\t\t\t\tcum_size += prev_rate * (end_time - prev_time)\n\t\t\t\t\t\tbreak\n\t\t\t\tif cum_size >= min_cum_size:\n\t\t\t\t\t# Break if already >= minimum\n\t\t\t\t\tbreak\n\t\t\t\telif time >= end_time:\n\t\t\t\t\t# Break if time exceeds deadline\n\t\t\t\t\tbreak\n\n\t\t\t\tprev_time = time\n\t\t\t\tprev_rate = rate\n\n\t\t\tif cum_size < min_cum_size:\n\t\t\t\tmin_cum_size = cum_size\n\t\t\t\tmin_edge = e\n\n\t\treturn min_edge, min_cum_size","def compute_optimal_block_maximum(block_counts) -> int:\n q1, q3 = compute_quartiles(block_counts)\n iqr = q3 - q1\n high_threshold = q3 + 1.5 * iqr\n return high_threshold","def min_distance(distance, spt_set, self_nodes):\n minimum = sys.maxsize\n minimum_node = None\n for curr_node in self_nodes.values():\n if distance[curr_node.id] < minimum and not spt_set[curr_node.id]:\n minimum = distance[curr_node.id]\n minimum_node = curr_node\n return minimum_node","def get_max_and_min(self):\n max_x = float('-inf')\n min_x = float('inf')\n max_y = float('-inf')\n min_y = float('inf')\n max_z = float('-inf')\n min_z = float('inf')\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n counter = 0\n for src, node in self._graph.get_all_v().items():\n if node.location is not None:\n x = node.location.x\n y = node.location.y\n z = node.location.z\n counter += 1\n max_x = x if x > max_x else max_x\n min_x = x if x < min_x else min_x\n max_y = y if y > max_y else max_y\n min_y = y if y < min_y else min_y\n max_z = z if z > max_z else max_z\n min_z = z if z < min_z else min_z\n if counter > 4:\n ans = max_x, max_y, max_z, min_x, min_y, min_z\n return ans","def get_current_max_link(self):\n return self.current_max_link","def calc_strongest_bridge(comp_map: CompMap):\n @lru_cache(None)\n def _helper(cur_no_pins: int = 0, used_components: FrozenSet[Component] = frozenset()):\n available_connections = comp_map[cur_no_pins] - used_components\n\n if not available_connections:\n return sum(c.strength for c in used_components)\n\n res = []\n for c in available_connections:\n res.append(_helper(c.other(cur_no_pins), used_components | {c}))\n return max(res)\n res = _helper()\n print(_helper.cache_info())\n return res","def test_node_weight_range_max(self):\n n = Node(inputs=3)\n for i in n.weights:\n self.assertLess(i, 0.1)","def mincost(L,m,n):\n # find the length of the strings\n # declaring the array for storing the dp values\n tc = [[0]*(n + 1) for i in range(m + 1)]\n tc[0][0]=L[0][0]\n for i in range(1,m + 1):\n tc[i][0]=tc[i-1][0]+L[i][0]\n for j in range(1,n + 1):\n tc[0][j]=tc[0][j-1]+L[0][j]\n for i in range(1,m+1):\n for j in range(1,n+1):\n tc[i][j]=min(tc[i-1][j-1],tc[i-1][j],tc[i][j-1])+L[i][j]\n\n\n # L[m][n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\n return tc[m][n]","def get_best(self):\n if len(self._table) == 0:\n self.log.warning(\"table is empty, cannot extract best value\")\n raise ValueError()\n\n max_prob = -np.inf\n max_assignment = None\n for assignment in self._table.keys():\n prob = self._table[assignment]\n if prob > max_prob:\n max_prob = prob\n max_assignment = assignment\n\n # TODO: check refactor > there is no case of max_assignment is None\n return max_assignment if max_assignment is not None else Assignment.create_default(self._head_vars)","def get_best_lower_bound(self):\n if not self.tours:\n raise Exception('No lower bound has been computed yet')\n best = max(self.lower_bounds,key=self.lower_bounds.get)\n print('The best lower bound is given by {} with score {}'.format(best,self.lower_bounds[best]))\n return self.lower_bounds[best]","def lazy_greedy_max(self, budget):\r\n\r\n classes, no_elements = torch.unique(self.y_trn, return_counts=True)\r\n len_unique_elements = no_elements.shape[0]\r\n per_class_bud = int(budget / len(classes))\r\n final_per_class_bud = []\r\n _, sorted_indices = torch.sort(no_elements, descending = True)\r\n\r\n if self.selection_type == 'PerClass':\r\n \r\n total_idxs = 0\r\n for n_element in no_elements:\r\n final_per_class_bud.append(min(per_class_bud, torch.IntTensor.item(n_element)))\r\n total_idxs += min(per_class_bud, torch.IntTensor.item(n_element))\r\n \r\n if total_idxs < budget:\r\n bud_difference = budget - total_idxs\r\n for i in range(len_unique_elements):\r\n available_idxs = torch.IntTensor.item(no_elements[sorted_indices[i]])-per_class_bud \r\n final_per_class_bud[sorted_indices[i]] += min(bud_difference, available_idxs)\r\n total_idxs += min(bud_difference, available_idxs)\r\n bud_difference = budget - total_idxs\r\n if bud_difference == 0:\r\n break\r\n\r\n total_greedy_list = []\r\n for i in range(len_unique_elements):\r\n idxs = torch.where(self.y_trn == classes[i])[0]\r\n \r\n if self.submod == 'facility_location':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'graph_cut':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'saturated_coverage':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'sum_redundancy':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\r\n n_samples=final_per_class_bud[i])\r\n elif self.submod == 'feature_based':\r\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=final_per_class_bud[i])\r\n\r\n if self.submod == 'feature_based':\r\n\r\n x_sub = fl.fit_transform(self.x_trn[idxs].numpy())\r\n greedyList = self.get_index(self.x_trn[idxs].numpy(), x_sub)\r\n total_greedy_list.extend(idxs[greedyList])\r\n\r\n else: \r\n\r\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\r\n greedyList = list(np.argmax(sim_sub, axis=1))\r\n total_greedy_list.extend(idxs[greedyList])\r\n\r\n elif self.selection_type == 'Supervised':\r\n \r\n \r\n if self.submod == 'feature_based':\r\n \r\n class_map = {}\r\n for i in range(len_unique_elements):\r\n class_map[torch.IntTensor.item(classes[i])] = i #Mapping classes from 0 to n\r\n \r\n sparse_data = torch.zeros([self.x_trn.shape[0], self.x_trn.shape[1]*len_unique_elements])\r\n for i in range(self.x_trn.shape[0]):\r\n \r\n start_col = class_map[torch.IntTensor.item(self.y_trn[i])]*self.x_trn.shape[1]\r\n end_col = start_col+self.x_trn.shape[1]\r\n sparse_data[i, start_col:end_col] = self.x_trn[i, :]\r\n\r\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\r\n x_sub = fl.fit_transform(sparse_data.numpy())\r\n total_greedy_list = self.get_index(sparse_data.numpy(), x_sub)\r\n\r\n else:\r\n for i in range(len(classes)):\r\n \r\n if i == 0:\r\n idxs = torch.where(self.y_trn == classes[i])[0]\r\n N = len(idxs)\r\n self.compute_score(idxs)\r\n row = idxs.repeat_interleave(N)\r\n col = idxs.repeat(N)\r\n data = self.dist_mat.cpu().numpy().flatten()\r\n else:\r\n idxs = torch.where(self.y_trn == classes[i])[0]\r\n N = len(idxs)\r\n self.compute_score(idxs)\r\n row = torch.cat((row, idxs.repeat_interleave(N)), dim=0)\r\n col = torch.cat((col, idxs.repeat(N)), dim=0)\r\n data = np.concatenate([data, self.dist_mat.cpu().numpy().flatten()], axis=0)\r\n \r\n \r\n sparse_simmat = csr_matrix((data, (row.numpy(), col.numpy())), shape=(self.N_trn, self.N_trn))\r\n #self.dist_mat = sparse_simmat\r\n\r\n if self.submod == 'facility_location':\r\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'graph_cut':\r\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'saturated_coverage':\r\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'sum_redundancy':\r\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n sim_sub = fl.fit_transform(sparse_simmat)\r\n total_greedy_list = list(np.array(np.argmax(sim_sub, axis=1)).reshape(-1))\r\n\r\n\r\n if self.selection_type == 'Full':\r\n \r\n\r\n total_greedy_list = []\r\n idx_end = self.x_trn.shape[0] - 1\r\n idxs = torch.linspace(0, idx_end, self.x_trn.shape[0]).long()\r\n\r\n if self.submod == 'facility_location':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'graph_cut':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'saturated_coverage':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'sum_redundancy':\r\n self.compute_score(idxs)\r\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\r\n n_samples=budget)\r\n elif self.submod == 'feature_based':\r\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\r\n\r\n if self.submod == 'feature_based':\r\n\r\n x_sub = fl.fit_transform(self.x_trn.numpy())\r\n total_greedy_list = self.get_index(self.x_trn.numpy(), x_sub)\r\n\r\n else: \r\n\r\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\r\n total_greedy_list = list(np.argmax(sim_sub, axis=1))\r\n\r\n return total_greedy_list","def max_weight(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def probabilityTransitionRule(self, unvisitedHeuristics, totalUnvisited):\n argMaxProbValue = 0\n argMaxToken = None\n for unvisitedToken in unvisitedHeuristics:\n probValue = unvisitedHeuristics[unvisitedToken] / totalUnvisited\n\n # In case obtained value is higher than previous maximum, substitute\n if probValue > argMaxProbValue:\n argMaxProbValue = probValue\n argMaxToken = unvisitedToken\n\n return argMaxToken","def best_unexplored_lower_bound(self):\n if self._unexplored_nodes:\n return min(node.lower_bound for node in self._unexplored_nodes)\n else:\n return 0.0","def find_free(min_=0):\n while is_occupied(min_):\n min_ += 1\n return min_","def strategy_cheap(cookies, cps, history, time_left, build_info):\n min_item = None\n min_cost = float('inf')\n for item in build_info.build_items():\n if build_info.get_cost(item) <= min_cost:\n min_item = item\n min_cost = build_info.get_cost(item)\n\n if (time_left * cps + cookies) < min_cost:\n min_item = None\n\n print \"min item\", min_item\n print \"min_cost:\", min_cost\n print \"CPS:\", cps\n print \"Time Left:\", time_left\n print time_left * cps + cookies\n\n return min_item","def required_gpu_maximum(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"required_gpu_maximum\")","def estimate_cost(q, n, max_m, s, attacks):\n r = [float('inf')] * 3\n for cost in [primal_cost, dual_cost]:\n for i, attack in enumerate(attacks):\n _, _, c = optimize_attack(q, n, max_m, s, cost, attack)\n r[i] = min(r[i], c)\n return r","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def fmax(func_to_maximize, initial_guess=0):\n func_to_minimize = lambda x : -func_to_maximize(x)\n return fmin(func_to_minimize, initial_guess, disp=False)[0]","def largestResolution(resolutions):\n return resolutions[0]","def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation","def __mini_max_ab(self,\n board: Board,\n depth: int,\n is_max: bool,\n alpha: int,\n beta: int,\n states: List[Board]\n ) -> Tuple[int, Board]:\n self.nodes_count += 1\n if depth == 0:\n return self.__moves_available(board), states[0]\n if self.get_num_of_moves(board, self.opponent_color) == 0:\n return 9999, states[0]\n all_moves = self.get_all_moves(board, self.player_color)\n\n if is_max:\n best = (-9999, board)\n for move in all_moves:\n next_state = self.__mini_max_ab(move, depth - 1, False, alpha, beta, states + [move])\n best = max(best, next_state, key=lambda x: x[0])\n alpha = max(alpha, best[0])\n if beta <= alpha:\n self.pruning_count += 1\n break\n return best\n else:\n best = (9999, board)\n for move in all_moves:\n next_state = self.__mini_max_ab(move, depth - 1, True, alpha, beta, states + [move])\n best = min(best, next_state, key=lambda x: x[0])\n beta = min(beta, best[0])\n if beta <= alpha:\n self.pruning_count += 1\n break\n return best","def get_max_lb(self):\n max_lb = 0\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"lower_bound\"] > max_lb:\n max_lb = self.arc_info[arc][\"lower_bound\"]\n return max_lb","def max_network_performance(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_network_performance\")","def _joint_nodes(self, job, node_avl, res_type=None):\n if not res_type:\n _min = min([node_avl[res_type] // v for res_type, v in job.requested_resources.items() if v > 0])\n return _min\n return node_avl[res_type] // job.requested_resources[res_type]","def getNextNodeUsingTotalStepsToTravel(kGoalState):\n \n global fringe\n global solutions\n\n\n\n minNode = None\n minCost = 99999999999\n minNodeIndex = -1\n\n \n pnode = None\n pcost = None\n\n if len(solutions)>0 and solutions[0] != None:\n pnode = solutions[0];\n pcost = getTotalStepsToReachGoalState(pnode,kGoalState)\n # print pnode, pcost\n # raw_input()\n \n\n\n\n for idx,node in enumerate(fringe):\n #get the heu. function values\n g_value =getTotalStepsToReachGoalState(node,kGoalState)\n \n\n if g_value < minCost:\n minNode = node\n minNodeIndex = idx\n minCost = g_value\n\n\n fringe.pop(minNodeIndex)\n c = getTotalStepsToReachGoalState(minNode,kGoalState)\n if pnode != None:\n if c > pcost:\n minNode = None\n \n return minNode","def search_best_goal_node(self):\n\n dist_to_goal_list = [self.calc_dist_to_goal(n.x, n.y) for n in self.node_list]\n goal_indexes = [\n dist_to_goal_list.index(i)\n for i in dist_to_goal_list\n if i <= self.expand_dis\n ]\n\n safe_goal_indexes = []\n for goal_index in goal_indexes:\n t_node = self.steer(self.node_list[goal_index], self.goal_node)\n if self.check_collision(t_node, self.obstacle_list):\n safe_goal_indexes.append(goal_index)\n\n if not safe_goal_indexes:\n return None\n\n min_cost = min([self.node_list[i].cost for i in safe_goal_indexes])\n for i in safe_goal_indexes:\n if self.node_list[i].cost == min_cost:\n return i\n\n return None","def pre_processing(self):\n while self.number_of_dmax() < 1:\n self.dmax -= 1\n __edges = self.current_edges()\n print('current edges =', __edges, ' expected edges =', self.edges)\n if __edges < self.edges:\n __temp = self.dmax\n __l = self.dmax\n self.dmax *= 2\n __r = self.dmax\n while self.number_of_dmax() >= 1 and __r < self.nodes:\n __l = __r\n self.dmax *= 2\n __r = self.dmax\n while __l < __r:\n self.dmax = int((__l + __r) / 2)\n if self.number_of_dmax() < 1:\n __r = self.dmax\n else:\n __l = self.dmax + 1\n self.dmax = __l - 1\n __edges = self.current_edges()\n if __edges > self.edges:\n __l = __temp\n __r = self.dmax\n while __l < __r:\n self.dmax = int((__l + __r) / 2)\n __edges = self.current_edges()\n if __edges > self.edges:\n __r = self.dmax\n else:\n __l = self.dmax + 1\n self.dmax = __l - 1\n print('adjust dmax =', self.dmax, ' edges =', int(__edges))\n elif __edges > self.edges:\n __temp1 = [_ ** self.lmd for _ in range(self.dmin, self.dmax + 1)]\n __temp2 = [_ * __ for _, __ in zip(__temp1, list(range(self.dmin, self.dmax+1)))]\n c = self.edges / sum(__temp2)\n n = c * sum(__temp1)\n self.select_p = n / self.nodes\n print('reduce select p =', self.select_p)","def get_best(self, population):\n best = min(population, key=self.cost_function)\n return best, self.cost_function(best)","def opt_settlement(player, board, gains, goal=\"default\"):\n goal_index = goal_list.get(goal, 0)\n vertex_score = lambda t: vertex_eval(player, board, t[0], gains, goal_index)\n vertex_list = [(v, board.get_vertex_location(v)) for v in range(board.max_vertex+1) \\\n if board.if_can_build(\"settlement\", *(board.get_vertex_location(v)))]\n return max(vertex_list, key = vertex_score, default=(None, None))","def choose_max_efficiency(efficiencies):\n if type(efficiencies) == list or type(efficiencies) == tuple:\n return max(map(float,efficiencies)) \n else:\n return float(efficiencies)"],"string":"[\n \"def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\\n pass\",\n \"def max_flow_min_cut(vertices, start, end):\\n\\n max_flow = 0 # There is no flow initially\\n\\n while True:\\n bfs(vertices, start)\\n\\n if not end.bfs_visited:\\n # There is no path between start and end\\n break\\n\\n path = end.get_bfs_path()\\n bottleneck = min([edge.weight for edge in path])\\n\\n # Update edges and residual edges values\\n for edge in path:\\n edge.weight -= bottleneck\\n edge.inverse_edge.weight += bottleneck\\n max_flow += bottleneck\\n\\n min_cut = calculate_min_cut(vertices, start)\\n return max_flow, min_cut\",\n \"def find_max_flow(graph, start, end):\\n try:\\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\\\"weight\\\")\\n return flow_value\\n except Exception as e:\\n print(\\\"Error in Max flow computation \\\", e)\\n return \\\"NaN\\\"\",\n \"def optimal_min(board):\\n if terminal(board):\\n return [None, utility(board)]\\n\\n available_actions = list(actions(board))\\n\\n # Naive baseline comparison is positive infinity\\n global_optimum = [None, math.inf]\\n\\n for action in available_actions:\\n # Anticipates optimal adversarial moves.\\n local_optimum = optimal_max(result(board, action))\\n\\n if global_optimum[1] >= local_optimum[1]:\\n global_optimum = [action, local_optimum[1]]\\n\\n return global_optimum\",\n \"def maximize(self, budget, optimizer):\\n\\n\\t\\tpass\",\n \"def get_max_usage(topology, path):\\n max_usage = np.finfo(0.0).min\\n for i in range(len(path.node_list) - 1):\\n max_usage = max(max_usage, topology[path.node_list[i]][path.node_list[i + 1]]['total_units'] - topology[path.node_list[i]][path.node_list[i + 1]]['available_units'])\\n return max_usage\",\n \"def optimal_max(board):\\n # Board full?\\n if terminal(board):\\n return [None, utility(board)]\\n\\n available_actions = list(actions(board))\\n\\n # Naive baseline comparison is negative infinity\\n global_optimum = [None, -math.inf]\\n\\n # For each move, what would opponent do next? Update best move.\\n for action in available_actions:\\n # Anticipates optimal adversarial moves\\n local_optimum = optimal_min(result(board, action))\\n\\n # Compares local vs global optima\\n if global_optimum[1] <= local_optimum[1]:\\n global_optimum = [action, local_optimum[1]]\\n\\n return global_optimum\",\n \"def maximum_flow(graph, start, end):\\n if not isinstance(graph, BasicGraph):\\n raise TypeError(f\\\"Expected subclass of BasicGraph, not {type(graph)}\\\")\\n Graph = type(graph)\\n \\n if start not in graph:\\n raise ValueError(f\\\"{start} not in graph\\\")\\n if end not in graph:\\n raise ValueError(f\\\"{end} not in graph\\\")\\n\\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\\n total_flow = 0\\n # -----------------------------------------------------------------------\\n # The algorithm\\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\\n # of DFS, which leads to a lot of node visits.\\n #\\n # I therefore choose to invert the capacities of the graph so that the\\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\\n # This allows me to use the shortest path method to find the path with\\n # most capacity in the first attempt, resulting in a significant reduction\\n # of unassigned flow.\\n #\\n # By updating G_inverted, with the residual capacity, I can keep using the\\n # shortest path, until the capacity is zero, whereby I remove the links\\n # When the shortest path method returns 'No path' or when unassigned flow\\n # is zero, I exit the algorithm.\\n #\\n # Even on small graphs, this method is very efficient, despite the overhead\\n # of using shortest path. For very large graphs, this method outperforms\\n # all other algorithms by orders of magnitude.\\n # -----------------------------------------------------------------------\\n\\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\\n inverted_graph = Graph(from_list=edges) # create G_inverted.\\n capacity_graph = Graph() # Create structure to record capacity left.\\n flow_graph = Graph() # Create structure to record flows.\\n\\n while unassigned_flow:\\n # 1. find the best path\\n d, path = shortest_path(inverted_graph, start, end)\\n if d == float(\\\"inf\\\"): # then there is no path, and we must exit.\\n return total_flow, flow_graph\\n # else: use the path and lookup the actual flow from the capacity graph.\\n\\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\\\"inf\\\"))) for s, e, d in graph.edges(path=path)])\\n\\n # 2. update the unassigned flow.\\n unassigned_flow -= path_flow\\n total_flow += path_flow\\n\\n # 3. record the flows and update the inverted graph, so that it is\\n # ready for the next iteration.\\n edges = graph.edges(path)\\n for n1, n2, d in edges:\\n # 3.a. recording:\\n v = flow_graph.edge(n1, n2, default=None)\\n if v is None:\\n flow_graph.add_edge(n1, n2, path_flow)\\n c = graph.edge(n1, n2) - path_flow\\n else:\\n flow_graph.add_edge(n1, n2, value=v + path_flow)\\n c = graph.edge(n1, n2) - (v + path_flow)\\n capacity_graph.add_edge(n1, n2, c)\\n\\n # 3.b. updating:\\n # if there is capacity left: update with new 1/capacity\\n # else: remove node, as we can't do 1/zero.\\n if c > 0:\\n inverted_graph.add_edge(n1, n2, 1 / c)\\n else:\\n inverted_graph.del_edge(n1, n2)\\n return total_flow, flow_graph\",\n \"def gopt_max(fun, bounds, n_warmup = 1000, n_local = 10):\\n x_best, y_best = gopt_min(lambda x: -fun(x), bounds, n_warmup, n_local)\\n return x_best, -y_best\",\n \"def calculate_greatest(self):\\n greatest = 0\\n for resourceList in self.loading.values():\\n for time, use in resourceList:\\n if use > greatest:\\n greatest = use\\n self.emit(\\\"greatest_calculated\\\",greatest)\\n return greatest\",\n \"def max_dist(graph, source):\\r\\n q = queue.Queue()\\r\\n found = {}\\r\\n distance = {}\\r\\n for vertex in graph: \\r\\n found[vertex] = 0\\r\\n distance[vertex] = -1\\r\\n max_distance = 0\\r\\n found[source] = 1\\r\\n distance[source] = 0\\r\\n q.put(source)\\r\\n while q.empty() == False:\\r\\n current = q.get()\\r\\n for neighbour in graph[current]:\\r\\n if found[neighbour] == 0:\\r\\n found[neighbour] = 1\\r\\n distance[neighbour] = distance[current] + 1\\r\\n max_distance = distance[neighbour]\\r\\n q.put(neighbour)\\r\\n return max_distance\",\n \"def get_min_max_weight_edges(G):\\n min_weight = 1e10\\n max_weight = 0\\n for edge in G.edges(data=True):\\n min_weight = min(1.0/edge[2][\\\"weight\\\"], min_weight)\\n max_weight = max(1.0/edge[2][\\\"weight\\\"], max_weight)\\n return min_weight, max_weight\",\n \"def calc_min_flow(m0, m1):\\n if m0 == 0:\\n m0 = 1E6\\n if m1 > 0:\\n mmin = min(m0, m1)\\n else:\\n mmin = m0\\n return mmin\",\n \"def calculateOptimal(self) -> (list, int):\\n\\t\\tcombinations = list(itertools.product(*self.clusters))\\n\\t\\tmin_dist = 1000000\\n\\t\\tmin_combination = None\\n\\t\\tfor combination in combinations:\\n\\t\\t\\tdist = super().step(combination)\\n\\t\\t\\tif(dist < min_dist):\\n\\t\\t\\t\\tmin_dist = dist\\n\\t\\t\\t\\tmin_combination = combination\\n\\t\\treturn (min_combination, min_dist)\",\n \"def max_path_cost(self, path, attr): \\n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])\",\n \"def _find_lowest_cost_node(self) -> str:\\n lowest_cost = float(\\\"inf\\\")\\n lowest_cost_node = None\\n for node in self.costs:\\n cost = self.costs[node]\\n if cost < lowest_cost and node not in self.closed_nodes:\\n lowest_cost = cost\\n lowest_cost_node = node\\n return lowest_cost_node\",\n \"def maximize(self):\\n raise NotImplementedError\",\n \"def local_max_to_min(node):\\r\\n if node.op == T.neg and node.inputs[0].owner:\\r\\n max = node.inputs[0]\\r\\n if (max.owner and\\r\\n isinstance(max.owner.op, CAReduce)\\r\\n and max.owner.op.scalar_op == scal.maximum):\\r\\n neg = max.owner.inputs[0]\\r\\n if neg.owner and neg.owner.op == T.neg:\\r\\n return [CAReduce(scal.minimum,\\r\\n max.owner.op.axis)(neg.owner.inputs[0])]\\r\\n\\r\\n return False\",\n \"def find_allocation_with_min_shering(self):\\n for consumption_graph in self.graph_generator.generate_all_consumption_graph():\\n self.find_allocation_for_graph(consumption_graph)\\n return self.min_sharing_allocation\",\n \"def calculate_best_way(self) -> int:\\n node = self._find_lowest_cost_node()\\n while node:\\n cost = self.costs[node]\\n neighbors = self.graph[node]\\n for neighbor in neighbors.keys():\\n node_cost = cost + neighbors[neighbor]\\n if self.costs[neighbor] > node_cost:\\n self.costs[neighbor] = node_cost\\n self.parents[neighbor] = node\\n self.closed_nodes.append(node)\\n node = self._find_lowest_cost_node()\\n\\n return self.costs[\\\"fin\\\"]\",\n \"def smallMax(Ss, Gs, delta, source=None):\\n \\n BFS_handles = [next_delta_connected(Gs[i], Ss[i], delta, source and\\n source[i] or None) for i in xrange(len(Gs))]\\n\\n Vs = [set() for _ in xrange(len(Gs))]\\n ps = [True for _ in xrange(len(Gs))]\\n\\n while any(ps) and all(imap(lambda i: ps[i] or (len(Vs[i]) == len(Ss[i])), \\\\\\n xrange(len(Gs)))):\\n\\n for i in xrange(len(Gs)):\\n try: \\n v = next(BFS_handles[i])\\n Vs[i].add(v)\\n except StopIteration:\\n ps[i] = False\\n\\n # search for any maximal \\\\delta-set that is smaller than its input set...\\n for i in xrange(len(Gs)-1):\\n if not ps[i] and len(Vs[i]) != len(Ss[i]):\\n return i, Vs[i] \\n #... if none is found, return first set by default\\n return len(Gs)-1, Vs[len(Gs)-1]\",\n \"def get_cheapest_neighbor(client, facilities):\\n adj_facilities = client.get_facility_list(facilities)\\n return min(adj_facilities, key=lambda fac: fac['cost'])\",\n \"def _compute_best_value(self):\\n asgt = self._neighbors_values.copy()\\n best_cost, best_val = None, []\\n\\n for v in self._variable.domain:\\n asgt[self.variable.name] = v\\n c = self._compute_cost(**asgt)\\n if (\\n best_cost is None\\n or (best_cost > c and self._mode == \\\"min\\\")\\n or (best_cost < c and self._mode == \\\"max\\\")\\n ):\\n best_cost = c\\n best_val = [v]\\n elif best_cost == c:\\n best_val.append(v)\\n\\n return best_val, best_cost\",\n \"def get_next_unvisited(visited, shortest_paths):\\n min_dist = math.inf\\n min_node = None\\n for node_id in shortest_paths:\\n dist = shortest_paths[node_id][0]\\n if dist < min_dist and visited[node_id] == False:\\n min_dist = dist\\n min_node = node_id\\n return min_node\",\n \"def lovliest_path(G):\\n m = 0\\n ma = None\\n mb = None\\n for node in G.keys():\\n for conn in G[node].keys():\\n if G[node][conn] > m:\\n m = G[node][conn]\\n ma = node\\n mb = conn\\n print \\\"found lovliest_path of %s to %s with weight %s\\\" % (ma,mb,m)\\n return (ma,mb)\",\n \"def get_optimal_step(self, num_min):\\r\\n if self.pmax <= self.pmin:\\r\\n return None\\r\\n stepex = float(self.pmax - self.pmin) / num_min\\r\\n step1 = math.pow(10, math.floor(math.log(stepex, 10)))\\r\\n step2 = step1 * 2\\r\\n step5 = step1 * 5\\r\\n if step5 <= stepex:\\r\\n return step5\\r\\n if step2 <= stepex:\\r\\n return step2\\r\\n return step1\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def get_bprop_minimum(self):\\n input_grad = G.MinimumGrad()\\n\\n def bprop(x, y, out, dout):\\n dx, dy = input_grad(x, y, dout)\\n return dx, dy\\n return bprop\",\n \"def lnprior(params, params_min, params_max):\\n inSpace = 1\\n for i, p in enumerate(params):\\n inSpace = inSpace * (params_max[i] > p > params_min[i])\\n if inSpace == 0:\\n return -np.inf\\n else:\\n return 0\",\n \"def calc_slow(self, demands: Demand, routing: Routing) -> float:\\n edge_capacities = [e[2]['weight'] for e in\\n sorted(self.graph.edges(data=True))]\\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\\n # Because utilisation compared to link width is what we care about here\\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\\n\\n return np.max(ratio_capacities)\",\n \"def optimal(count):\\n\\n return _optimal(start, count)[0]\",\n \"def max_cardinality():\\r\\n #create a list containing the number of each vertex involvement.\\r\\n array = []\\r\\n for i in adj:\\r\\n array += [i[0],i[1]]\\r\\n\\r\\n #compute the degree by counting the involment\\r\\n degree = Counter(array).most_common()\\r\\n\\r\\n #retrieve the degree only\\r\\n degree_ = [ i[1] for i in degree]\\r\\n\\r\\n degree_ = np.array(degree_)\\r\\n \\r\\n max_m = None\\r\\n \\r\\n #check if m is valid\\r\\n for i in range(degree[0][1]+2)[2:]:\\r\\n \\r\\n #valid if there are at least m vertex with degree equals to at least m-1 \\r\\n if i < len(np.where(degree_>=i-1)[0]):\\r\\n max_m = i\\r\\n else:\\r\\n break\\r\\n max_m += 1\\r\\n print(f'maximum possible clique cardinality :{max_m}')\\r\\n return max_m\",\n \"def get_bprop_reducemax(self):\\n\\n def bprop(x, axis, out, dout):\\n dx = _min_or_max_grad(x, axis, out, dout)\\n return (dx, zeros_like(axis))\\n return bprop\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def findmaxmin(input_file):\\n\\tE_list = sub.check_output(\\\"check_maxmin.py {}\\\".format(input_file), shell=True).decode(\\\"utf-8\\\")\\n\\tEmax = float(re.search(r\\\"Maximum\\\\s*:\\\\s*(([+-]|\\\\s)\\\\d*\\\\.\\\\d+)\\\", E_list).group(1))\\n\\tEmin = float(re.search(r\\\"Minimum\\\\s*:\\\\s*(([+-]|\\\\s)\\\\d*\\\\.\\\\d+)\\\", E_list).group(1))\\n\\treturn Emax, Emin\",\n \"def min_network_performance(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"min_network_performance\\\")\",\n \"def calc_max_prev_node(graphs_path):\\n max_prev_node = []\\n count = len([name for name in os.listdir(graphs_path) if name.endswith(\\\".dat\\\")])\\n\\n max_prev_node = []\\n with Pool(processes=MAX_WORKERS) as pool:\\n for max_prev_node_g in tqdm(pool.imap_unordered(\\n partial(calc_max_prev_node_helper, graphs_path=graphs_path), list(range(count)))):\\n max_prev_node.extend(max_prev_node_g)\\n \\n max_prev_node = sorted(max_prev_node)[-1 * int(0.001 * len(max_prev_node))]\\n return max_prev_node\",\n \"def get_max_min(block_size):\\r\\n return (int(block_size / 2), int((block_size - 1) / 2))\",\n \"def __solve_alternative_linear_problem(self, user):\\n result = [0] * self.layout_slots\\n de_rand_approach = \\\"greedy\\\"\\n bins_per_category = []\\n bins_cardinality = []\\n for _ in range(len(self.categories)):\\n bins_per_category.append([])\\n bins_cardinality.append([])\\n\\n for cat in range(len(self.categories)):\\n for _ in range(len(self.news_row_pivots) + 1):\\n bins_per_category[cat].append([])\\n bins_cardinality[cat].append([])\\n for _ in range(len(self.news_column_pivots) + 1):\\n bins_per_category[cat][-1].append([])\\n bins_cardinality[cat][-1].append(0)\\n\\n for news in self.news_pool:\\n category_index = self.categories.index(news.news_category)\\n x, y = self.__compute_position_in_learning_matrix(user=user, news=news)\\n bins_per_category[category_index][x][y].append(news)\\n bins_cardinality[category_index][x][y] += 1\\n\\n index = 0\\n bin_samples = []\\n for cat in range(len(self.categories)):\\n for x in range(len(self.news_row_pivots) + 1):\\n for y in range(len(self.news_column_pivots) + 1):\\n if (y == 0) and (x != 0):\\n continue\\n self.alt_B[index] = min(bins_cardinality[cat][x][y], self.layout_slots)\\n index += 1\\n try:\\n selected_news = np.random.choice(bins_per_category[cat][x][y])\\n self.sample_quality(selected_news, user, interest_decay=True)\\n bin_samples += [selected_news.sampled_quality] * self.layout_slots\\n except ValueError:\\n bin_samples += [0] * self.layout_slots\\n\\n self.alt_C = np.array(list(np.array(self.alt_lambdas) * bin_samples)) * -1\\n linear_problem = opt.linprog(A_ub=self.alt_A, b_ub=self.alt_B, c=self.alt_C)\\n\\n # FOR EACH SLOT, ISOLATES THE CORRESPONDING VARIABLES\\n slots_assegnation_probabilities = []\\n slot_counter = 0\\n tmp_slot_probabilities = []\\n while slot_counter < self.layout_slots:\\n i = slot_counter\\n while i < len(linear_problem.x):\\n tmp_slot_probabilities.append(np.abs(linear_problem.x[i]))\\n i += self.layout_slots\\n slots_assegnation_probabilities.append(tmp_slot_probabilities.copy())\\n tmp_slot_probabilities.clear()\\n slot_counter += 1\\n\\n slot_promenances = self.real_slot_promenances.copy()\\n slot_promenances_norm = np.array(slot_promenances) / sum(slot_promenances)\\n slots_nr = [s for s in range(0, self.layout_slots)]\\n for i in range(self.layout_slots):\\n if de_rand_approach == \\\"ordered\\\":\\n k = i\\n elif (de_rand_approach == \\\"greedy\\\") or (de_rand_approach == \\\"greedy_max\\\"):\\n k = np.argmax(slot_promenances)\\n slot_promenances[k] = 0\\n elif de_rand_approach == \\\"randomized\\\":\\n k = np.random.choice(slots_nr, p=slot_promenances_norm)\\n slot_promenances[k] = 0\\n else:\\n raise RuntimeError(\\\"De_randomization approach not recognized. Try either 'ordered', 'greedy', \\\"\\n \\\"'randomized' or 'greedy_max'.\\\")\\n\\n target_slot_probabilities = [x for x in slots_assegnation_probabilities[k]]\\n target_slot_probabilities_norm = np.array(target_slot_probabilities) / sum(target_slot_probabilities)\\n if de_rand_approach == \\\"greedy_max\\\":\\n assigning_bin_index = np.argmax(target_slot_probabilities)\\n cat_index = int(assigning_bin_index / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin_index)][0]\\n y = self.bins_for_position[int(assigning_bin_index)][1]\\n\\n else:\\n assigning_bin = np.random.choice([x for x in range(len(slots_assegnation_probabilities[k]))], p=target_slot_probabilities_norm)\\n cat_index = int(assigning_bin / self.num_of_bins)\\n x = self.bins_for_position[int(assigning_bin)][0]\\n y = self.bins_for_position[int(assigning_bin)][1]\\n\\n result[k] = np.random.choice(bins_per_category[cat_index][x][y])\\n\\n return result\",\n \"def prim_MST():\\n node_list = list(node_set)\\n s = random.choice(node_list)\\n\\n val_s = -exp_node_weights[s][1] + exp_node_weights[s][0] # value of starting node\\n value = 0 # MST value\\n cost = 0 # MST cost\\n add_cost = 0\\n compensation = 0 # compensation for edges that are counted twice\\n\\n prev = [0]*no_nodes\\n dist = [math.inf]*no_nodes\\n S = set()\\n H = Heap(no_nodes)\\n H.insert(s, val_s, 0)\\n dist[s] = val_s\\n\\n for v in range(no_nodes):\\n H.insert(v, math.inf, 0)\\n\\n while H.size > 0:\\n v = H.delete_min()\\n if v[1] > 0: # min in Heap is of positive value, i.e., a cost, abort\\n break\\n\\n # abort if out of budget\\n cost += exp_node_weights[v[0]][0]\\n if cost > budget:\\n #print(value, compensation)\\n MST_value = -(value-compensation)\\n return (S, MST_value)\\n\\n # complementarity\\n for node in S:\\n for adjacent in exp_graph[node]:\\n if adjacent[0] == v[0]:\\n value -= adjacent[1]\\n\\n S.add(v[0])\\n value += v[1]\\n compensation += v[2] # necessary since edge weight was added to node quality already\\n\\n for w in exp_graph[v[0]]:\\n if not w[0] in S:\\n if dist[w[0]] > w[1]:\\n d = -w[1] - exp_node_weights[w[0]][1] + exp_node_weights[w[0]][0] # negate for maximum spanning tree\\n if d > 0: # bad/costly node\\n continue\\n dist[w[0]] = d\\n comp = -w[1]\\n prev[w[0]] = v[0]\\n H.decrease_key(w[0], dist[w[0]], comp)\\n\\n MST_value = -(value-compensation)\\n del H\\n return (S, MST_value, cost, add_cost)\",\n \"def __mini_max(self, board: Board, depth: int, is_max: bool, states: List[Board]) -> Tuple[int, Board]:\\n self.nodes_count += 1\\n if depth == 0:\\n return self.__moves_available(board), states[0]\\n all_moves = self.get_all_moves(board, self.player_color)\\n\\n if self.get_num_of_moves(board, self.opponent_color) == 0:\\n return 9999, states[0]\\n\\n func = max if is_max else min\\n return func([self.__mini_max(m, depth - 1, not is_max, states + [m]) for m in all_moves], key=lambda x: x[0])\",\n \"def get_bprop_maximum(self):\\n input_grad = G.MaximumGrad()\\n\\n def bprop(x, y, out, dout):\\n dx, dy = input_grad(x, y, dout)\\n return dx, dy\\n return bprop\",\n \"def find_max(self):\\n return max(self.nodes, key=int)\",\n \"def find_max_depth(start_url):\\n print \\\"****** sequence of links that must be followed to reach the page *****\\\"\\n S, Q = set(), deque()\\n Q.append(start_url)\\n while Q:\\n u = Q.popleft()\\n if u in S: continue\\n b = u\\n S.add(u)\\n Q.extend(getLinks(u))\\n find_shortest_path(start_url,b)\\n print \\\"****** URL that is the greatest distance from start_url *****\\\"\\n print b\",\n \"def getOptimalSolution(self):\\n max_index = np.argmax(self.Ws)\\n self.Wmax = self.Ws[max_index]\\n self.Emax = self.subsets[max_index]\\n return (self.Wmax, self.Emax)\",\n \"def test_max_flow(default_plugin_resolver):\\n dpr = default_plugin_resolver\\n source_node = 0\\n target_node = 7\\n ebunch = [\\n (0, 1, 9),\\n (0, 3, 10),\\n (1, 4, 3),\\n (2, 7, 6),\\n (3, 1, 2),\\n (3, 4, 8),\\n (4, 5, 7),\\n (4, 2, 4),\\n (5, 2, 5),\\n (5, 6, 1),\\n (6, 2, 11),\\n ]\\n nx_graph = nx.DiGraph()\\n nx_graph.add_weighted_edges_from(ebunch)\\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\\\"weight\\\")\\n\\n expected_flow_value = 6\\n bottleneck_nodes = {2, 4}\\n expected_nodemap = {2: 6, 4: 6}\\n\\n mv = MultiVerify(dpr)\\n results = mv.compute(\\\"flow.max_flow\\\", graph, source_node, target_node)\\n\\n # Compare flow rate\\n results[0].assert_equal(expected_flow_value)\\n\\n # Normalize actual flow to prepare to transform\\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\\n\\n # Compare sum of out edges for bottleneck nodes\\n out_edges = mv.transform(\\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n )\\n out_bottleneck = mv.transform(\\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\\n )\\n out_bottleneck.assert_equal(expected_nodemap)\\n\\n # Compare sum of in edges for bottleneck nodes\\n in_edges = mv.transform(\\n \\\"util.graph.aggregate_edges.core_networkx\\\",\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n in_edges=True,\\n out_edges=False,\\n )\\n in_bottleneck = mv.transform(\\n \\\"util.nodemap.select.core_python\\\", in_edges, bottleneck_nodes\\n )\\n in_bottleneck.assert_equal(expected_nodemap)\",\n \"def _get_lip_best(self) -> float:\\n pass\",\n \"def get_bprop_reducemin(self):\\n\\n def bprop(x, axis, out, dout):\\n dx = _min_or_max_grad(x, axis, out, dout)\\n return (dx, zeros_like(axis))\\n return bprop\",\n \"def minim(self):\\n cycles = self.get_elementary_cycles()\\n\\n for cycle in cycles:\\n # take back our clean graph (self._graph) and operate on it\\n nodes_concerned = []\\n for node in self._graph.node_list:\\n possible_names = [check_node.getName() for check_node in cycle]\\n if node.getName() in possible_names:\\n nodes_concerned.append(node)\\n possible_debts = []\\n\\n # inspect what the minimum debt is\\n for node in nodes_concerned:\\n next_node = node.getNext()\\n while next_node is not None:\\n if next_node.getCreditor() in nodes_concerned:\\n if int(next_node.getAmount()) != 0:\\n possible_debts.append(int(next_node.getAmount()))\\n break # Only once\\n next_node = next_node.getNext()\\n\\n # subtract that debt from all the debts in the cycle\\n least_debt = min(possible_debts)\\n for node in nodes_concerned:\\n next_node = node.getNext()\\n while next_node is not None:\\n if next_node.getCreditor() in nodes_concerned:\\n if int(next_node.getAmount()) != 0:\\n next_node.setAmount(str(int(next_node.getAmount()) - int(least_debt)))\\n break # Only once\\n next_node = next_node.getNext()\\n return self._graph\",\n \"def maximal_destination_for_passenger(state, problem):\\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\\n if unsatisfied:\\n max_dist = max([p.opt for p in unsatisfied])\\n return max_dist\\n return 0\",\n \"def find_waste_min(sol_total, solutions):\\n\\n\\twaste_min = solutions[0][2] + 1\\n\\n\\tfor sol_num in range(0, sol_total): # finds solution with lowest waste\\n\\t\\tif(waste_min > solutions[sol_num][2]):\\n\\t\\t\\topt = []\\n\\n\\t\\t\\twaste_min = solutions[sol_num][2]\\n\\t\\t\\tn = solutions[sol_num][0]\\n\\t\\t\\tm = solutions[sol_num][1]\\n\\n\\t\\t\\topt.append(waste_min)\\n\\t\\t\\topt.append(n)\\n\\t\\t\\topt.append(m)\\n\\n\\treturn opt\",\n \"def search_for_maximum(self):\\n return self.maximise_aquisition(self.expected_improvement)\",\n \"def min_target(board, depth, alpha, beta):\\n if terminal(board) or depth == DEPTH:\\n return utility(board)\\n\\n best_val = math.inf\\n for action in actions(board):\\n val = max_target(result(board, action), depth+1, alpha, beta)\\n best_val = min(val, best_val)\\n beta = min(beta, best_val)\\n if beta <= alpha:\\n break\\n\\n return best_val\",\n \"def bestVectorIndex(self):\\n return min(range(len(self.costs)), key=self.costs.__getitem__)\",\n \"def get_interval_from_minflow(self, wide=False):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.arc_info[arc][\\\"start\\\"],\\n # self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.arc_info[arc][\\\"destin\\\"],\\n # self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # x,\\n # self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.source(),\\n # x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.sink(),\\n # x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # x,\\n # self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".\\n # format(s_prime, v, int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".\\n # format(v, t_prime, int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n # s_prime,\\n # x,\\n # int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n # x,\\n # t_prime,\\n # int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i],\\n capacities[i],\\n unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n # print('Minimum cost:', min_cost_flow.OptimalCost())\\n # print('')\\n # print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n # cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n # print('%1s -> %1s %3s / %3s %3s' % (\\n # min_cost_flow.Tail(i),\\n # min_cost_flow.Head(i),\\n # min_cost_flow.Flow(i),\\n # min_cost_flow.Capacity(i),\\n # cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n # print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n # print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n # destin,\\n # sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in\\n self.arc_info[arc].keys()):\\n # print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n bound_1 = old_flow + sup_flow\\n bound_2 = old_flow - sup_flow\\n new_lb = max(0, int(min(bound_1, bound_2)))\\n new_ub = int(max(bound_1, bound_2))\\n if wide:\\n if new_lb == new_ub:\\n # print(\\\"We had a zero interval\\\")\\n new_lb = int(new_lb*0.8)\\n new_ub = int(new_ub*1.2)\\n if new_lb == 0:\\n # print(\\\"We got a zero lower bound\\\")\\n new_ub = 5\\n # print(\\\"But now we're doing {} {}\\\".\\n # format(new_lb, new_ub))\\n\\n self.arc_info[arc][\\\"lower_bound\\\"] = new_lb\\n self.arc_info[arc][\\\"upper_bound\\\"] = new_ub\\n # print(\\\"Edge ({},{}) bounds are [{},{}]\\\".format(\\n # start,\\n # destin,\\n # self.arc_info[arc][\\\"lower_bound\\\"],\\n # self.arc_info[arc][\\\"upper_bound\\\"]))\\n # print(self.arc_info[arc])\\n else:\\n print('There was an issue with the min cost flow input.')\\n # self.check_conservation_of_flow() # check that solution is valid\",\n \"def best_upper_bound(self):\\n if self._all_nodes:\\n return min(node.upper_bound for node in self._all_nodes)\\n else:\\n return np.inf\",\n \"def get_smallest_h_cost_unvisited_node(self):\\n node_list = []\\n for column in self.grid:\\n for node in column:\\n if node.pos in self.unvisited_pos:\\n node_list.append(node)\\n return min(node_list, key=lambda x: x.h_cost)\",\n \"def __dijkstra_max_prob_tree(unit_rules_graph, source_var):\\n variables = unit_rules_graph.vertices\\n dist = {var: -1.0 for var in variables}\\n dist[source_var] = 1.0\\n tree_nodes = {var: ParseTreeNode(var) for var in variables}\\n pending_vars = set(variables)\\n while pending_vars:\\n max_dist, max_dist_var = max((d, v) for v, d in dist.items() if v in pending_vars)\\n pending_vars.remove(max_dist_var)\\n for neighbor, prob in unit_rules_graph.neighbors[max_dist_var]:\\n if neighbor not in pending_vars:\\n continue\\n alt_dist = dist[max_dist_var] * prob\\n if dist[neighbor] is None or alt_dist > dist[neighbor]:\\n dist[neighbor] = alt_dist\\n tree_nodes[max_dist_var].children.append(tree_nodes[neighbor])\\n return ParseTree(tree_nodes[source_var])\",\n \"def get_smallest_f_cost_unvisited_node(self):\\n node_list = []\\n for column in self.grid:\\n for node in column:\\n if node.pos in self.unvisited_pos:\\n node_list.append(node)\\n min_f_cost_node = min(node_list, key=lambda x: x.g_cost)\\n min_f_cost_list = []\\n for column in self.grid:\\n for node in column:\\n if (\\n node.f_cost == min_f_cost_node.f_cost\\n and node.pos in self.unvisited_pos\\n ):\\n min_f_cost_list.append(node)\\n return min_f_cost_node, len(min_f_cost_list)\",\n \"def min_neighbor_node(g):\\r\\n return min(g.degree_iter(),key = lambda item:item[1])[0]\",\n \"def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\\n # set availbandwidth to the maximal value\\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\\n if d.type == 'STATIC':\\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\\n # subtract the reserved link and internal (inside Infras) bandwidth\\n if mode == self.MODE_ADD:\\n for d in self.infras:\\n for p in d.ports:\\n for fr in p.flowrules:\\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\\n # Flowrules are cummulatively subtracted from the switching \\n # capacity of the node.\\n d.availres['bandwidth'] -= fr.bandwidth\\n if d.availres['bandwidth'] < 0:\\n raise RuntimeError(\\\"The node bandwidth of %s got below zero \\\"\\n \\\"during available resource calculation!\\\" %\\n d.id)\\n # Get all the mapped paths of all SGHops from the NFFG\\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\\n for sg_hop_id, data in sg_map.iteritems():\\n src, dst, flowclass, bandwidth, delay, path = data\\n if bandwidth is not None:\\n for link in path:\\n link.availbandwidth -= bandwidth\\n if link.availbandwidth < 0:\\n raise RuntimeError(\\n \\\"The link bandwidth of %s got below zero during\\\"\\n \\\"available resource calculation!\\\" % link.id)\",\n \"def fmax(func_to_maximize, initial_guess=0.5*V):\\n func_to_minimize = lambda x : -func_to_maximize(x)\\n return fmin(func_to_minimize, initial_guess, disp=False)[0]\",\n \"def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,\\n best_path):\\n path[0] = path[0] + [start]\\n \\n if digraph.has_node(Node(start)) == False or digraph.has_node(Node(end)) == False:\\n raise ValueError('Start or end node are not valid')\\n elif start == end :\\n return path\\n else:\\n for edge in digraph.get_edges_for_node(Node(start)):\\n \\n node = str(edge.get_destination())\\n tot_distance = edge.get_total_distance() + path[1]\\n tot_outdoors = edge.get_outdoor_distance() + path[2]\\n\\n if node not in path[0] and tot_distance <= best_dist and tot_outdoors <= max_dist_outdoors :\\n updated_path = [path[0], tot_distance, tot_outdoors]\\n new_path = get_best_path(digraph, node, end, updated_path, max_dist_outdoors, best_dist, best_path)\\n \\n if new_path:\\n if not best_dist or new_path[1] < best_dist: \\n best_path = new_path[0]\\n best_dist = new_path[1]\\n\\n return best_path, best_dist\",\n \"def optimal_synthesis_decreasing_cost(self, max_cost=35, min_cost=10, precision=0.1, msw=0, max_depth=False):\\n cost = max_cost\\n result_file_names = []\\n\\n if not max_depth:\\n max_depth = self.num_modes\\n\\n while cost >= min_cost:\\n self.edit_cost(cost)\\n result_file_name = self.call_solver(precision, cost, ' --ode-opts --continue-after-not-reaching-horizon', msw=msw, max_depth=max_depth)\\n result_file_names.append(result_file_name)\\n cost -= 1\\n return result_file_names\",\n \"def get_maximum_fitness(self) -> float:\\n anticipated_change_cls = [cl for cl in self\\n if cl.does_anticipate_change()]\\n\\n if len(anticipated_change_cls) > 0:\\n best_cl = max(anticipated_change_cls, key=lambda cl: cl.fitness)\\n return best_cl.fitness\\n\\n return 0.0\",\n \"def calculate_min_max_tiles(self):\",\n \"def get_road_to(network, start, end):\\n roads_common = list( set(network[1][start][0]).intersection(network[1][end][1]) )\\n\\n minimum = None\\n if 0 < len(roads_common):\\n minimum = roads_common[0]\\n \\n for road in roads_common:\\n if get_length(network,minimum) > get_length(network,road):\\n minimum = road\\n \\n return minimum\",\n \"def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\\n #print slink_dict\\n #print \\\"FIND\\\"\\n failed_dict = model.failed_dict\\n #print failed_dict, limit\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n bw_matrix = model.cost_dict['bw']\\n #cpu_vector = model.cost_dict['cpu']\\n selected_dict = {}\\n \\n # get aggregated residual bw for all substrate nodes, and store it as a list\\n snode_bw_list = total_bw(bw_matrix)\\n \\n # get total capacity and used bw for each snode\\n node_port_list, used_bw_list = total_port(model)\\n #vnet_set = model.vnets\\n sorted_vn = sort_vnet(model)\\n\\n #for vnet in vnet_set:\\n if w_m[2] >= 10*w_m[1]:\\n threshold = 0.8\\n else:\\n threshold = 0.8\\n snode_traffic = {}\\n for vn_traffic in sorted_vn:\\n vnet = vn_traffic[0]\\n failed_vr = failed_dict[vnet.vnet_id]\\n if failed_vr != -1: \\n # this node is failed\\n standby_list = vnet.get_standby_ids()\\n standby_cost = {}\\n for s_vr in standby_list:\\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\\n failed_node = vnet.vnodes[failed_vr]\\n vneighbors = failed_node.vneighbors\\n dist_k = 0\\n rtt_k = 0\\n for k in vneighbors:\\n dist_k += float(dist_matrix[s_vr][k + 1])\\n rtt_k += float(rtt_matrix[s_vr][k + 1])\\n\\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\\\\n w_b[1] * rtt_k\\n res_cost = snode_bw_list[s_vr]\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\\n standby_cost[s_vr] = total\\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\\n #print \\\"SORTED\\\", sorted_x\\n \\n for item in sorted_x:\\n if item[0] not in snode_traffic:\\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n else:\\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n #print utilization\\n # Link-Path selsection add-on\\n path_alloc = 1\\n for k in vneighbors:\\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\\n item[0] + 1, k + 1)\\n demand = demand_dict[demand_id]['capacity']\\n find, path = find_path(demand_path, demand_id, \\n slink_dict, demand) \\n if find == 0:\\n print \\\"No available path between svr and nbr on the substrate network\\\" \\n path_alloc = 0\\n #print \\\"FIND PATH\\\", find, path\\n # End link-path block \\n #print \\\"ALLOCATED: \\\", path_alloc\\n if path_alloc == 1:\\n if selected_dict.values().count(item[0]) < limit:\\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\\n if item[0] not in snode_traffic: \\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] = vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break;\\n else:\\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \\n if min_id == item[0]:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n #threshold = (threshold + 0.01)/2\\n break\\n elif utilization < threshold:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n if item[0] not in snode_traffic: \\n snode_traffic[item[0]] = vn_traffic[1]\\n else:\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break\\n else:\\n print \\\"does not satisfy the threshold\\\" \\n # if a svr is selected -- item[0]\\n \\n \\n \\n else:\\n print \\\"cannot allocate paths\\\"\\n \\n #print slink_dict \\n return selected_dict, slink_dict\",\n \"def DRFindMinimalEdge(self, flow, edge_lst):\\n\\t\\tarr_time = flow[3]\\n\\t\\tend_time = flow[3] + flow[4]\\n\\t\\tmin_cum_size = float('inf')\\n\\t\\tmin_edge = (-1, -1)\\n\\t\\tfor e in edge_lst:\\n\\t\\t\\tprev_time = arr_time\\n\\t\\t\\tprev_rate = 0\\n\\t\\t\\tcum_size = 0\\n\\t\\t\\tfor time, rate in sorted(self.rate_lst[e].items()):\\n\\t\\t\\t\\tif time > arr_time:\\n\\t\\t\\t\\t\\tif time < end_time:\\n\\t\\t\\t\\t\\t\\tcum_size += prev_rate * (time - prev_time)\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tcum_size += prev_rate * (end_time - prev_time)\\n\\t\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\tif cum_size >= min_cum_size:\\n\\t\\t\\t\\t\\t# Break if already >= minimum\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\telif time >= end_time:\\n\\t\\t\\t\\t\\t# Break if time exceeds deadline\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\t\\tprev_time = time\\n\\t\\t\\t\\tprev_rate = rate\\n\\n\\t\\t\\tif cum_size < min_cum_size:\\n\\t\\t\\t\\tmin_cum_size = cum_size\\n\\t\\t\\t\\tmin_edge = e\\n\\n\\t\\treturn min_edge, min_cum_size\",\n \"def compute_optimal_block_maximum(block_counts) -> int:\\n q1, q3 = compute_quartiles(block_counts)\\n iqr = q3 - q1\\n high_threshold = q3 + 1.5 * iqr\\n return high_threshold\",\n \"def min_distance(distance, spt_set, self_nodes):\\n minimum = sys.maxsize\\n minimum_node = None\\n for curr_node in self_nodes.values():\\n if distance[curr_node.id] < minimum and not spt_set[curr_node.id]:\\n minimum = distance[curr_node.id]\\n minimum_node = curr_node\\n return minimum_node\",\n \"def get_max_and_min(self):\\n max_x = float('-inf')\\n min_x = float('inf')\\n max_y = float('-inf')\\n min_y = float('inf')\\n max_z = float('-inf')\\n min_z = float('inf')\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n counter = 0\\n for src, node in self._graph.get_all_v().items():\\n if node.location is not None:\\n x = node.location.x\\n y = node.location.y\\n z = node.location.z\\n counter += 1\\n max_x = x if x > max_x else max_x\\n min_x = x if x < min_x else min_x\\n max_y = y if y > max_y else max_y\\n min_y = y if y < min_y else min_y\\n max_z = z if z > max_z else max_z\\n min_z = z if z < min_z else min_z\\n if counter > 4:\\n ans = max_x, max_y, max_z, min_x, min_y, min_z\\n return ans\",\n \"def get_current_max_link(self):\\n return self.current_max_link\",\n \"def calc_strongest_bridge(comp_map: CompMap):\\n @lru_cache(None)\\n def _helper(cur_no_pins: int = 0, used_components: FrozenSet[Component] = frozenset()):\\n available_connections = comp_map[cur_no_pins] - used_components\\n\\n if not available_connections:\\n return sum(c.strength for c in used_components)\\n\\n res = []\\n for c in available_connections:\\n res.append(_helper(c.other(cur_no_pins), used_components | {c}))\\n return max(res)\\n res = _helper()\\n print(_helper.cache_info())\\n return res\",\n \"def test_node_weight_range_max(self):\\n n = Node(inputs=3)\\n for i in n.weights:\\n self.assertLess(i, 0.1)\",\n \"def mincost(L,m,n):\\n # find the length of the strings\\n # declaring the array for storing the dp values\\n tc = [[0]*(n + 1) for i in range(m + 1)]\\n tc[0][0]=L[0][0]\\n for i in range(1,m + 1):\\n tc[i][0]=tc[i-1][0]+L[i][0]\\n for j in range(1,n + 1):\\n tc[0][j]=tc[0][j-1]+L[0][j]\\n for i in range(1,m+1):\\n for j in range(1,n+1):\\n tc[i][j]=min(tc[i-1][j-1],tc[i-1][j],tc[i][j-1])+L[i][j]\\n\\n\\n # L[m][n] contains the length of LCS of X[0..n-1] & Y[0..m-1]\\n return tc[m][n]\",\n \"def get_best(self):\\n if len(self._table) == 0:\\n self.log.warning(\\\"table is empty, cannot extract best value\\\")\\n raise ValueError()\\n\\n max_prob = -np.inf\\n max_assignment = None\\n for assignment in self._table.keys():\\n prob = self._table[assignment]\\n if prob > max_prob:\\n max_prob = prob\\n max_assignment = assignment\\n\\n # TODO: check refactor > there is no case of max_assignment is None\\n return max_assignment if max_assignment is not None else Assignment.create_default(self._head_vars)\",\n \"def get_best_lower_bound(self):\\n if not self.tours:\\n raise Exception('No lower bound has been computed yet')\\n best = max(self.lower_bounds,key=self.lower_bounds.get)\\n print('The best lower bound is given by {} with score {}'.format(best,self.lower_bounds[best]))\\n return self.lower_bounds[best]\",\n \"def lazy_greedy_max(self, budget):\\r\\n\\r\\n classes, no_elements = torch.unique(self.y_trn, return_counts=True)\\r\\n len_unique_elements = no_elements.shape[0]\\r\\n per_class_bud = int(budget / len(classes))\\r\\n final_per_class_bud = []\\r\\n _, sorted_indices = torch.sort(no_elements, descending = True)\\r\\n\\r\\n if self.selection_type == 'PerClass':\\r\\n \\r\\n total_idxs = 0\\r\\n for n_element in no_elements:\\r\\n final_per_class_bud.append(min(per_class_bud, torch.IntTensor.item(n_element)))\\r\\n total_idxs += min(per_class_bud, torch.IntTensor.item(n_element))\\r\\n \\r\\n if total_idxs < budget:\\r\\n bud_difference = budget - total_idxs\\r\\n for i in range(len_unique_elements):\\r\\n available_idxs = torch.IntTensor.item(no_elements[sorted_indices[i]])-per_class_bud \\r\\n final_per_class_bud[sorted_indices[i]] += min(bud_difference, available_idxs)\\r\\n total_idxs += min(bud_difference, available_idxs)\\r\\n bud_difference = budget - total_idxs\\r\\n if bud_difference == 0:\\r\\n break\\r\\n\\r\\n total_greedy_list = []\\r\\n for i in range(len_unique_elements):\\r\\n idxs = torch.where(self.y_trn == classes[i])[0]\\r\\n \\r\\n if self.submod == 'facility_location':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'graph_cut':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'saturated_coverage':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'sum_redundancy':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\\r\\n n_samples=final_per_class_bud[i])\\r\\n elif self.submod == 'feature_based':\\r\\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=final_per_class_bud[i])\\r\\n\\r\\n if self.submod == 'feature_based':\\r\\n\\r\\n x_sub = fl.fit_transform(self.x_trn[idxs].numpy())\\r\\n greedyList = self.get_index(self.x_trn[idxs].numpy(), x_sub)\\r\\n total_greedy_list.extend(idxs[greedyList])\\r\\n\\r\\n else: \\r\\n\\r\\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\\r\\n greedyList = list(np.argmax(sim_sub, axis=1))\\r\\n total_greedy_list.extend(idxs[greedyList])\\r\\n\\r\\n elif self.selection_type == 'Supervised':\\r\\n \\r\\n \\r\\n if self.submod == 'feature_based':\\r\\n \\r\\n class_map = {}\\r\\n for i in range(len_unique_elements):\\r\\n class_map[torch.IntTensor.item(classes[i])] = i #Mapping classes from 0 to n\\r\\n \\r\\n sparse_data = torch.zeros([self.x_trn.shape[0], self.x_trn.shape[1]*len_unique_elements])\\r\\n for i in range(self.x_trn.shape[0]):\\r\\n \\r\\n start_col = class_map[torch.IntTensor.item(self.y_trn[i])]*self.x_trn.shape[1]\\r\\n end_col = start_col+self.x_trn.shape[1]\\r\\n sparse_data[i, start_col:end_col] = self.x_trn[i, :]\\r\\n\\r\\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\\r\\n x_sub = fl.fit_transform(sparse_data.numpy())\\r\\n total_greedy_list = self.get_index(sparse_data.numpy(), x_sub)\\r\\n\\r\\n else:\\r\\n for i in range(len(classes)):\\r\\n \\r\\n if i == 0:\\r\\n idxs = torch.where(self.y_trn == classes[i])[0]\\r\\n N = len(idxs)\\r\\n self.compute_score(idxs)\\r\\n row = idxs.repeat_interleave(N)\\r\\n col = idxs.repeat(N)\\r\\n data = self.dist_mat.cpu().numpy().flatten()\\r\\n else:\\r\\n idxs = torch.where(self.y_trn == classes[i])[0]\\r\\n N = len(idxs)\\r\\n self.compute_score(idxs)\\r\\n row = torch.cat((row, idxs.repeat_interleave(N)), dim=0)\\r\\n col = torch.cat((col, idxs.repeat(N)), dim=0)\\r\\n data = np.concatenate([data, self.dist_mat.cpu().numpy().flatten()], axis=0)\\r\\n \\r\\n \\r\\n sparse_simmat = csr_matrix((data, (row.numpy(), col.numpy())), shape=(self.N_trn, self.N_trn))\\r\\n #self.dist_mat = sparse_simmat\\r\\n\\r\\n if self.submod == 'facility_location':\\r\\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'graph_cut':\\r\\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'saturated_coverage':\\r\\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'sum_redundancy':\\r\\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n sim_sub = fl.fit_transform(sparse_simmat)\\r\\n total_greedy_list = list(np.array(np.argmax(sim_sub, axis=1)).reshape(-1))\\r\\n\\r\\n\\r\\n if self.selection_type == 'Full':\\r\\n \\r\\n\\r\\n total_greedy_list = []\\r\\n idx_end = self.x_trn.shape[0] - 1\\r\\n idxs = torch.linspace(0, idx_end, self.x_trn.shape[0]).long()\\r\\n\\r\\n if self.submod == 'facility_location':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.facilityLocation.FacilityLocationSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'graph_cut':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.graphCut.GraphCutSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'saturated_coverage':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.saturatedCoverage.SaturatedCoverageSelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'sum_redundancy':\\r\\n self.compute_score(idxs)\\r\\n fl = apricot.functions.sumRedundancy.SumRedundancySelection(random_state=0, metric='precomputed',\\r\\n n_samples=budget)\\r\\n elif self.submod == 'feature_based':\\r\\n fl = apricot.functions.featureBased.FeatureBasedSelection(random_state=0, n_samples=budget)\\r\\n\\r\\n if self.submod == 'feature_based':\\r\\n\\r\\n x_sub = fl.fit_transform(self.x_trn.numpy())\\r\\n total_greedy_list = self.get_index(self.x_trn.numpy(), x_sub)\\r\\n\\r\\n else: \\r\\n\\r\\n sim_sub = fl.fit_transform(self.dist_mat.cpu().numpy())\\r\\n total_greedy_list = list(np.argmax(sim_sub, axis=1))\\r\\n\\r\\n return total_greedy_list\",\n \"def max_weight(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def probabilityTransitionRule(self, unvisitedHeuristics, totalUnvisited):\\n argMaxProbValue = 0\\n argMaxToken = None\\n for unvisitedToken in unvisitedHeuristics:\\n probValue = unvisitedHeuristics[unvisitedToken] / totalUnvisited\\n\\n # In case obtained value is higher than previous maximum, substitute\\n if probValue > argMaxProbValue:\\n argMaxProbValue = probValue\\n argMaxToken = unvisitedToken\\n\\n return argMaxToken\",\n \"def best_unexplored_lower_bound(self):\\n if self._unexplored_nodes:\\n return min(node.lower_bound for node in self._unexplored_nodes)\\n else:\\n return 0.0\",\n \"def find_free(min_=0):\\n while is_occupied(min_):\\n min_ += 1\\n return min_\",\n \"def strategy_cheap(cookies, cps, history, time_left, build_info):\\n min_item = None\\n min_cost = float('inf')\\n for item in build_info.build_items():\\n if build_info.get_cost(item) <= min_cost:\\n min_item = item\\n min_cost = build_info.get_cost(item)\\n\\n if (time_left * cps + cookies) < min_cost:\\n min_item = None\\n\\n print \\\"min item\\\", min_item\\n print \\\"min_cost:\\\", min_cost\\n print \\\"CPS:\\\", cps\\n print \\\"Time Left:\\\", time_left\\n print time_left * cps + cookies\\n\\n return min_item\",\n \"def required_gpu_maximum(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"required_gpu_maximum\\\")\",\n \"def estimate_cost(q, n, max_m, s, attacks):\\n r = [float('inf')] * 3\\n for cost in [primal_cost, dual_cost]:\\n for i, attack in enumerate(attacks):\\n _, _, c = optimize_attack(q, n, max_m, s, cost, attack)\\n r[i] = min(r[i], c)\\n return r\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def fmax(func_to_maximize, initial_guess=0):\\n func_to_minimize = lambda x : -func_to_maximize(x)\\n return fmin(func_to_minimize, initial_guess, disp=False)[0]\",\n \"def largestResolution(resolutions):\\n return resolutions[0]\",\n \"def calc_overall_link_utilisation(self, demands: Demand,\\n routing: Routing) -> np.ndarray:\\n flows = [(i, j) for i in range(self.num_nodes)\\n for j in range(self.num_nodes)\\n if i != j]\\n\\n link_utilisation = np.zeros(self.num_edges)\\n\\n for i, flow in enumerate(flows):\\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\\n demands[\\n i],\\n routing[\\n i])\\n link_utilisation += flow_link_utilisation\\n\\n return link_utilisation\",\n \"def __mini_max_ab(self,\\n board: Board,\\n depth: int,\\n is_max: bool,\\n alpha: int,\\n beta: int,\\n states: List[Board]\\n ) -> Tuple[int, Board]:\\n self.nodes_count += 1\\n if depth == 0:\\n return self.__moves_available(board), states[0]\\n if self.get_num_of_moves(board, self.opponent_color) == 0:\\n return 9999, states[0]\\n all_moves = self.get_all_moves(board, self.player_color)\\n\\n if is_max:\\n best = (-9999, board)\\n for move in all_moves:\\n next_state = self.__mini_max_ab(move, depth - 1, False, alpha, beta, states + [move])\\n best = max(best, next_state, key=lambda x: x[0])\\n alpha = max(alpha, best[0])\\n if beta <= alpha:\\n self.pruning_count += 1\\n break\\n return best\\n else:\\n best = (9999, board)\\n for move in all_moves:\\n next_state = self.__mini_max_ab(move, depth - 1, True, alpha, beta, states + [move])\\n best = min(best, next_state, key=lambda x: x[0])\\n beta = min(beta, best[0])\\n if beta <= alpha:\\n self.pruning_count += 1\\n break\\n return best\",\n \"def get_max_lb(self):\\n max_lb = 0\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"lower_bound\\\"] > max_lb:\\n max_lb = self.arc_info[arc][\\\"lower_bound\\\"]\\n return max_lb\",\n \"def max_network_performance(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_network_performance\\\")\",\n \"def _joint_nodes(self, job, node_avl, res_type=None):\\n if not res_type:\\n _min = min([node_avl[res_type] // v for res_type, v in job.requested_resources.items() if v > 0])\\n return _min\\n return node_avl[res_type] // job.requested_resources[res_type]\",\n \"def getNextNodeUsingTotalStepsToTravel(kGoalState):\\n \\n global fringe\\n global solutions\\n\\n\\n\\n minNode = None\\n minCost = 99999999999\\n minNodeIndex = -1\\n\\n \\n pnode = None\\n pcost = None\\n\\n if len(solutions)>0 and solutions[0] != None:\\n pnode = solutions[0];\\n pcost = getTotalStepsToReachGoalState(pnode,kGoalState)\\n # print pnode, pcost\\n # raw_input()\\n \\n\\n\\n\\n for idx,node in enumerate(fringe):\\n #get the heu. function values\\n g_value =getTotalStepsToReachGoalState(node,kGoalState)\\n \\n\\n if g_value < minCost:\\n minNode = node\\n minNodeIndex = idx\\n minCost = g_value\\n\\n\\n fringe.pop(minNodeIndex)\\n c = getTotalStepsToReachGoalState(minNode,kGoalState)\\n if pnode != None:\\n if c > pcost:\\n minNode = None\\n \\n return minNode\",\n \"def search_best_goal_node(self):\\n\\n dist_to_goal_list = [self.calc_dist_to_goal(n.x, n.y) for n in self.node_list]\\n goal_indexes = [\\n dist_to_goal_list.index(i)\\n for i in dist_to_goal_list\\n if i <= self.expand_dis\\n ]\\n\\n safe_goal_indexes = []\\n for goal_index in goal_indexes:\\n t_node = self.steer(self.node_list[goal_index], self.goal_node)\\n if self.check_collision(t_node, self.obstacle_list):\\n safe_goal_indexes.append(goal_index)\\n\\n if not safe_goal_indexes:\\n return None\\n\\n min_cost = min([self.node_list[i].cost for i in safe_goal_indexes])\\n for i in safe_goal_indexes:\\n if self.node_list[i].cost == min_cost:\\n return i\\n\\n return None\",\n \"def pre_processing(self):\\n while self.number_of_dmax() < 1:\\n self.dmax -= 1\\n __edges = self.current_edges()\\n print('current edges =', __edges, ' expected edges =', self.edges)\\n if __edges < self.edges:\\n __temp = self.dmax\\n __l = self.dmax\\n self.dmax *= 2\\n __r = self.dmax\\n while self.number_of_dmax() >= 1 and __r < self.nodes:\\n __l = __r\\n self.dmax *= 2\\n __r = self.dmax\\n while __l < __r:\\n self.dmax = int((__l + __r) / 2)\\n if self.number_of_dmax() < 1:\\n __r = self.dmax\\n else:\\n __l = self.dmax + 1\\n self.dmax = __l - 1\\n __edges = self.current_edges()\\n if __edges > self.edges:\\n __l = __temp\\n __r = self.dmax\\n while __l < __r:\\n self.dmax = int((__l + __r) / 2)\\n __edges = self.current_edges()\\n if __edges > self.edges:\\n __r = self.dmax\\n else:\\n __l = self.dmax + 1\\n self.dmax = __l - 1\\n print('adjust dmax =', self.dmax, ' edges =', int(__edges))\\n elif __edges > self.edges:\\n __temp1 = [_ ** self.lmd for _ in range(self.dmin, self.dmax + 1)]\\n __temp2 = [_ * __ for _, __ in zip(__temp1, list(range(self.dmin, self.dmax+1)))]\\n c = self.edges / sum(__temp2)\\n n = c * sum(__temp1)\\n self.select_p = n / self.nodes\\n print('reduce select p =', self.select_p)\",\n \"def get_best(self, population):\\n best = min(population, key=self.cost_function)\\n return best, self.cost_function(best)\",\n \"def opt_settlement(player, board, gains, goal=\\\"default\\\"):\\n goal_index = goal_list.get(goal, 0)\\n vertex_score = lambda t: vertex_eval(player, board, t[0], gains, goal_index)\\n vertex_list = [(v, board.get_vertex_location(v)) for v in range(board.max_vertex+1) \\\\\\n if board.if_can_build(\\\"settlement\\\", *(board.get_vertex_location(v)))]\\n return max(vertex_list, key = vertex_score, default=(None, None))\",\n \"def choose_max_efficiency(efficiencies):\\n if type(efficiencies) == list or type(efficiencies) == tuple:\\n return max(map(float,efficiencies)) \\n else:\\n return float(efficiencies)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6206008","0.61956775","0.61796796","0.6167126","0.6034246","0.58196956","0.5767577","0.57007045","0.5692291","0.5689462","0.5678431","0.56615597","0.5658582","0.5644581","0.5641445","0.564055","0.5603883","0.5592757","0.5569047","0.5535338","0.5527755","0.5520978","0.5520648","0.55119294","0.5506627","0.5495627","0.54878074","0.5454127","0.5429707","0.54072994","0.54022104","0.5397602","0.53965837","0.5385299","0.53830355","0.5374855","0.5373514","0.5360256","0.53532606","0.535127","0.53396463","0.5336005","0.53322613","0.53305876","0.532706","0.5322781","0.5315278","0.5311538","0.5310787","0.530874","0.5308445","0.5304706","0.529306","0.5291827","0.5290595","0.5290078","0.52811146","0.5280405","0.52789414","0.52782744","0.52764463","0.52684534","0.52673733","0.52663434","0.52637","0.5261467","0.52537864","0.5253408","0.5244946","0.52413136","0.5231579","0.52303475","0.52290523","0.5227402","0.521997","0.5219444","0.5219064","0.5213659","0.52112454","0.520991","0.5208612","0.5206732","0.52023274","0.52021116","0.51995313","0.5198759","0.5193763","0.51920366","0.51863277","0.5186013","0.51731974","0.51708835","0.51670665","0.5166898","0.5156025","0.51558673","0.5151737","0.5151366","0.5150319","0.51502293"],"string":"[\n \"0.6206008\",\n \"0.61956775\",\n \"0.61796796\",\n \"0.6167126\",\n \"0.6034246\",\n \"0.58196956\",\n \"0.5767577\",\n \"0.57007045\",\n \"0.5692291\",\n \"0.5689462\",\n \"0.5678431\",\n \"0.56615597\",\n \"0.5658582\",\n \"0.5644581\",\n \"0.5641445\",\n \"0.564055\",\n \"0.5603883\",\n \"0.5592757\",\n \"0.5569047\",\n \"0.5535338\",\n \"0.5527755\",\n \"0.5520978\",\n \"0.5520648\",\n \"0.55119294\",\n \"0.5506627\",\n \"0.5495627\",\n \"0.54878074\",\n \"0.5454127\",\n \"0.5429707\",\n \"0.54072994\",\n \"0.54022104\",\n \"0.5397602\",\n \"0.53965837\",\n \"0.5385299\",\n \"0.53830355\",\n \"0.5374855\",\n \"0.5373514\",\n \"0.5360256\",\n \"0.53532606\",\n \"0.535127\",\n \"0.53396463\",\n \"0.5336005\",\n \"0.53322613\",\n \"0.53305876\",\n \"0.532706\",\n \"0.5322781\",\n \"0.5315278\",\n \"0.5311538\",\n \"0.5310787\",\n \"0.530874\",\n \"0.5308445\",\n \"0.5304706\",\n \"0.529306\",\n \"0.5291827\",\n \"0.5290595\",\n \"0.5290078\",\n \"0.52811146\",\n \"0.5280405\",\n \"0.52789414\",\n \"0.52782744\",\n \"0.52764463\",\n \"0.52684534\",\n \"0.52673733\",\n \"0.52663434\",\n \"0.52637\",\n \"0.5261467\",\n \"0.52537864\",\n \"0.5253408\",\n \"0.5244946\",\n \"0.52413136\",\n \"0.5231579\",\n \"0.52303475\",\n \"0.52290523\",\n \"0.5227402\",\n \"0.521997\",\n \"0.5219444\",\n \"0.5219064\",\n \"0.5213659\",\n \"0.52112454\",\n \"0.520991\",\n \"0.5208612\",\n \"0.5206732\",\n \"0.52023274\",\n \"0.52021116\",\n \"0.51995313\",\n \"0.5198759\",\n \"0.5193763\",\n \"0.51920366\",\n \"0.51863277\",\n \"0.5186013\",\n \"0.51731974\",\n \"0.51708835\",\n \"0.51670665\",\n \"0.5166898\",\n \"0.5156025\",\n \"0.51558673\",\n \"0.5151737\",\n \"0.5151366\",\n \"0.5150319\",\n \"0.51502293\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59470457"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":23588,"cells":{"query":{"kind":"string","value":"Calculates the link utilisation over a graph for a particular flow and its demand. (NB utilisation in bandwidth, not relative to capacity)"},"document":{"kind":"string","value":"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation","def compute_path_metric(self, sw, path, util, time_now, local_contrib):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n # Use the last-learned-via-sync value for a link\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\n used1 = self.graph[u][v]['sync_learned'] + util\n used2 = self.graph[u][v]['used'] + util\n # ['used'] is a strict lower bound for ['sync_learned']\n if used1 > used2: \n used = used1\n logging.debug(\"CS [%s] using sync_learned value 1 [%f]\", str(self.name), used1)\n else:\n used = used2\n logging.debug(\"CS [%s] using sync_learned value 2 [%f]\", str(self.name), used2)\n else:\n logging.debug(\"CS [%s] using tracking value\", str(self.name))\n used = self.graph[u][v]['used'] + util\n\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def compute_path_metric(self, sw, path, util, time_now):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\n #only include extra-domain state when not stale (timestamp), 3) always exclude\n #extra-domain state when calculating the path metric? Here we do (1)\n used = self.graph[u][v]['used'] + util\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def calc_slow(self, demands: Demand, routing: Routing) -> float:\n edge_capacities = [e[2]['weight'] for e in\n sorted(self.graph.edges(data=True))]\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\n # Because utilisation compared to link width is what we care about here\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\n\n return np.max(ratio_capacities)","def compute_link_utilization_over_time(link_byte_counts):\n def find_matching_iface_stats(byte_count, source_id, destination_id):\n matching_stats = [d_i for d_i in byte_count\n if d_i[\"sourceSwitchId\"] == source_id and\n d_i[\"destinationSwitchId\"] == destination_id]\n if len(matching_stats) != 1:\n raise ValueError(\"Unexpected results in find_matching_iface_stats. \\\n Found %d matching iface_stats\" % len(matching_stats))\n return matching_stats[0]\n\n def compute_tx_rate(count_in_bytes):\n return (count_in_bytes * 8) / 10.0**7\n\n # First compute the delta between the iface_stats in time_period t_i and the iface_stats\n # in time period t_{i+1}.\n # tx_rate_t: (source_id x destination_id) -> link_utilization_in_time_period_t forall. t\n tx_rate_t = []\n for t_0, t_1 in zip(link_byte_counts, link_byte_counts[1:]):\n byte_count_delta_t = defaultdict(float)\n for iface_stats in t_0:\n source_id = iface_stats[\"sourceSwitchId\"]\n destination_id = iface_stats[\"destinationSwitchId\"]\n t_0_count = iface_stats[\"bytesSent\"] + iface_stats[\"bytesReceived\"]\n try:\n t_1_stats = find_matching_iface_stats(t_1, source_id, destination_id)\n t_1_count = t_1_stats[\"bytesSent\"] + t_1_stats[\"bytesReceived\"]\n except ValueError:\n t_1_count = t_0_count\n\n count_delta = t_1_count - t_0_count\n link_key = compute_link_key(source_id, \n destination_id)\n byte_count_delta_t[link_key] += count_delta\n\n tx_rate_t.append({the_link_key: compute_tx_rate(byte_count_t) \n for the_link_key, byte_count_t in byte_count_delta_t.items()})\n return tx_rate_t","def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\n # set availbandwidth to the maximal value\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\n if d.type == 'STATIC':\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\n # subtract the reserved link and internal (inside Infras) bandwidth\n if mode == self.MODE_ADD:\n for d in self.infras:\n for p in d.ports:\n for fr in p.flowrules:\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\n # Flowrules are cummulatively subtracted from the switching \n # capacity of the node.\n d.availres['bandwidth'] -= fr.bandwidth\n if d.availres['bandwidth'] < 0:\n raise RuntimeError(\"The node bandwidth of %s got below zero \"\n \"during available resource calculation!\" %\n d.id)\n # Get all the mapped paths of all SGHops from the NFFG\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\n for sg_hop_id, data in sg_map.iteritems():\n src, dst, flowclass, bandwidth, delay, path = data\n if bandwidth is not None:\n for link in path:\n link.availbandwidth -= bandwidth\n if link.availbandwidth < 0:\n raise RuntimeError(\n \"The link bandwidth of %s got below zero during\"\n \"available resource calculation!\" % link.id)","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def opt(self, demands: Demand) -> float:\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('multicommodity_flow_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the splitting ratios for each edge\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(self.num_edges):\n flow_variable_edges.append(\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Capacity constraint\n capacity_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint between 0 and edge capacity\n constraint_i = solver.Constraint(\n 0, self.graph.get_edge_data(*edge)['weight'],\n '(1,{},{})'.format(*edge))\n for j, commodity in enumerate(self.commodities):\n # Coefficient for jth flow over ith edge is scaled by flow width\n constraint_i.SetCoefficient(flow_variables[j][i],\n # cast because or-tools :'(\n float(demands[j]))\n capacity_constraints.append(constraint_i)\n\n # Conservation on transit nodes\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.num_nodes):\n if j != commodity[0] and j != commodity[1]:\n # Constraint must sum to zero\n constraint_j = solver.Constraint(0, 0,\n '(2,{},{})'.format(i, j))\n for k in list(sorted(self.graph.adj[j].keys())):\n # Ingress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\n # Egress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Conservation of flow at source node\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[0], edge_dest)]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[0])]],\n -1)\n conservation_source_constraints.append(constraint_i)\n\n # Conservation of flow at destination node\n conservation_dest_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[1])]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[1], edge_dest)]],\n -1)\n conservation_dest_constraints.append(constraint_i)\n\n ## OBJECTIVES\n # Implementation of the load-balancing example from Wikipedia\n # First we add more constraints so that we are minimising the maximum\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\n 'max_link_utilisation')\n min_of_max_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\n # i.e 'f_0 + f_1 + ... < max'\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\n '(5,{})'.format(i))\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\n for j, flow_variable in enumerate(flow_variables):\n constraint_i.SetCoefficient(flow_variable[i],\n demands[j] /\n self.graph.get_edge_data(*edge)[\n 'weight'])\n min_of_max_constraints.append(constraint_i)\n\n # Objective now is to minimise the maximum link utilisation\n objective = solver.Objective()\n objective.SetCoefficient(max_utilisation_variable, 1)\n objective.SetMinimization()\n solver.Solve()\n\n return objective.Value()","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def cost(graph,a, undirected=True):\n cost = sum(sum(np.array(abs(graph-a))))\n if undirected:\n return cost/2.0\n else:\n return cost","def get_link_cost(self, global_clock_sec):\n return self.static_delay_sec + \\\n self.link_buffer.get_average_q_del_sec(global_clock_sec)","def calc_demand(self, routing: np.ndarray, demand: float,\n commodity_idx: int) -> np.ndarray:\n commodity = self.commodities[commodity_idx]\n node_flow = np.zeros(self.num_nodes)\n node_flow[commodity[0]] = demand\n\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\n for edge_idx, edge in enumerate(self.edges):\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\n\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\n\n num_steps = 0\n while True:\n change = np.multiply(split_matrix, node_flow)\n edge_utilisation += change\n node_flow = np.matmul(split_matrix, node_flow)\n if np.any(np.isnan(change)):\n print(\"is_nan :'(\")\n comparison = np.less(np.nan_to_num(change), self.min_delta)\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\n break\n num_steps += 1\n # if we take more than |E| steps we have cycles which is not good.\n # Therefore: end here with really bad reward, scaled by number of\n # cycles\n if num_steps > routing.shape[1]:\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\n edge_utilisation += np.multiply(remaining_flow, np.full(\n (self.num_nodes, self.num_nodes), demand))\n break\n\n return edge_utilisation","def calc_cost(self):\n cost = 0\n for i,[source, sinks] in enumerate(self.nets):\n self.costs[i] = self.calc_half_perimeter(source, sinks)\n cost += self.costs[i]\n self.cost = cost\n return True","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def compute_unequal_flow_allocations(target_graph, K=3):\n\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n link_utilization = {}\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - {node}\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \n replace=False).item()\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\n the_flow = Flow( source_node = node\n , destination_node = destination_node\n , flow_tx_rate = 10.0\n , paths = [shortest_path]\n , splitting_ratio = [1.0]\n )\n flows.append(the_flow)\n\n return flow_allocation_seed_number, flows","def add_link_capacity(self, path, bw):\n\n # PART 1, TASK 3.4 add bw to edges","def calculate_demand(flow, requested_sf, available_sf, service_functions):\n\n if requested_sf in available_sf:\n vnf_need_placement = False\n demanded_total_capacity = 0.0\n for sf_i, sf_data in available_sf.items():\n if requested_sf == sf_i:\n # Include flows data rate in requested sf capacity calculation\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\n sf_data['load'] + flow.dr)\n else:\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\n return demanded_total_capacity, vnf_need_placement\n else:\n vnf_need_placement = True\n available_sf[requested_sf] = {'load': 0.0}\n demanded_total_capacity = 0.0\n for sf_i, sf_data in available_sf.items():\n if requested_sf == sf_i:\n # Include flows data rate in requested sf capacity calculation\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\n sf_data['load'] + flow.dr)\n else:\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\n del available_sf[requested_sf]\n return demanded_total_capacity, vnf_need_placement","def objective(graph, flows):\n\n G = graph.copy()\n rules = {}\n flows.sort(key=lambda a: a[1], reverse=True)\n\n for flow,demand in flows:\n src = get_host_from_ip(G, flow.nw_src)\n dst = get_host_from_ip(G, flow.nw_dst)\n\n if not (src and dst):\n continue\n if not (src in G.nodes() and dst in G.nodes()):\n continue\n\n path = widest_path(G, src, dst)\n\n hops = []\n for a,b in pairwise(path):\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\n G.edge[a][b]['capacity'] -= demand\n G.edge[b][a]['capacity'] -= demand\n\n rules[flow] = hops\n\n return rules","def global_efficiency(graph):\n return nx.global_efficiency(graph.graph)","def maximum_flow(graph, start, end):\n if not isinstance(graph, BasicGraph):\n raise TypeError(f\"Expected subclass of BasicGraph, not {type(graph)}\")\n Graph = type(graph)\n \n if start not in graph:\n raise ValueError(f\"{start} not in graph\")\n if end not in graph:\n raise ValueError(f\"{end} not in graph\")\n\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\n total_flow = 0\n # -----------------------------------------------------------------------\n # The algorithm\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\n # of DFS, which leads to a lot of node visits.\n #\n # I therefore choose to invert the capacities of the graph so that the\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\n # This allows me to use the shortest path method to find the path with\n # most capacity in the first attempt, resulting in a significant reduction\n # of unassigned flow.\n #\n # By updating G_inverted, with the residual capacity, I can keep using the\n # shortest path, until the capacity is zero, whereby I remove the links\n # When the shortest path method returns 'No path' or when unassigned flow\n # is zero, I exit the algorithm.\n #\n # Even on small graphs, this method is very efficient, despite the overhead\n # of using shortest path. For very large graphs, this method outperforms\n # all other algorithms by orders of magnitude.\n # -----------------------------------------------------------------------\n\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\n inverted_graph = Graph(from_list=edges) # create G_inverted.\n capacity_graph = Graph() # Create structure to record capacity left.\n flow_graph = Graph() # Create structure to record flows.\n\n while unassigned_flow:\n # 1. find the best path\n d, path = shortest_path(inverted_graph, start, end)\n if d == float(\"inf\"): # then there is no path, and we must exit.\n return total_flow, flow_graph\n # else: use the path and lookup the actual flow from the capacity graph.\n\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\"inf\"))) for s, e, d in graph.edges(path=path)])\n\n # 2. update the unassigned flow.\n unassigned_flow -= path_flow\n total_flow += path_flow\n\n # 3. record the flows and update the inverted graph, so that it is\n # ready for the next iteration.\n edges = graph.edges(path)\n for n1, n2, d in edges:\n # 3.a. recording:\n v = flow_graph.edge(n1, n2, default=None)\n if v is None:\n flow_graph.add_edge(n1, n2, path_flow)\n c = graph.edge(n1, n2) - path_flow\n else:\n flow_graph.add_edge(n1, n2, value=v + path_flow)\n c = graph.edge(n1, n2) - (v + path_flow)\n capacity_graph.add_edge(n1, n2, c)\n\n # 3.b. updating:\n # if there is capacity left: update with new 1/capacity\n # else: remove node, as we can't do 1/zero.\n if c > 0:\n inverted_graph.add_edge(n1, n2, 1 / c)\n else:\n inverted_graph.del_edge(n1, n2)\n return total_flow, flow_graph","def update_flow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n # (1): add all edges (u, v) with capacity ub-lb\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"upper_bound\"] == float('inf'):\n self.arc_info[arc][\"upper_bound\"] = B\n for arc in self.arc_info.keys():\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(int(self.arc_info[arc][\"upper_bound\"]\\\n - self.arc_info[arc][\"lower_bound\"]))\n # (2): add edge (t, s) with capacity B\n # B = max_lb * (m - n + 2)\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n if B == 0:\n #B = float('inf')\n B = 100000\n start_nodes.append(self.sink())\n end_nodes.append(self.source())\n capacities.append(int(B))\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\n s_prime = max(self.vertices) + 1\n t_prime = max(self.vertices) + 2\n print(\"s'={}, t'={}\".format(s_prime, t_prime))\n for v in self:\n #print(\"vert {} in arcs: {}\".format(v,\n # self.in_arcs_lists[v]))\n # compute exc: lower bounds of in - lower bounds of out\n sum_lb_in = 0\n for in_arc in self.in_arcs_lists[v]:\n sum_lb_in += self.arc_info[in_arc][\"lower_bound\"]\n sum_lb_out = 0\n #print(\"vert {} out arcs: {}\".format(v,\n # self.out_arcs_lists[v]))\n for out_arc in self.out_arcs_lists[v]:\n sum_lb_out += self.arc_info[out_arc][\"lower_bound\"]\n exc = sum_lb_in - sum_lb_out\n #print(\"exc is {}\".format(exc))\n if exc > 0:\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(exc))\n else:\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(-exc))\n # solve maxflow\n #print(\"s' is {} and t' is {}\".format(s_prime, t_prime))\n max_flow = pywrapgraph.SimpleMaxFlow()\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\n #print(\"Adding edge {}, {} with cap {}\".format(u,v,cap))\n max_flow.AddArcWithCapacity(u, v, cap)\n success = True\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\n #print(' Arc Flow / Capacity')\n for i in range(max_flow.NumArcs()):\n # print('%1s -> %1s %3s / %3s' % (\n # max_flow.Tail(i),\n # max_flow.Head(i),\n # max_flow.Flow(i),\n # max_flow.Capacity(i)))\n # check that (s', v) edges are saturated (once we find a false,\n # stay false forever)\n if success:\n if max_flow.Tail(i) == s_prime:\n success = max_flow.Flow(i) == max_flow.Capacity(i)\n else:\n success = False\n print('There was an issue with the max flow input.')\n if success:\n # update the flows to be the flow found from maxflow problem\n for i in range(max_flow.NumArcs()):\n # if this is an original arc, update the flow\n if max_flow.Tail(i) != s_prime \\\n and max_flow.Head(i) != t_prime \\\n and not (max_flow.Tail(i) == self.sink() \\\n and max_flow.Head(i) == self.source()):\n # update arc\n start = max_flow.Tail(i)\n destin = max_flow.Head(i)\n arc = self.get_arc(start, destin)\n new_flow = self.arc_info[arc][\"lower_bound\"] + max_flow.Flow(i)\n old_flow = self.arc_info[arc][\"weight\"]\n self.arc_info[arc][\"weight\"] = new_flow\n #print(\"Edge {} {} adjusted from {} to {}\".format(\n # start,\n # destin,\n # old_flow,\n # new_flow\n # ))\n self.check_conservation_of_flow() # check that solution is valid\n return True\n else:\n return False","def compute_equal_flow_allocations(target_graph, K=3):\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n flow_allocation_seed_number = 0xDEAD_BEEF\n np.random.seed(flow_allocation_seed_number)\n flows = []\n for node in target_graph.nodes:\n possible_destination_nodes = set(target_graph.nodes) - set([node])\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n the_flow = Flow( source_node = node\n , destination_node = destination_node.item()\n , flow_tx_rate = 10.0\n , paths = k_shortest_paths\n , splitting_ratio = [1/K]*K\n )\n flows.append(the_flow)\n \n return flow_allocation_seed_number, flows","def sub_link_capacity(self, path, bw):\n \n # PART 1, TASK 3.4 sub bw to edges","def check_link_availability(self, link):\n circuits = self.load_circuits()\n total = 0\n for circuit in circuits:\n exists = circuit.get_link(link)\n if exists:\n total += exists.bandwidth\n if total + link.bandwidth > 100000000000: # 100 Gigabits\n return None\n return total","def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\n pass","def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\n dtype=float)\n\n for commodity_idx in range(len(self.commodities)):\n utilisation = self.calc_demand(routing,\n demands[commodity_idx],\n commodity_idx)\n total_utilisation += utilisation\n\n return np.max(np.divide(total_utilisation, self.edge_capacities))","def main(supply):\n\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\n # between each pair. For instance, the arc from node 0 to node 1 has a\n # capacity of 15 and a unit cost of 4.\n\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\n\n # Define an array of supplies at each node.\n supplies = supply\n\n\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n\n # Add each arc.\n for i in range(0, len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\n capacities[i], unit_costs[i])\n\n # Add node supplies.\n\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n\n\n # Find the minimum cost flow between node 0 and node 4.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n flag = 1\n optimal_flows = np.zeros(36)\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # save answer to the variable\n optimal_flows[i] = min_cost_flow.Flow(i)\n return flag, optimal_flows\n else:\n print('There was an issue with the min cost flow input.')\n flag = 0\n return flag, 0","def get_expected_cost(self):","def update_flow(self):\n N = len(self.vertices)\n _vertices = self.vertices+['_source', '_sink']\n s, t = _vertices.index('_source'), _vertices.index('_sink')\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\n\n cost[:N, :N] = self.cost\n capacity[:N, :N] = self.upper_bound-self.lower_bound\n # _source to main vertices\n l_in = self.lower_bound.toarray().sum(axis=0)\n us, = l_in.nonzero()\n for u in us:\n capacity[s, u] = l_in[u]\n # main vertices to _sink\n l_out = self.lower_bound.toarray().sum(axis=1)\n us, = l_out.nonzero()\n for u in us:\n capacity[u, t] = l_out[u]\n # sink to source\n infinite_flow = self.upper_bound.toarray().sum()\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\n\n # get a feasible flow on original graph by finding the max flow on\n # auxiliary graph\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\n aux_fg.FordFulkerson()\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\n\n self.residual = aux_fg.residual[:N, :N]\n s, t = self.vertices.index('source'), self.vertices.index('sink')\n self.residual[s, t] = 0\n self.residual[t, s] = 0\n\n self.FordFulkerson()","def __compute_connection_strengths(G, induced_ordering, previous_vertex):\n # for edges incident to the previous vertex added to the induced ordering\n for edge in previous_vertex.get_incident_edges():\n other_node = edge.get_other_node(previous_vertex.get_name()) # get the other node object\n if other_node.get_name() not in induced_ordering: # if the other node is not in the ordering\n other_node.set_attribute_value(\n StoerWagner.CONNECTION_STRENGTH_ATTRIBUTE,\n other_node.get_attribute_value(StoerWagner.CONNECTION_STRENGTH_ATTRIBUTE) + edge.get_weight()\n ) # add to the connection strength, the weight of the edge\n return G # return the graph with the connection strength information","def diff_equilibrium_equation(flow, capacity, network, route_idx): \r\n total_flow = np.sum(flow)\r\n if 0 < total_flow < 1:\r\n diff = np.log(flow[route_idx]) + network.beta * (flow[route_idx]**network.theta) - network.b[route_idx] + \\\r\n network.phi * flow[route_idx]/capacity[route_idx] - np.log(1-total_flow) \r\n return diff \r\n else:\r\n print(\"The given flow vector is not feasible.\")\r\n return 0","def link_compare(a, b):\n\n # wired > anything\n if not a.is_wifi() and not a.is_mobile() and (b.is_wifi() or b.is_mobile()):\n return 1\n\n # wifi > mobile unless wifi is going down.\n if a.is_wifi() and b.is_mobile():\n return a.is_going_down() == False\n\n # if its the same tech, signal strength decides who's better\n if type(a) == type(b):\n delta = a.strenght - b.strenght\n return delta / abs(delta) if delta != 0 else 0\n\n return 0","def update_bandwidth(self, flow_id, flow_current_bandwidth,\n flow_statistics, time_str):\n\n reassigned_flow_bandwidth = {}\n temp_current = flow_current_bandwidth\n temp = {}\n total_bandwidth = 0\n for f_id in flow_statistics:\n del temp_current[f_id]\n\n initial = datetime.strptime(flow_statistics[f_id][0], '%Y-%m-%d '\n '%H:%M:%S.%f')\n final = datetime.strptime(flow_statistics[f_id][1], '%Y-%m-%d '\n '%H:%M:%S.%f')\n request_time = datetime.strptime(time_str, '%Y-%m-%d %H:%M:%S.%f')\n\n delta_time = request_time - final\n total_delta = final - initial\n # TODO: must be a clever way to fix this\n if delta_time.total_seconds() < 5:\n if 0 == total_delta.total_seconds():\n new_bandwidth = flow_statistics[f_id][2][0][0]\n else:\n new_bandwidth = \\\n sum([x[0] for x in flow_statistics[f_id][2]])\\\n /total_delta.total_seconds()\n else:\n new_bandwidth = 0\n total_bandwidth += new_bandwidth\n temp[f_id] = new_bandwidth\n\n for f_id in temp:\n reassigned_flow_bandwidth[f_id] = \\\n (temp[f_id]/total_bandwidth) * self.max_capacity\n log.info(\"The bandwidth assign of %s is %s\",\n f_id, reassigned_flow_bandwidth[f_id])\n\n current_capacity = sum(reassigned_flow_bandwidth.values())\n\n if self.max_capacity+self.reserved_bytes < current_capacity:\n log.warning(\"Capacity overflow max+reserved %s - assigned capacity \"\n \"%s\",\n self.max_capacity + self.reserved_bytes,\n current_capacity)\n # Sanity check, all flows that are not in statistics implies no\n # activity, so assign a bandwidth of 0\n for id_flow in temp_current:\n reassigned_flow_bandwidth[id_flow] = 0\n\n return reassigned_flow_bandwidth","def get_interval_from_minflow(self, wide=False):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.arc_info[arc][\"start\"],\n # self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.arc_info[arc][\"destin\"],\n # self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # x,\n # self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.source(),\n # x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # self.sink(),\n # x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n # print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n # x,\n # self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".\n # format(s_prime, v, int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".\n # format(v, t_prime, int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n # s_prime,\n # x,\n # int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n # print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n # x,\n # t_prime,\n # int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i],\n capacities[i],\n unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n # print('Minimum cost:', min_cost_flow.OptimalCost())\n # print('')\n # print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n # cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n # print('%1s -> %1s %3s / %3s %3s' % (\n # min_cost_flow.Tail(i),\n # min_cost_flow.Head(i),\n # min_cost_flow.Flow(i),\n # min_cost_flow.Capacity(i),\n # cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n # print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n # print(\"Has become ({}, {}) with sup {}\".format(start,\n # destin,\n # sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in\n self.arc_info[arc].keys()):\n # print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n bound_1 = old_flow + sup_flow\n bound_2 = old_flow - sup_flow\n new_lb = max(0, int(min(bound_1, bound_2)))\n new_ub = int(max(bound_1, bound_2))\n if wide:\n if new_lb == new_ub:\n # print(\"We had a zero interval\")\n new_lb = int(new_lb*0.8)\n new_ub = int(new_ub*1.2)\n if new_lb == 0:\n # print(\"We got a zero lower bound\")\n new_ub = 5\n # print(\"But now we're doing {} {}\".\n # format(new_lb, new_ub))\n\n self.arc_info[arc][\"lower_bound\"] = new_lb\n self.arc_info[arc][\"upper_bound\"] = new_ub\n # print(\"Edge ({},{}) bounds are [{},{}]\".format(\n # start,\n # destin,\n # self.arc_info[arc][\"lower_bound\"],\n # self.arc_info[arc][\"upper_bound\"]))\n # print(self.arc_info[arc])\n else:\n print('There was an issue with the min cost flow input.')\n # self.check_conservation_of_flow() # check that solution is valid","def cost(self) -> float:","def compute_social_welfare(flow):\r\n total_flow = np.sum(flow)\r\n if 0 < total_flow < 1:\r\n social_welfare = np.sum(np.multiply(flow, np.log(flow))) - total_flow * np.log(1 - total_flow)\r\n return social_welfare \r\n else:\r\n print(\"The given flow vector is not feasible.\")\r\n return 0","def averageExcessCost(self):\n TSTT = 0\n for l in self.link:\n if self.link[l].flow <0:\n print(\"what in tarnation?\") #this really shouldn't happen, but the sheer number of leetcode problems I've been doing make me want to check against it anyway\n break\n if self.link[l].flow >0:\n contribution = self.link[l].flow * self.link[l].cost\n TSTT += contribution\n SPTT = 0\n TotalDemand = 0\n for od in self.ODpair:\n if self.ODpair[od].demand >0:\n O = self.ODpair[od].origin\n D = self.ODpair[od].destination\n BL,C = self.shortestPath(O)\n SPTT += C[D]*self.ODpair[od].demand\n TotalDemand+=self.ODpair[od].demand\n AEC = (TSTT - SPTT)/TotalDemand\n \n return AEC","def compute_cost(self, chrome):\n return 1","def check_path_availability(self, path, bandwidth):\n total = 0\n for endpoint_a, endpoint_b in zip(path[:-1], path[1:]):\n link = Link(Endpoint(endpoint_a[:23], endpoint_a[24:]),\n Endpoint(endpoint_b[:23], endpoint_b[24:]),\n bandwidth)\n avail = self.check_link_availability(link)\n if avail is None:\n return None\n total += avail\n return total","def combined_costs(matrix_MSLL_IO):\r\n return","def handle_request(self, sw, util, duration, time_now):\n\n #logging.debug(str(self.graph.edges(data=True)))\n\n #1 Get available paths from servers to switch\n paths = self.get_srv_paths(sw, self.graph)\n\n #2 choose the path which mins the max link utilization for all links\n # along the path\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\n\n if len(bestpath) > 0:\n self.allocate_resources(bestpath, util, time_now, duration)\n else:\n logging.warn(\"[%s] No best path found at switch [%s]\", str(time_now), str(sw))\n\n return bestpath","def compute_social_welfare(self):\r\n #self.social_welfare = 0\r\n #for i in range(self.num_routes):\r\n # self.social_welfare += self.routes[i].flow * self.routes[i].get_route_utility()\r","def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\n model = copy.deepcopy(model_old)\n \n #cpu_vector = model.cost_dict['cpu']\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n #bw_matrix = model.cost_dict['bw']\n w_a1, w_a2 = w_a\n w_b1, w_b2 = w_b\n theta1, theta2, theta3 = theta\n # find total capacity and used bw on substrate nodes\n node_port_list, used_bw_list = total_port(model)\n #print \"CHECK POINT-1\", used_bw_list, node_port_list\n vnet_info = model.get_vnet_info()\n infeasible = 0\n\n fail_nodes = model.failed_dict\n start_time = time.time()\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n # random selection\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n #print \"selection takes: \", time.time() - start_time\n #print \"Selected\", select_dict\n sum_cost_1_2 = 0\n r_list = {}\n \n for node_id in range(0,len(used_bw_list)):\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\n #print \"INITIAL\", r_list\n svr_subset = {}\n for vnet in model.vnets:\n j = vnet.vnet_id\n f = fail_nodes[j]\n # only count the failed virtual network\n if f == -1:\n pass\n else:\n for node_id in vnet_info[j]['standby']:\n svr_subset[node_id] = r_list[node_id]\n #print \"Subset SVR: \", svr_subset\n \n if j in select_dict:\n #print \"FEASIBLE FOUND\"\n #print vnet_info[j]['standby']\n i = select_dict[j]\n failed_node = vnet.vnodes[f]\n vneighbors = failed_node.vneighbors\n for k in vneighbors: \n eta = operation_cost()\n #print \"a1: \", w_a1, \"a2: \", w_a2, \"b1: \", w_b1, \"b2: \", w_b2\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\n rtt_c = rtt_cost(i, k, rtt_matrix)\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\n #find residual bw on substrate node\n #xi = resource_cost(bw_matrix, i)\n req_bw = sum(failed_node.neighbor_traffic.values())\n #util = req_bw / xi\n #print req_bw, i, used_bw_list[i], node_port_list[i]\n util = req_bw/node_port_list[i]\n \n if i not in r_list:\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\n else:\n r_list[i] += util\n svr_subset[i] = r_list[i]\n #print sigma, \" v_\" + str(vnet.vnet_id) + \"_\" + str(f) + \"_\" + str(i) + \"_\" + str(k) + \"_\" + str(k)\n else:\n print \"INFEASIBLE at vnet: \", j\n infeasible = 1\n #print \"DONE\"\n \n if infeasible == 0:\n #print svr_subset\n max_util = max(svr_subset.values())\n obj = sum_cost_1_2 + theta3 * max_util\n else:\n obj = \"infeasible\"\n max_util = \"none\"\n #print obj\n used_time = time.time() - start_time\n return obj, select_dict, max_util, used_time","def build_links_capacity(self):\n\n links_capacity = {}\n # Iterates all the edges in the topology formed by switches\n for src, dst in self.topo.keep_only_p4switches().edges:\n bw = self.topo.edges[(src, dst)]['bw']\n # add both directions\n links_capacity[(src, dst)] = bw\n links_capacity[(dst, src)] = bw\n\n return links_capacity","def cal_step(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,timecost_b,_ulabel_lane,per_b):\n lb = 0.0000000001\n ub = 0.99\n step = (lb + ub) / 2.0\n while abs(div(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,step,timecost_b,_ulabel_lane,per_b)) >= 0.01 and abs(ub-lb) > 0.0001:\n if div(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,step,timecost_b,_ulabel_lane,per_b) * div(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,ub,timecost_b,_ulabel_lane,per_b) > 0:\n ub = step\n else:\n lb = step\n step = (lb + ub) / 2.0\n return step","def compute_link_loss(min_dist, dist_der, safety_dist):\n dist = min_dist[0]\n if dist < safety_dist:\n return (safety_dist - dist) * dist_der\n return np.zeros_like(dist_der)","def local_efficiency(self, node_list1, node_list2, link_attribute=None):\n path_lengths = self.cross_path_lengths(node_list1, node_list2,\n link_attribute)\n return np.mean(1/path_lengths, axis=1)","def _calculate_costs(self):\n cost = 0\n cost += self._cost_route_fine()\n cost += self._cost_petrol()\n cost += self._cost_wage()\n cost += self._cost_refueling()\n cost += self._cost_caught_by_police()\n cost += self._cost_vehicle_malfunction()\n return cost","def DRPathValidation(self, flow, p):\n\t\tpath_rate_lst = []\n\n\t\tarr_time = flow[3]\n\t\tend_time = flow[3] + flow[4]\n\t\tedge_lst = [(p[i], p[i+1]) for i in xrange(len(p)-1)]\n\t\t# Calculate the bottlenecked rate at each event point\n\t\tfor evt in self.event_lst:\n\t\t\tmin_rate = float('inf')\n\t\t\tfor e in edge_lst:\n\t\t\t\tif evt in self.rate_lst[e].keys() and self.rate_lst[e][evt] < min_rate:\n\t\t\t\t\tmin_rate = self.rate_lst[e][evt]\n\t\t\tif min_rate < float('inf'):\n\t\t\t\tpath_rate_lst.append((evt, min_rate))\n\n\t\t# Calculate the cumulative size over the bottleneck rates between arr_time and end_time\n\t\tprev_time = arr_time\n\t\tprev_rate = 0\n\t\tcum_size = 0\n\t\trate_alloc = [(-1, 0)]\t# Start from time -1 with rate 0, so as a benchmark from the beginning\n\t\tfor time, rate in path_rate_lst:\n\t\t\t# Each time period is from prev_time -> min{time, end_time}\n\t\t\tif time > prev_time:\n\t\t\t\tif time < end_time:\n\t\t\t\t\tcum_size += prev_rate * (time - prev_time)\n\t\t\t\t\tcur_ed_time = time\n\t\t\t\telse:\n\t\t\t\t\tcum_size += prev_rate * (end_time - prev_time)\n\t\t\t\t\tcur_ed_time = end_time\n\t\t\t\trate_alloc.append((prev_time, prev_rate))\n\n\t\t\t\tif cum_size >= flow[2]:\n\t\t\t\t\tbreak\n\t\t\t\telif time >= end_time:\n\t\t\t\t\tbreak\n\n\t\t\tprev_time = time\n\t\t\tprev_rate = rate\n\n\t\t# If it can carry the flow size before deadline\n\t\tif cum_size >= flow[2]:\n\t\t\tcum_size -= prev_rate * (cur_ed_time - prev_time)\n\t\t\tnew_end_time = float(flow[2] - cum_size) / prev_rate + prev_time\n\t\t\t# Add the finish rate onto the allocation list\n\t\t\trate_alloc.append((new_end_time, 0))\n\n\t\t\treturn True, edge_lst, self.DRAllocTrim(rate_alloc), new_end_time\n\n\t\t# If not, return the minimum edge regarding the cumulative size\n\t\tedge, size = self.DRFindMinimalEdge(flow, edge_lst)\n\t\treturn False, edge, size","def get_speed_cost(data, start_node_id, end_node_id):\n start_node = data[start_node_id]\n dist_cost = get_dist_cost(data, start_node_id, end_node_id)\n # Get the speed limit along the way that connects the starting and ending nodes\n speed_limit_between_nodes = start_node['adjacent'][end_node_id]\n return dist_cost / speed_limit_between_nodes # Cost = Time = Distance/Rate","def legalize_graph(gm: pippy.fx.GraphModule) -> pippy.fx.GraphModule:\n indeg = {node: 0 for node in gm.graph.nodes}\n new_graph = pippy.fx.Graph()\n # Track how many unfulfilled dependencies each node has\n for node in gm.graph.nodes:\n for user in node.users:\n indeg[user] += 1\n queue: collections.deque = collections.deque()\n # Add all nodes with no dependencies to the queue\n for node in gm.graph.nodes:\n if indeg[node] == 0:\n queue.append(node)\n env: Dict[pippy.fx.Node, pippy.fx.Node] = {}\n # Pop nodes from the queue, and add nodes that have had all their\n # dependencies fulfilled\n while len(queue) > 0:\n cur = queue.popleft()\n env[cur] = new_graph.node_copy(cur, lambda x: env[x])\n for user in cur.users:\n indeg[user] -= 1\n if indeg[user] == 0:\n queue.append(user)\n # If the new graph's size is not as large as the old one, then there must be\n # a cycle (i.e. some node's dependencies were not satisfied.)\n if len(new_graph.nodes) < len(gm.graph.nodes):\n raise RuntimeError(f\"Input graph has cycles, unable to add {[node for node in indeg if indeg[node] != 0]}\")\n gm.graph = new_graph\n return gm","def calculate_path_cost_with_weighted_sum(self, path, attr1, attr2): \n costs = [] \n for i in range(len(path) - 1):\n a = (1- self.G[path[i]][path[i+1]][attr2]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \n b = (1- self.G[path[i]][path[i+1]][attr1]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \n costs.append(a * self.G[path[i]][path[i+1]][attr1] + b * self.G[path[i]][path[i+1]][attr2]) \n return max(costs)","def connection_probability(prev_props : EdgeProps, curr_props : EdgeProps) -> float:\n d = Delay.__compute_delay(\n arrival_time = prev_props['arr_time'],\n next_departure_time = curr_props['dep_time'], \n ttype = prev_props['ttype'], \n previous_route_id = prev_props['trip_id'],\n next_route_id = curr_props['trip_id']\n )\n proba = Delay.__connection_probability(\n delay = d, \n gamma_params = prev_props['gamma'], \n ttype = curr_props['ttype'], \n previous_route_id = prev_props['trip_id'],\n next_route_id = curr_props['trip_id']\n )\n return proba","def global_efficiency(self, node_list1, node_list2, link_attribute=None):\n local_efficiency = self.local_efficiency(node_list1, node_list2,\n link_attribute)\n return 1/np.mean(local_efficiency)","def operation_cost(tau=0):\n iface_on = 0.2\n iface_off = 0.2 \n ipconfig = 2\n reconf_ip_bin = tau\n op_cost = 2 * (iface_on + iface_off) + reconf_ip_bin * ipconfig\n return op_cost","def calculate_cost(route, adjacency_matrix):\n route_shifted = np.roll(route,1)\n cost = np.sum(adjacency_matrix[route, route_shifted])\n st_dev = np.std(adjacency_matrix[route, route_shifted])\n return st_dev, cost","def su_cost(node_type, node_count, cpu, gpu, ram, duration):\r\n if node_type == 'std':\r\n node_factor = 1\r\n tot_cpu = 28\r\n tot_ram = 128\r\n if node_type == 'gpu':\r\n node_factor = 2\r\n tot_cpu = 28\r\n tot_ram = 256\r\n if node_type == 'fat':\r\n node_factor = 6\r\n tot_cpu = 56\r\n tot_ram = 1024\r\n # job_setup = \"current setup = {} node type + {} number of nodes + {} number of cpu # + {} number of ram + {} hrs duration of job + {} total cpu + {} total ram\".format(node_type, node_count, cpu, ram, duration, tot_cpu, tot_ram)\r\n # calculate service units\r\n max_resource = top_resource(\r\n alloc_CPU = cpu, cpu_denominator = tot_cpu,\r\n alloc_GPU = gpu, gpu_denominator = 4,\r\n alloc_RAM = ram, ram_denominator = tot_ram)\r\n su = ( (node_count * (max_resource * node_factor)) * 28 * duration )\r\n return(su)","def _straight(self):\r\n \r\n flow = min(self.upstream.demand, self.downstream.supply)\r\n self.upstream.outflow = flow\r\n self.downstream.inflow = flow","def calculate_algorithm_cost(algorithm_stats, operation_costs): \n\n (comparisons, reads, writes) = algorithm_stats\n (comparison_cost, read_cost, write_cost) = operation_costs\n return (comparisons * comparison_cost) + (reads * read_cost) + (writes * write_cost)","def internal_link_density(self, node_list):\n N = len(node_list)\n n_links = self.number_internal_links(node_list)\n if self.directed:\n return float(n_links) / (N * (N - 1))\n else:\n return 2 * float(n_links) / (N * (N - 1))","def topo_efficiency_cal(self):\n Temp = 0\n for i in self.supplyseries:\n for j in self.demandseries:\n if(self.topo_shortestpathij(i, j) == None):\n continue\n Temp += 1/self.topo_shortestpathij(i, j)\n \n self.topo_efficiency = 1/(self.supplynum*self.demandnum)*Temp","def find_max_flow(graph, start, end):\n try:\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\"weight\")\n return flow_value\n except Exception as e:\n print(\"Error in Max flow computation \", e)\n return \"NaN\"","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE ***\"\n fringe = util.PriorityQueueWithFunction(lambda node: node.path_cost)\n return GraphSearch(problem, 'ucs').search(fringe)","def compute_cost(AL, Y):\n pass","def cost(route):\n cost = 0\n for li in route:\n if cost<li.get_cost():\n cost=li.get_cost()\n return cost","def GetPathCost(self, bucketOfActions):","def bgll(self, graph, node_count, min_mod, max_pass):\n\n #the belonging of the node\n bl = [i for i in range(node_count)]\n #the node's weight in community\n _in = [0.0] * node_count\n #the node's weight in graph\n _tot = []\n #total weight of a node, just a copy of _tot\n k = []\n #the total weight of the graph\n m = []\n\n #inital the in-param\n network = [[0.0] * node_count for n in range(node_count)]\n for node, tag, weight in graph:\n network[node][tag] = weight\n for node in network:\n k.append(sum(node))\n _tot = k[:]\n m = sum(k)\n #inital the in-param\n\n def modularity():\n \"\"\"\n This function mainly computes the modularity of the network\n Return:\n mod->the modularity value\n \"\"\"\n\n q = 0.0\n for idx in range(0, node_count):\n if _tot[idx] > 0.0:\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\n return q\n\n def modularity_gain(n, c, dnodecomm):\n \"\"\"\n This function mainly computes the modularity gain of a node moving\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n Return:\n gain->modularity gain\n \"\"\"\n\n totc = _tot[c]\n degc = k[n]\n return dnodecomm - (totc * degc) / m\n\n def neigh_comm(n):\n \"\"\"\n This function mainly computes the weight between the node and it's neighbour community\n Param:\n n->node id\n Return:\n nc->the map of the weight between the node and it's neighbour community\n nc=>{cid,weight}\n \"\"\"\n\n nc = {bl[n]: 0.0}\n for idx in range(0, node_count):\n neigh = idx\n ncomm = bl[neigh]\n nei_weight = network[n][idx]\n if (neigh != n) & (nei_weight > 0.0):\n if ncomm in nc:\n nc[ncomm] += nei_weight\n else:\n nc[ncomm] = nei_weight\n return nc\n\n def insert(n, c, dnodecomm):\n \"\"\"\n This function mainly get the effect of insert the node into community\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n \"\"\"\n\n _tot[c] += k[n]\n _in[c] += 2 * dnodecomm + network[n][n]\n bl[n] = c\n\n def remove(n, c, dnodecomm):\n \"\"\"\n This function mainly get the effect of remove the node off community\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n \"\"\"\n\n _tot[c] -= k[n]\n _in[c] -= 2 * dnodecomm + network[n][n]\n bl[n] = -1\n\n def detect():\n \"\"\"\n This function mainly detect the community of the graph.\n \"\"\"\n\n _pass_done = 0\n _improve = True\n new_mod = modularity()\n cur_mod = -999999999.0\n rl = random.sample(range(0, node_count), node_count)\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\n cur_mod = new_mod\n _improve = False\n _pass_done += 1\n for node_tmp in rl:\n n = node_tmp\n nc = bl[n]\n ncomm = neigh_comm(n)\n remove(n, nc, ncomm[nc])\n best_c = nc\n best_l = 0.0\n best_incre = 0.0\n for c in ncomm:\n incre = modularity_gain(n, c, ncomm[c])\n if incre > best_incre:\n best_incre = incre\n best_c = c\n best_l = ncomm[c]\n insert(n, best_c, best_l)\n if best_c != nc:\n _improve = True\n new_mod = modularity()\n print new_mod\n\n detect()\n return bl","def path_cost(self, c, state1, action, state2):\n # This should probably just be 1 every state....\n return c + 1","def path_cost(self, c, state1, action, state2):\n # This should probably just be 1 every state....\n return c + 1","def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\n #print slink_dict\n #print \"FIND\"\n failed_dict = model.failed_dict\n #print failed_dict, limit\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n bw_matrix = model.cost_dict['bw']\n #cpu_vector = model.cost_dict['cpu']\n selected_dict = {}\n \n # get aggregated residual bw for all substrate nodes, and store it as a list\n snode_bw_list = total_bw(bw_matrix)\n \n # get total capacity and used bw for each snode\n node_port_list, used_bw_list = total_port(model)\n #vnet_set = model.vnets\n sorted_vn = sort_vnet(model)\n\n #for vnet in vnet_set:\n if w_m[2] >= 10*w_m[1]:\n threshold = 0.8\n else:\n threshold = 0.8\n snode_traffic = {}\n for vn_traffic in sorted_vn:\n vnet = vn_traffic[0]\n failed_vr = failed_dict[vnet.vnet_id]\n if failed_vr != -1: \n # this node is failed\n standby_list = vnet.get_standby_ids()\n standby_cost = {}\n for s_vr in standby_list:\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\n failed_node = vnet.vnodes[failed_vr]\n vneighbors = failed_node.vneighbors\n dist_k = 0\n rtt_k = 0\n for k in vneighbors:\n dist_k += float(dist_matrix[s_vr][k + 1])\n rtt_k += float(rtt_matrix[s_vr][k + 1])\n\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\n w_b[1] * rtt_k\n res_cost = snode_bw_list[s_vr]\n req_bw = sum(failed_node.neighbor_traffic.values())\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\n standby_cost[s_vr] = total\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\n #print \"SORTED\", sorted_x\n \n for item in sorted_x:\n if item[0] not in snode_traffic:\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n else:\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n #print utilization\n # Link-Path selsection add-on\n path_alloc = 1\n for k in vneighbors:\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\n item[0] + 1, k + 1)\n demand = demand_dict[demand_id]['capacity']\n find, path = find_path(demand_path, demand_id, \n slink_dict, demand) \n if find == 0:\n print \"No available path between svr and nbr on the substrate network\" \n path_alloc = 0\n #print \"FIND PATH\", find, path\n # End link-path block \n #print \"ALLOCATED: \", path_alloc\n if path_alloc == 1:\n if selected_dict.values().count(item[0]) < limit:\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\n if item[0] not in snode_traffic: \n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] = vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break;\n else:\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \n if min_id == item[0]:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n #threshold = (threshold + 0.01)/2\n break\n elif utilization < threshold:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n if item[0] not in snode_traffic: \n snode_traffic[item[0]] = vn_traffic[1]\n else:\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break\n else:\n print \"does not satisfy the threshold\" \n # if a svr is selected -- item[0]\n \n \n \n else:\n print \"cannot allocate paths\"\n \n #print slink_dict \n return selected_dict, slink_dict","def compute_cost(AL, Y):\n pass","def total_cost(path: Path) -> float:\n\t\n\tdistance = calc_total_dist(path)\n\tavg_speed = calc_average_speed(path)\n\t\n\t# Speed is less important, but gets a huge multiplier, because speed and\n\t# \tdistance are in different units. Speed requires a high ratio to have\n\t# \tsimilar amounts of variation.\n\tSPEED_DISTANCE_COST_RATIO = 7865.099\n\t\n\treturn (\n\t\t(distance * 1) +\n\t\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\n\t)","def loadPaths(self):\n for ij in self.link:\n self.link[ij].flow = 0\n for p in self.path:\n for ij in self.path[p].links:\n self.link[ij].flow += self.path[p].flow\n for ij in self.link:\n self.link[ij].updateCost()\n for p in self.path:\n self.path[p].updateCost()","def contract(self, cycle):\n # create a new id to represent the cycle in the resulting graph.\n new_id = Digraph.new_node_id\n Digraph.new_node_id += 1\n\n # we store links that cross into and out of the cycle in these maps. the\n # to_cycle map contains links reaching into the cycle, and is thus a map\n # from each target node in the cycle to a list of source nodes that\n # reach that target from outside the cycle. the from_cycle map contains\n # links going out from the cycle, and is thus a map from each source\n # node in the cycle to a list of target nodes outside the cycle.\n to_cycle = collections.defaultdict(list)\n from_cycle = collections.defaultdict(list)\n\n scores = {}\n labels = {}\n succs = collections.defaultdict(list)\n for source, target in self.iteredges():\n if source in cycle:\n if target not in cycle:\n from_cycle[target].append(source)\n elif target in cycle:\n # we know source is not in cycle from above.\n to_cycle[source].append(target)\n else:\n succs[source].append(target)\n succs[target]\n scores[source, target] = self.get_score(source, target)\n labels[source, target] = self.get_label(source, target)\n\n old_edges = collections.defaultdict(list)\n\n # for each target in our graph that's reachable from the cycle, add an\n # edge from our new node to that target, with an appropriate score.\n for target, sources in from_cycle.items():\n succs[new_id].append(target)\n max_score = -1e100\n max_source = None\n for s in sources:\n score = self.get_score(s, target)\n if score > max_score:\n max_score = score\n max_source = s\n old_edges[max_source].append(target)\n scores[new_id, target] = max_score\n labels[new_id, target] = self.get_label(max_source, target)\n\n # before we handle the to_cycle map, we need to build some convenience\n # information for the cycle -- total score, and predecessor edges.\n pred = {}\n cycle_score = 0\n for s, t in cycle.iteredges():\n pred[t] = s\n cycle_score += self.get_score(s, t)\n\n # for each source in our graph that reaches into the cycle, add an edge\n # from the source to our new node, with an appropriate edge score.\n for source, targets in to_cycle.items():\n succs[source].append(new_id)\n max_score = -1e100\n max_target = None\n for t in targets:\n score = self.get_score(source, t) - self.get_score(pred[t], t)\n if score > max_score:\n max_score = score\n max_target = t\n old_edges[source].append(max_target)\n scores[source, new_id] = cycle_score + max_score\n labels[source, new_id] = self.get_label(source, max_target)\n\n return (\n new_id,\n old_edges,\n Digraph(\n succs, lambda s, t: scores[s, t], lambda s, t: labels[s, t]\n ),\n )","def __init__(self, graphs: List[Graph], graph_ids: Set[str]) -> None:\n self.graph_ids = graph_ids\n\n # count of link given source & object\n self.c_l_given_so: Dict[Tuple[bytes, bytes], Dict[bytes, int]] = {}\n # count of nodes\n self.c_n: Dict[bytes, int] = {}\n # count of link given source\n self.c_l_given_s: Dict[bytes, Dict[bytes, int]] = {}\n\n # COMPUTE counting\n for g in graphs:\n for link in g.iter_links():\n s = link.get_source_node().label\n o = link.get_target_node().label\n\n # COMPUTE c_l_given_s\n if s not in self.c_l_given_s:\n self.c_l_given_s[s] = {}\n if link.label not in self.c_l_given_s[s]:\n self.c_l_given_s[s][link.label] = 0\n self.c_l_given_s[s][link.label] += 1\n\n # COMPUTE c_l_given_so\n if link.get_target_node().is_data_node():\n # no need to estimate this prob, since it will be result from semantic labeling\n pass\n else:\n if (s, o) not in self.c_l_given_so:\n self.c_l_given_so[(s, o)] = {}\n if link.label not in self.c_l_given_so[(s, o)]:\n self.c_l_given_so[(s, o)][link.label] = 0\n self.c_l_given_so[(s, o)][link.label] += 1\n\n # COMPUTE c_n\n for n in g.iter_nodes():\n if n.label not in self.c_n:\n self.c_n[n.label] = 0\n self.c_n[n.label] += 1\n\n # cached\n self.p_critical_l_given_s = {}\n for s, counts in self.c_l_given_s.items():\n l, c_l = max(counts.items(), key=lambda x: x[1])\n self.p_critical_l_given_s[s] = (l, c_l / self.c_n[s])","def _distance_2_link_quality(self, distance):\n\n raise NotImplementedError","def calculate_q(module, degree_table, edges, num_of_edges):\n res = 0.0\n for node_1 in module:\n for node_2 in module:\n pair = tuple(sorted([node_1, node_2]))\n a_i_j = 1.0 if pair in edges else 0.0\n res += (a_i_j - ((degree_table[node_1] * degree_table[node_2]) / (2.0 * num_of_edges)))\n\n return res","def test_max_flow(default_plugin_resolver):\n dpr = default_plugin_resolver\n source_node = 0\n target_node = 7\n ebunch = [\n (0, 1, 9),\n (0, 3, 10),\n (1, 4, 3),\n (2, 7, 6),\n (3, 1, 2),\n (3, 4, 8),\n (4, 5, 7),\n (4, 2, 4),\n (5, 2, 5),\n (5, 6, 1),\n (6, 2, 11),\n ]\n nx_graph = nx.DiGraph()\n nx_graph.add_weighted_edges_from(ebunch)\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\"weight\")\n\n expected_flow_value = 6\n bottleneck_nodes = {2, 4}\n expected_nodemap = {2: 6, 4: 6}\n\n mv = MultiVerify(dpr)\n results = mv.compute(\"flow.max_flow\", graph, source_node, target_node)\n\n # Compare flow rate\n results[0].assert_equal(expected_flow_value)\n\n # Normalize actual flow to prepare to transform\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\n\n # Compare sum of out edges for bottleneck nodes\n out_edges = mv.transform(\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\n actual_flow,\n lambda x, y: x + y,\n initial_value=0,\n )\n out_bottleneck = mv.transform(\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\n )\n out_bottleneck.assert_equal(expected_nodemap)\n\n # Compare sum of in edges for bottleneck nodes\n in_edges = mv.transform(\n \"util.graph.aggregate_edges.core_networkx\",\n actual_flow,\n lambda x, y: x + y,\n initial_value=0,\n in_edges=True,\n out_edges=False,\n )\n in_bottleneck = mv.transform(\n \"util.nodemap.select.core_python\", in_edges, bottleneck_nodes\n )\n in_bottleneck.assert_equal(expected_nodemap)","def search_optimal_capacities(network, step_size, tolerance, filename):\r\n ## Initialization\r\n # Initialize the value of total flow over the network\r\n totalflow = max(network.lb_totalflow, step_size)\r\n \r\n # An auxiliary threshold of the total flow computed based on the capacity upper bounds, used in Line 4 of Algorithm 3.\r\n aux_bound = 1 - np.exp(network.beta - network.b + network.phi/network.u)\r\n \r\n \r\n # Initialize the bounds for flow over each route\r\n ub_flow = np.zeros(network.num_routes)\r\n lb_flow = np.zeros(network.num_routes)\r\n \r\n # Initialize the optimal solution over the network\r\n opt_socialwelfare = np.array([])\r\n opt_totalflow = 0\r\n opt_flows = np.array([])\r\n opt_capacity = np.zeros(network.num_routes)\r\n \r\n\r\n# # For debugging only\r\n# lower_bound = np.zeros(network.num_routes)\r\n# upper_bound = np.zeros(network.num_routes)\r\n# count = 0\r\n \r\n # Try to plot out the (totalflow, social_welfare) scatter plot\r\n z = []\r\n hz = []\r\n# # End of debugging\r\n\r\n ## Start the search\r\n while totalflow < 1 - tolerance:\r\n flag_nofeasibleflow = False\r\n \r\n # Compute the bounds for the flow.\r\n for i in range(network.num_routes):\r\n # Line 3-8 of Algorithm 3. Compute the upper bounds for the flow.\r\n if totalflow >= aux_bound[i]: \r\n x3_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 3) \r\n if x3_star > network.u[i]:\r\n flag_nofeasibleflow = True\r\n break \r\n else:\r\n ub_flow[i] = x3_star \r\n else: \r\n ub_flow[i] = 1 \r\n # Line 9-10 of Algorithm 3. Compute the lower bounds of the flow.\r\n x1_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 1)\r\n x2_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 2)\r\n lb_flow[i] = max(x1_star, x2_star)\r\n \r\n \r\n if not flag_nofeasibleflow:\r\n # Check feasibility of the flow based on the current total flow, lower and upper bounds of the flow\r\n if totalflow < np.sum(lb_flow) or totalflow > np.sum(ub_flow): \r\n totalflow += step_size \r\n\r\n# # For debugging only\r\n# print(\"\\nThe current total flow is: \" + str(totalflow))\r\n# print(\"\\nThe capacity upper bound when optimal flow is found: \")\r\n# print(upper_bound)\r\n# print(\"\\nThe capacity lower bound when optimal flow is found: \")\r\n# print(lower_bound)\r\n# print(str(count))\r\n# # Eng of debugging\r\n# \r\n continue\r\n \r\n # The implementation of line 11 to 18. Find the optimal flow given the current value of z.\r\n [opt_obj, opt_x] = ip.max_sum_xlogx(network.num_routes, totalflow, lb_flow, ub_flow) \r\n \r\n \r\n # Line 18 of Algorithm 3. Compute the social welfare given the current z and optimal q(z).\r\n temp = opt_obj - totalflow * np.log(1-totalflow)\r\n\r\n ##### Testing: to plot out the function of h(z)\r\n z.append(totalflow)\r\n hz.append(temp)\r\n ##### End of Testing: to plot out the function of h(z)\r\n \r\n if opt_socialwelfare.size == 0 or temp > opt_socialwelfare:\r\n opt_socialwelfare = temp\r\n opt_flows = opt_x\r\n opt_totalflow = totalflow \r\n \r\n # For debugging only\r\n# print(\"\\nUpdate optimal flow\")\r\n# print(opt_x)\r\n# print(lb_flow)\r\n# print(ub_flow)\r\n# print(\"Total flow is \" + str(opt_totalflow)) \r\n \r\n # For debugging\r\n# np.copyto(lower_bound, lb_flow) \r\n# np.copyto(upper_bound, ub_flow) \r\n# count += 1\r\n# print(\"The lower and upper bounds are: \")\r\n# print(lb_flow)\r\n# print(lower_bound)\r\n# print(\"\\n\")\r\n# print(ub_flow)\r\n# print(upper_bound)\r\n# print(\"\\n\")\r\n \r\n totalflow += step_size \r\n\r\n \r\n \r\n# # For debugging only\r\n# print(\"\\n----------------\\n Exiting the while loop.\")\r\n# print(\"\\nThe capacity upper bound when optimal flow is found: \")\r\n# print(upper_bound)\r\n# print(\"\\nThe capacity lower bound when optimal flow is found: \")\r\n# print(lower_bound)\r\n# print(str(count)) \r\n# # Eng of debugging\r\n \r\n # Line 20 of ALgorithm 3\r\n if opt_flows.size > 0:\r\n network.update_flow(opt_flows) \r\n for i in range(network.num_routes): \r\n network.compute_capacity(opt_totalflow, i)\r\n opt_capacity[i] = network.capacity[i]\r\n print(\"\\n--------------\\nThe optimal flow is: \")\r\n print(opt_flows)\r\n print(\"\\n--------------\\nThe optimal parking capacity is: \")\r\n print(opt_capacity) \r\n print(\"\\n--------------\\nThe optimal total flow is \" + str(opt_totalflow))\r\n print(\"\\n--------------\\nThe maximum social welfare is \" + str(opt_socialwelfare) +\".\")\r\n \r\n \r\n ##### Testing: to plot out the function of h(z)\r\n #plt.scatter(z, hz, c='r', marker='r')\r\n plt.plot(z, hz, '-', linewidth=0.5)\r\n #plt.xlim(0.5, 1)\r\n plt.savefig(filename + '.png', bbox_inches='tight')\r\n ##### End of Testing: to plot out the function of h(z)\r\n \r\n \r\n \r\n# # For debugging\r\n# temp1 = np.zeros(network.num_routes)\r\n# temp2 = np.zeros(network.num_routes)\r\n# temp3 = np.zeros(network.num_routes)\r\n# for i in range(network.num_routes): \r\n# temp1[i] = zeta(network, i, opt_flows[i], opt_totalflow, 1)\r\n# temp2[i] = zeta(network, i, opt_flows[i], opt_totalflow, 2)\r\n# temp3[i] = zeta(network, i, opt_flows[i], opt_totalflow, 3)\r\n# print(\"The function value of zeta at the optimal flow: \")\r\n# print(temp1)\r\n# print(temp2)\r\n# print(temp3)\r\n# \r\n# # For debugging\r\n# print(\"\\nThe capacity upper bound when optimal flow is found: \")\r\n# print(upper_bound)\r\n# print(\"\\nThe capacity lower bound when optimal flow is found: \")\r\n# print(lower_bound)\r\n# print(str(count))\r\n# # End of debugging\r\n \r\n return opt_flows, opt_capacity, opt_socialwelfare \r\n else:\r\n print(\"\\nNo optimal solution is found!\")\r\n return np.array([]), opt_capacity, opt_socialwelfare","def total_weight(network):\n weight = 0\n\n for node_connections in network:\n for edge in node_connections:\n if edge is not None:\n weight += edge\n\n return weight // 2","def astar_heuristic(n1, n2):\n average_speed = 70\n return edge_weight(n1, n2, 70)","def net_flow(G, \n inplace = False,\n new_weight_name = None,\n verbose = False):\n\n if new_weight_name is None:\n new_weight_name = 'net_flow'\n # TO-DO: WHAT HAPPENS WHEN WEIGHT NAME ALREADY EXISTS?\n\n node_label = dict(enumerate(G.nodes))\n if not nx.is_connected(G):\n raise DisconnectedGraphError\n\n # The exact sparse representation is irrelevant from a speed\n # perspective, but differs in the implementation below.\n A_coo = nx.to_scipy_sparse_array(G, format = 'coo')\n\n # Inverted Laplacian is going to be dense anyways.\n # So there is no harm in working with dense matrices here.\n L = -A_coo.toarray()\n np.fill_diagonal(L, A_coo.sum(axis = 1))\n\n # Removing first (or any other) row and corresponding column from the\n # Laplacian matrix leads to an invertible matrix if the graph is connected.\n # The invers of this matrix can be interpreted as a 'potential' matrix\n # that leads to voltage vectors by taking differences.\n C = np.zeros(L.shape)\n C[1:,1:] = np.linalg.inv(L[1:,1:])\n\n # Calculating the current flow directly involves taking all pairwise distances\n # twice: We need to take all pairwise distances for each source-target pair\n # (leading to a voltage vector V_st), and we need to do that for all source-target\n # pairs (leading to the current flow matrix). This is computationally expensive.\n # We can reduce the complexity by realizing that not all values need to be calculated\n # and that some computations can be reused. This idea is based on an algorithm from\n # Brandes and Fleischer.\n\n # The implementation here is optimized for COO sparse format, converting\n # CSR to COO is cheap.\n\n row_idx, col_idx = map(np.array, zip(*((i,j)\n for (i,j) in zip(A_coo.row, A_coo.col) if i<j)))\n\n edge_values = _current_flow_loop(C, row_idx, col_idx )\n edge_dict = {(node_label[i], node_label[j]) : edge_values\n for (i,j,edge_values) in zip(row_idx, col_idx, edge_values)}\n\n if inplace:\n nx.set_edge_attributes(G, \n values = edge_dict, \n name = new_weight_name)\n else:\n return edge_dict","def linkUpdate(self, time): \r\n cellTransitionFlow = list()\r\n # deal with intermediate cells\r\n for c in range(0, self.numCells-1):\r\n cellSendingFlow = self.cells[c].calculateSendingFlow()\r\n cellReceivingFlow = self.cells[c+1].calculateReceivingFlow()\r\n cellTransitionFlow.append(min(cellSendingFlow, cellReceivingFlow))\r\n for c in range(0, self.numCells-1):\r\n self.cells[c].removeVehicles(cellTransitionFlow[c])\r\n self.cells[c+1].addVehicles(cellTransitionFlow[c])\r\n self.flowIn(time)\r\n self.flowOut(time)\r\n return None","def compute_network_load(env: ControlledRandomWalk) -> float:\n rho = cvx.Variable()\n zeta = cvx.Variable((env.num_activities, 1))\n objective = cvx.Minimize(rho)\n constraints = [\n env.job_generator.buffer_processing_matrix * zeta + env.job_generator.demand_rate\n == np.zeros((env.num_buffers, 1)),\n env.constituency_matrix * zeta <= rho * np.ones((env.num_resources, 1)),\n zeta >= np.zeros((env.num_activities, 1))\n ]\n prob = cvx.Problem(objective, constraints)\n network_load = prob.solve(solver=cvx.SCS, eps=1e-7)\n return network_load","def calculate_attribution(self, model_instance, input_graph):\n self.device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n self.model_instance = model_instance\n \n tmp_graph = copy.deepcopy(input_graph).to(self.device)\n node_feats = tmp_graph.ndata.pop('h').to(self.device)\n \n self.model_instance.to(self.device)\n if self.att_type == 'integrated_gradients':\n att_function = IntegratedGradients(self._model_forward)\n self.attr_weights = att_function.attribute(\n node_feats, \n additional_forward_args=tmp_graph, \n internal_batch_size=len(node_feats),\n n_steps = 100)\n elif self.att_type == 'input_gradient':\n att_function = InputXGradient(self._model_forward)\n self.attr_weights = att_function.attribute(\n node_feats, \n additional_forward_args=tmp_graph,)\n elif self.att_type == 'attention':\n edge_feats = tmp_graph.edata.pop('e').to('cuda')\n _, self.att_weights = self.model_instance(\n tmp_graph, node_feats, edge_feats, get_node_weight=True)\n return self.att_weights[0].to('cpu').detach().numpy()\n \n self.attributes = np.multiply(\n node_feats.to('cpu').numpy(), self.attr_weights.to('cpu').numpy())\n self.attributes[self.attributes < 0] = 0\n \n self.node_weights = self.normalize_node_weights(self.attributes.sum(axis=1))","def find_allocation_for_graph(self,consumption_graph : ConsumptionGraph):\n mat = cvxpy.Variable((self.num_of_agents, self.num_of_items))\n constraints = []\n # every var >=0 and if there is no edge the var is zero\n # and proportional condition\n for i in range(self.num_of_agents):\n count = 0\n for j in range(self.num_of_items):\n if (consumption_graph.get_graph()[i][j] == 0):\n constraints.append(mat[i][j] == 0)\n else:\n constraints.append(mat[i][j] >= 0)\n count += mat[i][j] * self.valuation[i][j]\n constraints.append(count >= sum(self.valuation[i]) / len(self.valuation))\n # the sum of each column is 1 (the property on each object is 100%)\n for i in range(self.num_of_items):\n constraints.append(sum(mat[:, i]) == 1)\n \"\"\"\n # the proportional condition\n count = 0\n for i in range(len(consumption_graph)):\n count = 0\n for j in range(len(consumption_graph[i])):\n count += mat[i][j] * matv[i][j]\n constraints.append(count >= sum(matv[i]) / len(matv[i]))\n \"\"\"\n objective = cvxpy.Maximize(1)\n prob = cvxpy.Problem(objective, constraints)\n prob.solve() # Returns the optimal value.\n if not (prob.status == 'infeasible'):\n alloc = Allocation(mat.value)\n alloc.round()\n if(alloc.num_of_shering() < self.min_sharing_number):\n self.min_sharing_number = alloc.num_of_shering()\n self.min_sharing_allocation = alloc.get_allocation()\n # only for doctet:\n return (mat.value)","def two_user_route_statistics(i,j, source_data, destination_data, source_destination_data, delta=1.2):\n\toccupancy_ratio = 0.0\n\tminimum_distance_so_far = 0.0\n\tcommon_travel_distance = 0.0\n\n\ttry:\n\t\tif source_destination_data[j][i] + source_data[i][j] <= 1.2*source_destination_data[i][i] and source_destination_data[j][i] + destination_data[i][j] <= 1.2*source_destination_data[j][j]:\n\t\t\tfirst = ((source_destination_data[j][i] + source_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\n\t\t\tsecond = ((source_destination_data[j][i] + destination_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\n\t\t\toccupancy_ratio = (first+second)/2\n\t\t\tcommon_travel_distance = source_destination_data[j][i]\n\t\t\tminimum_distance_so_far = source_data[i][j] + source_destination_data[j][i] + destination_data[i][j]\n\n\t\tif source_destination_data[i][j] + destination_data[j][i] <= 1.2*source_destination_data[i][i] and source_destination_data[i][j] + source_data[j][i] <= 1.2*source_destination_data[j][j]:\n\t\t\tfirst = ((source_destination_data[i][j] + destination_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\t\t\n\t\t\tsecond = ((source_destination_data[i][j] + source_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\n\t\t\ttotal_distance = source_data[j][i] + source_destination_data[i][j] + destination_data[j][i]\n\n\t\t\tif total_distance < minimum_distance_so_far:\n\t\t\t\tminimum_distance_so_far = total_distance\n\t\t\t\tcommon_travel_distance = source_destination_data[i][j]\n\t\t\t\toccupancy_ratio = (first+second)/2\n\n\t\tif source_data[i][j]+source_destination_data[j][j]+destination_data[j][i] <= 1.2*source_destination_data[i][i]:\n\t\t\tfirst = (1)\n\t\t\tsecond = (source_destination_data[j][j]/(source_data[i][j]+source_destination_data[j][j]+destination_data[j][i]))\n\n\t\t\ttotal_distance = source_data[i][j] + source_destination_data[j][j] + destination_data[j][i]\n\n\t\t\tif total_distance < minimum_distance_so_far:\n\t\t\t\tminimum_distance_so_far = total_distance\n\t\t\t\tcommon_travel_distance = source_destination_data[j][j]\n\t\t\t\toccupancy_ratio = (first+second)/2\n\n\t\tif source_data[j][i]+source_destination_data[i][i]+destination_data[i][j] <= 1.2*source_destination_data[j][j]:\n\t\t\tfirst = (source_destination_data[i][i]/(source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]))\n\t\t\tsecond = (1)\n\n\t\t\ttotal_distance = source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]\n\n\t\t\tif total_distance < minimum_distance_so_far:\n\t\t\t\tminimum_distance_so_far = total_distance\n\t\t\t\tcommon_travel_distance = source_destination_data[i][i]\n\t\t\t\toccupancy_ratio = (first+second)/2\n\n\texcept Exception as e:\n\t\toccupancy_ratio = 1.0\n\t\tminimum_distance_so_far = 0.0\n\t\tcommon_travel_distance = 0.0\n\n\n\treturn occupancy_ratio, common_travel_distance, minimum_distance_so_far","def route_cost(self, route):\n total_weight = 0\n c = 0\n start = route[0]\n for end in route[1:]:\n y = float(self.stars[start][end]['weight']) - c\n t = total_weight + y\n c = (t - total_weight) - y\n\n total_weight = t\n\n start = end\n return total_weight","def _compute_longest_path_cut(self, src_uid, dst_uid):\n # NOTE: at the time being the reason why it was chosen to include edges\n # that belong to any path to the returned list, is unclear to me.\n to_visit_uids = [dst_uid]\n node_costs = {}\n node_succs = {}\n subgraph_edge_uids = []\n subgraph_node_uids = [src_uid]\n dsp = 0\n\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\n node = self._nodes[src_uid]\n return node.get_cost(), [src_uid], [], []\n\n # NOTE: the generated block graph might contain dead ends, thus\n # visited_uids must be pre-computed\n visited_uids = copy.deepcopy(self._nodes.keys())\n lvisited_uids = []\n while len(to_visit_uids) > 0:\n cur_uid = to_visit_uids[0]\n cur_node = self._nodes[cur_uid]\n\n if cur_uid in visited_uids:\n visited_uids.remove(cur_uid)\n\n for pred_uid in cur_node.get_predecessors():\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\n to_visit_uids.append(pred_uid)\n\n to_visit_uids = to_visit_uids[1:]\n lvisited_uids.append(cur_uid)\n\n to_visit_uids = [dst_uid]\n\n # reverse graph exploration\n while 0 < len(to_visit_uids):\n assert(dsp < len(to_visit_uids))\t# dead ends or loops\n\n cur_uid = to_visit_uids[dsp]\n cur_node = self._nodes[cur_uid]\n\n assert(cur_uid != src_uid)\n assert(cur_uid not in visited_uids)\t# loop!\n\n # skip node for which there is still some unexplored successor\n skip_uid = False\n for succ_uid in cur_node.get_successors():\n if not succ_uid in visited_uids:\n skip_uid = True\n\n if skip_uid:\n dsp += 1\n continue\n else:\n dsp = 0\n\n if cur_uid == dst_uid:\n node_costs[cur_uid] = cur_node.get_cost()\n\n for pred_uid in cur_node.get_predecessors():\n pred_node = self._nodes[pred_uid]\n # get edge pred_uid ---> cur_uid\n edge_uid = Edge.get_edge_uid(pred_uid, cur_uid)\n edge = self._edges[edge_uid]\n edge_cost = edge.get_cost()\n if edge_uid not in subgraph_edge_uids:\n subgraph_edge_uids.append(edge_uid)\n\n # update node distance\n pred_node_cost = node_costs[cur_uid] + edge_cost + pred_node.get_cost()\n if pred_uid not in node_costs or pred_node_cost > node_costs[pred_uid]:\n node_costs[pred_uid] = pred_node_cost\n node_succs[pred_uid] = cur_uid\n\n # update to_visit_uids, a node cannot be visited more than once\n if (pred_uid != src_uid) and (pred_uid not in visited_uids) \\\n and (pred_uid not in to_visit_uids):\n to_visit_uids.append(pred_uid)\n\n to_visit_uids.remove(cur_uid)\n visited_uids.append(cur_uid)\n subgraph_node_uids.append(cur_uid)\n\n # construct path from src_node to dst_node\n cur_uid = src_uid\n maxpath_node_uids = [cur_uid]\n while cur_uid != dst_uid:\n cur_uid = node_succs[cur_uid]\n cur_node = self._nodes[cur_uid]\n if cur_uid not in maxpath_node_uids:\n maxpath_node_uids.append(cur_uid)\n else:\n raise Exception(\"invalid input source code graph: loop detected\")\n\n max_cost = node_costs[src_uid]\n return max_cost, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids","def geo_dist_penalty(p_a, p_b): # created on Nov.3 2019\n\n # Offset is 0 for the 1st destination.\n distance_matrix = Network.dist_mat\n if p_a[0] != p_b[0] or p_a[-1] != p_b[-1]:\n raise ValueError('Paths have different o or d.')\n\n # define the penalty in utility form for every two destinations. u_ik stands for the generalized cost of travel\n o, d = p_a[0], p_a[-1]\n\n path_a, path_b = p_a[1:-1], p_b[1:-1] # excluding origin and destination\n\n path_node_check = []\n for _path in [path_a, path_b]:\n _new_path = []\n for node in _path:\n if node <= min(distance_matrix.shape) - 1:\n _new_path.append(node)\n path_node_check.append(_new_path)\n path_a, path_b = path_node_check[0], path_node_check[1]\n\n # utility (negative) penalty evaluation\n cost, a, b = 0, o, o # let a, b be origin\n\n # if exist empty path\n if not path_a: # if observed path is empty\n return cost\n\n while path_a and path_b:\n a, b = path_a.pop(0), path_b.pop(0) # a, b correspond to the i_th node in path_a, path_b\n cost += distance_matrix[a][b]\n\n if path_a: # length of path_a > path b\n while path_a:\n a = path_a.pop(0)\n cost += distance_matrix[a][b]\n else: # case when length of path_b > path a\n while path_b:\n b = path_b.pop(0)\n cost += distance_matrix[a][b]\n return cost","def ClusteringTransitivity(graph):\n transitivity = nx.transitivity(graph)\n return transitivity","def unit_costs(node1, node2):\r\n # insertion cost\r\n if node1 is None:\r\n return 1\r\n \r\n # deletion cost\r\n if node2 is None:\r\n return 0\r\n \r\n # substitution cost\r\n if node1.label != node2.label:\r\n return 1\r\n else:\r\n return 0","def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\n\n G = nx.DiGraph()\n G.add_edge( 0, 1, time_stamp = 1)\n\n # List of existing nodes, with nodes repeated once for each adjacent edge\n repeated_nodes = [0, 1]\n\n # compute discrete bins for nodes \n DistNodes = _get_distribution( N_max, 0 )\n # compute discrete bins for edges\n DistLinks = _get_distribution( E_max, 1 )\n \n # Start adding the other n - 2 nodes.\n N_current = time_current = 2\n while N_current < n and time_current < time_total + 1:\n # preferential attachment\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\n time_total, time_current, n, repeated_nodes, G )\n time_current += 1\n \n# print(time_current, N_current)\n return G","def getCost(dat, rateBlocks, key=\"Lintel\"):\n\n x = dat[:]\n\n if key == \"Lintel\":\n edges = [s*100 for s in [5, 6, 7, 10,\n 11, 12, 15, 16, 17, 20, 21, 22, 25]]\n else:\n edges = [s*100 for s in [10, 11, 12, 15, 16, 17, 20,\n 21, 22, 25, 26, 27, 30, 31, 32, 35, 36, 37, 40]]\n for i in edges:\n if i >= x[2]:\n x[2] = i\n break\n\n vol = x[0]*600*x[2]/float(1000000000)\n return vol*rateBlocks # *x[3]","def test_global_efficiency_complete_graph(self):\n for n in range(2, 10):\n G = nx.complete_graph(n)\n assert_equal(nx.global_efficiency(G), 1)","def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\r\n\r\n residual_graph = copy.deepcopy(graph)\r\n row = len(residual_graph)\r\n parent = [-1] * row\r\n max_flow = 0\r\n\r\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\r\n raise WrongInputException('Wrong input source/sink vertice(s)')\r\n\r\n while bfs(residual_graph, row, source, sink, parent):\r\n\r\n path_flow = float(\"Inf\")\r\n s = sink\r\n while s != source:\r\n path_flow = min(path_flow, residual_graph[parent[s]][s])\r\n s = parent[s]\r\n\r\n max_flow += path_flow\r\n\r\n v = sink\r\n while v != source:\r\n u = parent[v]\r\n residual_graph[u][v] -= path_flow\r\n residual_graph[v][u] += path_flow\r\n v = parent[v]\r\n print(\"Max flow: %d\" % max_flow)\r\n\r\n return residual_graph","def total_sdram_requirements(self):","def path_cost(self, c, state1, action, state2):\n\t\treturn c + 1"],"string":"[\n \"def calc_overall_link_utilisation(self, demands: Demand,\\n routing: Routing) -> np.ndarray:\\n flows = [(i, j) for i in range(self.num_nodes)\\n for j in range(self.num_nodes)\\n if i != j]\\n\\n link_utilisation = np.zeros(self.num_edges)\\n\\n for i, flow in enumerate(flows):\\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\\n demands[\\n i],\\n routing[\\n i])\\n link_utilisation += flow_link_utilisation\\n\\n return link_utilisation\",\n \"def compute_path_metric(self, sw, path, util, time_now, local_contrib):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n # Use the last-learned-via-sync value for a link\\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\\n used1 = self.graph[u][v]['sync_learned'] + util\\n used2 = self.graph[u][v]['used'] + util\\n # ['used'] is a strict lower bound for ['sync_learned']\\n if used1 > used2: \\n used = used1\\n logging.debug(\\\"CS [%s] using sync_learned value 1 [%f]\\\", str(self.name), used1)\\n else:\\n used = used2\\n logging.debug(\\\"CS [%s] using sync_learned value 2 [%f]\\\", str(self.name), used2)\\n else:\\n logging.debug(\\\"CS [%s] using tracking value\\\", str(self.name))\\n used = self.graph[u][v]['used'] + util\\n\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def compute_path_metric(self, sw, path, util, time_now):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\\n #only include extra-domain state when not stale (timestamp), 3) always exclude\\n #extra-domain state when calculating the path metric? Here we do (1)\\n used = self.graph[u][v]['used'] + util\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def calc_slow(self, demands: Demand, routing: Routing) -> float:\\n edge_capacities = [e[2]['weight'] for e in\\n sorted(self.graph.edges(data=True))]\\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\\n # Because utilisation compared to link width is what we care about here\\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\\n\\n return np.max(ratio_capacities)\",\n \"def compute_link_utilization_over_time(link_byte_counts):\\n def find_matching_iface_stats(byte_count, source_id, destination_id):\\n matching_stats = [d_i for d_i in byte_count\\n if d_i[\\\"sourceSwitchId\\\"] == source_id and\\n d_i[\\\"destinationSwitchId\\\"] == destination_id]\\n if len(matching_stats) != 1:\\n raise ValueError(\\\"Unexpected results in find_matching_iface_stats. \\\\\\n Found %d matching iface_stats\\\" % len(matching_stats))\\n return matching_stats[0]\\n\\n def compute_tx_rate(count_in_bytes):\\n return (count_in_bytes * 8) / 10.0**7\\n\\n # First compute the delta between the iface_stats in time_period t_i and the iface_stats\\n # in time period t_{i+1}.\\n # tx_rate_t: (source_id x destination_id) -> link_utilization_in_time_period_t forall. t\\n tx_rate_t = []\\n for t_0, t_1 in zip(link_byte_counts, link_byte_counts[1:]):\\n byte_count_delta_t = defaultdict(float)\\n for iface_stats in t_0:\\n source_id = iface_stats[\\\"sourceSwitchId\\\"]\\n destination_id = iface_stats[\\\"destinationSwitchId\\\"]\\n t_0_count = iface_stats[\\\"bytesSent\\\"] + iface_stats[\\\"bytesReceived\\\"]\\n try:\\n t_1_stats = find_matching_iface_stats(t_1, source_id, destination_id)\\n t_1_count = t_1_stats[\\\"bytesSent\\\"] + t_1_stats[\\\"bytesReceived\\\"]\\n except ValueError:\\n t_1_count = t_0_count\\n\\n count_delta = t_1_count - t_0_count\\n link_key = compute_link_key(source_id, \\n destination_id)\\n byte_count_delta_t[link_key] += count_delta\\n\\n tx_rate_t.append({the_link_key: compute_tx_rate(byte_count_t) \\n for the_link_key, byte_count_t in byte_count_delta_t.items()})\\n return tx_rate_t\",\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\\n # set availbandwidth to the maximal value\\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\\n if d.type == 'STATIC':\\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\\n # subtract the reserved link and internal (inside Infras) bandwidth\\n if mode == self.MODE_ADD:\\n for d in self.infras:\\n for p in d.ports:\\n for fr in p.flowrules:\\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\\n # Flowrules are cummulatively subtracted from the switching \\n # capacity of the node.\\n d.availres['bandwidth'] -= fr.bandwidth\\n if d.availres['bandwidth'] < 0:\\n raise RuntimeError(\\\"The node bandwidth of %s got below zero \\\"\\n \\\"during available resource calculation!\\\" %\\n d.id)\\n # Get all the mapped paths of all SGHops from the NFFG\\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\\n for sg_hop_id, data in sg_map.iteritems():\\n src, dst, flowclass, bandwidth, delay, path = data\\n if bandwidth is not None:\\n for link in path:\\n link.availbandwidth -= bandwidth\\n if link.availbandwidth < 0:\\n raise RuntimeError(\\n \\\"The link bandwidth of %s got below zero during\\\"\\n \\\"available resource calculation!\\\" % link.id)\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def opt(self, demands: Demand) -> float:\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('multicommodity_flow_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the splitting ratios for each edge\\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(self.num_edges):\\n flow_variable_edges.append(\\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Capacity constraint\\n capacity_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint between 0 and edge capacity\\n constraint_i = solver.Constraint(\\n 0, self.graph.get_edge_data(*edge)['weight'],\\n '(1,{},{})'.format(*edge))\\n for j, commodity in enumerate(self.commodities):\\n # Coefficient for jth flow over ith edge is scaled by flow width\\n constraint_i.SetCoefficient(flow_variables[j][i],\\n # cast because or-tools :'(\\n float(demands[j]))\\n capacity_constraints.append(constraint_i)\\n\\n # Conservation on transit nodes\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.num_nodes):\\n if j != commodity[0] and j != commodity[1]:\\n # Constraint must sum to zero\\n constraint_j = solver.Constraint(0, 0,\\n '(2,{},{})'.format(i, j))\\n for k in list(sorted(self.graph.adj[j].keys())):\\n # Ingress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\\n # Egress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Conservation of flow at source node\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[0], edge_dest)]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[0])]],\\n -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Conservation of flow at destination node\\n conservation_dest_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[1])]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[1], edge_dest)]],\\n -1)\\n conservation_dest_constraints.append(constraint_i)\\n\\n ## OBJECTIVES\\n # Implementation of the load-balancing example from Wikipedia\\n # First we add more constraints so that we are minimising the maximum\\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\\n 'max_link_utilisation')\\n min_of_max_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\\n # i.e 'f_0 + f_1 + ... < max'\\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\\n '(5,{})'.format(i))\\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\\n for j, flow_variable in enumerate(flow_variables):\\n constraint_i.SetCoefficient(flow_variable[i],\\n demands[j] /\\n self.graph.get_edge_data(*edge)[\\n 'weight'])\\n min_of_max_constraints.append(constraint_i)\\n\\n # Objective now is to minimise the maximum link utilisation\\n objective = solver.Objective()\\n objective.SetCoefficient(max_utilisation_variable, 1)\\n objective.SetMinimization()\\n solver.Solve()\\n\\n return objective.Value()\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def cost(graph,a, undirected=True):\\n cost = sum(sum(np.array(abs(graph-a))))\\n if undirected:\\n return cost/2.0\\n else:\\n return cost\",\n \"def get_link_cost(self, global_clock_sec):\\n return self.static_delay_sec + \\\\\\n self.link_buffer.get_average_q_del_sec(global_clock_sec)\",\n \"def calc_demand(self, routing: np.ndarray, demand: float,\\n commodity_idx: int) -> np.ndarray:\\n commodity = self.commodities[commodity_idx]\\n node_flow = np.zeros(self.num_nodes)\\n node_flow[commodity[0]] = demand\\n\\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\\n for edge_idx, edge in enumerate(self.edges):\\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\\n\\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\\n\\n num_steps = 0\\n while True:\\n change = np.multiply(split_matrix, node_flow)\\n edge_utilisation += change\\n node_flow = np.matmul(split_matrix, node_flow)\\n if np.any(np.isnan(change)):\\n print(\\\"is_nan :'(\\\")\\n comparison = np.less(np.nan_to_num(change), self.min_delta)\\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\\n break\\n num_steps += 1\\n # if we take more than |E| steps we have cycles which is not good.\\n # Therefore: end here with really bad reward, scaled by number of\\n # cycles\\n if num_steps > routing.shape[1]:\\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\\n edge_utilisation += np.multiply(remaining_flow, np.full(\\n (self.num_nodes, self.num_nodes), demand))\\n break\\n\\n return edge_utilisation\",\n \"def calc_cost(self):\\n cost = 0\\n for i,[source, sinks] in enumerate(self.nets):\\n self.costs[i] = self.calc_half_perimeter(source, sinks)\\n cost += self.costs[i]\\n self.cost = cost\\n return True\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def compute_unequal_flow_allocations(target_graph, K=3):\\n\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n link_utilization = {}\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - {node}\\n destination_node = np.random.choice(list(possible_destination_nodes), 1, \\n replace=False).item()\\n shortest_path = nx.shortest_path(target_graph, node, destination_node)\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node\\n , flow_tx_rate = 10.0\\n , paths = [shortest_path]\\n , splitting_ratio = [1.0]\\n )\\n flows.append(the_flow)\\n\\n return flow_allocation_seed_number, flows\",\n \"def add_link_capacity(self, path, bw):\\n\\n # PART 1, TASK 3.4 add bw to edges\",\n \"def calculate_demand(flow, requested_sf, available_sf, service_functions):\\n\\n if requested_sf in available_sf:\\n vnf_need_placement = False\\n demanded_total_capacity = 0.0\\n for sf_i, sf_data in available_sf.items():\\n if requested_sf == sf_i:\\n # Include flows data rate in requested sf capacity calculation\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\\n sf_data['load'] + flow.dr)\\n else:\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\\n return demanded_total_capacity, vnf_need_placement\\n else:\\n vnf_need_placement = True\\n available_sf[requested_sf] = {'load': 0.0}\\n demanded_total_capacity = 0.0\\n for sf_i, sf_data in available_sf.items():\\n if requested_sf == sf_i:\\n # Include flows data rate in requested sf capacity calculation\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\\n sf_data['load'] + flow.dr)\\n else:\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\\n del available_sf[requested_sf]\\n return demanded_total_capacity, vnf_need_placement\",\n \"def objective(graph, flows):\\n\\n G = graph.copy()\\n rules = {}\\n flows.sort(key=lambda a: a[1], reverse=True)\\n\\n for flow,demand in flows:\\n src = get_host_from_ip(G, flow.nw_src)\\n dst = get_host_from_ip(G, flow.nw_dst)\\n\\n if not (src and dst):\\n continue\\n if not (src in G.nodes() and dst in G.nodes()):\\n continue\\n\\n path = widest_path(G, src, dst)\\n\\n hops = []\\n for a,b in pairwise(path):\\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\\n G.edge[a][b]['capacity'] -= demand\\n G.edge[b][a]['capacity'] -= demand\\n\\n rules[flow] = hops\\n\\n return rules\",\n \"def global_efficiency(graph):\\n return nx.global_efficiency(graph.graph)\",\n \"def maximum_flow(graph, start, end):\\n if not isinstance(graph, BasicGraph):\\n raise TypeError(f\\\"Expected subclass of BasicGraph, not {type(graph)}\\\")\\n Graph = type(graph)\\n \\n if start not in graph:\\n raise ValueError(f\\\"{start} not in graph\\\")\\n if end not in graph:\\n raise ValueError(f\\\"{end} not in graph\\\")\\n\\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\\n total_flow = 0\\n # -----------------------------------------------------------------------\\n # The algorithm\\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\\n # of DFS, which leads to a lot of node visits.\\n #\\n # I therefore choose to invert the capacities of the graph so that the\\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\\n # This allows me to use the shortest path method to find the path with\\n # most capacity in the first attempt, resulting in a significant reduction\\n # of unassigned flow.\\n #\\n # By updating G_inverted, with the residual capacity, I can keep using the\\n # shortest path, until the capacity is zero, whereby I remove the links\\n # When the shortest path method returns 'No path' or when unassigned flow\\n # is zero, I exit the algorithm.\\n #\\n # Even on small graphs, this method is very efficient, despite the overhead\\n # of using shortest path. For very large graphs, this method outperforms\\n # all other algorithms by orders of magnitude.\\n # -----------------------------------------------------------------------\\n\\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\\n inverted_graph = Graph(from_list=edges) # create G_inverted.\\n capacity_graph = Graph() # Create structure to record capacity left.\\n flow_graph = Graph() # Create structure to record flows.\\n\\n while unassigned_flow:\\n # 1. find the best path\\n d, path = shortest_path(inverted_graph, start, end)\\n if d == float(\\\"inf\\\"): # then there is no path, and we must exit.\\n return total_flow, flow_graph\\n # else: use the path and lookup the actual flow from the capacity graph.\\n\\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\\\"inf\\\"))) for s, e, d in graph.edges(path=path)])\\n\\n # 2. update the unassigned flow.\\n unassigned_flow -= path_flow\\n total_flow += path_flow\\n\\n # 3. record the flows and update the inverted graph, so that it is\\n # ready for the next iteration.\\n edges = graph.edges(path)\\n for n1, n2, d in edges:\\n # 3.a. recording:\\n v = flow_graph.edge(n1, n2, default=None)\\n if v is None:\\n flow_graph.add_edge(n1, n2, path_flow)\\n c = graph.edge(n1, n2) - path_flow\\n else:\\n flow_graph.add_edge(n1, n2, value=v + path_flow)\\n c = graph.edge(n1, n2) - (v + path_flow)\\n capacity_graph.add_edge(n1, n2, c)\\n\\n # 3.b. updating:\\n # if there is capacity left: update with new 1/capacity\\n # else: remove node, as we can't do 1/zero.\\n if c > 0:\\n inverted_graph.add_edge(n1, n2, 1 / c)\\n else:\\n inverted_graph.del_edge(n1, n2)\\n return total_flow, flow_graph\",\n \"def update_flow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n # (1): add all edges (u, v) with capacity ub-lb\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"upper_bound\\\"] == float('inf'):\\n self.arc_info[arc][\\\"upper_bound\\\"] = B\\n for arc in self.arc_info.keys():\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"upper_bound\\\"]\\\\\\n - self.arc_info[arc][\\\"lower_bound\\\"]))\\n # (2): add edge (t, s) with capacity B\\n # B = max_lb * (m - n + 2)\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n if B == 0:\\n #B = float('inf')\\n B = 100000\\n start_nodes.append(self.sink())\\n end_nodes.append(self.source())\\n capacities.append(int(B))\\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\\n s_prime = max(self.vertices) + 1\\n t_prime = max(self.vertices) + 2\\n print(\\\"s'={}, t'={}\\\".format(s_prime, t_prime))\\n for v in self:\\n #print(\\\"vert {} in arcs: {}\\\".format(v,\\n # self.in_arcs_lists[v]))\\n # compute exc: lower bounds of in - lower bounds of out\\n sum_lb_in = 0\\n for in_arc in self.in_arcs_lists[v]:\\n sum_lb_in += self.arc_info[in_arc][\\\"lower_bound\\\"]\\n sum_lb_out = 0\\n #print(\\\"vert {} out arcs: {}\\\".format(v,\\n # self.out_arcs_lists[v]))\\n for out_arc in self.out_arcs_lists[v]:\\n sum_lb_out += self.arc_info[out_arc][\\\"lower_bound\\\"]\\n exc = sum_lb_in - sum_lb_out\\n #print(\\\"exc is {}\\\".format(exc))\\n if exc > 0:\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(exc))\\n else:\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(-exc))\\n # solve maxflow\\n #print(\\\"s' is {} and t' is {}\\\".format(s_prime, t_prime))\\n max_flow = pywrapgraph.SimpleMaxFlow()\\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\\n #print(\\\"Adding edge {}, {} with cap {}\\\".format(u,v,cap))\\n max_flow.AddArcWithCapacity(u, v, cap)\\n success = True\\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\\n #print(' Arc Flow / Capacity')\\n for i in range(max_flow.NumArcs()):\\n # print('%1s -> %1s %3s / %3s' % (\\n # max_flow.Tail(i),\\n # max_flow.Head(i),\\n # max_flow.Flow(i),\\n # max_flow.Capacity(i)))\\n # check that (s', v) edges are saturated (once we find a false,\\n # stay false forever)\\n if success:\\n if max_flow.Tail(i) == s_prime:\\n success = max_flow.Flow(i) == max_flow.Capacity(i)\\n else:\\n success = False\\n print('There was an issue with the max flow input.')\\n if success:\\n # update the flows to be the flow found from maxflow problem\\n for i in range(max_flow.NumArcs()):\\n # if this is an original arc, update the flow\\n if max_flow.Tail(i) != s_prime \\\\\\n and max_flow.Head(i) != t_prime \\\\\\n and not (max_flow.Tail(i) == self.sink() \\\\\\n and max_flow.Head(i) == self.source()):\\n # update arc\\n start = max_flow.Tail(i)\\n destin = max_flow.Head(i)\\n arc = self.get_arc(start, destin)\\n new_flow = self.arc_info[arc][\\\"lower_bound\\\"] + max_flow.Flow(i)\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n self.arc_info[arc][\\\"weight\\\"] = new_flow\\n #print(\\\"Edge {} {} adjusted from {} to {}\\\".format(\\n # start,\\n # destin,\\n # old_flow,\\n # new_flow\\n # ))\\n self.check_conservation_of_flow() # check that solution is valid\\n return True\\n else:\\n return False\",\n \"def compute_equal_flow_allocations(target_graph, K=3):\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n flow_allocation_seed_number = 0xDEAD_BEEF\\n np.random.seed(flow_allocation_seed_number)\\n flows = []\\n for node in target_graph.nodes:\\n possible_destination_nodes = set(target_graph.nodes) - set([node])\\n [destination_node] = np.random.choice(list(possible_destination_nodes), 1, replace=False)\\n # shortest_paths = all_shortest_paths(target_graph, node, destination_node.item())\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, node, destination_node.item(),\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n the_flow = Flow( source_node = node\\n , destination_node = destination_node.item()\\n , flow_tx_rate = 10.0\\n , paths = k_shortest_paths\\n , splitting_ratio = [1/K]*K\\n )\\n flows.append(the_flow)\\n \\n return flow_allocation_seed_number, flows\",\n \"def sub_link_capacity(self, path, bw):\\n \\n # PART 1, TASK 3.4 sub bw to edges\",\n \"def check_link_availability(self, link):\\n circuits = self.load_circuits()\\n total = 0\\n for circuit in circuits:\\n exists = circuit.get_link(link)\\n if exists:\\n total += exists.bandwidth\\n if total + link.bandwidth > 100000000000: # 100 Gigabits\\n return None\\n return total\",\n \"def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\\n pass\",\n \"def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\\n dtype=float)\\n\\n for commodity_idx in range(len(self.commodities)):\\n utilisation = self.calc_demand(routing,\\n demands[commodity_idx],\\n commodity_idx)\\n total_utilisation += utilisation\\n\\n return np.max(np.divide(total_utilisation, self.edge_capacities))\",\n \"def main(supply):\\n\\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\\n # between each pair. For instance, the arc from node 0 to node 1 has a\\n # capacity of 15 and a unit cost of 4.\\n\\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\\n\\n # Define an array of supplies at each node.\\n supplies = supply\\n\\n\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n\\n # Add each arc.\\n for i in range(0, len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\\n capacities[i], unit_costs[i])\\n\\n # Add node supplies.\\n\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n\\n\\n # Find the minimum cost flow between node 0 and node 4.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n flag = 1\\n optimal_flows = np.zeros(36)\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # save answer to the variable\\n optimal_flows[i] = min_cost_flow.Flow(i)\\n return flag, optimal_flows\\n else:\\n print('There was an issue with the min cost flow input.')\\n flag = 0\\n return flag, 0\",\n \"def get_expected_cost(self):\",\n \"def update_flow(self):\\n N = len(self.vertices)\\n _vertices = self.vertices+['_source', '_sink']\\n s, t = _vertices.index('_source'), _vertices.index('_sink')\\n cost, capacity = dok_matrix((N+2, N+2)), dok_matrix((N+2, N+2))\\n\\n cost[:N, :N] = self.cost\\n capacity[:N, :N] = self.upper_bound-self.lower_bound\\n # _source to main vertices\\n l_in = self.lower_bound.toarray().sum(axis=0)\\n us, = l_in.nonzero()\\n for u in us:\\n capacity[s, u] = l_in[u]\\n # main vertices to _sink\\n l_out = self.lower_bound.toarray().sum(axis=1)\\n us, = l_out.nonzero()\\n for u in us:\\n capacity[u, t] = l_out[u]\\n # sink to source\\n infinite_flow = self.upper_bound.toarray().sum()\\n capacity[_vertices.index('sink'), _vertices.index('source')] = infinite_flow\\n\\n # get a feasible flow on original graph by finding the max flow on\\n # auxiliary graph\\n aux_fg = FlowGraph(_vertices, cost, capacity, True)\\n aux_fg.FordFulkerson()\\n assert aux_fg.residual[s].toarray().sum()==0, 'feasible flow within bounds not found'\\n\\n self.residual = aux_fg.residual[:N, :N]\\n s, t = self.vertices.index('source'), self.vertices.index('sink')\\n self.residual[s, t] = 0\\n self.residual[t, s] = 0\\n\\n self.FordFulkerson()\",\n \"def __compute_connection_strengths(G, induced_ordering, previous_vertex):\\n # for edges incident to the previous vertex added to the induced ordering\\n for edge in previous_vertex.get_incident_edges():\\n other_node = edge.get_other_node(previous_vertex.get_name()) # get the other node object\\n if other_node.get_name() not in induced_ordering: # if the other node is not in the ordering\\n other_node.set_attribute_value(\\n StoerWagner.CONNECTION_STRENGTH_ATTRIBUTE,\\n other_node.get_attribute_value(StoerWagner.CONNECTION_STRENGTH_ATTRIBUTE) + edge.get_weight()\\n ) # add to the connection strength, the weight of the edge\\n return G # return the graph with the connection strength information\",\n \"def diff_equilibrium_equation(flow, capacity, network, route_idx): \\r\\n total_flow = np.sum(flow)\\r\\n if 0 < total_flow < 1:\\r\\n diff = np.log(flow[route_idx]) + network.beta * (flow[route_idx]**network.theta) - network.b[route_idx] + \\\\\\r\\n network.phi * flow[route_idx]/capacity[route_idx] - np.log(1-total_flow) \\r\\n return diff \\r\\n else:\\r\\n print(\\\"The given flow vector is not feasible.\\\")\\r\\n return 0\",\n \"def link_compare(a, b):\\n\\n # wired > anything\\n if not a.is_wifi() and not a.is_mobile() and (b.is_wifi() or b.is_mobile()):\\n return 1\\n\\n # wifi > mobile unless wifi is going down.\\n if a.is_wifi() and b.is_mobile():\\n return a.is_going_down() == False\\n\\n # if its the same tech, signal strength decides who's better\\n if type(a) == type(b):\\n delta = a.strenght - b.strenght\\n return delta / abs(delta) if delta != 0 else 0\\n\\n return 0\",\n \"def update_bandwidth(self, flow_id, flow_current_bandwidth,\\n flow_statistics, time_str):\\n\\n reassigned_flow_bandwidth = {}\\n temp_current = flow_current_bandwidth\\n temp = {}\\n total_bandwidth = 0\\n for f_id in flow_statistics:\\n del temp_current[f_id]\\n\\n initial = datetime.strptime(flow_statistics[f_id][0], '%Y-%m-%d '\\n '%H:%M:%S.%f')\\n final = datetime.strptime(flow_statistics[f_id][1], '%Y-%m-%d '\\n '%H:%M:%S.%f')\\n request_time = datetime.strptime(time_str, '%Y-%m-%d %H:%M:%S.%f')\\n\\n delta_time = request_time - final\\n total_delta = final - initial\\n # TODO: must be a clever way to fix this\\n if delta_time.total_seconds() < 5:\\n if 0 == total_delta.total_seconds():\\n new_bandwidth = flow_statistics[f_id][2][0][0]\\n else:\\n new_bandwidth = \\\\\\n sum([x[0] for x in flow_statistics[f_id][2]])\\\\\\n /total_delta.total_seconds()\\n else:\\n new_bandwidth = 0\\n total_bandwidth += new_bandwidth\\n temp[f_id] = new_bandwidth\\n\\n for f_id in temp:\\n reassigned_flow_bandwidth[f_id] = \\\\\\n (temp[f_id]/total_bandwidth) * self.max_capacity\\n log.info(\\\"The bandwidth assign of %s is %s\\\",\\n f_id, reassigned_flow_bandwidth[f_id])\\n\\n current_capacity = sum(reassigned_flow_bandwidth.values())\\n\\n if self.max_capacity+self.reserved_bytes < current_capacity:\\n log.warning(\\\"Capacity overflow max+reserved %s - assigned capacity \\\"\\n \\\"%s\\\",\\n self.max_capacity + self.reserved_bytes,\\n current_capacity)\\n # Sanity check, all flows that are not in statistics implies no\\n # activity, so assign a bandwidth of 0\\n for id_flow in temp_current:\\n reassigned_flow_bandwidth[id_flow] = 0\\n\\n return reassigned_flow_bandwidth\",\n \"def get_interval_from_minflow(self, wide=False):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.arc_info[arc][\\\"start\\\"],\\n # self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.arc_info[arc][\\\"destin\\\"],\\n # self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # x,\\n # self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.source(),\\n # x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # self.sink(),\\n # x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n # print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n # x,\\n # self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".\\n # format(s_prime, v, int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".\\n # format(v, t_prime, int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n # s_prime,\\n # x,\\n # int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n # print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n # x,\\n # t_prime,\\n # int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i],\\n capacities[i],\\n unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n # print('Minimum cost:', min_cost_flow.OptimalCost())\\n # print('')\\n # print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n # cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n # print('%1s -> %1s %3s / %3s %3s' % (\\n # min_cost_flow.Tail(i),\\n # min_cost_flow.Head(i),\\n # min_cost_flow.Flow(i),\\n # min_cost_flow.Capacity(i),\\n # cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n # print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n # print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n # destin,\\n # sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in\\n self.arc_info[arc].keys()):\\n # print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n bound_1 = old_flow + sup_flow\\n bound_2 = old_flow - sup_flow\\n new_lb = max(0, int(min(bound_1, bound_2)))\\n new_ub = int(max(bound_1, bound_2))\\n if wide:\\n if new_lb == new_ub:\\n # print(\\\"We had a zero interval\\\")\\n new_lb = int(new_lb*0.8)\\n new_ub = int(new_ub*1.2)\\n if new_lb == 0:\\n # print(\\\"We got a zero lower bound\\\")\\n new_ub = 5\\n # print(\\\"But now we're doing {} {}\\\".\\n # format(new_lb, new_ub))\\n\\n self.arc_info[arc][\\\"lower_bound\\\"] = new_lb\\n self.arc_info[arc][\\\"upper_bound\\\"] = new_ub\\n # print(\\\"Edge ({},{}) bounds are [{},{}]\\\".format(\\n # start,\\n # destin,\\n # self.arc_info[arc][\\\"lower_bound\\\"],\\n # self.arc_info[arc][\\\"upper_bound\\\"]))\\n # print(self.arc_info[arc])\\n else:\\n print('There was an issue with the min cost flow input.')\\n # self.check_conservation_of_flow() # check that solution is valid\",\n \"def cost(self) -> float:\",\n \"def compute_social_welfare(flow):\\r\\n total_flow = np.sum(flow)\\r\\n if 0 < total_flow < 1:\\r\\n social_welfare = np.sum(np.multiply(flow, np.log(flow))) - total_flow * np.log(1 - total_flow)\\r\\n return social_welfare \\r\\n else:\\r\\n print(\\\"The given flow vector is not feasible.\\\")\\r\\n return 0\",\n \"def averageExcessCost(self):\\n TSTT = 0\\n for l in self.link:\\n if self.link[l].flow <0:\\n print(\\\"what in tarnation?\\\") #this really shouldn't happen, but the sheer number of leetcode problems I've been doing make me want to check against it anyway\\n break\\n if self.link[l].flow >0:\\n contribution = self.link[l].flow * self.link[l].cost\\n TSTT += contribution\\n SPTT = 0\\n TotalDemand = 0\\n for od in self.ODpair:\\n if self.ODpair[od].demand >0:\\n O = self.ODpair[od].origin\\n D = self.ODpair[od].destination\\n BL,C = self.shortestPath(O)\\n SPTT += C[D]*self.ODpair[od].demand\\n TotalDemand+=self.ODpair[od].demand\\n AEC = (TSTT - SPTT)/TotalDemand\\n \\n return AEC\",\n \"def compute_cost(self, chrome):\\n return 1\",\n \"def check_path_availability(self, path, bandwidth):\\n total = 0\\n for endpoint_a, endpoint_b in zip(path[:-1], path[1:]):\\n link = Link(Endpoint(endpoint_a[:23], endpoint_a[24:]),\\n Endpoint(endpoint_b[:23], endpoint_b[24:]),\\n bandwidth)\\n avail = self.check_link_availability(link)\\n if avail is None:\\n return None\\n total += avail\\n return total\",\n \"def combined_costs(matrix_MSLL_IO):\\r\\n return\",\n \"def handle_request(self, sw, util, duration, time_now):\\n\\n #logging.debug(str(self.graph.edges(data=True)))\\n\\n #1 Get available paths from servers to switch\\n paths = self.get_srv_paths(sw, self.graph)\\n\\n #2 choose the path which mins the max link utilization for all links\\n # along the path\\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\\n\\n if len(bestpath) > 0:\\n self.allocate_resources(bestpath, util, time_now, duration)\\n else:\\n logging.warn(\\\"[%s] No best path found at switch [%s]\\\", str(time_now), str(sw))\\n\\n return bestpath\",\n \"def compute_social_welfare(self):\\r\\n #self.social_welfare = 0\\r\\n #for i in range(self.num_routes):\\r\\n # self.social_welfare += self.routes[i].flow * self.routes[i].get_route_utility()\\r\",\n \"def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\\n model = copy.deepcopy(model_old)\\n \\n #cpu_vector = model.cost_dict['cpu']\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n #bw_matrix = model.cost_dict['bw']\\n w_a1, w_a2 = w_a\\n w_b1, w_b2 = w_b\\n theta1, theta2, theta3 = theta\\n # find total capacity and used bw on substrate nodes\\n node_port_list, used_bw_list = total_port(model)\\n #print \\\"CHECK POINT-1\\\", used_bw_list, node_port_list\\n vnet_info = model.get_vnet_info()\\n infeasible = 0\\n\\n fail_nodes = model.failed_dict\\n start_time = time.time()\\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n # random selection\\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n #print \\\"selection takes: \\\", time.time() - start_time\\n #print \\\"Selected\\\", select_dict\\n sum_cost_1_2 = 0\\n r_list = {}\\n \\n for node_id in range(0,len(used_bw_list)):\\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\\n #print \\\"INITIAL\\\", r_list\\n svr_subset = {}\\n for vnet in model.vnets:\\n j = vnet.vnet_id\\n f = fail_nodes[j]\\n # only count the failed virtual network\\n if f == -1:\\n pass\\n else:\\n for node_id in vnet_info[j]['standby']:\\n svr_subset[node_id] = r_list[node_id]\\n #print \\\"Subset SVR: \\\", svr_subset\\n \\n if j in select_dict:\\n #print \\\"FEASIBLE FOUND\\\"\\n #print vnet_info[j]['standby']\\n i = select_dict[j]\\n failed_node = vnet.vnodes[f]\\n vneighbors = failed_node.vneighbors\\n for k in vneighbors: \\n eta = operation_cost()\\n #print \\\"a1: \\\", w_a1, \\\"a2: \\\", w_a2, \\\"b1: \\\", w_b1, \\\"b2: \\\", w_b2\\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\\n rtt_c = rtt_cost(i, k, rtt_matrix)\\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\\n #find residual bw on substrate node\\n #xi = resource_cost(bw_matrix, i)\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n #util = req_bw / xi\\n #print req_bw, i, used_bw_list[i], node_port_list[i]\\n util = req_bw/node_port_list[i]\\n \\n if i not in r_list:\\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\\n else:\\n r_list[i] += util\\n svr_subset[i] = r_list[i]\\n #print sigma, \\\" v_\\\" + str(vnet.vnet_id) + \\\"_\\\" + str(f) + \\\"_\\\" + str(i) + \\\"_\\\" + str(k) + \\\"_\\\" + str(k)\\n else:\\n print \\\"INFEASIBLE at vnet: \\\", j\\n infeasible = 1\\n #print \\\"DONE\\\"\\n \\n if infeasible == 0:\\n #print svr_subset\\n max_util = max(svr_subset.values())\\n obj = sum_cost_1_2 + theta3 * max_util\\n else:\\n obj = \\\"infeasible\\\"\\n max_util = \\\"none\\\"\\n #print obj\\n used_time = time.time() - start_time\\n return obj, select_dict, max_util, used_time\",\n \"def build_links_capacity(self):\\n\\n links_capacity = {}\\n # Iterates all the edges in the topology formed by switches\\n for src, dst in self.topo.keep_only_p4switches().edges:\\n bw = self.topo.edges[(src, dst)]['bw']\\n # add both directions\\n links_capacity[(src, dst)] = bw\\n links_capacity[(dst, src)] = bw\\n\\n return links_capacity\",\n \"def cal_step(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,timecost_b,_ulabel_lane,per_b):\\n lb = 0.0000000001\\n ub = 0.99\\n step = (lb + ub) / 2.0\\n while abs(div(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,step,timecost_b,_ulabel_lane,per_b)) >= 0.01 and abs(ub-lb) > 0.0001:\\n if div(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,step,timecost_b,_ulabel_lane,per_b) * div(net_a, net_b, prior_a,prior_b, posterior_a, posterior_b,origins,destinations,od_flow,od_flow_b,v_b,ub,timecost_b,_ulabel_lane,per_b) > 0:\\n ub = step\\n else:\\n lb = step\\n step = (lb + ub) / 2.0\\n return step\",\n \"def compute_link_loss(min_dist, dist_der, safety_dist):\\n dist = min_dist[0]\\n if dist < safety_dist:\\n return (safety_dist - dist) * dist_der\\n return np.zeros_like(dist_der)\",\n \"def local_efficiency(self, node_list1, node_list2, link_attribute=None):\\n path_lengths = self.cross_path_lengths(node_list1, node_list2,\\n link_attribute)\\n return np.mean(1/path_lengths, axis=1)\",\n \"def _calculate_costs(self):\\n cost = 0\\n cost += self._cost_route_fine()\\n cost += self._cost_petrol()\\n cost += self._cost_wage()\\n cost += self._cost_refueling()\\n cost += self._cost_caught_by_police()\\n cost += self._cost_vehicle_malfunction()\\n return cost\",\n \"def DRPathValidation(self, flow, p):\\n\\t\\tpath_rate_lst = []\\n\\n\\t\\tarr_time = flow[3]\\n\\t\\tend_time = flow[3] + flow[4]\\n\\t\\tedge_lst = [(p[i], p[i+1]) for i in xrange(len(p)-1)]\\n\\t\\t# Calculate the bottlenecked rate at each event point\\n\\t\\tfor evt in self.event_lst:\\n\\t\\t\\tmin_rate = float('inf')\\n\\t\\t\\tfor e in edge_lst:\\n\\t\\t\\t\\tif evt in self.rate_lst[e].keys() and self.rate_lst[e][evt] < min_rate:\\n\\t\\t\\t\\t\\tmin_rate = self.rate_lst[e][evt]\\n\\t\\t\\tif min_rate < float('inf'):\\n\\t\\t\\t\\tpath_rate_lst.append((evt, min_rate))\\n\\n\\t\\t# Calculate the cumulative size over the bottleneck rates between arr_time and end_time\\n\\t\\tprev_time = arr_time\\n\\t\\tprev_rate = 0\\n\\t\\tcum_size = 0\\n\\t\\trate_alloc = [(-1, 0)]\\t# Start from time -1 with rate 0, so as a benchmark from the beginning\\n\\t\\tfor time, rate in path_rate_lst:\\n\\t\\t\\t# Each time period is from prev_time -> min{time, end_time}\\n\\t\\t\\tif time > prev_time:\\n\\t\\t\\t\\tif time < end_time:\\n\\t\\t\\t\\t\\tcum_size += prev_rate * (time - prev_time)\\n\\t\\t\\t\\t\\tcur_ed_time = time\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tcum_size += prev_rate * (end_time - prev_time)\\n\\t\\t\\t\\t\\tcur_ed_time = end_time\\n\\t\\t\\t\\trate_alloc.append((prev_time, prev_rate))\\n\\n\\t\\t\\t\\tif cum_size >= flow[2]:\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\telif time >= end_time:\\n\\t\\t\\t\\t\\tbreak\\n\\n\\t\\t\\tprev_time = time\\n\\t\\t\\tprev_rate = rate\\n\\n\\t\\t# If it can carry the flow size before deadline\\n\\t\\tif cum_size >= flow[2]:\\n\\t\\t\\tcum_size -= prev_rate * (cur_ed_time - prev_time)\\n\\t\\t\\tnew_end_time = float(flow[2] - cum_size) / prev_rate + prev_time\\n\\t\\t\\t# Add the finish rate onto the allocation list\\n\\t\\t\\trate_alloc.append((new_end_time, 0))\\n\\n\\t\\t\\treturn True, edge_lst, self.DRAllocTrim(rate_alloc), new_end_time\\n\\n\\t\\t# If not, return the minimum edge regarding the cumulative size\\n\\t\\tedge, size = self.DRFindMinimalEdge(flow, edge_lst)\\n\\t\\treturn False, edge, size\",\n \"def get_speed_cost(data, start_node_id, end_node_id):\\n start_node = data[start_node_id]\\n dist_cost = get_dist_cost(data, start_node_id, end_node_id)\\n # Get the speed limit along the way that connects the starting and ending nodes\\n speed_limit_between_nodes = start_node['adjacent'][end_node_id]\\n return dist_cost / speed_limit_between_nodes # Cost = Time = Distance/Rate\",\n \"def legalize_graph(gm: pippy.fx.GraphModule) -> pippy.fx.GraphModule:\\n indeg = {node: 0 for node in gm.graph.nodes}\\n new_graph = pippy.fx.Graph()\\n # Track how many unfulfilled dependencies each node has\\n for node in gm.graph.nodes:\\n for user in node.users:\\n indeg[user] += 1\\n queue: collections.deque = collections.deque()\\n # Add all nodes with no dependencies to the queue\\n for node in gm.graph.nodes:\\n if indeg[node] == 0:\\n queue.append(node)\\n env: Dict[pippy.fx.Node, pippy.fx.Node] = {}\\n # Pop nodes from the queue, and add nodes that have had all their\\n # dependencies fulfilled\\n while len(queue) > 0:\\n cur = queue.popleft()\\n env[cur] = new_graph.node_copy(cur, lambda x: env[x])\\n for user in cur.users:\\n indeg[user] -= 1\\n if indeg[user] == 0:\\n queue.append(user)\\n # If the new graph's size is not as large as the old one, then there must be\\n # a cycle (i.e. some node's dependencies were not satisfied.)\\n if len(new_graph.nodes) < len(gm.graph.nodes):\\n raise RuntimeError(f\\\"Input graph has cycles, unable to add {[node for node in indeg if indeg[node] != 0]}\\\")\\n gm.graph = new_graph\\n return gm\",\n \"def calculate_path_cost_with_weighted_sum(self, path, attr1, attr2): \\n costs = [] \\n for i in range(len(path) - 1):\\n a = (1- self.G[path[i]][path[i+1]][attr2]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \\n b = (1- self.G[path[i]][path[i+1]][attr1]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \\n costs.append(a * self.G[path[i]][path[i+1]][attr1] + b * self.G[path[i]][path[i+1]][attr2]) \\n return max(costs)\",\n \"def connection_probability(prev_props : EdgeProps, curr_props : EdgeProps) -> float:\\n d = Delay.__compute_delay(\\n arrival_time = prev_props['arr_time'],\\n next_departure_time = curr_props['dep_time'], \\n ttype = prev_props['ttype'], \\n previous_route_id = prev_props['trip_id'],\\n next_route_id = curr_props['trip_id']\\n )\\n proba = Delay.__connection_probability(\\n delay = d, \\n gamma_params = prev_props['gamma'], \\n ttype = curr_props['ttype'], \\n previous_route_id = prev_props['trip_id'],\\n next_route_id = curr_props['trip_id']\\n )\\n return proba\",\n \"def global_efficiency(self, node_list1, node_list2, link_attribute=None):\\n local_efficiency = self.local_efficiency(node_list1, node_list2,\\n link_attribute)\\n return 1/np.mean(local_efficiency)\",\n \"def operation_cost(tau=0):\\n iface_on = 0.2\\n iface_off = 0.2 \\n ipconfig = 2\\n reconf_ip_bin = tau\\n op_cost = 2 * (iface_on + iface_off) + reconf_ip_bin * ipconfig\\n return op_cost\",\n \"def calculate_cost(route, adjacency_matrix):\\n route_shifted = np.roll(route,1)\\n cost = np.sum(adjacency_matrix[route, route_shifted])\\n st_dev = np.std(adjacency_matrix[route, route_shifted])\\n return st_dev, cost\",\n \"def su_cost(node_type, node_count, cpu, gpu, ram, duration):\\r\\n if node_type == 'std':\\r\\n node_factor = 1\\r\\n tot_cpu = 28\\r\\n tot_ram = 128\\r\\n if node_type == 'gpu':\\r\\n node_factor = 2\\r\\n tot_cpu = 28\\r\\n tot_ram = 256\\r\\n if node_type == 'fat':\\r\\n node_factor = 6\\r\\n tot_cpu = 56\\r\\n tot_ram = 1024\\r\\n # job_setup = \\\"current setup = {} node type + {} number of nodes + {} number of cpu # + {} number of ram + {} hrs duration of job + {} total cpu + {} total ram\\\".format(node_type, node_count, cpu, ram, duration, tot_cpu, tot_ram)\\r\\n # calculate service units\\r\\n max_resource = top_resource(\\r\\n alloc_CPU = cpu, cpu_denominator = tot_cpu,\\r\\n alloc_GPU = gpu, gpu_denominator = 4,\\r\\n alloc_RAM = ram, ram_denominator = tot_ram)\\r\\n su = ( (node_count * (max_resource * node_factor)) * 28 * duration )\\r\\n return(su)\",\n \"def _straight(self):\\r\\n \\r\\n flow = min(self.upstream.demand, self.downstream.supply)\\r\\n self.upstream.outflow = flow\\r\\n self.downstream.inflow = flow\",\n \"def calculate_algorithm_cost(algorithm_stats, operation_costs): \\n\\n (comparisons, reads, writes) = algorithm_stats\\n (comparison_cost, read_cost, write_cost) = operation_costs\\n return (comparisons * comparison_cost) + (reads * read_cost) + (writes * write_cost)\",\n \"def internal_link_density(self, node_list):\\n N = len(node_list)\\n n_links = self.number_internal_links(node_list)\\n if self.directed:\\n return float(n_links) / (N * (N - 1))\\n else:\\n return 2 * float(n_links) / (N * (N - 1))\",\n \"def topo_efficiency_cal(self):\\n Temp = 0\\n for i in self.supplyseries:\\n for j in self.demandseries:\\n if(self.topo_shortestpathij(i, j) == None):\\n continue\\n Temp += 1/self.topo_shortestpathij(i, j)\\n \\n self.topo_efficiency = 1/(self.supplynum*self.demandnum)*Temp\",\n \"def find_max_flow(graph, start, end):\\n try:\\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\\\"weight\\\")\\n return flow_value\\n except Exception as e:\\n print(\\\"Error in Max flow computation \\\", e)\\n return \\\"NaN\\\"\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE ***\\\"\\n fringe = util.PriorityQueueWithFunction(lambda node: node.path_cost)\\n return GraphSearch(problem, 'ucs').search(fringe)\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def cost(route):\\n cost = 0\\n for li in route:\\n if cost<li.get_cost():\\n cost=li.get_cost()\\n return cost\",\n \"def GetPathCost(self, bucketOfActions):\",\n \"def bgll(self, graph, node_count, min_mod, max_pass):\\n\\n #the belonging of the node\\n bl = [i for i in range(node_count)]\\n #the node's weight in community\\n _in = [0.0] * node_count\\n #the node's weight in graph\\n _tot = []\\n #total weight of a node, just a copy of _tot\\n k = []\\n #the total weight of the graph\\n m = []\\n\\n #inital the in-param\\n network = [[0.0] * node_count for n in range(node_count)]\\n for node, tag, weight in graph:\\n network[node][tag] = weight\\n for node in network:\\n k.append(sum(node))\\n _tot = k[:]\\n m = sum(k)\\n #inital the in-param\\n\\n def modularity():\\n \\\"\\\"\\\"\\n This function mainly computes the modularity of the network\\n Return:\\n mod->the modularity value\\n \\\"\\\"\\\"\\n\\n q = 0.0\\n for idx in range(0, node_count):\\n if _tot[idx] > 0.0:\\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\\n return q\\n\\n def modularity_gain(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly computes the modularity gain of a node moving\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n Return:\\n gain->modularity gain\\n \\\"\\\"\\\"\\n\\n totc = _tot[c]\\n degc = k[n]\\n return dnodecomm - (totc * degc) / m\\n\\n def neigh_comm(n):\\n \\\"\\\"\\\"\\n This function mainly computes the weight between the node and it's neighbour community\\n Param:\\n n->node id\\n Return:\\n nc->the map of the weight between the node and it's neighbour community\\n nc=>{cid,weight}\\n \\\"\\\"\\\"\\n\\n nc = {bl[n]: 0.0}\\n for idx in range(0, node_count):\\n neigh = idx\\n ncomm = bl[neigh]\\n nei_weight = network[n][idx]\\n if (neigh != n) & (nei_weight > 0.0):\\n if ncomm in nc:\\n nc[ncomm] += nei_weight\\n else:\\n nc[ncomm] = nei_weight\\n return nc\\n\\n def insert(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly get the effect of insert the node into community\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n \\\"\\\"\\\"\\n\\n _tot[c] += k[n]\\n _in[c] += 2 * dnodecomm + network[n][n]\\n bl[n] = c\\n\\n def remove(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly get the effect of remove the node off community\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n \\\"\\\"\\\"\\n\\n _tot[c] -= k[n]\\n _in[c] -= 2 * dnodecomm + network[n][n]\\n bl[n] = -1\\n\\n def detect():\\n \\\"\\\"\\\"\\n This function mainly detect the community of the graph.\\n \\\"\\\"\\\"\\n\\n _pass_done = 0\\n _improve = True\\n new_mod = modularity()\\n cur_mod = -999999999.0\\n rl = random.sample(range(0, node_count), node_count)\\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\\n cur_mod = new_mod\\n _improve = False\\n _pass_done += 1\\n for node_tmp in rl:\\n n = node_tmp\\n nc = bl[n]\\n ncomm = neigh_comm(n)\\n remove(n, nc, ncomm[nc])\\n best_c = nc\\n best_l = 0.0\\n best_incre = 0.0\\n for c in ncomm:\\n incre = modularity_gain(n, c, ncomm[c])\\n if incre > best_incre:\\n best_incre = incre\\n best_c = c\\n best_l = ncomm[c]\\n insert(n, best_c, best_l)\\n if best_c != nc:\\n _improve = True\\n new_mod = modularity()\\n print new_mod\\n\\n detect()\\n return bl\",\n \"def path_cost(self, c, state1, action, state2):\\n # This should probably just be 1 every state....\\n return c + 1\",\n \"def path_cost(self, c, state1, action, state2):\\n # This should probably just be 1 every state....\\n return c + 1\",\n \"def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\\n #print slink_dict\\n #print \\\"FIND\\\"\\n failed_dict = model.failed_dict\\n #print failed_dict, limit\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n bw_matrix = model.cost_dict['bw']\\n #cpu_vector = model.cost_dict['cpu']\\n selected_dict = {}\\n \\n # get aggregated residual bw for all substrate nodes, and store it as a list\\n snode_bw_list = total_bw(bw_matrix)\\n \\n # get total capacity and used bw for each snode\\n node_port_list, used_bw_list = total_port(model)\\n #vnet_set = model.vnets\\n sorted_vn = sort_vnet(model)\\n\\n #for vnet in vnet_set:\\n if w_m[2] >= 10*w_m[1]:\\n threshold = 0.8\\n else:\\n threshold = 0.8\\n snode_traffic = {}\\n for vn_traffic in sorted_vn:\\n vnet = vn_traffic[0]\\n failed_vr = failed_dict[vnet.vnet_id]\\n if failed_vr != -1: \\n # this node is failed\\n standby_list = vnet.get_standby_ids()\\n standby_cost = {}\\n for s_vr in standby_list:\\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\\n failed_node = vnet.vnodes[failed_vr]\\n vneighbors = failed_node.vneighbors\\n dist_k = 0\\n rtt_k = 0\\n for k in vneighbors:\\n dist_k += float(dist_matrix[s_vr][k + 1])\\n rtt_k += float(rtt_matrix[s_vr][k + 1])\\n\\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\\\\n w_b[1] * rtt_k\\n res_cost = snode_bw_list[s_vr]\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\\n standby_cost[s_vr] = total\\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\\n #print \\\"SORTED\\\", sorted_x\\n \\n for item in sorted_x:\\n if item[0] not in snode_traffic:\\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n else:\\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n #print utilization\\n # Link-Path selsection add-on\\n path_alloc = 1\\n for k in vneighbors:\\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\\n item[0] + 1, k + 1)\\n demand = demand_dict[demand_id]['capacity']\\n find, path = find_path(demand_path, demand_id, \\n slink_dict, demand) \\n if find == 0:\\n print \\\"No available path between svr and nbr on the substrate network\\\" \\n path_alloc = 0\\n #print \\\"FIND PATH\\\", find, path\\n # End link-path block \\n #print \\\"ALLOCATED: \\\", path_alloc\\n if path_alloc == 1:\\n if selected_dict.values().count(item[0]) < limit:\\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\\n if item[0] not in snode_traffic: \\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] = vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break;\\n else:\\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \\n if min_id == item[0]:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n #threshold = (threshold + 0.01)/2\\n break\\n elif utilization < threshold:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n if item[0] not in snode_traffic: \\n snode_traffic[item[0]] = vn_traffic[1]\\n else:\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break\\n else:\\n print \\\"does not satisfy the threshold\\\" \\n # if a svr is selected -- item[0]\\n \\n \\n \\n else:\\n print \\\"cannot allocate paths\\\"\\n \\n #print slink_dict \\n return selected_dict, slink_dict\",\n \"def compute_cost(AL, Y):\\n pass\",\n \"def total_cost(path: Path) -> float:\\n\\t\\n\\tdistance = calc_total_dist(path)\\n\\tavg_speed = calc_average_speed(path)\\n\\t\\n\\t# Speed is less important, but gets a huge multiplier, because speed and\\n\\t# \\tdistance are in different units. Speed requires a high ratio to have\\n\\t# \\tsimilar amounts of variation.\\n\\tSPEED_DISTANCE_COST_RATIO = 7865.099\\n\\t\\n\\treturn (\\n\\t\\t(distance * 1) +\\n\\t\\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\\n\\t)\",\n \"def loadPaths(self):\\n for ij in self.link:\\n self.link[ij].flow = 0\\n for p in self.path:\\n for ij in self.path[p].links:\\n self.link[ij].flow += self.path[p].flow\\n for ij in self.link:\\n self.link[ij].updateCost()\\n for p in self.path:\\n self.path[p].updateCost()\",\n \"def contract(self, cycle):\\n # create a new id to represent the cycle in the resulting graph.\\n new_id = Digraph.new_node_id\\n Digraph.new_node_id += 1\\n\\n # we store links that cross into and out of the cycle in these maps. the\\n # to_cycle map contains links reaching into the cycle, and is thus a map\\n # from each target node in the cycle to a list of source nodes that\\n # reach that target from outside the cycle. the from_cycle map contains\\n # links going out from the cycle, and is thus a map from each source\\n # node in the cycle to a list of target nodes outside the cycle.\\n to_cycle = collections.defaultdict(list)\\n from_cycle = collections.defaultdict(list)\\n\\n scores = {}\\n labels = {}\\n succs = collections.defaultdict(list)\\n for source, target in self.iteredges():\\n if source in cycle:\\n if target not in cycle:\\n from_cycle[target].append(source)\\n elif target in cycle:\\n # we know source is not in cycle from above.\\n to_cycle[source].append(target)\\n else:\\n succs[source].append(target)\\n succs[target]\\n scores[source, target] = self.get_score(source, target)\\n labels[source, target] = self.get_label(source, target)\\n\\n old_edges = collections.defaultdict(list)\\n\\n # for each target in our graph that's reachable from the cycle, add an\\n # edge from our new node to that target, with an appropriate score.\\n for target, sources in from_cycle.items():\\n succs[new_id].append(target)\\n max_score = -1e100\\n max_source = None\\n for s in sources:\\n score = self.get_score(s, target)\\n if score > max_score:\\n max_score = score\\n max_source = s\\n old_edges[max_source].append(target)\\n scores[new_id, target] = max_score\\n labels[new_id, target] = self.get_label(max_source, target)\\n\\n # before we handle the to_cycle map, we need to build some convenience\\n # information for the cycle -- total score, and predecessor edges.\\n pred = {}\\n cycle_score = 0\\n for s, t in cycle.iteredges():\\n pred[t] = s\\n cycle_score += self.get_score(s, t)\\n\\n # for each source in our graph that reaches into the cycle, add an edge\\n # from the source to our new node, with an appropriate edge score.\\n for source, targets in to_cycle.items():\\n succs[source].append(new_id)\\n max_score = -1e100\\n max_target = None\\n for t in targets:\\n score = self.get_score(source, t) - self.get_score(pred[t], t)\\n if score > max_score:\\n max_score = score\\n max_target = t\\n old_edges[source].append(max_target)\\n scores[source, new_id] = cycle_score + max_score\\n labels[source, new_id] = self.get_label(source, max_target)\\n\\n return (\\n new_id,\\n old_edges,\\n Digraph(\\n succs, lambda s, t: scores[s, t], lambda s, t: labels[s, t]\\n ),\\n )\",\n \"def __init__(self, graphs: List[Graph], graph_ids: Set[str]) -> None:\\n self.graph_ids = graph_ids\\n\\n # count of link given source & object\\n self.c_l_given_so: Dict[Tuple[bytes, bytes], Dict[bytes, int]] = {}\\n # count of nodes\\n self.c_n: Dict[bytes, int] = {}\\n # count of link given source\\n self.c_l_given_s: Dict[bytes, Dict[bytes, int]] = {}\\n\\n # COMPUTE counting\\n for g in graphs:\\n for link in g.iter_links():\\n s = link.get_source_node().label\\n o = link.get_target_node().label\\n\\n # COMPUTE c_l_given_s\\n if s not in self.c_l_given_s:\\n self.c_l_given_s[s] = {}\\n if link.label not in self.c_l_given_s[s]:\\n self.c_l_given_s[s][link.label] = 0\\n self.c_l_given_s[s][link.label] += 1\\n\\n # COMPUTE c_l_given_so\\n if link.get_target_node().is_data_node():\\n # no need to estimate this prob, since it will be result from semantic labeling\\n pass\\n else:\\n if (s, o) not in self.c_l_given_so:\\n self.c_l_given_so[(s, o)] = {}\\n if link.label not in self.c_l_given_so[(s, o)]:\\n self.c_l_given_so[(s, o)][link.label] = 0\\n self.c_l_given_so[(s, o)][link.label] += 1\\n\\n # COMPUTE c_n\\n for n in g.iter_nodes():\\n if n.label not in self.c_n:\\n self.c_n[n.label] = 0\\n self.c_n[n.label] += 1\\n\\n # cached\\n self.p_critical_l_given_s = {}\\n for s, counts in self.c_l_given_s.items():\\n l, c_l = max(counts.items(), key=lambda x: x[1])\\n self.p_critical_l_given_s[s] = (l, c_l / self.c_n[s])\",\n \"def _distance_2_link_quality(self, distance):\\n\\n raise NotImplementedError\",\n \"def calculate_q(module, degree_table, edges, num_of_edges):\\n res = 0.0\\n for node_1 in module:\\n for node_2 in module:\\n pair = tuple(sorted([node_1, node_2]))\\n a_i_j = 1.0 if pair in edges else 0.0\\n res += (a_i_j - ((degree_table[node_1] * degree_table[node_2]) / (2.0 * num_of_edges)))\\n\\n return res\",\n \"def test_max_flow(default_plugin_resolver):\\n dpr = default_plugin_resolver\\n source_node = 0\\n target_node = 7\\n ebunch = [\\n (0, 1, 9),\\n (0, 3, 10),\\n (1, 4, 3),\\n (2, 7, 6),\\n (3, 1, 2),\\n (3, 4, 8),\\n (4, 5, 7),\\n (4, 2, 4),\\n (5, 2, 5),\\n (5, 6, 1),\\n (6, 2, 11),\\n ]\\n nx_graph = nx.DiGraph()\\n nx_graph.add_weighted_edges_from(ebunch)\\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\\\"weight\\\")\\n\\n expected_flow_value = 6\\n bottleneck_nodes = {2, 4}\\n expected_nodemap = {2: 6, 4: 6}\\n\\n mv = MultiVerify(dpr)\\n results = mv.compute(\\\"flow.max_flow\\\", graph, source_node, target_node)\\n\\n # Compare flow rate\\n results[0].assert_equal(expected_flow_value)\\n\\n # Normalize actual flow to prepare to transform\\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\\n\\n # Compare sum of out edges for bottleneck nodes\\n out_edges = mv.transform(\\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n )\\n out_bottleneck = mv.transform(\\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\\n )\\n out_bottleneck.assert_equal(expected_nodemap)\\n\\n # Compare sum of in edges for bottleneck nodes\\n in_edges = mv.transform(\\n \\\"util.graph.aggregate_edges.core_networkx\\\",\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n in_edges=True,\\n out_edges=False,\\n )\\n in_bottleneck = mv.transform(\\n \\\"util.nodemap.select.core_python\\\", in_edges, bottleneck_nodes\\n )\\n in_bottleneck.assert_equal(expected_nodemap)\",\n \"def search_optimal_capacities(network, step_size, tolerance, filename):\\r\\n ## Initialization\\r\\n # Initialize the value of total flow over the network\\r\\n totalflow = max(network.lb_totalflow, step_size)\\r\\n \\r\\n # An auxiliary threshold of the total flow computed based on the capacity upper bounds, used in Line 4 of Algorithm 3.\\r\\n aux_bound = 1 - np.exp(network.beta - network.b + network.phi/network.u)\\r\\n \\r\\n \\r\\n # Initialize the bounds for flow over each route\\r\\n ub_flow = np.zeros(network.num_routes)\\r\\n lb_flow = np.zeros(network.num_routes)\\r\\n \\r\\n # Initialize the optimal solution over the network\\r\\n opt_socialwelfare = np.array([])\\r\\n opt_totalflow = 0\\r\\n opt_flows = np.array([])\\r\\n opt_capacity = np.zeros(network.num_routes)\\r\\n \\r\\n\\r\\n# # For debugging only\\r\\n# lower_bound = np.zeros(network.num_routes)\\r\\n# upper_bound = np.zeros(network.num_routes)\\r\\n# count = 0\\r\\n \\r\\n # Try to plot out the (totalflow, social_welfare) scatter plot\\r\\n z = []\\r\\n hz = []\\r\\n# # End of debugging\\r\\n\\r\\n ## Start the search\\r\\n while totalflow < 1 - tolerance:\\r\\n flag_nofeasibleflow = False\\r\\n \\r\\n # Compute the bounds for the flow.\\r\\n for i in range(network.num_routes):\\r\\n # Line 3-8 of Algorithm 3. Compute the upper bounds for the flow.\\r\\n if totalflow >= aux_bound[i]: \\r\\n x3_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 3) \\r\\n if x3_star > network.u[i]:\\r\\n flag_nofeasibleflow = True\\r\\n break \\r\\n else:\\r\\n ub_flow[i] = x3_star \\r\\n else: \\r\\n ub_flow[i] = 1 \\r\\n # Line 9-10 of Algorithm 3. Compute the lower bounds of the flow.\\r\\n x1_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 1)\\r\\n x2_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 2)\\r\\n lb_flow[i] = max(x1_star, x2_star)\\r\\n \\r\\n \\r\\n if not flag_nofeasibleflow:\\r\\n # Check feasibility of the flow based on the current total flow, lower and upper bounds of the flow\\r\\n if totalflow < np.sum(lb_flow) or totalflow > np.sum(ub_flow): \\r\\n totalflow += step_size \\r\\n\\r\\n# # For debugging only\\r\\n# print(\\\"\\\\nThe current total flow is: \\\" + str(totalflow))\\r\\n# print(\\\"\\\\nThe capacity upper bound when optimal flow is found: \\\")\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\nThe capacity lower bound when optimal flow is found: \\\")\\r\\n# print(lower_bound)\\r\\n# print(str(count))\\r\\n# # Eng of debugging\\r\\n# \\r\\n continue\\r\\n \\r\\n # The implementation of line 11 to 18. Find the optimal flow given the current value of z.\\r\\n [opt_obj, opt_x] = ip.max_sum_xlogx(network.num_routes, totalflow, lb_flow, ub_flow) \\r\\n \\r\\n \\r\\n # Line 18 of Algorithm 3. Compute the social welfare given the current z and optimal q(z).\\r\\n temp = opt_obj - totalflow * np.log(1-totalflow)\\r\\n\\r\\n ##### Testing: to plot out the function of h(z)\\r\\n z.append(totalflow)\\r\\n hz.append(temp)\\r\\n ##### End of Testing: to plot out the function of h(z)\\r\\n \\r\\n if opt_socialwelfare.size == 0 or temp > opt_socialwelfare:\\r\\n opt_socialwelfare = temp\\r\\n opt_flows = opt_x\\r\\n opt_totalflow = totalflow \\r\\n \\r\\n # For debugging only\\r\\n# print(\\\"\\\\nUpdate optimal flow\\\")\\r\\n# print(opt_x)\\r\\n# print(lb_flow)\\r\\n# print(ub_flow)\\r\\n# print(\\\"Total flow is \\\" + str(opt_totalflow)) \\r\\n \\r\\n # For debugging\\r\\n# np.copyto(lower_bound, lb_flow) \\r\\n# np.copyto(upper_bound, ub_flow) \\r\\n# count += 1\\r\\n# print(\\\"The lower and upper bounds are: \\\")\\r\\n# print(lb_flow)\\r\\n# print(lower_bound)\\r\\n# print(\\\"\\\\n\\\")\\r\\n# print(ub_flow)\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\n\\\")\\r\\n \\r\\n totalflow += step_size \\r\\n\\r\\n \\r\\n \\r\\n# # For debugging only\\r\\n# print(\\\"\\\\n----------------\\\\n Exiting the while loop.\\\")\\r\\n# print(\\\"\\\\nThe capacity upper bound when optimal flow is found: \\\")\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\nThe capacity lower bound when optimal flow is found: \\\")\\r\\n# print(lower_bound)\\r\\n# print(str(count)) \\r\\n# # Eng of debugging\\r\\n \\r\\n # Line 20 of ALgorithm 3\\r\\n if opt_flows.size > 0:\\r\\n network.update_flow(opt_flows) \\r\\n for i in range(network.num_routes): \\r\\n network.compute_capacity(opt_totalflow, i)\\r\\n opt_capacity[i] = network.capacity[i]\\r\\n print(\\\"\\\\n--------------\\\\nThe optimal flow is: \\\")\\r\\n print(opt_flows)\\r\\n print(\\\"\\\\n--------------\\\\nThe optimal parking capacity is: \\\")\\r\\n print(opt_capacity) \\r\\n print(\\\"\\\\n--------------\\\\nThe optimal total flow is \\\" + str(opt_totalflow))\\r\\n print(\\\"\\\\n--------------\\\\nThe maximum social welfare is \\\" + str(opt_socialwelfare) +\\\".\\\")\\r\\n \\r\\n \\r\\n ##### Testing: to plot out the function of h(z)\\r\\n #plt.scatter(z, hz, c='r', marker='r')\\r\\n plt.plot(z, hz, '-', linewidth=0.5)\\r\\n #plt.xlim(0.5, 1)\\r\\n plt.savefig(filename + '.png', bbox_inches='tight')\\r\\n ##### End of Testing: to plot out the function of h(z)\\r\\n \\r\\n \\r\\n \\r\\n# # For debugging\\r\\n# temp1 = np.zeros(network.num_routes)\\r\\n# temp2 = np.zeros(network.num_routes)\\r\\n# temp3 = np.zeros(network.num_routes)\\r\\n# for i in range(network.num_routes): \\r\\n# temp1[i] = zeta(network, i, opt_flows[i], opt_totalflow, 1)\\r\\n# temp2[i] = zeta(network, i, opt_flows[i], opt_totalflow, 2)\\r\\n# temp3[i] = zeta(network, i, opt_flows[i], opt_totalflow, 3)\\r\\n# print(\\\"The function value of zeta at the optimal flow: \\\")\\r\\n# print(temp1)\\r\\n# print(temp2)\\r\\n# print(temp3)\\r\\n# \\r\\n# # For debugging\\r\\n# print(\\\"\\\\nThe capacity upper bound when optimal flow is found: \\\")\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\nThe capacity lower bound when optimal flow is found: \\\")\\r\\n# print(lower_bound)\\r\\n# print(str(count))\\r\\n# # End of debugging\\r\\n \\r\\n return opt_flows, opt_capacity, opt_socialwelfare \\r\\n else:\\r\\n print(\\\"\\\\nNo optimal solution is found!\\\")\\r\\n return np.array([]), opt_capacity, opt_socialwelfare\",\n \"def total_weight(network):\\n weight = 0\\n\\n for node_connections in network:\\n for edge in node_connections:\\n if edge is not None:\\n weight += edge\\n\\n return weight // 2\",\n \"def astar_heuristic(n1, n2):\\n average_speed = 70\\n return edge_weight(n1, n2, 70)\",\n \"def net_flow(G, \\n inplace = False,\\n new_weight_name = None,\\n verbose = False):\\n\\n if new_weight_name is None:\\n new_weight_name = 'net_flow'\\n # TO-DO: WHAT HAPPENS WHEN WEIGHT NAME ALREADY EXISTS?\\n\\n node_label = dict(enumerate(G.nodes))\\n if not nx.is_connected(G):\\n raise DisconnectedGraphError\\n\\n # The exact sparse representation is irrelevant from a speed\\n # perspective, but differs in the implementation below.\\n A_coo = nx.to_scipy_sparse_array(G, format = 'coo')\\n\\n # Inverted Laplacian is going to be dense anyways.\\n # So there is no harm in working with dense matrices here.\\n L = -A_coo.toarray()\\n np.fill_diagonal(L, A_coo.sum(axis = 1))\\n\\n # Removing first (or any other) row and corresponding column from the\\n # Laplacian matrix leads to an invertible matrix if the graph is connected.\\n # The invers of this matrix can be interpreted as a 'potential' matrix\\n # that leads to voltage vectors by taking differences.\\n C = np.zeros(L.shape)\\n C[1:,1:] = np.linalg.inv(L[1:,1:])\\n\\n # Calculating the current flow directly involves taking all pairwise distances\\n # twice: We need to take all pairwise distances for each source-target pair\\n # (leading to a voltage vector V_st), and we need to do that for all source-target\\n # pairs (leading to the current flow matrix). This is computationally expensive.\\n # We can reduce the complexity by realizing that not all values need to be calculated\\n # and that some computations can be reused. This idea is based on an algorithm from\\n # Brandes and Fleischer.\\n\\n # The implementation here is optimized for COO sparse format, converting\\n # CSR to COO is cheap.\\n\\n row_idx, col_idx = map(np.array, zip(*((i,j)\\n for (i,j) in zip(A_coo.row, A_coo.col) if i<j)))\\n\\n edge_values = _current_flow_loop(C, row_idx, col_idx )\\n edge_dict = {(node_label[i], node_label[j]) : edge_values\\n for (i,j,edge_values) in zip(row_idx, col_idx, edge_values)}\\n\\n if inplace:\\n nx.set_edge_attributes(G, \\n values = edge_dict, \\n name = new_weight_name)\\n else:\\n return edge_dict\",\n \"def linkUpdate(self, time): \\r\\n cellTransitionFlow = list()\\r\\n # deal with intermediate cells\\r\\n for c in range(0, self.numCells-1):\\r\\n cellSendingFlow = self.cells[c].calculateSendingFlow()\\r\\n cellReceivingFlow = self.cells[c+1].calculateReceivingFlow()\\r\\n cellTransitionFlow.append(min(cellSendingFlow, cellReceivingFlow))\\r\\n for c in range(0, self.numCells-1):\\r\\n self.cells[c].removeVehicles(cellTransitionFlow[c])\\r\\n self.cells[c+1].addVehicles(cellTransitionFlow[c])\\r\\n self.flowIn(time)\\r\\n self.flowOut(time)\\r\\n return None\",\n \"def compute_network_load(env: ControlledRandomWalk) -> float:\\n rho = cvx.Variable()\\n zeta = cvx.Variable((env.num_activities, 1))\\n objective = cvx.Minimize(rho)\\n constraints = [\\n env.job_generator.buffer_processing_matrix * zeta + env.job_generator.demand_rate\\n == np.zeros((env.num_buffers, 1)),\\n env.constituency_matrix * zeta <= rho * np.ones((env.num_resources, 1)),\\n zeta >= np.zeros((env.num_activities, 1))\\n ]\\n prob = cvx.Problem(objective, constraints)\\n network_load = prob.solve(solver=cvx.SCS, eps=1e-7)\\n return network_load\",\n \"def calculate_attribution(self, model_instance, input_graph):\\n self.device = \\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n self.model_instance = model_instance\\n \\n tmp_graph = copy.deepcopy(input_graph).to(self.device)\\n node_feats = tmp_graph.ndata.pop('h').to(self.device)\\n \\n self.model_instance.to(self.device)\\n if self.att_type == 'integrated_gradients':\\n att_function = IntegratedGradients(self._model_forward)\\n self.attr_weights = att_function.attribute(\\n node_feats, \\n additional_forward_args=tmp_graph, \\n internal_batch_size=len(node_feats),\\n n_steps = 100)\\n elif self.att_type == 'input_gradient':\\n att_function = InputXGradient(self._model_forward)\\n self.attr_weights = att_function.attribute(\\n node_feats, \\n additional_forward_args=tmp_graph,)\\n elif self.att_type == 'attention':\\n edge_feats = tmp_graph.edata.pop('e').to('cuda')\\n _, self.att_weights = self.model_instance(\\n tmp_graph, node_feats, edge_feats, get_node_weight=True)\\n return self.att_weights[0].to('cpu').detach().numpy()\\n \\n self.attributes = np.multiply(\\n node_feats.to('cpu').numpy(), self.attr_weights.to('cpu').numpy())\\n self.attributes[self.attributes < 0] = 0\\n \\n self.node_weights = self.normalize_node_weights(self.attributes.sum(axis=1))\",\n \"def find_allocation_for_graph(self,consumption_graph : ConsumptionGraph):\\n mat = cvxpy.Variable((self.num_of_agents, self.num_of_items))\\n constraints = []\\n # every var >=0 and if there is no edge the var is zero\\n # and proportional condition\\n for i in range(self.num_of_agents):\\n count = 0\\n for j in range(self.num_of_items):\\n if (consumption_graph.get_graph()[i][j] == 0):\\n constraints.append(mat[i][j] == 0)\\n else:\\n constraints.append(mat[i][j] >= 0)\\n count += mat[i][j] * self.valuation[i][j]\\n constraints.append(count >= sum(self.valuation[i]) / len(self.valuation))\\n # the sum of each column is 1 (the property on each object is 100%)\\n for i in range(self.num_of_items):\\n constraints.append(sum(mat[:, i]) == 1)\\n \\\"\\\"\\\"\\n # the proportional condition\\n count = 0\\n for i in range(len(consumption_graph)):\\n count = 0\\n for j in range(len(consumption_graph[i])):\\n count += mat[i][j] * matv[i][j]\\n constraints.append(count >= sum(matv[i]) / len(matv[i]))\\n \\\"\\\"\\\"\\n objective = cvxpy.Maximize(1)\\n prob = cvxpy.Problem(objective, constraints)\\n prob.solve() # Returns the optimal value.\\n if not (prob.status == 'infeasible'):\\n alloc = Allocation(mat.value)\\n alloc.round()\\n if(alloc.num_of_shering() < self.min_sharing_number):\\n self.min_sharing_number = alloc.num_of_shering()\\n self.min_sharing_allocation = alloc.get_allocation()\\n # only for doctet:\\n return (mat.value)\",\n \"def two_user_route_statistics(i,j, source_data, destination_data, source_destination_data, delta=1.2):\\n\\toccupancy_ratio = 0.0\\n\\tminimum_distance_so_far = 0.0\\n\\tcommon_travel_distance = 0.0\\n\\n\\ttry:\\n\\t\\tif source_destination_data[j][i] + source_data[i][j] <= 1.2*source_destination_data[i][i] and source_destination_data[j][i] + destination_data[i][j] <= 1.2*source_destination_data[j][j]:\\n\\t\\t\\tfirst = ((source_destination_data[j][i] + source_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\\n\\t\\t\\tsecond = ((source_destination_data[j][i] + destination_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\\n\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\t\\t\\tcommon_travel_distance = source_destination_data[j][i]\\n\\t\\t\\tminimum_distance_so_far = source_data[i][j] + source_destination_data[j][i] + destination_data[i][j]\\n\\n\\t\\tif source_destination_data[i][j] + destination_data[j][i] <= 1.2*source_destination_data[i][i] and source_destination_data[i][j] + source_data[j][i] <= 1.2*source_destination_data[j][j]:\\n\\t\\t\\tfirst = ((source_destination_data[i][j] + destination_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\\t\\t\\n\\t\\t\\tsecond = ((source_destination_data[i][j] + source_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\\n\\t\\t\\ttotal_distance = source_data[j][i] + source_destination_data[i][j] + destination_data[j][i]\\n\\n\\t\\t\\tif total_distance < minimum_distance_so_far:\\n\\t\\t\\t\\tminimum_distance_so_far = total_distance\\n\\t\\t\\t\\tcommon_travel_distance = source_destination_data[i][j]\\n\\t\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\n\\t\\tif source_data[i][j]+source_destination_data[j][j]+destination_data[j][i] <= 1.2*source_destination_data[i][i]:\\n\\t\\t\\tfirst = (1)\\n\\t\\t\\tsecond = (source_destination_data[j][j]/(source_data[i][j]+source_destination_data[j][j]+destination_data[j][i]))\\n\\n\\t\\t\\ttotal_distance = source_data[i][j] + source_destination_data[j][j] + destination_data[j][i]\\n\\n\\t\\t\\tif total_distance < minimum_distance_so_far:\\n\\t\\t\\t\\tminimum_distance_so_far = total_distance\\n\\t\\t\\t\\tcommon_travel_distance = source_destination_data[j][j]\\n\\t\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\n\\t\\tif source_data[j][i]+source_destination_data[i][i]+destination_data[i][j] <= 1.2*source_destination_data[j][j]:\\n\\t\\t\\tfirst = (source_destination_data[i][i]/(source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]))\\n\\t\\t\\tsecond = (1)\\n\\n\\t\\t\\ttotal_distance = source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]\\n\\n\\t\\t\\tif total_distance < minimum_distance_so_far:\\n\\t\\t\\t\\tminimum_distance_so_far = total_distance\\n\\t\\t\\t\\tcommon_travel_distance = source_destination_data[i][i]\\n\\t\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\n\\texcept Exception as e:\\n\\t\\toccupancy_ratio = 1.0\\n\\t\\tminimum_distance_so_far = 0.0\\n\\t\\tcommon_travel_distance = 0.0\\n\\n\\n\\treturn occupancy_ratio, common_travel_distance, minimum_distance_so_far\",\n \"def route_cost(self, route):\\n total_weight = 0\\n c = 0\\n start = route[0]\\n for end in route[1:]:\\n y = float(self.stars[start][end]['weight']) - c\\n t = total_weight + y\\n c = (t - total_weight) - y\\n\\n total_weight = t\\n\\n start = end\\n return total_weight\",\n \"def _compute_longest_path_cut(self, src_uid, dst_uid):\\n # NOTE: at the time being the reason why it was chosen to include edges\\n # that belong to any path to the returned list, is unclear to me.\\n to_visit_uids = [dst_uid]\\n node_costs = {}\\n node_succs = {}\\n subgraph_edge_uids = []\\n subgraph_node_uids = [src_uid]\\n dsp = 0\\n\\n if (src_uid == dst_uid): # NOTE: deals with single-block graphs\\n node = self._nodes[src_uid]\\n return node.get_cost(), [src_uid], [], []\\n\\n # NOTE: the generated block graph might contain dead ends, thus\\n # visited_uids must be pre-computed\\n visited_uids = copy.deepcopy(self._nodes.keys())\\n lvisited_uids = []\\n while len(to_visit_uids) > 0:\\n cur_uid = to_visit_uids[0]\\n cur_node = self._nodes[cur_uid]\\n\\n if cur_uid in visited_uids:\\n visited_uids.remove(cur_uid)\\n\\n for pred_uid in cur_node.get_predecessors():\\n if pred_uid not in to_visit_uids and pred_uid not in lvisited_uids:\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids = to_visit_uids[1:]\\n lvisited_uids.append(cur_uid)\\n\\n to_visit_uids = [dst_uid]\\n\\n # reverse graph exploration\\n while 0 < len(to_visit_uids):\\n assert(dsp < len(to_visit_uids))\\t# dead ends or loops\\n\\n cur_uid = to_visit_uids[dsp]\\n cur_node = self._nodes[cur_uid]\\n\\n assert(cur_uid != src_uid)\\n assert(cur_uid not in visited_uids)\\t# loop!\\n\\n # skip node for which there is still some unexplored successor\\n skip_uid = False\\n for succ_uid in cur_node.get_successors():\\n if not succ_uid in visited_uids:\\n skip_uid = True\\n\\n if skip_uid:\\n dsp += 1\\n continue\\n else:\\n dsp = 0\\n\\n if cur_uid == dst_uid:\\n node_costs[cur_uid] = cur_node.get_cost()\\n\\n for pred_uid in cur_node.get_predecessors():\\n pred_node = self._nodes[pred_uid]\\n # get edge pred_uid ---> cur_uid\\n edge_uid = Edge.get_edge_uid(pred_uid, cur_uid)\\n edge = self._edges[edge_uid]\\n edge_cost = edge.get_cost()\\n if edge_uid not in subgraph_edge_uids:\\n subgraph_edge_uids.append(edge_uid)\\n\\n # update node distance\\n pred_node_cost = node_costs[cur_uid] + edge_cost + pred_node.get_cost()\\n if pred_uid not in node_costs or pred_node_cost > node_costs[pred_uid]:\\n node_costs[pred_uid] = pred_node_cost\\n node_succs[pred_uid] = cur_uid\\n\\n # update to_visit_uids, a node cannot be visited more than once\\n if (pred_uid != src_uid) and (pred_uid not in visited_uids) \\\\\\n and (pred_uid not in to_visit_uids):\\n to_visit_uids.append(pred_uid)\\n\\n to_visit_uids.remove(cur_uid)\\n visited_uids.append(cur_uid)\\n subgraph_node_uids.append(cur_uid)\\n\\n # construct path from src_node to dst_node\\n cur_uid = src_uid\\n maxpath_node_uids = [cur_uid]\\n while cur_uid != dst_uid:\\n cur_uid = node_succs[cur_uid]\\n cur_node = self._nodes[cur_uid]\\n if cur_uid not in maxpath_node_uids:\\n maxpath_node_uids.append(cur_uid)\\n else:\\n raise Exception(\\\"invalid input source code graph: loop detected\\\")\\n\\n max_cost = node_costs[src_uid]\\n return max_cost, maxpath_node_uids, subgraph_node_uids, subgraph_edge_uids\",\n \"def geo_dist_penalty(p_a, p_b): # created on Nov.3 2019\\n\\n # Offset is 0 for the 1st destination.\\n distance_matrix = Network.dist_mat\\n if p_a[0] != p_b[0] or p_a[-1] != p_b[-1]:\\n raise ValueError('Paths have different o or d.')\\n\\n # define the penalty in utility form for every two destinations. u_ik stands for the generalized cost of travel\\n o, d = p_a[0], p_a[-1]\\n\\n path_a, path_b = p_a[1:-1], p_b[1:-1] # excluding origin and destination\\n\\n path_node_check = []\\n for _path in [path_a, path_b]:\\n _new_path = []\\n for node in _path:\\n if node <= min(distance_matrix.shape) - 1:\\n _new_path.append(node)\\n path_node_check.append(_new_path)\\n path_a, path_b = path_node_check[0], path_node_check[1]\\n\\n # utility (negative) penalty evaluation\\n cost, a, b = 0, o, o # let a, b be origin\\n\\n # if exist empty path\\n if not path_a: # if observed path is empty\\n return cost\\n\\n while path_a and path_b:\\n a, b = path_a.pop(0), path_b.pop(0) # a, b correspond to the i_th node in path_a, path_b\\n cost += distance_matrix[a][b]\\n\\n if path_a: # length of path_a > path b\\n while path_a:\\n a = path_a.pop(0)\\n cost += distance_matrix[a][b]\\n else: # case when length of path_b > path a\\n while path_b:\\n b = path_b.pop(0)\\n cost += distance_matrix[a][b]\\n return cost\",\n \"def ClusteringTransitivity(graph):\\n transitivity = nx.transitivity(graph)\\n return transitivity\",\n \"def unit_costs(node1, node2):\\r\\n # insertion cost\\r\\n if node1 is None:\\r\\n return 1\\r\\n \\r\\n # deletion cost\\r\\n if node2 is None:\\r\\n return 0\\r\\n \\r\\n # substitution cost\\r\\n if node1.label != node2.label:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def ssf(n, N_max = 6, E_max = 4, time_total = 100 ):\\n\\n G = nx.DiGraph()\\n G.add_edge( 0, 1, time_stamp = 1)\\n\\n # List of existing nodes, with nodes repeated once for each adjacent edge\\n repeated_nodes = [0, 1]\\n\\n # compute discrete bins for nodes \\n DistNodes = _get_distribution( N_max, 0 )\\n # compute discrete bins for edges\\n DistLinks = _get_distribution( E_max, 1 )\\n \\n # Start adding the other n - 2 nodes.\\n N_current = time_current = 2\\n while N_current < n and time_current < time_total + 1:\\n # preferential attachment\\n N_current = _preferential_attachment( DistNodes, DistLinks, N_current,\\n time_total, time_current, n, repeated_nodes, G )\\n time_current += 1\\n \\n# print(time_current, N_current)\\n return G\",\n \"def getCost(dat, rateBlocks, key=\\\"Lintel\\\"):\\n\\n x = dat[:]\\n\\n if key == \\\"Lintel\\\":\\n edges = [s*100 for s in [5, 6, 7, 10,\\n 11, 12, 15, 16, 17, 20, 21, 22, 25]]\\n else:\\n edges = [s*100 for s in [10, 11, 12, 15, 16, 17, 20,\\n 21, 22, 25, 26, 27, 30, 31, 32, 35, 36, 37, 40]]\\n for i in edges:\\n if i >= x[2]:\\n x[2] = i\\n break\\n\\n vol = x[0]*600*x[2]/float(1000000000)\\n return vol*rateBlocks # *x[3]\",\n \"def test_global_efficiency_complete_graph(self):\\n for n in range(2, 10):\\n G = nx.complete_graph(n)\\n assert_equal(nx.global_efficiency(G), 1)\",\n \"def ford_fulkerson_algorithm(graph: np.ndarray, source: int, sink: int) -> np.ndarray:\\r\\n\\r\\n residual_graph = copy.deepcopy(graph)\\r\\n row = len(residual_graph)\\r\\n parent = [-1] * row\\r\\n max_flow = 0\\r\\n\\r\\n if source == sink or sink < 0 or source < 0 or source >= row or sink >= row:\\r\\n raise WrongInputException('Wrong input source/sink vertice(s)')\\r\\n\\r\\n while bfs(residual_graph, row, source, sink, parent):\\r\\n\\r\\n path_flow = float(\\\"Inf\\\")\\r\\n s = sink\\r\\n while s != source:\\r\\n path_flow = min(path_flow, residual_graph[parent[s]][s])\\r\\n s = parent[s]\\r\\n\\r\\n max_flow += path_flow\\r\\n\\r\\n v = sink\\r\\n while v != source:\\r\\n u = parent[v]\\r\\n residual_graph[u][v] -= path_flow\\r\\n residual_graph[v][u] += path_flow\\r\\n v = parent[v]\\r\\n print(\\\"Max flow: %d\\\" % max_flow)\\r\\n\\r\\n return residual_graph\",\n \"def total_sdram_requirements(self):\",\n \"def path_cost(self, c, state1, action, state2):\\n\\t\\treturn c + 1\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71253026","0.67660636","0.66454524","0.6522981","0.6514812","0.647129","0.6460042","0.6392503","0.6243768","0.62313336","0.6146924","0.61348885","0.6108246","0.5984085","0.5855024","0.58338815","0.5774301","0.57635266","0.5752603","0.57300353","0.5705901","0.566435","0.5619962","0.5604273","0.55933666","0.55786896","0.5571607","0.54947335","0.548535","0.5471225","0.54385906","0.54253906","0.5418493","0.54077107","0.5401337","0.5386984","0.53835124","0.5328413","0.5327113","0.53171194","0.5310602","0.5309819","0.5295381","0.52770483","0.527189","0.5260725","0.5257506","0.5253648","0.52525777","0.5243567","0.5230457","0.52288693","0.5216303","0.5208654","0.5206977","0.5200993","0.51972014","0.51597226","0.51502466","0.51406413","0.5135587","0.51344776","0.5131152","0.5114992","0.51135665","0.51113504","0.51091665","0.5103767","0.5092609","0.50912935","0.50912935","0.5089409","0.5087055","0.5077652","0.50691855","0.50488853","0.50483984","0.50431687","0.5042263","0.5040196","0.50386226","0.5038163","0.5033373","0.502514","0.502208","0.5015679","0.50155705","0.500842","0.4994289","0.49910522","0.49895644","0.49869922","0.4985307","0.49851182","0.497549","0.49731365","0.4971874","0.49695337","0.4968723","0.49642232"],"string":"[\n \"0.71253026\",\n \"0.67660636\",\n \"0.66454524\",\n \"0.6522981\",\n \"0.6514812\",\n \"0.647129\",\n \"0.6460042\",\n \"0.6392503\",\n \"0.6243768\",\n \"0.62313336\",\n \"0.6146924\",\n \"0.61348885\",\n \"0.6108246\",\n \"0.5984085\",\n \"0.5855024\",\n \"0.58338815\",\n \"0.5774301\",\n \"0.57635266\",\n \"0.5752603\",\n \"0.57300353\",\n \"0.5705901\",\n \"0.566435\",\n \"0.5619962\",\n \"0.5604273\",\n \"0.55933666\",\n \"0.55786896\",\n \"0.5571607\",\n \"0.54947335\",\n \"0.548535\",\n \"0.5471225\",\n \"0.54385906\",\n \"0.54253906\",\n \"0.5418493\",\n \"0.54077107\",\n \"0.5401337\",\n \"0.5386984\",\n \"0.53835124\",\n \"0.5328413\",\n \"0.5327113\",\n \"0.53171194\",\n \"0.5310602\",\n \"0.5309819\",\n \"0.5295381\",\n \"0.52770483\",\n \"0.527189\",\n \"0.5260725\",\n \"0.5257506\",\n \"0.5253648\",\n \"0.52525777\",\n \"0.5243567\",\n \"0.5230457\",\n \"0.52288693\",\n \"0.5216303\",\n \"0.5208654\",\n \"0.5206977\",\n \"0.5200993\",\n \"0.51972014\",\n \"0.51597226\",\n \"0.51502466\",\n \"0.51406413\",\n \"0.5135587\",\n \"0.51344776\",\n \"0.5131152\",\n \"0.5114992\",\n \"0.51135665\",\n \"0.51113504\",\n \"0.51091665\",\n \"0.5103767\",\n \"0.5092609\",\n \"0.50912935\",\n \"0.50912935\",\n \"0.5089409\",\n \"0.5087055\",\n \"0.5077652\",\n \"0.50691855\",\n \"0.50488853\",\n \"0.50483984\",\n \"0.50431687\",\n \"0.5042263\",\n \"0.5040196\",\n \"0.50386226\",\n \"0.5038163\",\n \"0.5033373\",\n \"0.502514\",\n \"0.502208\",\n \"0.5015679\",\n \"0.50155705\",\n \"0.500842\",\n \"0.4994289\",\n \"0.49910522\",\n \"0.49895644\",\n \"0.49869922\",\n \"0.4985307\",\n \"0.49851182\",\n \"0.497549\",\n \"0.49731365\",\n \"0.4971874\",\n \"0.49695337\",\n \"0.4968723\",\n \"0.49642232\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77368706"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23589,"cells":{"query":{"kind":"string","value":"Calculates the overall utilisation of each link in a network given a routing choice and a set of demands. (NB utilisation in bandwidth, not relative to capacity)"},"document":{"kind":"string","value":"def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def calc_slow(self, demands: Demand, routing: Routing) -> float:\n edge_capacities = [e[2]['weight'] for e in\n sorted(self.graph.edges(data=True))]\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\n # Because utilisation compared to link width is what we care about here\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\n\n return np.max(ratio_capacities)","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\n # set availbandwidth to the maximal value\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\n if d.type == 'STATIC':\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\n # subtract the reserved link and internal (inside Infras) bandwidth\n if mode == self.MODE_ADD:\n for d in self.infras:\n for p in d.ports:\n for fr in p.flowrules:\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\n # Flowrules are cummulatively subtracted from the switching \n # capacity of the node.\n d.availres['bandwidth'] -= fr.bandwidth\n if d.availres['bandwidth'] < 0:\n raise RuntimeError(\"The node bandwidth of %s got below zero \"\n \"during available resource calculation!\" %\n d.id)\n # Get all the mapped paths of all SGHops from the NFFG\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\n for sg_hop_id, data in sg_map.iteritems():\n src, dst, flowclass, bandwidth, delay, path = data\n if bandwidth is not None:\n for link in path:\n link.availbandwidth -= bandwidth\n if link.availbandwidth < 0:\n raise RuntimeError(\n \"The link bandwidth of %s got below zero during\"\n \"available resource calculation!\" % link.id)","def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\n dtype=float)\n\n for commodity_idx in range(len(self.commodities)):\n utilisation = self.calc_demand(routing,\n demands[commodity_idx],\n commodity_idx)\n total_utilisation += utilisation\n\n return np.max(np.divide(total_utilisation, self.edge_capacities))","def compute_link_utilization_over_time(link_byte_counts):\n def find_matching_iface_stats(byte_count, source_id, destination_id):\n matching_stats = [d_i for d_i in byte_count\n if d_i[\"sourceSwitchId\"] == source_id and\n d_i[\"destinationSwitchId\"] == destination_id]\n if len(matching_stats) != 1:\n raise ValueError(\"Unexpected results in find_matching_iface_stats. \\\n Found %d matching iface_stats\" % len(matching_stats))\n return matching_stats[0]\n\n def compute_tx_rate(count_in_bytes):\n return (count_in_bytes * 8) / 10.0**7\n\n # First compute the delta between the iface_stats in time_period t_i and the iface_stats\n # in time period t_{i+1}.\n # tx_rate_t: (source_id x destination_id) -> link_utilization_in_time_period_t forall. t\n tx_rate_t = []\n for t_0, t_1 in zip(link_byte_counts, link_byte_counts[1:]):\n byte_count_delta_t = defaultdict(float)\n for iface_stats in t_0:\n source_id = iface_stats[\"sourceSwitchId\"]\n destination_id = iface_stats[\"destinationSwitchId\"]\n t_0_count = iface_stats[\"bytesSent\"] + iface_stats[\"bytesReceived\"]\n try:\n t_1_stats = find_matching_iface_stats(t_1, source_id, destination_id)\n t_1_count = t_1_stats[\"bytesSent\"] + t_1_stats[\"bytesReceived\"]\n except ValueError:\n t_1_count = t_0_count\n\n count_delta = t_1_count - t_0_count\n link_key = compute_link_key(source_id, \n destination_id)\n byte_count_delta_t[link_key] += count_delta\n\n tx_rate_t.append({the_link_key: compute_tx_rate(byte_count_t) \n for the_link_key, byte_count_t in byte_count_delta_t.items()})\n return tx_rate_t","def compute_path_metric(self, sw, path, util, time_now, local_contrib):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n # Use the last-learned-via-sync value for a link\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\n used1 = self.graph[u][v]['sync_learned'] + util\n used2 = self.graph[u][v]['used'] + util\n # ['used'] is a strict lower bound for ['sync_learned']\n if used1 > used2: \n used = used1\n logging.debug(\"CS [%s] using sync_learned value 1 [%f]\", str(self.name), used1)\n else:\n used = used2\n logging.debug(\"CS [%s] using sync_learned value 2 [%f]\", str(self.name), used2)\n else:\n logging.debug(\"CS [%s] using tracking value\", str(self.name))\n used = self.graph[u][v]['used'] + util\n\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def calc_cost(self):\n cost = 0\n for i,[source, sinks] in enumerate(self.nets):\n self.costs[i] = self.calc_half_perimeter(source, sinks)\n cost += self.costs[i]\n self.cost = cost\n return True","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def compute_path_metric(self, sw, path, util, time_now):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\n #only include extra-domain state when not stale (timestamp), 3) always exclude\n #extra-domain state when calculating the path metric? Here we do (1)\n used = self.graph[u][v]['used'] + util\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def _calculate_costs(self):\n cost = 0\n cost += self._cost_route_fine()\n cost += self._cost_petrol()\n cost += self._cost_wage()\n cost += self._cost_refueling()\n cost += self._cost_caught_by_police()\n cost += self._cost_vehicle_malfunction()\n return cost","def cost(route):\n cost = 0\n for li in route:\n if cost<li.get_cost():\n cost=li.get_cost()\n return cost","def calc_demand(self, routing: np.ndarray, demand: float,\n commodity_idx: int) -> np.ndarray:\n commodity = self.commodities[commodity_idx]\n node_flow = np.zeros(self.num_nodes)\n node_flow[commodity[0]] = demand\n\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\n for edge_idx, edge in enumerate(self.edges):\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\n\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\n\n num_steps = 0\n while True:\n change = np.multiply(split_matrix, node_flow)\n edge_utilisation += change\n node_flow = np.matmul(split_matrix, node_flow)\n if np.any(np.isnan(change)):\n print(\"is_nan :'(\")\n comparison = np.less(np.nan_to_num(change), self.min_delta)\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\n break\n num_steps += 1\n # if we take more than |E| steps we have cycles which is not good.\n # Therefore: end here with really bad reward, scaled by number of\n # cycles\n if num_steps > routing.shape[1]:\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\n edge_utilisation += np.multiply(remaining_flow, np.full(\n (self.num_nodes, self.num_nodes), demand))\n break\n\n return edge_utilisation","def rate(way):\n cost = 0\n for i in range(len(way)-1):\n cost += DISTANCES[way[i]][way[i+1]]\n return cost","def astar_heuristic(n1, n2):\n average_speed = 70\n return edge_weight(n1, n2, 70)","def route_cost(self, route):\n total_weight = 0\n c = 0\n start = route[0]\n for end in route[1:]:\n y = float(self.stars[start][end]['weight']) - c\n t = total_weight + y\n c = (t - total_weight) - y\n\n total_weight = t\n\n start = end\n return total_weight","def cost(self, route: List[int]) -> float:\n raise NotImplementedError","def build_links_capacity(self):\n\n links_capacity = {}\n # Iterates all the edges in the topology formed by switches\n for src, dst in self.topo.keep_only_p4switches().edges:\n bw = self.topo.edges[(src, dst)]['bw']\n # add both directions\n links_capacity[(src, dst)] = bw\n links_capacity[(dst, src)] = bw\n\n return links_capacity","def caculate_network_statistics(self):\n divide_factor_sum = 0 \n for key in self.stars.keys():\n star = self.stars[key]\n if star.nb_num == 0 :\n self.standalone_star_num += 1 \n\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\n if star.spec_num < star.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + star.id + \" \" + str(star.spec_num) + \"is less than\" + str(star.shared_spec_num))\n if star.spec_num > star.shared_spec_num:\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\n\n divide_factor_sum = 0 \n for key in self.starlets.keys():\n starlet = self.starlets[key]\n if starlet.nb_num == 0 :\n self.standalone_starlet_num += 1 \n\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\n divide_factor_sum += divide_factor\n divide_factor_int = round(divide_factor)\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\n if starlet.spec_num < starlet.shared_spec_num:\n print(\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\")\n print(\"with star \" + starlet.id + \" \" + str(starlet.spec_num) + \"is less than\" + str(starlet.shared_spec_num))\n if starlet.spec_num > starlet.shared_spec_num:\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def search_optimal_capacities(network, step_size, tolerance, filename):\r\n ## Initialization\r\n # Initialize the value of total flow over the network\r\n totalflow = max(network.lb_totalflow, step_size)\r\n \r\n # An auxiliary threshold of the total flow computed based on the capacity upper bounds, used in Line 4 of Algorithm 3.\r\n aux_bound = 1 - np.exp(network.beta - network.b + network.phi/network.u)\r\n \r\n \r\n # Initialize the bounds for flow over each route\r\n ub_flow = np.zeros(network.num_routes)\r\n lb_flow = np.zeros(network.num_routes)\r\n \r\n # Initialize the optimal solution over the network\r\n opt_socialwelfare = np.array([])\r\n opt_totalflow = 0\r\n opt_flows = np.array([])\r\n opt_capacity = np.zeros(network.num_routes)\r\n \r\n\r\n# # For debugging only\r\n# lower_bound = np.zeros(network.num_routes)\r\n# upper_bound = np.zeros(network.num_routes)\r\n# count = 0\r\n \r\n # Try to plot out the (totalflow, social_welfare) scatter plot\r\n z = []\r\n hz = []\r\n# # End of debugging\r\n\r\n ## Start the search\r\n while totalflow < 1 - tolerance:\r\n flag_nofeasibleflow = False\r\n \r\n # Compute the bounds for the flow.\r\n for i in range(network.num_routes):\r\n # Line 3-8 of Algorithm 3. Compute the upper bounds for the flow.\r\n if totalflow >= aux_bound[i]: \r\n x3_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 3) \r\n if x3_star > network.u[i]:\r\n flag_nofeasibleflow = True\r\n break \r\n else:\r\n ub_flow[i] = x3_star \r\n else: \r\n ub_flow[i] = 1 \r\n # Line 9-10 of Algorithm 3. Compute the lower bounds of the flow.\r\n x1_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 1)\r\n x2_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 2)\r\n lb_flow[i] = max(x1_star, x2_star)\r\n \r\n \r\n if not flag_nofeasibleflow:\r\n # Check feasibility of the flow based on the current total flow, lower and upper bounds of the flow\r\n if totalflow < np.sum(lb_flow) or totalflow > np.sum(ub_flow): \r\n totalflow += step_size \r\n\r\n# # For debugging only\r\n# print(\"\\nThe current total flow is: \" + str(totalflow))\r\n# print(\"\\nThe capacity upper bound when optimal flow is found: \")\r\n# print(upper_bound)\r\n# print(\"\\nThe capacity lower bound when optimal flow is found: \")\r\n# print(lower_bound)\r\n# print(str(count))\r\n# # Eng of debugging\r\n# \r\n continue\r\n \r\n # The implementation of line 11 to 18. Find the optimal flow given the current value of z.\r\n [opt_obj, opt_x] = ip.max_sum_xlogx(network.num_routes, totalflow, lb_flow, ub_flow) \r\n \r\n \r\n # Line 18 of Algorithm 3. Compute the social welfare given the current z and optimal q(z).\r\n temp = opt_obj - totalflow * np.log(1-totalflow)\r\n\r\n ##### Testing: to plot out the function of h(z)\r\n z.append(totalflow)\r\n hz.append(temp)\r\n ##### End of Testing: to plot out the function of h(z)\r\n \r\n if opt_socialwelfare.size == 0 or temp > opt_socialwelfare:\r\n opt_socialwelfare = temp\r\n opt_flows = opt_x\r\n opt_totalflow = totalflow \r\n \r\n # For debugging only\r\n# print(\"\\nUpdate optimal flow\")\r\n# print(opt_x)\r\n# print(lb_flow)\r\n# print(ub_flow)\r\n# print(\"Total flow is \" + str(opt_totalflow)) \r\n \r\n # For debugging\r\n# np.copyto(lower_bound, lb_flow) \r\n# np.copyto(upper_bound, ub_flow) \r\n# count += 1\r\n# print(\"The lower and upper bounds are: \")\r\n# print(lb_flow)\r\n# print(lower_bound)\r\n# print(\"\\n\")\r\n# print(ub_flow)\r\n# print(upper_bound)\r\n# print(\"\\n\")\r\n \r\n totalflow += step_size \r\n\r\n \r\n \r\n# # For debugging only\r\n# print(\"\\n----------------\\n Exiting the while loop.\")\r\n# print(\"\\nThe capacity upper bound when optimal flow is found: \")\r\n# print(upper_bound)\r\n# print(\"\\nThe capacity lower bound when optimal flow is found: \")\r\n# print(lower_bound)\r\n# print(str(count)) \r\n# # Eng of debugging\r\n \r\n # Line 20 of ALgorithm 3\r\n if opt_flows.size > 0:\r\n network.update_flow(opt_flows) \r\n for i in range(network.num_routes): \r\n network.compute_capacity(opt_totalflow, i)\r\n opt_capacity[i] = network.capacity[i]\r\n print(\"\\n--------------\\nThe optimal flow is: \")\r\n print(opt_flows)\r\n print(\"\\n--------------\\nThe optimal parking capacity is: \")\r\n print(opt_capacity) \r\n print(\"\\n--------------\\nThe optimal total flow is \" + str(opt_totalflow))\r\n print(\"\\n--------------\\nThe maximum social welfare is \" + str(opt_socialwelfare) +\".\")\r\n \r\n \r\n ##### Testing: to plot out the function of h(z)\r\n #plt.scatter(z, hz, c='r', marker='r')\r\n plt.plot(z, hz, '-', linewidth=0.5)\r\n #plt.xlim(0.5, 1)\r\n plt.savefig(filename + '.png', bbox_inches='tight')\r\n ##### End of Testing: to plot out the function of h(z)\r\n \r\n \r\n \r\n# # For debugging\r\n# temp1 = np.zeros(network.num_routes)\r\n# temp2 = np.zeros(network.num_routes)\r\n# temp3 = np.zeros(network.num_routes)\r\n# for i in range(network.num_routes): \r\n# temp1[i] = zeta(network, i, opt_flows[i], opt_totalflow, 1)\r\n# temp2[i] = zeta(network, i, opt_flows[i], opt_totalflow, 2)\r\n# temp3[i] = zeta(network, i, opt_flows[i], opt_totalflow, 3)\r\n# print(\"The function value of zeta at the optimal flow: \")\r\n# print(temp1)\r\n# print(temp2)\r\n# print(temp3)\r\n# \r\n# # For debugging\r\n# print(\"\\nThe capacity upper bound when optimal flow is found: \")\r\n# print(upper_bound)\r\n# print(\"\\nThe capacity lower bound when optimal flow is found: \")\r\n# print(lower_bound)\r\n# print(str(count))\r\n# # End of debugging\r\n \r\n return opt_flows, opt_capacity, opt_socialwelfare \r\n else:\r\n print(\"\\nNo optimal solution is found!\")\r\n return np.array([]), opt_capacity, opt_socialwelfare","def combined_costs(matrix_MSLL_IO):\r\n return","def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\n #print slink_dict\n #print \"FIND\"\n failed_dict = model.failed_dict\n #print failed_dict, limit\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n bw_matrix = model.cost_dict['bw']\n #cpu_vector = model.cost_dict['cpu']\n selected_dict = {}\n \n # get aggregated residual bw for all substrate nodes, and store it as a list\n snode_bw_list = total_bw(bw_matrix)\n \n # get total capacity and used bw for each snode\n node_port_list, used_bw_list = total_port(model)\n #vnet_set = model.vnets\n sorted_vn = sort_vnet(model)\n\n #for vnet in vnet_set:\n if w_m[2] >= 10*w_m[1]:\n threshold = 0.8\n else:\n threshold = 0.8\n snode_traffic = {}\n for vn_traffic in sorted_vn:\n vnet = vn_traffic[0]\n failed_vr = failed_dict[vnet.vnet_id]\n if failed_vr != -1: \n # this node is failed\n standby_list = vnet.get_standby_ids()\n standby_cost = {}\n for s_vr in standby_list:\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\n failed_node = vnet.vnodes[failed_vr]\n vneighbors = failed_node.vneighbors\n dist_k = 0\n rtt_k = 0\n for k in vneighbors:\n dist_k += float(dist_matrix[s_vr][k + 1])\n rtt_k += float(rtt_matrix[s_vr][k + 1])\n\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\n w_b[1] * rtt_k\n res_cost = snode_bw_list[s_vr]\n req_bw = sum(failed_node.neighbor_traffic.values())\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\n standby_cost[s_vr] = total\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\n #print \"SORTED\", sorted_x\n \n for item in sorted_x:\n if item[0] not in snode_traffic:\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n else:\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n #print utilization\n # Link-Path selsection add-on\n path_alloc = 1\n for k in vneighbors:\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\n item[0] + 1, k + 1)\n demand = demand_dict[demand_id]['capacity']\n find, path = find_path(demand_path, demand_id, \n slink_dict, demand) \n if find == 0:\n print \"No available path between svr and nbr on the substrate network\" \n path_alloc = 0\n #print \"FIND PATH\", find, path\n # End link-path block \n #print \"ALLOCATED: \", path_alloc\n if path_alloc == 1:\n if selected_dict.values().count(item[0]) < limit:\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\n if item[0] not in snode_traffic: \n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] = vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break;\n else:\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \n if min_id == item[0]:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n #threshold = (threshold + 0.01)/2\n break\n elif utilization < threshold:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n if item[0] not in snode_traffic: \n snode_traffic[item[0]] = vn_traffic[1]\n else:\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break\n else:\n print \"does not satisfy the threshold\" \n # if a svr is selected -- item[0]\n \n \n \n else:\n print \"cannot allocate paths\"\n \n #print slink_dict \n return selected_dict, slink_dict","def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\n pass","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def calculate_path_cost_with_weighted_sum(self, path, attr1, attr2): \n costs = [] \n for i in range(len(path) - 1):\n a = (1- self.G[path[i]][path[i+1]][attr2]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \n b = (1- self.G[path[i]][path[i+1]][attr1]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \n costs.append(a * self.G[path[i]][path[i+1]][attr1] + b * self.G[path[i]][path[i+1]][attr2]) \n return max(costs)","def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\n model = copy.deepcopy(model_old)\n \n #cpu_vector = model.cost_dict['cpu']\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n #bw_matrix = model.cost_dict['bw']\n w_a1, w_a2 = w_a\n w_b1, w_b2 = w_b\n theta1, theta2, theta3 = theta\n # find total capacity and used bw on substrate nodes\n node_port_list, used_bw_list = total_port(model)\n #print \"CHECK POINT-1\", used_bw_list, node_port_list\n vnet_info = model.get_vnet_info()\n infeasible = 0\n\n fail_nodes = model.failed_dict\n start_time = time.time()\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n # random selection\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n #print \"selection takes: \", time.time() - start_time\n #print \"Selected\", select_dict\n sum_cost_1_2 = 0\n r_list = {}\n \n for node_id in range(0,len(used_bw_list)):\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\n #print \"INITIAL\", r_list\n svr_subset = {}\n for vnet in model.vnets:\n j = vnet.vnet_id\n f = fail_nodes[j]\n # only count the failed virtual network\n if f == -1:\n pass\n else:\n for node_id in vnet_info[j]['standby']:\n svr_subset[node_id] = r_list[node_id]\n #print \"Subset SVR: \", svr_subset\n \n if j in select_dict:\n #print \"FEASIBLE FOUND\"\n #print vnet_info[j]['standby']\n i = select_dict[j]\n failed_node = vnet.vnodes[f]\n vneighbors = failed_node.vneighbors\n for k in vneighbors: \n eta = operation_cost()\n #print \"a1: \", w_a1, \"a2: \", w_a2, \"b1: \", w_b1, \"b2: \", w_b2\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\n rtt_c = rtt_cost(i, k, rtt_matrix)\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\n #find residual bw on substrate node\n #xi = resource_cost(bw_matrix, i)\n req_bw = sum(failed_node.neighbor_traffic.values())\n #util = req_bw / xi\n #print req_bw, i, used_bw_list[i], node_port_list[i]\n util = req_bw/node_port_list[i]\n \n if i not in r_list:\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\n else:\n r_list[i] += util\n svr_subset[i] = r_list[i]\n #print sigma, \" v_\" + str(vnet.vnet_id) + \"_\" + str(f) + \"_\" + str(i) + \"_\" + str(k) + \"_\" + str(k)\n else:\n print \"INFEASIBLE at vnet: \", j\n infeasible = 1\n #print \"DONE\"\n \n if infeasible == 0:\n #print svr_subset\n max_util = max(svr_subset.values())\n obj = sum_cost_1_2 + theta3 * max_util\n else:\n obj = \"infeasible\"\n max_util = \"none\"\n #print obj\n used_time = time.time() - start_time\n return obj, select_dict, max_util, used_time","def utilization(self):\n\n counters = net_io_counters()\n return LinuxNetworkMetrics._util_tuple(counters.bytes_recv,\n counters.bytes_sent) # TODO max\n # ethtool","def calculate_cost(route, adjacency_matrix):\n route_shifted = np.roll(route,1)\n cost = np.sum(adjacency_matrix[route, route_shifted])\n st_dev = np.std(adjacency_matrix[route, route_shifted])\n return st_dev, cost","def check_link_availability(self, link):\n circuits = self.load_circuits()\n total = 0\n for circuit in circuits:\n exists = circuit.get_link(link)\n if exists:\n total += exists.bandwidth\n if total + link.bandwidth > 100000000000: # 100 Gigabits\n return None\n return total","def opt(self, demands: Demand) -> float:\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('multicommodity_flow_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the splitting ratios for each edge\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(self.num_edges):\n flow_variable_edges.append(\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Capacity constraint\n capacity_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint between 0 and edge capacity\n constraint_i = solver.Constraint(\n 0, self.graph.get_edge_data(*edge)['weight'],\n '(1,{},{})'.format(*edge))\n for j, commodity in enumerate(self.commodities):\n # Coefficient for jth flow over ith edge is scaled by flow width\n constraint_i.SetCoefficient(flow_variables[j][i],\n # cast because or-tools :'(\n float(demands[j]))\n capacity_constraints.append(constraint_i)\n\n # Conservation on transit nodes\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.num_nodes):\n if j != commodity[0] and j != commodity[1]:\n # Constraint must sum to zero\n constraint_j = solver.Constraint(0, 0,\n '(2,{},{})'.format(i, j))\n for k in list(sorted(self.graph.adj[j].keys())):\n # Ingress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\n # Egress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Conservation of flow at source node\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[0], edge_dest)]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[0])]],\n -1)\n conservation_source_constraints.append(constraint_i)\n\n # Conservation of flow at destination node\n conservation_dest_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[1])]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[1], edge_dest)]],\n -1)\n conservation_dest_constraints.append(constraint_i)\n\n ## OBJECTIVES\n # Implementation of the load-balancing example from Wikipedia\n # First we add more constraints so that we are minimising the maximum\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\n 'max_link_utilisation')\n min_of_max_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\n # i.e 'f_0 + f_1 + ... < max'\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\n '(5,{})'.format(i))\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\n for j, flow_variable in enumerate(flow_variables):\n constraint_i.SetCoefficient(flow_variable[i],\n demands[j] /\n self.graph.get_edge_data(*edge)[\n 'weight'])\n min_of_max_constraints.append(constraint_i)\n\n # Objective now is to minimise the maximum link utilisation\n objective = solver.Objective()\n objective.SetCoefficient(max_utilisation_variable, 1)\n objective.SetMinimization()\n solver.Solve()\n\n return objective.Value()","def get_expected_cost(self):","def handle_request(self, sw, util, duration, time_now):\n\n #logging.debug(str(self.graph.edges(data=True)))\n\n #1 Get available paths from servers to switch\n paths = self.get_srv_paths(sw, self.graph)\n\n #2 choose the path which mins the max link utilization for all links\n # along the path\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\n\n if len(bestpath) > 0:\n self.allocate_resources(bestpath, util, time_now, duration)\n else:\n logging.warn(\"[%s] No best path found at switch [%s]\", str(time_now), str(sw))\n\n return bestpath","def get_available_resources(threshold, usage, total):\n return dict((host, int(threshold * total[host] - resource))\n for host, resource in usage.items())","def two_opt_annealing(T, scheme, route, adjacency_matrix, max_chain_length, c):\n best = route.copy()\n cost_list, T_list = [], []\n accept_list = [[],[]]\n\n chains, iterations = 0, 0\n T_0 = T\n iterations = 0\n\n while T > 0:\n for i in range(1, len(route) - 2):\n # test\n # Adjust temperature\n if scheme == \"exp\":\n T = T*c\n if scheme == \"log\":\n alpha = 50\n T = T_0/(1+alpha*np.log(1+iterations))\n # if scheme == \"std\":\n # delta = .01\n # T = T / (1 + ((np.log(1+delta)* T) / (3 * sd0)))\n if scheme == \"quad\":\n alpha = 1\n T = T_0/(1+alpha*iterations**2)\n\n iterations += 1\n \n for j in range(i + 1, len(route)):\n chains += 1\n\n if j - i == 1: continue\n\n cost_list.append(calculate_cost(best,adjacency_matrix)[1])\n T_list.append(T)\n\n if cost_change(adjacency_matrix, best[i - 1], best[i], \\\n best[j - 1], best[j]) < 0:\n best[i:j] = best[j - 1:i - 1:-1]\n else:\n temp = best.copy()\n sd0, cost0 = calculate_cost(temp,adjacency_matrix)\n temp[i:j] = temp[j - 1:i - 1:-1]\n _, cost1 = calculate_cost(temp,adjacency_matrix)\n\n U = rs.uniform()\n Z = np.exp((cost0-cost1)/T)\n\n if U < Z:\n accept_list[1].append(Z)\n accept_list[0].insert(0,T)\n\n best[i:j] = best[j - 1:i - 1:-1]\n\n if chains > max_chain_length:\n print(\"End by chainlength: \",chains,\"T =\",T,\"Cost:\",cost0)\n print(\"route\",best)\n return best, cost_list, accept_list\n\n route = best.copy()\n print(\"End by T: \",T,\"Chains: \",chains,\"Cost:\",cost0)\n print(\"route\",best)\n return best, cost_list, accept_list","def compute_social_welfare(self):\r\n #self.social_welfare = 0\r\n #for i in range(self.num_routes):\r\n # self.social_welfare += self.routes[i].flow * self.routes[i].get_route_utility()\r","def calculate_demand(flow, requested_sf, available_sf, service_functions):\n\n if requested_sf in available_sf:\n vnf_need_placement = False\n demanded_total_capacity = 0.0\n for sf_i, sf_data in available_sf.items():\n if requested_sf == sf_i:\n # Include flows data rate in requested sf capacity calculation\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\n sf_data['load'] + flow.dr)\n else:\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\n return demanded_total_capacity, vnf_need_placement\n else:\n vnf_need_placement = True\n available_sf[requested_sf] = {'load': 0.0}\n demanded_total_capacity = 0.0\n for sf_i, sf_data in available_sf.items():\n if requested_sf == sf_i:\n # Include flows data rate in requested sf capacity calculation\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\n sf_data['load'] + flow.dr)\n else:\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\n del available_sf[requested_sf]\n return demanded_total_capacity, vnf_need_placement","def cost(graph,a, undirected=True):\n cost = sum(sum(np.array(abs(graph-a))))\n if undirected:\n return cost/2.0\n else:\n return cost","def calculate_algorithm_cost(algorithm_stats, operation_costs): \n\n (comparisons, reads, writes) = algorithm_stats\n (comparison_cost, read_cost, write_cost) = operation_costs\n return (comparisons * comparison_cost) + (reads * read_cost) + (writes * write_cost)","def get_link_cost(self, global_clock_sec):\n return self.static_delay_sec + \\\n self.link_buffer.get_average_q_del_sec(global_clock_sec)","def score(caches, endpoints, requests, videos):\n result = 0\n for endpoint in endpoints:\n for request in endpoint.requests:\n result += (endpoint.latence_to_dc - getLatency(request.video, endpoint.eid, caches, videos, endpoints)) * request.amount\n return result","def dist(a, b):\n base_url=\"https://route.api.here.com/routing/7.2/calculateroute.json?\"\n payload = {'app_id':HERE_ID, \n 'app_code':HERE_CODE,\n 'waypoint0':'geo!'+','.join([str(i) for i in a]),\n 'waypoint1':'geo!'+','.join([str(i) for i in b]),\n 'mode':'fastest;car;traffic:disabled',\n }\n resp = requests.get(base_url, params=payload)\n data = json.loads(resp.content)\n #import ipdb; ipdb.set_trace()\n summary = data['response']['route'][0]['summary']\n return {\"distance\" : summary['distance'], \n \"trafficTime\" : summary[\"trafficTime\"],\n \"baseTime\" : summary[\"baseTime\"]}","def evalPart(origTopo, capacities, subTopos):\r\n # print \"\\t===== Evaluate Partitioning =====\"\r\n numTopos = len(subTopos)\r\n numPM = len(capacities)\r\n if (numTopos > numPM):\r\n logger.error(\"Number of sub topologies does not match number of PMs\")\r\n exit()\r\n \r\n weights = {x:0 for x in range(numPM)}\r\n cutWeights = {x:0 for x in range(numPM)}\r\n subLinks = list(itertools.chain(*[subTopos[x].links(sort=True) for x in range(numTopos)]))\r\n cuts = [x for x in origTopo.links(sort=True) if x not in subLinks]\r\n\r\n for i in range(numTopos):\r\n weights[i] = calcTopoWeight(subTopos[i])\r\n cutWeights[i] = 0\r\n\r\n # for i in range(numTopos):\r\n # weights[i] = 0.0\r\n # for link in subTopos[i].links():\r\n # if origTopo.isSwitch(link[0]) and origTopo.isSwitch(link[1]):\r\n # weights[i] = weights[i] + subTopos[i].linkInfo(link[0], link[1])[\"bw\"]\r\n \r\n for link in cuts:\r\n for i in range(numTopos):\r\n if link[0] in subTopos[i].switches() or link[1] in subTopos[i].switches():\r\n weights[i] = weights[i] + origTopo.linkInfo(link[0], link[1])[\"bw\"]\r\n cutWeights[i] = cutWeights[i] + origTopo.linkInfo(link[0], link[1])[\"bw\"]\r\n\r\n return [weights, cutWeights]\r\n # return sorted(weights.values(), reverse=True)\r\n # wSum = sum(weights.values())\r\n # print \"\\tPart\\tCap\\tWeight\\tFraction\"\r\n # for x in range(numPM):\r\n # print \"\\t%d\\t%.1f\\t%.1f\\t%.4f\" % (x, capacities[x], weights[x], weights[x]/wSum)\r","def resource_costs(self, fleet):\n base = (10, 15, 0, 0)\n ins = fleet.get_ship_instances()\n mult = sum([ship_stats.get_ship_type(x.base().stype)\n .resource_mult for x in ins])\n return tuple(map(lambda x: x * mult, base))","def averageExcessCost(self):\n TSTT = 0\n for l in self.link:\n if self.link[l].flow <0:\n print(\"what in tarnation?\") #this really shouldn't happen, but the sheer number of leetcode problems I've been doing make me want to check against it anyway\n break\n if self.link[l].flow >0:\n contribution = self.link[l].flow * self.link[l].cost\n TSTT += contribution\n SPTT = 0\n TotalDemand = 0\n for od in self.ODpair:\n if self.ODpair[od].demand >0:\n O = self.ODpair[od].origin\n D = self.ODpair[od].destination\n BL,C = self.shortestPath(O)\n SPTT += C[D]*self.ODpair[od].demand\n TotalDemand+=self.ODpair[od].demand\n AEC = (TSTT - SPTT)/TotalDemand\n \n return AEC","def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\n if highway == 'motorway':\n result = -motorway_pref*0.5\n elif highway == 'primary':\n result = -highway_pref*0.5\n elif highway == 'residential' or highway == 'service':\n result = -residential_pref*0.5\n elif highway == 'cycleway':\n result = -bicycle_pref * 0.8\n else:\n result = 0\n return result","def compute_path_hopping_flow_allocations(target_graph, K=3):\n flow_allocation_seed_number = 0xCAFE_BABE\n np.random.seed(flow_allocation_seed_number)\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\n node_capacity = {u: 0.0 for u in target_graph.nodes}\n flows = []\n while True:\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\n print(source_node, destination_node)\n\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\n cutoff=3),\n key=lambda p: len(p))\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\n\n # flow_tx_rate = np.random.uniform() * 10\n flow_tx_rate = 1.0\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\n # break\n node_capacity[source_node] += flow_tx_rate\n capacity_was_exceeded = False \n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\n for u, v in [sorted(h_i) for h_i in path]:\n flow_rate_per_subpath = flow_tx_rate / K\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = k_shortest_paths\n , splitting_ratio = [1.0/K]*K\n )\n flows.append(the_flow)\n return flows, link_utilization","def metric_path_length(pathways):\r\n num_users = len(pathways)\r\n num_good_recommendations = 0\r\n sum_u_path_len = 0\r\n sum_r_path_len = 0\r\n career_goal_reached = 0\r\n for user, pathway_tuple in pathways.items():\r\n u_path = pathway_tuple[0]\r\n r_path = pathway_tuple[1]\r\n sum_u_path_len += len(u_path)\r\n sum_r_path_len += len(r_path)\r\n if r_path[-1]==u_path[-1]:\r\n career_goal_reached += 1\r\n if len(r_path) < len(u_path):\r\n num_good_recommendations += 1\r\n return 100.0 * career_goal_reached/num_users, 100.0 * num_good_recommendations / num_users, sum_u_path_len/num_users, sum_r_path_len/num_users","def calc_capital_costs (self):\n road_needed = 'road needed'\n if self.cd['on road system']:\n road_needed = 'road not needed'\n\n dist = self.comp_specs['distance to community']\n self.capital_costs = self.comp_specs['est. intertie cost per mile']\\\n [road_needed] * dist\n #~ print self.capital_costs","def update_flow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n # (1): add all edges (u, v) with capacity ub-lb\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"upper_bound\"] == float('inf'):\n self.arc_info[arc][\"upper_bound\"] = B\n for arc in self.arc_info.keys():\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(int(self.arc_info[arc][\"upper_bound\"]\\\n - self.arc_info[arc][\"lower_bound\"]))\n # (2): add edge (t, s) with capacity B\n # B = max_lb * (m - n + 2)\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\n if B == 0:\n #B = float('inf')\n B = 100000\n start_nodes.append(self.sink())\n end_nodes.append(self.source())\n capacities.append(int(B))\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\n s_prime = max(self.vertices) + 1\n t_prime = max(self.vertices) + 2\n print(\"s'={}, t'={}\".format(s_prime, t_prime))\n for v in self:\n #print(\"vert {} in arcs: {}\".format(v,\n # self.in_arcs_lists[v]))\n # compute exc: lower bounds of in - lower bounds of out\n sum_lb_in = 0\n for in_arc in self.in_arcs_lists[v]:\n sum_lb_in += self.arc_info[in_arc][\"lower_bound\"]\n sum_lb_out = 0\n #print(\"vert {} out arcs: {}\".format(v,\n # self.out_arcs_lists[v]))\n for out_arc in self.out_arcs_lists[v]:\n sum_lb_out += self.arc_info[out_arc][\"lower_bound\"]\n exc = sum_lb_in - sum_lb_out\n #print(\"exc is {}\".format(exc))\n if exc > 0:\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(exc))\n else:\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(-exc))\n # solve maxflow\n #print(\"s' is {} and t' is {}\".format(s_prime, t_prime))\n max_flow = pywrapgraph.SimpleMaxFlow()\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\n #print(\"Adding edge {}, {} with cap {}\".format(u,v,cap))\n max_flow.AddArcWithCapacity(u, v, cap)\n success = True\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\n #print(' Arc Flow / Capacity')\n for i in range(max_flow.NumArcs()):\n # print('%1s -> %1s %3s / %3s' % (\n # max_flow.Tail(i),\n # max_flow.Head(i),\n # max_flow.Flow(i),\n # max_flow.Capacity(i)))\n # check that (s', v) edges are saturated (once we find a false,\n # stay false forever)\n if success:\n if max_flow.Tail(i) == s_prime:\n success = max_flow.Flow(i) == max_flow.Capacity(i)\n else:\n success = False\n print('There was an issue with the max flow input.')\n if success:\n # update the flows to be the flow found from maxflow problem\n for i in range(max_flow.NumArcs()):\n # if this is an original arc, update the flow\n if max_flow.Tail(i) != s_prime \\\n and max_flow.Head(i) != t_prime \\\n and not (max_flow.Tail(i) == self.sink() \\\n and max_flow.Head(i) == self.source()):\n # update arc\n start = max_flow.Tail(i)\n destin = max_flow.Head(i)\n arc = self.get_arc(start, destin)\n new_flow = self.arc_info[arc][\"lower_bound\"] + max_flow.Flow(i)\n old_flow = self.arc_info[arc][\"weight\"]\n self.arc_info[arc][\"weight\"] = new_flow\n #print(\"Edge {} {} adjusted from {} to {}\".format(\n # start,\n # destin,\n # old_flow,\n # new_flow\n # ))\n self.check_conservation_of_flow() # check that solution is valid\n return True\n else:\n return False","def get_routecost(self, route):\n return np.sum(self.parent.edges.lengths[route])","def overhead(readings):\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))","def geo_dist_penalty(p_a, p_b): # created on Nov.3 2019\n\n # Offset is 0 for the 1st destination.\n distance_matrix = Network.dist_mat\n if p_a[0] != p_b[0] or p_a[-1] != p_b[-1]:\n raise ValueError('Paths have different o or d.')\n\n # define the penalty in utility form for every two destinations. u_ik stands for the generalized cost of travel\n o, d = p_a[0], p_a[-1]\n\n path_a, path_b = p_a[1:-1], p_b[1:-1] # excluding origin and destination\n\n path_node_check = []\n for _path in [path_a, path_b]:\n _new_path = []\n for node in _path:\n if node <= min(distance_matrix.shape) - 1:\n _new_path.append(node)\n path_node_check.append(_new_path)\n path_a, path_b = path_node_check[0], path_node_check[1]\n\n # utility (negative) penalty evaluation\n cost, a, b = 0, o, o # let a, b be origin\n\n # if exist empty path\n if not path_a: # if observed path is empty\n return cost\n\n while path_a and path_b:\n a, b = path_a.pop(0), path_b.pop(0) # a, b correspond to the i_th node in path_a, path_b\n cost += distance_matrix[a][b]\n\n if path_a: # length of path_a > path b\n while path_a:\n a = path_a.pop(0)\n cost += distance_matrix[a][b]\n else: # case when length of path_b > path a\n while path_b:\n b = path_b.pop(0)\n cost += distance_matrix[a][b]\n return cost","def optimal_route(graph,homes,source):\n number_of_homes = len(homes)\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\n \n cluster_list = range(1,number_of_homes+1)\n optimal_cost = np.Inf\n optimal_dropoffs = dict()\n optimal_route = []\n optimal_num_clusters = 0\n\n\n for num_clusters in cluster_list:\n home_clusters = num_clusters_to_clustering[num_clusters]\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\n if cost < optimal_cost:\n optimal_cost = cost\n optimal_route = route \n optimal_dropoffs = dropoffs\n optimal_num_clusters = num_clusters\n\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters","def total_sdram_requirements(self):","def main(supply):\n\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\n # between each pair. For instance, the arc from node 0 to node 1 has a\n # capacity of 15 and a unit cost of 4.\n\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\n\n # Define an array of supplies at each node.\n supplies = supply\n\n\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n\n # Add each arc.\n for i in range(0, len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\n capacities[i], unit_costs[i])\n\n # Add node supplies.\n\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n\n\n # Find the minimum cost flow between node 0 and node 4.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n flag = 1\n optimal_flows = np.zeros(36)\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # save answer to the variable\n optimal_flows[i] = min_cost_flow.Flow(i)\n return flag, optimal_flows\n else:\n print('There was an issue with the min cost flow input.')\n flag = 0\n return flag, 0","def calculateRSTFairshare(self, reqRules):\n self.getQoSTotals()\n reqRate, _ = self.convertToRate(reqRules['rules'])\n totalRate = None\n for key in ['src_ipv4', 'src_ipv6']:\n totalRate = self.getTotalAvailableForIP(reqRules[key])\n if totalRate:\n break\n if not totalRate:\n return None\n reserved = int(self.params[reqRules['master_intf']]['intf_reserve'])\n totalAll = self.params[reqRules['master_intf']]['total_allocated']\n intfMax = self.params[reqRules['master_intf']]['intf_max']\n # Formula 1: Find ratio between all servers total capacity\n # (individualRate/totalRates) = ratio\n ratio = round(float(intfMax) / float(totalRate), 4)\n # Formula 2: Find individual node fairshare\n # ratio * reqRate = nodeThrgShare\n nodeThrgShare = int(ratio * reqRate)\n # Condition 1: If not enough capacity on all Nodes,\n # do a fractional calculation for fairshare\n if nodeThrgShare >= intfMax or nodeThrgShare > totalAll:\n fractReq = self.reqRatio(intfMax, reqRate, totalAll)\n reqRate = fractReq\n # Min for QoS we use 1Gb/s.\n reqRate = max(int(nodeThrgShare), 1000)\n return {'reqRate': reqRate, 'reserved': reserved}","def main(edges=[(0, 1, 3), (1, 3, 4), (2, 3, 3), (0, 2, 2) ], num=4):\n\n # initialize routers array\n routers = []\n for x in range(num):\n routers.append([1000] * num)\n routers[x][x] = 0\n \n # set distance to all neighbours \n for edge in edges:\n routers[edge[0]][edge[1]] = edge[2]\n routers[edge[1]][edge[0]] = edge[2]\n\n start_table = routers.copy()\n\n flag = True\n while flag:\n upflag = False\n for nbrs in edges:\n routers[nbrs[0]], up_flag1 = update_table(routers[nbrs[0]], routers[nbrs[1]], dist=nbrs[2])\n routers[nbrs[1]], up_flag2 = update_table(routers[nbrs[1]], routers[nbrs[0]], dist=nbrs[2])\n upflag = upflag or up_flag1 or up_flag2\n\n flag = upflag\n\n return start_table, routers","def operation_cost(tau=0):\n iface_on = 0.2\n iface_off = 0.2 \n ipconfig = 2\n reconf_ip_bin = tau\n op_cost = 2 * (iface_on + iface_off) + reconf_ip_bin * ipconfig\n return op_cost","def topo_efficiency_cal(self):\n Temp = 0\n for i in self.supplyseries:\n for j in self.demandseries:\n if(self.topo_shortestpathij(i, j) == None):\n continue\n Temp += 1/self.topo_shortestpathij(i, j)\n \n self.topo_efficiency = 1/(self.supplynum*self.demandnum)*Temp","def su_cost(node_type, node_count, cpu, gpu, ram, duration):\r\n if node_type == 'std':\r\n node_factor = 1\r\n tot_cpu = 28\r\n tot_ram = 128\r\n if node_type == 'gpu':\r\n node_factor = 2\r\n tot_cpu = 28\r\n tot_ram = 256\r\n if node_type == 'fat':\r\n node_factor = 6\r\n tot_cpu = 56\r\n tot_ram = 1024\r\n # job_setup = \"current setup = {} node type + {} number of nodes + {} number of cpu # + {} number of ram + {} hrs duration of job + {} total cpu + {} total ram\".format(node_type, node_count, cpu, ram, duration, tot_cpu, tot_ram)\r\n # calculate service units\r\n max_resource = top_resource(\r\n alloc_CPU = cpu, cpu_denominator = tot_cpu,\r\n alloc_GPU = gpu, gpu_denominator = 4,\r\n alloc_RAM = ram, ram_denominator = tot_ram)\r\n su = ( (node_count * (max_resource * node_factor)) * 28 * duration )\r\n return(su)","def compute_untargeted_prob(client_as_lst, \r\n bw_resource,\r\n num_relays,\r\n guard_to_bw,\r\n all_ases,\r\n ip_to_as,\r\n pfi,\r\n outDir):\r\n\r\n mal_guard_probs = {}\r\n mal_guard_bw = bw_resource / num_relays\r\n\r\n # initial network state (no malicious guards yet)\r\n # format: {FP: (AS, BW)}\r\n network_state = {}\r\n for g, bw in guard_to_bw.items():\r\n network_state[g.fingerprint] = (ip_to_as[g.address], bw)\r\n\r\n for i in range(0, num_relays):\r\n\r\n mal_guard_fp = f\"MALGUARD{i}\"\r\n\r\n # avg_prob, i^{th} mal_as, network_state\r\n best_state = (0, \"unknown\", {})\r\n\r\n cnt = 0\r\n for cand_as in all_ases:\r\n\r\n # insert malicious guard in candidate AS\r\n temp_network_state = copy.deepcopy(network_state)\r\n temp_network_state[mal_guard_fp] = (cand_as, mal_guard_bw)\r\n \r\n sum_probs = 0\r\n for client_as in client_as_lst:\r\n prob = compute_prob(client_as,\r\n mal_guard_fp, \r\n mal_guard_bw, \r\n temp_network_state,\r\n pfi)\r\n sum_probs += prob\r\n avg_prob = sum_probs / len(client_as_lst)\r\n\r\n cnt += 1\r\n print(cnt)\r\n\r\n if avg_prob > best_state[0]:\r\n best_state = (avg_prob, cand_as, copy.deepcopy(temp_network_state))\r\n\r\n network_state = copy.deepcopy(best_state[2])\r\n mal_guard_probs[f'{best_state[1]}_{i}'] = best_state[0]\r\n\r\n if outDir is not None:\r\n json.dump(best_state, open(f\"{outDir}/tempbeststate{i}.json\", \"w\"))\r\n\r\n print(mal_guard_probs)\r\n if outDir is not None:\r\n json.dump(mal_guard_probs, open(f\"{outDir}/malguardprobs.json\", \"w\"))\r\n print(sum(mal_guard_probs.values()))\r\n\r\n return mal_guard_probs","def Option2_routing(self, S, D, L):\n if self.has_path(S, D): \n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \n Opt_path = Shortest_path\n path_cost_with_weighted_sum = self.calculate_path_cost_with_weighted_sum(Shortest_path, 'c1', 'c2')\n return path_cost_with_weighted_sum, Opt_path\n\n while len(Shortest_path) != 0:\n path_cost = self.additive_path_cost(Shortest_path, 'w') \n #self.logger.info('Path cost - %d', path_cost)\n if path_cost <= L:\n \"\"\"go to path cost with weighted sum\"\"\"\n path_cost_with_weighted_sum = self.calculate_path_cost_with_weighted_sum(Shortest_path, 'c1', 'c2')\n self.G = self.rm_edge_constraint(path_cost_with_weighted_sum) # remove all links where the concave link is greater than PathConcave_cost \n Opt_path = Shortest_path\n if self.has_path(S, D):\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\n else:\n Shortest_path = [] \n else:\n break \n else:\n self.logger.info('No path from %s to %s', S, D)\n Opt_path = []\n path_cost_with_weighted_sum = 0\n return path_cost_with_weighted_sum, Opt_path","def objective(graph, flows):\n\n G = graph.copy()\n rules = {}\n flows.sort(key=lambda a: a[1], reverse=True)\n\n for flow,demand in flows:\n src = get_host_from_ip(G, flow.nw_src)\n dst = get_host_from_ip(G, flow.nw_dst)\n\n if not (src and dst):\n continue\n if not (src in G.nodes() and dst in G.nodes()):\n continue\n\n path = widest_path(G, src, dst)\n\n hops = []\n for a,b in pairwise(path):\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\n G.edge[a][b]['capacity'] -= demand\n G.edge[b][a]['capacity'] -= demand\n\n rules[flow] = hops\n\n return rules","def cost(self):\n lg = len(self.guarantees.cnf)\n la = len(self.assumptions.cnf)\n\n \"\"\"heuristic\n Low: guarantees while assuming little (assumption set is bigger)\n High: guarantees while assuming a lot (assumption set is smaller)\"\"\"\n\n return la / lg","def compute_pagerank(urls, inlinks, outlinks, b=.85, iters=20):\n ###TODO\n pagerank = defaultdict(lambda: 1.0)\n N = len(urls)\n for url in urls:\n pagerank[url]\n for i in range(0, iters):\n for url in urls:\n result_sum = 0.0\n for link in inlinks[url]:\n if len(outlinks[link]) is not 0:\n result_sum += (pagerank[link] / len(outlinks[link]))\n pagerank[url] = (1/N) * (1-b) + (b * result_sum)\n return pagerank\n pass","def sub_link_capacity(self, path, bw):\n \n # PART 1, TASK 3.4 sub bw to edges","def two_user_route_statistics(i,j, source_data, destination_data, source_destination_data, delta=1.2):\n\toccupancy_ratio = 0.0\n\tminimum_distance_so_far = 0.0\n\tcommon_travel_distance = 0.0\n\n\ttry:\n\t\tif source_destination_data[j][i] + source_data[i][j] <= 1.2*source_destination_data[i][i] and source_destination_data[j][i] + destination_data[i][j] <= 1.2*source_destination_data[j][j]:\n\t\t\tfirst = ((source_destination_data[j][i] + source_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\n\t\t\tsecond = ((source_destination_data[j][i] + destination_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\n\t\t\toccupancy_ratio = (first+second)/2\n\t\t\tcommon_travel_distance = source_destination_data[j][i]\n\t\t\tminimum_distance_so_far = source_data[i][j] + source_destination_data[j][i] + destination_data[i][j]\n\n\t\tif source_destination_data[i][j] + destination_data[j][i] <= 1.2*source_destination_data[i][i] and source_destination_data[i][j] + source_data[j][i] <= 1.2*source_destination_data[j][j]:\n\t\t\tfirst = ((source_destination_data[i][j] + destination_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\t\t\n\t\t\tsecond = ((source_destination_data[i][j] + source_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\n\t\t\ttotal_distance = source_data[j][i] + source_destination_data[i][j] + destination_data[j][i]\n\n\t\t\tif total_distance < minimum_distance_so_far:\n\t\t\t\tminimum_distance_so_far = total_distance\n\t\t\t\tcommon_travel_distance = source_destination_data[i][j]\n\t\t\t\toccupancy_ratio = (first+second)/2\n\n\t\tif source_data[i][j]+source_destination_data[j][j]+destination_data[j][i] <= 1.2*source_destination_data[i][i]:\n\t\t\tfirst = (1)\n\t\t\tsecond = (source_destination_data[j][j]/(source_data[i][j]+source_destination_data[j][j]+destination_data[j][i]))\n\n\t\t\ttotal_distance = source_data[i][j] + source_destination_data[j][j] + destination_data[j][i]\n\n\t\t\tif total_distance < minimum_distance_so_far:\n\t\t\t\tminimum_distance_so_far = total_distance\n\t\t\t\tcommon_travel_distance = source_destination_data[j][j]\n\t\t\t\toccupancy_ratio = (first+second)/2\n\n\t\tif source_data[j][i]+source_destination_data[i][i]+destination_data[i][j] <= 1.2*source_destination_data[j][j]:\n\t\t\tfirst = (source_destination_data[i][i]/(source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]))\n\t\t\tsecond = (1)\n\n\t\t\ttotal_distance = source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]\n\n\t\t\tif total_distance < minimum_distance_so_far:\n\t\t\t\tminimum_distance_so_far = total_distance\n\t\t\t\tcommon_travel_distance = source_destination_data[i][i]\n\t\t\t\toccupancy_ratio = (first+second)/2\n\n\texcept Exception as e:\n\t\toccupancy_ratio = 1.0\n\t\tminimum_distance_so_far = 0.0\n\t\tcommon_travel_distance = 0.0\n\n\n\treturn occupancy_ratio, common_travel_distance, minimum_distance_so_far","def total_weight(network):\n weight = 0\n\n for node_connections in network:\n for edge in node_connections:\n if edge is not None:\n weight += edge\n\n return weight // 2","def mapping_quality(graph, spanset, gapset):\n the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)\n # if directed graph, uncomment this:\n #the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)\n return the_sum","def compute_m_paths_of_len_forw(g, sampl, start_times, path_len=5, cost=1, its=100, max_duration=sys.maxint):\n\n num_of_paths_dict = {}\n\n # for each node in source, generate random paths and count the number of times they end up in each\n # dest. node\n for source, start_time in zip(sampl, start_times):\n print \"Processing source node: {} (starting at time {})\".format(source, start_time)\n num_of_paths_dict[(source, start_time)] = {dest: 0 for dest in g.nodes()}\n for _ in range(its):\n d = random_path_forward(g, source, path_len, start_time, cost, max_duration)\n if d is not None:\n num_of_paths_dict[(source, start_time)][d] += 1\n\n return num_of_paths_dict","def compute_total_distance(road_map):\n \n try:\n distances = distances_and_limits(road_map)[0]\n return round(sum(distances),2)\n except Exception as e:\n print(str(e))","def assess_latency_by_obs(self,\n possible_routes, \n executed_routes, \n rt_poss_dv_getter = rt_possible_dv_getter, \n rt_exec_dv_getter= rt_scheduled_dv_getter, \n verbose=False):\n\n # possible routes by observation\n poss_rts_by_obs = self.get_routes_by_obs (possible_routes)\n exec_rts_by_obs = self.get_routes_by_obs (executed_routes)\n exec_obs = exec_rts_by_obs.keys()\n\n stats = {}\n\n # for selected routes\n possible_initial_lat_by_obs_exec = {}\n for obs, rts in poss_rts_by_obs.items ():\n\n # want to make this a fair comparison. Only consider latency in rs for those obs that show up in AS\n if not obs in exec_obs:\n continue\n\n # start, center, end...whichever we're using for the latency calculation\n time_option = self.latency_calculation_params['dlnk']\n\n # want to sort these by earliest time so that we favor earlier downlinks\n rts.sort (key=lambda rt: getattr(rt.get_dlnk(),time_option))\n\n # figure out the latency for the initial minimum DV downlink\n # have to accumulate data volume because route selection minimum data volume might be less than that for activity scheduling\n cum_dv = 0\n for rt in rts:\n cum_dv += rt_poss_dv_getter(rt)\n \n # if we have reached our minimum required data volume amount to deem the observation downlinked for the purposes of latency calculation...\n if cum_dv >= self.min_obs_dv_dlnk_req - self.min_obs_dv_dlnk_req_slop :\n\n possible_initial_lat_by_obs_exec[obs] = rt.get_latency(\n 'minutes',\n obs_option = self.latency_calculation_params['obs'], \n dlnk_option = self.latency_calculation_params['dlnk']\n )\n\n # break so that we don't continue considering the rest of the data volume\n break\n\n # for executed routes\n executed_initial_lat_by_obs_exec = {}\n executed_final_lat_by_obs_exec = {}\n for obs, rts in exec_rts_by_obs.items ():\n # start, center, end...whichever we're using for the latency calculation\n time_option = self.latency_calculation_params['dlnk']\n\n # want to sort these by earliest time so that we favor earlier downlinks\n rts.sort (key=lambda rt: getattr(rt.get_dlnk(),time_option))\n\n # figure out the latency for the initial minimum DV downlink\n # have to accumulate data volume because route selection minimum data volume might be less than that for activity scheduling\n cum_dv = 0\n for rt in rts:\n cum_dv += rt_exec_dv_getter(rt)\n \n # if we have reached our minimum required data volume amount to deem the observation downlinked for the purposes of latency calculation...\n if cum_dv >= self.min_obs_dv_dlnk_req - self.min_obs_dv_dlnk_req_slop :\n executed_initial_lat_by_obs_exec[obs] = rts[0].get_latency(\n 'minutes',\n obs_option = self.latency_calculation_params['obs'], \n dlnk_option = self.latency_calculation_params['dlnk']\n )\n\n # break so that we don't continue considering the rest of the data volume\n break\n\n # figure out the latency for downlink of all observation data that we chose to downlink\n executed_final_lat_by_obs_exec[obs] = rts[-1].get_latency(\n 'minutes',\n obs_option = self.latency_calculation_params['obs'], \n dlnk_option = self.latency_calculation_params['dlnk']\n )\n\n i_lats_poss = [lat for lat in possible_initial_lat_by_obs_exec. values ()]\n i_lats_exec = [lat for lat in executed_initial_lat_by_obs_exec. values ()]\n f_lats_exec = [lat for lat in executed_final_lat_by_obs_exec. values ()]\n \n i_valid_poss = len(i_lats_poss) > 0\n i_valid_exec = len(i_lats_exec) > 0\n f_valid_exec = len(f_lats_exec) > 0\n\n # debug_tools.debug_breakpt()\n\n # note: don't use mean/std. they're not super useful metrics, statistically speaking\n # note that if center times are not used with both the observation and downlink for calculating latency, then the route selection and executed the numbers might differ. this is because the executed numbers reflect the updated start and end time for the Windows\n # stats['ave_obs_initial_lat_poss'] = np.mean(i_lats_poss) if i_valid_poss else None\n # stats['std_obs_initial_lat_poss'] = np.std(i_lats_poss) if i_valid_poss else None\n stats['min_obs_initial_lat_poss'] = np.min(i_lats_poss) if i_valid_poss else None\n stats['prcntl25_obs_initial_lat_poss'] = np.percentile(i_lats_poss,25) if i_valid_poss else None\n stats['median_obs_initial_lat_poss'] = np.median(i_lats_poss) if i_valid_poss else None\n stats['prcntl75_obs_initial_lat_poss'] = np.percentile(i_lats_poss,75) if i_valid_poss else None\n stats['max_obs_initial_lat_poss'] = np.max(i_lats_poss) if i_valid_poss else None\n # stats['ave_obs_initial_lat_exec'] = np.mean(i_lats_exec) if i_valid_exec else None\n # stats['std_obs_initial_lat_exec'] = np.std(i_lats_exec) if i_valid_exec else None\n stats['min_obs_initial_lat_exec'] = np.min(i_lats_exec) if i_valid_exec else None\n stats['prcntl25_obs_initial_lat_exec'] = np.percentile(i_lats_exec,25) if i_valid_exec else None\n stats['median_obs_initial_lat_exec'] = np.median(i_lats_exec) if i_valid_exec else None\n stats['prcntl75_obs_initial_lat_exec'] = np.percentile(i_lats_exec,75) if i_valid_exec else None\n stats['max_obs_initial_lat_exec'] = np.max(i_lats_exec) if i_valid_exec else None\n\n stats['ave_obs_final_lat_exec'] = np.mean(f_lats_exec) if f_valid_exec else None\n stats['min_obs_final_lat_exec'] = np.min(f_lats_exec) if f_valid_exec else None\n stats['max_obs_final_lat_exec'] = np.max(f_lats_exec) if f_valid_exec else None\n\n stats['possible_initial_lat_by_obs_exec'] = possible_initial_lat_by_obs_exec\n stats['executed_initial_lat_by_obs_exec'] = executed_initial_lat_by_obs_exec\n stats['executed_final_lat_by_obs_exec'] = executed_final_lat_by_obs_exec\n\n if verbose:\n print('latencies by observation (only considering \"executed\" obs windows)')\n\n if not (i_valid_poss or i_valid_exec):\n print('no routes found, no valid statistics to display')\n return stats\n\n if not i_valid_poss:\n print('no RS routes found')\n if not i_valid_exec:\n print('no scheduled routes found')\n\n if i_valid_poss:\n # print(\"%s: \\t\\t %f\"%('ave_obs_initial_lat_poss',stats['ave_obs_initial_lat_poss']))\n # print(\"%s: \\t\\t %f\"%('std_obs_initial_lat_poss',stats['std_obs_initial_lat_poss']))\n print(\"%s: %f\"%('min_obs_initial_lat_poss',stats['min_obs_initial_lat_poss']))\n print(\"%s: %f\"%('prcntl25_obs_initial_lat_poss',stats['prcntl25_obs_initial_lat_poss']))\n print(\"%s: \\t\\t %f\"%('median_obs_initial_lat_poss',stats['median_obs_initial_lat_poss']))\n print(\"%s: %f\"%('prcntl75_obs_initial_lat_poss',stats['prcntl75_obs_initial_lat_poss']))\n print(\"%s: %f\"%('max_obs_initial_lat_poss',stats['max_obs_initial_lat_poss']))\n\n if i_valid_exec:\n # print(\"%s: \\t\\t %f\"%('ave_obs_initial_lat_exec',stats['ave_obs_initial_lat_exec']))\n # print(\"%s: \\t\\t %f\"%('std_obs_initial_lat_exec',stats['std_obs_initial_lat_exec']))\n print(\"%s: %f\"%('min_obs_initial_lat_exec',stats['min_obs_initial_lat_exec']))\n print(\"%s: %f\"%('prcntl25_obs_initial_lat_exec',stats['prcntl25_obs_initial_lat_exec']))\n print(\"%s: \\t\\t %f\"%('median_obs_initial_lat_exec',stats['median_obs_initial_lat_exec']))\n print(\"%s: %f\"%('prcntl75_obs_initial_lat_exec',stats['prcntl75_obs_initial_lat_exec']))\n print(\"%s: %f\"%('max_obs_initial_lat_exec',stats['max_obs_initial_lat_exec']))\n print(\"all 5 in a row: %f %f %f %f %f\"%(\n stats['min_obs_initial_lat_exec'],\n stats['prcntl25_obs_initial_lat_exec'],\n stats['median_obs_initial_lat_exec'],\n stats['prcntl75_obs_initial_lat_exec'],\n stats['max_obs_initial_lat_exec'])\n )\n \n # todo: might should update median calcs for final lat as well\n print(\"Note: should update final latency to median and prcntls as well\")\n print(\"%s: %f\"%('ave_obs_final_lat_exec',stats['ave_obs_final_lat_exec']))\n print(\"%s: %f\"%('min_obs_final_lat_exec',stats['min_obs_final_lat_exec']))\n print(\"%s: %f\"%('max_obs_final_lat_exec',stats['max_obs_final_lat_exec']))\n\n return stats","def uniformCostSearch(problem):\n \"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\"\n aStarSearch(problem)","def _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\n partial_asgt = self._neighbors_values.copy()\n offers = dict()\n\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\n partial_asgt.update(limited_asgt)\n cost = self._compute_cost(**partial_asgt)\n if self.logger.isEnabledFor(logging.DEBUG):\n self.logger.debug(\n f\"looking for offer : {partial_asgt} - cost {cost}\"\n f\" current {self.current_cost} {self._mode}\"\n )\n\n if (self.current_cost > cost and self._mode == \"min\") or (\n self.current_cost < cost and self._mode == \"max\"\n ):\n offers[(limited_asgt[self.name], limited_asgt[self._partner.name])] = (\n self.current_cost - cost\n )\n return offers","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def resource_cost(bw_matrix, standby_vr):\n #host_cpu = float(cpu_info[0][standby_vr])\n host_bw = 0\n num_rows = len(bw_matrix)\n #num_cols = len(bw_matrix[1,:])\n for port in range(num_rows):\n if bw_matrix[port][standby_vr] != '.':\n host_bw += float(bw_matrix[port][standby_vr])\n else:\n pass\n #return host_cpu * host_bw\n return host_bw","def cost(self) -> float:","def get_num_to_request():\n #ALLOWABLE_REQUEST_SIZES = [1, 3, 5, 8, 12]\n ALLOWABLE_REQUEST_SIZES = [1, 3, 5, 8]\n avgrate = jobtracker.query(\"SELECT AVG(files.size/\" \\\n \"(TO_SECONDS(download_attempts.updated_at)*1/86400. - \" \\\n \"TO_SECONDS(download_attempts.created_at)*1/86400.)) \" \\\n \"FROM files, download_attempts \" \\\n \"WHERE files.id=download_attempts.file_id \" \\\n \"AND download_attempts.status='downloaded'\", \\\n fetchone=True)\n avgsize = jobtracker.query(\"SELECT AVG(size/numrequested) FROM requests \" \\\n \"WHERE numbits=%d AND \" \\\n \"file_type='%s'\" % \\\n (config.download.request_numbits, \\\n config.download.request_datatype.lower()), \\\n fetchone=True)\n if avgrate is None or avgsize is None:\n return min(ALLOWABLE_REQUEST_SIZES)\n\n # Total number requested that can be downloaded per day (on average).\n max_to_request_per_day = avgrate/avgsize\n \n used = get_space_used()\n avail = get_space_available()\n reserved = get_space_committed()\n \n # Maximum number of bytes that we should request\n max_bytes = min([avail-reserved-config.download.min_free_space, \\\n config.download.space_to_use-reserved-used])\n # Maximum number to request\n max_num = max_bytes/avgsize\n\n ideal_num_to_request = min([max_num, max_to_request_per_day])\n\n if debug.DOWNLOAD:\n print \"Average dl rate: %.2f bytes/day\" % avgrate\n print \"Average size per request unit: %d bytes\" % avgsize\n print \"Max can dl per day: %d\" % max_to_request_per_day\n print \"Max num to request: %d\" % max_num\n print \"Ideal to request: %d\" % ideal_num_to_request\n\n # Return the closest allowable request size without exceeding\n # 'ideal_num_to_request'\n num_to_request = max([0]+[N for N in ALLOWABLE_REQUEST_SIZES \\\n if N <= ideal_num_to_request])\n\n return num_to_request","def add_link_capacity(self, path, bw):\n\n # PART 1, TASK 3.4 add bw to edges","def __best_units_derivation(searchable_rules, unit_routes, lhs_var, final_rhs):\n def get_prob(var, rhs):\n return 0.0 if (var not in searchable_rules) or (rhs not in searchable_rules[var]) \\\n else searchable_rules[var][rhs].probability\n best_route_prob = get_prob(lhs_var, final_rhs)\n best_route = [] if best_route_prob == 0.0 else [searchable_rules[lhs_var][final_rhs]]\n for full_route in unit_routes.get(lhs_var, []):\n curr_prob = 1.0\n for i in range(1, len(full_route)):\n prev_var = full_route[i - 1]\n next_var = full_route[i]\n curr_prob *= get_prob(prev_var, (next_var,))\n alt_prob = curr_prob * get_prob(next_var, final_rhs)\n if alt_prob > best_route_prob:\n best_route = [searchable_rules[full_route[j]][(full_route[j + 1],)]\n for j in range(i)]\n best_route.append(searchable_rules[full_route[i]][final_rhs])\n best_route_prob = alt_prob\n return best_route, best_route_prob","def compute_node_weight(walks):\n\n # Define a dict to count node occurrences\n count = {}\n # Float variable which will be the sum of all nodes\n sum = 0.0\n # The final list\n sorted_values_list = []\n\n # Browse each random walk realised\n for walk in walks:\n # Browse each node of a random walk\n for i in walk:\n # Do +1 if the node is already in dict\n if i in count.keys():\n count[i] = count[i] + 1.0\n # Insert nodes as key and 0 as the value it is not in dict\n else:\n count[i] = 0\n\n # Store the sum of all nodes values (number of time each node has been selected by the RWR) in the sum variable\n for val in count.values():\n sum = sum + val\n\n # Replace value of nodes by the ratio of the number of times a node has been selected to the total nodes selected\n for i in count:\n count[i] = count[i] / sum\n\n # Insert each node ratio in a list sorted by nodes (from 0 to n)\n for i in range(0, max(count.keys()) + 1):\n sorted_values_list.append(count[i])\n\n return sorted_values_list","def general_stats():\n\n setproctitle(f\"RNANet statistics.py general_stats()\")\n\n reqs = [\n # unique unmapped chains with no issues\n \"\"\" SELECT distinct pdb_id, chain_name, exp_method, resolution\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\n WHERE rfam_acc = 'unmappd' AND ISSUE=0;\"\"\",\n\n # unique mapped chains with no issues\n \"\"\" SELECT distinct pdb_id, chain_name, exp_method, resolution\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\"\"\",\n\n # mapped chains with no issues\n \"\"\" SELECT pdb_id, chain_name, inferred, rfam_acc, pdb_start, pdb_end, exp_method, resolution\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\"\"\",\n\n # mapped chains with no issues that are all inferred\n \"\"\" SELECT DISTINCT pdb_id, c.chain_name, exp_method, resolution\n FROM (\n SELECT inferred, rfam_acc, pdb_start, pdb_end, chain.structure_id, chain.chain_name, r.redundancy, r.inf_redundancy\n FROM chain \n JOIN (SELECT structure_id, chain_name, COUNT(distinct rfam_acc) AS redundancy, SUM(inferred) AS inf_redundancy \n FROM chain \n WHERE rfam_acc != 'unmappd' AND issue=0 \n GROUP BY structure_id, chain_name\n ) AS r ON chain.structure_id=r.structure_id AND chain.chain_name = r.chain_name \n WHERE r.redundancy=r.inf_redundancy AND rfam_acc != 'unmappd' and issue=0\n ) AS c\n JOIN structure ON c.structure_id=structure.pdb_id;\"\"\",\n\n # Number of mapped chains (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\"\"\",\n\n # Number of unique mapped chains (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\"\"\",\n\n # Number of mapped chains (inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\"\"\",\n\n # Number of unique mapped chains (inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\"\"\",\n\n # Number of mapped chains inferred once\n \"\"\"SELECT count(*) FROM (\n SELECT structure_id, chain_name, COUNT(DISTINCT rfam_acc) as c \n FROM chain where rfam_acc!='unmappd' and inferred=1 \n GROUP BY structure_id, chain_name\n ) WHERE c=1;\"\"\",\n\n # Number of mapped chains inferred twice\n \"\"\"select count(*) from (\n select structure_id, chain_name, count(distinct rfam_acc) as c \n from chain where rfam_acc!='unmappd' and inferred=1 \n group by structure_id, chain_name\n ) where c=2;\"\"\",\n\n # Number of mapped chains inferred 3 times or more\n \"\"\"select count(*) from (\n select structure_id, chain_name, count(distinct rfam_acc) as c \n from chain where rfam_acc!='unmappd' and inferred=1 \n group by structure_id, chain_name\n ) where c>2;\"\"\",\n\n # Number of chains both mapped with and without inferrence\n \"\"\" SELECT COUNT(*) FROM (\n SELECT structure_id, chain_name, sum(inferred) AS s, COUNT(rfam_acc) AS c \n FROM chain \n WHERE rfam_acc!='unmappd' \n GROUP BY structure_id, chain_name\n ) \n WHERE s < c AND s > 0;\"\"\",\n \n # Number of mapped chains (total)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\"\"\",\n\n # Number of unique mapped chains\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\"\"\",\n\n # Number of unmapped chains\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd');\"\"\",\n \n # Number of mapped chains without issues (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\"\"\",\n\n # Number of unique mapped chains without issues (not inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\"\"\",\n\n # Number of mapped chains without issues (inferred)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\"\"\",\n\n # Number of unique mapped chains without issues (inferred)\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\"\"\",\n\n # Number of mapped chains without issues (total)\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\"\"\",\n\n # Number of unique mapped chains without issues\n \"\"\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\"\"\",\n\n # Number of unmapped chains without issues\n \"\"\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd' AND issue=0);\"\"\"\n ]\n\n answers = []\n with sqlite3.connect(runDir + \"/results/RNANet.db\") as conn:\n conn.execute('pragma journal_mode=wal')\n for r in reqs:\n answers.append(pd.read_sql(r, conn))\n df_unique = answers[0]\n df_mapped_unique = answers[1]\n df_mapped_copies = answers[2]\n df_inferred_only_unique = answers[3]\n print()\n print(\"> found\", answers[4].iloc[0][0], f\"chains ({answers[5].iloc[0][0]} unique chains) that are mapped thanks to Rfam. Removing chains with issues, only {answers[15].iloc[0][0]} ({answers[16].iloc[0][0]} unique)\")\n if answers[4].iloc[0][0] != answers[5].iloc[0][0]:\n print(\"\\t> This happens because different parts of the same chain can be mapped to different families.\")\n print(\"> found\", answers[6].iloc[0][0], f\"chains ({answers[7].iloc[0][0]} unique chains) that are mapped by inferrence. Removing chains with issues, only {answers[17].iloc[0][0]} ({answers[18].iloc[0][0]} unique).\")\n print(\"\\t> \", answers[8].iloc[0][0], \"chains are mapped only once,\")\n print(\"\\t> \", answers[9].iloc[0][0], \"are mapped to 2 families,\")\n print(\"\\t> \", answers[10].iloc[0][0], \"are mapped to 3 or more.\")\n print(\"> Among them,\", answers[11].iloc[0][0], \"chains are mapped both with families found on Rfam and by inferrence.\")\n if answers[11].iloc[0][0]:\n print(\"\\t> this is normal if you used option -f (--full-inference). Otherwise, there might be a problem.\")\n print(\"> TOTAL:\", answers[12].iloc[0][0], f\"chains ({answers[13].iloc[0][0]} unique chains) mapped to a family. Removing chains with issues, only {answers[19].iloc[0][0]} ({answers[20].iloc[0][0]} unique).\")\n print(\"> TOTAL:\", answers[14].iloc[0][0], f\"unmapped chains. Removing chains with issues, {answers[21].iloc[0][0]}.\")\n if answers[14].iloc[0][0]:\n print(\"\\t> this is normal if you used option --no-homology. Otherwise, there might be a problem.\")\n print()\n\n ##########################################\n # plot N = f(resolution, exp_method)\n ##########################################\n\n methods = df_unique.exp_method.unique()\n\n fig, axs = plt.subplots(1+len(methods), 3, figsize=(15,5*(1+len(methods))), sharex=True)\n df_unique.sort_values('resolution', inplace=True, ignore_index=True)\n df_mapped_unique.sort_values('resolution', inplace=True, ignore_index=True)\n df_inferred_only_unique.sort_values('resolution', inplace=True, ignore_index=True)\n df_mapped_copies.sort_values('resolution', inplace=True, ignore_index=True)\n max_res = max(df_unique.resolution)\n max_structs = max(len(df_mapped_copies.index), len(df_unique.index))\n colors = np.linspace(0,1,1+len(methods))\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\n\n axs[0][0].grid(axis='y', ls='dotted', lw=1)\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\n axs[0][0].text(0.95*max_res, 0.95*len(df_unique.resolution), \"%d \" % len(df_unique.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0][0].set_ylabel(\"ALL\", fontsize=14)\n axs[0][0].set_title(\"Number of unique RNA chains\", fontsize=14)\n axs[0][0].set_ylim((0, max_structs * 1.05))\n axs[0][0].legend(loc=\"lower right\", fontsize=14)\n\n axs[0][1].grid(axis='y', ls='dotted', lw=1)\n axs[0][1].set_yticklabels([])\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\n axs[0][1].hist(df_inferred_only_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='only by inference')\n axs[0][1].text(0.95*max_res, 0.95*len(df_mapped_unique.resolution), \"%d \" % len(df_mapped_unique.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0][1].set_title(r\"Number of unique RNA chains\\nmapped to $\\geq 1$ family\", fontsize=14)\n axs[0][1].set_ylim((0, max_structs * 1.05))\n axs[0][1].legend(loc=\"upper left\", fontsize=14)\n\n axs[0][2].grid(axis='y', ls='dotted', lw=1)\n axs[0][2].set_yticklabels([])\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\n axs[0][2].hist(df_mapped_copies[df_mapped_copies.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='inferred')\n axs[0][2].text(0.95*max_res, 0.95*len(df_mapped_copies.resolution), \"%d \" % len(df_mapped_copies.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0][2].set_title(\"Number of RNA chains mapped to a\\nfamily (with copies)\", fontsize=14)\n axs[0][2].legend(loc=\"upper left\", fontsize=14)\n axs[0][2].set_ylim((0, max_structs * 1.05))\n\n for i,m in enumerate(methods):\n df_unique_m = df_unique[df_unique.exp_method == m]\n df_mapped_unique_m = df_mapped_unique[df_mapped_unique.exp_method == m]\n df_inferred_only_unique_m = df_inferred_only_unique[df_inferred_only_unique.exp_method == m]\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m]\n max_structs = max(len(df_mapped_copies_m.index), len(df_unique_m.index))\n print(\"> found\", max_structs, \"structures with method\", m, flush=True)\n\n axs[1+i][0].grid(axis='y', ls='dotted', lw=1)\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\n axs[1+i][0].text(0.95*max_res, 0.95*len(df_unique_m.resolution), \"%d \" % len(df_unique_m.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i][0].set_ylim((0, max_structs * 1.05))\n axs[1+i][0].set_ylabel(m, fontsize=14)\n axs[1+i][0].legend(loc=\"lower right\", fontsize=14)\n\n axs[1+i][1].grid(axis='y', ls='dotted', lw=1)\n axs[1+i][1].set_yticklabels([])\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\n axs[1+i][1].hist(df_inferred_only_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='only by inference')\n axs[1+i][1].text(0.95*max_res, 0.95*len(df_mapped_unique_m.resolution), \"%d \" % len(df_mapped_unique_m.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i][1].set_ylim((0, max_structs * 1.05))\n axs[1+i][1].legend(loc=\"upper left\", fontsize=14)\n \n axs[1+i][2].grid(axis='y', ls='dotted', lw=1)\n axs[1+i][2].set_yticklabels([])\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\n axs[1+i][2].hist(df_mapped_copies_m[df_mapped_copies_m.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='inferred')\n axs[1+i][2].text(0.95*max_res, 0.95*len(df_mapped_copies_m.resolution), \"%d \" % len(df_mapped_copies_m.resolution), \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i][2].set_ylim((0, max_structs * 1.05))\n axs[1+i][2].legend(loc=\"upper left\", fontsize=14)\n \n axs[-1][0].set_xlabel(\"Structure resolution\\n(Angströms, lower is better)\", fontsize=14)\n axs[-1][1].set_xlabel(\"Structure resolution\\n(Angströms, lower is better)\", fontsize=14)\n axs[-1][2].set_xlabel(\"Structure resolution\\n(Angströms, lower is better)\", fontsize=14)\n\n fig.suptitle(\"Number of RNA chains by experimental method and resolution\", fontsize=16)\n fig.subplots_adjust(left=0.07, right=0.98, wspace=0.05, \n hspace=0.05, bottom=0.05, top=0.92)\n fig.savefig(runDir + \"/results/figures/resolutions.png\")\n plt.close()\n\n ##########################################\n # plot Nfam = f(resolution, exp_method)\n ##########################################\n\n df_mapped_copies['n_fam'] = [ len(df_mapped_copies.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies.index)) ]\n\n fig, axs = plt.subplots(1, 1+len(methods), figsize=(5*(1+len(methods)), 5))\n max_res = max(df_mapped_copies.resolution)\n max_fams = max(df_mapped_copies.n_fam)\n colors = np.linspace(0,1,1+len(methods))\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\n\n axs[0].grid(axis='y', ls='dotted', lw=1)\n axs[0].plot(df_mapped_copies.resolution, df_mapped_copies.n_fam)\n axs[0].text(0.95*max_res, 0.95*df_mapped_copies.n_fam.iloc[-1], \"%d \" % df_mapped_copies.n_fam.iloc[-1], \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[0].set_title(\"ALL\", fontsize=14)\n axs[0].set_xlabel(\"Structure resolution (Angströms)\", fontsize=14)\n axs[0].set_ylabel(\"Number of Rfam families\", fontsize=14)\n axs[0].set_ylim((0, max_res * 1.05))\n axs[0].set_ylim((0, max_fams * 1.05))\n \n for i,m in enumerate(methods):\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m].drop(\"n_fam\", axis=1).copy()\n df_mapped_copies_m['n_fam'] = [ len(df_mapped_copies_m.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies_m.index)) ]\n print(\">\", df_mapped_copies_m.n_fam.iloc[-1], \"different RNA families have a 3D structure solved by\", m)\n\n axs[1+i].grid(axis='y', ls='dotted', lw=1)\n axs[1+i].plot(df_mapped_copies_m.resolution, df_mapped_copies_m.n_fam, )\n axs[1+i].text(0.95*max(df_mapped_copies_m.resolution), 0.95*df_mapped_copies_m.n_fam.iloc[-1], \"%d \" % df_mapped_copies_m.n_fam.iloc[-1], \n horizontalalignment='right', verticalalignment='top', fontsize=14)\n axs[1+i].set_xlim((0, max_res * 1.05))\n axs[1+i].set_ylim((0, max_fams * 1.05))\n axs[1+i].set_xlabel(\"Structure resolution (Angströms)\", fontsize=14)\n axs[1+i].set_title(m, fontsize=14)\n axs[1+i].set_yticklabels([])\n \n fig.suptitle(\"Number of RNA families used by experimental method and resolution\", fontsize=16)\n fig.subplots_adjust(left=0.05, right=0.98, wspace=0.05, \n hspace=0.05, bottom=0.12, top=0.84)\n fig.savefig(runDir + \"/results/figures/Nfamilies.png\")\n plt.close()","def calculateCosts(self):\n self.costs = 0\n for house in self.houses:\n if not house.distance == 1000:\n self.costs += house.distance * 9\n for battery in self.batteries:\n self.costs += battery.costs\n return self.costs","def _cost_route_fine(self):\n return self.fine","def cost(distance, highway, bicycle, incline, preferences):\n\n #unpack preferences\n (flatness_pref, bicycle_pref, distance_pref,\n motorway_pref, highway_pref, residential_pref) = preferences\n multiplier = 1 + bike_multiplier(bicycle, bicycle_pref) + road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref)\n if multiplier <= 0:\n multiplier = 0.01\n incl = incline_multiplier(float(incline))*flatness_pref\n cost = float(distance) * multiplier + incl\n if cost <= 0:\n cost = 0.01\n return cost","def cost(self):\n cost = 0\n for battery in self.grid.batteries:\n for house in battery.connections:\n cost += house.distances[house.connection] * 9\n cost += battery.cost\n return cost","def total_cost(self, system=None):\n system = system or self.system()\n if system == 'grid':\n cost = self['system (grid)']['internal system nodal cost']\n else:\n cost = self['system (%s)' % system]['system nodal cost']\n cost = float(cost)\n return cost","def update_cost(self, id):\n cost = 0\n for i, [source, sinks] in enumerate(self.nets):\n if id == source:\n self.costs[i] = self.calc_half_perimeter(source, sinks)\n cost += self.costs[i]\n elif id in sinks:\n self.costs[i] = self.calc_half_perimeter(source, sinks)\n cost += self.costs[i]\n else:\n cost += self.costs[i]\n\n self.cost = cost\n return True","def compute_optimalReward(task):\n\n\tT = 15.0\n\tweights = 0\n\tif task == TABLE_TASK or task == COFFEE_TASK:\n\t\tweights = 1\n\telif task == LAPTOP_TASK:\n\t\tweights = 10\n\n\t# initialize start/goal based on task \n\tif task == COFFEE_TASK or task == HUMAN_TASK:\n\t\tpick = pick_shelf\n\telse:\n\t\tpick = pick_basic\n\n\tif task == LAPTOP_TASK:\n\t\tplace = place_higher\n\telse:\n\t\tplace = place_lower\n\t\t\n\tstartRad = np.array(pick)*(math.pi/180.0)\n\tgoalRad = np.array(place)*(math.pi/180.0)\n\tstart = startRad\n\tgoal = goalRad\n\n\tplan = Planner(task)\t\n\tfilename = None\n\tif task == 1:\n\t\tfilename = \"task1.csv\"\n\telif task == 2:\n\t\tfilename = \"task2.csv\"\n\telif task == 3:\n\t\tfilename = \"task3.csv\"\n\t\t\n\t# get optimal waypts from file\n\twaypts = get_opt_waypts(filename)\n\tr = plan.featurize(waypts)\n\tRvel = r[0]\n\tRfeat = np.sum(r[1])\n\n\tplan.kill_planner()\n\treturn (Rvel, Rfeat)","def total_cost(path: Path) -> float:\n\t\n\tdistance = calc_total_dist(path)\n\tavg_speed = calc_average_speed(path)\n\t\n\t# Speed is less important, but gets a huge multiplier, because speed and\n\t# \tdistance are in different units. Speed requires a high ratio to have\n\t# \tsimilar amounts of variation.\n\tSPEED_DISTANCE_COST_RATIO = 7865.099\n\t\n\treturn (\n\t\t(distance * 1) +\n\t\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\n\t)","def GetPathCost(self, bucketOfActions):","def compute_network_load_and_bottleneck_workload(env: ControlledRandomWalk) \\\n -> Tuple[np.ndarray, np.ndarray, np.ndarray, List]:\n xi = cvx.Variable((env.num_buffers, 1))\n nu = cvx.Variable((env.num_resources, 1))\n objective = cvx.Maximize(xi.T * env.job_generator.demand_rate)\n constraints = [\n -env.job_generator.buffer_processing_matrix.T * xi - env.constituency_matrix.T * nu\n <= np.zeros((env.num_activities, 1)),\n np.ones((env.num_resources, 1)).T * nu <= 1,\n nu >= np.zeros((env.num_resources, 1))\n ]\n prob = cvx.Problem(objective, constraints)\n network_load = prob.solve(solver=cvx.CPLEX)\n return network_load, xi, nu, constraints","def Option3_routing(self, S, D, L):\n if self.has_path(S, D): \n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \n Opt_path = Shortest_path\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\n return path_cost_with_concave_function, Opt_path\n while len(Shortest_path) != 0:\n path_cost = self.additive_path_cost(Shortest_path, 'w') \n #self.logger.info('Path cost - %d', path_cost)\n if path_cost <= L:\n \"\"\"go to path cost with weighted sum\"\"\"\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\n self.G = self.rm_edge_constraint(path_cost_with_concave_function) # remove all links where the concave link is greater than PathConcave_cost \n Opt_path = Shortest_path\n if self.has_path(S, D):\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\n else:\n Shortest_path = [] \n else:\n break \n else:\n self.logger.info('No path from %s to %s', S, D)\n Opt_path = []\n path_cost_with_concave_function = 0\n return path_cost_with_concave_function, Opt_path","def _calc_desc_and_queues(\n total_numa_nodes, total_ports_per_numa, total_rx_queues, ports_per_numa_value\n ):\n\n # Get the number of rx queues\n rx_queues = max(1, total_rx_queues)\n tx_queues = rx_queues * total_numa_nodes + 1\n\n # Get the descriptor entries\n desc_entries = 1024\n ports_per_numa_value[\"rx_queues\"] = rx_queues\n total_mbufs = (\n (rx_queues * desc_entries) + (tx_queues * desc_entries)\n ) * total_ports_per_numa\n\n return total_mbufs","def work(params) -> Union[None, float]:\n try:\n # either HTTP or bindings\n if host:\n path = action if action == \"route\" else \"sources_to_targets\"\n params_str = delimit_tuple(\n tuple((delimit_tuple(x) for x in params)), delimiter=\";\"\n )\n route = requests.get(f\"{host}/{path}/v1/driving/{params_str}\")\n else:\n route = router.route(params) if action == \"route\" else None\n except (RuntimeError, requests.exceptions.BaseHTTPError):\n return None\n\n if (\n random() > 0.95\n ): # assume that large number of routes will be tested, only print sample in debug mode\n LOGGER.debug(f\"Calculated route between {params[0]} and {params[1]}\")\n\n if report:\n result = route.json()\n if action == \"route\":\n try:\n dist = sum([x[\"distance\"] for x in result[\"routes\"]])\n except KeyError:\n LOGGER.critical(\n f\"No route was found from {params[0]} to {params[1]}. \"\n f\"Try regenerating the locations or specify a more narrow bounding box.\"\n )\n return None\n else:\n dists = [\n inner[\"distance\"]\n for outer in route[\"sources_to_targets\"]\n for inner in outer\n ]\n dist: float = mean(filter(lambda x: x is not None, dists))\n\n return dist","def route_info(self, route):\r\n total_distance = 0\r\n cost_mult = 0.35\r\n cost = 0\r\n time = 0\r\n if route[0] in self.edges:\r\n for i in range(len(route) - 1):\r\n for edge in self.edges[route[i]]:\r\n if edge.destination == route[i + 1]:\r\n total_distance += edge.distance\r\n cost += cost_mult * edge.distance\r\n time += self.calc_time(edge.distance)\r\n outgoing = len(self.edges[edge.destination])\r\n # if this airport is not the last one since we don't need to calculate layover for last\r\n if i is not len(route) - 2:\r\n time += 2 - ((1 / 6) * (outgoing - 1))\r\n if cost_mult > 0:\r\n cost_mult -= 0.05\r\n break;\r\n else:\r\n if edge == self.edges[route[i]][-1]:\r\n return\r\n return total_distance, round(cost, 2), round(time, 2)","def check_path_availability(self, path, bandwidth):\n total = 0\n for endpoint_a, endpoint_b in zip(path[:-1], path[1:]):\n link = Link(Endpoint(endpoint_a[:23], endpoint_a[24:]),\n Endpoint(endpoint_b[:23], endpoint_b[24:]),\n bandwidth)\n avail = self.check_link_availability(link)\n if avail is None:\n return None\n total += avail\n return total","def dist_cost(s_vr, failed_vr, neighbor_vr, dist_matrix, w_a1, w_a2):\n #print s_vr, failed_vr, neighbor_vr\n dist_i_f = dist_matrix[s_vr][failed_vr + 1]\n dist_i_k = dist_matrix[s_vr][neighbor_vr + 1]\n dist = w_a1 * float(dist_i_f) + w_a2 * float(dist_i_k)\n #print \"d_i_f: \", dist_i_f, \", dist_i_k: \", dist_i_k\n return dist","def test_network_calculate_variables(request):\n print(\"\\n--Starting:\", request.node.name)\n\n net = ModelRoadwayNetwork.read(\n link_file=STPAUL_LINK_FILE,\n node_file=STPAUL_NODE_FILE,\n shape_file=STPAUL_SHAPE_FILE,\n fast=True,\n )\n net.calculate_county()\n print(\"County Frequency\")\n print(net.links_df[\"county\"].value_counts())\n\n net.calculate_mpo()\n print(\"MPO Frequency\")\n print(net.links_df[\"mpo\"].value_counts())\n ## todo write an assert that actually tests something","def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\n pass"],"string":"[\n \"def calc_slow(self, demands: Demand, routing: Routing) -> float:\\n edge_capacities = [e[2]['weight'] for e in\\n sorted(self.graph.edges(data=True))]\\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\\n # Because utilisation compared to link width is what we care about here\\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\\n\\n return np.max(ratio_capacities)\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\\n # set availbandwidth to the maximal value\\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\\n if d.type == 'STATIC':\\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\\n # subtract the reserved link and internal (inside Infras) bandwidth\\n if mode == self.MODE_ADD:\\n for d in self.infras:\\n for p in d.ports:\\n for fr in p.flowrules:\\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\\n # Flowrules are cummulatively subtracted from the switching \\n # capacity of the node.\\n d.availres['bandwidth'] -= fr.bandwidth\\n if d.availres['bandwidth'] < 0:\\n raise RuntimeError(\\\"The node bandwidth of %s got below zero \\\"\\n \\\"during available resource calculation!\\\" %\\n d.id)\\n # Get all the mapped paths of all SGHops from the NFFG\\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\\n for sg_hop_id, data in sg_map.iteritems():\\n src, dst, flowclass, bandwidth, delay, path = data\\n if bandwidth is not None:\\n for link in path:\\n link.availbandwidth -= bandwidth\\n if link.availbandwidth < 0:\\n raise RuntimeError(\\n \\\"The link bandwidth of %s got below zero during\\\"\\n \\\"available resource calculation!\\\" % link.id)\",\n \"def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\\n dtype=float)\\n\\n for commodity_idx in range(len(self.commodities)):\\n utilisation = self.calc_demand(routing,\\n demands[commodity_idx],\\n commodity_idx)\\n total_utilisation += utilisation\\n\\n return np.max(np.divide(total_utilisation, self.edge_capacities))\",\n \"def compute_link_utilization_over_time(link_byte_counts):\\n def find_matching_iface_stats(byte_count, source_id, destination_id):\\n matching_stats = [d_i for d_i in byte_count\\n if d_i[\\\"sourceSwitchId\\\"] == source_id and\\n d_i[\\\"destinationSwitchId\\\"] == destination_id]\\n if len(matching_stats) != 1:\\n raise ValueError(\\\"Unexpected results in find_matching_iface_stats. \\\\\\n Found %d matching iface_stats\\\" % len(matching_stats))\\n return matching_stats[0]\\n\\n def compute_tx_rate(count_in_bytes):\\n return (count_in_bytes * 8) / 10.0**7\\n\\n # First compute the delta between the iface_stats in time_period t_i and the iface_stats\\n # in time period t_{i+1}.\\n # tx_rate_t: (source_id x destination_id) -> link_utilization_in_time_period_t forall. t\\n tx_rate_t = []\\n for t_0, t_1 in zip(link_byte_counts, link_byte_counts[1:]):\\n byte_count_delta_t = defaultdict(float)\\n for iface_stats in t_0:\\n source_id = iface_stats[\\\"sourceSwitchId\\\"]\\n destination_id = iface_stats[\\\"destinationSwitchId\\\"]\\n t_0_count = iface_stats[\\\"bytesSent\\\"] + iface_stats[\\\"bytesReceived\\\"]\\n try:\\n t_1_stats = find_matching_iface_stats(t_1, source_id, destination_id)\\n t_1_count = t_1_stats[\\\"bytesSent\\\"] + t_1_stats[\\\"bytesReceived\\\"]\\n except ValueError:\\n t_1_count = t_0_count\\n\\n count_delta = t_1_count - t_0_count\\n link_key = compute_link_key(source_id, \\n destination_id)\\n byte_count_delta_t[link_key] += count_delta\\n\\n tx_rate_t.append({the_link_key: compute_tx_rate(byte_count_t) \\n for the_link_key, byte_count_t in byte_count_delta_t.items()})\\n return tx_rate_t\",\n \"def compute_path_metric(self, sw, path, util, time_now, local_contrib):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n # Use the last-learned-via-sync value for a link\\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\\n used1 = self.graph[u][v]['sync_learned'] + util\\n used2 = self.graph[u][v]['used'] + util\\n # ['used'] is a strict lower bound for ['sync_learned']\\n if used1 > used2: \\n used = used1\\n logging.debug(\\\"CS [%s] using sync_learned value 1 [%f]\\\", str(self.name), used1)\\n else:\\n used = used2\\n logging.debug(\\\"CS [%s] using sync_learned value 2 [%f]\\\", str(self.name), used2)\\n else:\\n logging.debug(\\\"CS [%s] using tracking value\\\", str(self.name))\\n used = self.graph[u][v]['used'] + util\\n\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def calc_cost(self):\\n cost = 0\\n for i,[source, sinks] in enumerate(self.nets):\\n self.costs[i] = self.calc_half_perimeter(source, sinks)\\n cost += self.costs[i]\\n self.cost = cost\\n return True\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def compute_path_metric(self, sw, path, util, time_now):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\\n #only include extra-domain state when not stale (timestamp), 3) always exclude\\n #extra-domain state when calculating the path metric? Here we do (1)\\n used = self.graph[u][v]['used'] + util\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def _calculate_costs(self):\\n cost = 0\\n cost += self._cost_route_fine()\\n cost += self._cost_petrol()\\n cost += self._cost_wage()\\n cost += self._cost_refueling()\\n cost += self._cost_caught_by_police()\\n cost += self._cost_vehicle_malfunction()\\n return cost\",\n \"def cost(route):\\n cost = 0\\n for li in route:\\n if cost<li.get_cost():\\n cost=li.get_cost()\\n return cost\",\n \"def calc_demand(self, routing: np.ndarray, demand: float,\\n commodity_idx: int) -> np.ndarray:\\n commodity = self.commodities[commodity_idx]\\n node_flow = np.zeros(self.num_nodes)\\n node_flow[commodity[0]] = demand\\n\\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\\n for edge_idx, edge in enumerate(self.edges):\\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\\n\\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\\n\\n num_steps = 0\\n while True:\\n change = np.multiply(split_matrix, node_flow)\\n edge_utilisation += change\\n node_flow = np.matmul(split_matrix, node_flow)\\n if np.any(np.isnan(change)):\\n print(\\\"is_nan :'(\\\")\\n comparison = np.less(np.nan_to_num(change), self.min_delta)\\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\\n break\\n num_steps += 1\\n # if we take more than |E| steps we have cycles which is not good.\\n # Therefore: end here with really bad reward, scaled by number of\\n # cycles\\n if num_steps > routing.shape[1]:\\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\\n edge_utilisation += np.multiply(remaining_flow, np.full(\\n (self.num_nodes, self.num_nodes), demand))\\n break\\n\\n return edge_utilisation\",\n \"def rate(way):\\n cost = 0\\n for i in range(len(way)-1):\\n cost += DISTANCES[way[i]][way[i+1]]\\n return cost\",\n \"def astar_heuristic(n1, n2):\\n average_speed = 70\\n return edge_weight(n1, n2, 70)\",\n \"def route_cost(self, route):\\n total_weight = 0\\n c = 0\\n start = route[0]\\n for end in route[1:]:\\n y = float(self.stars[start][end]['weight']) - c\\n t = total_weight + y\\n c = (t - total_weight) - y\\n\\n total_weight = t\\n\\n start = end\\n return total_weight\",\n \"def cost(self, route: List[int]) -> float:\\n raise NotImplementedError\",\n \"def build_links_capacity(self):\\n\\n links_capacity = {}\\n # Iterates all the edges in the topology formed by switches\\n for src, dst in self.topo.keep_only_p4switches().edges:\\n bw = self.topo.edges[(src, dst)]['bw']\\n # add both directions\\n links_capacity[(src, dst)] = bw\\n links_capacity[(dst, src)] = bw\\n\\n return links_capacity\",\n \"def caculate_network_statistics(self):\\n divide_factor_sum = 0 \\n for key in self.stars.keys():\\n star = self.stars[key]\\n if star.nb_num == 0 :\\n self.standalone_star_num += 1 \\n\\n divide_factor = star.nb_num + 2 * (star.spec_num - star.shared_spec_num )/self.ave_starlet_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.star_divide_factor_dist[divide_factor_int] = self.star_divide_factor_dist.get(divide_factor_int,0) + 1\\n if star.spec_num < star.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + star.id + \\\" \\\" + str(star.spec_num) + \\\"is less than\\\" + str(star.shared_spec_num))\\n if star.spec_num > star.shared_spec_num:\\n self.star_lost_spec_num += star.spec_num - star.shared_spec_num\\n self.ave_divide_factor_star = divide_factor_sum/self.stars_length\\n\\n divide_factor_sum = 0 \\n for key in self.starlets.keys():\\n starlet = self.starlets[key]\\n if starlet.nb_num == 0 :\\n self.standalone_starlet_num += 1 \\n\\n divide_factor = starlet.nb_num + 2 * (starlet.spec_num - starlet.shared_spec_num )/self.ave_star_size\\n divide_factor_sum += divide_factor\\n divide_factor_int = round(divide_factor)\\n self.starlet_divide_factor_dist[divide_factor_int] = self.starlet_divide_factor_dist.get(divide_factor_int,0) + 1\\n if starlet.spec_num < starlet.shared_spec_num:\\n print(\\\"!!!!!!!!!!!!Becareful, total spectra No is less than Shared Spectra with starlets\\\")\\n print(\\\"with star \\\" + starlet.id + \\\" \\\" + str(starlet.spec_num) + \\\"is less than\\\" + str(starlet.shared_spec_num))\\n if starlet.spec_num > starlet.shared_spec_num:\\n self.starlet_lost_spec_num += starlet.spec_num - starlet.shared_spec_num\\n self.ave_divide_factor_starlet = divide_factor_sum/self.starlets_length\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def search_optimal_capacities(network, step_size, tolerance, filename):\\r\\n ## Initialization\\r\\n # Initialize the value of total flow over the network\\r\\n totalflow = max(network.lb_totalflow, step_size)\\r\\n \\r\\n # An auxiliary threshold of the total flow computed based on the capacity upper bounds, used in Line 4 of Algorithm 3.\\r\\n aux_bound = 1 - np.exp(network.beta - network.b + network.phi/network.u)\\r\\n \\r\\n \\r\\n # Initialize the bounds for flow over each route\\r\\n ub_flow = np.zeros(network.num_routes)\\r\\n lb_flow = np.zeros(network.num_routes)\\r\\n \\r\\n # Initialize the optimal solution over the network\\r\\n opt_socialwelfare = np.array([])\\r\\n opt_totalflow = 0\\r\\n opt_flows = np.array([])\\r\\n opt_capacity = np.zeros(network.num_routes)\\r\\n \\r\\n\\r\\n# # For debugging only\\r\\n# lower_bound = np.zeros(network.num_routes)\\r\\n# upper_bound = np.zeros(network.num_routes)\\r\\n# count = 0\\r\\n \\r\\n # Try to plot out the (totalflow, social_welfare) scatter plot\\r\\n z = []\\r\\n hz = []\\r\\n# # End of debugging\\r\\n\\r\\n ## Start the search\\r\\n while totalflow < 1 - tolerance:\\r\\n flag_nofeasibleflow = False\\r\\n \\r\\n # Compute the bounds for the flow.\\r\\n for i in range(network.num_routes):\\r\\n # Line 3-8 of Algorithm 3. Compute the upper bounds for the flow.\\r\\n if totalflow >= aux_bound[i]: \\r\\n x3_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 3) \\r\\n if x3_star > network.u[i]:\\r\\n flag_nofeasibleflow = True\\r\\n break \\r\\n else:\\r\\n ub_flow[i] = x3_star \\r\\n else: \\r\\n ub_flow[i] = 1 \\r\\n # Line 9-10 of Algorithm 3. Compute the lower bounds of the flow.\\r\\n x1_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 1)\\r\\n x2_star = bisection_search(zeta, 0, 1, [tolerance, tolerance], True, network, totalflow, i, 2)\\r\\n lb_flow[i] = max(x1_star, x2_star)\\r\\n \\r\\n \\r\\n if not flag_nofeasibleflow:\\r\\n # Check feasibility of the flow based on the current total flow, lower and upper bounds of the flow\\r\\n if totalflow < np.sum(lb_flow) or totalflow > np.sum(ub_flow): \\r\\n totalflow += step_size \\r\\n\\r\\n# # For debugging only\\r\\n# print(\\\"\\\\nThe current total flow is: \\\" + str(totalflow))\\r\\n# print(\\\"\\\\nThe capacity upper bound when optimal flow is found: \\\")\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\nThe capacity lower bound when optimal flow is found: \\\")\\r\\n# print(lower_bound)\\r\\n# print(str(count))\\r\\n# # Eng of debugging\\r\\n# \\r\\n continue\\r\\n \\r\\n # The implementation of line 11 to 18. Find the optimal flow given the current value of z.\\r\\n [opt_obj, opt_x] = ip.max_sum_xlogx(network.num_routes, totalflow, lb_flow, ub_flow) \\r\\n \\r\\n \\r\\n # Line 18 of Algorithm 3. Compute the social welfare given the current z and optimal q(z).\\r\\n temp = opt_obj - totalflow * np.log(1-totalflow)\\r\\n\\r\\n ##### Testing: to plot out the function of h(z)\\r\\n z.append(totalflow)\\r\\n hz.append(temp)\\r\\n ##### End of Testing: to plot out the function of h(z)\\r\\n \\r\\n if opt_socialwelfare.size == 0 or temp > opt_socialwelfare:\\r\\n opt_socialwelfare = temp\\r\\n opt_flows = opt_x\\r\\n opt_totalflow = totalflow \\r\\n \\r\\n # For debugging only\\r\\n# print(\\\"\\\\nUpdate optimal flow\\\")\\r\\n# print(opt_x)\\r\\n# print(lb_flow)\\r\\n# print(ub_flow)\\r\\n# print(\\\"Total flow is \\\" + str(opt_totalflow)) \\r\\n \\r\\n # For debugging\\r\\n# np.copyto(lower_bound, lb_flow) \\r\\n# np.copyto(upper_bound, ub_flow) \\r\\n# count += 1\\r\\n# print(\\\"The lower and upper bounds are: \\\")\\r\\n# print(lb_flow)\\r\\n# print(lower_bound)\\r\\n# print(\\\"\\\\n\\\")\\r\\n# print(ub_flow)\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\n\\\")\\r\\n \\r\\n totalflow += step_size \\r\\n\\r\\n \\r\\n \\r\\n# # For debugging only\\r\\n# print(\\\"\\\\n----------------\\\\n Exiting the while loop.\\\")\\r\\n# print(\\\"\\\\nThe capacity upper bound when optimal flow is found: \\\")\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\nThe capacity lower bound when optimal flow is found: \\\")\\r\\n# print(lower_bound)\\r\\n# print(str(count)) \\r\\n# # Eng of debugging\\r\\n \\r\\n # Line 20 of ALgorithm 3\\r\\n if opt_flows.size > 0:\\r\\n network.update_flow(opt_flows) \\r\\n for i in range(network.num_routes): \\r\\n network.compute_capacity(opt_totalflow, i)\\r\\n opt_capacity[i] = network.capacity[i]\\r\\n print(\\\"\\\\n--------------\\\\nThe optimal flow is: \\\")\\r\\n print(opt_flows)\\r\\n print(\\\"\\\\n--------------\\\\nThe optimal parking capacity is: \\\")\\r\\n print(opt_capacity) \\r\\n print(\\\"\\\\n--------------\\\\nThe optimal total flow is \\\" + str(opt_totalflow))\\r\\n print(\\\"\\\\n--------------\\\\nThe maximum social welfare is \\\" + str(opt_socialwelfare) +\\\".\\\")\\r\\n \\r\\n \\r\\n ##### Testing: to plot out the function of h(z)\\r\\n #plt.scatter(z, hz, c='r', marker='r')\\r\\n plt.plot(z, hz, '-', linewidth=0.5)\\r\\n #plt.xlim(0.5, 1)\\r\\n plt.savefig(filename + '.png', bbox_inches='tight')\\r\\n ##### End of Testing: to plot out the function of h(z)\\r\\n \\r\\n \\r\\n \\r\\n# # For debugging\\r\\n# temp1 = np.zeros(network.num_routes)\\r\\n# temp2 = np.zeros(network.num_routes)\\r\\n# temp3 = np.zeros(network.num_routes)\\r\\n# for i in range(network.num_routes): \\r\\n# temp1[i] = zeta(network, i, opt_flows[i], opt_totalflow, 1)\\r\\n# temp2[i] = zeta(network, i, opt_flows[i], opt_totalflow, 2)\\r\\n# temp3[i] = zeta(network, i, opt_flows[i], opt_totalflow, 3)\\r\\n# print(\\\"The function value of zeta at the optimal flow: \\\")\\r\\n# print(temp1)\\r\\n# print(temp2)\\r\\n# print(temp3)\\r\\n# \\r\\n# # For debugging\\r\\n# print(\\\"\\\\nThe capacity upper bound when optimal flow is found: \\\")\\r\\n# print(upper_bound)\\r\\n# print(\\\"\\\\nThe capacity lower bound when optimal flow is found: \\\")\\r\\n# print(lower_bound)\\r\\n# print(str(count))\\r\\n# # End of debugging\\r\\n \\r\\n return opt_flows, opt_capacity, opt_socialwelfare \\r\\n else:\\r\\n print(\\\"\\\\nNo optimal solution is found!\\\")\\r\\n return np.array([]), opt_capacity, opt_socialwelfare\",\n \"def combined_costs(matrix_MSLL_IO):\\r\\n return\",\n \"def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\\n #print slink_dict\\n #print \\\"FIND\\\"\\n failed_dict = model.failed_dict\\n #print failed_dict, limit\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n bw_matrix = model.cost_dict['bw']\\n #cpu_vector = model.cost_dict['cpu']\\n selected_dict = {}\\n \\n # get aggregated residual bw for all substrate nodes, and store it as a list\\n snode_bw_list = total_bw(bw_matrix)\\n \\n # get total capacity and used bw for each snode\\n node_port_list, used_bw_list = total_port(model)\\n #vnet_set = model.vnets\\n sorted_vn = sort_vnet(model)\\n\\n #for vnet in vnet_set:\\n if w_m[2] >= 10*w_m[1]:\\n threshold = 0.8\\n else:\\n threshold = 0.8\\n snode_traffic = {}\\n for vn_traffic in sorted_vn:\\n vnet = vn_traffic[0]\\n failed_vr = failed_dict[vnet.vnet_id]\\n if failed_vr != -1: \\n # this node is failed\\n standby_list = vnet.get_standby_ids()\\n standby_cost = {}\\n for s_vr in standby_list:\\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\\n failed_node = vnet.vnodes[failed_vr]\\n vneighbors = failed_node.vneighbors\\n dist_k = 0\\n rtt_k = 0\\n for k in vneighbors:\\n dist_k += float(dist_matrix[s_vr][k + 1])\\n rtt_k += float(rtt_matrix[s_vr][k + 1])\\n\\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\\\\n w_b[1] * rtt_k\\n res_cost = snode_bw_list[s_vr]\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\\n standby_cost[s_vr] = total\\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\\n #print \\\"SORTED\\\", sorted_x\\n \\n for item in sorted_x:\\n if item[0] not in snode_traffic:\\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n else:\\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n #print utilization\\n # Link-Path selsection add-on\\n path_alloc = 1\\n for k in vneighbors:\\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\\n item[0] + 1, k + 1)\\n demand = demand_dict[demand_id]['capacity']\\n find, path = find_path(demand_path, demand_id, \\n slink_dict, demand) \\n if find == 0:\\n print \\\"No available path between svr and nbr on the substrate network\\\" \\n path_alloc = 0\\n #print \\\"FIND PATH\\\", find, path\\n # End link-path block \\n #print \\\"ALLOCATED: \\\", path_alloc\\n if path_alloc == 1:\\n if selected_dict.values().count(item[0]) < limit:\\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\\n if item[0] not in snode_traffic: \\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] = vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break;\\n else:\\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \\n if min_id == item[0]:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n #threshold = (threshold + 0.01)/2\\n break\\n elif utilization < threshold:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n if item[0] not in snode_traffic: \\n snode_traffic[item[0]] = vn_traffic[1]\\n else:\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break\\n else:\\n print \\\"does not satisfy the threshold\\\" \\n # if a svr is selected -- item[0]\\n \\n \\n \\n else:\\n print \\\"cannot allocate paths\\\"\\n \\n #print slink_dict \\n return selected_dict, slink_dict\",\n \"def bandwidth_share(self, nodes_efficiency: Dict[str, float]) -> Dict[str, float]:\\n pass\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def calculate_path_cost_with_weighted_sum(self, path, attr1, attr2): \\n costs = [] \\n for i in range(len(path) - 1):\\n a = (1- self.G[path[i]][path[i+1]][attr2]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \\n b = (1- self.G[path[i]][path[i+1]][attr1]) / (2 - self.G[path[i]][path[i+1]][attr1] - self.G[path[i]][path[i+1]][attr2]) \\n costs.append(a * self.G[path[i]][path[i+1]][attr1] + b * self.G[path[i]][path[i+1]][attr2]) \\n return max(costs)\",\n \"def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\\n model = copy.deepcopy(model_old)\\n \\n #cpu_vector = model.cost_dict['cpu']\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n #bw_matrix = model.cost_dict['bw']\\n w_a1, w_a2 = w_a\\n w_b1, w_b2 = w_b\\n theta1, theta2, theta3 = theta\\n # find total capacity and used bw on substrate nodes\\n node_port_list, used_bw_list = total_port(model)\\n #print \\\"CHECK POINT-1\\\", used_bw_list, node_port_list\\n vnet_info = model.get_vnet_info()\\n infeasible = 0\\n\\n fail_nodes = model.failed_dict\\n start_time = time.time()\\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n # random selection\\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n #print \\\"selection takes: \\\", time.time() - start_time\\n #print \\\"Selected\\\", select_dict\\n sum_cost_1_2 = 0\\n r_list = {}\\n \\n for node_id in range(0,len(used_bw_list)):\\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\\n #print \\\"INITIAL\\\", r_list\\n svr_subset = {}\\n for vnet in model.vnets:\\n j = vnet.vnet_id\\n f = fail_nodes[j]\\n # only count the failed virtual network\\n if f == -1:\\n pass\\n else:\\n for node_id in vnet_info[j]['standby']:\\n svr_subset[node_id] = r_list[node_id]\\n #print \\\"Subset SVR: \\\", svr_subset\\n \\n if j in select_dict:\\n #print \\\"FEASIBLE FOUND\\\"\\n #print vnet_info[j]['standby']\\n i = select_dict[j]\\n failed_node = vnet.vnodes[f]\\n vneighbors = failed_node.vneighbors\\n for k in vneighbors: \\n eta = operation_cost()\\n #print \\\"a1: \\\", w_a1, \\\"a2: \\\", w_a2, \\\"b1: \\\", w_b1, \\\"b2: \\\", w_b2\\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\\n rtt_c = rtt_cost(i, k, rtt_matrix)\\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\\n #find residual bw on substrate node\\n #xi = resource_cost(bw_matrix, i)\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n #util = req_bw / xi\\n #print req_bw, i, used_bw_list[i], node_port_list[i]\\n util = req_bw/node_port_list[i]\\n \\n if i not in r_list:\\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\\n else:\\n r_list[i] += util\\n svr_subset[i] = r_list[i]\\n #print sigma, \\\" v_\\\" + str(vnet.vnet_id) + \\\"_\\\" + str(f) + \\\"_\\\" + str(i) + \\\"_\\\" + str(k) + \\\"_\\\" + str(k)\\n else:\\n print \\\"INFEASIBLE at vnet: \\\", j\\n infeasible = 1\\n #print \\\"DONE\\\"\\n \\n if infeasible == 0:\\n #print svr_subset\\n max_util = max(svr_subset.values())\\n obj = sum_cost_1_2 + theta3 * max_util\\n else:\\n obj = \\\"infeasible\\\"\\n max_util = \\\"none\\\"\\n #print obj\\n used_time = time.time() - start_time\\n return obj, select_dict, max_util, used_time\",\n \"def utilization(self):\\n\\n counters = net_io_counters()\\n return LinuxNetworkMetrics._util_tuple(counters.bytes_recv,\\n counters.bytes_sent) # TODO max\\n # ethtool\",\n \"def calculate_cost(route, adjacency_matrix):\\n route_shifted = np.roll(route,1)\\n cost = np.sum(adjacency_matrix[route, route_shifted])\\n st_dev = np.std(adjacency_matrix[route, route_shifted])\\n return st_dev, cost\",\n \"def check_link_availability(self, link):\\n circuits = self.load_circuits()\\n total = 0\\n for circuit in circuits:\\n exists = circuit.get_link(link)\\n if exists:\\n total += exists.bandwidth\\n if total + link.bandwidth > 100000000000: # 100 Gigabits\\n return None\\n return total\",\n \"def opt(self, demands: Demand) -> float:\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('multicommodity_flow_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the splitting ratios for each edge\\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(self.num_edges):\\n flow_variable_edges.append(\\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Capacity constraint\\n capacity_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint between 0 and edge capacity\\n constraint_i = solver.Constraint(\\n 0, self.graph.get_edge_data(*edge)['weight'],\\n '(1,{},{})'.format(*edge))\\n for j, commodity in enumerate(self.commodities):\\n # Coefficient for jth flow over ith edge is scaled by flow width\\n constraint_i.SetCoefficient(flow_variables[j][i],\\n # cast because or-tools :'(\\n float(demands[j]))\\n capacity_constraints.append(constraint_i)\\n\\n # Conservation on transit nodes\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.num_nodes):\\n if j != commodity[0] and j != commodity[1]:\\n # Constraint must sum to zero\\n constraint_j = solver.Constraint(0, 0,\\n '(2,{},{})'.format(i, j))\\n for k in list(sorted(self.graph.adj[j].keys())):\\n # Ingress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\\n # Egress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Conservation of flow at source node\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[0], edge_dest)]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[0])]],\\n -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Conservation of flow at destination node\\n conservation_dest_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[1])]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[1], edge_dest)]],\\n -1)\\n conservation_dest_constraints.append(constraint_i)\\n\\n ## OBJECTIVES\\n # Implementation of the load-balancing example from Wikipedia\\n # First we add more constraints so that we are minimising the maximum\\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\\n 'max_link_utilisation')\\n min_of_max_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\\n # i.e 'f_0 + f_1 + ... < max'\\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\\n '(5,{})'.format(i))\\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\\n for j, flow_variable in enumerate(flow_variables):\\n constraint_i.SetCoefficient(flow_variable[i],\\n demands[j] /\\n self.graph.get_edge_data(*edge)[\\n 'weight'])\\n min_of_max_constraints.append(constraint_i)\\n\\n # Objective now is to minimise the maximum link utilisation\\n objective = solver.Objective()\\n objective.SetCoefficient(max_utilisation_variable, 1)\\n objective.SetMinimization()\\n solver.Solve()\\n\\n return objective.Value()\",\n \"def get_expected_cost(self):\",\n \"def handle_request(self, sw, util, duration, time_now):\\n\\n #logging.debug(str(self.graph.edges(data=True)))\\n\\n #1 Get available paths from servers to switch\\n paths = self.get_srv_paths(sw, self.graph)\\n\\n #2 choose the path which mins the max link utilization for all links\\n # along the path\\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\\n\\n if len(bestpath) > 0:\\n self.allocate_resources(bestpath, util, time_now, duration)\\n else:\\n logging.warn(\\\"[%s] No best path found at switch [%s]\\\", str(time_now), str(sw))\\n\\n return bestpath\",\n \"def get_available_resources(threshold, usage, total):\\n return dict((host, int(threshold * total[host] - resource))\\n for host, resource in usage.items())\",\n \"def two_opt_annealing(T, scheme, route, adjacency_matrix, max_chain_length, c):\\n best = route.copy()\\n cost_list, T_list = [], []\\n accept_list = [[],[]]\\n\\n chains, iterations = 0, 0\\n T_0 = T\\n iterations = 0\\n\\n while T > 0:\\n for i in range(1, len(route) - 2):\\n # test\\n # Adjust temperature\\n if scheme == \\\"exp\\\":\\n T = T*c\\n if scheme == \\\"log\\\":\\n alpha = 50\\n T = T_0/(1+alpha*np.log(1+iterations))\\n # if scheme == \\\"std\\\":\\n # delta = .01\\n # T = T / (1 + ((np.log(1+delta)* T) / (3 * sd0)))\\n if scheme == \\\"quad\\\":\\n alpha = 1\\n T = T_0/(1+alpha*iterations**2)\\n\\n iterations += 1\\n \\n for j in range(i + 1, len(route)):\\n chains += 1\\n\\n if j - i == 1: continue\\n\\n cost_list.append(calculate_cost(best,adjacency_matrix)[1])\\n T_list.append(T)\\n\\n if cost_change(adjacency_matrix, best[i - 1], best[i], \\\\\\n best[j - 1], best[j]) < 0:\\n best[i:j] = best[j - 1:i - 1:-1]\\n else:\\n temp = best.copy()\\n sd0, cost0 = calculate_cost(temp,adjacency_matrix)\\n temp[i:j] = temp[j - 1:i - 1:-1]\\n _, cost1 = calculate_cost(temp,adjacency_matrix)\\n\\n U = rs.uniform()\\n Z = np.exp((cost0-cost1)/T)\\n\\n if U < Z:\\n accept_list[1].append(Z)\\n accept_list[0].insert(0,T)\\n\\n best[i:j] = best[j - 1:i - 1:-1]\\n\\n if chains > max_chain_length:\\n print(\\\"End by chainlength: \\\",chains,\\\"T =\\\",T,\\\"Cost:\\\",cost0)\\n print(\\\"route\\\",best)\\n return best, cost_list, accept_list\\n\\n route = best.copy()\\n print(\\\"End by T: \\\",T,\\\"Chains: \\\",chains,\\\"Cost:\\\",cost0)\\n print(\\\"route\\\",best)\\n return best, cost_list, accept_list\",\n \"def compute_social_welfare(self):\\r\\n #self.social_welfare = 0\\r\\n #for i in range(self.num_routes):\\r\\n # self.social_welfare += self.routes[i].flow * self.routes[i].get_route_utility()\\r\",\n \"def calculate_demand(flow, requested_sf, available_sf, service_functions):\\n\\n if requested_sf in available_sf:\\n vnf_need_placement = False\\n demanded_total_capacity = 0.0\\n for sf_i, sf_data in available_sf.items():\\n if requested_sf == sf_i:\\n # Include flows data rate in requested sf capacity calculation\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\\n sf_data['load'] + flow.dr)\\n else:\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\\n return demanded_total_capacity, vnf_need_placement\\n else:\\n vnf_need_placement = True\\n available_sf[requested_sf] = {'load': 0.0}\\n demanded_total_capacity = 0.0\\n for sf_i, sf_data in available_sf.items():\\n if requested_sf == sf_i:\\n # Include flows data rate in requested sf capacity calculation\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](\\n sf_data['load'] + flow.dr)\\n else:\\n demanded_total_capacity += service_functions[sf_i]['resource_function'](sf_data['load'])\\n del available_sf[requested_sf]\\n return demanded_total_capacity, vnf_need_placement\",\n \"def cost(graph,a, undirected=True):\\n cost = sum(sum(np.array(abs(graph-a))))\\n if undirected:\\n return cost/2.0\\n else:\\n return cost\",\n \"def calculate_algorithm_cost(algorithm_stats, operation_costs): \\n\\n (comparisons, reads, writes) = algorithm_stats\\n (comparison_cost, read_cost, write_cost) = operation_costs\\n return (comparisons * comparison_cost) + (reads * read_cost) + (writes * write_cost)\",\n \"def get_link_cost(self, global_clock_sec):\\n return self.static_delay_sec + \\\\\\n self.link_buffer.get_average_q_del_sec(global_clock_sec)\",\n \"def score(caches, endpoints, requests, videos):\\n result = 0\\n for endpoint in endpoints:\\n for request in endpoint.requests:\\n result += (endpoint.latence_to_dc - getLatency(request.video, endpoint.eid, caches, videos, endpoints)) * request.amount\\n return result\",\n \"def dist(a, b):\\n base_url=\\\"https://route.api.here.com/routing/7.2/calculateroute.json?\\\"\\n payload = {'app_id':HERE_ID, \\n 'app_code':HERE_CODE,\\n 'waypoint0':'geo!'+','.join([str(i) for i in a]),\\n 'waypoint1':'geo!'+','.join([str(i) for i in b]),\\n 'mode':'fastest;car;traffic:disabled',\\n }\\n resp = requests.get(base_url, params=payload)\\n data = json.loads(resp.content)\\n #import ipdb; ipdb.set_trace()\\n summary = data['response']['route'][0]['summary']\\n return {\\\"distance\\\" : summary['distance'], \\n \\\"trafficTime\\\" : summary[\\\"trafficTime\\\"],\\n \\\"baseTime\\\" : summary[\\\"baseTime\\\"]}\",\n \"def evalPart(origTopo, capacities, subTopos):\\r\\n # print \\\"\\\\t===== Evaluate Partitioning =====\\\"\\r\\n numTopos = len(subTopos)\\r\\n numPM = len(capacities)\\r\\n if (numTopos > numPM):\\r\\n logger.error(\\\"Number of sub topologies does not match number of PMs\\\")\\r\\n exit()\\r\\n \\r\\n weights = {x:0 for x in range(numPM)}\\r\\n cutWeights = {x:0 for x in range(numPM)}\\r\\n subLinks = list(itertools.chain(*[subTopos[x].links(sort=True) for x in range(numTopos)]))\\r\\n cuts = [x for x in origTopo.links(sort=True) if x not in subLinks]\\r\\n\\r\\n for i in range(numTopos):\\r\\n weights[i] = calcTopoWeight(subTopos[i])\\r\\n cutWeights[i] = 0\\r\\n\\r\\n # for i in range(numTopos):\\r\\n # weights[i] = 0.0\\r\\n # for link in subTopos[i].links():\\r\\n # if origTopo.isSwitch(link[0]) and origTopo.isSwitch(link[1]):\\r\\n # weights[i] = weights[i] + subTopos[i].linkInfo(link[0], link[1])[\\\"bw\\\"]\\r\\n \\r\\n for link in cuts:\\r\\n for i in range(numTopos):\\r\\n if link[0] in subTopos[i].switches() or link[1] in subTopos[i].switches():\\r\\n weights[i] = weights[i] + origTopo.linkInfo(link[0], link[1])[\\\"bw\\\"]\\r\\n cutWeights[i] = cutWeights[i] + origTopo.linkInfo(link[0], link[1])[\\\"bw\\\"]\\r\\n\\r\\n return [weights, cutWeights]\\r\\n # return sorted(weights.values(), reverse=True)\\r\\n # wSum = sum(weights.values())\\r\\n # print \\\"\\\\tPart\\\\tCap\\\\tWeight\\\\tFraction\\\"\\r\\n # for x in range(numPM):\\r\\n # print \\\"\\\\t%d\\\\t%.1f\\\\t%.1f\\\\t%.4f\\\" % (x, capacities[x], weights[x], weights[x]/wSum)\\r\",\n \"def resource_costs(self, fleet):\\n base = (10, 15, 0, 0)\\n ins = fleet.get_ship_instances()\\n mult = sum([ship_stats.get_ship_type(x.base().stype)\\n .resource_mult for x in ins])\\n return tuple(map(lambda x: x * mult, base))\",\n \"def averageExcessCost(self):\\n TSTT = 0\\n for l in self.link:\\n if self.link[l].flow <0:\\n print(\\\"what in tarnation?\\\") #this really shouldn't happen, but the sheer number of leetcode problems I've been doing make me want to check against it anyway\\n break\\n if self.link[l].flow >0:\\n contribution = self.link[l].flow * self.link[l].cost\\n TSTT += contribution\\n SPTT = 0\\n TotalDemand = 0\\n for od in self.ODpair:\\n if self.ODpair[od].demand >0:\\n O = self.ODpair[od].origin\\n D = self.ODpair[od].destination\\n BL,C = self.shortestPath(O)\\n SPTT += C[D]*self.ODpair[od].demand\\n TotalDemand+=self.ODpair[od].demand\\n AEC = (TSTT - SPTT)/TotalDemand\\n \\n return AEC\",\n \"def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\\n if highway == 'motorway':\\n result = -motorway_pref*0.5\\n elif highway == 'primary':\\n result = -highway_pref*0.5\\n elif highway == 'residential' or highway == 'service':\\n result = -residential_pref*0.5\\n elif highway == 'cycleway':\\n result = -bicycle_pref * 0.8\\n else:\\n result = 0\\n return result\",\n \"def compute_path_hopping_flow_allocations(target_graph, K=3):\\n flow_allocation_seed_number = 0xCAFE_BABE\\n np.random.seed(flow_allocation_seed_number)\\n # id_to_dpid = topo_mapper.get_and_validate_onos_topo_x(target_graph)\\n link_utilization = {(u, v): 0.0 for u, v in target_graph.edges}\\n node_capacity = {u: 0.0 for u in target_graph.nodes}\\n flows = []\\n while True:\\n source_node, destination_node = flow_selection_fn(target_graph.nodes, 2, replace=False)\\n print(source_node, destination_node)\\n\\n shortest_paths = sorted(nx.all_simple_paths(target_graph, source_node, destination_node,\\n cutoff=3),\\n key=lambda p: len(p))\\n k_shortest_paths = list(itertools.islice(shortest_paths, K))\\n\\n # flow_tx_rate = np.random.uniform() * 10\\n flow_tx_rate = 1.0\\n # if node_capacity[source_node] + flow_tx_rate > LINK_CAPACITY:\\n # break\\n node_capacity[source_node] += flow_tx_rate\\n capacity_was_exceeded = False \\n for path in [nx.utils.pairwise(p_i) for p_i in k_shortest_paths]:\\n for u, v in [sorted(h_i) for h_i in path]:\\n flow_rate_per_subpath = flow_tx_rate / K\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = k_shortest_paths\\n , splitting_ratio = [1.0/K]*K\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def metric_path_length(pathways):\\r\\n num_users = len(pathways)\\r\\n num_good_recommendations = 0\\r\\n sum_u_path_len = 0\\r\\n sum_r_path_len = 0\\r\\n career_goal_reached = 0\\r\\n for user, pathway_tuple in pathways.items():\\r\\n u_path = pathway_tuple[0]\\r\\n r_path = pathway_tuple[1]\\r\\n sum_u_path_len += len(u_path)\\r\\n sum_r_path_len += len(r_path)\\r\\n if r_path[-1]==u_path[-1]:\\r\\n career_goal_reached += 1\\r\\n if len(r_path) < len(u_path):\\r\\n num_good_recommendations += 1\\r\\n return 100.0 * career_goal_reached/num_users, 100.0 * num_good_recommendations / num_users, sum_u_path_len/num_users, sum_r_path_len/num_users\",\n \"def calc_capital_costs (self):\\n road_needed = 'road needed'\\n if self.cd['on road system']:\\n road_needed = 'road not needed'\\n\\n dist = self.comp_specs['distance to community']\\n self.capital_costs = self.comp_specs['est. intertie cost per mile']\\\\\\n [road_needed] * dist\\n #~ print self.capital_costs\",\n \"def update_flow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n # (1): add all edges (u, v) with capacity ub-lb\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"upper_bound\\\"] == float('inf'):\\n self.arc_info[arc][\\\"upper_bound\\\"] = B\\n for arc in self.arc_info.keys():\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"upper_bound\\\"]\\\\\\n - self.arc_info[arc][\\\"lower_bound\\\"]))\\n # (2): add edge (t, s) with capacity B\\n # B = max_lb * (m - n + 2)\\n B = self.get_max_lb()*(self.num_edges() - len(self) + 2)\\n if B == 0:\\n #B = float('inf')\\n B = 100000\\n start_nodes.append(self.sink())\\n end_nodes.append(self.source())\\n capacities.append(int(B))\\n # (3): for all verts, if exc > 0, add edge (s', v) with capacity exc(v),\\n # and if exc < 0, add edge(s', v) with capacity -exc(v)\\n s_prime = max(self.vertices) + 1\\n t_prime = max(self.vertices) + 2\\n print(\\\"s'={}, t'={}\\\".format(s_prime, t_prime))\\n for v in self:\\n #print(\\\"vert {} in arcs: {}\\\".format(v,\\n # self.in_arcs_lists[v]))\\n # compute exc: lower bounds of in - lower bounds of out\\n sum_lb_in = 0\\n for in_arc in self.in_arcs_lists[v]:\\n sum_lb_in += self.arc_info[in_arc][\\\"lower_bound\\\"]\\n sum_lb_out = 0\\n #print(\\\"vert {} out arcs: {}\\\".format(v,\\n # self.out_arcs_lists[v]))\\n for out_arc in self.out_arcs_lists[v]:\\n sum_lb_out += self.arc_info[out_arc][\\\"lower_bound\\\"]\\n exc = sum_lb_in - sum_lb_out\\n #print(\\\"exc is {}\\\".format(exc))\\n if exc > 0:\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(exc))\\n else:\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(-exc))\\n # solve maxflow\\n #print(\\\"s' is {} and t' is {}\\\".format(s_prime, t_prime))\\n max_flow = pywrapgraph.SimpleMaxFlow()\\n for u, v, cap in zip(start_nodes, end_nodes, capacities):\\n #print(\\\"Adding edge {}, {} with cap {}\\\".format(u,v,cap))\\n max_flow.AddArcWithCapacity(u, v, cap)\\n success = True\\n if max_flow.Solve(s_prime, t_prime) == max_flow.OPTIMAL:\\n #print('Max flow: {}'.format( max_flow.OptimalFlow()))\\n #print(' Arc Flow / Capacity')\\n for i in range(max_flow.NumArcs()):\\n # print('%1s -> %1s %3s / %3s' % (\\n # max_flow.Tail(i),\\n # max_flow.Head(i),\\n # max_flow.Flow(i),\\n # max_flow.Capacity(i)))\\n # check that (s', v) edges are saturated (once we find a false,\\n # stay false forever)\\n if success:\\n if max_flow.Tail(i) == s_prime:\\n success = max_flow.Flow(i) == max_flow.Capacity(i)\\n else:\\n success = False\\n print('There was an issue with the max flow input.')\\n if success:\\n # update the flows to be the flow found from maxflow problem\\n for i in range(max_flow.NumArcs()):\\n # if this is an original arc, update the flow\\n if max_flow.Tail(i) != s_prime \\\\\\n and max_flow.Head(i) != t_prime \\\\\\n and not (max_flow.Tail(i) == self.sink() \\\\\\n and max_flow.Head(i) == self.source()):\\n # update arc\\n start = max_flow.Tail(i)\\n destin = max_flow.Head(i)\\n arc = self.get_arc(start, destin)\\n new_flow = self.arc_info[arc][\\\"lower_bound\\\"] + max_flow.Flow(i)\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n self.arc_info[arc][\\\"weight\\\"] = new_flow\\n #print(\\\"Edge {} {} adjusted from {} to {}\\\".format(\\n # start,\\n # destin,\\n # old_flow,\\n # new_flow\\n # ))\\n self.check_conservation_of_flow() # check that solution is valid\\n return True\\n else:\\n return False\",\n \"def get_routecost(self, route):\\n return np.sum(self.parent.edges.lengths[route])\",\n \"def overhead(readings):\\n return 100.0 * (int(readings[0]) + int(readings[1])) / (int(readings[2]) + int(readings[3]))\",\n \"def geo_dist_penalty(p_a, p_b): # created on Nov.3 2019\\n\\n # Offset is 0 for the 1st destination.\\n distance_matrix = Network.dist_mat\\n if p_a[0] != p_b[0] or p_a[-1] != p_b[-1]:\\n raise ValueError('Paths have different o or d.')\\n\\n # define the penalty in utility form for every two destinations. u_ik stands for the generalized cost of travel\\n o, d = p_a[0], p_a[-1]\\n\\n path_a, path_b = p_a[1:-1], p_b[1:-1] # excluding origin and destination\\n\\n path_node_check = []\\n for _path in [path_a, path_b]:\\n _new_path = []\\n for node in _path:\\n if node <= min(distance_matrix.shape) - 1:\\n _new_path.append(node)\\n path_node_check.append(_new_path)\\n path_a, path_b = path_node_check[0], path_node_check[1]\\n\\n # utility (negative) penalty evaluation\\n cost, a, b = 0, o, o # let a, b be origin\\n\\n # if exist empty path\\n if not path_a: # if observed path is empty\\n return cost\\n\\n while path_a and path_b:\\n a, b = path_a.pop(0), path_b.pop(0) # a, b correspond to the i_th node in path_a, path_b\\n cost += distance_matrix[a][b]\\n\\n if path_a: # length of path_a > path b\\n while path_a:\\n a = path_a.pop(0)\\n cost += distance_matrix[a][b]\\n else: # case when length of path_b > path a\\n while path_b:\\n b = path_b.pop(0)\\n cost += distance_matrix[a][b]\\n return cost\",\n \"def optimal_route(graph,homes,source):\\n number_of_homes = len(homes)\\n all_pairs_distances = dict(nx.shortest_path_length(graph, weight = 'weight'))\\n all_pairs_shortest_paths = dict(nx.shortest_path(graph, weight = 'weight'))\\n homes_subgraph = tsp_routines.complete_shortest_path_subgraph_efficient(graph,homes,all_pairs_distances)\\n num_clusters_to_clustering = clustering_routines.all_k_clusters(homes_subgraph,number_of_homes)\\n \\n cluster_list = range(1,number_of_homes+1)\\n optimal_cost = np.Inf\\n optimal_dropoffs = dict()\\n optimal_route = []\\n optimal_num_clusters = 0\\n\\n\\n for num_clusters in cluster_list:\\n home_clusters = num_clusters_to_clustering[num_clusters]\\n cost, dropoffs, route = solver(graph,homes,source,home_clusters,all_pairs_distances,all_pairs_shortest_paths)\\n if cost < optimal_cost:\\n optimal_cost = cost\\n optimal_route = route \\n optimal_dropoffs = dropoffs\\n optimal_num_clusters = num_clusters\\n\\n return optimal_cost, optimal_dropoffs, optimal_route, optimal_num_clusters\",\n \"def total_sdram_requirements(self):\",\n \"def main(supply):\\n\\n # Define four parallel arrays: start_nodes, end_nodes, capacities, and unit costs\\n # between each pair. For instance, the arc from node 0 to node 1 has a\\n # capacity of 15 and a unit cost of 4.\\n\\n start_nodes = [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 8, 8, 8, 8, 8, 9, 9, 9]\\n end_nodes = [8, 2, 4, 6, 5, 4, 7, 6, 9, 8, 9, 0, 3, 4, 2, 5, 1, 0, 2, 5, 1, 8, 3, 4, 1, 0, 8, 1, 1, 0, 9, 5, 6, 1, 8, 2]\\n capacities = [23, 10, 25, 15, 17, 14, 10, 21, 17, 11, 22, 27, 14, 6, 19, 9, 11, 8, 29, 16, 22, 29, 20, 13, 18, 14, 20, 25, 13, 8, 10, 24, 5, 9, 20, 28]\\n unit_costs = [6, 9, 7, 8, 8, 5, 8, 5, 6, 9, 6, 5, 6, 6, 9, 7, 8, 6, 9, 6, 5, 5, 8, 7, 5, 8, 7, 9, 7, 6, 9, 6, 5, 5, 6, 7]\\n\\n # Define an array of supplies at each node.\\n supplies = supply\\n\\n\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n\\n # Add each arc.\\n for i in range(0, len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i], end_nodes[i],\\n capacities[i], unit_costs[i])\\n\\n # Add node supplies.\\n\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n\\n\\n # Find the minimum cost flow between node 0 and node 4.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n flag = 1\\n optimal_flows = np.zeros(36)\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i) * min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # save answer to the variable\\n optimal_flows[i] = min_cost_flow.Flow(i)\\n return flag, optimal_flows\\n else:\\n print('There was an issue with the min cost flow input.')\\n flag = 0\\n return flag, 0\",\n \"def calculateRSTFairshare(self, reqRules):\\n self.getQoSTotals()\\n reqRate, _ = self.convertToRate(reqRules['rules'])\\n totalRate = None\\n for key in ['src_ipv4', 'src_ipv6']:\\n totalRate = self.getTotalAvailableForIP(reqRules[key])\\n if totalRate:\\n break\\n if not totalRate:\\n return None\\n reserved = int(self.params[reqRules['master_intf']]['intf_reserve'])\\n totalAll = self.params[reqRules['master_intf']]['total_allocated']\\n intfMax = self.params[reqRules['master_intf']]['intf_max']\\n # Formula 1: Find ratio between all servers total capacity\\n # (individualRate/totalRates) = ratio\\n ratio = round(float(intfMax) / float(totalRate), 4)\\n # Formula 2: Find individual node fairshare\\n # ratio * reqRate = nodeThrgShare\\n nodeThrgShare = int(ratio * reqRate)\\n # Condition 1: If not enough capacity on all Nodes,\\n # do a fractional calculation for fairshare\\n if nodeThrgShare >= intfMax or nodeThrgShare > totalAll:\\n fractReq = self.reqRatio(intfMax, reqRate, totalAll)\\n reqRate = fractReq\\n # Min for QoS we use 1Gb/s.\\n reqRate = max(int(nodeThrgShare), 1000)\\n return {'reqRate': reqRate, 'reserved': reserved}\",\n \"def main(edges=[(0, 1, 3), (1, 3, 4), (2, 3, 3), (0, 2, 2) ], num=4):\\n\\n # initialize routers array\\n routers = []\\n for x in range(num):\\n routers.append([1000] * num)\\n routers[x][x] = 0\\n \\n # set distance to all neighbours \\n for edge in edges:\\n routers[edge[0]][edge[1]] = edge[2]\\n routers[edge[1]][edge[0]] = edge[2]\\n\\n start_table = routers.copy()\\n\\n flag = True\\n while flag:\\n upflag = False\\n for nbrs in edges:\\n routers[nbrs[0]], up_flag1 = update_table(routers[nbrs[0]], routers[nbrs[1]], dist=nbrs[2])\\n routers[nbrs[1]], up_flag2 = update_table(routers[nbrs[1]], routers[nbrs[0]], dist=nbrs[2])\\n upflag = upflag or up_flag1 or up_flag2\\n\\n flag = upflag\\n\\n return start_table, routers\",\n \"def operation_cost(tau=0):\\n iface_on = 0.2\\n iface_off = 0.2 \\n ipconfig = 2\\n reconf_ip_bin = tau\\n op_cost = 2 * (iface_on + iface_off) + reconf_ip_bin * ipconfig\\n return op_cost\",\n \"def topo_efficiency_cal(self):\\n Temp = 0\\n for i in self.supplyseries:\\n for j in self.demandseries:\\n if(self.topo_shortestpathij(i, j) == None):\\n continue\\n Temp += 1/self.topo_shortestpathij(i, j)\\n \\n self.topo_efficiency = 1/(self.supplynum*self.demandnum)*Temp\",\n \"def su_cost(node_type, node_count, cpu, gpu, ram, duration):\\r\\n if node_type == 'std':\\r\\n node_factor = 1\\r\\n tot_cpu = 28\\r\\n tot_ram = 128\\r\\n if node_type == 'gpu':\\r\\n node_factor = 2\\r\\n tot_cpu = 28\\r\\n tot_ram = 256\\r\\n if node_type == 'fat':\\r\\n node_factor = 6\\r\\n tot_cpu = 56\\r\\n tot_ram = 1024\\r\\n # job_setup = \\\"current setup = {} node type + {} number of nodes + {} number of cpu # + {} number of ram + {} hrs duration of job + {} total cpu + {} total ram\\\".format(node_type, node_count, cpu, ram, duration, tot_cpu, tot_ram)\\r\\n # calculate service units\\r\\n max_resource = top_resource(\\r\\n alloc_CPU = cpu, cpu_denominator = tot_cpu,\\r\\n alloc_GPU = gpu, gpu_denominator = 4,\\r\\n alloc_RAM = ram, ram_denominator = tot_ram)\\r\\n su = ( (node_count * (max_resource * node_factor)) * 28 * duration )\\r\\n return(su)\",\n \"def compute_untargeted_prob(client_as_lst, \\r\\n bw_resource,\\r\\n num_relays,\\r\\n guard_to_bw,\\r\\n all_ases,\\r\\n ip_to_as,\\r\\n pfi,\\r\\n outDir):\\r\\n\\r\\n mal_guard_probs = {}\\r\\n mal_guard_bw = bw_resource / num_relays\\r\\n\\r\\n # initial network state (no malicious guards yet)\\r\\n # format: {FP: (AS, BW)}\\r\\n network_state = {}\\r\\n for g, bw in guard_to_bw.items():\\r\\n network_state[g.fingerprint] = (ip_to_as[g.address], bw)\\r\\n\\r\\n for i in range(0, num_relays):\\r\\n\\r\\n mal_guard_fp = f\\\"MALGUARD{i}\\\"\\r\\n\\r\\n # avg_prob, i^{th} mal_as, network_state\\r\\n best_state = (0, \\\"unknown\\\", {})\\r\\n\\r\\n cnt = 0\\r\\n for cand_as in all_ases:\\r\\n\\r\\n # insert malicious guard in candidate AS\\r\\n temp_network_state = copy.deepcopy(network_state)\\r\\n temp_network_state[mal_guard_fp] = (cand_as, mal_guard_bw)\\r\\n \\r\\n sum_probs = 0\\r\\n for client_as in client_as_lst:\\r\\n prob = compute_prob(client_as,\\r\\n mal_guard_fp, \\r\\n mal_guard_bw, \\r\\n temp_network_state,\\r\\n pfi)\\r\\n sum_probs += prob\\r\\n avg_prob = sum_probs / len(client_as_lst)\\r\\n\\r\\n cnt += 1\\r\\n print(cnt)\\r\\n\\r\\n if avg_prob > best_state[0]:\\r\\n best_state = (avg_prob, cand_as, copy.deepcopy(temp_network_state))\\r\\n\\r\\n network_state = copy.deepcopy(best_state[2])\\r\\n mal_guard_probs[f'{best_state[1]}_{i}'] = best_state[0]\\r\\n\\r\\n if outDir is not None:\\r\\n json.dump(best_state, open(f\\\"{outDir}/tempbeststate{i}.json\\\", \\\"w\\\"))\\r\\n\\r\\n print(mal_guard_probs)\\r\\n if outDir is not None:\\r\\n json.dump(mal_guard_probs, open(f\\\"{outDir}/malguardprobs.json\\\", \\\"w\\\"))\\r\\n print(sum(mal_guard_probs.values()))\\r\\n\\r\\n return mal_guard_probs\",\n \"def Option2_routing(self, S, D, L):\\n if self.has_path(S, D): \\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \\n Opt_path = Shortest_path\\n path_cost_with_weighted_sum = self.calculate_path_cost_with_weighted_sum(Shortest_path, 'c1', 'c2')\\n return path_cost_with_weighted_sum, Opt_path\\n\\n while len(Shortest_path) != 0:\\n path_cost = self.additive_path_cost(Shortest_path, 'w') \\n #self.logger.info('Path cost - %d', path_cost)\\n if path_cost <= L:\\n \\\"\\\"\\\"go to path cost with weighted sum\\\"\\\"\\\"\\n path_cost_with_weighted_sum = self.calculate_path_cost_with_weighted_sum(Shortest_path, 'c1', 'c2')\\n self.G = self.rm_edge_constraint(path_cost_with_weighted_sum) # remove all links where the concave link is greater than PathConcave_cost \\n Opt_path = Shortest_path\\n if self.has_path(S, D):\\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\\n else:\\n Shortest_path = [] \\n else:\\n break \\n else:\\n self.logger.info('No path from %s to %s', S, D)\\n Opt_path = []\\n path_cost_with_weighted_sum = 0\\n return path_cost_with_weighted_sum, Opt_path\",\n \"def objective(graph, flows):\\n\\n G = graph.copy()\\n rules = {}\\n flows.sort(key=lambda a: a[1], reverse=True)\\n\\n for flow,demand in flows:\\n src = get_host_from_ip(G, flow.nw_src)\\n dst = get_host_from_ip(G, flow.nw_dst)\\n\\n if not (src and dst):\\n continue\\n if not (src in G.nodes() and dst in G.nodes()):\\n continue\\n\\n path = widest_path(G, src, dst)\\n\\n hops = []\\n for a,b in pairwise(path):\\n hops.append(Hop(dpid=int(a[1:]), port=G.edge[a][b]['port']))\\n G.edge[a][b]['capacity'] -= demand\\n G.edge[b][a]['capacity'] -= demand\\n\\n rules[flow] = hops\\n\\n return rules\",\n \"def cost(self):\\n lg = len(self.guarantees.cnf)\\n la = len(self.assumptions.cnf)\\n\\n \\\"\\\"\\\"heuristic\\n Low: guarantees while assuming little (assumption set is bigger)\\n High: guarantees while assuming a lot (assumption set is smaller)\\\"\\\"\\\"\\n\\n return la / lg\",\n \"def compute_pagerank(urls, inlinks, outlinks, b=.85, iters=20):\\n ###TODO\\n pagerank = defaultdict(lambda: 1.0)\\n N = len(urls)\\n for url in urls:\\n pagerank[url]\\n for i in range(0, iters):\\n for url in urls:\\n result_sum = 0.0\\n for link in inlinks[url]:\\n if len(outlinks[link]) is not 0:\\n result_sum += (pagerank[link] / len(outlinks[link]))\\n pagerank[url] = (1/N) * (1-b) + (b * result_sum)\\n return pagerank\\n pass\",\n \"def sub_link_capacity(self, path, bw):\\n \\n # PART 1, TASK 3.4 sub bw to edges\",\n \"def two_user_route_statistics(i,j, source_data, destination_data, source_destination_data, delta=1.2):\\n\\toccupancy_ratio = 0.0\\n\\tminimum_distance_so_far = 0.0\\n\\tcommon_travel_distance = 0.0\\n\\n\\ttry:\\n\\t\\tif source_destination_data[j][i] + source_data[i][j] <= 1.2*source_destination_data[i][i] and source_destination_data[j][i] + destination_data[i][j] <= 1.2*source_destination_data[j][j]:\\n\\t\\t\\tfirst = ((source_destination_data[j][i] + source_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\\n\\t\\t\\tsecond = ((source_destination_data[j][i] + destination_data[i][j])/(source_destination_data[j][i] + source_data[i][j]+destination_data[i][j]))\\n\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\t\\t\\tcommon_travel_distance = source_destination_data[j][i]\\n\\t\\t\\tminimum_distance_so_far = source_data[i][j] + source_destination_data[j][i] + destination_data[i][j]\\n\\n\\t\\tif source_destination_data[i][j] + destination_data[j][i] <= 1.2*source_destination_data[i][i] and source_destination_data[i][j] + source_data[j][i] <= 1.2*source_destination_data[j][j]:\\n\\t\\t\\tfirst = ((source_destination_data[i][j] + destination_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\\t\\t\\n\\t\\t\\tsecond = ((source_destination_data[i][j] + source_data[j][i])/(source_destination_data[i][j] + destination_data[j][i]+source_data[j][i]))\\n\\t\\t\\ttotal_distance = source_data[j][i] + source_destination_data[i][j] + destination_data[j][i]\\n\\n\\t\\t\\tif total_distance < minimum_distance_so_far:\\n\\t\\t\\t\\tminimum_distance_so_far = total_distance\\n\\t\\t\\t\\tcommon_travel_distance = source_destination_data[i][j]\\n\\t\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\n\\t\\tif source_data[i][j]+source_destination_data[j][j]+destination_data[j][i] <= 1.2*source_destination_data[i][i]:\\n\\t\\t\\tfirst = (1)\\n\\t\\t\\tsecond = (source_destination_data[j][j]/(source_data[i][j]+source_destination_data[j][j]+destination_data[j][i]))\\n\\n\\t\\t\\ttotal_distance = source_data[i][j] + source_destination_data[j][j] + destination_data[j][i]\\n\\n\\t\\t\\tif total_distance < minimum_distance_so_far:\\n\\t\\t\\t\\tminimum_distance_so_far = total_distance\\n\\t\\t\\t\\tcommon_travel_distance = source_destination_data[j][j]\\n\\t\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\n\\t\\tif source_data[j][i]+source_destination_data[i][i]+destination_data[i][j] <= 1.2*source_destination_data[j][j]:\\n\\t\\t\\tfirst = (source_destination_data[i][i]/(source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]))\\n\\t\\t\\tsecond = (1)\\n\\n\\t\\t\\ttotal_distance = source_data[j][i]+source_destination_data[i][i]+destination_data[i][j]\\n\\n\\t\\t\\tif total_distance < minimum_distance_so_far:\\n\\t\\t\\t\\tminimum_distance_so_far = total_distance\\n\\t\\t\\t\\tcommon_travel_distance = source_destination_data[i][i]\\n\\t\\t\\t\\toccupancy_ratio = (first+second)/2\\n\\n\\texcept Exception as e:\\n\\t\\toccupancy_ratio = 1.0\\n\\t\\tminimum_distance_so_far = 0.0\\n\\t\\tcommon_travel_distance = 0.0\\n\\n\\n\\treturn occupancy_ratio, common_travel_distance, minimum_distance_so_far\",\n \"def total_weight(network):\\n weight = 0\\n\\n for node_connections in network:\\n for edge in node_connections:\\n if edge is not None:\\n weight += edge\\n\\n return weight // 2\",\n \"def mapping_quality(graph, spanset, gapset):\\n the_sum = sum(sum(1 for edge in graph.edges(node) if edge[1] in gapset) for node in spanset)\\n # if directed graph, uncomment this:\\n #the_sum += sum(sum(1 for edge in graph.edges(node) if edge[1] in spanset) for node in gapset)\\n return the_sum\",\n \"def compute_m_paths_of_len_forw(g, sampl, start_times, path_len=5, cost=1, its=100, max_duration=sys.maxint):\\n\\n num_of_paths_dict = {}\\n\\n # for each node in source, generate random paths and count the number of times they end up in each\\n # dest. node\\n for source, start_time in zip(sampl, start_times):\\n print \\\"Processing source node: {} (starting at time {})\\\".format(source, start_time)\\n num_of_paths_dict[(source, start_time)] = {dest: 0 for dest in g.nodes()}\\n for _ in range(its):\\n d = random_path_forward(g, source, path_len, start_time, cost, max_duration)\\n if d is not None:\\n num_of_paths_dict[(source, start_time)][d] += 1\\n\\n return num_of_paths_dict\",\n \"def compute_total_distance(road_map):\\n \\n try:\\n distances = distances_and_limits(road_map)[0]\\n return round(sum(distances),2)\\n except Exception as e:\\n print(str(e))\",\n \"def assess_latency_by_obs(self,\\n possible_routes, \\n executed_routes, \\n rt_poss_dv_getter = rt_possible_dv_getter, \\n rt_exec_dv_getter= rt_scheduled_dv_getter, \\n verbose=False):\\n\\n # possible routes by observation\\n poss_rts_by_obs = self.get_routes_by_obs (possible_routes)\\n exec_rts_by_obs = self.get_routes_by_obs (executed_routes)\\n exec_obs = exec_rts_by_obs.keys()\\n\\n stats = {}\\n\\n # for selected routes\\n possible_initial_lat_by_obs_exec = {}\\n for obs, rts in poss_rts_by_obs.items ():\\n\\n # want to make this a fair comparison. Only consider latency in rs for those obs that show up in AS\\n if not obs in exec_obs:\\n continue\\n\\n # start, center, end...whichever we're using for the latency calculation\\n time_option = self.latency_calculation_params['dlnk']\\n\\n # want to sort these by earliest time so that we favor earlier downlinks\\n rts.sort (key=lambda rt: getattr(rt.get_dlnk(),time_option))\\n\\n # figure out the latency for the initial minimum DV downlink\\n # have to accumulate data volume because route selection minimum data volume might be less than that for activity scheduling\\n cum_dv = 0\\n for rt in rts:\\n cum_dv += rt_poss_dv_getter(rt)\\n \\n # if we have reached our minimum required data volume amount to deem the observation downlinked for the purposes of latency calculation...\\n if cum_dv >= self.min_obs_dv_dlnk_req - self.min_obs_dv_dlnk_req_slop :\\n\\n possible_initial_lat_by_obs_exec[obs] = rt.get_latency(\\n 'minutes',\\n obs_option = self.latency_calculation_params['obs'], \\n dlnk_option = self.latency_calculation_params['dlnk']\\n )\\n\\n # break so that we don't continue considering the rest of the data volume\\n break\\n\\n # for executed routes\\n executed_initial_lat_by_obs_exec = {}\\n executed_final_lat_by_obs_exec = {}\\n for obs, rts in exec_rts_by_obs.items ():\\n # start, center, end...whichever we're using for the latency calculation\\n time_option = self.latency_calculation_params['dlnk']\\n\\n # want to sort these by earliest time so that we favor earlier downlinks\\n rts.sort (key=lambda rt: getattr(rt.get_dlnk(),time_option))\\n\\n # figure out the latency for the initial minimum DV downlink\\n # have to accumulate data volume because route selection minimum data volume might be less than that for activity scheduling\\n cum_dv = 0\\n for rt in rts:\\n cum_dv += rt_exec_dv_getter(rt)\\n \\n # if we have reached our minimum required data volume amount to deem the observation downlinked for the purposes of latency calculation...\\n if cum_dv >= self.min_obs_dv_dlnk_req - self.min_obs_dv_dlnk_req_slop :\\n executed_initial_lat_by_obs_exec[obs] = rts[0].get_latency(\\n 'minutes',\\n obs_option = self.latency_calculation_params['obs'], \\n dlnk_option = self.latency_calculation_params['dlnk']\\n )\\n\\n # break so that we don't continue considering the rest of the data volume\\n break\\n\\n # figure out the latency for downlink of all observation data that we chose to downlink\\n executed_final_lat_by_obs_exec[obs] = rts[-1].get_latency(\\n 'minutes',\\n obs_option = self.latency_calculation_params['obs'], \\n dlnk_option = self.latency_calculation_params['dlnk']\\n )\\n\\n i_lats_poss = [lat for lat in possible_initial_lat_by_obs_exec. values ()]\\n i_lats_exec = [lat for lat in executed_initial_lat_by_obs_exec. values ()]\\n f_lats_exec = [lat for lat in executed_final_lat_by_obs_exec. values ()]\\n \\n i_valid_poss = len(i_lats_poss) > 0\\n i_valid_exec = len(i_lats_exec) > 0\\n f_valid_exec = len(f_lats_exec) > 0\\n\\n # debug_tools.debug_breakpt()\\n\\n # note: don't use mean/std. they're not super useful metrics, statistically speaking\\n # note that if center times are not used with both the observation and downlink for calculating latency, then the route selection and executed the numbers might differ. this is because the executed numbers reflect the updated start and end time for the Windows\\n # stats['ave_obs_initial_lat_poss'] = np.mean(i_lats_poss) if i_valid_poss else None\\n # stats['std_obs_initial_lat_poss'] = np.std(i_lats_poss) if i_valid_poss else None\\n stats['min_obs_initial_lat_poss'] = np.min(i_lats_poss) if i_valid_poss else None\\n stats['prcntl25_obs_initial_lat_poss'] = np.percentile(i_lats_poss,25) if i_valid_poss else None\\n stats['median_obs_initial_lat_poss'] = np.median(i_lats_poss) if i_valid_poss else None\\n stats['prcntl75_obs_initial_lat_poss'] = np.percentile(i_lats_poss,75) if i_valid_poss else None\\n stats['max_obs_initial_lat_poss'] = np.max(i_lats_poss) if i_valid_poss else None\\n # stats['ave_obs_initial_lat_exec'] = np.mean(i_lats_exec) if i_valid_exec else None\\n # stats['std_obs_initial_lat_exec'] = np.std(i_lats_exec) if i_valid_exec else None\\n stats['min_obs_initial_lat_exec'] = np.min(i_lats_exec) if i_valid_exec else None\\n stats['prcntl25_obs_initial_lat_exec'] = np.percentile(i_lats_exec,25) if i_valid_exec else None\\n stats['median_obs_initial_lat_exec'] = np.median(i_lats_exec) if i_valid_exec else None\\n stats['prcntl75_obs_initial_lat_exec'] = np.percentile(i_lats_exec,75) if i_valid_exec else None\\n stats['max_obs_initial_lat_exec'] = np.max(i_lats_exec) if i_valid_exec else None\\n\\n stats['ave_obs_final_lat_exec'] = np.mean(f_lats_exec) if f_valid_exec else None\\n stats['min_obs_final_lat_exec'] = np.min(f_lats_exec) if f_valid_exec else None\\n stats['max_obs_final_lat_exec'] = np.max(f_lats_exec) if f_valid_exec else None\\n\\n stats['possible_initial_lat_by_obs_exec'] = possible_initial_lat_by_obs_exec\\n stats['executed_initial_lat_by_obs_exec'] = executed_initial_lat_by_obs_exec\\n stats['executed_final_lat_by_obs_exec'] = executed_final_lat_by_obs_exec\\n\\n if verbose:\\n print('latencies by observation (only considering \\\"executed\\\" obs windows)')\\n\\n if not (i_valid_poss or i_valid_exec):\\n print('no routes found, no valid statistics to display')\\n return stats\\n\\n if not i_valid_poss:\\n print('no RS routes found')\\n if not i_valid_exec:\\n print('no scheduled routes found')\\n\\n if i_valid_poss:\\n # print(\\\"%s: \\\\t\\\\t %f\\\"%('ave_obs_initial_lat_poss',stats['ave_obs_initial_lat_poss']))\\n # print(\\\"%s: \\\\t\\\\t %f\\\"%('std_obs_initial_lat_poss',stats['std_obs_initial_lat_poss']))\\n print(\\\"%s: %f\\\"%('min_obs_initial_lat_poss',stats['min_obs_initial_lat_poss']))\\n print(\\\"%s: %f\\\"%('prcntl25_obs_initial_lat_poss',stats['prcntl25_obs_initial_lat_poss']))\\n print(\\\"%s: \\\\t\\\\t %f\\\"%('median_obs_initial_lat_poss',stats['median_obs_initial_lat_poss']))\\n print(\\\"%s: %f\\\"%('prcntl75_obs_initial_lat_poss',stats['prcntl75_obs_initial_lat_poss']))\\n print(\\\"%s: %f\\\"%('max_obs_initial_lat_poss',stats['max_obs_initial_lat_poss']))\\n\\n if i_valid_exec:\\n # print(\\\"%s: \\\\t\\\\t %f\\\"%('ave_obs_initial_lat_exec',stats['ave_obs_initial_lat_exec']))\\n # print(\\\"%s: \\\\t\\\\t %f\\\"%('std_obs_initial_lat_exec',stats['std_obs_initial_lat_exec']))\\n print(\\\"%s: %f\\\"%('min_obs_initial_lat_exec',stats['min_obs_initial_lat_exec']))\\n print(\\\"%s: %f\\\"%('prcntl25_obs_initial_lat_exec',stats['prcntl25_obs_initial_lat_exec']))\\n print(\\\"%s: \\\\t\\\\t %f\\\"%('median_obs_initial_lat_exec',stats['median_obs_initial_lat_exec']))\\n print(\\\"%s: %f\\\"%('prcntl75_obs_initial_lat_exec',stats['prcntl75_obs_initial_lat_exec']))\\n print(\\\"%s: %f\\\"%('max_obs_initial_lat_exec',stats['max_obs_initial_lat_exec']))\\n print(\\\"all 5 in a row: %f %f %f %f %f\\\"%(\\n stats['min_obs_initial_lat_exec'],\\n stats['prcntl25_obs_initial_lat_exec'],\\n stats['median_obs_initial_lat_exec'],\\n stats['prcntl75_obs_initial_lat_exec'],\\n stats['max_obs_initial_lat_exec'])\\n )\\n \\n # todo: might should update median calcs for final lat as well\\n print(\\\"Note: should update final latency to median and prcntls as well\\\")\\n print(\\\"%s: %f\\\"%('ave_obs_final_lat_exec',stats['ave_obs_final_lat_exec']))\\n print(\\\"%s: %f\\\"%('min_obs_final_lat_exec',stats['min_obs_final_lat_exec']))\\n print(\\\"%s: %f\\\"%('max_obs_final_lat_exec',stats['max_obs_final_lat_exec']))\\n\\n return stats\",\n \"def uniformCostSearch(problem):\\n \\\"*** YOUR CODE HERE IF YOU WANT TO PRACTICE ***\\\"\\n aStarSearch(problem)\",\n \"def _compute_offers_to_send(self) -> Dict[Tuple[float, float], float]:\\n partial_asgt = self._neighbors_values.copy()\\n offers = dict()\\n\\n for limited_asgt in generate_assignment_as_dict([self.variable, self._partner]):\\n partial_asgt.update(limited_asgt)\\n cost = self._compute_cost(**partial_asgt)\\n if self.logger.isEnabledFor(logging.DEBUG):\\n self.logger.debug(\\n f\\\"looking for offer : {partial_asgt} - cost {cost}\\\"\\n f\\\" current {self.current_cost} {self._mode}\\\"\\n )\\n\\n if (self.current_cost > cost and self._mode == \\\"min\\\") or (\\n self.current_cost < cost and self._mode == \\\"max\\\"\\n ):\\n offers[(limited_asgt[self.name], limited_asgt[self._partner.name])] = (\\n self.current_cost - cost\\n )\\n return offers\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def resource_cost(bw_matrix, standby_vr):\\n #host_cpu = float(cpu_info[0][standby_vr])\\n host_bw = 0\\n num_rows = len(bw_matrix)\\n #num_cols = len(bw_matrix[1,:])\\n for port in range(num_rows):\\n if bw_matrix[port][standby_vr] != '.':\\n host_bw += float(bw_matrix[port][standby_vr])\\n else:\\n pass\\n #return host_cpu * host_bw\\n return host_bw\",\n \"def cost(self) -> float:\",\n \"def get_num_to_request():\\n #ALLOWABLE_REQUEST_SIZES = [1, 3, 5, 8, 12]\\n ALLOWABLE_REQUEST_SIZES = [1, 3, 5, 8]\\n avgrate = jobtracker.query(\\\"SELECT AVG(files.size/\\\" \\\\\\n \\\"(TO_SECONDS(download_attempts.updated_at)*1/86400. - \\\" \\\\\\n \\\"TO_SECONDS(download_attempts.created_at)*1/86400.)) \\\" \\\\\\n \\\"FROM files, download_attempts \\\" \\\\\\n \\\"WHERE files.id=download_attempts.file_id \\\" \\\\\\n \\\"AND download_attempts.status='downloaded'\\\", \\\\\\n fetchone=True)\\n avgsize = jobtracker.query(\\\"SELECT AVG(size/numrequested) FROM requests \\\" \\\\\\n \\\"WHERE numbits=%d AND \\\" \\\\\\n \\\"file_type='%s'\\\" % \\\\\\n (config.download.request_numbits, \\\\\\n config.download.request_datatype.lower()), \\\\\\n fetchone=True)\\n if avgrate is None or avgsize is None:\\n return min(ALLOWABLE_REQUEST_SIZES)\\n\\n # Total number requested that can be downloaded per day (on average).\\n max_to_request_per_day = avgrate/avgsize\\n \\n used = get_space_used()\\n avail = get_space_available()\\n reserved = get_space_committed()\\n \\n # Maximum number of bytes that we should request\\n max_bytes = min([avail-reserved-config.download.min_free_space, \\\\\\n config.download.space_to_use-reserved-used])\\n # Maximum number to request\\n max_num = max_bytes/avgsize\\n\\n ideal_num_to_request = min([max_num, max_to_request_per_day])\\n\\n if debug.DOWNLOAD:\\n print \\\"Average dl rate: %.2f bytes/day\\\" % avgrate\\n print \\\"Average size per request unit: %d bytes\\\" % avgsize\\n print \\\"Max can dl per day: %d\\\" % max_to_request_per_day\\n print \\\"Max num to request: %d\\\" % max_num\\n print \\\"Ideal to request: %d\\\" % ideal_num_to_request\\n\\n # Return the closest allowable request size without exceeding\\n # 'ideal_num_to_request'\\n num_to_request = max([0]+[N for N in ALLOWABLE_REQUEST_SIZES \\\\\\n if N <= ideal_num_to_request])\\n\\n return num_to_request\",\n \"def add_link_capacity(self, path, bw):\\n\\n # PART 1, TASK 3.4 add bw to edges\",\n \"def __best_units_derivation(searchable_rules, unit_routes, lhs_var, final_rhs):\\n def get_prob(var, rhs):\\n return 0.0 if (var not in searchable_rules) or (rhs not in searchable_rules[var]) \\\\\\n else searchable_rules[var][rhs].probability\\n best_route_prob = get_prob(lhs_var, final_rhs)\\n best_route = [] if best_route_prob == 0.0 else [searchable_rules[lhs_var][final_rhs]]\\n for full_route in unit_routes.get(lhs_var, []):\\n curr_prob = 1.0\\n for i in range(1, len(full_route)):\\n prev_var = full_route[i - 1]\\n next_var = full_route[i]\\n curr_prob *= get_prob(prev_var, (next_var,))\\n alt_prob = curr_prob * get_prob(next_var, final_rhs)\\n if alt_prob > best_route_prob:\\n best_route = [searchable_rules[full_route[j]][(full_route[j + 1],)]\\n for j in range(i)]\\n best_route.append(searchable_rules[full_route[i]][final_rhs])\\n best_route_prob = alt_prob\\n return best_route, best_route_prob\",\n \"def compute_node_weight(walks):\\n\\n # Define a dict to count node occurrences\\n count = {}\\n # Float variable which will be the sum of all nodes\\n sum = 0.0\\n # The final list\\n sorted_values_list = []\\n\\n # Browse each random walk realised\\n for walk in walks:\\n # Browse each node of a random walk\\n for i in walk:\\n # Do +1 if the node is already in dict\\n if i in count.keys():\\n count[i] = count[i] + 1.0\\n # Insert nodes as key and 0 as the value it is not in dict\\n else:\\n count[i] = 0\\n\\n # Store the sum of all nodes values (number of time each node has been selected by the RWR) in the sum variable\\n for val in count.values():\\n sum = sum + val\\n\\n # Replace value of nodes by the ratio of the number of times a node has been selected to the total nodes selected\\n for i in count:\\n count[i] = count[i] / sum\\n\\n # Insert each node ratio in a list sorted by nodes (from 0 to n)\\n for i in range(0, max(count.keys()) + 1):\\n sorted_values_list.append(count[i])\\n\\n return sorted_values_list\",\n \"def general_stats():\\n\\n setproctitle(f\\\"RNANet statistics.py general_stats()\\\")\\n\\n reqs = [\\n # unique unmapped chains with no issues\\n \\\"\\\"\\\" SELECT distinct pdb_id, chain_name, exp_method, resolution\\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\\n WHERE rfam_acc = 'unmappd' AND ISSUE=0;\\\"\\\"\\\",\\n\\n # unique mapped chains with no issues\\n \\\"\\\"\\\" SELECT distinct pdb_id, chain_name, exp_method, resolution\\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\\\"\\\"\\\",\\n\\n # mapped chains with no issues\\n \\\"\\\"\\\" SELECT pdb_id, chain_name, inferred, rfam_acc, pdb_start, pdb_end, exp_method, resolution\\n FROM chain JOIN structure ON chain.structure_id = structure.pdb_id\\n WHERE rfam_acc != 'unmappd' AND ISSUE=0;\\\"\\\"\\\",\\n\\n # mapped chains with no issues that are all inferred\\n \\\"\\\"\\\" SELECT DISTINCT pdb_id, c.chain_name, exp_method, resolution\\n FROM (\\n SELECT inferred, rfam_acc, pdb_start, pdb_end, chain.structure_id, chain.chain_name, r.redundancy, r.inf_redundancy\\n FROM chain \\n JOIN (SELECT structure_id, chain_name, COUNT(distinct rfam_acc) AS redundancy, SUM(inferred) AS inf_redundancy \\n FROM chain \\n WHERE rfam_acc != 'unmappd' AND issue=0 \\n GROUP BY structure_id, chain_name\\n ) AS r ON chain.structure_id=r.structure_id AND chain.chain_name = r.chain_name \\n WHERE r.redundancy=r.inf_redundancy AND rfam_acc != 'unmappd' and issue=0\\n ) AS c\\n JOIN structure ON c.structure_id=structure.pdb_id;\\\"\\\"\\\",\\n\\n # Number of mapped chains (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0);\\\"\\\"\\\",\\n\\n # Number of mapped chains (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1);\\\"\\\"\\\",\\n\\n # Number of mapped chains inferred once\\n \\\"\\\"\\\"SELECT count(*) FROM (\\n SELECT structure_id, chain_name, COUNT(DISTINCT rfam_acc) as c \\n FROM chain where rfam_acc!='unmappd' and inferred=1 \\n GROUP BY structure_id, chain_name\\n ) WHERE c=1;\\\"\\\"\\\",\\n\\n # Number of mapped chains inferred twice\\n \\\"\\\"\\\"select count(*) from (\\n select structure_id, chain_name, count(distinct rfam_acc) as c \\n from chain where rfam_acc!='unmappd' and inferred=1 \\n group by structure_id, chain_name\\n ) where c=2;\\\"\\\"\\\",\\n\\n # Number of mapped chains inferred 3 times or more\\n \\\"\\\"\\\"select count(*) from (\\n select structure_id, chain_name, count(distinct rfam_acc) as c \\n from chain where rfam_acc!='unmappd' and inferred=1 \\n group by structure_id, chain_name\\n ) where c>2;\\\"\\\"\\\",\\n\\n # Number of chains both mapped with and without inferrence\\n \\\"\\\"\\\" SELECT COUNT(*) FROM (\\n SELECT structure_id, chain_name, sum(inferred) AS s, COUNT(rfam_acc) AS c \\n FROM chain \\n WHERE rfam_acc!='unmappd' \\n GROUP BY structure_id, chain_name\\n ) \\n WHERE s < c AND s > 0;\\\"\\\"\\\",\\n \\n # Number of mapped chains (total)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\\\"\\\"\\\",\\n\\n # Number of unique mapped chains\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd');\\\"\\\"\\\",\\n\\n # Number of unmapped chains\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd');\\\"\\\"\\\",\\n \\n # Number of mapped chains without issues (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains without issues (not inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 0 AND issue = 0);\\\"\\\"\\\",\\n\\n # Number of mapped chains without issues (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains without issues (inferred)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND inferred = 1 AND issue=0);\\\"\\\"\\\",\\n\\n # Number of mapped chains without issues (total)\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\\\"\\\"\\\",\\n\\n # Number of unique mapped chains without issues\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT DISTINCT structure_id, chain_name FROM chain WHERE rfam_acc != 'unmappd' AND issue=0);\\\"\\\"\\\",\\n\\n # Number of unmapped chains without issues\\n \\\"\\\"\\\"SELECT count(*) FROM (SELECT structure_id, chain_name FROM chain WHERE rfam_acc = 'unmappd' AND issue=0);\\\"\\\"\\\"\\n ]\\n\\n answers = []\\n with sqlite3.connect(runDir + \\\"/results/RNANet.db\\\") as conn:\\n conn.execute('pragma journal_mode=wal')\\n for r in reqs:\\n answers.append(pd.read_sql(r, conn))\\n df_unique = answers[0]\\n df_mapped_unique = answers[1]\\n df_mapped_copies = answers[2]\\n df_inferred_only_unique = answers[3]\\n print()\\n print(\\\"> found\\\", answers[4].iloc[0][0], f\\\"chains ({answers[5].iloc[0][0]} unique chains) that are mapped thanks to Rfam. Removing chains with issues, only {answers[15].iloc[0][0]} ({answers[16].iloc[0][0]} unique)\\\")\\n if answers[4].iloc[0][0] != answers[5].iloc[0][0]:\\n print(\\\"\\\\t> This happens because different parts of the same chain can be mapped to different families.\\\")\\n print(\\\"> found\\\", answers[6].iloc[0][0], f\\\"chains ({answers[7].iloc[0][0]} unique chains) that are mapped by inferrence. Removing chains with issues, only {answers[17].iloc[0][0]} ({answers[18].iloc[0][0]} unique).\\\")\\n print(\\\"\\\\t> \\\", answers[8].iloc[0][0], \\\"chains are mapped only once,\\\")\\n print(\\\"\\\\t> \\\", answers[9].iloc[0][0], \\\"are mapped to 2 families,\\\")\\n print(\\\"\\\\t> \\\", answers[10].iloc[0][0], \\\"are mapped to 3 or more.\\\")\\n print(\\\"> Among them,\\\", answers[11].iloc[0][0], \\\"chains are mapped both with families found on Rfam and by inferrence.\\\")\\n if answers[11].iloc[0][0]:\\n print(\\\"\\\\t> this is normal if you used option -f (--full-inference). Otherwise, there might be a problem.\\\")\\n print(\\\"> TOTAL:\\\", answers[12].iloc[0][0], f\\\"chains ({answers[13].iloc[0][0]} unique chains) mapped to a family. Removing chains with issues, only {answers[19].iloc[0][0]} ({answers[20].iloc[0][0]} unique).\\\")\\n print(\\\"> TOTAL:\\\", answers[14].iloc[0][0], f\\\"unmapped chains. Removing chains with issues, {answers[21].iloc[0][0]}.\\\")\\n if answers[14].iloc[0][0]:\\n print(\\\"\\\\t> this is normal if you used option --no-homology. Otherwise, there might be a problem.\\\")\\n print()\\n\\n ##########################################\\n # plot N = f(resolution, exp_method)\\n ##########################################\\n\\n methods = df_unique.exp_method.unique()\\n\\n fig, axs = plt.subplots(1+len(methods), 3, figsize=(15,5*(1+len(methods))), sharex=True)\\n df_unique.sort_values('resolution', inplace=True, ignore_index=True)\\n df_mapped_unique.sort_values('resolution', inplace=True, ignore_index=True)\\n df_inferred_only_unique.sort_values('resolution', inplace=True, ignore_index=True)\\n df_mapped_copies.sort_values('resolution', inplace=True, ignore_index=True)\\n max_res = max(df_unique.resolution)\\n max_structs = max(len(df_mapped_copies.index), len(df_unique.index))\\n colors = np.linspace(0,1,1+len(methods))\\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\\n\\n axs[0][0].grid(axis='y', ls='dotted', lw=1)\\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\\n axs[0][0].hist(df_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\\n axs[0][0].text(0.95*max_res, 0.95*len(df_unique.resolution), \\\"%d \\\" % len(df_unique.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0][0].set_ylabel(\\\"ALL\\\", fontsize=14)\\n axs[0][0].set_title(\\\"Number of unique RNA chains\\\", fontsize=14)\\n axs[0][0].set_ylim((0, max_structs * 1.05))\\n axs[0][0].legend(loc=\\\"lower right\\\", fontsize=14)\\n\\n axs[0][1].grid(axis='y', ls='dotted', lw=1)\\n axs[0][1].set_yticklabels([])\\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\\n axs[0][1].hist(df_mapped_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\\n axs[0][1].hist(df_inferred_only_unique.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='only by inference')\\n axs[0][1].text(0.95*max_res, 0.95*len(df_mapped_unique.resolution), \\\"%d \\\" % len(df_mapped_unique.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0][1].set_title(r\\\"Number of unique RNA chains\\\\nmapped to $\\\\geq 1$ family\\\", fontsize=14)\\n axs[0][1].set_ylim((0, max_structs * 1.05))\\n axs[0][1].legend(loc=\\\"upper left\\\", fontsize=14)\\n\\n axs[0][2].grid(axis='y', ls='dotted', lw=1)\\n axs[0][2].set_yticklabels([])\\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[0], 1), label='distribution')\\n axs[0][2].hist(df_mapped_copies.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[0], 0.5), cumulative=True, label='cumulative')\\n axs[0][2].hist(df_mapped_copies[df_mapped_copies.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[0], 0.5), cumulative=True, label='inferred')\\n axs[0][2].text(0.95*max_res, 0.95*len(df_mapped_copies.resolution), \\\"%d \\\" % len(df_mapped_copies.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0][2].set_title(\\\"Number of RNA chains mapped to a\\\\nfamily (with copies)\\\", fontsize=14)\\n axs[0][2].legend(loc=\\\"upper left\\\", fontsize=14)\\n axs[0][2].set_ylim((0, max_structs * 1.05))\\n\\n for i,m in enumerate(methods):\\n df_unique_m = df_unique[df_unique.exp_method == m]\\n df_mapped_unique_m = df_mapped_unique[df_mapped_unique.exp_method == m]\\n df_inferred_only_unique_m = df_inferred_only_unique[df_inferred_only_unique.exp_method == m]\\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m]\\n max_structs = max(len(df_mapped_copies_m.index), len(df_unique_m.index))\\n print(\\\"> found\\\", max_structs, \\\"structures with method\\\", m, flush=True)\\n\\n axs[1+i][0].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\\n axs[1+i][0].hist(df_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\\n axs[1+i][0].text(0.95*max_res, 0.95*len(df_unique_m.resolution), \\\"%d \\\" % len(df_unique_m.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i][0].set_ylim((0, max_structs * 1.05))\\n axs[1+i][0].set_ylabel(m, fontsize=14)\\n axs[1+i][0].legend(loc=\\\"lower right\\\", fontsize=14)\\n\\n axs[1+i][1].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i][1].set_yticklabels([])\\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\\n axs[1+i][1].hist(df_mapped_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\\n axs[1+i][1].hist(df_inferred_only_unique_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='only by inference')\\n axs[1+i][1].text(0.95*max_res, 0.95*len(df_mapped_unique_m.resolution), \\\"%d \\\" % len(df_mapped_unique_m.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i][1].set_ylim((0, max_structs * 1.05))\\n axs[1+i][1].legend(loc=\\\"upper left\\\", fontsize=14)\\n \\n axs[1+i][2].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i][2].set_yticklabels([])\\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 1, colors[1+i], 1), label='distribution')\\n axs[1+i][2].hist(df_mapped_copies_m.resolution, bins=np.arange(0, max_res, 0.5), fc=(0, 0, colors[1+i], 0.5), cumulative=True, label='cumulative')\\n axs[1+i][2].hist(df_mapped_copies_m[df_mapped_copies_m.inferred == 1].resolution, bins=np.arange(0, max_res, 0.5), fc=(0.2, 0, colors[1+i], 0.5), cumulative=True, label='inferred')\\n axs[1+i][2].text(0.95*max_res, 0.95*len(df_mapped_copies_m.resolution), \\\"%d \\\" % len(df_mapped_copies_m.resolution), \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i][2].set_ylim((0, max_structs * 1.05))\\n axs[1+i][2].legend(loc=\\\"upper left\\\", fontsize=14)\\n \\n axs[-1][0].set_xlabel(\\\"Structure resolution\\\\n(Angströms, lower is better)\\\", fontsize=14)\\n axs[-1][1].set_xlabel(\\\"Structure resolution\\\\n(Angströms, lower is better)\\\", fontsize=14)\\n axs[-1][2].set_xlabel(\\\"Structure resolution\\\\n(Angströms, lower is better)\\\", fontsize=14)\\n\\n fig.suptitle(\\\"Number of RNA chains by experimental method and resolution\\\", fontsize=16)\\n fig.subplots_adjust(left=0.07, right=0.98, wspace=0.05, \\n hspace=0.05, bottom=0.05, top=0.92)\\n fig.savefig(runDir + \\\"/results/figures/resolutions.png\\\")\\n plt.close()\\n\\n ##########################################\\n # plot Nfam = f(resolution, exp_method)\\n ##########################################\\n\\n df_mapped_copies['n_fam'] = [ len(df_mapped_copies.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies.index)) ]\\n\\n fig, axs = plt.subplots(1, 1+len(methods), figsize=(5*(1+len(methods)), 5))\\n max_res = max(df_mapped_copies.resolution)\\n max_fams = max(df_mapped_copies.n_fam)\\n colors = np.linspace(0,1,1+len(methods))\\n plt.xticks( np.arange(0, max_res+2, 2.0).tolist(), np.arange(0, max_res+2, 2.0).tolist() )\\n\\n axs[0].grid(axis='y', ls='dotted', lw=1)\\n axs[0].plot(df_mapped_copies.resolution, df_mapped_copies.n_fam)\\n axs[0].text(0.95*max_res, 0.95*df_mapped_copies.n_fam.iloc[-1], \\\"%d \\\" % df_mapped_copies.n_fam.iloc[-1], \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[0].set_title(\\\"ALL\\\", fontsize=14)\\n axs[0].set_xlabel(\\\"Structure resolution (Angströms)\\\", fontsize=14)\\n axs[0].set_ylabel(\\\"Number of Rfam families\\\", fontsize=14)\\n axs[0].set_ylim((0, max_res * 1.05))\\n axs[0].set_ylim((0, max_fams * 1.05))\\n \\n for i,m in enumerate(methods):\\n df_mapped_copies_m = df_mapped_copies[ df_mapped_copies.exp_method == m].drop(\\\"n_fam\\\", axis=1).copy()\\n df_mapped_copies_m['n_fam'] = [ len(df_mapped_copies_m.rfam_acc[:i+1].unique()) for i in range(len(df_mapped_copies_m.index)) ]\\n print(\\\">\\\", df_mapped_copies_m.n_fam.iloc[-1], \\\"different RNA families have a 3D structure solved by\\\", m)\\n\\n axs[1+i].grid(axis='y', ls='dotted', lw=1)\\n axs[1+i].plot(df_mapped_copies_m.resolution, df_mapped_copies_m.n_fam, )\\n axs[1+i].text(0.95*max(df_mapped_copies_m.resolution), 0.95*df_mapped_copies_m.n_fam.iloc[-1], \\\"%d \\\" % df_mapped_copies_m.n_fam.iloc[-1], \\n horizontalalignment='right', verticalalignment='top', fontsize=14)\\n axs[1+i].set_xlim((0, max_res * 1.05))\\n axs[1+i].set_ylim((0, max_fams * 1.05))\\n axs[1+i].set_xlabel(\\\"Structure resolution (Angströms)\\\", fontsize=14)\\n axs[1+i].set_title(m, fontsize=14)\\n axs[1+i].set_yticklabels([])\\n \\n fig.suptitle(\\\"Number of RNA families used by experimental method and resolution\\\", fontsize=16)\\n fig.subplots_adjust(left=0.05, right=0.98, wspace=0.05, \\n hspace=0.05, bottom=0.12, top=0.84)\\n fig.savefig(runDir + \\\"/results/figures/Nfamilies.png\\\")\\n plt.close()\",\n \"def calculateCosts(self):\\n self.costs = 0\\n for house in self.houses:\\n if not house.distance == 1000:\\n self.costs += house.distance * 9\\n for battery in self.batteries:\\n self.costs += battery.costs\\n return self.costs\",\n \"def _cost_route_fine(self):\\n return self.fine\",\n \"def cost(distance, highway, bicycle, incline, preferences):\\n\\n #unpack preferences\\n (flatness_pref, bicycle_pref, distance_pref,\\n motorway_pref, highway_pref, residential_pref) = preferences\\n multiplier = 1 + bike_multiplier(bicycle, bicycle_pref) + road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref)\\n if multiplier <= 0:\\n multiplier = 0.01\\n incl = incline_multiplier(float(incline))*flatness_pref\\n cost = float(distance) * multiplier + incl\\n if cost <= 0:\\n cost = 0.01\\n return cost\",\n \"def cost(self):\\n cost = 0\\n for battery in self.grid.batteries:\\n for house in battery.connections:\\n cost += house.distances[house.connection] * 9\\n cost += battery.cost\\n return cost\",\n \"def total_cost(self, system=None):\\n system = system or self.system()\\n if system == 'grid':\\n cost = self['system (grid)']['internal system nodal cost']\\n else:\\n cost = self['system (%s)' % system]['system nodal cost']\\n cost = float(cost)\\n return cost\",\n \"def update_cost(self, id):\\n cost = 0\\n for i, [source, sinks] in enumerate(self.nets):\\n if id == source:\\n self.costs[i] = self.calc_half_perimeter(source, sinks)\\n cost += self.costs[i]\\n elif id in sinks:\\n self.costs[i] = self.calc_half_perimeter(source, sinks)\\n cost += self.costs[i]\\n else:\\n cost += self.costs[i]\\n\\n self.cost = cost\\n return True\",\n \"def compute_optimalReward(task):\\n\\n\\tT = 15.0\\n\\tweights = 0\\n\\tif task == TABLE_TASK or task == COFFEE_TASK:\\n\\t\\tweights = 1\\n\\telif task == LAPTOP_TASK:\\n\\t\\tweights = 10\\n\\n\\t# initialize start/goal based on task \\n\\tif task == COFFEE_TASK or task == HUMAN_TASK:\\n\\t\\tpick = pick_shelf\\n\\telse:\\n\\t\\tpick = pick_basic\\n\\n\\tif task == LAPTOP_TASK:\\n\\t\\tplace = place_higher\\n\\telse:\\n\\t\\tplace = place_lower\\n\\t\\t\\n\\tstartRad = np.array(pick)*(math.pi/180.0)\\n\\tgoalRad = np.array(place)*(math.pi/180.0)\\n\\tstart = startRad\\n\\tgoal = goalRad\\n\\n\\tplan = Planner(task)\\t\\n\\tfilename = None\\n\\tif task == 1:\\n\\t\\tfilename = \\\"task1.csv\\\"\\n\\telif task == 2:\\n\\t\\tfilename = \\\"task2.csv\\\"\\n\\telif task == 3:\\n\\t\\tfilename = \\\"task3.csv\\\"\\n\\t\\t\\n\\t# get optimal waypts from file\\n\\twaypts = get_opt_waypts(filename)\\n\\tr = plan.featurize(waypts)\\n\\tRvel = r[0]\\n\\tRfeat = np.sum(r[1])\\n\\n\\tplan.kill_planner()\\n\\treturn (Rvel, Rfeat)\",\n \"def total_cost(path: Path) -> float:\\n\\t\\n\\tdistance = calc_total_dist(path)\\n\\tavg_speed = calc_average_speed(path)\\n\\t\\n\\t# Speed is less important, but gets a huge multiplier, because speed and\\n\\t# \\tdistance are in different units. Speed requires a high ratio to have\\n\\t# \\tsimilar amounts of variation.\\n\\tSPEED_DISTANCE_COST_RATIO = 7865.099\\n\\t\\n\\treturn (\\n\\t\\t(distance * 1) +\\n\\t\\t(-avg_speed * SPEED_DISTANCE_COST_RATIO)\\n\\t)\",\n \"def GetPathCost(self, bucketOfActions):\",\n \"def compute_network_load_and_bottleneck_workload(env: ControlledRandomWalk) \\\\\\n -> Tuple[np.ndarray, np.ndarray, np.ndarray, List]:\\n xi = cvx.Variable((env.num_buffers, 1))\\n nu = cvx.Variable((env.num_resources, 1))\\n objective = cvx.Maximize(xi.T * env.job_generator.demand_rate)\\n constraints = [\\n -env.job_generator.buffer_processing_matrix.T * xi - env.constituency_matrix.T * nu\\n <= np.zeros((env.num_activities, 1)),\\n np.ones((env.num_resources, 1)).T * nu <= 1,\\n nu >= np.zeros((env.num_resources, 1))\\n ]\\n prob = cvx.Problem(objective, constraints)\\n network_load = prob.solve(solver=cvx.CPLEX)\\n return network_load, xi, nu, constraints\",\n \"def Option3_routing(self, S, D, L):\\n if self.has_path(S, D): \\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \\n Opt_path = Shortest_path\\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\\n return path_cost_with_concave_function, Opt_path\\n while len(Shortest_path) != 0:\\n path_cost = self.additive_path_cost(Shortest_path, 'w') \\n #self.logger.info('Path cost - %d', path_cost)\\n if path_cost <= L:\\n \\\"\\\"\\\"go to path cost with weighted sum\\\"\\\"\\\"\\n path_cost_with_concave_function = self.calculate_path_cost_with_concave_function(Shortest_path, 'c1', 'c2')\\n self.G = self.rm_edge_constraint(path_cost_with_concave_function) # remove all links where the concave link is greater than PathConcave_cost \\n Opt_path = Shortest_path\\n if self.has_path(S, D):\\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\\n else:\\n Shortest_path = [] \\n else:\\n break \\n else:\\n self.logger.info('No path from %s to %s', S, D)\\n Opt_path = []\\n path_cost_with_concave_function = 0\\n return path_cost_with_concave_function, Opt_path\",\n \"def _calc_desc_and_queues(\\n total_numa_nodes, total_ports_per_numa, total_rx_queues, ports_per_numa_value\\n ):\\n\\n # Get the number of rx queues\\n rx_queues = max(1, total_rx_queues)\\n tx_queues = rx_queues * total_numa_nodes + 1\\n\\n # Get the descriptor entries\\n desc_entries = 1024\\n ports_per_numa_value[\\\"rx_queues\\\"] = rx_queues\\n total_mbufs = (\\n (rx_queues * desc_entries) + (tx_queues * desc_entries)\\n ) * total_ports_per_numa\\n\\n return total_mbufs\",\n \"def work(params) -> Union[None, float]:\\n try:\\n # either HTTP or bindings\\n if host:\\n path = action if action == \\\"route\\\" else \\\"sources_to_targets\\\"\\n params_str = delimit_tuple(\\n tuple((delimit_tuple(x) for x in params)), delimiter=\\\";\\\"\\n )\\n route = requests.get(f\\\"{host}/{path}/v1/driving/{params_str}\\\")\\n else:\\n route = router.route(params) if action == \\\"route\\\" else None\\n except (RuntimeError, requests.exceptions.BaseHTTPError):\\n return None\\n\\n if (\\n random() > 0.95\\n ): # assume that large number of routes will be tested, only print sample in debug mode\\n LOGGER.debug(f\\\"Calculated route between {params[0]} and {params[1]}\\\")\\n\\n if report:\\n result = route.json()\\n if action == \\\"route\\\":\\n try:\\n dist = sum([x[\\\"distance\\\"] for x in result[\\\"routes\\\"]])\\n except KeyError:\\n LOGGER.critical(\\n f\\\"No route was found from {params[0]} to {params[1]}. \\\"\\n f\\\"Try regenerating the locations or specify a more narrow bounding box.\\\"\\n )\\n return None\\n else:\\n dists = [\\n inner[\\\"distance\\\"]\\n for outer in route[\\\"sources_to_targets\\\"]\\n for inner in outer\\n ]\\n dist: float = mean(filter(lambda x: x is not None, dists))\\n\\n return dist\",\n \"def route_info(self, route):\\r\\n total_distance = 0\\r\\n cost_mult = 0.35\\r\\n cost = 0\\r\\n time = 0\\r\\n if route[0] in self.edges:\\r\\n for i in range(len(route) - 1):\\r\\n for edge in self.edges[route[i]]:\\r\\n if edge.destination == route[i + 1]:\\r\\n total_distance += edge.distance\\r\\n cost += cost_mult * edge.distance\\r\\n time += self.calc_time(edge.distance)\\r\\n outgoing = len(self.edges[edge.destination])\\r\\n # if this airport is not the last one since we don't need to calculate layover for last\\r\\n if i is not len(route) - 2:\\r\\n time += 2 - ((1 / 6) * (outgoing - 1))\\r\\n if cost_mult > 0:\\r\\n cost_mult -= 0.05\\r\\n break;\\r\\n else:\\r\\n if edge == self.edges[route[i]][-1]:\\r\\n return\\r\\n return total_distance, round(cost, 2), round(time, 2)\",\n \"def check_path_availability(self, path, bandwidth):\\n total = 0\\n for endpoint_a, endpoint_b in zip(path[:-1], path[1:]):\\n link = Link(Endpoint(endpoint_a[:23], endpoint_a[24:]),\\n Endpoint(endpoint_b[:23], endpoint_b[24:]),\\n bandwidth)\\n avail = self.check_link_availability(link)\\n if avail is None:\\n return None\\n total += avail\\n return total\",\n \"def dist_cost(s_vr, failed_vr, neighbor_vr, dist_matrix, w_a1, w_a2):\\n #print s_vr, failed_vr, neighbor_vr\\n dist_i_f = dist_matrix[s_vr][failed_vr + 1]\\n dist_i_k = dist_matrix[s_vr][neighbor_vr + 1]\\n dist = w_a1 * float(dist_i_f) + w_a2 * float(dist_i_k)\\n #print \\\"d_i_f: \\\", dist_i_f, \\\", dist_i_k: \\\", dist_i_k\\n return dist\",\n \"def test_network_calculate_variables(request):\\n print(\\\"\\\\n--Starting:\\\", request.node.name)\\n\\n net = ModelRoadwayNetwork.read(\\n link_file=STPAUL_LINK_FILE,\\n node_file=STPAUL_NODE_FILE,\\n shape_file=STPAUL_SHAPE_FILE,\\n fast=True,\\n )\\n net.calculate_county()\\n print(\\\"County Frequency\\\")\\n print(net.links_df[\\\"county\\\"].value_counts())\\n\\n net.calculate_mpo()\\n print(\\\"MPO Frequency\\\")\\n print(net.links_df[\\\"mpo\\\"].value_counts())\\n ## todo write an assert that actually tests something\",\n \"def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69715726","0.6957851","0.6760472","0.6361233","0.6345169","0.61192685","0.61020505","0.6086766","0.60547054","0.5906217","0.5893766","0.58539325","0.58028054","0.56963044","0.5695608","0.5679503","0.56758183","0.56425416","0.5628271","0.5583995","0.55727","0.55416006","0.5533431","0.5531597","0.5522171","0.5478762","0.54680395","0.5465506","0.5453772","0.5453414","0.5452143","0.54436773","0.54397666","0.5436558","0.5434805","0.543347","0.54196864","0.5394341","0.5377189","0.53563946","0.5351983","0.5335932","0.53287977","0.53222764","0.5320723","0.5313806","0.53105515","0.5290681","0.5288917","0.5288729","0.52886707","0.5279843","0.52701724","0.5267743","0.5263145","0.526225","0.52464414","0.52331364","0.522338","0.5222993","0.5206095","0.52044183","0.520116","0.5199797","0.5198645","0.5190081","0.5178645","0.5169594","0.5160753","0.5158343","0.5156981","0.5148746","0.5127397","0.5127016","0.512625","0.5126006","0.51097983","0.50984967","0.50967926","0.50963783","0.5094963","0.5092705","0.50805163","0.5078699","0.5078262","0.50716436","0.50690645","0.50649685","0.5064318","0.5061489","0.5056106","0.5056064","0.5051156","0.50475425","0.50432354","0.504028","0.5038236","0.5029972","0.5027988","0.50056547"],"string":"[\n \"0.69715726\",\n \"0.6957851\",\n \"0.6760472\",\n \"0.6361233\",\n \"0.6345169\",\n \"0.61192685\",\n \"0.61020505\",\n \"0.6086766\",\n \"0.60547054\",\n \"0.5906217\",\n \"0.5893766\",\n \"0.58539325\",\n \"0.58028054\",\n \"0.56963044\",\n \"0.5695608\",\n \"0.5679503\",\n \"0.56758183\",\n \"0.56425416\",\n \"0.5628271\",\n \"0.5583995\",\n \"0.55727\",\n \"0.55416006\",\n \"0.5533431\",\n \"0.5531597\",\n \"0.5522171\",\n \"0.5478762\",\n \"0.54680395\",\n \"0.5465506\",\n \"0.5453772\",\n \"0.5453414\",\n \"0.5452143\",\n \"0.54436773\",\n \"0.54397666\",\n \"0.5436558\",\n \"0.5434805\",\n \"0.543347\",\n \"0.54196864\",\n \"0.5394341\",\n \"0.5377189\",\n \"0.53563946\",\n \"0.5351983\",\n \"0.5335932\",\n \"0.53287977\",\n \"0.53222764\",\n \"0.5320723\",\n \"0.5313806\",\n \"0.53105515\",\n \"0.5290681\",\n \"0.5288917\",\n \"0.5288729\",\n \"0.52886707\",\n \"0.5279843\",\n \"0.52701724\",\n \"0.5267743\",\n \"0.5263145\",\n \"0.526225\",\n \"0.52464414\",\n \"0.52331364\",\n \"0.522338\",\n \"0.5222993\",\n \"0.5206095\",\n \"0.52044183\",\n \"0.520116\",\n \"0.5199797\",\n \"0.5198645\",\n \"0.5190081\",\n \"0.5178645\",\n \"0.5169594\",\n \"0.5160753\",\n \"0.5158343\",\n \"0.5156981\",\n \"0.5148746\",\n \"0.5127397\",\n \"0.5127016\",\n \"0.512625\",\n \"0.5126006\",\n \"0.51097983\",\n \"0.50984967\",\n \"0.50967926\",\n \"0.50963783\",\n \"0.5094963\",\n \"0.5092705\",\n \"0.50805163\",\n \"0.5078699\",\n \"0.5078262\",\n \"0.50716436\",\n \"0.50690645\",\n \"0.50649685\",\n \"0.5064318\",\n \"0.5061489\",\n \"0.5056106\",\n \"0.5056064\",\n \"0.5051156\",\n \"0.50475425\",\n \"0.50432354\",\n \"0.504028\",\n \"0.5038236\",\n \"0.5029972\",\n \"0.5027988\",\n \"0.50056547\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75995314"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23590,"cells":{"query":{"kind":"string","value":"Returns the maxlinkutilisation for the graph, given the demands and routing"},"document":{"kind":"string","value":"def calc_slow(self, demands: Demand, routing: Routing) -> float:\n edge_capacities = [e[2]['weight'] for e in\n sorted(self.graph.edges(data=True))]\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\n # Because utilisation compared to link width is what we care about here\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\n\n return np.max(ratio_capacities)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def find_max_flow(graph, start, end):\n try:\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\"weight\")\n return flow_value\n except Exception as e:\n print(\"Error in Max flow computation \", e)\n return \"NaN\"","def get_max_usage(topology, path):\n max_usage = np.finfo(0.0).min\n for i in range(len(path.node_list) - 1):\n max_usage = max(max_usage, topology[path.node_list[i]][path.node_list[i + 1]]['total_units'] - topology[path.node_list[i]][path.node_list[i + 1]]['available_units'])\n return max_usage","def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation","def max_path_cost(self, path, attr): \n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])","def part_2(distances: Distances) -> int:\n\n result, _ = max(generate_routes(distances))\n print(f\"part 2: longest route has distance {result}\")\n return result","def get_current_max_link(self):\n return self.current_max_link","def control_edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.control_edge_count_max or 0)","def maximal_destination_for_passenger(state, problem):\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\n if unsatisfied:\n max_dist = max([p.opt for p in unsatisfied])\n return max_dist\n return 0","def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\n # set availbandwidth to the maximal value\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\n if d.type == 'STATIC':\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\n # subtract the reserved link and internal (inside Infras) bandwidth\n if mode == self.MODE_ADD:\n for d in self.infras:\n for p in d.ports:\n for fr in p.flowrules:\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\n # Flowrules are cummulatively subtracted from the switching \n # capacity of the node.\n d.availres['bandwidth'] -= fr.bandwidth\n if d.availres['bandwidth'] < 0:\n raise RuntimeError(\"The node bandwidth of %s got below zero \"\n \"during available resource calculation!\" %\n d.id)\n # Get all the mapped paths of all SGHops from the NFFG\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\n for sg_hop_id, data in sg_map.iteritems():\n src, dst, flowclass, bandwidth, delay, path = data\n if bandwidth is not None:\n for link in path:\n link.availbandwidth -= bandwidth\n if link.availbandwidth < 0:\n raise RuntimeError(\n \"The link bandwidth of %s got below zero during\"\n \"available resource calculation!\" % link.id)","def node_count_max(self) -> int:\n return int(self.graph_tuple_stats.node_count_max or 0)","def get_highest_preference(self, routes):\n # routes is all possible routes to daddr\n outroutes = {}\n highest = 0\n\n for ip in routes.keys():\n if routes[ip][LPRF] > highest:\n highest = routes[ip][LPRF]\n\n for ip in routes.keys():\n if routes[ip][LPRF] == highest:\n outroutes[ip] = routes[ip]\n\n return outroutes","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.edge_count_max or 0)","def max_dist(graph, source):\r\n q = queue.Queue()\r\n found = {}\r\n distance = {}\r\n for vertex in graph: \r\n found[vertex] = 0\r\n distance[vertex] = -1\r\n max_distance = 0\r\n found[source] = 1\r\n distance[source] = 0\r\n q.put(source)\r\n while q.empty() == False:\r\n current = q.get()\r\n for neighbour in graph[current]:\r\n if found[neighbour] == 0:\r\n found[neighbour] = 1\r\n distance[neighbour] = distance[current] + 1\r\n max_distance = distance[neighbour]\r\n q.put(neighbour)\r\n return max_distance","def compute_path_metric(self, sw, path, util, time_now):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\n #only include extra-domain state when not stale (timestamp), 3) always exclude\n #extra-domain state when calculating the path metric? Here we do (1)\n used = self.graph[u][v]['used'] + util\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def compute_path_metric(self, sw, path, util, time_now, local_contrib):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n # Use the last-learned-via-sync value for a link\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\n used1 = self.graph[u][v]['sync_learned'] + util\n used2 = self.graph[u][v]['used'] + util\n # ['used'] is a strict lower bound for ['sync_learned']\n if used1 > used2: \n used = used1\n logging.debug(\"CS [%s] using sync_learned value 1 [%f]\", str(self.name), used1)\n else:\n used = used2\n logging.debug(\"CS [%s] using sync_learned value 2 [%f]\", str(self.name), used2)\n else:\n logging.debug(\"CS [%s] using tracking value\", str(self.name))\n used = self.graph[u][v]['used'] + util\n\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def get_highest_preference(self, routes):\n outroutes = []\n max_val = float('-inf')\n # find highest local pref first\n for r in routes:\n if r[MESG][LPRF] > max_val:\n max_val = r[MESG][LPRF]\n # find all routes with that val\n for r in routes:\n if r[MESG][LPRF] == max_val:\n outroutes.append(r)\n\n return outroutes","def countMaxDegree(self):\r\n max_degree = [0, 0] # le sommet, son nombre de connection \r\n for i_node, node_connections in enumerate(self.adjMatrix):\r\n connection = self.n - node_connections.count(0) # on compte le nombre de connections du sommet\r\n if connection > max_degree[1]:\r\n max_degree = max_degree[i_node, node_connections]\r\n return max_degree[0], max_degree[1] # C un tuple ! \r","def max_network_performance(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_network_performance\")","def calculate_greatest(self):\n greatest = 0\n for resourceList in self.loading.values():\n for time, use in resourceList:\n if use > greatest:\n greatest = use\n self.emit(\"greatest_calculated\",greatest)\n return greatest","def call_edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.call_edge_count_max or 0)","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def find_maximal_path(graph):\n maximal_path_in_graph = [] # This is where the maximal path in the graph is stored (updates)\n checked_pairs = set() # In order not to check a pair twice, the set stores the already checked pairs (and the\n # reversed order of the tuple\n for node_start in graph.nodes.keys():\n for node_end in graph.nodes.keys():\n tup_of_nodes = (node_start, node_end) # This tuple is checked in checked_pairs\n # Need to make sure that the path is valid (!=Node) and that it is not checked yet\n if graph.find_longest_path(node_start,\n node_end) != None and tup_of_nodes not in checked_pairs:\n tup_of_nodes_reverse = (node_end, node_start) # This is a tuple with the opposite order\n checked_pairs.add(tup_of_nodes)\n checked_pairs.add(tup_of_nodes_reverse)\n maximal_path_for_pair = graph.find_longest_path(node_start, node_end)\n # Updates the maximal path per pair exceeds the current one\n if len(maximal_path_for_pair) > len(maximal_path_in_graph):\n maximal_path_in_graph = maximal_path_for_pair\n return \"Maximal path between nodes is: {}, and the length is {} nodes.\".format(maximal_path_in_graph, \\\n len(maximal_path_in_graph))","def find_max(self):\n return max(self.nodes, key=int)","def test_max_flow(default_plugin_resolver):\n dpr = default_plugin_resolver\n source_node = 0\n target_node = 7\n ebunch = [\n (0, 1, 9),\n (0, 3, 10),\n (1, 4, 3),\n (2, 7, 6),\n (3, 1, 2),\n (3, 4, 8),\n (4, 5, 7),\n (4, 2, 4),\n (5, 2, 5),\n (5, 6, 1),\n (6, 2, 11),\n ]\n nx_graph = nx.DiGraph()\n nx_graph.add_weighted_edges_from(ebunch)\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\"weight\")\n\n expected_flow_value = 6\n bottleneck_nodes = {2, 4}\n expected_nodemap = {2: 6, 4: 6}\n\n mv = MultiVerify(dpr)\n results = mv.compute(\"flow.max_flow\", graph, source_node, target_node)\n\n # Compare flow rate\n results[0].assert_equal(expected_flow_value)\n\n # Normalize actual flow to prepare to transform\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\n\n # Compare sum of out edges for bottleneck nodes\n out_edges = mv.transform(\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\n actual_flow,\n lambda x, y: x + y,\n initial_value=0,\n )\n out_bottleneck = mv.transform(\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\n )\n out_bottleneck.assert_equal(expected_nodemap)\n\n # Compare sum of in edges for bottleneck nodes\n in_edges = mv.transform(\n \"util.graph.aggregate_edges.core_networkx\",\n actual_flow,\n lambda x, y: x + y,\n initial_value=0,\n in_edges=True,\n out_edges=False,\n )\n in_bottleneck = mv.transform(\n \"util.nodemap.select.core_python\", in_edges, bottleneck_nodes\n )\n in_bottleneck.assert_equal(expected_nodemap)","def maxTargets(self):\n return self._getAttribute(Attribute.maxTargets)","def getMaximumDistances(self):\n pass","def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\n pass","def strength_longest_bridge():\n # first again filter all the Nonetype out\n bridges = [ b for b in all_bridges if b != None ]\n\n # the find the strength of the longest bridge\n # in this case the first longest to be found is also the\n # the strongest out of all the longest\n\n return max(bridges, key=lambda b: len(b[1]))[0]","def degree_graph(g):\n return max(degree_node(g, node) for node in g)","def maximum_flow(graph, start, end):\n if not isinstance(graph, BasicGraph):\n raise TypeError(f\"Expected subclass of BasicGraph, not {type(graph)}\")\n Graph = type(graph)\n \n if start not in graph:\n raise ValueError(f\"{start} not in graph\")\n if end not in graph:\n raise ValueError(f\"{end} not in graph\")\n\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\n total_flow = 0\n # -----------------------------------------------------------------------\n # The algorithm\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\n # of DFS, which leads to a lot of node visits.\n #\n # I therefore choose to invert the capacities of the graph so that the\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\n # This allows me to use the shortest path method to find the path with\n # most capacity in the first attempt, resulting in a significant reduction\n # of unassigned flow.\n #\n # By updating G_inverted, with the residual capacity, I can keep using the\n # shortest path, until the capacity is zero, whereby I remove the links\n # When the shortest path method returns 'No path' or when unassigned flow\n # is zero, I exit the algorithm.\n #\n # Even on small graphs, this method is very efficient, despite the overhead\n # of using shortest path. For very large graphs, this method outperforms\n # all other algorithms by orders of magnitude.\n # -----------------------------------------------------------------------\n\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\n inverted_graph = Graph(from_list=edges) # create G_inverted.\n capacity_graph = Graph() # Create structure to record capacity left.\n flow_graph = Graph() # Create structure to record flows.\n\n while unassigned_flow:\n # 1. find the best path\n d, path = shortest_path(inverted_graph, start, end)\n if d == float(\"inf\"): # then there is no path, and we must exit.\n return total_flow, flow_graph\n # else: use the path and lookup the actual flow from the capacity graph.\n\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\"inf\"))) for s, e, d in graph.edges(path=path)])\n\n # 2. update the unassigned flow.\n unassigned_flow -= path_flow\n total_flow += path_flow\n\n # 3. record the flows and update the inverted graph, so that it is\n # ready for the next iteration.\n edges = graph.edges(path)\n for n1, n2, d in edges:\n # 3.a. recording:\n v = flow_graph.edge(n1, n2, default=None)\n if v is None:\n flow_graph.add_edge(n1, n2, path_flow)\n c = graph.edge(n1, n2) - path_flow\n else:\n flow_graph.add_edge(n1, n2, value=v + path_flow)\n c = graph.edge(n1, n2) - (v + path_flow)\n capacity_graph.add_edge(n1, n2, c)\n\n # 3.b. updating:\n # if there is capacity left: update with new 1/capacity\n # else: remove node, as we can't do 1/zero.\n if c > 0:\n inverted_graph.add_edge(n1, n2, 1 / c)\n else:\n inverted_graph.del_edge(n1, n2)\n return total_flow, flow_graph","def get_highest_preference(self, routes):\n # filter out any routes that don't have the highest localPref\n outroutes = routes.copy()\n outroutes.sort(reverse=True, key=lambda r: r[MESG][LPRF])\n highest = outroutes[0][MESG][LPRF]\n outroutes = list(filter(lambda r: r[MESG][LPRF] == highest, outroutes))\n return outroutes","def pair_nodes_with_max_weight_in_shortest_path(graph):\n list_pairs_with_shortest_path = []\n # The following for loop takes each pair, and adds the weight of their shortest path to the list\n for frm_name in graph.nodes:\n for to_name in graph.nodes:\n if frm_name != to_name: # Irrelevant because the question asks \"pair of nodes\"\n shortest_path = graph.find_shortest_path(frm_name, to_name)\n if shortest_path != None: # We must ignore a pair with no path\n path_weight = graph.get_path_weight(shortest_path)\n if path_weight != None: # We must ignore path with None weight\n pair_weight_tup = ((frm_name, to_name), path_weight)\n list_pairs_with_shortest_path.append(pair_weight_tup)\n # print(list_pairs_with_shortest_path) # Was used to check the function\n sorted_list_pairs = sorted(list_pairs_with_shortest_path, key=lambda tup: tup[1], reverse=True)\n pair_with_max = sorted_list_pairs[0] # Pair with the highest weight\n return \"Pair whose shortest path with max weight: {} to {}\".format(pair_with_max[0][0], pair_with_max[0][1])","def data_edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.data_edge_count_max or 0)","def get_max_addr(self):\n\n out = None\n for segment in self.segments:\n if out is None or segment.max_addr > out:\n out = segment.max_addr\n\n if out is None:\n for section in self.sections:\n if out is None or section.max_addr > out:\n out = section.max_addr\n\n if out is None:\n return self.rebase_addr\n else:\n return out + self.rebase_addr","def calc_strongest_bridge(comp_map: CompMap):\n @lru_cache(None)\n def _helper(cur_no_pins: int = 0, used_components: FrozenSet[Component] = frozenset()):\n available_connections = comp_map[cur_no_pins] - used_components\n\n if not available_connections:\n return sum(c.strength for c in used_components)\n\n res = []\n for c in available_connections:\n res.append(_helper(c.other(cur_no_pins), used_components | {c}))\n return max(res)\n res = _helper()\n print(_helper.cache_info())\n return res","def get_highest_preference(self, routes):\n if len(routes) == 1: \n return routes\n if len(routes) == 0: \n return []\n prefList = []\n for val in routes: \n prefList.append(val[\"msg\"][\"localpref\"]) \n highestVal = max(prefList) \n outroutes = []\n for val in routes:\n if val[\"msg\"][\"localpref\"] == highestVal:\n outroutes.append(val)\n return outroutes","def get_max_paper(link_graph: dict):\n papers = []\n for k, v in link_graph.items():\n papers.extend(v.keys())\n return max(papers, key=papers.count)","def largestResolution(resolutions):\n return resolutions[0]","def handle_request(self, sw, util, duration, time_now):\n\n #logging.debug(str(self.graph.edges(data=True)))\n\n #1 Get available paths from servers to switch\n paths = self.get_srv_paths(sw, self.graph)\n\n #2 choose the path which mins the max link utilization for all links\n # along the path\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\n\n if len(bestpath) > 0:\n self.allocate_resources(bestpath, util, time_now, duration)\n else:\n logging.warn(\"[%s] No best path found at switch [%s]\", str(time_now), str(sw))\n\n return bestpath","def _get_maximum(self):\n return self._maximum","def best_routes_for_routers(self) -> Sequence['outputs.GetRouterStatusBestRoutesForRouterResult']:\n return pulumi.get(self, \"best_routes_for_routers\")","def best_routes(self) -> Sequence['outputs.GetRouterStatusBestRouteResult']:\n return pulumi.get(self, \"best_routes\")","def lovliest_path(G):\n m = 0\n ma = None\n mb = None\n for node in G.keys():\n for conn in G[node].keys():\n if G[node][conn] > m:\n m = G[node][conn]\n ma = node\n mb = conn\n print \"found lovliest_path of %s to %s with weight %s\" % (ma,mb,m)\n return (ma,mb)","def produce_max(self, meta, raven_vars, dispatch, t):\n request, meta = self.get_capacity(meta, raven_vars, dispatch, t)\n return request, meta","def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))","def search_for_maximum(self):\n return self.maximise_aquisition(self.expected_improvement)","def get_highest_preference(self, routes):\n # start highest lpref route as the first route's path\n highest_lprf_route = [routes[0]]\n # start the highest lpref as that\n # of the first route's path\n highest_lprf = int(routes[0][LPRF])\n # iterate through all routes in given list and\n # find the one with the highest local pref\n for route in routes:\n r_lprf = int(route[LPRF])\n if r_lprf > highest_lprf:\n highest_lprf = r_lprf\n highest_lprf_route = [route]\n elif r_lprf == highest_lprf:\n highest_lprf_route.append(route)\n return highest_lprf_route","def cost(route):\n cost = 0\n for li in route:\n if cost<li.get_cost():\n cost=li.get_cost()\n return cost","def greedy(self):\n # for each node, find the incoming link with the highest score.\n max_scores = {}\n max_sources = {}\n for source, target in self.iteredges():\n score = self.get_score(source, target)\n max_score = max_scores.get(target)\n if max_score is None or score > max_score:\n max_scores[target] = score\n max_sources[target] = source\n # then build a graph out of just these links.\n succs = dict((n, []) for n in self)\n for target, source in max_sources.items():\n succs[source].append(target)\n return Digraph(succs, self.get_score, self.get_label)","def global_efficiency(graph):\n return nx.global_efficiency(graph.graph)","def max_num_links(self):\n return self._max_num_links","def calculate_best_way(self) -> int:\n node = self._find_lowest_cost_node()\n while node:\n cost = self.costs[node]\n neighbors = self.graph[node]\n for neighbor in neighbors.keys():\n node_cost = cost + neighbors[neighbor]\n if self.costs[neighbor] > node_cost:\n self.costs[neighbor] = node_cost\n self.parents[neighbor] = node\n self.closed_nodes.append(node)\n node = self._find_lowest_cost_node()\n\n return self.costs[\"fin\"]","def _maximum(self) -> float:\n if self._type == \"power\":\n return 5.0\n elif self._type == \"setpoint\":\n return self._product.get_data_config_json()[\"_value_setpoint_max\"]\n elif self._type == \"fan1\":\n fan = 1\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]\n elif self._type == \"fan2\":\n fan = 2\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]\n elif self._type == \"fan3\":\n fan = 3\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]","def calculate_ucb_max(self, node):\n pass","def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,\n best_path):\n path[0] = path[0] + [start]\n \n if digraph.has_node(Node(start)) == False or digraph.has_node(Node(end)) == False:\n raise ValueError('Start or end node are not valid')\n elif start == end :\n return path\n else:\n for edge in digraph.get_edges_for_node(Node(start)):\n \n node = str(edge.get_destination())\n tot_distance = edge.get_total_distance() + path[1]\n tot_outdoors = edge.get_outdoor_distance() + path[2]\n\n if node not in path[0] and tot_distance <= best_dist and tot_outdoors <= max_dist_outdoors :\n updated_path = [path[0], tot_distance, tot_outdoors]\n new_path = get_best_path(digraph, node, end, updated_path, max_dist_outdoors, best_dist, best_path)\n \n if new_path:\n if not best_dist or new_path[1] < best_dist: \n best_path = new_path[0]\n best_dist = new_path[1]\n\n return best_path, best_dist","def get_max_lb(self):\n max_lb = 0\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"lower_bound\"] > max_lb:\n max_lb = self.arc_info[arc][\"lower_bound\"]\n return max_lb","def score_max_depths(graph, max_depths):\n ###TODO\n pass","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def find_best_route(all_cost, all_routes):\n cost_best_route = np.inf\n for i in range(len(all_cost)):\n if all_cost[i] < cost_best_route:\n cost_best_route = all_cost[i]\n best_route = all_routes[i]\n return cost_best_route, best_route","def max_cardinality():\r\n #create a list containing the number of each vertex involvement.\r\n array = []\r\n for i in adj:\r\n array += [i[0],i[1]]\r\n\r\n #compute the degree by counting the involment\r\n degree = Counter(array).most_common()\r\n\r\n #retrieve the degree only\r\n degree_ = [ i[1] for i in degree]\r\n\r\n degree_ = np.array(degree_)\r\n \r\n max_m = None\r\n \r\n #check if m is valid\r\n for i in range(degree[0][1]+2)[2:]:\r\n \r\n #valid if there are at least m vertex with degree equals to at least m-1 \r\n if i < len(np.where(degree_>=i-1)[0]):\r\n max_m = i\r\n else:\r\n break\r\n max_m += 1\r\n print(f'maximum possible clique cardinality :{max_m}')\r\n return max_m","def max_edges(self):\n return self._max_edges","def max_weight(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def edge_position_max(self) -> int:\n return int(self.graph_tuple_stats.edge_position_max or 0)","def find_max_depth(start_url):\n print \"****** sequence of links that must be followed to reach the page *****\"\n S, Q = set(), deque()\n Q.append(start_url)\n while Q:\n u = Q.popleft()\n if u in S: continue\n b = u\n S.add(u)\n Q.extend(getLinks(u))\n find_shortest_path(start_url,b)\n print \"****** URL that is the greatest distance from start_url *****\"\n print b","def _get_max_estimated_bandit(self)->Bandit:\n # print(\"mus - \", self.mu)\n # print(\"actions - \", np.argmax(self.mu))\n unique, counts = np.unique(self.mu, return_counts=True)\n lens = counts[np.argmax(unique)] \n if lens>1: # if two actions have same argmax\n # then return arbitrarily from those max ones\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\n return np.random.choice(maxs)\n # otherwise return the max one\n return self.bandits[np.argmax(self.mu)]","def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\n if highway == 'motorway':\n result = -motorway_pref*0.5\n elif highway == 'primary':\n result = -highway_pref*0.5\n elif highway == 'residential' or highway == 'service':\n result = -residential_pref*0.5\n elif highway == 'cycleway':\n result = -bicycle_pref * 0.8\n else:\n result = 0\n return result","def find_max():\n bridges = all_bridges\n bridges = [ b for b in bridges if b != None ]\n return max(bridges)","def find_maximum_required_assets(geotype, area_km2, capacity_lookup):\n capacity_values = []\n for key, values in capacity_lookup.items():\n if key[0] == geotype:\n for value in values:\n capacity_values.append(value[0])\n\n max_assets_km2 = max(capacity_values)\n\n max_assets = max_assets_km2 * area_km2\n\n return roundup(max_assets)","def max_flow(self, source, sink):\n\n max_flow = 0\n\n for i in range(self.V):\n for j in range(self.V):\n self.flow[i, j] = 0\n\n while self.bfs(source, sink):\n increment = maxint\n\n u = sink\n\n while self.pred[u] != -1:\n increment = min(\n increment, self.capacity[self.pred[u], u] - self.flow[self.pred[u], u])\n u = self.pred[u]\n\n u = sink\n\n while self.pred[u] != -1:\n self.flow[self.pred[u], u] += increment\n self.flow[u, self.pred[u]] -= increment\n u = self.pred[u]\n\n max_flow += increment\n\n return max_flow","def max_surge(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"max_surge\")","def max_surge(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_surge\")","def maxValue(gameState, depth, a, b):\n ultimateMove = None # The best move the agent can do\n if gameState.isWin() or gameState.isLose(): # if terminal node return gamescore\n return self.evaluationFunction(gameState)\n bestValue = -math.inf\n # for all of max agents moves\n for action in gameState.getLegalActions(0):\n value = minValue(gameState.generateSuccessor(\n 0, action), depth, 1, a, b) # save value from call to minimizing agent\n if value > bestValue: # if value has increased, update parametres\n bestValue = value\n ultimateMove = action\n a = max(a, bestValue) # updates a=alpha if bestvalue > alpha\n if bestValue > b: # if value is greater than connected branch, do prune\n return bestValue\n if depth == self.depth: # if top node, return the best move\n return ultimateMove\n else:\n # if not top node (and no pruning) return best value\n return bestValue","def get_graph_attributes(net_G):\r\n # number of nodes\r\n num_of_nodes = net_G.number_of_nodes()\r\n # number of nodes\r\n num_of_edges = net_G.number_of_edges()\r\n # density of net\r\n net_density = nx.density(net_G)\r\n # maximum degree and average degree\r\n nodes_degree = nx.degree(net_G)\r\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\r\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\r\n # global clustering coefficient: n - count numbers of paths of length two\r\n nodes_triangles = nx.triangles(net_G)\r\n num_of_triangles = sum(nodes_triangles.values())\r\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\r\n n = 0 \r\n for node in pairs_path_length.keys(): \r\n for item in pairs_path_length[node].values():\r\n if item == 2:\r\n n = n + 1\r\n global_clustering_coefficient = (num_of_triangles * 6) / n\r\n # size of giant component\r\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\r\n # return number of edges in graph=graph size\r\n size_of_giant = nx.Graph.size(giant_component)\r\n # calculate the average path length of giant component\r\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\r\n # maximum centrality and average centrality\r\n nodes_centrality = nx.degree_centrality(net_G)\r\n maximum_of_centrality = max(nodes_centrality.values())\r\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\r\n # maximum betweenness centrality\r\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\r\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\r\n # maximum closeness centrality\r\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\r\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\r\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\r\n # summarize graph attributes\r\n graph_attributes = [[\"Number of nodes:\", num_of_nodes], \\\r\n [\"Number of edges:\", num_of_edges], \\\r\n [\"Global clustering coefficient:\", global_clustering_coefficient], \\\r\n [\"Maximum degree:\", maximum_degree], \\\r\n [\"Average degree:\", average_degree], \\\r\n [\"Size of giant component:\", size_of_giant], \\\r\n [\"Average path length:\", average_shortest_path_length],\\\r\n [\"Maximum centrality:\", maximum_of_centrality], \\\r\n [\"Average centrality:\", average_of_centrality],\\\r\n [\"Maximum betweenness centrality:\", maximum_betweenness_centrality],\\\r\n [\"Maximum closeness centrality:\", maximum_closeness_centrality], \\\r\n [\"Average closeness centrality:\", average_closeness_centrality], \\\r\n [\"Net density:\", net_density]]\r\n return graph_attributes","def maxWeightMatching(edges, maxcardinality=False):\r\n\r\n #\r\n # Vertices are numbered 0 .. (nvertex-1).\r\n # Non-trivial blossoms are numbered nvertex .. (2*nvertex-1)\r\n #\r\n # Edges are numbered 0 .. (nedge-1).\r\n # Edge endpoints are numbered 0 .. (2*nedge-1), such that endpoints\r\n # (2*k) and (2*k+1) both belong to edge k.\r\n #\r\n # Many terms used in the comments (sub-blossom, T-vertex) come from\r\n # the paper by Galil; read the paper before reading this code.\r\n #\r\n\r\n # Python 2/3 compatibility.\r\n from sys import version as sys_version\r\n if sys_version < '3':\r\n integer_types = (int, long)\r\n else:\r\n integer_types = (int,)\r\n\r\n # Deal swiftly with empty graphs.\r\n if not edges:\r\n return [ ]\r\n\r\n # Count vertices.\r\n nedge = len(edges)\r\n nvertex = 0\r\n for (i, j, w) in edges:\r\n assert i >= 0 and j >= 0 #and i != j\r\n if i >= nvertex:\r\n nvertex = i + 1\r\n if j >= nvertex:\r\n nvertex = j + 1\r\n\r\n # Find the maximum edge weight.\r\n maxweight = max(0, max([ wt for (i, j, wt) in edges ]))\r\n\r\n # If p is an edge endpoint,\r\n # endpoint[p] is the vertex to which endpoint p is attached.\r\n # Not modified by the algorithm.\r\n endpoint = [ edges[p//2][p%2] for p in range(2*nedge) ]\r\n\r\n # If v is a vertex,\r\n # neighbend[v] is the list of remote endpoints of the edges attached to v.\r\n # Not modified by the algorithm.\r\n neighbend = [ [ ] for i in range(nvertex) ]\r\n for k in range(len(edges)):\r\n (i, j, w) = edges[k]\r\n neighbend[i].append(2*k+1)\r\n neighbend[j].append(2*k)\r\n\r\n # If v is a vertex,\r\n # mate[v] is the remote endpoint of its matched edge, or -1 if it is single\r\n # (i.e. endpoint[mate[v]] is v's partner vertex).\r\n # Initially all vertices are single; updated during augmentation.\r\n mate = nvertex * [ -1 ]\r\n\r\n # If b is a top-level blossom,\r\n # label[b] is 0 if b is unlabeled (free);\r\n # 1 if b is an S-vertex/blossom;\r\n # 2 if b is a T-vertex/blossom.\r\n # The label of a vertex is found by looking at the label of its\r\n # top-level containing blossom.\r\n # If v is a vertex inside a T-blossom,\r\n # label[v] is 2 iff v is reachable from an S-vertex outside the blossom.\r\n # Labels are assigned during a stage and reset after each augmentation.\r\n label = (2 * nvertex) * [ 0 ]\r\n\r\n # If b is a labeled top-level blossom,\r\n # labelend[b] is the remote endpoint of the edge through which b obtained\r\n # its label, or -1 if b's base vertex is single.\r\n # If v is a vertex inside a T-blossom and label[v] == 2,\r\n # labelend[v] is the remote endpoint of the edge through which v is\r\n # reachable from outside the blossom.\r\n labelend = (2 * nvertex) * [ -1 ]\r\n\r\n # If v is a vertex,\r\n # inblossom[v] is the top-level blossom to which v belongs.\r\n # If v is a top-level vertex, v is itself a blossom (a trivial blossom)\r\n # and inblossom[v] == v.\r\n # Initially all vertices are top-level trivial blossoms.\r\n inblossom = list(range(nvertex))\r\n\r\n # If b is a sub-blossom,\r\n # blossomparent[b] is its immediate parent (sub-)blossom.\r\n # If b is a top-level blossom, blossomparent[b] is -1.\r\n blossomparent = (2 * nvertex) * [ -1 ]\r\n\r\n # If b is a non-trivial (sub-)blossom,\r\n # blossomchilds[b] is an ordered list of its sub-blossoms, starting with\r\n # the base and going round the blossom.\r\n blossomchilds = (2 * nvertex) * [ None ]\r\n\r\n # If b is a (sub-)blossom,\r\n # blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).\r\n blossombase = list(range(nvertex)) + nvertex * [ -1 ]\r\n\r\n # If b is a non-trivial (sub-)blossom,\r\n # blossomendps[b] is a list of endpoints on its connecting edges,\r\n # such that blossomendps[b][i] is the local endpoint of blossomchilds[b][i]\r\n # on the edge that connects it to blossomchilds[b][wrap(i+1)].\r\n blossomendps = (2 * nvertex) * [ None ]\r\n\r\n # If v is a free vertex (or an unreached vertex inside a T-blossom),\r\n # bestedge[v] is the edge to an S-vertex with least slack,\r\n # or -1 if there is no such edge.\r\n # If b is a (possibly trivial) top-level S-blossom,\r\n # bestedge[b] is the least-slack edge to a different S-blossom,\r\n # or -1 if there is no such edge.\r\n # This is used for efficient computation of delta2 and delta3.\r\n bestedge = (2 * nvertex) * [ -1 ]\r\n\r\n # If b is a non-trivial top-level S-blossom,\r\n # blossombestedges[b] is a list of least-slack edges to neighbouring\r\n # S-blossoms, or None if no such list has been computed yet.\r\n # This is used for efficient computation of delta3.\r\n blossombestedges = (2 * nvertex) * [ None ]\r\n\r\n # List of currently unused blossom numbers.\r\n unusedblossoms = list(range(nvertex, 2*nvertex))\r\n\r\n # If v is a vertex,\r\n # dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual\r\n # optimization problem (multiplication by two ensures integer values\r\n # throughout the algorithm if all edge weights are integers).\r\n # If b is a non-trivial blossom,\r\n # dualvar[b] = z(b) where z(b) is b's variable in the dual optimization\r\n # problem.\r\n dualvar = nvertex * [ maxweight ] + nvertex * [ 0 ]\r\n\r\n # If allowedge[k] is true, edge k has zero slack in the optimization\r\n # problem; if allowedge[k] is false, the edge's slack may or may not\r\n # be zero.\r\n allowedge = nedge * [ False ]\r\n\r\n # Queue of newly discovered S-vertices.\r\n queue = [ ]\r\n\r\n # Return 2 * slack of edge k (does not work inside blossoms).\r\n def slack(k):\r\n (i, j, wt) = edges[k]\r\n return dualvar[i] + dualvar[j] - 2 * wt\r\n\r\n # Generate the leaf vertices of a blossom.\r\n def blossomLeaves(b):\r\n if b < nvertex:\r\n yield b\r\n else:\r\n for t in blossomchilds[b]:\r\n if t < nvertex:\r\n yield t\r\n else:\r\n for v in blossomLeaves(t):\r\n yield v\r\n\r\n # Assign label t to the top-level blossom containing vertex w\r\n # and record the fact that w was reached through the edge with\r\n # remote endpoint p.\r\n def assignLabel(w, t, p):\r\n if DEBUG: DEBUG('assignLabel(%d,%d,%d)' % (w, t, p))\r\n b = inblossom[w]\r\n assert label[w] == 0 and label[b] == 0\r\n label[w] = label[b] = t\r\n labelend[w] = labelend[b] = p\r\n bestedge[w] = bestedge[b] = -1\r\n if t == 1:\r\n # b became an S-vertex/blossom; add it(s vertices) to the queue.\r\n queue.extend(blossomLeaves(b))\r\n if DEBUG: DEBUG('PUSH ' + str(list(blossomLeaves(b))))\r\n elif t == 2:\r\n # b became a T-vertex/blossom; assign label S to its mate.\r\n # (If b is a non-trivial blossom, its base is the only vertex\r\n # with an external mate.)\r\n base = blossombase[b]\r\n assert mate[base] >= 0\r\n assignLabel(endpoint[mate[base]], 1, mate[base] ^ 1)\r\n\r\n # Trace back from vertices v and w to discover either a new blossom\r\n # or an augmenting path. Return the base vertex of the new blossom or -1.\r\n def scanBlossom(v, w):\r\n if DEBUG: DEBUG('scanBlossom(%d,%d)' % (v, w))\r\n # Trace back from v and w, placing breadcrumbs as we go.\r\n path = [ ]\r\n base = -1\r\n while v != -1 or w != -1:\r\n # Look for a breadcrumb in v's blossom or put a new breadcrumb.\r\n b = inblossom[v]\r\n if label[b] & 4:\r\n base = blossombase[b]\r\n break\r\n assert label[b] == 1\r\n path.append(b)\r\n label[b] = 5\r\n # Trace one step back.\r\n assert labelend[b] == mate[blossombase[b]]\r\n if labelend[b] == -1:\r\n # The base of blossom b is single; stop tracing this path.\r\n v = -1\r\n else:\r\n v = endpoint[labelend[b]]\r\n b = inblossom[v]\r\n assert label[b] == 2\r\n # b is a T-blossom; trace one more step back.\r\n assert labelend[b] >= 0\r\n v = endpoint[labelend[b]]\r\n # Swap v and w so that we alternate between both paths.\r\n if w != -1:\r\n v, w = w, v\r\n # Remove breadcrumbs.\r\n for b in path:\r\n label[b] = 1\r\n # Return base vertex, if we found one.\r\n return base\r\n\r\n # Construct a new blossom with given base, containing edge k which\r\n # connects a pair of S vertices. Label the new blossom as S; set its dual\r\n # variable to zero; relabel its T-vertices to S and add them to the queue.\r\n def addBlossom(base, k):\r\n (v, w, wt) = edges[k]\r\n bb = inblossom[base]\r\n bv = inblossom[v]\r\n bw = inblossom[w]\r\n # Create blossom.\r\n b = unusedblossoms.pop()\r\n if DEBUG: DEBUG('addBlossom(%d,%d) (v=%d w=%d) -> %d' % (base, k, v, w, b))\r\n blossombase[b] = base\r\n blossomparent[b] = -1\r\n blossomparent[bb] = b\r\n # Make list of sub-blossoms and their interconnecting edge endpoints.\r\n blossomchilds[b] = path = [ ]\r\n blossomendps[b] = endps = [ ]\r\n # Trace back from v to base.\r\n while bv != bb:\r\n # Add bv to the new blossom.\r\n blossomparent[bv] = b\r\n path.append(bv)\r\n endps.append(labelend[bv])\r\n assert (label[bv] == 2 or\r\n (label[bv] == 1 and labelend[bv] == mate[blossombase[bv]]))\r\n # Trace one step back.\r\n assert labelend[bv] >= 0\r\n v = endpoint[labelend[bv]]\r\n bv = inblossom[v]\r\n # Reverse lists, add endpoint that connects the pair of S vertices.\r\n path.append(bb)\r\n path.reverse()\r\n endps.reverse()\r\n endps.append(2*k)\r\n # Trace back from w to base.\r\n while bw != bb:\r\n # Add bw to the new blossom.\r\n blossomparent[bw] = b\r\n path.append(bw)\r\n endps.append(labelend[bw] ^ 1)\r\n assert (label[bw] == 2 or\r\n (label[bw] == 1 and labelend[bw] == mate[blossombase[bw]]))\r\n # Trace one step back.\r\n assert labelend[bw] >= 0\r\n w = endpoint[labelend[bw]]\r\n bw = inblossom[w]\r\n # Set label to S.\r\n assert label[bb] == 1\r\n label[b] = 1\r\n labelend[b] = labelend[bb]\r\n # Set dual variable to zero.\r\n dualvar[b] = 0\r\n # Relabel vertices.\r\n for v in blossomLeaves(b):\r\n if label[inblossom[v]] == 2:\r\n # This T-vertex now turns into an S-vertex because it becomes\r\n # part of an S-blossom; add it to the queue.\r\n queue.append(v)\r\n inblossom[v] = b\r\n # Compute blossombestedges[b].\r\n bestedgeto = (2 * nvertex) * [ -1 ]\r\n for bv in path:\r\n if blossombestedges[bv] is None:\r\n # This subblossom does not have a list of least-slack edges;\r\n # get the information from the vertices.\r\n nblists = [ [ p // 2 for p in neighbend[v] ]\r\n for v in blossomLeaves(bv) ]\r\n else:\r\n # Walk this subblossom's least-slack edges.\r\n nblists = [ blossombestedges[bv] ]\r\n for nblist in nblists:\r\n for k in nblist:\r\n (i, j, wt) = edges[k]\r\n if inblossom[j] == b:\r\n i, j = j, i\r\n bj = inblossom[j]\r\n if (bj != b and label[bj] == 1 and\r\n (bestedgeto[bj] == -1 or\r\n slack(k) < slack(bestedgeto[bj]))):\r\n bestedgeto[bj] = k\r\n # Forget about least-slack edges of the subblossom.\r\n blossombestedges[bv] = None\r\n bestedge[bv] = -1\r\n blossombestedges[b] = [ k for k in bestedgeto if k != -1 ]\r\n # Select bestedge[b].\r\n bestedge[b] = -1\r\n for k in blossombestedges[b]:\r\n if bestedge[b] == -1 or slack(k) < slack(bestedge[b]):\r\n bestedge[b] = k\r\n if DEBUG: DEBUG('blossomchilds[%d]=' % b + repr(blossomchilds[b]))\r\n\r\n # Expand the given top-level blossom.\r\n def expandBlossom(b, endstage):\r\n if DEBUG: DEBUG('expandBlossom(%d,%d) %s' % (b, endstage, repr(blossomchilds[b])))\r\n # Convert sub-blossoms into top-level blossoms.\r\n for s in blossomchilds[b]:\r\n blossomparent[s] = -1\r\n if s < nvertex:\r\n inblossom[s] = s\r\n elif endstage and dualvar[s] == 0:\r\n # Recursively expand this sub-blossom.\r\n expandBlossom(s, endstage)\r\n else:\r\n for v in blossomLeaves(s):\r\n inblossom[v] = s\r\n # If we expand a T-blossom during a stage, its sub-blossoms must be\r\n # relabeled.\r\n if (not endstage) and label[b] == 2:\r\n # Start at the sub-blossom through which the expanding\r\n # blossom obtained its label, and relabel sub-blossoms untili\r\n # we reach the base.\r\n # Figure out through which sub-blossom the expanding blossom\r\n # obtained its label initially.\r\n assert labelend[b] >= 0\r\n entrychild = inblossom[endpoint[labelend[b] ^ 1]]\r\n # Decide in which direction we will go round the blossom.\r\n j = blossomchilds[b].index(entrychild)\r\n if j & 1:\r\n # Start index is odd; go forward and wrap.\r\n j -= len(blossomchilds[b])\r\n jstep = 1\r\n endptrick = 0\r\n else:\r\n # Start index is even; go backward.\r\n jstep = -1\r\n endptrick = 1\r\n # Move along the blossom until we get to the base.\r\n p = labelend[b]\r\n while j != 0:\r\n # Relabel the T-sub-blossom.\r\n label[endpoint[p ^ 1]] = 0\r\n label[endpoint[blossomendps[b][j-endptrick]^endptrick^1]] = 0\r\n assignLabel(endpoint[p ^ 1], 2, p)\r\n # Step to the next S-sub-blossom and note its forward endpoint.\r\n allowedge[blossomendps[b][j-endptrick]//2] = True\r\n j += jstep\r\n p = blossomendps[b][j-endptrick] ^ endptrick\r\n # Step to the next T-sub-blossom.\r\n allowedge[p//2] = True\r\n j += jstep\r\n # Relabel the base T-sub-blossom WITHOUT stepping through to\r\n # its mate (so don't call assignLabel).\r\n bv = blossomchilds[b][j]\r\n label[endpoint[p ^ 1]] = label[bv] = 2\r\n labelend[endpoint[p ^ 1]] = labelend[bv] = p\r\n bestedge[bv] = -1\r\n # Continue along the blossom until we get back to entrychild.\r\n j += jstep\r\n while blossomchilds[b][j] != entrychild:\r\n # Examine the vertices of the sub-blossom to see whether\r\n # it is reachable from a neighbouring S-vertex outside the\r\n # expanding blossom.\r\n bv = blossomchilds[b][j]\r\n if label[bv] == 1:\r\n # This sub-blossom just got label S through one of its\r\n # neighbours; leave it.\r\n j += jstep\r\n continue\r\n for v in blossomLeaves(bv):\r\n if label[v] != 0:\r\n break\r\n # If the sub-blossom contains a reachable vertex, assign\r\n # label T to the sub-blossom.\r\n if label[v] != 0:\r\n assert label[v] == 2\r\n assert inblossom[v] == bv\r\n label[v] = 0\r\n label[endpoint[mate[blossombase[bv]]]] = 0\r\n assignLabel(v, 2, labelend[v])\r\n j += jstep\r\n # Recycle the blossom number.\r\n label[b] = labelend[b] = -1\r\n blossomchilds[b] = blossomendps[b] = None\r\n blossombase[b] = -1\r\n blossombestedges[b] = None\r\n bestedge[b] = -1\r\n unusedblossoms.append(b)\r\n\r\n # Swap matched/unmatched edges over an alternating path through blossom b\r\n # between vertex v and the base vertex. Keep blossom bookkeeping consistent.\r\n def augmentBlossom(b, v):\r\n if DEBUG: DEBUG('augmentBlossom(%d,%d)' % (b, v))\r\n # Bubble up through the blossom tree from vertex v to an immediate\r\n # sub-blossom of b.\r\n t = v\r\n while blossomparent[t] != b:\r\n t = blossomparent[t]\r\n # Recursively deal with the first sub-blossom.\r\n if t >= nvertex:\r\n augmentBlossom(t, v)\r\n # Decide in which direction we will go round the blossom.\r\n i = j = blossomchilds[b].index(t)\r\n if i & 1:\r\n # Start index is odd; go forward and wrap.\r\n j -= len(blossomchilds[b])\r\n jstep = 1\r\n endptrick = 0\r\n else:\r\n # Start index is even; go backward.\r\n jstep = -1\r\n endptrick = 1\r\n # Move along the blossom until we get to the base.\r\n while j != 0:\r\n # Step to the next sub-blossom and augment it recursively.\r\n j += jstep\r\n t = blossomchilds[b][j]\r\n p = blossomendps[b][j-endptrick] ^ endptrick\r\n if t >= nvertex:\r\n augmentBlossom(t, endpoint[p])\r\n # Step to the next sub-blossom and augment it recursively.\r\n j += jstep\r\n t = blossomchilds[b][j]\r\n if t >= nvertex:\r\n augmentBlossom(t, endpoint[p ^ 1])\r\n # Match the edge connecting those sub-blossoms.\r\n mate[endpoint[p]] = p ^ 1\r\n mate[endpoint[p ^ 1]] = p\r\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (endpoint[p], endpoint[p^1], p//2))\r\n # Rotate the list of sub-blossoms to put the new base at the front.\r\n blossomchilds[b] = blossomchilds[b][i:] + blossomchilds[b][:i]\r\n blossomendps[b] = blossomendps[b][i:] + blossomendps[b][:i]\r\n blossombase[b] = blossombase[blossomchilds[b][0]]\r\n assert blossombase[b] == v\r\n\r\n # Swap matched/unmatched edges over an alternating path between two\r\n # single vertices. The augmenting path runs through edge k, which\r\n # connects a pair of S vertices.\r\n def augmentMatching(k):\r\n (v, w, wt) = edges[k]\r\n if DEBUG: DEBUG('augmentMatching(%d) (v=%d w=%d)' % (k, v, w))\r\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (v, w, k))\r\n for (s, p) in ((v, 2*k+1), (w, 2*k)):\r\n # Match vertex s to remote endpoint p. Then trace back from s\r\n # until we find a single vertex, swapping matched and unmatched\r\n # edges as we go.\r\n while 1:\r\n bs = inblossom[s]\r\n assert label[bs] == 1\r\n assert labelend[bs] == mate[blossombase[bs]]\r\n # Augment through the S-blossom from s to base.\r\n if bs >= nvertex:\r\n augmentBlossom(bs, s)\r\n # Update mate[s]\r\n mate[s] = p\r\n # Trace one step back.\r\n if labelend[bs] == -1:\r\n # Reached single vertex; stop.\r\n break\r\n t = endpoint[labelend[bs]]\r\n bt = inblossom[t]\r\n assert label[bt] == 2\r\n # Trace one step back.\r\n assert labelend[bt] >= 0\r\n s = endpoint[labelend[bt]]\r\n j = endpoint[labelend[bt] ^ 1]\r\n # Augment through the T-blossom from j to base.\r\n assert blossombase[bt] == t\r\n if bt >= nvertex:\r\n augmentBlossom(bt, j)\r\n # Update mate[j]\r\n mate[j] = labelend[bt]\r\n # Keep the opposite endpoint;\r\n # it will be assigned to mate[s] in the next step.\r\n p = labelend[bt] ^ 1\r\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (s, t, p//2))\r\n\r\n # Verify that the optimum solution has been reached.\r\n def verifyOptimum():\r\n if maxcardinality:\r\n # Vertices may have negative dual;\r\n # find a constant non-negative number to add to all vertex duals.\r\n vdualoffset = max(0, -min(dualvar[:nvertex]))\r\n else:\r\n vdualoffset = 0\r\n # 0. all dual variables are non-negative\r\n assert min(dualvar[:nvertex]) + vdualoffset >= 0\r\n assert min(dualvar[nvertex:]) >= 0\r\n # 0. all edges have non-negative slack and\r\n # 1. all matched edges have zero slack;\r\n for k in range(nedge):\r\n (i, j, wt) = edges[k]\r\n s = dualvar[i] + dualvar[j] - 2 * wt\r\n iblossoms = [ i ]\r\n jblossoms = [ j ]\r\n while blossomparent[iblossoms[-1]] != -1:\r\n iblossoms.append(blossomparent[iblossoms[-1]])\r\n while blossomparent[jblossoms[-1]] != -1:\r\n jblossoms.append(blossomparent[jblossoms[-1]])\r\n iblossoms.reverse()\r\n jblossoms.reverse()\r\n for (bi, bj) in zip(iblossoms, jblossoms):\r\n if bi != bj:\r\n break\r\n s += 2 * dualvar[bi]\r\n #assert s >= 0\r\n if mate[i] // 2 == k or mate[j] // 2 == k:\r\n assert mate[i] // 2 == k and mate[j] // 2 == k\r\n assert s == 0\r\n # 2. all single vertices have zero dual value;\r\n for v in range(nvertex):\r\n assert mate[v] >= 0 or dualvar[v] + vdualoffset == 0\r\n # 3. all blossoms with positive dual value are full.\r\n for b in range(nvertex, 2*nvertex):\r\n if blossombase[b] >= 0 and dualvar[b] > 0:\r\n assert len(blossomendps[b]) % 2 == 1\r\n for p in blossomendps[b][1::2]:\r\n assert mate[endpoint[p]] == p ^ 1\r\n assert mate[endpoint[p ^ 1]] == p\r\n # Ok.\r\n\r\n # Check optimized delta2 against a trivial computation.\r\n def checkDelta2():\r\n for v in range(nvertex):\r\n if label[inblossom[v]] == 0:\r\n bd = None\r\n bk = -1\r\n for p in neighbend[v]:\r\n k = p // 2\r\n w = endpoint[p]\r\n if label[inblossom[w]] == 1:\r\n d = slack(k)\r\n if bk == -1 or d < bd:\r\n bk = k\r\n bd = d\r\n if DEBUG and (bestedge[v] != -1 or bk != -1) and (bestedge[v] == -1 or bd != slack(bestedge[v])):\r\n DEBUG('v=' + str(v) + ' bk=' + str(bk) + ' bd=' + str(bd) + ' bestedge=' + str(bestedge[v]) + ' slack=' + str(slack(bestedge[v])))\r\n assert (bk == -1 and bestedge[v] == -1) or (bestedge[v] != -1 and bd == slack(bestedge[v]))\r\n\r\n # Check optimized delta3 against a trivial computation.\r\n def checkDelta3():\r\n bk = -1\r\n bd = None\r\n tbk = -1\r\n tbd = None\r\n for b in range(2 * nvertex):\r\n if blossomparent[b] == -1 and label[b] == 1:\r\n for v in blossomLeaves(b):\r\n for p in neighbend[v]:\r\n k = p // 2\r\n w = endpoint[p]\r\n if inblossom[w] != b and label[inblossom[w]] == 1:\r\n d = slack(k)\r\n if bk == -1 or d < bd:\r\n bk = k\r\n bd = d\r\n if bestedge[b] != -1:\r\n (i, j, wt) = edges[bestedge[b]]\r\n assert inblossom[i] == b or inblossom[j] == b\r\n assert inblossom[i] != b or inblossom[j] != b\r\n assert label[inblossom[i]] == 1 and label[inblossom[j]] == 1\r\n if tbk == -1 or slack(bestedge[b]) < tbd:\r\n tbk = bestedge[b]\r\n tbd = slack(bestedge[b])\r\n if DEBUG and bd != tbd:\r\n DEBUG('bk=%d tbk=%d bd=%s tbd=%s' % (bk, tbk, repr(bd), repr(tbd)))\r\n assert bd == tbd\r\n\r\n # Main loop: continue until no further improvement is possible.\r\n for t in range(nvertex):\r\n\r\n # Each iteration of this loop is a \"stage\".\r\n # A stage finds an augmenting path and uses that to improve\r\n # the matching.\r\n if DEBUG: DEBUG('STAGE %d' % t)\r\n\r\n # Remove labels from top-level blossoms/vertices.\r\n label[:] = (2 * nvertex) * [ 0 ]\r\n\r\n # Forget all about least-slack edges.\r\n bestedge[:] = (2 * nvertex) * [ -1 ]\r\n blossombestedges[nvertex:] = nvertex * [ None ]\r\n\r\n # Loss of labeling means that we can not be sure that currently\r\n # allowable edges remain allowable througout this stage.\r\n allowedge[:] = nedge * [ False ]\r\n\r\n # Make queue empty.\r\n queue[:] = [ ]\r\n \r\n # Label single blossoms/vertices with S and put them in the queue.\r\n for v in range(nvertex):\r\n if mate[v] == -1 and label[inblossom[v]] == 0:\r\n assignLabel(v, 1, -1)\r\n\r\n # Loop until we succeed in augmenting the matching.\r\n augmented = 0\r\n while 1:\r\n\r\n # Each iteration of this loop is a \"substage\".\r\n # A substage tries to find an augmenting path;\r\n # if found, the path is used to improve the matching and\r\n # the stage ends. If there is no augmenting path, the\r\n # primal-dual method is used to pump some slack out of\r\n # the dual variables.\r\n if DEBUG: DEBUG('SUBSTAGE')\r\n\r\n # Continue labeling until all vertices which are reachable\r\n # through an alternating path have got a label.\r\n while queue and not augmented:\r\n\r\n # Take an S vertex from the queue.\r\n v = queue.pop()\r\n if DEBUG: DEBUG('POP v=%d' % v)\r\n assert label[inblossom[v]] == 1\r\n\r\n # Scan its neighbours:\r\n for p in neighbend[v]:\r\n k = p // 2\r\n w = endpoint[p]\r\n # w is a neighbour to v\r\n if inblossom[v] == inblossom[w]:\r\n # this edge is internal to a blossom; ignore it\r\n continue\r\n if not allowedge[k]:\r\n kslack = slack(k)\r\n if kslack <= 0:\r\n # edge k has zero slack => it is allowable\r\n allowedge[k] = True\r\n if allowedge[k]:\r\n if label[inblossom[w]] == 0:\r\n # (C1) w is a free vertex;\r\n # label w with T and label its mate with S (R12).\r\n assignLabel(w, 2, p ^ 1)\r\n elif label[inblossom[w]] == 1:\r\n # (C2) w is an S-vertex (not in the same blossom);\r\n # follow back-links to discover either an\r\n # augmenting path or a new blossom.\r\n base = scanBlossom(v, w)\r\n if base >= 0:\r\n # Found a new blossom; add it to the blossom\r\n # bookkeeping and turn it into an S-blossom.\r\n addBlossom(base, k)\r\n else:\r\n # Found an augmenting path; augment the\r\n # matching and end this stage.\r\n augmentMatching(k)\r\n augmented = 1\r\n break\r\n elif label[w] == 0:\r\n # w is inside a T-blossom, but w itself has not\r\n # yet been reached from outside the blossom;\r\n # mark it as reached (we need this to relabel\r\n # during T-blossom expansion).\r\n assert label[inblossom[w]] == 2\r\n label[w] = 2\r\n labelend[w] = p ^ 1\r\n elif label[inblossom[w]] == 1:\r\n # keep track of the least-slack non-allowable edge to\r\n # a different S-blossom.\r\n b = inblossom[v]\r\n if bestedge[b] == -1 or kslack < slack(bestedge[b]):\r\n bestedge[b] = k\r\n elif label[w] == 0:\r\n # w is a free vertex (or an unreached vertex inside\r\n # a T-blossom) but we can not reach it yet;\r\n # keep track of the least-slack edge that reaches w.\r\n if bestedge[w] == -1 or kslack < slack(bestedge[w]):\r\n bestedge[w] = k\r\n\r\n if augmented:\r\n break\r\n\r\n # There is no augmenting path under these constraints;\r\n # compute delta and reduce slack in the optimization problem.\r\n # (Note that our vertex dual variables, edge slacks and delta's\r\n # are pre-multiplied by two.)\r\n deltatype = -1\r\n delta = deltaedge = deltablossom = None\r\n\r\n # Verify data structures for delta2/delta3 computation.\r\n if CHECK_DELTA:\r\n checkDelta2()\r\n checkDelta3()\r\n\r\n # Compute delta1: the minumum value of any vertex dual.\r\n if not maxcardinality:\r\n deltatype = 1\r\n delta = min(dualvar[:nvertex])\r\n\r\n # Compute delta2: the minimum slack on any edge between\r\n # an S-vertex and a free vertex.\r\n for v in range(nvertex):\r\n if label[inblossom[v]] == 0 and bestedge[v] != -1:\r\n d = slack(bestedge[v])\r\n if deltatype == -1 or d < delta:\r\n delta = d\r\n deltatype = 2\r\n deltaedge = bestedge[v]\r\n\r\n # Compute delta3: half the minimum slack on any edge between\r\n # a pair of S-blossoms.\r\n for b in range(2 * nvertex):\r\n if ( blossomparent[b] == -1 and label[b] == 1 and\r\n bestedge[b] != -1 ):\r\n kslack = slack(bestedge[b])\r\n if isinstance(kslack, integer_types):\r\n assert (kslack % 2) == 0\r\n d = kslack // 2\r\n else:\r\n d = kslack / 2\r\n if deltatype == -1 or d < delta:\r\n delta = d\r\n deltatype = 3\r\n deltaedge = bestedge[b]\r\n\r\n # Compute delta4: minimum z variable of any T-blossom.\r\n for b in range(nvertex, 2*nvertex):\r\n if ( blossombase[b] >= 0 and blossomparent[b] == -1 and\r\n label[b] == 2 and\r\n (deltatype == -1 or dualvar[b] < delta) ):\r\n delta = dualvar[b]\r\n deltatype = 4\r\n deltablossom = b\r\n\r\n if deltatype == -1:\r\n # No further improvement possible; max-cardinality optimum\r\n # reached. Do a final delta update to make the optimum\r\n # verifyable.\r\n assert maxcardinality\r\n deltatype = 1\r\n delta = max(0, min(dualvar[:nvertex]))\r\n\r\n # Update dual variables according to delta.\r\n for v in range(nvertex):\r\n if label[inblossom[v]] == 1:\r\n # S-vertex: 2*u = 2*u - 2*delta\r\n dualvar[v] -= delta\r\n elif label[inblossom[v]] == 2:\r\n # T-vertex: 2*u = 2*u + 2*delta\r\n dualvar[v] += delta\r\n for b in range(nvertex, 2*nvertex):\r\n if blossombase[b] >= 0 and blossomparent[b] == -1:\r\n if label[b] == 1:\r\n # top-level S-blossom: z = z + 2*delta\r\n dualvar[b] += delta\r\n elif label[b] == 2:\r\n # top-level T-blossom: z = z - 2*delta\r\n dualvar[b] -= delta\r\n\r\n # Take action at the point where minimum delta occurred.\r\n if DEBUG: DEBUG('delta%d=%f' % (deltatype, delta))\r\n if deltatype == 1: \r\n # No further improvement possible; optimum reached.\r\n break\r\n elif deltatype == 2:\r\n # Use the least-slack edge to continue the search.\r\n allowedge[deltaedge] = True\r\n (i, j, wt) = edges[deltaedge]\r\n if label[inblossom[i]] == 0:\r\n i, j = j, i\r\n assert label[inblossom[i]] == 1\r\n queue.append(i)\r\n elif deltatype == 3:\r\n # Use the least-slack edge to continue the search.\r\n allowedge[deltaedge] = True\r\n (i, j, wt) = edges[deltaedge]\r\n assert label[inblossom[i]] == 1\r\n queue.append(i)\r\n elif deltatype == 4:\r\n # Expand the least-z blossom.\r\n expandBlossom(deltablossom, False)\r\n\r\n # End of a this substage.\r\n\r\n # Stop when no more augmenting path can be found.\r\n if not augmented:\r\n break\r\n\r\n # End of a stage; expand all S-blossoms which have dualvar = 0.\r\n for b in range(nvertex, 2*nvertex):\r\n if ( blossomparent[b] == -1 and blossombase[b] >= 0 and\r\n label[b] == 1 and dualvar[b] == 0 ):\r\n expandBlossom(b, True)\r\n\r\n # Verify that we reached the optimum solution.\r\n if CHECK_OPTIMUM:\r\n verifyOptimum()\r\n\r\n # Transform mate[] such that mate[v] is the vertex to which v is paired.\r\n for v in range(nvertex):\r\n if mate[v] >= 0:\r\n mate[v] = endpoint[mate[v]]\r\n for v in range(nvertex):\r\n assert mate[v] == -1 or mate[mate[v]] == v\r\n\r\n return mate","def get_max_incident_edge_weight(self, u, v):\n max_weight = 0\n for node in self.graph.neighbors(u):\n if node != v and self.graph[u][node][\"weight\"] > max_weight:\n max_weight = self.graph[u][node][\"weight\"]\n\n for node in self.graph.neighbors(v):\n if node != u and self.graph[v][node][\"weight\"] > max_weight:\n max_weight = self.graph[v][node][\"weight\"]\n\n return max_weight","async def max_distance(self, *args):\n return await self._rpc.max_distance(*args)","def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\n dtype=float)\n\n for commodity_idx in range(len(self.commodities)):\n utilisation = self.calc_demand(routing,\n demands[commodity_idx],\n commodity_idx)\n total_utilisation += utilisation\n\n return np.max(np.divide(total_utilisation, self.edge_capacities))","def __find_max_distance(self):\n return utils.find_max_distance(self.__game)","def calculate_max_paths(self):\n self.max_paths = {}\n first_nodes = [key for (key, val) in self.predecessors.items() if not val]\n for nm in first_nodes:\n self.max_paths[nm] = {}\n self._checking_path(node_name=nm, first_name=nm)","def get_max_gains(self):\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x800c+i,100)/100 for i in range(4)])","def _maximum(self) -> float:\n return self._config[CONF_MAX]","def get_longest_paths(nodes, graph):\n paths = []\n distances = []\n possible_paths = list(combinations(nodes, r=2))\n for node1, node2 in possible_paths:\n try:\n path = nx.shortest_path(graph, node1, node2, \"weight\")\n except Exception,e:\n path = []\n if len(path)>1:\n distance = get_path_distance(path, graph)\n paths.append(path)\n distances.append(distance)\n paths_sorted = [x for (y,x) in sorted(zip(distances, paths), reverse=True)]\n # longest_path = paths_sorted[0]\n # return longest_path\n return paths_sorted","def _cost_route_fine(self):\n return self.fine","def euclid_destination_for_passenger(state, problem):\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\n if unsatisfied:\n max_dist = sum([p.opt for p in unsatisfied])\n return max_dist\n return 0","def count_routes_max_distance(self, src, dest, max_distance):\n\n criteria = lambda stops, distance: distance < max_distance # inconsistent max, per test cases\n return len(self.routes_with_criteria(src, dest, criteria))","def findMaximumDeviationJunction(junctions, wires, resistances, voltages, currents):\n raise NotImplementedError","def resource_max_constraint_rule(backend_model, node, tech, timestep):\n timestep_resolution = backend_model.timestep_resolution[timestep]\n\n return backend_model.resource_con[node, tech, timestep] <= (\n timestep_resolution * backend_model.resource_cap[node, tech]\n )","def maximum(self):\n return self.properties.get('maximum')","def cost(graph,a, undirected=True):\n cost = sum(sum(np.array(abs(graph-a))))\n if undirected:\n return cost/2.0\n else:\n return cost","def max_degree_node(g, d, connected):\n if not connected:\n deg = d\n else:\n deg = {k: v for k, v in d.items() if k in connected}\n if not deg:\n return None\n n = max(deg.keys(), key=lambda k: deg[k])\n d.pop(n)\n for n_ in g.neighbors(n):\n connected.add(n_)\n return n","def bern_max_metric(pipe_diameter, delta_p):\n\n rho = 1000 # density of water kg/m^3\n flow_rate_max = ((math.pi * (pipe_diameter**2)) / 4) * math.sqrt((2 * delta_p) / rho)\n\n return flow_rate_max","def get_length(network, road_id):\n return network[0][road_id][2]","def get_bprop_maximum(self):\n input_grad = G.MaximumGrad()\n\n def bprop(x, y, out, dout):\n dx, dy = input_grad(x, y, dout)\n return dx, dy\n return bprop","def longest_flight(g):\n max_distance = None\n max_destination = None\n max_key = None\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n if(flight[1] > max_distance):\n max_key = key\n max_destination = flight[0]\n max_distance = flight[1]\n return g.city_dict[max_key].get_code(), max_destination, max_distance","def greedy_max_cut(graph):\n cut = Cut(set(), set())\n for vertex in graph.nodes:\n l_neighbors = sum((adj in cut.left) for adj in graph.neighbors(vertex))\n r_neighbors = sum((adj in cut.right) for adj in graph.neighbors(vertex))\n if l_neighbors < r_neighbors:\n cut.left.add(vertex)\n else:\n cut.right.add(vertex)\n return cut","def calc_demand(self, routing: np.ndarray, demand: float,\n commodity_idx: int) -> np.ndarray:\n commodity = self.commodities[commodity_idx]\n node_flow = np.zeros(self.num_nodes)\n node_flow[commodity[0]] = demand\n\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\n for edge_idx, edge in enumerate(self.edges):\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\n\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\n\n num_steps = 0\n while True:\n change = np.multiply(split_matrix, node_flow)\n edge_utilisation += change\n node_flow = np.matmul(split_matrix, node_flow)\n if np.any(np.isnan(change)):\n print(\"is_nan :'(\")\n comparison = np.less(np.nan_to_num(change), self.min_delta)\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\n break\n num_steps += 1\n # if we take more than |E| steps we have cycles which is not good.\n # Therefore: end here with really bad reward, scaled by number of\n # cycles\n if num_steps > routing.shape[1]:\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\n edge_utilisation += np.multiply(remaining_flow, np.full(\n (self.num_nodes, self.num_nodes), demand))\n break\n\n return edge_utilisation","def probabilityTransitionRule(self, unvisitedHeuristics, totalUnvisited):\n argMaxProbValue = 0\n argMaxToken = None\n for unvisitedToken in unvisitedHeuristics:\n probValue = unvisitedHeuristics[unvisitedToken] / totalUnvisited\n\n # In case obtained value is higher than previous maximum, substitute\n if probValue > argMaxProbValue:\n argMaxProbValue = probValue\n argMaxToken = unvisitedToken\n\n return argMaxToken","def build_links_capacity(self):\n\n links_capacity = {}\n # Iterates all the edges in the topology formed by switches\n for src, dst in self.topo.keep_only_p4switches().edges:\n bw = self.topo.edges[(src, dst)]['bw']\n # add both directions\n links_capacity[(src, dst)] = bw\n links_capacity[(dst, src)] = bw\n\n return links_capacity"],"string":"[\n \"def find_max_flow(graph, start, end):\\n try:\\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\\\"weight\\\")\\n return flow_value\\n except Exception as e:\\n print(\\\"Error in Max flow computation \\\", e)\\n return \\\"NaN\\\"\",\n \"def get_max_usage(topology, path):\\n max_usage = np.finfo(0.0).min\\n for i in range(len(path.node_list) - 1):\\n max_usage = max(max_usage, topology[path.node_list[i]][path.node_list[i + 1]]['total_units'] - topology[path.node_list[i]][path.node_list[i + 1]]['available_units'])\\n return max_usage\",\n \"def calc_overall_link_utilisation(self, demands: Demand,\\n routing: Routing) -> np.ndarray:\\n flows = [(i, j) for i in range(self.num_nodes)\\n for j in range(self.num_nodes)\\n if i != j]\\n\\n link_utilisation = np.zeros(self.num_edges)\\n\\n for i, flow in enumerate(flows):\\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\\n demands[\\n i],\\n routing[\\n i])\\n link_utilisation += flow_link_utilisation\\n\\n return link_utilisation\",\n \"def max_path_cost(self, path, attr): \\n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])\",\n \"def part_2(distances: Distances) -> int:\\n\\n result, _ = max(generate_routes(distances))\\n print(f\\\"part 2: longest route has distance {result}\\\")\\n return result\",\n \"def get_current_max_link(self):\\n return self.current_max_link\",\n \"def control_edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.control_edge_count_max or 0)\",\n \"def maximal_destination_for_passenger(state, problem):\\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\\n if unsatisfied:\\n max_dist = max([p.opt for p in unsatisfied])\\n return max_dist\\n return 0\",\n \"def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\\n # set availbandwidth to the maximal value\\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\\n if d.type == 'STATIC':\\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\\n # subtract the reserved link and internal (inside Infras) bandwidth\\n if mode == self.MODE_ADD:\\n for d in self.infras:\\n for p in d.ports:\\n for fr in p.flowrules:\\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\\n # Flowrules are cummulatively subtracted from the switching \\n # capacity of the node.\\n d.availres['bandwidth'] -= fr.bandwidth\\n if d.availres['bandwidth'] < 0:\\n raise RuntimeError(\\\"The node bandwidth of %s got below zero \\\"\\n \\\"during available resource calculation!\\\" %\\n d.id)\\n # Get all the mapped paths of all SGHops from the NFFG\\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\\n for sg_hop_id, data in sg_map.iteritems():\\n src, dst, flowclass, bandwidth, delay, path = data\\n if bandwidth is not None:\\n for link in path:\\n link.availbandwidth -= bandwidth\\n if link.availbandwidth < 0:\\n raise RuntimeError(\\n \\\"The link bandwidth of %s got below zero during\\\"\\n \\\"available resource calculation!\\\" % link.id)\",\n \"def node_count_max(self) -> int:\\n return int(self.graph_tuple_stats.node_count_max or 0)\",\n \"def get_highest_preference(self, routes):\\n # routes is all possible routes to daddr\\n outroutes = {}\\n highest = 0\\n\\n for ip in routes.keys():\\n if routes[ip][LPRF] > highest:\\n highest = routes[ip][LPRF]\\n\\n for ip in routes.keys():\\n if routes[ip][LPRF] == highest:\\n outroutes[ip] = routes[ip]\\n\\n return outroutes\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.edge_count_max or 0)\",\n \"def max_dist(graph, source):\\r\\n q = queue.Queue()\\r\\n found = {}\\r\\n distance = {}\\r\\n for vertex in graph: \\r\\n found[vertex] = 0\\r\\n distance[vertex] = -1\\r\\n max_distance = 0\\r\\n found[source] = 1\\r\\n distance[source] = 0\\r\\n q.put(source)\\r\\n while q.empty() == False:\\r\\n current = q.get()\\r\\n for neighbour in graph[current]:\\r\\n if found[neighbour] == 0:\\r\\n found[neighbour] = 1\\r\\n distance[neighbour] = distance[current] + 1\\r\\n max_distance = distance[neighbour]\\r\\n q.put(neighbour)\\r\\n return max_distance\",\n \"def compute_path_metric(self, sw, path, util, time_now):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\\n #only include extra-domain state when not stale (timestamp), 3) always exclude\\n #extra-domain state when calculating the path metric? Here we do (1)\\n used = self.graph[u][v]['used'] + util\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def compute_path_metric(self, sw, path, util, time_now, local_contrib):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n # Use the last-learned-via-sync value for a link\\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\\n used1 = self.graph[u][v]['sync_learned'] + util\\n used2 = self.graph[u][v]['used'] + util\\n # ['used'] is a strict lower bound for ['sync_learned']\\n if used1 > used2: \\n used = used1\\n logging.debug(\\\"CS [%s] using sync_learned value 1 [%f]\\\", str(self.name), used1)\\n else:\\n used = used2\\n logging.debug(\\\"CS [%s] using sync_learned value 2 [%f]\\\", str(self.name), used2)\\n else:\\n logging.debug(\\\"CS [%s] using tracking value\\\", str(self.name))\\n used = self.graph[u][v]['used'] + util\\n\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def get_highest_preference(self, routes):\\n outroutes = []\\n max_val = float('-inf')\\n # find highest local pref first\\n for r in routes:\\n if r[MESG][LPRF] > max_val:\\n max_val = r[MESG][LPRF]\\n # find all routes with that val\\n for r in routes:\\n if r[MESG][LPRF] == max_val:\\n outroutes.append(r)\\n\\n return outroutes\",\n \"def countMaxDegree(self):\\r\\n max_degree = [0, 0] # le sommet, son nombre de connection \\r\\n for i_node, node_connections in enumerate(self.adjMatrix):\\r\\n connection = self.n - node_connections.count(0) # on compte le nombre de connections du sommet\\r\\n if connection > max_degree[1]:\\r\\n max_degree = max_degree[i_node, node_connections]\\r\\n return max_degree[0], max_degree[1] # C un tuple ! \\r\",\n \"def max_network_performance(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_network_performance\\\")\",\n \"def calculate_greatest(self):\\n greatest = 0\\n for resourceList in self.loading.values():\\n for time, use in resourceList:\\n if use > greatest:\\n greatest = use\\n self.emit(\\\"greatest_calculated\\\",greatest)\\n return greatest\",\n \"def call_edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.call_edge_count_max or 0)\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def find_maximal_path(graph):\\n maximal_path_in_graph = [] # This is where the maximal path in the graph is stored (updates)\\n checked_pairs = set() # In order not to check a pair twice, the set stores the already checked pairs (and the\\n # reversed order of the tuple\\n for node_start in graph.nodes.keys():\\n for node_end in graph.nodes.keys():\\n tup_of_nodes = (node_start, node_end) # This tuple is checked in checked_pairs\\n # Need to make sure that the path is valid (!=Node) and that it is not checked yet\\n if graph.find_longest_path(node_start,\\n node_end) != None and tup_of_nodes not in checked_pairs:\\n tup_of_nodes_reverse = (node_end, node_start) # This is a tuple with the opposite order\\n checked_pairs.add(tup_of_nodes)\\n checked_pairs.add(tup_of_nodes_reverse)\\n maximal_path_for_pair = graph.find_longest_path(node_start, node_end)\\n # Updates the maximal path per pair exceeds the current one\\n if len(maximal_path_for_pair) > len(maximal_path_in_graph):\\n maximal_path_in_graph = maximal_path_for_pair\\n return \\\"Maximal path between nodes is: {}, and the length is {} nodes.\\\".format(maximal_path_in_graph, \\\\\\n len(maximal_path_in_graph))\",\n \"def find_max(self):\\n return max(self.nodes, key=int)\",\n \"def test_max_flow(default_plugin_resolver):\\n dpr = default_plugin_resolver\\n source_node = 0\\n target_node = 7\\n ebunch = [\\n (0, 1, 9),\\n (0, 3, 10),\\n (1, 4, 3),\\n (2, 7, 6),\\n (3, 1, 2),\\n (3, 4, 8),\\n (4, 5, 7),\\n (4, 2, 4),\\n (5, 2, 5),\\n (5, 6, 1),\\n (6, 2, 11),\\n ]\\n nx_graph = nx.DiGraph()\\n nx_graph.add_weighted_edges_from(ebunch)\\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\\\"weight\\\")\\n\\n expected_flow_value = 6\\n bottleneck_nodes = {2, 4}\\n expected_nodemap = {2: 6, 4: 6}\\n\\n mv = MultiVerify(dpr)\\n results = mv.compute(\\\"flow.max_flow\\\", graph, source_node, target_node)\\n\\n # Compare flow rate\\n results[0].assert_equal(expected_flow_value)\\n\\n # Normalize actual flow to prepare to transform\\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\\n\\n # Compare sum of out edges for bottleneck nodes\\n out_edges = mv.transform(\\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n )\\n out_bottleneck = mv.transform(\\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\\n )\\n out_bottleneck.assert_equal(expected_nodemap)\\n\\n # Compare sum of in edges for bottleneck nodes\\n in_edges = mv.transform(\\n \\\"util.graph.aggregate_edges.core_networkx\\\",\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n in_edges=True,\\n out_edges=False,\\n )\\n in_bottleneck = mv.transform(\\n \\\"util.nodemap.select.core_python\\\", in_edges, bottleneck_nodes\\n )\\n in_bottleneck.assert_equal(expected_nodemap)\",\n \"def maxTargets(self):\\n return self._getAttribute(Attribute.maxTargets)\",\n \"def getMaximumDistances(self):\\n pass\",\n \"def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\\n pass\",\n \"def strength_longest_bridge():\\n # first again filter all the Nonetype out\\n bridges = [ b for b in all_bridges if b != None ]\\n\\n # the find the strength of the longest bridge\\n # in this case the first longest to be found is also the\\n # the strongest out of all the longest\\n\\n return max(bridges, key=lambda b: len(b[1]))[0]\",\n \"def degree_graph(g):\\n return max(degree_node(g, node) for node in g)\",\n \"def maximum_flow(graph, start, end):\\n if not isinstance(graph, BasicGraph):\\n raise TypeError(f\\\"Expected subclass of BasicGraph, not {type(graph)}\\\")\\n Graph = type(graph)\\n \\n if start not in graph:\\n raise ValueError(f\\\"{start} not in graph\\\")\\n if end not in graph:\\n raise ValueError(f\\\"{end} not in graph\\\")\\n\\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\\n total_flow = 0\\n # -----------------------------------------------------------------------\\n # The algorithm\\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\\n # of DFS, which leads to a lot of node visits.\\n #\\n # I therefore choose to invert the capacities of the graph so that the\\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\\n # This allows me to use the shortest path method to find the path with\\n # most capacity in the first attempt, resulting in a significant reduction\\n # of unassigned flow.\\n #\\n # By updating G_inverted, with the residual capacity, I can keep using the\\n # shortest path, until the capacity is zero, whereby I remove the links\\n # When the shortest path method returns 'No path' or when unassigned flow\\n # is zero, I exit the algorithm.\\n #\\n # Even on small graphs, this method is very efficient, despite the overhead\\n # of using shortest path. For very large graphs, this method outperforms\\n # all other algorithms by orders of magnitude.\\n # -----------------------------------------------------------------------\\n\\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\\n inverted_graph = Graph(from_list=edges) # create G_inverted.\\n capacity_graph = Graph() # Create structure to record capacity left.\\n flow_graph = Graph() # Create structure to record flows.\\n\\n while unassigned_flow:\\n # 1. find the best path\\n d, path = shortest_path(inverted_graph, start, end)\\n if d == float(\\\"inf\\\"): # then there is no path, and we must exit.\\n return total_flow, flow_graph\\n # else: use the path and lookup the actual flow from the capacity graph.\\n\\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\\\"inf\\\"))) for s, e, d in graph.edges(path=path)])\\n\\n # 2. update the unassigned flow.\\n unassigned_flow -= path_flow\\n total_flow += path_flow\\n\\n # 3. record the flows and update the inverted graph, so that it is\\n # ready for the next iteration.\\n edges = graph.edges(path)\\n for n1, n2, d in edges:\\n # 3.a. recording:\\n v = flow_graph.edge(n1, n2, default=None)\\n if v is None:\\n flow_graph.add_edge(n1, n2, path_flow)\\n c = graph.edge(n1, n2) - path_flow\\n else:\\n flow_graph.add_edge(n1, n2, value=v + path_flow)\\n c = graph.edge(n1, n2) - (v + path_flow)\\n capacity_graph.add_edge(n1, n2, c)\\n\\n # 3.b. updating:\\n # if there is capacity left: update with new 1/capacity\\n # else: remove node, as we can't do 1/zero.\\n if c > 0:\\n inverted_graph.add_edge(n1, n2, 1 / c)\\n else:\\n inverted_graph.del_edge(n1, n2)\\n return total_flow, flow_graph\",\n \"def get_highest_preference(self, routes):\\n # filter out any routes that don't have the highest localPref\\n outroutes = routes.copy()\\n outroutes.sort(reverse=True, key=lambda r: r[MESG][LPRF])\\n highest = outroutes[0][MESG][LPRF]\\n outroutes = list(filter(lambda r: r[MESG][LPRF] == highest, outroutes))\\n return outroutes\",\n \"def pair_nodes_with_max_weight_in_shortest_path(graph):\\n list_pairs_with_shortest_path = []\\n # The following for loop takes each pair, and adds the weight of their shortest path to the list\\n for frm_name in graph.nodes:\\n for to_name in graph.nodes:\\n if frm_name != to_name: # Irrelevant because the question asks \\\"pair of nodes\\\"\\n shortest_path = graph.find_shortest_path(frm_name, to_name)\\n if shortest_path != None: # We must ignore a pair with no path\\n path_weight = graph.get_path_weight(shortest_path)\\n if path_weight != None: # We must ignore path with None weight\\n pair_weight_tup = ((frm_name, to_name), path_weight)\\n list_pairs_with_shortest_path.append(pair_weight_tup)\\n # print(list_pairs_with_shortest_path) # Was used to check the function\\n sorted_list_pairs = sorted(list_pairs_with_shortest_path, key=lambda tup: tup[1], reverse=True)\\n pair_with_max = sorted_list_pairs[0] # Pair with the highest weight\\n return \\\"Pair whose shortest path with max weight: {} to {}\\\".format(pair_with_max[0][0], pair_with_max[0][1])\",\n \"def data_edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.data_edge_count_max or 0)\",\n \"def get_max_addr(self):\\n\\n out = None\\n for segment in self.segments:\\n if out is None or segment.max_addr > out:\\n out = segment.max_addr\\n\\n if out is None:\\n for section in self.sections:\\n if out is None or section.max_addr > out:\\n out = section.max_addr\\n\\n if out is None:\\n return self.rebase_addr\\n else:\\n return out + self.rebase_addr\",\n \"def calc_strongest_bridge(comp_map: CompMap):\\n @lru_cache(None)\\n def _helper(cur_no_pins: int = 0, used_components: FrozenSet[Component] = frozenset()):\\n available_connections = comp_map[cur_no_pins] - used_components\\n\\n if not available_connections:\\n return sum(c.strength for c in used_components)\\n\\n res = []\\n for c in available_connections:\\n res.append(_helper(c.other(cur_no_pins), used_components | {c}))\\n return max(res)\\n res = _helper()\\n print(_helper.cache_info())\\n return res\",\n \"def get_highest_preference(self, routes):\\n if len(routes) == 1: \\n return routes\\n if len(routes) == 0: \\n return []\\n prefList = []\\n for val in routes: \\n prefList.append(val[\\\"msg\\\"][\\\"localpref\\\"]) \\n highestVal = max(prefList) \\n outroutes = []\\n for val in routes:\\n if val[\\\"msg\\\"][\\\"localpref\\\"] == highestVal:\\n outroutes.append(val)\\n return outroutes\",\n \"def get_max_paper(link_graph: dict):\\n papers = []\\n for k, v in link_graph.items():\\n papers.extend(v.keys())\\n return max(papers, key=papers.count)\",\n \"def largestResolution(resolutions):\\n return resolutions[0]\",\n \"def handle_request(self, sw, util, duration, time_now):\\n\\n #logging.debug(str(self.graph.edges(data=True)))\\n\\n #1 Get available paths from servers to switch\\n paths = self.get_srv_paths(sw, self.graph)\\n\\n #2 choose the path which mins the max link utilization for all links\\n # along the path\\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\\n\\n if len(bestpath) > 0:\\n self.allocate_resources(bestpath, util, time_now, duration)\\n else:\\n logging.warn(\\\"[%s] No best path found at switch [%s]\\\", str(time_now), str(sw))\\n\\n return bestpath\",\n \"def _get_maximum(self):\\n return self._maximum\",\n \"def best_routes_for_routers(self) -> Sequence['outputs.GetRouterStatusBestRoutesForRouterResult']:\\n return pulumi.get(self, \\\"best_routes_for_routers\\\")\",\n \"def best_routes(self) -> Sequence['outputs.GetRouterStatusBestRouteResult']:\\n return pulumi.get(self, \\\"best_routes\\\")\",\n \"def lovliest_path(G):\\n m = 0\\n ma = None\\n mb = None\\n for node in G.keys():\\n for conn in G[node].keys():\\n if G[node][conn] > m:\\n m = G[node][conn]\\n ma = node\\n mb = conn\\n print \\\"found lovliest_path of %s to %s with weight %s\\\" % (ma,mb,m)\\n return (ma,mb)\",\n \"def produce_max(self, meta, raven_vars, dispatch, t):\\n request, meta = self.get_capacity(meta, raven_vars, dispatch, t)\\n return request, meta\",\n \"def calc_lp(self, demands: Demand, routing: Routing) -> float:\\n epsilon = self.epsilon\\n\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('flow_utilisation_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the amount of flow along each edge\\n # stored as a list flow_variables[ith_flow][jth_edge]\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(len(self.edges)):\\n flow_variable_edges.append(\\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Flow from source constraint (net flow must equal demand)\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create constraint\\n constraint_i = solver.Constraint(demands[i] - epsilon,\\n demands[i] + epsilon,\\n '(source,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]:\\n # out flow is positive\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]:\\n # in flow is negative\\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Flow to sink constraint (in flow must equal demand, out must be zero)\\n conservation_sink_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # create in flow constraint\\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\\n -demands[i] + epsilon,\\n '(sink_in,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[1])]:\\n # in flow is negative\\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\\n -1)\\n conservation_sink_constraints.append(constraint_i_in)\\n\\n constraint_i_out = solver.Constraint(0, 0,\\n '(sink_out,{})'.format(i))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[1])]:\\n # out flow is positive\\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\\n 1)\\n conservation_sink_constraints.append(constraint_i_out)\\n\\n # Flow at transit node constraint (net flow must be zero)\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n if j != commodity[0] and j != commodity[1]:\\n # create constraint\\n constraint_j = solver.Constraint(-epsilon, +epsilon,\\n '(transit,{},{})'.format(i,\\n j))\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]:\\n # out flow is positive\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n 1)\\n for edge_index in [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]:\\n # in flow is negative\\n constraint_j.SetCoefficient(\\n flow_variables[i][edge_index],\\n -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at transit constraints (edge flow must be correct split of\\n # in flow)\\n splitting_ratio_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.graph.number_of_nodes()):\\n # Sink has not such constraint and we handle source differently\\n if j != commodity[1] and j != commodity[0]:\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(j)]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(j)]\\n\\n # separate constraint for split of each out_edge taking into\\n # account all in_edges\\n for out_edge_index in out_edges:\\n # create constraint\\n constraint_edge = \\\\\\n solver.Constraint(-epsilon, +epsilon,\\n '(split,{},{},{})'.format(\\n i, j,\\n out_edge_index))\\n split_ratio = routing[i][out_edge_index]\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by\\n # split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n splitting_ratio_constraints.append(constraints_flow_i)\\n\\n # Flow splitting at source constraints (edge flow must be correct split of\\n # in flow + demand)\\n source_splitting_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n in_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.in_edges(commodity[0])]\\n out_edges = [self.edge_index_dict[edge] for edge in\\n self.graph.out_edges(commodity[0])]\\n for out_edge_index in out_edges:\\n # create constraint\\n split_ratio = routing[i][out_edge_index]\\n split_demand = split_ratio * demands[i]\\n constraint_edge = \\\\\\n solver.Constraint(split_demand - epsilon,\\n split_demand + epsilon,\\n '(split,{},{},{})'.format(i, j,\\n out_edge_index))\\n # flow on out edge\\n constraint_edge.SetCoefficient(\\n flow_variables[i][out_edge_index], 1)\\n for in_edge_index in in_edges:\\n # should equal sum of flow on all in edges scaled by split ratio\\n constraint_edge.SetCoefficient(\\n flow_variables[i][in_edge_index],\\n -1 * split_ratio)\\n constraints_flow_i.append(constraint_edge)\\n source_splitting_constraints.append(constraints_flow_i)\\n\\n solver.Solve()\\n\\n result_status = solver.Solve()\\n\\n utilisation = np.zeros(\\n (len(self.commodities), self.graph.number_of_edges()))\\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\\n # assignment = np.zeros(\\n # (len(self.commodities), self.graph.number_of_edges()))\\n\\n # if routing is really that bad, just bail and give a sad result\\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\\n return 1.0\\n\\n for i in range(len(self.commodities)):\\n for j in range(self.graph.number_of_edges()):\\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\\\\n self.edges[j][2]['weight']\\n # assignment[i][j] = flow_variables[i][j].solution_value()\\n\\n return np.max(np.sum(utilisation, axis=0))\",\n \"def search_for_maximum(self):\\n return self.maximise_aquisition(self.expected_improvement)\",\n \"def get_highest_preference(self, routes):\\n # start highest lpref route as the first route's path\\n highest_lprf_route = [routes[0]]\\n # start the highest lpref as that\\n # of the first route's path\\n highest_lprf = int(routes[0][LPRF])\\n # iterate through all routes in given list and\\n # find the one with the highest local pref\\n for route in routes:\\n r_lprf = int(route[LPRF])\\n if r_lprf > highest_lprf:\\n highest_lprf = r_lprf\\n highest_lprf_route = [route]\\n elif r_lprf == highest_lprf:\\n highest_lprf_route.append(route)\\n return highest_lprf_route\",\n \"def cost(route):\\n cost = 0\\n for li in route:\\n if cost<li.get_cost():\\n cost=li.get_cost()\\n return cost\",\n \"def greedy(self):\\n # for each node, find the incoming link with the highest score.\\n max_scores = {}\\n max_sources = {}\\n for source, target in self.iteredges():\\n score = self.get_score(source, target)\\n max_score = max_scores.get(target)\\n if max_score is None or score > max_score:\\n max_scores[target] = score\\n max_sources[target] = source\\n # then build a graph out of just these links.\\n succs = dict((n, []) for n in self)\\n for target, source in max_sources.items():\\n succs[source].append(target)\\n return Digraph(succs, self.get_score, self.get_label)\",\n \"def global_efficiency(graph):\\n return nx.global_efficiency(graph.graph)\",\n \"def max_num_links(self):\\n return self._max_num_links\",\n \"def calculate_best_way(self) -> int:\\n node = self._find_lowest_cost_node()\\n while node:\\n cost = self.costs[node]\\n neighbors = self.graph[node]\\n for neighbor in neighbors.keys():\\n node_cost = cost + neighbors[neighbor]\\n if self.costs[neighbor] > node_cost:\\n self.costs[neighbor] = node_cost\\n self.parents[neighbor] = node\\n self.closed_nodes.append(node)\\n node = self._find_lowest_cost_node()\\n\\n return self.costs[\\\"fin\\\"]\",\n \"def _maximum(self) -> float:\\n if self._type == \\\"power\\\":\\n return 5.0\\n elif self._type == \\\"setpoint\\\":\\n return self._product.get_data_config_json()[\\\"_value_setpoint_max\\\"]\\n elif self._type == \\\"fan1\\\":\\n fan = 1\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\\n elif self._type == \\\"fan2\\\":\\n fan = 2\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\\n elif self._type == \\\"fan3\\\":\\n fan = 3\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\",\n \"def calculate_ucb_max(self, node):\\n pass\",\n \"def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,\\n best_path):\\n path[0] = path[0] + [start]\\n \\n if digraph.has_node(Node(start)) == False or digraph.has_node(Node(end)) == False:\\n raise ValueError('Start or end node are not valid')\\n elif start == end :\\n return path\\n else:\\n for edge in digraph.get_edges_for_node(Node(start)):\\n \\n node = str(edge.get_destination())\\n tot_distance = edge.get_total_distance() + path[1]\\n tot_outdoors = edge.get_outdoor_distance() + path[2]\\n\\n if node not in path[0] and tot_distance <= best_dist and tot_outdoors <= max_dist_outdoors :\\n updated_path = [path[0], tot_distance, tot_outdoors]\\n new_path = get_best_path(digraph, node, end, updated_path, max_dist_outdoors, best_dist, best_path)\\n \\n if new_path:\\n if not best_dist or new_path[1] < best_dist: \\n best_path = new_path[0]\\n best_dist = new_path[1]\\n\\n return best_path, best_dist\",\n \"def get_max_lb(self):\\n max_lb = 0\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"lower_bound\\\"] > max_lb:\\n max_lb = self.arc_info[arc][\\\"lower_bound\\\"]\\n return max_lb\",\n \"def score_max_depths(graph, max_depths):\\n ###TODO\\n pass\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def find_best_route(all_cost, all_routes):\\n cost_best_route = np.inf\\n for i in range(len(all_cost)):\\n if all_cost[i] < cost_best_route:\\n cost_best_route = all_cost[i]\\n best_route = all_routes[i]\\n return cost_best_route, best_route\",\n \"def max_cardinality():\\r\\n #create a list containing the number of each vertex involvement.\\r\\n array = []\\r\\n for i in adj:\\r\\n array += [i[0],i[1]]\\r\\n\\r\\n #compute the degree by counting the involment\\r\\n degree = Counter(array).most_common()\\r\\n\\r\\n #retrieve the degree only\\r\\n degree_ = [ i[1] for i in degree]\\r\\n\\r\\n degree_ = np.array(degree_)\\r\\n \\r\\n max_m = None\\r\\n \\r\\n #check if m is valid\\r\\n for i in range(degree[0][1]+2)[2:]:\\r\\n \\r\\n #valid if there are at least m vertex with degree equals to at least m-1 \\r\\n if i < len(np.where(degree_>=i-1)[0]):\\r\\n max_m = i\\r\\n else:\\r\\n break\\r\\n max_m += 1\\r\\n print(f'maximum possible clique cardinality :{max_m}')\\r\\n return max_m\",\n \"def max_edges(self):\\n return self._max_edges\",\n \"def max_weight(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def edge_position_max(self) -> int:\\n return int(self.graph_tuple_stats.edge_position_max or 0)\",\n \"def find_max_depth(start_url):\\n print \\\"****** sequence of links that must be followed to reach the page *****\\\"\\n S, Q = set(), deque()\\n Q.append(start_url)\\n while Q:\\n u = Q.popleft()\\n if u in S: continue\\n b = u\\n S.add(u)\\n Q.extend(getLinks(u))\\n find_shortest_path(start_url,b)\\n print \\\"****** URL that is the greatest distance from start_url *****\\\"\\n print b\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\\n if highway == 'motorway':\\n result = -motorway_pref*0.5\\n elif highway == 'primary':\\n result = -highway_pref*0.5\\n elif highway == 'residential' or highway == 'service':\\n result = -residential_pref*0.5\\n elif highway == 'cycleway':\\n result = -bicycle_pref * 0.8\\n else:\\n result = 0\\n return result\",\n \"def find_max():\\n bridges = all_bridges\\n bridges = [ b for b in bridges if b != None ]\\n return max(bridges)\",\n \"def find_maximum_required_assets(geotype, area_km2, capacity_lookup):\\n capacity_values = []\\n for key, values in capacity_lookup.items():\\n if key[0] == geotype:\\n for value in values:\\n capacity_values.append(value[0])\\n\\n max_assets_km2 = max(capacity_values)\\n\\n max_assets = max_assets_km2 * area_km2\\n\\n return roundup(max_assets)\",\n \"def max_flow(self, source, sink):\\n\\n max_flow = 0\\n\\n for i in range(self.V):\\n for j in range(self.V):\\n self.flow[i, j] = 0\\n\\n while self.bfs(source, sink):\\n increment = maxint\\n\\n u = sink\\n\\n while self.pred[u] != -1:\\n increment = min(\\n increment, self.capacity[self.pred[u], u] - self.flow[self.pred[u], u])\\n u = self.pred[u]\\n\\n u = sink\\n\\n while self.pred[u] != -1:\\n self.flow[self.pred[u], u] += increment\\n self.flow[u, self.pred[u]] -= increment\\n u = self.pred[u]\\n\\n max_flow += increment\\n\\n return max_flow\",\n \"def max_surge(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"max_surge\\\")\",\n \"def max_surge(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_surge\\\")\",\n \"def maxValue(gameState, depth, a, b):\\n ultimateMove = None # The best move the agent can do\\n if gameState.isWin() or gameState.isLose(): # if terminal node return gamescore\\n return self.evaluationFunction(gameState)\\n bestValue = -math.inf\\n # for all of max agents moves\\n for action in gameState.getLegalActions(0):\\n value = minValue(gameState.generateSuccessor(\\n 0, action), depth, 1, a, b) # save value from call to minimizing agent\\n if value > bestValue: # if value has increased, update parametres\\n bestValue = value\\n ultimateMove = action\\n a = max(a, bestValue) # updates a=alpha if bestvalue > alpha\\n if bestValue > b: # if value is greater than connected branch, do prune\\n return bestValue\\n if depth == self.depth: # if top node, return the best move\\n return ultimateMove\\n else:\\n # if not top node (and no pruning) return best value\\n return bestValue\",\n \"def get_graph_attributes(net_G):\\r\\n # number of nodes\\r\\n num_of_nodes = net_G.number_of_nodes()\\r\\n # number of nodes\\r\\n num_of_edges = net_G.number_of_edges()\\r\\n # density of net\\r\\n net_density = nx.density(net_G)\\r\\n # maximum degree and average degree\\r\\n nodes_degree = nx.degree(net_G)\\r\\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\\r\\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\\r\\n # global clustering coefficient: n - count numbers of paths of length two\\r\\n nodes_triangles = nx.triangles(net_G)\\r\\n num_of_triangles = sum(nodes_triangles.values())\\r\\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\\r\\n n = 0 \\r\\n for node in pairs_path_length.keys(): \\r\\n for item in pairs_path_length[node].values():\\r\\n if item == 2:\\r\\n n = n + 1\\r\\n global_clustering_coefficient = (num_of_triangles * 6) / n\\r\\n # size of giant component\\r\\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\\r\\n # return number of edges in graph=graph size\\r\\n size_of_giant = nx.Graph.size(giant_component)\\r\\n # calculate the average path length of giant component\\r\\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\\r\\n # maximum centrality and average centrality\\r\\n nodes_centrality = nx.degree_centrality(net_G)\\r\\n maximum_of_centrality = max(nodes_centrality.values())\\r\\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\\r\\n # maximum betweenness centrality\\r\\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\\r\\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\\r\\n # maximum closeness centrality\\r\\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\\r\\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\\r\\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\\r\\n # summarize graph attributes\\r\\n graph_attributes = [[\\\"Number of nodes:\\\", num_of_nodes], \\\\\\r\\n [\\\"Number of edges:\\\", num_of_edges], \\\\\\r\\n [\\\"Global clustering coefficient:\\\", global_clustering_coefficient], \\\\\\r\\n [\\\"Maximum degree:\\\", maximum_degree], \\\\\\r\\n [\\\"Average degree:\\\", average_degree], \\\\\\r\\n [\\\"Size of giant component:\\\", size_of_giant], \\\\\\r\\n [\\\"Average path length:\\\", average_shortest_path_length],\\\\\\r\\n [\\\"Maximum centrality:\\\", maximum_of_centrality], \\\\\\r\\n [\\\"Average centrality:\\\", average_of_centrality],\\\\\\r\\n [\\\"Maximum betweenness centrality:\\\", maximum_betweenness_centrality],\\\\\\r\\n [\\\"Maximum closeness centrality:\\\", maximum_closeness_centrality], \\\\\\r\\n [\\\"Average closeness centrality:\\\", average_closeness_centrality], \\\\\\r\\n [\\\"Net density:\\\", net_density]]\\r\\n return graph_attributes\",\n \"def maxWeightMatching(edges, maxcardinality=False):\\r\\n\\r\\n #\\r\\n # Vertices are numbered 0 .. (nvertex-1).\\r\\n # Non-trivial blossoms are numbered nvertex .. (2*nvertex-1)\\r\\n #\\r\\n # Edges are numbered 0 .. (nedge-1).\\r\\n # Edge endpoints are numbered 0 .. (2*nedge-1), such that endpoints\\r\\n # (2*k) and (2*k+1) both belong to edge k.\\r\\n #\\r\\n # Many terms used in the comments (sub-blossom, T-vertex) come from\\r\\n # the paper by Galil; read the paper before reading this code.\\r\\n #\\r\\n\\r\\n # Python 2/3 compatibility.\\r\\n from sys import version as sys_version\\r\\n if sys_version < '3':\\r\\n integer_types = (int, long)\\r\\n else:\\r\\n integer_types = (int,)\\r\\n\\r\\n # Deal swiftly with empty graphs.\\r\\n if not edges:\\r\\n return [ ]\\r\\n\\r\\n # Count vertices.\\r\\n nedge = len(edges)\\r\\n nvertex = 0\\r\\n for (i, j, w) in edges:\\r\\n assert i >= 0 and j >= 0 #and i != j\\r\\n if i >= nvertex:\\r\\n nvertex = i + 1\\r\\n if j >= nvertex:\\r\\n nvertex = j + 1\\r\\n\\r\\n # Find the maximum edge weight.\\r\\n maxweight = max(0, max([ wt for (i, j, wt) in edges ]))\\r\\n\\r\\n # If p is an edge endpoint,\\r\\n # endpoint[p] is the vertex to which endpoint p is attached.\\r\\n # Not modified by the algorithm.\\r\\n endpoint = [ edges[p//2][p%2] for p in range(2*nedge) ]\\r\\n\\r\\n # If v is a vertex,\\r\\n # neighbend[v] is the list of remote endpoints of the edges attached to v.\\r\\n # Not modified by the algorithm.\\r\\n neighbend = [ [ ] for i in range(nvertex) ]\\r\\n for k in range(len(edges)):\\r\\n (i, j, w) = edges[k]\\r\\n neighbend[i].append(2*k+1)\\r\\n neighbend[j].append(2*k)\\r\\n\\r\\n # If v is a vertex,\\r\\n # mate[v] is the remote endpoint of its matched edge, or -1 if it is single\\r\\n # (i.e. endpoint[mate[v]] is v's partner vertex).\\r\\n # Initially all vertices are single; updated during augmentation.\\r\\n mate = nvertex * [ -1 ]\\r\\n\\r\\n # If b is a top-level blossom,\\r\\n # label[b] is 0 if b is unlabeled (free);\\r\\n # 1 if b is an S-vertex/blossom;\\r\\n # 2 if b is a T-vertex/blossom.\\r\\n # The label of a vertex is found by looking at the label of its\\r\\n # top-level containing blossom.\\r\\n # If v is a vertex inside a T-blossom,\\r\\n # label[v] is 2 iff v is reachable from an S-vertex outside the blossom.\\r\\n # Labels are assigned during a stage and reset after each augmentation.\\r\\n label = (2 * nvertex) * [ 0 ]\\r\\n\\r\\n # If b is a labeled top-level blossom,\\r\\n # labelend[b] is the remote endpoint of the edge through which b obtained\\r\\n # its label, or -1 if b's base vertex is single.\\r\\n # If v is a vertex inside a T-blossom and label[v] == 2,\\r\\n # labelend[v] is the remote endpoint of the edge through which v is\\r\\n # reachable from outside the blossom.\\r\\n labelend = (2 * nvertex) * [ -1 ]\\r\\n\\r\\n # If v is a vertex,\\r\\n # inblossom[v] is the top-level blossom to which v belongs.\\r\\n # If v is a top-level vertex, v is itself a blossom (a trivial blossom)\\r\\n # and inblossom[v] == v.\\r\\n # Initially all vertices are top-level trivial blossoms.\\r\\n inblossom = list(range(nvertex))\\r\\n\\r\\n # If b is a sub-blossom,\\r\\n # blossomparent[b] is its immediate parent (sub-)blossom.\\r\\n # If b is a top-level blossom, blossomparent[b] is -1.\\r\\n blossomparent = (2 * nvertex) * [ -1 ]\\r\\n\\r\\n # If b is a non-trivial (sub-)blossom,\\r\\n # blossomchilds[b] is an ordered list of its sub-blossoms, starting with\\r\\n # the base and going round the blossom.\\r\\n blossomchilds = (2 * nvertex) * [ None ]\\r\\n\\r\\n # If b is a (sub-)blossom,\\r\\n # blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).\\r\\n blossombase = list(range(nvertex)) + nvertex * [ -1 ]\\r\\n\\r\\n # If b is a non-trivial (sub-)blossom,\\r\\n # blossomendps[b] is a list of endpoints on its connecting edges,\\r\\n # such that blossomendps[b][i] is the local endpoint of blossomchilds[b][i]\\r\\n # on the edge that connects it to blossomchilds[b][wrap(i+1)].\\r\\n blossomendps = (2 * nvertex) * [ None ]\\r\\n\\r\\n # If v is a free vertex (or an unreached vertex inside a T-blossom),\\r\\n # bestedge[v] is the edge to an S-vertex with least slack,\\r\\n # or -1 if there is no such edge.\\r\\n # If b is a (possibly trivial) top-level S-blossom,\\r\\n # bestedge[b] is the least-slack edge to a different S-blossom,\\r\\n # or -1 if there is no such edge.\\r\\n # This is used for efficient computation of delta2 and delta3.\\r\\n bestedge = (2 * nvertex) * [ -1 ]\\r\\n\\r\\n # If b is a non-trivial top-level S-blossom,\\r\\n # blossombestedges[b] is a list of least-slack edges to neighbouring\\r\\n # S-blossoms, or None if no such list has been computed yet.\\r\\n # This is used for efficient computation of delta3.\\r\\n blossombestedges = (2 * nvertex) * [ None ]\\r\\n\\r\\n # List of currently unused blossom numbers.\\r\\n unusedblossoms = list(range(nvertex, 2*nvertex))\\r\\n\\r\\n # If v is a vertex,\\r\\n # dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual\\r\\n # optimization problem (multiplication by two ensures integer values\\r\\n # throughout the algorithm if all edge weights are integers).\\r\\n # If b is a non-trivial blossom,\\r\\n # dualvar[b] = z(b) where z(b) is b's variable in the dual optimization\\r\\n # problem.\\r\\n dualvar = nvertex * [ maxweight ] + nvertex * [ 0 ]\\r\\n\\r\\n # If allowedge[k] is true, edge k has zero slack in the optimization\\r\\n # problem; if allowedge[k] is false, the edge's slack may or may not\\r\\n # be zero.\\r\\n allowedge = nedge * [ False ]\\r\\n\\r\\n # Queue of newly discovered S-vertices.\\r\\n queue = [ ]\\r\\n\\r\\n # Return 2 * slack of edge k (does not work inside blossoms).\\r\\n def slack(k):\\r\\n (i, j, wt) = edges[k]\\r\\n return dualvar[i] + dualvar[j] - 2 * wt\\r\\n\\r\\n # Generate the leaf vertices of a blossom.\\r\\n def blossomLeaves(b):\\r\\n if b < nvertex:\\r\\n yield b\\r\\n else:\\r\\n for t in blossomchilds[b]:\\r\\n if t < nvertex:\\r\\n yield t\\r\\n else:\\r\\n for v in blossomLeaves(t):\\r\\n yield v\\r\\n\\r\\n # Assign label t to the top-level blossom containing vertex w\\r\\n # and record the fact that w was reached through the edge with\\r\\n # remote endpoint p.\\r\\n def assignLabel(w, t, p):\\r\\n if DEBUG: DEBUG('assignLabel(%d,%d,%d)' % (w, t, p))\\r\\n b = inblossom[w]\\r\\n assert label[w] == 0 and label[b] == 0\\r\\n label[w] = label[b] = t\\r\\n labelend[w] = labelend[b] = p\\r\\n bestedge[w] = bestedge[b] = -1\\r\\n if t == 1:\\r\\n # b became an S-vertex/blossom; add it(s vertices) to the queue.\\r\\n queue.extend(blossomLeaves(b))\\r\\n if DEBUG: DEBUG('PUSH ' + str(list(blossomLeaves(b))))\\r\\n elif t == 2:\\r\\n # b became a T-vertex/blossom; assign label S to its mate.\\r\\n # (If b is a non-trivial blossom, its base is the only vertex\\r\\n # with an external mate.)\\r\\n base = blossombase[b]\\r\\n assert mate[base] >= 0\\r\\n assignLabel(endpoint[mate[base]], 1, mate[base] ^ 1)\\r\\n\\r\\n # Trace back from vertices v and w to discover either a new blossom\\r\\n # or an augmenting path. Return the base vertex of the new blossom or -1.\\r\\n def scanBlossom(v, w):\\r\\n if DEBUG: DEBUG('scanBlossom(%d,%d)' % (v, w))\\r\\n # Trace back from v and w, placing breadcrumbs as we go.\\r\\n path = [ ]\\r\\n base = -1\\r\\n while v != -1 or w != -1:\\r\\n # Look for a breadcrumb in v's blossom or put a new breadcrumb.\\r\\n b = inblossom[v]\\r\\n if label[b] & 4:\\r\\n base = blossombase[b]\\r\\n break\\r\\n assert label[b] == 1\\r\\n path.append(b)\\r\\n label[b] = 5\\r\\n # Trace one step back.\\r\\n assert labelend[b] == mate[blossombase[b]]\\r\\n if labelend[b] == -1:\\r\\n # The base of blossom b is single; stop tracing this path.\\r\\n v = -1\\r\\n else:\\r\\n v = endpoint[labelend[b]]\\r\\n b = inblossom[v]\\r\\n assert label[b] == 2\\r\\n # b is a T-blossom; trace one more step back.\\r\\n assert labelend[b] >= 0\\r\\n v = endpoint[labelend[b]]\\r\\n # Swap v and w so that we alternate between both paths.\\r\\n if w != -1:\\r\\n v, w = w, v\\r\\n # Remove breadcrumbs.\\r\\n for b in path:\\r\\n label[b] = 1\\r\\n # Return base vertex, if we found one.\\r\\n return base\\r\\n\\r\\n # Construct a new blossom with given base, containing edge k which\\r\\n # connects a pair of S vertices. Label the new blossom as S; set its dual\\r\\n # variable to zero; relabel its T-vertices to S and add them to the queue.\\r\\n def addBlossom(base, k):\\r\\n (v, w, wt) = edges[k]\\r\\n bb = inblossom[base]\\r\\n bv = inblossom[v]\\r\\n bw = inblossom[w]\\r\\n # Create blossom.\\r\\n b = unusedblossoms.pop()\\r\\n if DEBUG: DEBUG('addBlossom(%d,%d) (v=%d w=%d) -> %d' % (base, k, v, w, b))\\r\\n blossombase[b] = base\\r\\n blossomparent[b] = -1\\r\\n blossomparent[bb] = b\\r\\n # Make list of sub-blossoms and their interconnecting edge endpoints.\\r\\n blossomchilds[b] = path = [ ]\\r\\n blossomendps[b] = endps = [ ]\\r\\n # Trace back from v to base.\\r\\n while bv != bb:\\r\\n # Add bv to the new blossom.\\r\\n blossomparent[bv] = b\\r\\n path.append(bv)\\r\\n endps.append(labelend[bv])\\r\\n assert (label[bv] == 2 or\\r\\n (label[bv] == 1 and labelend[bv] == mate[blossombase[bv]]))\\r\\n # Trace one step back.\\r\\n assert labelend[bv] >= 0\\r\\n v = endpoint[labelend[bv]]\\r\\n bv = inblossom[v]\\r\\n # Reverse lists, add endpoint that connects the pair of S vertices.\\r\\n path.append(bb)\\r\\n path.reverse()\\r\\n endps.reverse()\\r\\n endps.append(2*k)\\r\\n # Trace back from w to base.\\r\\n while bw != bb:\\r\\n # Add bw to the new blossom.\\r\\n blossomparent[bw] = b\\r\\n path.append(bw)\\r\\n endps.append(labelend[bw] ^ 1)\\r\\n assert (label[bw] == 2 or\\r\\n (label[bw] == 1 and labelend[bw] == mate[blossombase[bw]]))\\r\\n # Trace one step back.\\r\\n assert labelend[bw] >= 0\\r\\n w = endpoint[labelend[bw]]\\r\\n bw = inblossom[w]\\r\\n # Set label to S.\\r\\n assert label[bb] == 1\\r\\n label[b] = 1\\r\\n labelend[b] = labelend[bb]\\r\\n # Set dual variable to zero.\\r\\n dualvar[b] = 0\\r\\n # Relabel vertices.\\r\\n for v in blossomLeaves(b):\\r\\n if label[inblossom[v]] == 2:\\r\\n # This T-vertex now turns into an S-vertex because it becomes\\r\\n # part of an S-blossom; add it to the queue.\\r\\n queue.append(v)\\r\\n inblossom[v] = b\\r\\n # Compute blossombestedges[b].\\r\\n bestedgeto = (2 * nvertex) * [ -1 ]\\r\\n for bv in path:\\r\\n if blossombestedges[bv] is None:\\r\\n # This subblossom does not have a list of least-slack edges;\\r\\n # get the information from the vertices.\\r\\n nblists = [ [ p // 2 for p in neighbend[v] ]\\r\\n for v in blossomLeaves(bv) ]\\r\\n else:\\r\\n # Walk this subblossom's least-slack edges.\\r\\n nblists = [ blossombestedges[bv] ]\\r\\n for nblist in nblists:\\r\\n for k in nblist:\\r\\n (i, j, wt) = edges[k]\\r\\n if inblossom[j] == b:\\r\\n i, j = j, i\\r\\n bj = inblossom[j]\\r\\n if (bj != b and label[bj] == 1 and\\r\\n (bestedgeto[bj] == -1 or\\r\\n slack(k) < slack(bestedgeto[bj]))):\\r\\n bestedgeto[bj] = k\\r\\n # Forget about least-slack edges of the subblossom.\\r\\n blossombestedges[bv] = None\\r\\n bestedge[bv] = -1\\r\\n blossombestedges[b] = [ k for k in bestedgeto if k != -1 ]\\r\\n # Select bestedge[b].\\r\\n bestedge[b] = -1\\r\\n for k in blossombestedges[b]:\\r\\n if bestedge[b] == -1 or slack(k) < slack(bestedge[b]):\\r\\n bestedge[b] = k\\r\\n if DEBUG: DEBUG('blossomchilds[%d]=' % b + repr(blossomchilds[b]))\\r\\n\\r\\n # Expand the given top-level blossom.\\r\\n def expandBlossom(b, endstage):\\r\\n if DEBUG: DEBUG('expandBlossom(%d,%d) %s' % (b, endstage, repr(blossomchilds[b])))\\r\\n # Convert sub-blossoms into top-level blossoms.\\r\\n for s in blossomchilds[b]:\\r\\n blossomparent[s] = -1\\r\\n if s < nvertex:\\r\\n inblossom[s] = s\\r\\n elif endstage and dualvar[s] == 0:\\r\\n # Recursively expand this sub-blossom.\\r\\n expandBlossom(s, endstage)\\r\\n else:\\r\\n for v in blossomLeaves(s):\\r\\n inblossom[v] = s\\r\\n # If we expand a T-blossom during a stage, its sub-blossoms must be\\r\\n # relabeled.\\r\\n if (not endstage) and label[b] == 2:\\r\\n # Start at the sub-blossom through which the expanding\\r\\n # blossom obtained its label, and relabel sub-blossoms untili\\r\\n # we reach the base.\\r\\n # Figure out through which sub-blossom the expanding blossom\\r\\n # obtained its label initially.\\r\\n assert labelend[b] >= 0\\r\\n entrychild = inblossom[endpoint[labelend[b] ^ 1]]\\r\\n # Decide in which direction we will go round the blossom.\\r\\n j = blossomchilds[b].index(entrychild)\\r\\n if j & 1:\\r\\n # Start index is odd; go forward and wrap.\\r\\n j -= len(blossomchilds[b])\\r\\n jstep = 1\\r\\n endptrick = 0\\r\\n else:\\r\\n # Start index is even; go backward.\\r\\n jstep = -1\\r\\n endptrick = 1\\r\\n # Move along the blossom until we get to the base.\\r\\n p = labelend[b]\\r\\n while j != 0:\\r\\n # Relabel the T-sub-blossom.\\r\\n label[endpoint[p ^ 1]] = 0\\r\\n label[endpoint[blossomendps[b][j-endptrick]^endptrick^1]] = 0\\r\\n assignLabel(endpoint[p ^ 1], 2, p)\\r\\n # Step to the next S-sub-blossom and note its forward endpoint.\\r\\n allowedge[blossomendps[b][j-endptrick]//2] = True\\r\\n j += jstep\\r\\n p = blossomendps[b][j-endptrick] ^ endptrick\\r\\n # Step to the next T-sub-blossom.\\r\\n allowedge[p//2] = True\\r\\n j += jstep\\r\\n # Relabel the base T-sub-blossom WITHOUT stepping through to\\r\\n # its mate (so don't call assignLabel).\\r\\n bv = blossomchilds[b][j]\\r\\n label[endpoint[p ^ 1]] = label[bv] = 2\\r\\n labelend[endpoint[p ^ 1]] = labelend[bv] = p\\r\\n bestedge[bv] = -1\\r\\n # Continue along the blossom until we get back to entrychild.\\r\\n j += jstep\\r\\n while blossomchilds[b][j] != entrychild:\\r\\n # Examine the vertices of the sub-blossom to see whether\\r\\n # it is reachable from a neighbouring S-vertex outside the\\r\\n # expanding blossom.\\r\\n bv = blossomchilds[b][j]\\r\\n if label[bv] == 1:\\r\\n # This sub-blossom just got label S through one of its\\r\\n # neighbours; leave it.\\r\\n j += jstep\\r\\n continue\\r\\n for v in blossomLeaves(bv):\\r\\n if label[v] != 0:\\r\\n break\\r\\n # If the sub-blossom contains a reachable vertex, assign\\r\\n # label T to the sub-blossom.\\r\\n if label[v] != 0:\\r\\n assert label[v] == 2\\r\\n assert inblossom[v] == bv\\r\\n label[v] = 0\\r\\n label[endpoint[mate[blossombase[bv]]]] = 0\\r\\n assignLabel(v, 2, labelend[v])\\r\\n j += jstep\\r\\n # Recycle the blossom number.\\r\\n label[b] = labelend[b] = -1\\r\\n blossomchilds[b] = blossomendps[b] = None\\r\\n blossombase[b] = -1\\r\\n blossombestedges[b] = None\\r\\n bestedge[b] = -1\\r\\n unusedblossoms.append(b)\\r\\n\\r\\n # Swap matched/unmatched edges over an alternating path through blossom b\\r\\n # between vertex v and the base vertex. Keep blossom bookkeeping consistent.\\r\\n def augmentBlossom(b, v):\\r\\n if DEBUG: DEBUG('augmentBlossom(%d,%d)' % (b, v))\\r\\n # Bubble up through the blossom tree from vertex v to an immediate\\r\\n # sub-blossom of b.\\r\\n t = v\\r\\n while blossomparent[t] != b:\\r\\n t = blossomparent[t]\\r\\n # Recursively deal with the first sub-blossom.\\r\\n if t >= nvertex:\\r\\n augmentBlossom(t, v)\\r\\n # Decide in which direction we will go round the blossom.\\r\\n i = j = blossomchilds[b].index(t)\\r\\n if i & 1:\\r\\n # Start index is odd; go forward and wrap.\\r\\n j -= len(blossomchilds[b])\\r\\n jstep = 1\\r\\n endptrick = 0\\r\\n else:\\r\\n # Start index is even; go backward.\\r\\n jstep = -1\\r\\n endptrick = 1\\r\\n # Move along the blossom until we get to the base.\\r\\n while j != 0:\\r\\n # Step to the next sub-blossom and augment it recursively.\\r\\n j += jstep\\r\\n t = blossomchilds[b][j]\\r\\n p = blossomendps[b][j-endptrick] ^ endptrick\\r\\n if t >= nvertex:\\r\\n augmentBlossom(t, endpoint[p])\\r\\n # Step to the next sub-blossom and augment it recursively.\\r\\n j += jstep\\r\\n t = blossomchilds[b][j]\\r\\n if t >= nvertex:\\r\\n augmentBlossom(t, endpoint[p ^ 1])\\r\\n # Match the edge connecting those sub-blossoms.\\r\\n mate[endpoint[p]] = p ^ 1\\r\\n mate[endpoint[p ^ 1]] = p\\r\\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (endpoint[p], endpoint[p^1], p//2))\\r\\n # Rotate the list of sub-blossoms to put the new base at the front.\\r\\n blossomchilds[b] = blossomchilds[b][i:] + blossomchilds[b][:i]\\r\\n blossomendps[b] = blossomendps[b][i:] + blossomendps[b][:i]\\r\\n blossombase[b] = blossombase[blossomchilds[b][0]]\\r\\n assert blossombase[b] == v\\r\\n\\r\\n # Swap matched/unmatched edges over an alternating path between two\\r\\n # single vertices. The augmenting path runs through edge k, which\\r\\n # connects a pair of S vertices.\\r\\n def augmentMatching(k):\\r\\n (v, w, wt) = edges[k]\\r\\n if DEBUG: DEBUG('augmentMatching(%d) (v=%d w=%d)' % (k, v, w))\\r\\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (v, w, k))\\r\\n for (s, p) in ((v, 2*k+1), (w, 2*k)):\\r\\n # Match vertex s to remote endpoint p. Then trace back from s\\r\\n # until we find a single vertex, swapping matched and unmatched\\r\\n # edges as we go.\\r\\n while 1:\\r\\n bs = inblossom[s]\\r\\n assert label[bs] == 1\\r\\n assert labelend[bs] == mate[blossombase[bs]]\\r\\n # Augment through the S-blossom from s to base.\\r\\n if bs >= nvertex:\\r\\n augmentBlossom(bs, s)\\r\\n # Update mate[s]\\r\\n mate[s] = p\\r\\n # Trace one step back.\\r\\n if labelend[bs] == -1:\\r\\n # Reached single vertex; stop.\\r\\n break\\r\\n t = endpoint[labelend[bs]]\\r\\n bt = inblossom[t]\\r\\n assert label[bt] == 2\\r\\n # Trace one step back.\\r\\n assert labelend[bt] >= 0\\r\\n s = endpoint[labelend[bt]]\\r\\n j = endpoint[labelend[bt] ^ 1]\\r\\n # Augment through the T-blossom from j to base.\\r\\n assert blossombase[bt] == t\\r\\n if bt >= nvertex:\\r\\n augmentBlossom(bt, j)\\r\\n # Update mate[j]\\r\\n mate[j] = labelend[bt]\\r\\n # Keep the opposite endpoint;\\r\\n # it will be assigned to mate[s] in the next step.\\r\\n p = labelend[bt] ^ 1\\r\\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (s, t, p//2))\\r\\n\\r\\n # Verify that the optimum solution has been reached.\\r\\n def verifyOptimum():\\r\\n if maxcardinality:\\r\\n # Vertices may have negative dual;\\r\\n # find a constant non-negative number to add to all vertex duals.\\r\\n vdualoffset = max(0, -min(dualvar[:nvertex]))\\r\\n else:\\r\\n vdualoffset = 0\\r\\n # 0. all dual variables are non-negative\\r\\n assert min(dualvar[:nvertex]) + vdualoffset >= 0\\r\\n assert min(dualvar[nvertex:]) >= 0\\r\\n # 0. all edges have non-negative slack and\\r\\n # 1. all matched edges have zero slack;\\r\\n for k in range(nedge):\\r\\n (i, j, wt) = edges[k]\\r\\n s = dualvar[i] + dualvar[j] - 2 * wt\\r\\n iblossoms = [ i ]\\r\\n jblossoms = [ j ]\\r\\n while blossomparent[iblossoms[-1]] != -1:\\r\\n iblossoms.append(blossomparent[iblossoms[-1]])\\r\\n while blossomparent[jblossoms[-1]] != -1:\\r\\n jblossoms.append(blossomparent[jblossoms[-1]])\\r\\n iblossoms.reverse()\\r\\n jblossoms.reverse()\\r\\n for (bi, bj) in zip(iblossoms, jblossoms):\\r\\n if bi != bj:\\r\\n break\\r\\n s += 2 * dualvar[bi]\\r\\n #assert s >= 0\\r\\n if mate[i] // 2 == k or mate[j] // 2 == k:\\r\\n assert mate[i] // 2 == k and mate[j] // 2 == k\\r\\n assert s == 0\\r\\n # 2. all single vertices have zero dual value;\\r\\n for v in range(nvertex):\\r\\n assert mate[v] >= 0 or dualvar[v] + vdualoffset == 0\\r\\n # 3. all blossoms with positive dual value are full.\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if blossombase[b] >= 0 and dualvar[b] > 0:\\r\\n assert len(blossomendps[b]) % 2 == 1\\r\\n for p in blossomendps[b][1::2]:\\r\\n assert mate[endpoint[p]] == p ^ 1\\r\\n assert mate[endpoint[p ^ 1]] == p\\r\\n # Ok.\\r\\n\\r\\n # Check optimized delta2 against a trivial computation.\\r\\n def checkDelta2():\\r\\n for v in range(nvertex):\\r\\n if label[inblossom[v]] == 0:\\r\\n bd = None\\r\\n bk = -1\\r\\n for p in neighbend[v]:\\r\\n k = p // 2\\r\\n w = endpoint[p]\\r\\n if label[inblossom[w]] == 1:\\r\\n d = slack(k)\\r\\n if bk == -1 or d < bd:\\r\\n bk = k\\r\\n bd = d\\r\\n if DEBUG and (bestedge[v] != -1 or bk != -1) and (bestedge[v] == -1 or bd != slack(bestedge[v])):\\r\\n DEBUG('v=' + str(v) + ' bk=' + str(bk) + ' bd=' + str(bd) + ' bestedge=' + str(bestedge[v]) + ' slack=' + str(slack(bestedge[v])))\\r\\n assert (bk == -1 and bestedge[v] == -1) or (bestedge[v] != -1 and bd == slack(bestedge[v]))\\r\\n\\r\\n # Check optimized delta3 against a trivial computation.\\r\\n def checkDelta3():\\r\\n bk = -1\\r\\n bd = None\\r\\n tbk = -1\\r\\n tbd = None\\r\\n for b in range(2 * nvertex):\\r\\n if blossomparent[b] == -1 and label[b] == 1:\\r\\n for v in blossomLeaves(b):\\r\\n for p in neighbend[v]:\\r\\n k = p // 2\\r\\n w = endpoint[p]\\r\\n if inblossom[w] != b and label[inblossom[w]] == 1:\\r\\n d = slack(k)\\r\\n if bk == -1 or d < bd:\\r\\n bk = k\\r\\n bd = d\\r\\n if bestedge[b] != -1:\\r\\n (i, j, wt) = edges[bestedge[b]]\\r\\n assert inblossom[i] == b or inblossom[j] == b\\r\\n assert inblossom[i] != b or inblossom[j] != b\\r\\n assert label[inblossom[i]] == 1 and label[inblossom[j]] == 1\\r\\n if tbk == -1 or slack(bestedge[b]) < tbd:\\r\\n tbk = bestedge[b]\\r\\n tbd = slack(bestedge[b])\\r\\n if DEBUG and bd != tbd:\\r\\n DEBUG('bk=%d tbk=%d bd=%s tbd=%s' % (bk, tbk, repr(bd), repr(tbd)))\\r\\n assert bd == tbd\\r\\n\\r\\n # Main loop: continue until no further improvement is possible.\\r\\n for t in range(nvertex):\\r\\n\\r\\n # Each iteration of this loop is a \\\"stage\\\".\\r\\n # A stage finds an augmenting path and uses that to improve\\r\\n # the matching.\\r\\n if DEBUG: DEBUG('STAGE %d' % t)\\r\\n\\r\\n # Remove labels from top-level blossoms/vertices.\\r\\n label[:] = (2 * nvertex) * [ 0 ]\\r\\n\\r\\n # Forget all about least-slack edges.\\r\\n bestedge[:] = (2 * nvertex) * [ -1 ]\\r\\n blossombestedges[nvertex:] = nvertex * [ None ]\\r\\n\\r\\n # Loss of labeling means that we can not be sure that currently\\r\\n # allowable edges remain allowable througout this stage.\\r\\n allowedge[:] = nedge * [ False ]\\r\\n\\r\\n # Make queue empty.\\r\\n queue[:] = [ ]\\r\\n \\r\\n # Label single blossoms/vertices with S and put them in the queue.\\r\\n for v in range(nvertex):\\r\\n if mate[v] == -1 and label[inblossom[v]] == 0:\\r\\n assignLabel(v, 1, -1)\\r\\n\\r\\n # Loop until we succeed in augmenting the matching.\\r\\n augmented = 0\\r\\n while 1:\\r\\n\\r\\n # Each iteration of this loop is a \\\"substage\\\".\\r\\n # A substage tries to find an augmenting path;\\r\\n # if found, the path is used to improve the matching and\\r\\n # the stage ends. If there is no augmenting path, the\\r\\n # primal-dual method is used to pump some slack out of\\r\\n # the dual variables.\\r\\n if DEBUG: DEBUG('SUBSTAGE')\\r\\n\\r\\n # Continue labeling until all vertices which are reachable\\r\\n # through an alternating path have got a label.\\r\\n while queue and not augmented:\\r\\n\\r\\n # Take an S vertex from the queue.\\r\\n v = queue.pop()\\r\\n if DEBUG: DEBUG('POP v=%d' % v)\\r\\n assert label[inblossom[v]] == 1\\r\\n\\r\\n # Scan its neighbours:\\r\\n for p in neighbend[v]:\\r\\n k = p // 2\\r\\n w = endpoint[p]\\r\\n # w is a neighbour to v\\r\\n if inblossom[v] == inblossom[w]:\\r\\n # this edge is internal to a blossom; ignore it\\r\\n continue\\r\\n if not allowedge[k]:\\r\\n kslack = slack(k)\\r\\n if kslack <= 0:\\r\\n # edge k has zero slack => it is allowable\\r\\n allowedge[k] = True\\r\\n if allowedge[k]:\\r\\n if label[inblossom[w]] == 0:\\r\\n # (C1) w is a free vertex;\\r\\n # label w with T and label its mate with S (R12).\\r\\n assignLabel(w, 2, p ^ 1)\\r\\n elif label[inblossom[w]] == 1:\\r\\n # (C2) w is an S-vertex (not in the same blossom);\\r\\n # follow back-links to discover either an\\r\\n # augmenting path or a new blossom.\\r\\n base = scanBlossom(v, w)\\r\\n if base >= 0:\\r\\n # Found a new blossom; add it to the blossom\\r\\n # bookkeeping and turn it into an S-blossom.\\r\\n addBlossom(base, k)\\r\\n else:\\r\\n # Found an augmenting path; augment the\\r\\n # matching and end this stage.\\r\\n augmentMatching(k)\\r\\n augmented = 1\\r\\n break\\r\\n elif label[w] == 0:\\r\\n # w is inside a T-blossom, but w itself has not\\r\\n # yet been reached from outside the blossom;\\r\\n # mark it as reached (we need this to relabel\\r\\n # during T-blossom expansion).\\r\\n assert label[inblossom[w]] == 2\\r\\n label[w] = 2\\r\\n labelend[w] = p ^ 1\\r\\n elif label[inblossom[w]] == 1:\\r\\n # keep track of the least-slack non-allowable edge to\\r\\n # a different S-blossom.\\r\\n b = inblossom[v]\\r\\n if bestedge[b] == -1 or kslack < slack(bestedge[b]):\\r\\n bestedge[b] = k\\r\\n elif label[w] == 0:\\r\\n # w is a free vertex (or an unreached vertex inside\\r\\n # a T-blossom) but we can not reach it yet;\\r\\n # keep track of the least-slack edge that reaches w.\\r\\n if bestedge[w] == -1 or kslack < slack(bestedge[w]):\\r\\n bestedge[w] = k\\r\\n\\r\\n if augmented:\\r\\n break\\r\\n\\r\\n # There is no augmenting path under these constraints;\\r\\n # compute delta and reduce slack in the optimization problem.\\r\\n # (Note that our vertex dual variables, edge slacks and delta's\\r\\n # are pre-multiplied by two.)\\r\\n deltatype = -1\\r\\n delta = deltaedge = deltablossom = None\\r\\n\\r\\n # Verify data structures for delta2/delta3 computation.\\r\\n if CHECK_DELTA:\\r\\n checkDelta2()\\r\\n checkDelta3()\\r\\n\\r\\n # Compute delta1: the minumum value of any vertex dual.\\r\\n if not maxcardinality:\\r\\n deltatype = 1\\r\\n delta = min(dualvar[:nvertex])\\r\\n\\r\\n # Compute delta2: the minimum slack on any edge between\\r\\n # an S-vertex and a free vertex.\\r\\n for v in range(nvertex):\\r\\n if label[inblossom[v]] == 0 and bestedge[v] != -1:\\r\\n d = slack(bestedge[v])\\r\\n if deltatype == -1 or d < delta:\\r\\n delta = d\\r\\n deltatype = 2\\r\\n deltaedge = bestedge[v]\\r\\n\\r\\n # Compute delta3: half the minimum slack on any edge between\\r\\n # a pair of S-blossoms.\\r\\n for b in range(2 * nvertex):\\r\\n if ( blossomparent[b] == -1 and label[b] == 1 and\\r\\n bestedge[b] != -1 ):\\r\\n kslack = slack(bestedge[b])\\r\\n if isinstance(kslack, integer_types):\\r\\n assert (kslack % 2) == 0\\r\\n d = kslack // 2\\r\\n else:\\r\\n d = kslack / 2\\r\\n if deltatype == -1 or d < delta:\\r\\n delta = d\\r\\n deltatype = 3\\r\\n deltaedge = bestedge[b]\\r\\n\\r\\n # Compute delta4: minimum z variable of any T-blossom.\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if ( blossombase[b] >= 0 and blossomparent[b] == -1 and\\r\\n label[b] == 2 and\\r\\n (deltatype == -1 or dualvar[b] < delta) ):\\r\\n delta = dualvar[b]\\r\\n deltatype = 4\\r\\n deltablossom = b\\r\\n\\r\\n if deltatype == -1:\\r\\n # No further improvement possible; max-cardinality optimum\\r\\n # reached. Do a final delta update to make the optimum\\r\\n # verifyable.\\r\\n assert maxcardinality\\r\\n deltatype = 1\\r\\n delta = max(0, min(dualvar[:nvertex]))\\r\\n\\r\\n # Update dual variables according to delta.\\r\\n for v in range(nvertex):\\r\\n if label[inblossom[v]] == 1:\\r\\n # S-vertex: 2*u = 2*u - 2*delta\\r\\n dualvar[v] -= delta\\r\\n elif label[inblossom[v]] == 2:\\r\\n # T-vertex: 2*u = 2*u + 2*delta\\r\\n dualvar[v] += delta\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if blossombase[b] >= 0 and blossomparent[b] == -1:\\r\\n if label[b] == 1:\\r\\n # top-level S-blossom: z = z + 2*delta\\r\\n dualvar[b] += delta\\r\\n elif label[b] == 2:\\r\\n # top-level T-blossom: z = z - 2*delta\\r\\n dualvar[b] -= delta\\r\\n\\r\\n # Take action at the point where minimum delta occurred.\\r\\n if DEBUG: DEBUG('delta%d=%f' % (deltatype, delta))\\r\\n if deltatype == 1: \\r\\n # No further improvement possible; optimum reached.\\r\\n break\\r\\n elif deltatype == 2:\\r\\n # Use the least-slack edge to continue the search.\\r\\n allowedge[deltaedge] = True\\r\\n (i, j, wt) = edges[deltaedge]\\r\\n if label[inblossom[i]] == 0:\\r\\n i, j = j, i\\r\\n assert label[inblossom[i]] == 1\\r\\n queue.append(i)\\r\\n elif deltatype == 3:\\r\\n # Use the least-slack edge to continue the search.\\r\\n allowedge[deltaedge] = True\\r\\n (i, j, wt) = edges[deltaedge]\\r\\n assert label[inblossom[i]] == 1\\r\\n queue.append(i)\\r\\n elif deltatype == 4:\\r\\n # Expand the least-z blossom.\\r\\n expandBlossom(deltablossom, False)\\r\\n\\r\\n # End of a this substage.\\r\\n\\r\\n # Stop when no more augmenting path can be found.\\r\\n if not augmented:\\r\\n break\\r\\n\\r\\n # End of a stage; expand all S-blossoms which have dualvar = 0.\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if ( blossomparent[b] == -1 and blossombase[b] >= 0 and\\r\\n label[b] == 1 and dualvar[b] == 0 ):\\r\\n expandBlossom(b, True)\\r\\n\\r\\n # Verify that we reached the optimum solution.\\r\\n if CHECK_OPTIMUM:\\r\\n verifyOptimum()\\r\\n\\r\\n # Transform mate[] such that mate[v] is the vertex to which v is paired.\\r\\n for v in range(nvertex):\\r\\n if mate[v] >= 0:\\r\\n mate[v] = endpoint[mate[v]]\\r\\n for v in range(nvertex):\\r\\n assert mate[v] == -1 or mate[mate[v]] == v\\r\\n\\r\\n return mate\",\n \"def get_max_incident_edge_weight(self, u, v):\\n max_weight = 0\\n for node in self.graph.neighbors(u):\\n if node != v and self.graph[u][node][\\\"weight\\\"] > max_weight:\\n max_weight = self.graph[u][node][\\\"weight\\\"]\\n\\n for node in self.graph.neighbors(v):\\n if node != u and self.graph[v][node][\\\"weight\\\"] > max_weight:\\n max_weight = self.graph[v][node][\\\"weight\\\"]\\n\\n return max_weight\",\n \"async def max_distance(self, *args):\\n return await self._rpc.max_distance(*args)\",\n \"def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\\n dtype=float)\\n\\n for commodity_idx in range(len(self.commodities)):\\n utilisation = self.calc_demand(routing,\\n demands[commodity_idx],\\n commodity_idx)\\n total_utilisation += utilisation\\n\\n return np.max(np.divide(total_utilisation, self.edge_capacities))\",\n \"def __find_max_distance(self):\\n return utils.find_max_distance(self.__game)\",\n \"def calculate_max_paths(self):\\n self.max_paths = {}\\n first_nodes = [key for (key, val) in self.predecessors.items() if not val]\\n for nm in first_nodes:\\n self.max_paths[nm] = {}\\n self._checking_path(node_name=nm, first_name=nm)\",\n \"def get_max_gains(self):\\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x800c+i,100)/100 for i in range(4)])\",\n \"def _maximum(self) -> float:\\n return self._config[CONF_MAX]\",\n \"def get_longest_paths(nodes, graph):\\n paths = []\\n distances = []\\n possible_paths = list(combinations(nodes, r=2))\\n for node1, node2 in possible_paths:\\n try:\\n path = nx.shortest_path(graph, node1, node2, \\\"weight\\\")\\n except Exception,e:\\n path = []\\n if len(path)>1:\\n distance = get_path_distance(path, graph)\\n paths.append(path)\\n distances.append(distance)\\n paths_sorted = [x for (y,x) in sorted(zip(distances, paths), reverse=True)]\\n # longest_path = paths_sorted[0]\\n # return longest_path\\n return paths_sorted\",\n \"def _cost_route_fine(self):\\n return self.fine\",\n \"def euclid_destination_for_passenger(state, problem):\\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\\n if unsatisfied:\\n max_dist = sum([p.opt for p in unsatisfied])\\n return max_dist\\n return 0\",\n \"def count_routes_max_distance(self, src, dest, max_distance):\\n\\n criteria = lambda stops, distance: distance < max_distance # inconsistent max, per test cases\\n return len(self.routes_with_criteria(src, dest, criteria))\",\n \"def findMaximumDeviationJunction(junctions, wires, resistances, voltages, currents):\\n raise NotImplementedError\",\n \"def resource_max_constraint_rule(backend_model, node, tech, timestep):\\n timestep_resolution = backend_model.timestep_resolution[timestep]\\n\\n return backend_model.resource_con[node, tech, timestep] <= (\\n timestep_resolution * backend_model.resource_cap[node, tech]\\n )\",\n \"def maximum(self):\\n return self.properties.get('maximum')\",\n \"def cost(graph,a, undirected=True):\\n cost = sum(sum(np.array(abs(graph-a))))\\n if undirected:\\n return cost/2.0\\n else:\\n return cost\",\n \"def max_degree_node(g, d, connected):\\n if not connected:\\n deg = d\\n else:\\n deg = {k: v for k, v in d.items() if k in connected}\\n if not deg:\\n return None\\n n = max(deg.keys(), key=lambda k: deg[k])\\n d.pop(n)\\n for n_ in g.neighbors(n):\\n connected.add(n_)\\n return n\",\n \"def bern_max_metric(pipe_diameter, delta_p):\\n\\n rho = 1000 # density of water kg/m^3\\n flow_rate_max = ((math.pi * (pipe_diameter**2)) / 4) * math.sqrt((2 * delta_p) / rho)\\n\\n return flow_rate_max\",\n \"def get_length(network, road_id):\\n return network[0][road_id][2]\",\n \"def get_bprop_maximum(self):\\n input_grad = G.MaximumGrad()\\n\\n def bprop(x, y, out, dout):\\n dx, dy = input_grad(x, y, dout)\\n return dx, dy\\n return bprop\",\n \"def longest_flight(g):\\n max_distance = None\\n max_destination = None\\n max_key = None\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n if(flight[1] > max_distance):\\n max_key = key\\n max_destination = flight[0]\\n max_distance = flight[1]\\n return g.city_dict[max_key].get_code(), max_destination, max_distance\",\n \"def greedy_max_cut(graph):\\n cut = Cut(set(), set())\\n for vertex in graph.nodes:\\n l_neighbors = sum((adj in cut.left) for adj in graph.neighbors(vertex))\\n r_neighbors = sum((adj in cut.right) for adj in graph.neighbors(vertex))\\n if l_neighbors < r_neighbors:\\n cut.left.add(vertex)\\n else:\\n cut.right.add(vertex)\\n return cut\",\n \"def calc_demand(self, routing: np.ndarray, demand: float,\\n commodity_idx: int) -> np.ndarray:\\n commodity = self.commodities[commodity_idx]\\n node_flow = np.zeros(self.num_nodes)\\n node_flow[commodity[0]] = demand\\n\\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\\n for edge_idx, edge in enumerate(self.edges):\\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\\n\\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\\n\\n num_steps = 0\\n while True:\\n change = np.multiply(split_matrix, node_flow)\\n edge_utilisation += change\\n node_flow = np.matmul(split_matrix, node_flow)\\n if np.any(np.isnan(change)):\\n print(\\\"is_nan :'(\\\")\\n comparison = np.less(np.nan_to_num(change), self.min_delta)\\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\\n break\\n num_steps += 1\\n # if we take more than |E| steps we have cycles which is not good.\\n # Therefore: end here with really bad reward, scaled by number of\\n # cycles\\n if num_steps > routing.shape[1]:\\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\\n edge_utilisation += np.multiply(remaining_flow, np.full(\\n (self.num_nodes, self.num_nodes), demand))\\n break\\n\\n return edge_utilisation\",\n \"def probabilityTransitionRule(self, unvisitedHeuristics, totalUnvisited):\\n argMaxProbValue = 0\\n argMaxToken = None\\n for unvisitedToken in unvisitedHeuristics:\\n probValue = unvisitedHeuristics[unvisitedToken] / totalUnvisited\\n\\n # In case obtained value is higher than previous maximum, substitute\\n if probValue > argMaxProbValue:\\n argMaxProbValue = probValue\\n argMaxToken = unvisitedToken\\n\\n return argMaxToken\",\n \"def build_links_capacity(self):\\n\\n links_capacity = {}\\n # Iterates all the edges in the topology formed by switches\\n for src, dst in self.topo.keep_only_p4switches().edges:\\n bw = self.topo.edges[(src, dst)]['bw']\\n # add both directions\\n links_capacity[(src, dst)] = bw\\n links_capacity[(dst, src)] = bw\\n\\n return links_capacity\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6513394","0.644975","0.62100786","0.61312515","0.610921","0.6011917","0.60004693","0.59970826","0.5994218","0.5972986","0.5926666","0.5894119","0.5879665","0.5859379","0.5828642","0.5822828","0.58168876","0.5812462","0.5796409","0.579364","0.5784096","0.57300127","0.5641055","0.5629129","0.5620991","0.560681","0.5604858","0.5597869","0.5570167","0.5567207","0.55592614","0.5558826","0.55519545","0.5541752","0.55397475","0.55112374","0.5495413","0.5479784","0.54792315","0.547255","0.54397386","0.54293203","0.5429201","0.5414267","0.5412129","0.54075587","0.53911656","0.53852355","0.53754604","0.5353445","0.5346078","0.5345415","0.5341091","0.531785","0.5314435","0.5304055","0.52962494","0.5295352","0.52895796","0.5288811","0.5284601","0.5279958","0.5268549","0.5257369","0.5252266","0.52483845","0.5246892","0.5245153","0.523341","0.52225876","0.5222464","0.5221687","0.52156085","0.52127236","0.5211881","0.52087146","0.520049","0.51982814","0.5195929","0.51936436","0.5192967","0.51921314","0.5186138","0.5175767","0.51678675","0.51666534","0.5156739","0.51560897","0.51544446","0.51519775","0.51425403","0.51421446","0.51412994","0.51405585","0.5137825","0.51317567","0.513158","0.51260453","0.51250494","0.5124216"],"string":"[\n \"0.6513394\",\n \"0.644975\",\n \"0.62100786\",\n \"0.61312515\",\n \"0.610921\",\n \"0.6011917\",\n \"0.60004693\",\n \"0.59970826\",\n \"0.5994218\",\n \"0.5972986\",\n \"0.5926666\",\n \"0.5894119\",\n \"0.5879665\",\n \"0.5859379\",\n \"0.5828642\",\n \"0.5822828\",\n \"0.58168876\",\n \"0.5812462\",\n \"0.5796409\",\n \"0.579364\",\n \"0.5784096\",\n \"0.57300127\",\n \"0.5641055\",\n \"0.5629129\",\n \"0.5620991\",\n \"0.560681\",\n \"0.5604858\",\n \"0.5597869\",\n \"0.5570167\",\n \"0.5567207\",\n \"0.55592614\",\n \"0.5558826\",\n \"0.55519545\",\n \"0.5541752\",\n \"0.55397475\",\n \"0.55112374\",\n \"0.5495413\",\n \"0.5479784\",\n \"0.54792315\",\n \"0.547255\",\n \"0.54397386\",\n \"0.54293203\",\n \"0.5429201\",\n \"0.5414267\",\n \"0.5412129\",\n \"0.54075587\",\n \"0.53911656\",\n \"0.53852355\",\n \"0.53754604\",\n \"0.5353445\",\n \"0.5346078\",\n \"0.5345415\",\n \"0.5341091\",\n \"0.531785\",\n \"0.5314435\",\n \"0.5304055\",\n \"0.52962494\",\n \"0.5295352\",\n \"0.52895796\",\n \"0.5288811\",\n \"0.5284601\",\n \"0.5279958\",\n \"0.5268549\",\n \"0.5257369\",\n \"0.5252266\",\n \"0.52483845\",\n \"0.5246892\",\n \"0.5245153\",\n \"0.523341\",\n \"0.52225876\",\n \"0.5222464\",\n \"0.5221687\",\n \"0.52156085\",\n \"0.52127236\",\n \"0.5211881\",\n \"0.52087146\",\n \"0.520049\",\n \"0.51982814\",\n \"0.5195929\",\n \"0.51936436\",\n \"0.5192967\",\n \"0.51921314\",\n \"0.5186138\",\n \"0.5175767\",\n \"0.51678675\",\n \"0.51666534\",\n \"0.5156739\",\n \"0.51560897\",\n \"0.51544446\",\n \"0.51519775\",\n \"0.51425403\",\n \"0.51421446\",\n \"0.51412994\",\n \"0.51405585\",\n \"0.5137825\",\n \"0.51317567\",\n \"0.513158\",\n \"0.51260453\",\n \"0.51250494\",\n \"0.5124216\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5926042"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":23591,"cells":{"query":{"kind":"string","value":"Returns the maxlinkutilisation for the graph, given the demands and routing This method is hopefully much faster (by using LP rather than naive flow pushing)."},"document":{"kind":"string","value":"def calc_lp(self, demands: Demand, routing: Routing) -> float:\n epsilon = self.epsilon\n\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('flow_utilisation_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the amount of flow along each edge\n # stored as a list flow_variables[ith_flow][jth_edge]\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(len(self.edges)):\n flow_variable_edges.append(\n solver.NumVar(0, solver.infinity(), '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Flow from source constraint (net flow must equal demand)\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create constraint\n constraint_i = solver.Constraint(demands[i] - epsilon,\n demands[i] + epsilon,\n '(source,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]:\n # out flow is positive\n constraint_i.SetCoefficient(flow_variables[i][edge_index], 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]:\n # in flow is negative\n constraint_i.SetCoefficient(flow_variables[i][edge_index], -1)\n conservation_source_constraints.append(constraint_i)\n\n # Flow to sink constraint (in flow must equal demand, out must be zero)\n conservation_sink_constraints = []\n for i, commodity in enumerate(self.commodities):\n # create in flow constraint\n constraint_i_in = solver.Constraint(-demands[i] - epsilon,\n -demands[i] + epsilon,\n '(sink_in,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[1])]:\n # in flow is negative\n constraint_i_in.SetCoefficient(flow_variables[i][edge_index],\n -1)\n conservation_sink_constraints.append(constraint_i_in)\n\n constraint_i_out = solver.Constraint(0, 0,\n '(sink_out,{})'.format(i))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[1])]:\n # out flow is positive\n constraint_i_out.SetCoefficient(flow_variables[i][edge_index],\n 1)\n conservation_sink_constraints.append(constraint_i_out)\n\n # Flow at transit node constraint (net flow must be zero)\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n if j != commodity[0] and j != commodity[1]:\n # create constraint\n constraint_j = solver.Constraint(-epsilon, +epsilon,\n '(transit,{},{})'.format(i,\n j))\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]:\n # out flow is positive\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n 1)\n for edge_index in [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]:\n # in flow is negative\n constraint_j.SetCoefficient(\n flow_variables[i][edge_index],\n -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Flow splitting at transit constraints (edge flow must be correct split of\n # in flow)\n splitting_ratio_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.graph.number_of_nodes()):\n # Sink has not such constraint and we handle source differently\n if j != commodity[1] and j != commodity[0]:\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(j)]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(j)]\n\n # separate constraint for split of each out_edge taking into\n # account all in_edges\n for out_edge_index in out_edges:\n # create constraint\n constraint_edge = \\\n solver.Constraint(-epsilon, +epsilon,\n '(split,{},{},{})'.format(\n i, j,\n out_edge_index))\n split_ratio = routing[i][out_edge_index]\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by\n # split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n splitting_ratio_constraints.append(constraints_flow_i)\n\n # Flow splitting at source constraints (edge flow must be correct split of\n # in flow + demand)\n source_splitting_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n in_edges = [self.edge_index_dict[edge] for edge in\n self.graph.in_edges(commodity[0])]\n out_edges = [self.edge_index_dict[edge] for edge in\n self.graph.out_edges(commodity[0])]\n for out_edge_index in out_edges:\n # create constraint\n split_ratio = routing[i][out_edge_index]\n split_demand = split_ratio * demands[i]\n constraint_edge = \\\n solver.Constraint(split_demand - epsilon,\n split_demand + epsilon,\n '(split,{},{},{})'.format(i, j,\n out_edge_index))\n # flow on out edge\n constraint_edge.SetCoefficient(\n flow_variables[i][out_edge_index], 1)\n for in_edge_index in in_edges:\n # should equal sum of flow on all in edges scaled by split ratio\n constraint_edge.SetCoefficient(\n flow_variables[i][in_edge_index],\n -1 * split_ratio)\n constraints_flow_i.append(constraint_edge)\n source_splitting_constraints.append(constraints_flow_i)\n\n solver.Solve()\n\n result_status = solver.Solve()\n\n utilisation = np.zeros(\n (len(self.commodities), self.graph.number_of_edges()))\n # # extract the actual routing. Useful for debugging, maybe use to bootstrap\n # assignment = np.zeros(\n # (len(self.commodities), self.graph.number_of_edges()))\n\n # if routing is really that bad, just bail and give a sad result\n if result_status == solver.NOT_SOLVED or result_status == solver.INFEASIBLE:\n return 1.0\n\n for i in range(len(self.commodities)):\n for j in range(self.graph.number_of_edges()):\n utilisation[i][j] = flow_variables[i][j].solution_value() / \\\n self.edges[j][2]['weight']\n # assignment[i][j] = flow_variables[i][j].solution_value()\n\n return np.max(np.sum(utilisation, axis=0))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def find_max_flow(graph, start, end):\n try:\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\"weight\")\n return flow_value\n except Exception as e:\n print(\"Error in Max flow computation \", e)\n return \"NaN\"","def get_max_usage(topology, path):\n max_usage = np.finfo(0.0).min\n for i in range(len(path.node_list) - 1):\n max_usage = max(max_usage, topology[path.node_list[i]][path.node_list[i + 1]]['total_units'] - topology[path.node_list[i]][path.node_list[i + 1]]['available_units'])\n return max_usage","def calc_slow(self, demands: Demand, routing: Routing) -> float:\n edge_capacities = [e[2]['weight'] for e in\n sorted(self.graph.edges(data=True))]\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\n # Because utilisation compared to link width is what we care about here\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\n\n return np.max(ratio_capacities)","def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edges)\n\n for i, flow in enumerate(flows):\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\n demands[\n i],\n routing[\n i])\n link_utilisation += flow_link_utilisation\n\n return link_utilisation","def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n link_utilisation = np.zeros(self.num_edges)\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\n node_flow[flow[0]] = demand\n\n to_explore = [flow[0]]\n while to_explore:\n current_node = to_explore.pop(0)\n current_flow = node_flow[current_node]\n\n # this is the flow destination node so we absorb all flow\n if current_node == flow[1]:\n node_flow[current_node] = 0.0\n continue\n\n # push the flow at this node over all edges\n for edge in self.graph.out_edges(current_node):\n edge_index = edge_mapping[edge]\n ratio = routing[edge_index]\n flow_to_send = ratio * current_flow\n # only send flow if greater than epsilon (so no 'infinite' loops)\n if flow_to_send > 1.e-8:\n node_flow[edge[1]] += ratio * current_flow\n # all important step, update our output\n link_utilisation[edge_index] += ratio * current_flow\n # have updated the dst so add it to the list of things to do\n to_explore.append(edge[1])\n # we've moved all the flow from this node now, so reset back to zero\n node_flow[current_node] = 0.0\n\n return link_utilisation","def max_path_cost(self, path, attr): \n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])","def maximal_destination_for_passenger(state, problem):\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\n if unsatisfied:\n max_dist = max([p.opt for p in unsatisfied])\n return max_dist\n return 0","def part_2(distances: Distances) -> int:\n\n result, _ = max(generate_routes(distances))\n print(f\"part 2: longest route has distance {result}\")\n return result","def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\n # set availbandwidth to the maximal value\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\n if d.type == 'STATIC':\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\n # subtract the reserved link and internal (inside Infras) bandwidth\n if mode == self.MODE_ADD:\n for d in self.infras:\n for p in d.ports:\n for fr in p.flowrules:\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\n # Flowrules are cummulatively subtracted from the switching \n # capacity of the node.\n d.availres['bandwidth'] -= fr.bandwidth\n if d.availres['bandwidth'] < 0:\n raise RuntimeError(\"The node bandwidth of %s got below zero \"\n \"during available resource calculation!\" %\n d.id)\n # Get all the mapped paths of all SGHops from the NFFG\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\n for sg_hop_id, data in sg_map.iteritems():\n src, dst, flowclass, bandwidth, delay, path = data\n if bandwidth is not None:\n for link in path:\n link.availbandwidth -= bandwidth\n if link.availbandwidth < 0:\n raise RuntimeError(\n \"The link bandwidth of %s got below zero during\"\n \"available resource calculation!\" % link.id)","def max_network_performance(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_network_performance\")","def max_dist(graph, source):\r\n q = queue.Queue()\r\n found = {}\r\n distance = {}\r\n for vertex in graph: \r\n found[vertex] = 0\r\n distance[vertex] = -1\r\n max_distance = 0\r\n found[source] = 1\r\n distance[source] = 0\r\n q.put(source)\r\n while q.empty() == False:\r\n current = q.get()\r\n for neighbour in graph[current]:\r\n if found[neighbour] == 0:\r\n found[neighbour] = 1\r\n distance[neighbour] = distance[current] + 1\r\n max_distance = distance[neighbour]\r\n q.put(neighbour)\r\n return max_distance","def maximum_flow(graph, start, end):\n if not isinstance(graph, BasicGraph):\n raise TypeError(f\"Expected subclass of BasicGraph, not {type(graph)}\")\n Graph = type(graph)\n \n if start not in graph:\n raise ValueError(f\"{start} not in graph\")\n if end not in graph:\n raise ValueError(f\"{end} not in graph\")\n\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\n total_flow = 0\n # -----------------------------------------------------------------------\n # The algorithm\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\n # of DFS, which leads to a lot of node visits.\n #\n # I therefore choose to invert the capacities of the graph so that the\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\n # This allows me to use the shortest path method to find the path with\n # most capacity in the first attempt, resulting in a significant reduction\n # of unassigned flow.\n #\n # By updating G_inverted, with the residual capacity, I can keep using the\n # shortest path, until the capacity is zero, whereby I remove the links\n # When the shortest path method returns 'No path' or when unassigned flow\n # is zero, I exit the algorithm.\n #\n # Even on small graphs, this method is very efficient, despite the overhead\n # of using shortest path. For very large graphs, this method outperforms\n # all other algorithms by orders of magnitude.\n # -----------------------------------------------------------------------\n\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\n inverted_graph = Graph(from_list=edges) # create G_inverted.\n capacity_graph = Graph() # Create structure to record capacity left.\n flow_graph = Graph() # Create structure to record flows.\n\n while unassigned_flow:\n # 1. find the best path\n d, path = shortest_path(inverted_graph, start, end)\n if d == float(\"inf\"): # then there is no path, and we must exit.\n return total_flow, flow_graph\n # else: use the path and lookup the actual flow from the capacity graph.\n\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\"inf\"))) for s, e, d in graph.edges(path=path)])\n\n # 2. update the unassigned flow.\n unassigned_flow -= path_flow\n total_flow += path_flow\n\n # 3. record the flows and update the inverted graph, so that it is\n # ready for the next iteration.\n edges = graph.edges(path)\n for n1, n2, d in edges:\n # 3.a. recording:\n v = flow_graph.edge(n1, n2, default=None)\n if v is None:\n flow_graph.add_edge(n1, n2, path_flow)\n c = graph.edge(n1, n2) - path_flow\n else:\n flow_graph.add_edge(n1, n2, value=v + path_flow)\n c = graph.edge(n1, n2) - (v + path_flow)\n capacity_graph.add_edge(n1, n2, c)\n\n # 3.b. updating:\n # if there is capacity left: update with new 1/capacity\n # else: remove node, as we can't do 1/zero.\n if c > 0:\n inverted_graph.add_edge(n1, n2, 1 / c)\n else:\n inverted_graph.del_edge(n1, n2)\n return total_flow, flow_graph","def test_max_flow(default_plugin_resolver):\n dpr = default_plugin_resolver\n source_node = 0\n target_node = 7\n ebunch = [\n (0, 1, 9),\n (0, 3, 10),\n (1, 4, 3),\n (2, 7, 6),\n (3, 1, 2),\n (3, 4, 8),\n (4, 5, 7),\n (4, 2, 4),\n (5, 2, 5),\n (5, 6, 1),\n (6, 2, 11),\n ]\n nx_graph = nx.DiGraph()\n nx_graph.add_weighted_edges_from(ebunch)\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\"weight\")\n\n expected_flow_value = 6\n bottleneck_nodes = {2, 4}\n expected_nodemap = {2: 6, 4: 6}\n\n mv = MultiVerify(dpr)\n results = mv.compute(\"flow.max_flow\", graph, source_node, target_node)\n\n # Compare flow rate\n results[0].assert_equal(expected_flow_value)\n\n # Normalize actual flow to prepare to transform\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\n\n # Compare sum of out edges for bottleneck nodes\n out_edges = mv.transform(\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\n actual_flow,\n lambda x, y: x + y,\n initial_value=0,\n )\n out_bottleneck = mv.transform(\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\n )\n out_bottleneck.assert_equal(expected_nodemap)\n\n # Compare sum of in edges for bottleneck nodes\n in_edges = mv.transform(\n \"util.graph.aggregate_edges.core_networkx\",\n actual_flow,\n lambda x, y: x + y,\n initial_value=0,\n in_edges=True,\n out_edges=False,\n )\n in_bottleneck = mv.transform(\n \"util.nodemap.select.core_python\", in_edges, bottleneck_nodes\n )\n in_bottleneck.assert_equal(expected_nodemap)","def calculate_greatest(self):\n greatest = 0\n for resourceList in self.loading.values():\n for time, use in resourceList:\n if use > greatest:\n greatest = use\n self.emit(\"greatest_calculated\",greatest)\n return greatest","def get_highest_preference(self, routes):\n # routes is all possible routes to daddr\n outroutes = {}\n highest = 0\n\n for ip in routes.keys():\n if routes[ip][LPRF] > highest:\n highest = routes[ip][LPRF]\n\n for ip in routes.keys():\n if routes[ip][LPRF] == highest:\n outroutes[ip] = routes[ip]\n\n return outroutes","def compute_path_metric(self, sw, path, util, time_now, local_contrib):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n # Use the last-learned-via-sync value for a link\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\n used1 = self.graph[u][v]['sync_learned'] + util\n used2 = self.graph[u][v]['used'] + util\n # ['used'] is a strict lower bound for ['sync_learned']\n if used1 > used2: \n used = used1\n logging.debug(\"CS [%s] using sync_learned value 1 [%f]\", str(self.name), used1)\n else:\n used = used2\n logging.debug(\"CS [%s] using sync_learned value 2 [%f]\", str(self.name), used2)\n else:\n logging.debug(\"CS [%s] using tracking value\", str(self.name))\n used = self.graph[u][v]['used'] + util\n\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def control_edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.control_edge_count_max or 0)","def node_count_max(self) -> int:\n return int(self.graph_tuple_stats.node_count_max or 0)","def max_flow(self, source, sink):\n\n path = self.valid_path(source, sink, [])\n\n while path:\n # get the maximum possible flow that can be taken from this path:\n max_flow = min([edge.capacity for edge in path])\n for edge in path:\n self.edges[edge] += max_flow\n path = self.valid_path(source, sink, [])\n\n # Compute all the flows from the neighbors of source:\n return sum([self.edges[edge] for edge in self.adjacents[source]])","def calc_strongest_bridge(comp_map: CompMap):\n @lru_cache(None)\n def _helper(cur_no_pins: int = 0, used_components: FrozenSet[Component] = frozenset()):\n available_connections = comp_map[cur_no_pins] - used_components\n\n if not available_connections:\n return sum(c.strength for c in used_components)\n\n res = []\n for c in available_connections:\n res.append(_helper(c.other(cur_no_pins), used_components | {c}))\n return max(res)\n res = _helper()\n print(_helper.cache_info())\n return res","def get_current_max_link(self):\n return self.current_max_link","def compute_path_metric(self, sw, path, util, time_now):\n pathmetric = 1\n linkmetrics = []\n links = zip(path[:-1], path[1:])\n # calculate available capacity for each link in path\n for link in links:\n u, v = link\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\n #only include extra-domain state when not stale (timestamp), 3) always exclude\n #extra-domain state when calculating the path metric? Here we do (1)\n used = self.graph[u][v]['used'] + util\n capacity = self.graph[u][v]['capacity']\n linkmetric = float(used) / capacity\n # If the controller estimates it would oversubscribe this link\n if linkmetric > 1:\n logging.info(\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\", str(time_now), linkmetric, str(sw))\n break\n else:\n linkmetrics.append(linkmetric)\n\n # We define pathmetric to be the worst link metric in path\n if len(linkmetrics) > 0:\n pathmetric = max(linkmetrics)\n\n funname = sys._getframe().f_code.co_name\n logging.debug(\"[%s] [%s] [%s] [%s]\", funname, str(time_now), str(self),\n str((path, linkmetrics)))\n return (pathmetric, len(links))","def strength_longest_bridge():\n # first again filter all the Nonetype out\n bridges = [ b for b in all_bridges if b != None ]\n\n # the find the strength of the longest bridge\n # in this case the first longest to be found is also the\n # the strongest out of all the longest\n\n return max(bridges, key=lambda b: len(b[1]))[0]","def get_highest_preference(self, routes):\n outroutes = []\n max_val = float('-inf')\n # find highest local pref first\n for r in routes:\n if r[MESG][LPRF] > max_val:\n max_val = r[MESG][LPRF]\n # find all routes with that val\n for r in routes:\n if r[MESG][LPRF] == max_val:\n outroutes.append(r)\n\n return outroutes","def countMaxDegree(self):\r\n max_degree = [0, 0] # le sommet, son nombre de connection \r\n for i_node, node_connections in enumerate(self.adjMatrix):\r\n connection = self.n - node_connections.count(0) # on compte le nombre de connections du sommet\r\n if connection > max_degree[1]:\r\n max_degree = max_degree[i_node, node_connections]\r\n return max_degree[0], max_degree[1] # C un tuple ! \r","def edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.edge_count_max or 0)","def call_edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.call_edge_count_max or 0)","def longest_flight(self):\r\n distance = 0\r\n for code, _list in self.edges.items():\r\n for edge in _list:\r\n if edge.distance > distance:\r\n distance = edge.distance\r\n start = edge.start\r\n destination = edge.destination\r\n return start, destination, distance","def find_maximal_path(graph):\n maximal_path_in_graph = [] # This is where the maximal path in the graph is stored (updates)\n checked_pairs = set() # In order not to check a pair twice, the set stores the already checked pairs (and the\n # reversed order of the tuple\n for node_start in graph.nodes.keys():\n for node_end in graph.nodes.keys():\n tup_of_nodes = (node_start, node_end) # This tuple is checked in checked_pairs\n # Need to make sure that the path is valid (!=Node) and that it is not checked yet\n if graph.find_longest_path(node_start,\n node_end) != None and tup_of_nodes not in checked_pairs:\n tup_of_nodes_reverse = (node_end, node_start) # This is a tuple with the opposite order\n checked_pairs.add(tup_of_nodes)\n checked_pairs.add(tup_of_nodes_reverse)\n maximal_path_for_pair = graph.find_longest_path(node_start, node_end)\n # Updates the maximal path per pair exceeds the current one\n if len(maximal_path_for_pair) > len(maximal_path_in_graph):\n maximal_path_in_graph = maximal_path_for_pair\n return \"Maximal path between nodes is: {}, and the length is {} nodes.\".format(maximal_path_in_graph, \\\n len(maximal_path_in_graph))","def max_flow(self, source, sink):\n\n max_flow = 0\n\n for i in range(self.V):\n for j in range(self.V):\n self.flow[i, j] = 0\n\n while self.bfs(source, sink):\n increment = maxint\n\n u = sink\n\n while self.pred[u] != -1:\n increment = min(\n increment, self.capacity[self.pred[u], u] - self.flow[self.pred[u], u])\n u = self.pred[u]\n\n u = sink\n\n while self.pred[u] != -1:\n self.flow[self.pred[u], u] += increment\n self.flow[u, self.pred[u]] -= increment\n u = self.pred[u]\n\n max_flow += increment\n\n return max_flow","def find_max(self):\n return max(self.nodes, key=int)","def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\n pass","def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\n if highway == 'motorway':\n result = -motorway_pref*0.5\n elif highway == 'primary':\n result = -highway_pref*0.5\n elif highway == 'residential' or highway == 'service':\n result = -residential_pref*0.5\n elif highway == 'cycleway':\n result = -bicycle_pref * 0.8\n else:\n result = 0\n return result","def search_for_maximum(self):\n return self.maximise_aquisition(self.expected_improvement)","def get_highest_preference(self, routes):\n # filter out any routes that don't have the highest localPref\n outroutes = routes.copy()\n outroutes.sort(reverse=True, key=lambda r: r[MESG][LPRF])\n highest = outroutes[0][MESG][LPRF]\n outroutes = list(filter(lambda r: r[MESG][LPRF] == highest, outroutes))\n return outroutes","def get_max_lb(self):\n max_lb = 0\n for arc in self.arc_info.keys():\n if self.arc_info[arc][\"lower_bound\"] > max_lb:\n max_lb = self.arc_info[arc][\"lower_bound\"]\n return max_lb","def get_highest_preference(self, routes):\n # start highest lpref route as the first route's path\n highest_lprf_route = [routes[0]]\n # start the highest lpref as that\n # of the first route's path\n highest_lprf = int(routes[0][LPRF])\n # iterate through all routes in given list and\n # find the one with the highest local pref\n for route in routes:\n r_lprf = int(route[LPRF])\n if r_lprf > highest_lprf:\n highest_lprf = r_lprf\n highest_lprf_route = [route]\n elif r_lprf == highest_lprf:\n highest_lprf_route.append(route)\n return highest_lprf_route","def calculate_best_way(self) -> int:\n node = self._find_lowest_cost_node()\n while node:\n cost = self.costs[node]\n neighbors = self.graph[node]\n for neighbor in neighbors.keys():\n node_cost = cost + neighbors[neighbor]\n if self.costs[neighbor] > node_cost:\n self.costs[neighbor] = node_cost\n self.parents[neighbor] = node\n self.closed_nodes.append(node)\n node = self._find_lowest_cost_node()\n\n return self.costs[\"fin\"]","def _get_maximum(self):\n return self._maximum","def calculate_ucb_max(self, node):\n pass","def Optimum_prun_based_routing(self, S, D, L):\n if self.has_path(S, D):\n \n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \n Opt_path = Shortest_path\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \n while len(Shortest_path) != 0:\n path_cost = self.additive_path_cost(Shortest_path, 'w') \n if path_cost <= L:\n \"\"\"go to concave cost\"\"\"\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \n self.G = self.rm_edge_constraint(PathConcave_cost) # remove all links where the concave link is greater than PathConcave_cost\n \n Opt_path = Shortest_path\n if self.has_path(S, D):\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\n else:\n Shortest_path = [] \n else:\n break \n else:\n self.logger.info('No path from %s to %s', S, D)\n PathConcave_cost = 0\n Opt_path = []\n return PathConcave_cost, Opt_path","def maxValue(gameState, depth, a, b):\n ultimateMove = None # The best move the agent can do\n if gameState.isWin() or gameState.isLose(): # if terminal node return gamescore\n return self.evaluationFunction(gameState)\n bestValue = -math.inf\n # for all of max agents moves\n for action in gameState.getLegalActions(0):\n value = minValue(gameState.generateSuccessor(\n 0, action), depth, 1, a, b) # save value from call to minimizing agent\n if value > bestValue: # if value has increased, update parametres\n bestValue = value\n ultimateMove = action\n a = max(a, bestValue) # updates a=alpha if bestvalue > alpha\n if bestValue > b: # if value is greater than connected branch, do prune\n return bestValue\n if depth == self.depth: # if top node, return the best move\n return ultimateMove\n else:\n # if not top node (and no pruning) return best value\n return bestValue","def degree_graph(g):\n return max(degree_node(g, node) for node in g)","def _maximum(self) -> float:\n if self._type == \"power\":\n return 5.0\n elif self._type == \"setpoint\":\n return self._product.get_data_config_json()[\"_value_setpoint_max\"]\n elif self._type == \"fan1\":\n fan = 1\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]\n elif self._type == \"fan2\":\n fan = 2\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]\n elif self._type == \"fan3\":\n fan = 3\n return self._product.get_data_config_json()[\"_value_fan_limits\"][\n (((fan - 1) * 2) + 1)\n ]","def getMaximumDistances(self):\n pass","def data_edge_count_max(self) -> int:\n return int(self.graph_tuple_stats.data_edge_count_max or 0)","def get_max_gains(self):\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x800c+i,100)/100 for i in range(4)])","def find_best_route(all_cost, all_routes):\n cost_best_route = np.inf\n for i in range(len(all_cost)):\n if all_cost[i] < cost_best_route:\n cost_best_route = all_cost[i]\n best_route = all_routes[i]\n return cost_best_route, best_route","def _calcTotalMax(self, item, masterIntf, slaveIntf):\n if self.classmax:\n total = int((self.params[masterIntf]['intf_max']*self.params[masterIntf][slaveIntf]))\n total = int(total/self.params[masterIntf]['total_allocated'])+item['reserved']\n totalAll = item['reqRate'] + item['reserved']\n return max(total, totalAll)\n return item['reqRate'] + item['reserved']","def pair_nodes_with_max_weight_in_shortest_path(graph):\n list_pairs_with_shortest_path = []\n # The following for loop takes each pair, and adds the weight of their shortest path to the list\n for frm_name in graph.nodes:\n for to_name in graph.nodes:\n if frm_name != to_name: # Irrelevant because the question asks \"pair of nodes\"\n shortest_path = graph.find_shortest_path(frm_name, to_name)\n if shortest_path != None: # We must ignore a pair with no path\n path_weight = graph.get_path_weight(shortest_path)\n if path_weight != None: # We must ignore path with None weight\n pair_weight_tup = ((frm_name, to_name), path_weight)\n list_pairs_with_shortest_path.append(pair_weight_tup)\n # print(list_pairs_with_shortest_path) # Was used to check the function\n sorted_list_pairs = sorted(list_pairs_with_shortest_path, key=lambda tup: tup[1], reverse=True)\n pair_with_max = sorted_list_pairs[0] # Pair with the highest weight\n return \"Pair whose shortest path with max weight: {} to {}\".format(pair_with_max[0][0], pair_with_max[0][1])","def get_highest_preference(self, routes):\n if len(routes) == 1: \n return routes\n if len(routes) == 0: \n return []\n prefList = []\n for val in routes: \n prefList.append(val[\"msg\"][\"localpref\"]) \n highestVal = max(prefList) \n outroutes = []\n for val in routes:\n if val[\"msg\"][\"localpref\"] == highestVal:\n outroutes.append(val)\n return outroutes","def largestResolution(resolutions):\n return resolutions[0]","def lovliest_path(G):\n m = 0\n ma = None\n mb = None\n for node in G.keys():\n for conn in G[node].keys():\n if G[node][conn] > m:\n m = G[node][conn]\n ma = node\n mb = conn\n print \"found lovliest_path of %s to %s with weight %s\" % (ma,mb,m)\n return (ma,mb)","def global_efficiency(graph):\n return nx.global_efficiency(graph.graph)","def greedy(self):\n # for each node, find the incoming link with the highest score.\n max_scores = {}\n max_sources = {}\n for source, target in self.iteredges():\n score = self.get_score(source, target)\n max_score = max_scores.get(target)\n if max_score is None or score > max_score:\n max_scores[target] = score\n max_sources[target] = source\n # then build a graph out of just these links.\n succs = dict((n, []) for n in self)\n for target, source in max_sources.items():\n succs[source].append(target)\n return Digraph(succs, self.get_score, self.get_label)","def max_cardinality():\r\n #create a list containing the number of each vertex involvement.\r\n array = []\r\n for i in adj:\r\n array += [i[0],i[1]]\r\n\r\n #compute the degree by counting the involment\r\n degree = Counter(array).most_common()\r\n\r\n #retrieve the degree only\r\n degree_ = [ i[1] for i in degree]\r\n\r\n degree_ = np.array(degree_)\r\n \r\n max_m = None\r\n \r\n #check if m is valid\r\n for i in range(degree[0][1]+2)[2:]:\r\n \r\n #valid if there are at least m vertex with degree equals to at least m-1 \r\n if i < len(np.where(degree_>=i-1)[0]):\r\n max_m = i\r\n else:\r\n break\r\n max_m += 1\r\n print(f'maximum possible clique cardinality :{max_m}')\r\n return max_m","def max_flow_min_cut(vertices, start, end):\n\n max_flow = 0 # There is no flow initially\n\n while True:\n bfs(vertices, start)\n\n if not end.bfs_visited:\n # There is no path between start and end\n break\n\n path = end.get_bfs_path()\n bottleneck = min([edge.weight for edge in path])\n\n # Update edges and residual edges values\n for edge in path:\n edge.weight -= bottleneck\n edge.inverse_edge.weight += bottleneck\n max_flow += bottleneck\n\n min_cut = calculate_min_cut(vertices, start)\n return max_flow, min_cut","def calc_demand(self, routing: np.ndarray, demand: float,\n commodity_idx: int) -> np.ndarray:\n commodity = self.commodities[commodity_idx]\n node_flow = np.zeros(self.num_nodes)\n node_flow[commodity[0]] = demand\n\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\n for edge_idx, edge in enumerate(self.edges):\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\n\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\n\n num_steps = 0\n while True:\n change = np.multiply(split_matrix, node_flow)\n edge_utilisation += change\n node_flow = np.matmul(split_matrix, node_flow)\n if np.any(np.isnan(change)):\n print(\"is_nan :'(\")\n comparison = np.less(np.nan_to_num(change), self.min_delta)\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\n break\n num_steps += 1\n # if we take more than |E| steps we have cycles which is not good.\n # Therefore: end here with really bad reward, scaled by number of\n # cycles\n if num_steps > routing.shape[1]:\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\n edge_utilisation += np.multiply(remaining_flow, np.full(\n (self.num_nodes, self.num_nodes), demand))\n break\n\n return edge_utilisation","def cost(route):\n cost = 0\n for li in route:\n if cost<li.get_cost():\n cost=li.get_cost()\n return cost","def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\n dtype=float)\n\n for commodity_idx in range(len(self.commodities)):\n utilisation = self.calc_demand(routing,\n demands[commodity_idx],\n commodity_idx)\n total_utilisation += utilisation\n\n return np.max(np.divide(total_utilisation, self.edge_capacities))","def handle_request(self, sw, util, duration, time_now):\n\n #logging.debug(str(self.graph.edges(data=True)))\n\n #1 Get available paths from servers to switch\n paths = self.get_srv_paths(sw, self.graph)\n\n #2 choose the path which mins the max link utilization for all links\n # along the path\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\n\n if len(bestpath) > 0:\n self.allocate_resources(bestpath, util, time_now, duration)\n else:\n logging.warn(\"[%s] No best path found at switch [%s]\", str(time_now), str(sw))\n\n return bestpath","def max_powerflow_rule(_m, l, y, s, t):\r\n\r\n return m.p_L[l, y, s, t] - m.POWERFLOW_MAX[l] <= 0","def get_max_addr(self):\n\n out = None\n for segment in self.segments:\n if out is None or segment.max_addr > out:\n out = segment.max_addr\n\n if out is None:\n for section in self.sections:\n if out is None or section.max_addr > out:\n out = section.max_addr\n\n if out is None:\n return self.rebase_addr\n else:\n return out + self.rebase_addr","def maxTargets(self):\n return self._getAttribute(Attribute.maxTargets)","def bgll(self, graph, node_count, min_mod, max_pass):\n\n #the belonging of the node\n bl = [i for i in range(node_count)]\n #the node's weight in community\n _in = [0.0] * node_count\n #the node's weight in graph\n _tot = []\n #total weight of a node, just a copy of _tot\n k = []\n #the total weight of the graph\n m = []\n\n #inital the in-param\n network = [[0.0] * node_count for n in range(node_count)]\n for node, tag, weight in graph:\n network[node][tag] = weight\n for node in network:\n k.append(sum(node))\n _tot = k[:]\n m = sum(k)\n #inital the in-param\n\n def modularity():\n \"\"\"\n This function mainly computes the modularity of the network\n Return:\n mod->the modularity value\n \"\"\"\n\n q = 0.0\n for idx in range(0, node_count):\n if _tot[idx] > 0.0:\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\n return q\n\n def modularity_gain(n, c, dnodecomm):\n \"\"\"\n This function mainly computes the modularity gain of a node moving\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n Return:\n gain->modularity gain\n \"\"\"\n\n totc = _tot[c]\n degc = k[n]\n return dnodecomm - (totc * degc) / m\n\n def neigh_comm(n):\n \"\"\"\n This function mainly computes the weight between the node and it's neighbour community\n Param:\n n->node id\n Return:\n nc->the map of the weight between the node and it's neighbour community\n nc=>{cid,weight}\n \"\"\"\n\n nc = {bl[n]: 0.0}\n for idx in range(0, node_count):\n neigh = idx\n ncomm = bl[neigh]\n nei_weight = network[n][idx]\n if (neigh != n) & (nei_weight > 0.0):\n if ncomm in nc:\n nc[ncomm] += nei_weight\n else:\n nc[ncomm] = nei_weight\n return nc\n\n def insert(n, c, dnodecomm):\n \"\"\"\n This function mainly get the effect of insert the node into community\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n \"\"\"\n\n _tot[c] += k[n]\n _in[c] += 2 * dnodecomm + network[n][n]\n bl[n] = c\n\n def remove(n, c, dnodecomm):\n \"\"\"\n This function mainly get the effect of remove the node off community\n Param:\n n->node id\n c->community id\n dnodecomm->the weight between the node and the community\n \"\"\"\n\n _tot[c] -= k[n]\n _in[c] -= 2 * dnodecomm + network[n][n]\n bl[n] = -1\n\n def detect():\n \"\"\"\n This function mainly detect the community of the graph.\n \"\"\"\n\n _pass_done = 0\n _improve = True\n new_mod = modularity()\n cur_mod = -999999999.0\n rl = random.sample(range(0, node_count), node_count)\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\n cur_mod = new_mod\n _improve = False\n _pass_done += 1\n for node_tmp in rl:\n n = node_tmp\n nc = bl[n]\n ncomm = neigh_comm(n)\n remove(n, nc, ncomm[nc])\n best_c = nc\n best_l = 0.0\n best_incre = 0.0\n for c in ncomm:\n incre = modularity_gain(n, c, ncomm[c])\n if incre > best_incre:\n best_incre = incre\n best_c = c\n best_l = ncomm[c]\n insert(n, best_c, best_l)\n if best_c != nc:\n _improve = True\n new_mod = modularity()\n print new_mod\n\n detect()\n return bl","def _maximum(self) -> float:\n return self._config[CONF_MAX]","def get_bprop_maximum(self):\n input_grad = G.MaximumGrad()\n\n def bprop(x, y, out, dout):\n dx, dy = input_grad(x, y, dout)\n return dx, dy\n return bprop","def probabilityTransitionRule(self, unvisitedHeuristics, totalUnvisited):\n argMaxProbValue = 0\n argMaxToken = None\n for unvisitedToken in unvisitedHeuristics:\n probValue = unvisitedHeuristics[unvisitedToken] / totalUnvisited\n\n # In case obtained value is higher than previous maximum, substitute\n if probValue > argMaxProbValue:\n argMaxProbValue = probValue\n argMaxToken = unvisitedToken\n\n return argMaxToken","def bern_max_metric(pipe_diameter, delta_p):\n\n rho = 1000 # density of water kg/m^3\n flow_rate_max = ((math.pi * (pipe_diameter**2)) / 4) * math.sqrt((2 * delta_p) / rho)\n\n return flow_rate_max","def optimal_max(board):\n # Board full?\n if terminal(board):\n return [None, utility(board)]\n\n available_actions = list(actions(board))\n\n # Naive baseline comparison is negative infinity\n global_optimum = [None, -math.inf]\n\n # For each move, what would opponent do next? Update best move.\n for action in available_actions:\n # Anticipates optimal adversarial moves\n local_optimum = optimal_min(result(board, action))\n\n # Compares local vs global optima\n if global_optimum[1] <= local_optimum[1]:\n global_optimum = [action, local_optimum[1]]\n\n return global_optimum","def find_max():\n bridges = all_bridges\n bridges = [ b for b in bridges if b != None ]\n return max(bridges)","def __find_max_distance(self):\n return utils.find_max_distance(self.__game)","def score_max_depths(graph, max_depths):\n ###TODO\n pass","def max_pool_backward_naive(dout, cache):\n dx = None\n #############################################################################\n # TODO: Implement the max pooling backward pass #\n #############################################################################\n pass\n #############################################################################\n # END OF YOUR CODE #\n #############################################################################\n return dx","def _get_max_estimated_bandit(self)->Bandit:\n # print(\"mus - \", self.mu)\n # print(\"actions - \", np.argmax(self.mu))\n unique, counts = np.unique(self.mu, return_counts=True)\n lens = counts[np.argmax(unique)] \n if lens>1: # if two actions have same argmax\n # then return arbitrarily from those max ones\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\n return np.random.choice(maxs)\n # otherwise return the max one\n return self.bandits[np.argmax(self.mu)]","def greedy_max_cut(graph):\n cut = Cut(set(), set())\n for vertex in graph.nodes:\n l_neighbors = sum((adj in cut.left) for adj in graph.neighbors(vertex))\n r_neighbors = sum((adj in cut.right) for adj in graph.neighbors(vertex))\n if l_neighbors < r_neighbors:\n cut.left.add(vertex)\n else:\n cut.right.add(vertex)\n return cut","def euclid_destination_for_passenger(state, problem):\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\n if unsatisfied:\n max_dist = sum([p.opt for p in unsatisfied])\n return max_dist\n return 0","def get_routing_solution(self):\n G = self.base_digraph\n s1 = self.sources[0]\n s2 = self.sources[1]\n t1 = self.destinations[0]\n t2 = self.destinations[1]\n\n try:\n m = Model('routing')\n m.setParam('OutputFlag', False)\n\n # variables,\n # We have one variable per edge per session\n # e is the dict of dict for the variables\n e = {}\n r = {}\n for i in [1,2]:\n e[i] = {}\n r[i] = m.addVar()\n for u,v in G.edges():\n e[i][u,v] = m.addVar(lb=0)\n\n m.update()\n\n obj = quicksum(r.values())\n m.setObjective(obj, GRB.MAXIMIZE)\n\n # constraints\n # 1. conservations of flow at all intermediate nodes\n # 2. capacity constraints for each edge\n\n for u,v in G.edges():\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\n\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\n\n for n in G.nodes():\n if n not in [s1, s2, t1, t2]:\n for i in [1, 2]:\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\n m.addConstr(inflow == outflow)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n for u, v in G.edges():\n G[u][v]['Routing'] = {}\n G[u][v]['Routing'][1] = e[1][u,v].x\n G[u][v]['Routing'][2] = e[2][u,v].x\n return (m.objVal, r[1].x, r[2].x)\n else:\n # something went wrong...err...\n print \"Something was wrong, no optimal solution obtained\"\n return None, None, None\n\n except GurobiError:\n Print ('Error Report from Gurobi')","def produce_max(self, meta, raven_vars, dispatch, t):\n request, meta = self.get_capacity(meta, raven_vars, dispatch, t)\n return request, meta","def max_weight(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def opt(self, demands: Demand) -> float:\n # Create the linear solver with the GLOP backend.\n solver = pywraplp.Solver('multicommodity_flow_lp',\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\n\n ## VARIABLES\n # Flow variables, the splitting ratios for each edge\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\n flow_variables = []\n for i in range(len(self.commodities)):\n flow_variable_edges = []\n for j in range(self.num_edges):\n flow_variable_edges.append(\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\n flow_variables.append(flow_variable_edges)\n\n ## CONSTRAINTS\n # Capacity constraint\n capacity_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint between 0 and edge capacity\n constraint_i = solver.Constraint(\n 0, self.graph.get_edge_data(*edge)['weight'],\n '(1,{},{})'.format(*edge))\n for j, commodity in enumerate(self.commodities):\n # Coefficient for jth flow over ith edge is scaled by flow width\n constraint_i.SetCoefficient(flow_variables[j][i],\n # cast because or-tools :'(\n float(demands[j]))\n capacity_constraints.append(constraint_i)\n\n # Conservation on transit nodes\n conservation_transit_constraints = []\n for i, commodity in enumerate(self.commodities):\n constraints_flow_i = []\n for j in range(self.num_nodes):\n if j != commodity[0] and j != commodity[1]:\n # Constraint must sum to zero\n constraint_j = solver.Constraint(0, 0,\n '(2,{},{})'.format(i, j))\n for k in list(sorted(self.graph.adj[j].keys())):\n # Ingress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\n # Egress edges\n constraint_j.SetCoefficient(\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\n constraints_flow_i.append(constraint_j)\n conservation_transit_constraints.append(constraints_flow_i)\n\n # Conservation of flow at source node\n conservation_source_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[0], edge_dest)]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[0])]],\n -1)\n conservation_source_constraints.append(constraint_i)\n\n # Conservation of flow at destination node\n conservation_dest_constraints = []\n for i, commodity in enumerate(self.commodities):\n # Constraint must sum to one (assuming all the demand can be met)\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(edge_dest, commodity[1])]],\n 1)\n constraint_i.SetCoefficient(\n flow_variables[i][\n self.edge_index_dict[(commodity[1], edge_dest)]],\n -1)\n conservation_dest_constraints.append(constraint_i)\n\n ## OBJECTIVES\n # Implementation of the load-balancing example from Wikipedia\n # First we add more constraints so that we are minimising the maximum\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\n 'max_link_utilisation')\n min_of_max_constraints = []\n for i, edge in enumerate(self.edges):\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\n # i.e 'f_0 + f_1 + ... < max'\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\n '(5,{})'.format(i))\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\n for j, flow_variable in enumerate(flow_variables):\n constraint_i.SetCoefficient(flow_variable[i],\n demands[j] /\n self.graph.get_edge_data(*edge)[\n 'weight'])\n min_of_max_constraints.append(constraint_i)\n\n # Objective now is to minimise the maximum link utilisation\n objective = solver.Objective()\n objective.SetCoefficient(max_utilisation_variable, 1)\n objective.SetMinimization()\n solver.Solve()\n\n return objective.Value()","def find_max_depth(start_url):\n print \"****** sequence of links that must be followed to reach the page *****\"\n S, Q = set(), deque()\n Q.append(start_url)\n while Q:\n u = Q.popleft()\n if u in S: continue\n b = u\n S.add(u)\n Q.extend(getLinks(u))\n find_shortest_path(start_url,b)\n print \"****** URL that is the greatest distance from start_url *****\"\n print b","def __dijkstra_max_prob_tree(unit_rules_graph, source_var):\n variables = unit_rules_graph.vertices\n dist = {var: -1.0 for var in variables}\n dist[source_var] = 1.0\n tree_nodes = {var: ParseTreeNode(var) for var in variables}\n pending_vars = set(variables)\n while pending_vars:\n max_dist, max_dist_var = max((d, v) for v, d in dist.items() if v in pending_vars)\n pending_vars.remove(max_dist_var)\n for neighbor, prob in unit_rules_graph.neighbors[max_dist_var]:\n if neighbor not in pending_vars:\n continue\n alt_dist = dist[max_dist_var] * prob\n if dist[neighbor] is None or alt_dist > dist[neighbor]:\n dist[neighbor] = alt_dist\n tree_nodes[max_dist_var].children.append(tree_nodes[neighbor])\n return ParseTree(tree_nodes[source_var])","def maxWeightMatching(edges, maxcardinality=False):\r\n\r\n #\r\n # Vertices are numbered 0 .. (nvertex-1).\r\n # Non-trivial blossoms are numbered nvertex .. (2*nvertex-1)\r\n #\r\n # Edges are numbered 0 .. (nedge-1).\r\n # Edge endpoints are numbered 0 .. (2*nedge-1), such that endpoints\r\n # (2*k) and (2*k+1) both belong to edge k.\r\n #\r\n # Many terms used in the comments (sub-blossom, T-vertex) come from\r\n # the paper by Galil; read the paper before reading this code.\r\n #\r\n\r\n # Python 2/3 compatibility.\r\n from sys import version as sys_version\r\n if sys_version < '3':\r\n integer_types = (int, long)\r\n else:\r\n integer_types = (int,)\r\n\r\n # Deal swiftly with empty graphs.\r\n if not edges:\r\n return [ ]\r\n\r\n # Count vertices.\r\n nedge = len(edges)\r\n nvertex = 0\r\n for (i, j, w) in edges:\r\n assert i >= 0 and j >= 0 #and i != j\r\n if i >= nvertex:\r\n nvertex = i + 1\r\n if j >= nvertex:\r\n nvertex = j + 1\r\n\r\n # Find the maximum edge weight.\r\n maxweight = max(0, max([ wt for (i, j, wt) in edges ]))\r\n\r\n # If p is an edge endpoint,\r\n # endpoint[p] is the vertex to which endpoint p is attached.\r\n # Not modified by the algorithm.\r\n endpoint = [ edges[p//2][p%2] for p in range(2*nedge) ]\r\n\r\n # If v is a vertex,\r\n # neighbend[v] is the list of remote endpoints of the edges attached to v.\r\n # Not modified by the algorithm.\r\n neighbend = [ [ ] for i in range(nvertex) ]\r\n for k in range(len(edges)):\r\n (i, j, w) = edges[k]\r\n neighbend[i].append(2*k+1)\r\n neighbend[j].append(2*k)\r\n\r\n # If v is a vertex,\r\n # mate[v] is the remote endpoint of its matched edge, or -1 if it is single\r\n # (i.e. endpoint[mate[v]] is v's partner vertex).\r\n # Initially all vertices are single; updated during augmentation.\r\n mate = nvertex * [ -1 ]\r\n\r\n # If b is a top-level blossom,\r\n # label[b] is 0 if b is unlabeled (free);\r\n # 1 if b is an S-vertex/blossom;\r\n # 2 if b is a T-vertex/blossom.\r\n # The label of a vertex is found by looking at the label of its\r\n # top-level containing blossom.\r\n # If v is a vertex inside a T-blossom,\r\n # label[v] is 2 iff v is reachable from an S-vertex outside the blossom.\r\n # Labels are assigned during a stage and reset after each augmentation.\r\n label = (2 * nvertex) * [ 0 ]\r\n\r\n # If b is a labeled top-level blossom,\r\n # labelend[b] is the remote endpoint of the edge through which b obtained\r\n # its label, or -1 if b's base vertex is single.\r\n # If v is a vertex inside a T-blossom and label[v] == 2,\r\n # labelend[v] is the remote endpoint of the edge through which v is\r\n # reachable from outside the blossom.\r\n labelend = (2 * nvertex) * [ -1 ]\r\n\r\n # If v is a vertex,\r\n # inblossom[v] is the top-level blossom to which v belongs.\r\n # If v is a top-level vertex, v is itself a blossom (a trivial blossom)\r\n # and inblossom[v] == v.\r\n # Initially all vertices are top-level trivial blossoms.\r\n inblossom = list(range(nvertex))\r\n\r\n # If b is a sub-blossom,\r\n # blossomparent[b] is its immediate parent (sub-)blossom.\r\n # If b is a top-level blossom, blossomparent[b] is -1.\r\n blossomparent = (2 * nvertex) * [ -1 ]\r\n\r\n # If b is a non-trivial (sub-)blossom,\r\n # blossomchilds[b] is an ordered list of its sub-blossoms, starting with\r\n # the base and going round the blossom.\r\n blossomchilds = (2 * nvertex) * [ None ]\r\n\r\n # If b is a (sub-)blossom,\r\n # blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).\r\n blossombase = list(range(nvertex)) + nvertex * [ -1 ]\r\n\r\n # If b is a non-trivial (sub-)blossom,\r\n # blossomendps[b] is a list of endpoints on its connecting edges,\r\n # such that blossomendps[b][i] is the local endpoint of blossomchilds[b][i]\r\n # on the edge that connects it to blossomchilds[b][wrap(i+1)].\r\n blossomendps = (2 * nvertex) * [ None ]\r\n\r\n # If v is a free vertex (or an unreached vertex inside a T-blossom),\r\n # bestedge[v] is the edge to an S-vertex with least slack,\r\n # or -1 if there is no such edge.\r\n # If b is a (possibly trivial) top-level S-blossom,\r\n # bestedge[b] is the least-slack edge to a different S-blossom,\r\n # or -1 if there is no such edge.\r\n # This is used for efficient computation of delta2 and delta3.\r\n bestedge = (2 * nvertex) * [ -1 ]\r\n\r\n # If b is a non-trivial top-level S-blossom,\r\n # blossombestedges[b] is a list of least-slack edges to neighbouring\r\n # S-blossoms, or None if no such list has been computed yet.\r\n # This is used for efficient computation of delta3.\r\n blossombestedges = (2 * nvertex) * [ None ]\r\n\r\n # List of currently unused blossom numbers.\r\n unusedblossoms = list(range(nvertex, 2*nvertex))\r\n\r\n # If v is a vertex,\r\n # dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual\r\n # optimization problem (multiplication by two ensures integer values\r\n # throughout the algorithm if all edge weights are integers).\r\n # If b is a non-trivial blossom,\r\n # dualvar[b] = z(b) where z(b) is b's variable in the dual optimization\r\n # problem.\r\n dualvar = nvertex * [ maxweight ] + nvertex * [ 0 ]\r\n\r\n # If allowedge[k] is true, edge k has zero slack in the optimization\r\n # problem; if allowedge[k] is false, the edge's slack may or may not\r\n # be zero.\r\n allowedge = nedge * [ False ]\r\n\r\n # Queue of newly discovered S-vertices.\r\n queue = [ ]\r\n\r\n # Return 2 * slack of edge k (does not work inside blossoms).\r\n def slack(k):\r\n (i, j, wt) = edges[k]\r\n return dualvar[i] + dualvar[j] - 2 * wt\r\n\r\n # Generate the leaf vertices of a blossom.\r\n def blossomLeaves(b):\r\n if b < nvertex:\r\n yield b\r\n else:\r\n for t in blossomchilds[b]:\r\n if t < nvertex:\r\n yield t\r\n else:\r\n for v in blossomLeaves(t):\r\n yield v\r\n\r\n # Assign label t to the top-level blossom containing vertex w\r\n # and record the fact that w was reached through the edge with\r\n # remote endpoint p.\r\n def assignLabel(w, t, p):\r\n if DEBUG: DEBUG('assignLabel(%d,%d,%d)' % (w, t, p))\r\n b = inblossom[w]\r\n assert label[w] == 0 and label[b] == 0\r\n label[w] = label[b] = t\r\n labelend[w] = labelend[b] = p\r\n bestedge[w] = bestedge[b] = -1\r\n if t == 1:\r\n # b became an S-vertex/blossom; add it(s vertices) to the queue.\r\n queue.extend(blossomLeaves(b))\r\n if DEBUG: DEBUG('PUSH ' + str(list(blossomLeaves(b))))\r\n elif t == 2:\r\n # b became a T-vertex/blossom; assign label S to its mate.\r\n # (If b is a non-trivial blossom, its base is the only vertex\r\n # with an external mate.)\r\n base = blossombase[b]\r\n assert mate[base] >= 0\r\n assignLabel(endpoint[mate[base]], 1, mate[base] ^ 1)\r\n\r\n # Trace back from vertices v and w to discover either a new blossom\r\n # or an augmenting path. Return the base vertex of the new blossom or -1.\r\n def scanBlossom(v, w):\r\n if DEBUG: DEBUG('scanBlossom(%d,%d)' % (v, w))\r\n # Trace back from v and w, placing breadcrumbs as we go.\r\n path = [ ]\r\n base = -1\r\n while v != -1 or w != -1:\r\n # Look for a breadcrumb in v's blossom or put a new breadcrumb.\r\n b = inblossom[v]\r\n if label[b] & 4:\r\n base = blossombase[b]\r\n break\r\n assert label[b] == 1\r\n path.append(b)\r\n label[b] = 5\r\n # Trace one step back.\r\n assert labelend[b] == mate[blossombase[b]]\r\n if labelend[b] == -1:\r\n # The base of blossom b is single; stop tracing this path.\r\n v = -1\r\n else:\r\n v = endpoint[labelend[b]]\r\n b = inblossom[v]\r\n assert label[b] == 2\r\n # b is a T-blossom; trace one more step back.\r\n assert labelend[b] >= 0\r\n v = endpoint[labelend[b]]\r\n # Swap v and w so that we alternate between both paths.\r\n if w != -1:\r\n v, w = w, v\r\n # Remove breadcrumbs.\r\n for b in path:\r\n label[b] = 1\r\n # Return base vertex, if we found one.\r\n return base\r\n\r\n # Construct a new blossom with given base, containing edge k which\r\n # connects a pair of S vertices. Label the new blossom as S; set its dual\r\n # variable to zero; relabel its T-vertices to S and add them to the queue.\r\n def addBlossom(base, k):\r\n (v, w, wt) = edges[k]\r\n bb = inblossom[base]\r\n bv = inblossom[v]\r\n bw = inblossom[w]\r\n # Create blossom.\r\n b = unusedblossoms.pop()\r\n if DEBUG: DEBUG('addBlossom(%d,%d) (v=%d w=%d) -> %d' % (base, k, v, w, b))\r\n blossombase[b] = base\r\n blossomparent[b] = -1\r\n blossomparent[bb] = b\r\n # Make list of sub-blossoms and their interconnecting edge endpoints.\r\n blossomchilds[b] = path = [ ]\r\n blossomendps[b] = endps = [ ]\r\n # Trace back from v to base.\r\n while bv != bb:\r\n # Add bv to the new blossom.\r\n blossomparent[bv] = b\r\n path.append(bv)\r\n endps.append(labelend[bv])\r\n assert (label[bv] == 2 or\r\n (label[bv] == 1 and labelend[bv] == mate[blossombase[bv]]))\r\n # Trace one step back.\r\n assert labelend[bv] >= 0\r\n v = endpoint[labelend[bv]]\r\n bv = inblossom[v]\r\n # Reverse lists, add endpoint that connects the pair of S vertices.\r\n path.append(bb)\r\n path.reverse()\r\n endps.reverse()\r\n endps.append(2*k)\r\n # Trace back from w to base.\r\n while bw != bb:\r\n # Add bw to the new blossom.\r\n blossomparent[bw] = b\r\n path.append(bw)\r\n endps.append(labelend[bw] ^ 1)\r\n assert (label[bw] == 2 or\r\n (label[bw] == 1 and labelend[bw] == mate[blossombase[bw]]))\r\n # Trace one step back.\r\n assert labelend[bw] >= 0\r\n w = endpoint[labelend[bw]]\r\n bw = inblossom[w]\r\n # Set label to S.\r\n assert label[bb] == 1\r\n label[b] = 1\r\n labelend[b] = labelend[bb]\r\n # Set dual variable to zero.\r\n dualvar[b] = 0\r\n # Relabel vertices.\r\n for v in blossomLeaves(b):\r\n if label[inblossom[v]] == 2:\r\n # This T-vertex now turns into an S-vertex because it becomes\r\n # part of an S-blossom; add it to the queue.\r\n queue.append(v)\r\n inblossom[v] = b\r\n # Compute blossombestedges[b].\r\n bestedgeto = (2 * nvertex) * [ -1 ]\r\n for bv in path:\r\n if blossombestedges[bv] is None:\r\n # This subblossom does not have a list of least-slack edges;\r\n # get the information from the vertices.\r\n nblists = [ [ p // 2 for p in neighbend[v] ]\r\n for v in blossomLeaves(bv) ]\r\n else:\r\n # Walk this subblossom's least-slack edges.\r\n nblists = [ blossombestedges[bv] ]\r\n for nblist in nblists:\r\n for k in nblist:\r\n (i, j, wt) = edges[k]\r\n if inblossom[j] == b:\r\n i, j = j, i\r\n bj = inblossom[j]\r\n if (bj != b and label[bj] == 1 and\r\n (bestedgeto[bj] == -1 or\r\n slack(k) < slack(bestedgeto[bj]))):\r\n bestedgeto[bj] = k\r\n # Forget about least-slack edges of the subblossom.\r\n blossombestedges[bv] = None\r\n bestedge[bv] = -1\r\n blossombestedges[b] = [ k for k in bestedgeto if k != -1 ]\r\n # Select bestedge[b].\r\n bestedge[b] = -1\r\n for k in blossombestedges[b]:\r\n if bestedge[b] == -1 or slack(k) < slack(bestedge[b]):\r\n bestedge[b] = k\r\n if DEBUG: DEBUG('blossomchilds[%d]=' % b + repr(blossomchilds[b]))\r\n\r\n # Expand the given top-level blossom.\r\n def expandBlossom(b, endstage):\r\n if DEBUG: DEBUG('expandBlossom(%d,%d) %s' % (b, endstage, repr(blossomchilds[b])))\r\n # Convert sub-blossoms into top-level blossoms.\r\n for s in blossomchilds[b]:\r\n blossomparent[s] = -1\r\n if s < nvertex:\r\n inblossom[s] = s\r\n elif endstage and dualvar[s] == 0:\r\n # Recursively expand this sub-blossom.\r\n expandBlossom(s, endstage)\r\n else:\r\n for v in blossomLeaves(s):\r\n inblossom[v] = s\r\n # If we expand a T-blossom during a stage, its sub-blossoms must be\r\n # relabeled.\r\n if (not endstage) and label[b] == 2:\r\n # Start at the sub-blossom through which the expanding\r\n # blossom obtained its label, and relabel sub-blossoms untili\r\n # we reach the base.\r\n # Figure out through which sub-blossom the expanding blossom\r\n # obtained its label initially.\r\n assert labelend[b] >= 0\r\n entrychild = inblossom[endpoint[labelend[b] ^ 1]]\r\n # Decide in which direction we will go round the blossom.\r\n j = blossomchilds[b].index(entrychild)\r\n if j & 1:\r\n # Start index is odd; go forward and wrap.\r\n j -= len(blossomchilds[b])\r\n jstep = 1\r\n endptrick = 0\r\n else:\r\n # Start index is even; go backward.\r\n jstep = -1\r\n endptrick = 1\r\n # Move along the blossom until we get to the base.\r\n p = labelend[b]\r\n while j != 0:\r\n # Relabel the T-sub-blossom.\r\n label[endpoint[p ^ 1]] = 0\r\n label[endpoint[blossomendps[b][j-endptrick]^endptrick^1]] = 0\r\n assignLabel(endpoint[p ^ 1], 2, p)\r\n # Step to the next S-sub-blossom and note its forward endpoint.\r\n allowedge[blossomendps[b][j-endptrick]//2] = True\r\n j += jstep\r\n p = blossomendps[b][j-endptrick] ^ endptrick\r\n # Step to the next T-sub-blossom.\r\n allowedge[p//2] = True\r\n j += jstep\r\n # Relabel the base T-sub-blossom WITHOUT stepping through to\r\n # its mate (so don't call assignLabel).\r\n bv = blossomchilds[b][j]\r\n label[endpoint[p ^ 1]] = label[bv] = 2\r\n labelend[endpoint[p ^ 1]] = labelend[bv] = p\r\n bestedge[bv] = -1\r\n # Continue along the blossom until we get back to entrychild.\r\n j += jstep\r\n while blossomchilds[b][j] != entrychild:\r\n # Examine the vertices of the sub-blossom to see whether\r\n # it is reachable from a neighbouring S-vertex outside the\r\n # expanding blossom.\r\n bv = blossomchilds[b][j]\r\n if label[bv] == 1:\r\n # This sub-blossom just got label S through one of its\r\n # neighbours; leave it.\r\n j += jstep\r\n continue\r\n for v in blossomLeaves(bv):\r\n if label[v] != 0:\r\n break\r\n # If the sub-blossom contains a reachable vertex, assign\r\n # label T to the sub-blossom.\r\n if label[v] != 0:\r\n assert label[v] == 2\r\n assert inblossom[v] == bv\r\n label[v] = 0\r\n label[endpoint[mate[blossombase[bv]]]] = 0\r\n assignLabel(v, 2, labelend[v])\r\n j += jstep\r\n # Recycle the blossom number.\r\n label[b] = labelend[b] = -1\r\n blossomchilds[b] = blossomendps[b] = None\r\n blossombase[b] = -1\r\n blossombestedges[b] = None\r\n bestedge[b] = -1\r\n unusedblossoms.append(b)\r\n\r\n # Swap matched/unmatched edges over an alternating path through blossom b\r\n # between vertex v and the base vertex. Keep blossom bookkeeping consistent.\r\n def augmentBlossom(b, v):\r\n if DEBUG: DEBUG('augmentBlossom(%d,%d)' % (b, v))\r\n # Bubble up through the blossom tree from vertex v to an immediate\r\n # sub-blossom of b.\r\n t = v\r\n while blossomparent[t] != b:\r\n t = blossomparent[t]\r\n # Recursively deal with the first sub-blossom.\r\n if t >= nvertex:\r\n augmentBlossom(t, v)\r\n # Decide in which direction we will go round the blossom.\r\n i = j = blossomchilds[b].index(t)\r\n if i & 1:\r\n # Start index is odd; go forward and wrap.\r\n j -= len(blossomchilds[b])\r\n jstep = 1\r\n endptrick = 0\r\n else:\r\n # Start index is even; go backward.\r\n jstep = -1\r\n endptrick = 1\r\n # Move along the blossom until we get to the base.\r\n while j != 0:\r\n # Step to the next sub-blossom and augment it recursively.\r\n j += jstep\r\n t = blossomchilds[b][j]\r\n p = blossomendps[b][j-endptrick] ^ endptrick\r\n if t >= nvertex:\r\n augmentBlossom(t, endpoint[p])\r\n # Step to the next sub-blossom and augment it recursively.\r\n j += jstep\r\n t = blossomchilds[b][j]\r\n if t >= nvertex:\r\n augmentBlossom(t, endpoint[p ^ 1])\r\n # Match the edge connecting those sub-blossoms.\r\n mate[endpoint[p]] = p ^ 1\r\n mate[endpoint[p ^ 1]] = p\r\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (endpoint[p], endpoint[p^1], p//2))\r\n # Rotate the list of sub-blossoms to put the new base at the front.\r\n blossomchilds[b] = blossomchilds[b][i:] + blossomchilds[b][:i]\r\n blossomendps[b] = blossomendps[b][i:] + blossomendps[b][:i]\r\n blossombase[b] = blossombase[blossomchilds[b][0]]\r\n assert blossombase[b] == v\r\n\r\n # Swap matched/unmatched edges over an alternating path between two\r\n # single vertices. The augmenting path runs through edge k, which\r\n # connects a pair of S vertices.\r\n def augmentMatching(k):\r\n (v, w, wt) = edges[k]\r\n if DEBUG: DEBUG('augmentMatching(%d) (v=%d w=%d)' % (k, v, w))\r\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (v, w, k))\r\n for (s, p) in ((v, 2*k+1), (w, 2*k)):\r\n # Match vertex s to remote endpoint p. Then trace back from s\r\n # until we find a single vertex, swapping matched and unmatched\r\n # edges as we go.\r\n while 1:\r\n bs = inblossom[s]\r\n assert label[bs] == 1\r\n assert labelend[bs] == mate[blossombase[bs]]\r\n # Augment through the S-blossom from s to base.\r\n if bs >= nvertex:\r\n augmentBlossom(bs, s)\r\n # Update mate[s]\r\n mate[s] = p\r\n # Trace one step back.\r\n if labelend[bs] == -1:\r\n # Reached single vertex; stop.\r\n break\r\n t = endpoint[labelend[bs]]\r\n bt = inblossom[t]\r\n assert label[bt] == 2\r\n # Trace one step back.\r\n assert labelend[bt] >= 0\r\n s = endpoint[labelend[bt]]\r\n j = endpoint[labelend[bt] ^ 1]\r\n # Augment through the T-blossom from j to base.\r\n assert blossombase[bt] == t\r\n if bt >= nvertex:\r\n augmentBlossom(bt, j)\r\n # Update mate[j]\r\n mate[j] = labelend[bt]\r\n # Keep the opposite endpoint;\r\n # it will be assigned to mate[s] in the next step.\r\n p = labelend[bt] ^ 1\r\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (s, t, p//2))\r\n\r\n # Verify that the optimum solution has been reached.\r\n def verifyOptimum():\r\n if maxcardinality:\r\n # Vertices may have negative dual;\r\n # find a constant non-negative number to add to all vertex duals.\r\n vdualoffset = max(0, -min(dualvar[:nvertex]))\r\n else:\r\n vdualoffset = 0\r\n # 0. all dual variables are non-negative\r\n assert min(dualvar[:nvertex]) + vdualoffset >= 0\r\n assert min(dualvar[nvertex:]) >= 0\r\n # 0. all edges have non-negative slack and\r\n # 1. all matched edges have zero slack;\r\n for k in range(nedge):\r\n (i, j, wt) = edges[k]\r\n s = dualvar[i] + dualvar[j] - 2 * wt\r\n iblossoms = [ i ]\r\n jblossoms = [ j ]\r\n while blossomparent[iblossoms[-1]] != -1:\r\n iblossoms.append(blossomparent[iblossoms[-1]])\r\n while blossomparent[jblossoms[-1]] != -1:\r\n jblossoms.append(blossomparent[jblossoms[-1]])\r\n iblossoms.reverse()\r\n jblossoms.reverse()\r\n for (bi, bj) in zip(iblossoms, jblossoms):\r\n if bi != bj:\r\n break\r\n s += 2 * dualvar[bi]\r\n #assert s >= 0\r\n if mate[i] // 2 == k or mate[j] // 2 == k:\r\n assert mate[i] // 2 == k and mate[j] // 2 == k\r\n assert s == 0\r\n # 2. all single vertices have zero dual value;\r\n for v in range(nvertex):\r\n assert mate[v] >= 0 or dualvar[v] + vdualoffset == 0\r\n # 3. all blossoms with positive dual value are full.\r\n for b in range(nvertex, 2*nvertex):\r\n if blossombase[b] >= 0 and dualvar[b] > 0:\r\n assert len(blossomendps[b]) % 2 == 1\r\n for p in blossomendps[b][1::2]:\r\n assert mate[endpoint[p]] == p ^ 1\r\n assert mate[endpoint[p ^ 1]] == p\r\n # Ok.\r\n\r\n # Check optimized delta2 against a trivial computation.\r\n def checkDelta2():\r\n for v in range(nvertex):\r\n if label[inblossom[v]] == 0:\r\n bd = None\r\n bk = -1\r\n for p in neighbend[v]:\r\n k = p // 2\r\n w = endpoint[p]\r\n if label[inblossom[w]] == 1:\r\n d = slack(k)\r\n if bk == -1 or d < bd:\r\n bk = k\r\n bd = d\r\n if DEBUG and (bestedge[v] != -1 or bk != -1) and (bestedge[v] == -1 or bd != slack(bestedge[v])):\r\n DEBUG('v=' + str(v) + ' bk=' + str(bk) + ' bd=' + str(bd) + ' bestedge=' + str(bestedge[v]) + ' slack=' + str(slack(bestedge[v])))\r\n assert (bk == -1 and bestedge[v] == -1) or (bestedge[v] != -1 and bd == slack(bestedge[v]))\r\n\r\n # Check optimized delta3 against a trivial computation.\r\n def checkDelta3():\r\n bk = -1\r\n bd = None\r\n tbk = -1\r\n tbd = None\r\n for b in range(2 * nvertex):\r\n if blossomparent[b] == -1 and label[b] == 1:\r\n for v in blossomLeaves(b):\r\n for p in neighbend[v]:\r\n k = p // 2\r\n w = endpoint[p]\r\n if inblossom[w] != b and label[inblossom[w]] == 1:\r\n d = slack(k)\r\n if bk == -1 or d < bd:\r\n bk = k\r\n bd = d\r\n if bestedge[b] != -1:\r\n (i, j, wt) = edges[bestedge[b]]\r\n assert inblossom[i] == b or inblossom[j] == b\r\n assert inblossom[i] != b or inblossom[j] != b\r\n assert label[inblossom[i]] == 1 and label[inblossom[j]] == 1\r\n if tbk == -1 or slack(bestedge[b]) < tbd:\r\n tbk = bestedge[b]\r\n tbd = slack(bestedge[b])\r\n if DEBUG and bd != tbd:\r\n DEBUG('bk=%d tbk=%d bd=%s tbd=%s' % (bk, tbk, repr(bd), repr(tbd)))\r\n assert bd == tbd\r\n\r\n # Main loop: continue until no further improvement is possible.\r\n for t in range(nvertex):\r\n\r\n # Each iteration of this loop is a \"stage\".\r\n # A stage finds an augmenting path and uses that to improve\r\n # the matching.\r\n if DEBUG: DEBUG('STAGE %d' % t)\r\n\r\n # Remove labels from top-level blossoms/vertices.\r\n label[:] = (2 * nvertex) * [ 0 ]\r\n\r\n # Forget all about least-slack edges.\r\n bestedge[:] = (2 * nvertex) * [ -1 ]\r\n blossombestedges[nvertex:] = nvertex * [ None ]\r\n\r\n # Loss of labeling means that we can not be sure that currently\r\n # allowable edges remain allowable througout this stage.\r\n allowedge[:] = nedge * [ False ]\r\n\r\n # Make queue empty.\r\n queue[:] = [ ]\r\n \r\n # Label single blossoms/vertices with S and put them in the queue.\r\n for v in range(nvertex):\r\n if mate[v] == -1 and label[inblossom[v]] == 0:\r\n assignLabel(v, 1, -1)\r\n\r\n # Loop until we succeed in augmenting the matching.\r\n augmented = 0\r\n while 1:\r\n\r\n # Each iteration of this loop is a \"substage\".\r\n # A substage tries to find an augmenting path;\r\n # if found, the path is used to improve the matching and\r\n # the stage ends. If there is no augmenting path, the\r\n # primal-dual method is used to pump some slack out of\r\n # the dual variables.\r\n if DEBUG: DEBUG('SUBSTAGE')\r\n\r\n # Continue labeling until all vertices which are reachable\r\n # through an alternating path have got a label.\r\n while queue and not augmented:\r\n\r\n # Take an S vertex from the queue.\r\n v = queue.pop()\r\n if DEBUG: DEBUG('POP v=%d' % v)\r\n assert label[inblossom[v]] == 1\r\n\r\n # Scan its neighbours:\r\n for p in neighbend[v]:\r\n k = p // 2\r\n w = endpoint[p]\r\n # w is a neighbour to v\r\n if inblossom[v] == inblossom[w]:\r\n # this edge is internal to a blossom; ignore it\r\n continue\r\n if not allowedge[k]:\r\n kslack = slack(k)\r\n if kslack <= 0:\r\n # edge k has zero slack => it is allowable\r\n allowedge[k] = True\r\n if allowedge[k]:\r\n if label[inblossom[w]] == 0:\r\n # (C1) w is a free vertex;\r\n # label w with T and label its mate with S (R12).\r\n assignLabel(w, 2, p ^ 1)\r\n elif label[inblossom[w]] == 1:\r\n # (C2) w is an S-vertex (not in the same blossom);\r\n # follow back-links to discover either an\r\n # augmenting path or a new blossom.\r\n base = scanBlossom(v, w)\r\n if base >= 0:\r\n # Found a new blossom; add it to the blossom\r\n # bookkeeping and turn it into an S-blossom.\r\n addBlossom(base, k)\r\n else:\r\n # Found an augmenting path; augment the\r\n # matching and end this stage.\r\n augmentMatching(k)\r\n augmented = 1\r\n break\r\n elif label[w] == 0:\r\n # w is inside a T-blossom, but w itself has not\r\n # yet been reached from outside the blossom;\r\n # mark it as reached (we need this to relabel\r\n # during T-blossom expansion).\r\n assert label[inblossom[w]] == 2\r\n label[w] = 2\r\n labelend[w] = p ^ 1\r\n elif label[inblossom[w]] == 1:\r\n # keep track of the least-slack non-allowable edge to\r\n # a different S-blossom.\r\n b = inblossom[v]\r\n if bestedge[b] == -1 or kslack < slack(bestedge[b]):\r\n bestedge[b] = k\r\n elif label[w] == 0:\r\n # w is a free vertex (or an unreached vertex inside\r\n # a T-blossom) but we can not reach it yet;\r\n # keep track of the least-slack edge that reaches w.\r\n if bestedge[w] == -1 or kslack < slack(bestedge[w]):\r\n bestedge[w] = k\r\n\r\n if augmented:\r\n break\r\n\r\n # There is no augmenting path under these constraints;\r\n # compute delta and reduce slack in the optimization problem.\r\n # (Note that our vertex dual variables, edge slacks and delta's\r\n # are pre-multiplied by two.)\r\n deltatype = -1\r\n delta = deltaedge = deltablossom = None\r\n\r\n # Verify data structures for delta2/delta3 computation.\r\n if CHECK_DELTA:\r\n checkDelta2()\r\n checkDelta3()\r\n\r\n # Compute delta1: the minumum value of any vertex dual.\r\n if not maxcardinality:\r\n deltatype = 1\r\n delta = min(dualvar[:nvertex])\r\n\r\n # Compute delta2: the minimum slack on any edge between\r\n # an S-vertex and a free vertex.\r\n for v in range(nvertex):\r\n if label[inblossom[v]] == 0 and bestedge[v] != -1:\r\n d = slack(bestedge[v])\r\n if deltatype == -1 or d < delta:\r\n delta = d\r\n deltatype = 2\r\n deltaedge = bestedge[v]\r\n\r\n # Compute delta3: half the minimum slack on any edge between\r\n # a pair of S-blossoms.\r\n for b in range(2 * nvertex):\r\n if ( blossomparent[b] == -1 and label[b] == 1 and\r\n bestedge[b] != -1 ):\r\n kslack = slack(bestedge[b])\r\n if isinstance(kslack, integer_types):\r\n assert (kslack % 2) == 0\r\n d = kslack // 2\r\n else:\r\n d = kslack / 2\r\n if deltatype == -1 or d < delta:\r\n delta = d\r\n deltatype = 3\r\n deltaedge = bestedge[b]\r\n\r\n # Compute delta4: minimum z variable of any T-blossom.\r\n for b in range(nvertex, 2*nvertex):\r\n if ( blossombase[b] >= 0 and blossomparent[b] == -1 and\r\n label[b] == 2 and\r\n (deltatype == -1 or dualvar[b] < delta) ):\r\n delta = dualvar[b]\r\n deltatype = 4\r\n deltablossom = b\r\n\r\n if deltatype == -1:\r\n # No further improvement possible; max-cardinality optimum\r\n # reached. Do a final delta update to make the optimum\r\n # verifyable.\r\n assert maxcardinality\r\n deltatype = 1\r\n delta = max(0, min(dualvar[:nvertex]))\r\n\r\n # Update dual variables according to delta.\r\n for v in range(nvertex):\r\n if label[inblossom[v]] == 1:\r\n # S-vertex: 2*u = 2*u - 2*delta\r\n dualvar[v] -= delta\r\n elif label[inblossom[v]] == 2:\r\n # T-vertex: 2*u = 2*u + 2*delta\r\n dualvar[v] += delta\r\n for b in range(nvertex, 2*nvertex):\r\n if blossombase[b] >= 0 and blossomparent[b] == -1:\r\n if label[b] == 1:\r\n # top-level S-blossom: z = z + 2*delta\r\n dualvar[b] += delta\r\n elif label[b] == 2:\r\n # top-level T-blossom: z = z - 2*delta\r\n dualvar[b] -= delta\r\n\r\n # Take action at the point where minimum delta occurred.\r\n if DEBUG: DEBUG('delta%d=%f' % (deltatype, delta))\r\n if deltatype == 1: \r\n # No further improvement possible; optimum reached.\r\n break\r\n elif deltatype == 2:\r\n # Use the least-slack edge to continue the search.\r\n allowedge[deltaedge] = True\r\n (i, j, wt) = edges[deltaedge]\r\n if label[inblossom[i]] == 0:\r\n i, j = j, i\r\n assert label[inblossom[i]] == 1\r\n queue.append(i)\r\n elif deltatype == 3:\r\n # Use the least-slack edge to continue the search.\r\n allowedge[deltaedge] = True\r\n (i, j, wt) = edges[deltaedge]\r\n assert label[inblossom[i]] == 1\r\n queue.append(i)\r\n elif deltatype == 4:\r\n # Expand the least-z blossom.\r\n expandBlossom(deltablossom, False)\r\n\r\n # End of a this substage.\r\n\r\n # Stop when no more augmenting path can be found.\r\n if not augmented:\r\n break\r\n\r\n # End of a stage; expand all S-blossoms which have dualvar = 0.\r\n for b in range(nvertex, 2*nvertex):\r\n if ( blossomparent[b] == -1 and blossombase[b] >= 0 and\r\n label[b] == 1 and dualvar[b] == 0 ):\r\n expandBlossom(b, True)\r\n\r\n # Verify that we reached the optimum solution.\r\n if CHECK_OPTIMUM:\r\n verifyOptimum()\r\n\r\n # Transform mate[] such that mate[v] is the vertex to which v is paired.\r\n for v in range(nvertex):\r\n if mate[v] >= 0:\r\n mate[v] = endpoint[mate[v]]\r\n for v in range(nvertex):\r\n assert mate[v] == -1 or mate[mate[v]] == v\r\n\r\n return mate","def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,\n best_path):\n path[0] = path[0] + [start]\n \n if digraph.has_node(Node(start)) == False or digraph.has_node(Node(end)) == False:\n raise ValueError('Start or end node are not valid')\n elif start == end :\n return path\n else:\n for edge in digraph.get_edges_for_node(Node(start)):\n \n node = str(edge.get_destination())\n tot_distance = edge.get_total_distance() + path[1]\n tot_outdoors = edge.get_outdoor_distance() + path[2]\n\n if node not in path[0] and tot_distance <= best_dist and tot_outdoors <= max_dist_outdoors :\n updated_path = [path[0], tot_distance, tot_outdoors]\n new_path = get_best_path(digraph, node, end, updated_path, max_dist_outdoors, best_dist, best_path)\n \n if new_path:\n if not best_dist or new_path[1] < best_dist: \n best_path = new_path[0]\n best_dist = new_path[1]\n\n return best_path, best_dist","def optimize_pipe_size(self, network_frame, lb_diam, peak_consumption, max_capacity={}):\n\n # Start data initialization\n GraphParam = self.get_params(network_frame, peak_consumption)\n GraphParam['LB_DIAM'] = lb_diam\n\n # In case of old network\n if len(max_capacity) > 0:\n GraphParam['MAX_CAPACITY'] = {}\n for e, val in max_capacity.items():\n GraphParam['MAX_CAPACITY'][(e[0],e[1])] = val\n else:\n GraphParam['MAX_CAPACITY'] = {}\n \n # Start the algorithm\n # Use NLP module\n optimizer_directory = os.path.dirname(os.path.realpath(__file__))\n with JuliaQgisInterface() as j:\n j.include(os.path.join(optimizer_directory, \"NLP\", \"NLP_variable_flows.jl\"))\n j.using(\"Main.NLP: find_optimal_physical_parameters\")\n assert (hasattr(j, \"find_optimal_physical_parameters\"))\n nlp_start = time.time()\n NLP_Output, status = j.find_optimal_physical_parameters(GraphParam,\n self.conf,\n self.solver_log_file,\n self.energy,\n self.logger.info)\n nlp_end = time.time()\n self.logger.info(\"nlp time: %s\" % str(nlp_end - nlp_start))\n return NLP_Output, status","def get_max_paper(link_graph: dict):\n papers = []\n for k, v in link_graph.items():\n papers.extend(v.keys())\n return max(papers, key=papers.count)","def get_max(self):\n\n max_value = self.head.value\n current_node = self.head\n # while current_node.next is not None: # when current_node = current.tail, this will not iterate\n while current_node.next is not None: # when current_node = current.tail, this will not iterate\n current_node = current_node.next\n # checks if the value is larger than our max value so far\n if max_value < current_node.value:\n max_value = current_node.value\n return max_value","def _get_lip_best(self) -> float:\n pass","def findMaximumDeviationJunction(junctions, wires, resistances, voltages, currents):\n raise NotImplementedError","def get_best_link_station_with_power(self, link_stations):\n best_power = 0\n best_station = link_stations[0]\n for station in link_stations:\n power = station.get_power(self)\n if power > best_power:\n best_station = station\n best_power = power\n return self._str_best_link_station_with_power(best_station, best_power)","def max_surge(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"max_surge\")","def compute_greedy_flow_allocations( target_graph\n , flow_selection_fn\n , seed_number=DEFAULT_SEED_NUMBER):\n\n flow_allocation_seed_number = seed_number\n np.random.seed(flow_allocation_seed_number)\n\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\n flows = []\n\n while True:\n capacity_was_exceeded = False\n\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\n\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\n disjoint_path_count = len(connecting_paths)\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\n capacity_was_exceeded = True\n break\n link_utilization[u, v] += flow_rate_per_subpath\n if capacity_was_exceeded:\n break\n if capacity_was_exceeded:\n break\n\n the_flow = Flow( source_node = source_node\n , destination_node = destination_node\n , flow_tx_rate = flow_tx_rate\n , paths = connecting_paths\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\n )\n flows.append(the_flow)\n return flows, link_utilization","def resource_max_constraint_rule(backend_model, node, tech, timestep):\n timestep_resolution = backend_model.timestep_resolution[timestep]\n\n return backend_model.resource_con[node, tech, timestep] <= (\n timestep_resolution * backend_model.resource_cap[node, tech]\n )","def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\n #print slink_dict\n #print \"FIND\"\n failed_dict = model.failed_dict\n #print failed_dict, limit\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n bw_matrix = model.cost_dict['bw']\n #cpu_vector = model.cost_dict['cpu']\n selected_dict = {}\n \n # get aggregated residual bw for all substrate nodes, and store it as a list\n snode_bw_list = total_bw(bw_matrix)\n \n # get total capacity and used bw for each snode\n node_port_list, used_bw_list = total_port(model)\n #vnet_set = model.vnets\n sorted_vn = sort_vnet(model)\n\n #for vnet in vnet_set:\n if w_m[2] >= 10*w_m[1]:\n threshold = 0.8\n else:\n threshold = 0.8\n snode_traffic = {}\n for vn_traffic in sorted_vn:\n vnet = vn_traffic[0]\n failed_vr = failed_dict[vnet.vnet_id]\n if failed_vr != -1: \n # this node is failed\n standby_list = vnet.get_standby_ids()\n standby_cost = {}\n for s_vr in standby_list:\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\n failed_node = vnet.vnodes[failed_vr]\n vneighbors = failed_node.vneighbors\n dist_k = 0\n rtt_k = 0\n for k in vneighbors:\n dist_k += float(dist_matrix[s_vr][k + 1])\n rtt_k += float(rtt_matrix[s_vr][k + 1])\n\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\n w_b[1] * rtt_k\n res_cost = snode_bw_list[s_vr]\n req_bw = sum(failed_node.neighbor_traffic.values())\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\n standby_cost[s_vr] = total\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\n #print \"SORTED\", sorted_x\n \n for item in sorted_x:\n if item[0] not in snode_traffic:\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n else:\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n #print utilization\n # Link-Path selsection add-on\n path_alloc = 1\n for k in vneighbors:\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\n item[0] + 1, k + 1)\n demand = demand_dict[demand_id]['capacity']\n find, path = find_path(demand_path, demand_id, \n slink_dict, demand) \n if find == 0:\n print \"No available path between svr and nbr on the substrate network\" \n path_alloc = 0\n #print \"FIND PATH\", find, path\n # End link-path block \n #print \"ALLOCATED: \", path_alloc\n if path_alloc == 1:\n if selected_dict.values().count(item[0]) < limit:\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\n if item[0] not in snode_traffic: \n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] = vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break;\n else:\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \n if min_id == item[0]:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n #threshold = (threshold + 0.01)/2\n break\n elif utilization < threshold:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n if item[0] not in snode_traffic: \n snode_traffic[item[0]] = vn_traffic[1]\n else:\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break\n else:\n print \"does not satisfy the threshold\" \n # if a svr is selected -- item[0]\n \n \n \n else:\n print \"cannot allocate paths\"\n \n #print slink_dict \n return selected_dict, slink_dict","def edge_position_max(self) -> int:\n return int(self.graph_tuple_stats.edge_position_max or 0)","async def max_distance(self, *args):\n return await self._rpc.max_distance(*args)","def find_maximum_required_assets(geotype, area_km2, capacity_lookup):\n capacity_values = []\n for key, values in capacity_lookup.items():\n if key[0] == geotype:\n for value in values:\n capacity_values.append(value[0])\n\n max_assets_km2 = max(capacity_values)\n\n max_assets = max_assets_km2 * area_km2\n\n return roundup(max_assets)","def get_objective(self):\n self.objective = 0\n for r in self.routes:\n r.update_route(self.vrpdata)\n self.objective += r.distance\n # all() returns True if all elements of the iterable are true\n self.solutionValid = (all([r.tourValid for r in self.routes]) and len(self.routes) <= self.vrpdata.MaxNumVeh)\n if self.solutionValid:\n return self.objective\n return -1","def estimate_resources(workflow):\n segment = get_task_segments(workflow)\n\n inv_seg = dict()\n\n for k in segment:\n if not segment[k] in inv_seg:\n inv_seg[segment[k]] = 1\n else:\n inv_seg[segment[k]] += 1\n\n max_v = 0\n for k in inv_seg:\n max_v = max(inv_seg[k], max_v)\n\n return max_v"],"string":"[\n \"def find_max_flow(graph, start, end):\\n try:\\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\\\"weight\\\")\\n return flow_value\\n except Exception as e:\\n print(\\\"Error in Max flow computation \\\", e)\\n return \\\"NaN\\\"\",\n \"def get_max_usage(topology, path):\\n max_usage = np.finfo(0.0).min\\n for i in range(len(path.node_list) - 1):\\n max_usage = max(max_usage, topology[path.node_list[i]][path.node_list[i + 1]]['total_units'] - topology[path.node_list[i]][path.node_list[i + 1]]['available_units'])\\n return max_usage\",\n \"def calc_slow(self, demands: Demand, routing: Routing) -> float:\\n edge_capacities = [e[2]['weight'] for e in\\n sorted(self.graph.edges(data=True))]\\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\\n # Because utilisation compared to link width is what we care about here\\n ratio_capacities = np.divide(link_utilisation, edge_capacities)\\n\\n return np.max(ratio_capacities)\",\n \"def calc_overall_link_utilisation(self, demands: Demand,\\n routing: Routing) -> np.ndarray:\\n flows = [(i, j) for i in range(self.num_nodes)\\n for j in range(self.num_nodes)\\n if i != j]\\n\\n link_utilisation = np.zeros(self.num_edges)\\n\\n for i, flow in enumerate(flows):\\n flow_link_utilisation = self.calc_per_flow_link_utilisation(flow,\\n demands[\\n i],\\n routing[\\n i])\\n link_utilisation += flow_link_utilisation\\n\\n return link_utilisation\",\n \"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\\n demand: float,\\n routing: np.ndarray) -> np.ndarray:\\n edge_mapping = {edge: i for i, edge in\\n enumerate(sorted(self.graph.edges))}\\n\\n link_utilisation = np.zeros(self.num_edges)\\n node_flow = np.zeros(self.num_nodes) # the flow stored at a node\\n node_flow[flow[0]] = demand\\n\\n to_explore = [flow[0]]\\n while to_explore:\\n current_node = to_explore.pop(0)\\n current_flow = node_flow[current_node]\\n\\n # this is the flow destination node so we absorb all flow\\n if current_node == flow[1]:\\n node_flow[current_node] = 0.0\\n continue\\n\\n # push the flow at this node over all edges\\n for edge in self.graph.out_edges(current_node):\\n edge_index = edge_mapping[edge]\\n ratio = routing[edge_index]\\n flow_to_send = ratio * current_flow\\n # only send flow if greater than epsilon (so no 'infinite' loops)\\n if flow_to_send > 1.e-8:\\n node_flow[edge[1]] += ratio * current_flow\\n # all important step, update our output\\n link_utilisation[edge_index] += ratio * current_flow\\n # have updated the dst so add it to the list of things to do\\n to_explore.append(edge[1])\\n # we've moved all the flow from this node now, so reset back to zero\\n node_flow[current_node] = 0.0\\n\\n return link_utilisation\",\n \"def max_path_cost(self, path, attr): \\n return max([self.G[path[i]][path[i+1]][attr] for i in range(len(path)-1)])\",\n \"def maximal_destination_for_passenger(state, problem):\\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\\n if unsatisfied:\\n max_dist = max([p.opt for p in unsatisfied])\\n return max_dist\\n return 0\",\n \"def part_2(distances: Distances) -> int:\\n\\n result, _ = max(generate_routes(distances))\\n print(f\\\"part 2: longest route has distance {result}\\\")\\n return result\",\n \"def calculate_available_link_res (self, sg_hops_to_be_ignored, mode=MODE_ADD):\\n # set availbandwidth to the maximal value\\n for i, j, k, d in self.network.edges_iter(data=True, keys=True):\\n if d.type == 'STATIC':\\n setattr(self.network[i][j][k], 'availbandwidth', d.bandwidth)\\n # subtract the reserved link and internal (inside Infras) bandwidth\\n if mode == self.MODE_ADD:\\n for d in self.infras:\\n for p in d.ports:\\n for fr in p.flowrules:\\n if fr.id not in sg_hops_to_be_ignored and fr.bandwidth is not None:\\n # Flowrules are cummulatively subtracted from the switching \\n # capacity of the node.\\n d.availres['bandwidth'] -= fr.bandwidth\\n if d.availres['bandwidth'] < 0:\\n raise RuntimeError(\\\"The node bandwidth of %s got below zero \\\"\\n \\\"during available resource calculation!\\\" %\\n d.id)\\n # Get all the mapped paths of all SGHops from the NFFG\\n sg_map = NFFGToolBox.get_all_sghop_info(self, return_paths=True)\\n for sg_hop_id, data in sg_map.iteritems():\\n src, dst, flowclass, bandwidth, delay, path = data\\n if bandwidth is not None:\\n for link in path:\\n link.availbandwidth -= bandwidth\\n if link.availbandwidth < 0:\\n raise RuntimeError(\\n \\\"The link bandwidth of %s got below zero during\\\"\\n \\\"available resource calculation!\\\" % link.id)\",\n \"def max_network_performance(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_network_performance\\\")\",\n \"def max_dist(graph, source):\\r\\n q = queue.Queue()\\r\\n found = {}\\r\\n distance = {}\\r\\n for vertex in graph: \\r\\n found[vertex] = 0\\r\\n distance[vertex] = -1\\r\\n max_distance = 0\\r\\n found[source] = 1\\r\\n distance[source] = 0\\r\\n q.put(source)\\r\\n while q.empty() == False:\\r\\n current = q.get()\\r\\n for neighbour in graph[current]:\\r\\n if found[neighbour] == 0:\\r\\n found[neighbour] = 1\\r\\n distance[neighbour] = distance[current] + 1\\r\\n max_distance = distance[neighbour]\\r\\n q.put(neighbour)\\r\\n return max_distance\",\n \"def maximum_flow(graph, start, end):\\n if not isinstance(graph, BasicGraph):\\n raise TypeError(f\\\"Expected subclass of BasicGraph, not {type(graph)}\\\")\\n Graph = type(graph)\\n \\n if start not in graph:\\n raise ValueError(f\\\"{start} not in graph\\\")\\n if end not in graph:\\n raise ValueError(f\\\"{end} not in graph\\\")\\n\\n inflow = sum(d for s, e, d in graph.edges(from_node=start))\\n outflow = sum(d for s, e, d in graph.edges(to_node=end))\\n unassigned_flow = min(inflow, outflow) # search in excess of this 'flow' is a waste of time.\\n total_flow = 0\\n # -----------------------------------------------------------------------\\n # The algorithm\\n # I reviewed a number of algorithms, such as Ford-fulkerson algorithm,\\n # Edmonson-Karp and Dinic, but I didn't like them due to their naive usage\\n # of DFS, which leads to a lot of node visits.\\n #\\n # I therefore choose to invert the capacities of the graph so that the\\n # capacity any G[u][v] = c becomes 1/c in G_inverted.\\n # This allows me to use the shortest path method to find the path with\\n # most capacity in the first attempt, resulting in a significant reduction\\n # of unassigned flow.\\n #\\n # By updating G_inverted, with the residual capacity, I can keep using the\\n # shortest path, until the capacity is zero, whereby I remove the links\\n # When the shortest path method returns 'No path' or when unassigned flow\\n # is zero, I exit the algorithm.\\n #\\n # Even on small graphs, this method is very efficient, despite the overhead\\n # of using shortest path. For very large graphs, this method outperforms\\n # all other algorithms by orders of magnitude.\\n # -----------------------------------------------------------------------\\n\\n edges = [(n1, n2, 1 / d) for n1, n2, d in graph.edges() if d > 0]\\n inverted_graph = Graph(from_list=edges) # create G_inverted.\\n capacity_graph = Graph() # Create structure to record capacity left.\\n flow_graph = Graph() # Create structure to record flows.\\n\\n while unassigned_flow:\\n # 1. find the best path\\n d, path = shortest_path(inverted_graph, start, end)\\n if d == float(\\\"inf\\\"): # then there is no path, and we must exit.\\n return total_flow, flow_graph\\n # else: use the path and lookup the actual flow from the capacity graph.\\n\\n path_flow = min([min(d, capacity_graph.edge(s, e, default=float(\\\"inf\\\"))) for s, e, d in graph.edges(path=path)])\\n\\n # 2. update the unassigned flow.\\n unassigned_flow -= path_flow\\n total_flow += path_flow\\n\\n # 3. record the flows and update the inverted graph, so that it is\\n # ready for the next iteration.\\n edges = graph.edges(path)\\n for n1, n2, d in edges:\\n # 3.a. recording:\\n v = flow_graph.edge(n1, n2, default=None)\\n if v is None:\\n flow_graph.add_edge(n1, n2, path_flow)\\n c = graph.edge(n1, n2) - path_flow\\n else:\\n flow_graph.add_edge(n1, n2, value=v + path_flow)\\n c = graph.edge(n1, n2) - (v + path_flow)\\n capacity_graph.add_edge(n1, n2, c)\\n\\n # 3.b. updating:\\n # if there is capacity left: update with new 1/capacity\\n # else: remove node, as we can't do 1/zero.\\n if c > 0:\\n inverted_graph.add_edge(n1, n2, 1 / c)\\n else:\\n inverted_graph.del_edge(n1, n2)\\n return total_flow, flow_graph\",\n \"def test_max_flow(default_plugin_resolver):\\n dpr = default_plugin_resolver\\n source_node = 0\\n target_node = 7\\n ebunch = [\\n (0, 1, 9),\\n (0, 3, 10),\\n (1, 4, 3),\\n (2, 7, 6),\\n (3, 1, 2),\\n (3, 4, 8),\\n (4, 5, 7),\\n (4, 2, 4),\\n (5, 2, 5),\\n (5, 6, 1),\\n (6, 2, 11),\\n ]\\n nx_graph = nx.DiGraph()\\n nx_graph.add_weighted_edges_from(ebunch)\\n graph = dpr.wrappers.Graph.NetworkXGraph(nx_graph, edge_weight_label=\\\"weight\\\")\\n\\n expected_flow_value = 6\\n bottleneck_nodes = {2, 4}\\n expected_nodemap = {2: 6, 4: 6}\\n\\n mv = MultiVerify(dpr)\\n results = mv.compute(\\\"flow.max_flow\\\", graph, source_node, target_node)\\n\\n # Compare flow rate\\n results[0].assert_equal(expected_flow_value)\\n\\n # Normalize actual flow to prepare to transform\\n actual_flow = results[1].normalize(dpr.wrappers.Graph.NetworkXGraph)\\n\\n # Compare sum of out edges for bottleneck nodes\\n out_edges = mv.transform(\\n dpr.plugins.core_networkx.algos.util.graph.aggregate_edges,\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n )\\n out_bottleneck = mv.transform(\\n dpr.algos.util.nodemap.select.core_python, out_edges, bottleneck_nodes\\n )\\n out_bottleneck.assert_equal(expected_nodemap)\\n\\n # Compare sum of in edges for bottleneck nodes\\n in_edges = mv.transform(\\n \\\"util.graph.aggregate_edges.core_networkx\\\",\\n actual_flow,\\n lambda x, y: x + y,\\n initial_value=0,\\n in_edges=True,\\n out_edges=False,\\n )\\n in_bottleneck = mv.transform(\\n \\\"util.nodemap.select.core_python\\\", in_edges, bottleneck_nodes\\n )\\n in_bottleneck.assert_equal(expected_nodemap)\",\n \"def calculate_greatest(self):\\n greatest = 0\\n for resourceList in self.loading.values():\\n for time, use in resourceList:\\n if use > greatest:\\n greatest = use\\n self.emit(\\\"greatest_calculated\\\",greatest)\\n return greatest\",\n \"def get_highest_preference(self, routes):\\n # routes is all possible routes to daddr\\n outroutes = {}\\n highest = 0\\n\\n for ip in routes.keys():\\n if routes[ip][LPRF] > highest:\\n highest = routes[ip][LPRF]\\n\\n for ip in routes.keys():\\n if routes[ip][LPRF] == highest:\\n outroutes[ip] = routes[ip]\\n\\n return outroutes\",\n \"def compute_path_metric(self, sw, path, util, time_now, local_contrib):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n # Use the last-learned-via-sync value for a link\\n if (not local_contrib) and 'sync_learned' in self.graph[u][v]:\\n used1 = self.graph[u][v]['sync_learned'] + util\\n used2 = self.graph[u][v]['used'] + util\\n # ['used'] is a strict lower bound for ['sync_learned']\\n if used1 > used2: \\n used = used1\\n logging.debug(\\\"CS [%s] using sync_learned value 1 [%f]\\\", str(self.name), used1)\\n else:\\n used = used2\\n logging.debug(\\\"CS [%s] using sync_learned value 2 [%f]\\\", str(self.name), used2)\\n else:\\n logging.debug(\\\"CS [%s] using tracking value\\\", str(self.name))\\n used = self.graph[u][v]['used'] + util\\n\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def control_edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.control_edge_count_max or 0)\",\n \"def node_count_max(self) -> int:\\n return int(self.graph_tuple_stats.node_count_max or 0)\",\n \"def max_flow(self, source, sink):\\n\\n path = self.valid_path(source, sink, [])\\n\\n while path:\\n # get the maximum possible flow that can be taken from this path:\\n max_flow = min([edge.capacity for edge in path])\\n for edge in path:\\n self.edges[edge] += max_flow\\n path = self.valid_path(source, sink, [])\\n\\n # Compute all the flows from the neighbors of source:\\n return sum([self.edges[edge] for edge in self.adjacents[source]])\",\n \"def calc_strongest_bridge(comp_map: CompMap):\\n @lru_cache(None)\\n def _helper(cur_no_pins: int = 0, used_components: FrozenSet[Component] = frozenset()):\\n available_connections = comp_map[cur_no_pins] - used_components\\n\\n if not available_connections:\\n return sum(c.strength for c in used_components)\\n\\n res = []\\n for c in available_connections:\\n res.append(_helper(c.other(cur_no_pins), used_components | {c}))\\n return max(res)\\n res = _helper()\\n print(_helper.cache_info())\\n return res\",\n \"def get_current_max_link(self):\\n return self.current_max_link\",\n \"def compute_path_metric(self, sw, path, util, time_now):\\n pathmetric = 1\\n linkmetrics = []\\n links = zip(path[:-1], path[1:])\\n # calculate available capacity for each link in path\\n for link in links:\\n u, v = link\\n #DESIGN CHOICE: Should we 1) always include extra-domain state, 2)\\n #only include extra-domain state when not stale (timestamp), 3) always exclude\\n #extra-domain state when calculating the path metric? Here we do (1)\\n used = self.graph[u][v]['used'] + util\\n capacity = self.graph[u][v]['capacity']\\n linkmetric = float(used) / capacity\\n # If the controller estimates it would oversubscribe this link\\n if linkmetric > 1:\\n logging.info(\\\"[%s] MAY be OVERSUBSCRIBED [%f] at switch [%s]\\\", str(time_now), linkmetric, str(sw))\\n break\\n else:\\n linkmetrics.append(linkmetric)\\n\\n # We define pathmetric to be the worst link metric in path\\n if len(linkmetrics) > 0:\\n pathmetric = max(linkmetrics)\\n\\n funname = sys._getframe().f_code.co_name\\n logging.debug(\\\"[%s] [%s] [%s] [%s]\\\", funname, str(time_now), str(self),\\n str((path, linkmetrics)))\\n return (pathmetric, len(links))\",\n \"def strength_longest_bridge():\\n # first again filter all the Nonetype out\\n bridges = [ b for b in all_bridges if b != None ]\\n\\n # the find the strength of the longest bridge\\n # in this case the first longest to be found is also the\\n # the strongest out of all the longest\\n\\n return max(bridges, key=lambda b: len(b[1]))[0]\",\n \"def get_highest_preference(self, routes):\\n outroutes = []\\n max_val = float('-inf')\\n # find highest local pref first\\n for r in routes:\\n if r[MESG][LPRF] > max_val:\\n max_val = r[MESG][LPRF]\\n # find all routes with that val\\n for r in routes:\\n if r[MESG][LPRF] == max_val:\\n outroutes.append(r)\\n\\n return outroutes\",\n \"def countMaxDegree(self):\\r\\n max_degree = [0, 0] # le sommet, son nombre de connection \\r\\n for i_node, node_connections in enumerate(self.adjMatrix):\\r\\n connection = self.n - node_connections.count(0) # on compte le nombre de connections du sommet\\r\\n if connection > max_degree[1]:\\r\\n max_degree = max_degree[i_node, node_connections]\\r\\n return max_degree[0], max_degree[1] # C un tuple ! \\r\",\n \"def edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.edge_count_max or 0)\",\n \"def call_edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.call_edge_count_max or 0)\",\n \"def longest_flight(self):\\r\\n distance = 0\\r\\n for code, _list in self.edges.items():\\r\\n for edge in _list:\\r\\n if edge.distance > distance:\\r\\n distance = edge.distance\\r\\n start = edge.start\\r\\n destination = edge.destination\\r\\n return start, destination, distance\",\n \"def find_maximal_path(graph):\\n maximal_path_in_graph = [] # This is where the maximal path in the graph is stored (updates)\\n checked_pairs = set() # In order not to check a pair twice, the set stores the already checked pairs (and the\\n # reversed order of the tuple\\n for node_start in graph.nodes.keys():\\n for node_end in graph.nodes.keys():\\n tup_of_nodes = (node_start, node_end) # This tuple is checked in checked_pairs\\n # Need to make sure that the path is valid (!=Node) and that it is not checked yet\\n if graph.find_longest_path(node_start,\\n node_end) != None and tup_of_nodes not in checked_pairs:\\n tup_of_nodes_reverse = (node_end, node_start) # This is a tuple with the opposite order\\n checked_pairs.add(tup_of_nodes)\\n checked_pairs.add(tup_of_nodes_reverse)\\n maximal_path_for_pair = graph.find_longest_path(node_start, node_end)\\n # Updates the maximal path per pair exceeds the current one\\n if len(maximal_path_for_pair) > len(maximal_path_in_graph):\\n maximal_path_in_graph = maximal_path_for_pair\\n return \\\"Maximal path between nodes is: {}, and the length is {} nodes.\\\".format(maximal_path_in_graph, \\\\\\n len(maximal_path_in_graph))\",\n \"def max_flow(self, source, sink):\\n\\n max_flow = 0\\n\\n for i in range(self.V):\\n for j in range(self.V):\\n self.flow[i, j] = 0\\n\\n while self.bfs(source, sink):\\n increment = maxint\\n\\n u = sink\\n\\n while self.pred[u] != -1:\\n increment = min(\\n increment, self.capacity[self.pred[u], u] - self.flow[self.pred[u], u])\\n u = self.pred[u]\\n\\n u = sink\\n\\n while self.pred[u] != -1:\\n self.flow[self.pred[u], u] += increment\\n self.flow[u, self.pred[u]] -= increment\\n u = self.pred[u]\\n\\n max_flow += increment\\n\\n return max_flow\",\n \"def find_max(self):\\n return max(self.nodes, key=int)\",\n \"def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\\n pass\",\n \"def road_multiplier(highway, bicycle_pref, motorway_pref, highway_pref, residential_pref):\\n if highway == 'motorway':\\n result = -motorway_pref*0.5\\n elif highway == 'primary':\\n result = -highway_pref*0.5\\n elif highway == 'residential' or highway == 'service':\\n result = -residential_pref*0.5\\n elif highway == 'cycleway':\\n result = -bicycle_pref * 0.8\\n else:\\n result = 0\\n return result\",\n \"def search_for_maximum(self):\\n return self.maximise_aquisition(self.expected_improvement)\",\n \"def get_highest_preference(self, routes):\\n # filter out any routes that don't have the highest localPref\\n outroutes = routes.copy()\\n outroutes.sort(reverse=True, key=lambda r: r[MESG][LPRF])\\n highest = outroutes[0][MESG][LPRF]\\n outroutes = list(filter(lambda r: r[MESG][LPRF] == highest, outroutes))\\n return outroutes\",\n \"def get_max_lb(self):\\n max_lb = 0\\n for arc in self.arc_info.keys():\\n if self.arc_info[arc][\\\"lower_bound\\\"] > max_lb:\\n max_lb = self.arc_info[arc][\\\"lower_bound\\\"]\\n return max_lb\",\n \"def get_highest_preference(self, routes):\\n # start highest lpref route as the first route's path\\n highest_lprf_route = [routes[0]]\\n # start the highest lpref as that\\n # of the first route's path\\n highest_lprf = int(routes[0][LPRF])\\n # iterate through all routes in given list and\\n # find the one with the highest local pref\\n for route in routes:\\n r_lprf = int(route[LPRF])\\n if r_lprf > highest_lprf:\\n highest_lprf = r_lprf\\n highest_lprf_route = [route]\\n elif r_lprf == highest_lprf:\\n highest_lprf_route.append(route)\\n return highest_lprf_route\",\n \"def calculate_best_way(self) -> int:\\n node = self._find_lowest_cost_node()\\n while node:\\n cost = self.costs[node]\\n neighbors = self.graph[node]\\n for neighbor in neighbors.keys():\\n node_cost = cost + neighbors[neighbor]\\n if self.costs[neighbor] > node_cost:\\n self.costs[neighbor] = node_cost\\n self.parents[neighbor] = node\\n self.closed_nodes.append(node)\\n node = self._find_lowest_cost_node()\\n\\n return self.costs[\\\"fin\\\"]\",\n \"def _get_maximum(self):\\n return self._maximum\",\n \"def calculate_ucb_max(self, node):\\n pass\",\n \"def Optimum_prun_based_routing(self, S, D, L):\\n if self.has_path(S, D):\\n \\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w') \\n Opt_path = Shortest_path\\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \\n while len(Shortest_path) != 0:\\n path_cost = self.additive_path_cost(Shortest_path, 'w') \\n if path_cost <= L:\\n \\\"\\\"\\\"go to concave cost\\\"\\\"\\\"\\n PathConcave_cost = self.max_path_cost(Shortest_path, 'c1') \\n self.G = self.rm_edge_constraint(PathConcave_cost) # remove all links where the concave link is greater than PathConcave_cost\\n \\n Opt_path = Shortest_path\\n if self.has_path(S, D):\\n Shortest_path = nx.dijkstra_path(self.G, S, D, weight='w')\\n else:\\n Shortest_path = [] \\n else:\\n break \\n else:\\n self.logger.info('No path from %s to %s', S, D)\\n PathConcave_cost = 0\\n Opt_path = []\\n return PathConcave_cost, Opt_path\",\n \"def maxValue(gameState, depth, a, b):\\n ultimateMove = None # The best move the agent can do\\n if gameState.isWin() or gameState.isLose(): # if terminal node return gamescore\\n return self.evaluationFunction(gameState)\\n bestValue = -math.inf\\n # for all of max agents moves\\n for action in gameState.getLegalActions(0):\\n value = minValue(gameState.generateSuccessor(\\n 0, action), depth, 1, a, b) # save value from call to minimizing agent\\n if value > bestValue: # if value has increased, update parametres\\n bestValue = value\\n ultimateMove = action\\n a = max(a, bestValue) # updates a=alpha if bestvalue > alpha\\n if bestValue > b: # if value is greater than connected branch, do prune\\n return bestValue\\n if depth == self.depth: # if top node, return the best move\\n return ultimateMove\\n else:\\n # if not top node (and no pruning) return best value\\n return bestValue\",\n \"def degree_graph(g):\\n return max(degree_node(g, node) for node in g)\",\n \"def _maximum(self) -> float:\\n if self._type == \\\"power\\\":\\n return 5.0\\n elif self._type == \\\"setpoint\\\":\\n return self._product.get_data_config_json()[\\\"_value_setpoint_max\\\"]\\n elif self._type == \\\"fan1\\\":\\n fan = 1\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\\n elif self._type == \\\"fan2\\\":\\n fan = 2\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\\n elif self._type == \\\"fan3\\\":\\n fan = 3\\n return self._product.get_data_config_json()[\\\"_value_fan_limits\\\"][\\n (((fan - 1) * 2) + 1)\\n ]\",\n \"def getMaximumDistances(self):\\n pass\",\n \"def data_edge_count_max(self) -> int:\\n return int(self.graph_tuple_stats.data_edge_count_max or 0)\",\n \"def get_max_gains(self):\\n return tuple([lib.is_SetHWGainFactor(self.hcam,0x800c+i,100)/100 for i in range(4)])\",\n \"def find_best_route(all_cost, all_routes):\\n cost_best_route = np.inf\\n for i in range(len(all_cost)):\\n if all_cost[i] < cost_best_route:\\n cost_best_route = all_cost[i]\\n best_route = all_routes[i]\\n return cost_best_route, best_route\",\n \"def _calcTotalMax(self, item, masterIntf, slaveIntf):\\n if self.classmax:\\n total = int((self.params[masterIntf]['intf_max']*self.params[masterIntf][slaveIntf]))\\n total = int(total/self.params[masterIntf]['total_allocated'])+item['reserved']\\n totalAll = item['reqRate'] + item['reserved']\\n return max(total, totalAll)\\n return item['reqRate'] + item['reserved']\",\n \"def pair_nodes_with_max_weight_in_shortest_path(graph):\\n list_pairs_with_shortest_path = []\\n # The following for loop takes each pair, and adds the weight of their shortest path to the list\\n for frm_name in graph.nodes:\\n for to_name in graph.nodes:\\n if frm_name != to_name: # Irrelevant because the question asks \\\"pair of nodes\\\"\\n shortest_path = graph.find_shortest_path(frm_name, to_name)\\n if shortest_path != None: # We must ignore a pair with no path\\n path_weight = graph.get_path_weight(shortest_path)\\n if path_weight != None: # We must ignore path with None weight\\n pair_weight_tup = ((frm_name, to_name), path_weight)\\n list_pairs_with_shortest_path.append(pair_weight_tup)\\n # print(list_pairs_with_shortest_path) # Was used to check the function\\n sorted_list_pairs = sorted(list_pairs_with_shortest_path, key=lambda tup: tup[1], reverse=True)\\n pair_with_max = sorted_list_pairs[0] # Pair with the highest weight\\n return \\\"Pair whose shortest path with max weight: {} to {}\\\".format(pair_with_max[0][0], pair_with_max[0][1])\",\n \"def get_highest_preference(self, routes):\\n if len(routes) == 1: \\n return routes\\n if len(routes) == 0: \\n return []\\n prefList = []\\n for val in routes: \\n prefList.append(val[\\\"msg\\\"][\\\"localpref\\\"]) \\n highestVal = max(prefList) \\n outroutes = []\\n for val in routes:\\n if val[\\\"msg\\\"][\\\"localpref\\\"] == highestVal:\\n outroutes.append(val)\\n return outroutes\",\n \"def largestResolution(resolutions):\\n return resolutions[0]\",\n \"def lovliest_path(G):\\n m = 0\\n ma = None\\n mb = None\\n for node in G.keys():\\n for conn in G[node].keys():\\n if G[node][conn] > m:\\n m = G[node][conn]\\n ma = node\\n mb = conn\\n print \\\"found lovliest_path of %s to %s with weight %s\\\" % (ma,mb,m)\\n return (ma,mb)\",\n \"def global_efficiency(graph):\\n return nx.global_efficiency(graph.graph)\",\n \"def greedy(self):\\n # for each node, find the incoming link with the highest score.\\n max_scores = {}\\n max_sources = {}\\n for source, target in self.iteredges():\\n score = self.get_score(source, target)\\n max_score = max_scores.get(target)\\n if max_score is None or score > max_score:\\n max_scores[target] = score\\n max_sources[target] = source\\n # then build a graph out of just these links.\\n succs = dict((n, []) for n in self)\\n for target, source in max_sources.items():\\n succs[source].append(target)\\n return Digraph(succs, self.get_score, self.get_label)\",\n \"def max_cardinality():\\r\\n #create a list containing the number of each vertex involvement.\\r\\n array = []\\r\\n for i in adj:\\r\\n array += [i[0],i[1]]\\r\\n\\r\\n #compute the degree by counting the involment\\r\\n degree = Counter(array).most_common()\\r\\n\\r\\n #retrieve the degree only\\r\\n degree_ = [ i[1] for i in degree]\\r\\n\\r\\n degree_ = np.array(degree_)\\r\\n \\r\\n max_m = None\\r\\n \\r\\n #check if m is valid\\r\\n for i in range(degree[0][1]+2)[2:]:\\r\\n \\r\\n #valid if there are at least m vertex with degree equals to at least m-1 \\r\\n if i < len(np.where(degree_>=i-1)[0]):\\r\\n max_m = i\\r\\n else:\\r\\n break\\r\\n max_m += 1\\r\\n print(f'maximum possible clique cardinality :{max_m}')\\r\\n return max_m\",\n \"def max_flow_min_cut(vertices, start, end):\\n\\n max_flow = 0 # There is no flow initially\\n\\n while True:\\n bfs(vertices, start)\\n\\n if not end.bfs_visited:\\n # There is no path between start and end\\n break\\n\\n path = end.get_bfs_path()\\n bottleneck = min([edge.weight for edge in path])\\n\\n # Update edges and residual edges values\\n for edge in path:\\n edge.weight -= bottleneck\\n edge.inverse_edge.weight += bottleneck\\n max_flow += bottleneck\\n\\n min_cut = calculate_min_cut(vertices, start)\\n return max_flow, min_cut\",\n \"def calc_demand(self, routing: np.ndarray, demand: float,\\n commodity_idx: int) -> np.ndarray:\\n commodity = self.commodities[commodity_idx]\\n node_flow = np.zeros(self.num_nodes)\\n node_flow[commodity[0]] = demand\\n\\n split_matrix = np.zeros((self.num_nodes, self.num_nodes), dtype=float)\\n for edge_idx, edge in enumerate(self.edges):\\n split_matrix[edge[1]][edge[0]] = routing[commodity_idx][edge_idx]\\n split_matrix[:, commodity[1]] = 0 # no send from the destination node\\n\\n edge_utilisation = np.zeros((self.num_nodes, self.num_nodes))\\n\\n num_steps = 0\\n while True:\\n change = np.multiply(split_matrix, node_flow)\\n edge_utilisation += change\\n node_flow = np.matmul(split_matrix, node_flow)\\n if np.any(np.isnan(change)):\\n print(\\\"is_nan :'(\\\")\\n comparison = np.less(np.nan_to_num(change), self.min_delta)\\n if np.logical_and.reduce(np.logical_and.reduce(comparison)):\\n break\\n num_steps += 1\\n # if we take more than |E| steps we have cycles which is not good.\\n # Therefore: end here with really bad reward, scaled by number of\\n # cycles\\n if num_steps > routing.shape[1]:\\n remaining_flow = np.greater(np.nan_to_num(change), 0.0)\\n edge_utilisation += np.multiply(remaining_flow, np.full(\\n (self.num_nodes, self.num_nodes), demand))\\n break\\n\\n return edge_utilisation\",\n \"def cost(route):\\n cost = 0\\n for li in route:\\n if cost<li.get_cost():\\n cost=li.get_cost()\\n return cost\",\n \"def calc(self, demands: Demand, routing: Routing) -> np.ndarray:\\n total_utilisation = np.zeros((self.num_nodes, self.num_nodes),\\n dtype=float)\\n\\n for commodity_idx in range(len(self.commodities)):\\n utilisation = self.calc_demand(routing,\\n demands[commodity_idx],\\n commodity_idx)\\n total_utilisation += utilisation\\n\\n return np.max(np.divide(total_utilisation, self.edge_capacities))\",\n \"def handle_request(self, sw, util, duration, time_now):\\n\\n #logging.debug(str(self.graph.edges(data=True)))\\n\\n #1 Get available paths from servers to switch\\n paths = self.get_srv_paths(sw, self.graph)\\n\\n #2 choose the path which mins the max link utilization for all links\\n # along the path\\n bestpath, bestpm = self.find_best_path(paths, sw, util, duration, time_now)\\n\\n if len(bestpath) > 0:\\n self.allocate_resources(bestpath, util, time_now, duration)\\n else:\\n logging.warn(\\\"[%s] No best path found at switch [%s]\\\", str(time_now), str(sw))\\n\\n return bestpath\",\n \"def max_powerflow_rule(_m, l, y, s, t):\\r\\n\\r\\n return m.p_L[l, y, s, t] - m.POWERFLOW_MAX[l] <= 0\",\n \"def get_max_addr(self):\\n\\n out = None\\n for segment in self.segments:\\n if out is None or segment.max_addr > out:\\n out = segment.max_addr\\n\\n if out is None:\\n for section in self.sections:\\n if out is None or section.max_addr > out:\\n out = section.max_addr\\n\\n if out is None:\\n return self.rebase_addr\\n else:\\n return out + self.rebase_addr\",\n \"def maxTargets(self):\\n return self._getAttribute(Attribute.maxTargets)\",\n \"def bgll(self, graph, node_count, min_mod, max_pass):\\n\\n #the belonging of the node\\n bl = [i for i in range(node_count)]\\n #the node's weight in community\\n _in = [0.0] * node_count\\n #the node's weight in graph\\n _tot = []\\n #total weight of a node, just a copy of _tot\\n k = []\\n #the total weight of the graph\\n m = []\\n\\n #inital the in-param\\n network = [[0.0] * node_count for n in range(node_count)]\\n for node, tag, weight in graph:\\n network[node][tag] = weight\\n for node in network:\\n k.append(sum(node))\\n _tot = k[:]\\n m = sum(k)\\n #inital the in-param\\n\\n def modularity():\\n \\\"\\\"\\\"\\n This function mainly computes the modularity of the network\\n Return:\\n mod->the modularity value\\n \\\"\\\"\\\"\\n\\n q = 0.0\\n for idx in range(0, node_count):\\n if _tot[idx] > 0.0:\\n q += (_in[idx] / m - math.pow(_tot[idx] / m, 2))\\n return q\\n\\n def modularity_gain(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly computes the modularity gain of a node moving\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n Return:\\n gain->modularity gain\\n \\\"\\\"\\\"\\n\\n totc = _tot[c]\\n degc = k[n]\\n return dnodecomm - (totc * degc) / m\\n\\n def neigh_comm(n):\\n \\\"\\\"\\\"\\n This function mainly computes the weight between the node and it's neighbour community\\n Param:\\n n->node id\\n Return:\\n nc->the map of the weight between the node and it's neighbour community\\n nc=>{cid,weight}\\n \\\"\\\"\\\"\\n\\n nc = {bl[n]: 0.0}\\n for idx in range(0, node_count):\\n neigh = idx\\n ncomm = bl[neigh]\\n nei_weight = network[n][idx]\\n if (neigh != n) & (nei_weight > 0.0):\\n if ncomm in nc:\\n nc[ncomm] += nei_weight\\n else:\\n nc[ncomm] = nei_weight\\n return nc\\n\\n def insert(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly get the effect of insert the node into community\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n \\\"\\\"\\\"\\n\\n _tot[c] += k[n]\\n _in[c] += 2 * dnodecomm + network[n][n]\\n bl[n] = c\\n\\n def remove(n, c, dnodecomm):\\n \\\"\\\"\\\"\\n This function mainly get the effect of remove the node off community\\n Param:\\n n->node id\\n c->community id\\n dnodecomm->the weight between the node and the community\\n \\\"\\\"\\\"\\n\\n _tot[c] -= k[n]\\n _in[c] -= 2 * dnodecomm + network[n][n]\\n bl[n] = -1\\n\\n def detect():\\n \\\"\\\"\\\"\\n This function mainly detect the community of the graph.\\n \\\"\\\"\\\"\\n\\n _pass_done = 0\\n _improve = True\\n new_mod = modularity()\\n cur_mod = -999999999.0\\n rl = random.sample(range(0, node_count), node_count)\\n while _improve & (_pass_done < max_pass) & (new_mod - cur_mod > min_mod):\\n cur_mod = new_mod\\n _improve = False\\n _pass_done += 1\\n for node_tmp in rl:\\n n = node_tmp\\n nc = bl[n]\\n ncomm = neigh_comm(n)\\n remove(n, nc, ncomm[nc])\\n best_c = nc\\n best_l = 0.0\\n best_incre = 0.0\\n for c in ncomm:\\n incre = modularity_gain(n, c, ncomm[c])\\n if incre > best_incre:\\n best_incre = incre\\n best_c = c\\n best_l = ncomm[c]\\n insert(n, best_c, best_l)\\n if best_c != nc:\\n _improve = True\\n new_mod = modularity()\\n print new_mod\\n\\n detect()\\n return bl\",\n \"def _maximum(self) -> float:\\n return self._config[CONF_MAX]\",\n \"def get_bprop_maximum(self):\\n input_grad = G.MaximumGrad()\\n\\n def bprop(x, y, out, dout):\\n dx, dy = input_grad(x, y, dout)\\n return dx, dy\\n return bprop\",\n \"def probabilityTransitionRule(self, unvisitedHeuristics, totalUnvisited):\\n argMaxProbValue = 0\\n argMaxToken = None\\n for unvisitedToken in unvisitedHeuristics:\\n probValue = unvisitedHeuristics[unvisitedToken] / totalUnvisited\\n\\n # In case obtained value is higher than previous maximum, substitute\\n if probValue > argMaxProbValue:\\n argMaxProbValue = probValue\\n argMaxToken = unvisitedToken\\n\\n return argMaxToken\",\n \"def bern_max_metric(pipe_diameter, delta_p):\\n\\n rho = 1000 # density of water kg/m^3\\n flow_rate_max = ((math.pi * (pipe_diameter**2)) / 4) * math.sqrt((2 * delta_p) / rho)\\n\\n return flow_rate_max\",\n \"def optimal_max(board):\\n # Board full?\\n if terminal(board):\\n return [None, utility(board)]\\n\\n available_actions = list(actions(board))\\n\\n # Naive baseline comparison is negative infinity\\n global_optimum = [None, -math.inf]\\n\\n # For each move, what would opponent do next? Update best move.\\n for action in available_actions:\\n # Anticipates optimal adversarial moves\\n local_optimum = optimal_min(result(board, action))\\n\\n # Compares local vs global optima\\n if global_optimum[1] <= local_optimum[1]:\\n global_optimum = [action, local_optimum[1]]\\n\\n return global_optimum\",\n \"def find_max():\\n bridges = all_bridges\\n bridges = [ b for b in bridges if b != None ]\\n return max(bridges)\",\n \"def __find_max_distance(self):\\n return utils.find_max_distance(self.__game)\",\n \"def score_max_depths(graph, max_depths):\\n ###TODO\\n pass\",\n \"def max_pool_backward_naive(dout, cache):\\n dx = None\\n #############################################################################\\n # TODO: Implement the max pooling backward pass #\\n #############################################################################\\n pass\\n #############################################################################\\n # END OF YOUR CODE #\\n #############################################################################\\n return dx\",\n \"def _get_max_estimated_bandit(self)->Bandit:\\n # print(\\\"mus - \\\", self.mu)\\n # print(\\\"actions - \\\", np.argmax(self.mu))\\n unique, counts = np.unique(self.mu, return_counts=True)\\n lens = counts[np.argmax(unique)] \\n if lens>1: # if two actions have same argmax\\n # then return arbitrarily from those max ones\\n maxs = list(np.array(self.bandits)[self.mu==unique[np.argmax(unique)]])\\n return np.random.choice(maxs)\\n # otherwise return the max one\\n return self.bandits[np.argmax(self.mu)]\",\n \"def greedy_max_cut(graph):\\n cut = Cut(set(), set())\\n for vertex in graph.nodes:\\n l_neighbors = sum((adj in cut.left) for adj in graph.neighbors(vertex))\\n r_neighbors = sum((adj in cut.right) for adj in graph.neighbors(vertex))\\n if l_neighbors < r_neighbors:\\n cut.left.add(vertex)\\n else:\\n cut.right.add(vertex)\\n return cut\",\n \"def euclid_destination_for_passenger(state, problem):\\n unsatisfied = [p for p in state.passengers if not (p.is_arrived() or p.onboard)]\\n if unsatisfied:\\n max_dist = sum([p.opt for p in unsatisfied])\\n return max_dist\\n return 0\",\n \"def get_routing_solution(self):\\n G = self.base_digraph\\n s1 = self.sources[0]\\n s2 = self.sources[1]\\n t1 = self.destinations[0]\\n t2 = self.destinations[1]\\n\\n try:\\n m = Model('routing')\\n m.setParam('OutputFlag', False)\\n\\n # variables,\\n # We have one variable per edge per session\\n # e is the dict of dict for the variables\\n e = {}\\n r = {}\\n for i in [1,2]:\\n e[i] = {}\\n r[i] = m.addVar()\\n for u,v in G.edges():\\n e[i][u,v] = m.addVar(lb=0)\\n\\n m.update()\\n\\n obj = quicksum(r.values())\\n m.setObjective(obj, GRB.MAXIMIZE)\\n\\n # constraints\\n # 1. conservations of flow at all intermediate nodes\\n # 2. capacity constraints for each edge\\n\\n for u,v in G.edges():\\n m.addConstr(e[1][u,v] + e[2][u,v] <= G[u][v]['capacity'])\\n\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s2)) == r[2])\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.out_edges(s2)) == 0)\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.out_edges(s1)) == 0)\\n m.addConstr(quicksum(e[1][u,v] for u,v in G.in_edges(t1)) == r[1])\\n m.addConstr(quicksum(e[2][u,v] for u,v in G.in_edges(t2)) == r[2])\\n\\n for n in G.nodes():\\n if n not in [s1, s2, t1, t2]:\\n for i in [1, 2]:\\n inflow = quicksum(e[i][u,v] for u,v in G.in_edges(n))\\n outflow = quicksum(e[i][u,v] for u,v in G.out_edges(n))\\n m.addConstr(inflow == outflow)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n for u, v in G.edges():\\n G[u][v]['Routing'] = {}\\n G[u][v]['Routing'][1] = e[1][u,v].x\\n G[u][v]['Routing'][2] = e[2][u,v].x\\n return (m.objVal, r[1].x, r[2].x)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong, no optimal solution obtained\\\"\\n return None, None, None\\n\\n except GurobiError:\\n Print ('Error Report from Gurobi')\",\n \"def produce_max(self, meta, raven_vars, dispatch, t):\\n request, meta = self.get_capacity(meta, raven_vars, dispatch, t)\\n return request, meta\",\n \"def max_weight(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def opt(self, demands: Demand) -> float:\\n # Create the linear solver with the GLOP backend.\\n solver = pywraplp.Solver('multicommodity_flow_lp',\\n pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)\\n\\n ## VARIABLES\\n # Flow variables, the splitting ratios for each edge\\n # Stored as a list of lists (flow_variables[ith_flow][jth_edge])\\n flow_variables = []\\n for i in range(len(self.commodities)):\\n flow_variable_edges = []\\n for j in range(self.num_edges):\\n flow_variable_edges.append(\\n solver.NumVar(0, 1, '({},{})'.format(i, j)))\\n flow_variables.append(flow_variable_edges)\\n\\n ## CONSTRAINTS\\n # Capacity constraint\\n capacity_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint between 0 and edge capacity\\n constraint_i = solver.Constraint(\\n 0, self.graph.get_edge_data(*edge)['weight'],\\n '(1,{},{})'.format(*edge))\\n for j, commodity in enumerate(self.commodities):\\n # Coefficient for jth flow over ith edge is scaled by flow width\\n constraint_i.SetCoefficient(flow_variables[j][i],\\n # cast because or-tools :'(\\n float(demands[j]))\\n capacity_constraints.append(constraint_i)\\n\\n # Conservation on transit nodes\\n conservation_transit_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n constraints_flow_i = []\\n for j in range(self.num_nodes):\\n if j != commodity[0] and j != commodity[1]:\\n # Constraint must sum to zero\\n constraint_j = solver.Constraint(0, 0,\\n '(2,{},{})'.format(i, j))\\n for k in list(sorted(self.graph.adj[j].keys())):\\n # Ingress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(k, j)]], 1)\\n # Egress edges\\n constraint_j.SetCoefficient(\\n flow_variables[i][self.edge_index_dict[(j, k)]], -1)\\n constraints_flow_i.append(constraint_j)\\n conservation_transit_constraints.append(constraints_flow_i)\\n\\n # Conservation of flow at source node\\n conservation_source_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(3,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[0]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[0], edge_dest)]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[0])]],\\n -1)\\n conservation_source_constraints.append(constraint_i)\\n\\n # Conservation of flow at destination node\\n conservation_dest_constraints = []\\n for i, commodity in enumerate(self.commodities):\\n # Constraint must sum to one (assuming all the demand can be met)\\n constraint_i = solver.Constraint(1, 1, '(4,{})'.format(i))\\n for edge_dest in list(sorted(self.graph.adj[commodity[1]].keys())):\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(edge_dest, commodity[1])]],\\n 1)\\n constraint_i.SetCoefficient(\\n flow_variables[i][\\n self.edge_index_dict[(commodity[1], edge_dest)]],\\n -1)\\n conservation_dest_constraints.append(constraint_i)\\n\\n ## OBJECTIVES\\n # Implementation of the load-balancing example from Wikipedia\\n # First we add more constraints so that we are minimising the maximum\\n max_utilisation_variable = solver.NumVar(0, solver.Infinity(),\\n 'max_link_utilisation')\\n min_of_max_constraints = []\\n for i, edge in enumerate(self.edges):\\n # Constraint that '-inf < f_0 + f_1 +... - max < 0'\\n # i.e 'f_0 + f_1 + ... < max'\\n constraint_i = solver.Constraint(-solver.Infinity(), 0,\\n '(5,{})'.format(i))\\n constraint_i.SetCoefficient(max_utilisation_variable, -1)\\n for j, flow_variable in enumerate(flow_variables):\\n constraint_i.SetCoefficient(flow_variable[i],\\n demands[j] /\\n self.graph.get_edge_data(*edge)[\\n 'weight'])\\n min_of_max_constraints.append(constraint_i)\\n\\n # Objective now is to minimise the maximum link utilisation\\n objective = solver.Objective()\\n objective.SetCoefficient(max_utilisation_variable, 1)\\n objective.SetMinimization()\\n solver.Solve()\\n\\n return objective.Value()\",\n \"def find_max_depth(start_url):\\n print \\\"****** sequence of links that must be followed to reach the page *****\\\"\\n S, Q = set(), deque()\\n Q.append(start_url)\\n while Q:\\n u = Q.popleft()\\n if u in S: continue\\n b = u\\n S.add(u)\\n Q.extend(getLinks(u))\\n find_shortest_path(start_url,b)\\n print \\\"****** URL that is the greatest distance from start_url *****\\\"\\n print b\",\n \"def __dijkstra_max_prob_tree(unit_rules_graph, source_var):\\n variables = unit_rules_graph.vertices\\n dist = {var: -1.0 for var in variables}\\n dist[source_var] = 1.0\\n tree_nodes = {var: ParseTreeNode(var) for var in variables}\\n pending_vars = set(variables)\\n while pending_vars:\\n max_dist, max_dist_var = max((d, v) for v, d in dist.items() if v in pending_vars)\\n pending_vars.remove(max_dist_var)\\n for neighbor, prob in unit_rules_graph.neighbors[max_dist_var]:\\n if neighbor not in pending_vars:\\n continue\\n alt_dist = dist[max_dist_var] * prob\\n if dist[neighbor] is None or alt_dist > dist[neighbor]:\\n dist[neighbor] = alt_dist\\n tree_nodes[max_dist_var].children.append(tree_nodes[neighbor])\\n return ParseTree(tree_nodes[source_var])\",\n \"def maxWeightMatching(edges, maxcardinality=False):\\r\\n\\r\\n #\\r\\n # Vertices are numbered 0 .. (nvertex-1).\\r\\n # Non-trivial blossoms are numbered nvertex .. (2*nvertex-1)\\r\\n #\\r\\n # Edges are numbered 0 .. (nedge-1).\\r\\n # Edge endpoints are numbered 0 .. (2*nedge-1), such that endpoints\\r\\n # (2*k) and (2*k+1) both belong to edge k.\\r\\n #\\r\\n # Many terms used in the comments (sub-blossom, T-vertex) come from\\r\\n # the paper by Galil; read the paper before reading this code.\\r\\n #\\r\\n\\r\\n # Python 2/3 compatibility.\\r\\n from sys import version as sys_version\\r\\n if sys_version < '3':\\r\\n integer_types = (int, long)\\r\\n else:\\r\\n integer_types = (int,)\\r\\n\\r\\n # Deal swiftly with empty graphs.\\r\\n if not edges:\\r\\n return [ ]\\r\\n\\r\\n # Count vertices.\\r\\n nedge = len(edges)\\r\\n nvertex = 0\\r\\n for (i, j, w) in edges:\\r\\n assert i >= 0 and j >= 0 #and i != j\\r\\n if i >= nvertex:\\r\\n nvertex = i + 1\\r\\n if j >= nvertex:\\r\\n nvertex = j + 1\\r\\n\\r\\n # Find the maximum edge weight.\\r\\n maxweight = max(0, max([ wt for (i, j, wt) in edges ]))\\r\\n\\r\\n # If p is an edge endpoint,\\r\\n # endpoint[p] is the vertex to which endpoint p is attached.\\r\\n # Not modified by the algorithm.\\r\\n endpoint = [ edges[p//2][p%2] for p in range(2*nedge) ]\\r\\n\\r\\n # If v is a vertex,\\r\\n # neighbend[v] is the list of remote endpoints of the edges attached to v.\\r\\n # Not modified by the algorithm.\\r\\n neighbend = [ [ ] for i in range(nvertex) ]\\r\\n for k in range(len(edges)):\\r\\n (i, j, w) = edges[k]\\r\\n neighbend[i].append(2*k+1)\\r\\n neighbend[j].append(2*k)\\r\\n\\r\\n # If v is a vertex,\\r\\n # mate[v] is the remote endpoint of its matched edge, or -1 if it is single\\r\\n # (i.e. endpoint[mate[v]] is v's partner vertex).\\r\\n # Initially all vertices are single; updated during augmentation.\\r\\n mate = nvertex * [ -1 ]\\r\\n\\r\\n # If b is a top-level blossom,\\r\\n # label[b] is 0 if b is unlabeled (free);\\r\\n # 1 if b is an S-vertex/blossom;\\r\\n # 2 if b is a T-vertex/blossom.\\r\\n # The label of a vertex is found by looking at the label of its\\r\\n # top-level containing blossom.\\r\\n # If v is a vertex inside a T-blossom,\\r\\n # label[v] is 2 iff v is reachable from an S-vertex outside the blossom.\\r\\n # Labels are assigned during a stage and reset after each augmentation.\\r\\n label = (2 * nvertex) * [ 0 ]\\r\\n\\r\\n # If b is a labeled top-level blossom,\\r\\n # labelend[b] is the remote endpoint of the edge through which b obtained\\r\\n # its label, or -1 if b's base vertex is single.\\r\\n # If v is a vertex inside a T-blossom and label[v] == 2,\\r\\n # labelend[v] is the remote endpoint of the edge through which v is\\r\\n # reachable from outside the blossom.\\r\\n labelend = (2 * nvertex) * [ -1 ]\\r\\n\\r\\n # If v is a vertex,\\r\\n # inblossom[v] is the top-level blossom to which v belongs.\\r\\n # If v is a top-level vertex, v is itself a blossom (a trivial blossom)\\r\\n # and inblossom[v] == v.\\r\\n # Initially all vertices are top-level trivial blossoms.\\r\\n inblossom = list(range(nvertex))\\r\\n\\r\\n # If b is a sub-blossom,\\r\\n # blossomparent[b] is its immediate parent (sub-)blossom.\\r\\n # If b is a top-level blossom, blossomparent[b] is -1.\\r\\n blossomparent = (2 * nvertex) * [ -1 ]\\r\\n\\r\\n # If b is a non-trivial (sub-)blossom,\\r\\n # blossomchilds[b] is an ordered list of its sub-blossoms, starting with\\r\\n # the base and going round the blossom.\\r\\n blossomchilds = (2 * nvertex) * [ None ]\\r\\n\\r\\n # If b is a (sub-)blossom,\\r\\n # blossombase[b] is its base VERTEX (i.e. recursive sub-blossom).\\r\\n blossombase = list(range(nvertex)) + nvertex * [ -1 ]\\r\\n\\r\\n # If b is a non-trivial (sub-)blossom,\\r\\n # blossomendps[b] is a list of endpoints on its connecting edges,\\r\\n # such that blossomendps[b][i] is the local endpoint of blossomchilds[b][i]\\r\\n # on the edge that connects it to blossomchilds[b][wrap(i+1)].\\r\\n blossomendps = (2 * nvertex) * [ None ]\\r\\n\\r\\n # If v is a free vertex (or an unreached vertex inside a T-blossom),\\r\\n # bestedge[v] is the edge to an S-vertex with least slack,\\r\\n # or -1 if there is no such edge.\\r\\n # If b is a (possibly trivial) top-level S-blossom,\\r\\n # bestedge[b] is the least-slack edge to a different S-blossom,\\r\\n # or -1 if there is no such edge.\\r\\n # This is used for efficient computation of delta2 and delta3.\\r\\n bestedge = (2 * nvertex) * [ -1 ]\\r\\n\\r\\n # If b is a non-trivial top-level S-blossom,\\r\\n # blossombestedges[b] is a list of least-slack edges to neighbouring\\r\\n # S-blossoms, or None if no such list has been computed yet.\\r\\n # This is used for efficient computation of delta3.\\r\\n blossombestedges = (2 * nvertex) * [ None ]\\r\\n\\r\\n # List of currently unused blossom numbers.\\r\\n unusedblossoms = list(range(nvertex, 2*nvertex))\\r\\n\\r\\n # If v is a vertex,\\r\\n # dualvar[v] = 2 * u(v) where u(v) is the v's variable in the dual\\r\\n # optimization problem (multiplication by two ensures integer values\\r\\n # throughout the algorithm if all edge weights are integers).\\r\\n # If b is a non-trivial blossom,\\r\\n # dualvar[b] = z(b) where z(b) is b's variable in the dual optimization\\r\\n # problem.\\r\\n dualvar = nvertex * [ maxweight ] + nvertex * [ 0 ]\\r\\n\\r\\n # If allowedge[k] is true, edge k has zero slack in the optimization\\r\\n # problem; if allowedge[k] is false, the edge's slack may or may not\\r\\n # be zero.\\r\\n allowedge = nedge * [ False ]\\r\\n\\r\\n # Queue of newly discovered S-vertices.\\r\\n queue = [ ]\\r\\n\\r\\n # Return 2 * slack of edge k (does not work inside blossoms).\\r\\n def slack(k):\\r\\n (i, j, wt) = edges[k]\\r\\n return dualvar[i] + dualvar[j] - 2 * wt\\r\\n\\r\\n # Generate the leaf vertices of a blossom.\\r\\n def blossomLeaves(b):\\r\\n if b < nvertex:\\r\\n yield b\\r\\n else:\\r\\n for t in blossomchilds[b]:\\r\\n if t < nvertex:\\r\\n yield t\\r\\n else:\\r\\n for v in blossomLeaves(t):\\r\\n yield v\\r\\n\\r\\n # Assign label t to the top-level blossom containing vertex w\\r\\n # and record the fact that w was reached through the edge with\\r\\n # remote endpoint p.\\r\\n def assignLabel(w, t, p):\\r\\n if DEBUG: DEBUG('assignLabel(%d,%d,%d)' % (w, t, p))\\r\\n b = inblossom[w]\\r\\n assert label[w] == 0 and label[b] == 0\\r\\n label[w] = label[b] = t\\r\\n labelend[w] = labelend[b] = p\\r\\n bestedge[w] = bestedge[b] = -1\\r\\n if t == 1:\\r\\n # b became an S-vertex/blossom; add it(s vertices) to the queue.\\r\\n queue.extend(blossomLeaves(b))\\r\\n if DEBUG: DEBUG('PUSH ' + str(list(blossomLeaves(b))))\\r\\n elif t == 2:\\r\\n # b became a T-vertex/blossom; assign label S to its mate.\\r\\n # (If b is a non-trivial blossom, its base is the only vertex\\r\\n # with an external mate.)\\r\\n base = blossombase[b]\\r\\n assert mate[base] >= 0\\r\\n assignLabel(endpoint[mate[base]], 1, mate[base] ^ 1)\\r\\n\\r\\n # Trace back from vertices v and w to discover either a new blossom\\r\\n # or an augmenting path. Return the base vertex of the new blossom or -1.\\r\\n def scanBlossom(v, w):\\r\\n if DEBUG: DEBUG('scanBlossom(%d,%d)' % (v, w))\\r\\n # Trace back from v and w, placing breadcrumbs as we go.\\r\\n path = [ ]\\r\\n base = -1\\r\\n while v != -1 or w != -1:\\r\\n # Look for a breadcrumb in v's blossom or put a new breadcrumb.\\r\\n b = inblossom[v]\\r\\n if label[b] & 4:\\r\\n base = blossombase[b]\\r\\n break\\r\\n assert label[b] == 1\\r\\n path.append(b)\\r\\n label[b] = 5\\r\\n # Trace one step back.\\r\\n assert labelend[b] == mate[blossombase[b]]\\r\\n if labelend[b] == -1:\\r\\n # The base of blossom b is single; stop tracing this path.\\r\\n v = -1\\r\\n else:\\r\\n v = endpoint[labelend[b]]\\r\\n b = inblossom[v]\\r\\n assert label[b] == 2\\r\\n # b is a T-blossom; trace one more step back.\\r\\n assert labelend[b] >= 0\\r\\n v = endpoint[labelend[b]]\\r\\n # Swap v and w so that we alternate between both paths.\\r\\n if w != -1:\\r\\n v, w = w, v\\r\\n # Remove breadcrumbs.\\r\\n for b in path:\\r\\n label[b] = 1\\r\\n # Return base vertex, if we found one.\\r\\n return base\\r\\n\\r\\n # Construct a new blossom with given base, containing edge k which\\r\\n # connects a pair of S vertices. Label the new blossom as S; set its dual\\r\\n # variable to zero; relabel its T-vertices to S and add them to the queue.\\r\\n def addBlossom(base, k):\\r\\n (v, w, wt) = edges[k]\\r\\n bb = inblossom[base]\\r\\n bv = inblossom[v]\\r\\n bw = inblossom[w]\\r\\n # Create blossom.\\r\\n b = unusedblossoms.pop()\\r\\n if DEBUG: DEBUG('addBlossom(%d,%d) (v=%d w=%d) -> %d' % (base, k, v, w, b))\\r\\n blossombase[b] = base\\r\\n blossomparent[b] = -1\\r\\n blossomparent[bb] = b\\r\\n # Make list of sub-blossoms and their interconnecting edge endpoints.\\r\\n blossomchilds[b] = path = [ ]\\r\\n blossomendps[b] = endps = [ ]\\r\\n # Trace back from v to base.\\r\\n while bv != bb:\\r\\n # Add bv to the new blossom.\\r\\n blossomparent[bv] = b\\r\\n path.append(bv)\\r\\n endps.append(labelend[bv])\\r\\n assert (label[bv] == 2 or\\r\\n (label[bv] == 1 and labelend[bv] == mate[blossombase[bv]]))\\r\\n # Trace one step back.\\r\\n assert labelend[bv] >= 0\\r\\n v = endpoint[labelend[bv]]\\r\\n bv = inblossom[v]\\r\\n # Reverse lists, add endpoint that connects the pair of S vertices.\\r\\n path.append(bb)\\r\\n path.reverse()\\r\\n endps.reverse()\\r\\n endps.append(2*k)\\r\\n # Trace back from w to base.\\r\\n while bw != bb:\\r\\n # Add bw to the new blossom.\\r\\n blossomparent[bw] = b\\r\\n path.append(bw)\\r\\n endps.append(labelend[bw] ^ 1)\\r\\n assert (label[bw] == 2 or\\r\\n (label[bw] == 1 and labelend[bw] == mate[blossombase[bw]]))\\r\\n # Trace one step back.\\r\\n assert labelend[bw] >= 0\\r\\n w = endpoint[labelend[bw]]\\r\\n bw = inblossom[w]\\r\\n # Set label to S.\\r\\n assert label[bb] == 1\\r\\n label[b] = 1\\r\\n labelend[b] = labelend[bb]\\r\\n # Set dual variable to zero.\\r\\n dualvar[b] = 0\\r\\n # Relabel vertices.\\r\\n for v in blossomLeaves(b):\\r\\n if label[inblossom[v]] == 2:\\r\\n # This T-vertex now turns into an S-vertex because it becomes\\r\\n # part of an S-blossom; add it to the queue.\\r\\n queue.append(v)\\r\\n inblossom[v] = b\\r\\n # Compute blossombestedges[b].\\r\\n bestedgeto = (2 * nvertex) * [ -1 ]\\r\\n for bv in path:\\r\\n if blossombestedges[bv] is None:\\r\\n # This subblossom does not have a list of least-slack edges;\\r\\n # get the information from the vertices.\\r\\n nblists = [ [ p // 2 for p in neighbend[v] ]\\r\\n for v in blossomLeaves(bv) ]\\r\\n else:\\r\\n # Walk this subblossom's least-slack edges.\\r\\n nblists = [ blossombestedges[bv] ]\\r\\n for nblist in nblists:\\r\\n for k in nblist:\\r\\n (i, j, wt) = edges[k]\\r\\n if inblossom[j] == b:\\r\\n i, j = j, i\\r\\n bj = inblossom[j]\\r\\n if (bj != b and label[bj] == 1 and\\r\\n (bestedgeto[bj] == -1 or\\r\\n slack(k) < slack(bestedgeto[bj]))):\\r\\n bestedgeto[bj] = k\\r\\n # Forget about least-slack edges of the subblossom.\\r\\n blossombestedges[bv] = None\\r\\n bestedge[bv] = -1\\r\\n blossombestedges[b] = [ k for k in bestedgeto if k != -1 ]\\r\\n # Select bestedge[b].\\r\\n bestedge[b] = -1\\r\\n for k in blossombestedges[b]:\\r\\n if bestedge[b] == -1 or slack(k) < slack(bestedge[b]):\\r\\n bestedge[b] = k\\r\\n if DEBUG: DEBUG('blossomchilds[%d]=' % b + repr(blossomchilds[b]))\\r\\n\\r\\n # Expand the given top-level blossom.\\r\\n def expandBlossom(b, endstage):\\r\\n if DEBUG: DEBUG('expandBlossom(%d,%d) %s' % (b, endstage, repr(blossomchilds[b])))\\r\\n # Convert sub-blossoms into top-level blossoms.\\r\\n for s in blossomchilds[b]:\\r\\n blossomparent[s] = -1\\r\\n if s < nvertex:\\r\\n inblossom[s] = s\\r\\n elif endstage and dualvar[s] == 0:\\r\\n # Recursively expand this sub-blossom.\\r\\n expandBlossom(s, endstage)\\r\\n else:\\r\\n for v in blossomLeaves(s):\\r\\n inblossom[v] = s\\r\\n # If we expand a T-blossom during a stage, its sub-blossoms must be\\r\\n # relabeled.\\r\\n if (not endstage) and label[b] == 2:\\r\\n # Start at the sub-blossom through which the expanding\\r\\n # blossom obtained its label, and relabel sub-blossoms untili\\r\\n # we reach the base.\\r\\n # Figure out through which sub-blossom the expanding blossom\\r\\n # obtained its label initially.\\r\\n assert labelend[b] >= 0\\r\\n entrychild = inblossom[endpoint[labelend[b] ^ 1]]\\r\\n # Decide in which direction we will go round the blossom.\\r\\n j = blossomchilds[b].index(entrychild)\\r\\n if j & 1:\\r\\n # Start index is odd; go forward and wrap.\\r\\n j -= len(blossomchilds[b])\\r\\n jstep = 1\\r\\n endptrick = 0\\r\\n else:\\r\\n # Start index is even; go backward.\\r\\n jstep = -1\\r\\n endptrick = 1\\r\\n # Move along the blossom until we get to the base.\\r\\n p = labelend[b]\\r\\n while j != 0:\\r\\n # Relabel the T-sub-blossom.\\r\\n label[endpoint[p ^ 1]] = 0\\r\\n label[endpoint[blossomendps[b][j-endptrick]^endptrick^1]] = 0\\r\\n assignLabel(endpoint[p ^ 1], 2, p)\\r\\n # Step to the next S-sub-blossom and note its forward endpoint.\\r\\n allowedge[blossomendps[b][j-endptrick]//2] = True\\r\\n j += jstep\\r\\n p = blossomendps[b][j-endptrick] ^ endptrick\\r\\n # Step to the next T-sub-blossom.\\r\\n allowedge[p//2] = True\\r\\n j += jstep\\r\\n # Relabel the base T-sub-blossom WITHOUT stepping through to\\r\\n # its mate (so don't call assignLabel).\\r\\n bv = blossomchilds[b][j]\\r\\n label[endpoint[p ^ 1]] = label[bv] = 2\\r\\n labelend[endpoint[p ^ 1]] = labelend[bv] = p\\r\\n bestedge[bv] = -1\\r\\n # Continue along the blossom until we get back to entrychild.\\r\\n j += jstep\\r\\n while blossomchilds[b][j] != entrychild:\\r\\n # Examine the vertices of the sub-blossom to see whether\\r\\n # it is reachable from a neighbouring S-vertex outside the\\r\\n # expanding blossom.\\r\\n bv = blossomchilds[b][j]\\r\\n if label[bv] == 1:\\r\\n # This sub-blossom just got label S through one of its\\r\\n # neighbours; leave it.\\r\\n j += jstep\\r\\n continue\\r\\n for v in blossomLeaves(bv):\\r\\n if label[v] != 0:\\r\\n break\\r\\n # If the sub-blossom contains a reachable vertex, assign\\r\\n # label T to the sub-blossom.\\r\\n if label[v] != 0:\\r\\n assert label[v] == 2\\r\\n assert inblossom[v] == bv\\r\\n label[v] = 0\\r\\n label[endpoint[mate[blossombase[bv]]]] = 0\\r\\n assignLabel(v, 2, labelend[v])\\r\\n j += jstep\\r\\n # Recycle the blossom number.\\r\\n label[b] = labelend[b] = -1\\r\\n blossomchilds[b] = blossomendps[b] = None\\r\\n blossombase[b] = -1\\r\\n blossombestedges[b] = None\\r\\n bestedge[b] = -1\\r\\n unusedblossoms.append(b)\\r\\n\\r\\n # Swap matched/unmatched edges over an alternating path through blossom b\\r\\n # between vertex v and the base vertex. Keep blossom bookkeeping consistent.\\r\\n def augmentBlossom(b, v):\\r\\n if DEBUG: DEBUG('augmentBlossom(%d,%d)' % (b, v))\\r\\n # Bubble up through the blossom tree from vertex v to an immediate\\r\\n # sub-blossom of b.\\r\\n t = v\\r\\n while blossomparent[t] != b:\\r\\n t = blossomparent[t]\\r\\n # Recursively deal with the first sub-blossom.\\r\\n if t >= nvertex:\\r\\n augmentBlossom(t, v)\\r\\n # Decide in which direction we will go round the blossom.\\r\\n i = j = blossomchilds[b].index(t)\\r\\n if i & 1:\\r\\n # Start index is odd; go forward and wrap.\\r\\n j -= len(blossomchilds[b])\\r\\n jstep = 1\\r\\n endptrick = 0\\r\\n else:\\r\\n # Start index is even; go backward.\\r\\n jstep = -1\\r\\n endptrick = 1\\r\\n # Move along the blossom until we get to the base.\\r\\n while j != 0:\\r\\n # Step to the next sub-blossom and augment it recursively.\\r\\n j += jstep\\r\\n t = blossomchilds[b][j]\\r\\n p = blossomendps[b][j-endptrick] ^ endptrick\\r\\n if t >= nvertex:\\r\\n augmentBlossom(t, endpoint[p])\\r\\n # Step to the next sub-blossom and augment it recursively.\\r\\n j += jstep\\r\\n t = blossomchilds[b][j]\\r\\n if t >= nvertex:\\r\\n augmentBlossom(t, endpoint[p ^ 1])\\r\\n # Match the edge connecting those sub-blossoms.\\r\\n mate[endpoint[p]] = p ^ 1\\r\\n mate[endpoint[p ^ 1]] = p\\r\\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (endpoint[p], endpoint[p^1], p//2))\\r\\n # Rotate the list of sub-blossoms to put the new base at the front.\\r\\n blossomchilds[b] = blossomchilds[b][i:] + blossomchilds[b][:i]\\r\\n blossomendps[b] = blossomendps[b][i:] + blossomendps[b][:i]\\r\\n blossombase[b] = blossombase[blossomchilds[b][0]]\\r\\n assert blossombase[b] == v\\r\\n\\r\\n # Swap matched/unmatched edges over an alternating path between two\\r\\n # single vertices. The augmenting path runs through edge k, which\\r\\n # connects a pair of S vertices.\\r\\n def augmentMatching(k):\\r\\n (v, w, wt) = edges[k]\\r\\n if DEBUG: DEBUG('augmentMatching(%d) (v=%d w=%d)' % (k, v, w))\\r\\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (v, w, k))\\r\\n for (s, p) in ((v, 2*k+1), (w, 2*k)):\\r\\n # Match vertex s to remote endpoint p. Then trace back from s\\r\\n # until we find a single vertex, swapping matched and unmatched\\r\\n # edges as we go.\\r\\n while 1:\\r\\n bs = inblossom[s]\\r\\n assert label[bs] == 1\\r\\n assert labelend[bs] == mate[blossombase[bs]]\\r\\n # Augment through the S-blossom from s to base.\\r\\n if bs >= nvertex:\\r\\n augmentBlossom(bs, s)\\r\\n # Update mate[s]\\r\\n mate[s] = p\\r\\n # Trace one step back.\\r\\n if labelend[bs] == -1:\\r\\n # Reached single vertex; stop.\\r\\n break\\r\\n t = endpoint[labelend[bs]]\\r\\n bt = inblossom[t]\\r\\n assert label[bt] == 2\\r\\n # Trace one step back.\\r\\n assert labelend[bt] >= 0\\r\\n s = endpoint[labelend[bt]]\\r\\n j = endpoint[labelend[bt] ^ 1]\\r\\n # Augment through the T-blossom from j to base.\\r\\n assert blossombase[bt] == t\\r\\n if bt >= nvertex:\\r\\n augmentBlossom(bt, j)\\r\\n # Update mate[j]\\r\\n mate[j] = labelend[bt]\\r\\n # Keep the opposite endpoint;\\r\\n # it will be assigned to mate[s] in the next step.\\r\\n p = labelend[bt] ^ 1\\r\\n if DEBUG: DEBUG('PAIR %d %d (k=%d)' % (s, t, p//2))\\r\\n\\r\\n # Verify that the optimum solution has been reached.\\r\\n def verifyOptimum():\\r\\n if maxcardinality:\\r\\n # Vertices may have negative dual;\\r\\n # find a constant non-negative number to add to all vertex duals.\\r\\n vdualoffset = max(0, -min(dualvar[:nvertex]))\\r\\n else:\\r\\n vdualoffset = 0\\r\\n # 0. all dual variables are non-negative\\r\\n assert min(dualvar[:nvertex]) + vdualoffset >= 0\\r\\n assert min(dualvar[nvertex:]) >= 0\\r\\n # 0. all edges have non-negative slack and\\r\\n # 1. all matched edges have zero slack;\\r\\n for k in range(nedge):\\r\\n (i, j, wt) = edges[k]\\r\\n s = dualvar[i] + dualvar[j] - 2 * wt\\r\\n iblossoms = [ i ]\\r\\n jblossoms = [ j ]\\r\\n while blossomparent[iblossoms[-1]] != -1:\\r\\n iblossoms.append(blossomparent[iblossoms[-1]])\\r\\n while blossomparent[jblossoms[-1]] != -1:\\r\\n jblossoms.append(blossomparent[jblossoms[-1]])\\r\\n iblossoms.reverse()\\r\\n jblossoms.reverse()\\r\\n for (bi, bj) in zip(iblossoms, jblossoms):\\r\\n if bi != bj:\\r\\n break\\r\\n s += 2 * dualvar[bi]\\r\\n #assert s >= 0\\r\\n if mate[i] // 2 == k or mate[j] // 2 == k:\\r\\n assert mate[i] // 2 == k and mate[j] // 2 == k\\r\\n assert s == 0\\r\\n # 2. all single vertices have zero dual value;\\r\\n for v in range(nvertex):\\r\\n assert mate[v] >= 0 or dualvar[v] + vdualoffset == 0\\r\\n # 3. all blossoms with positive dual value are full.\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if blossombase[b] >= 0 and dualvar[b] > 0:\\r\\n assert len(blossomendps[b]) % 2 == 1\\r\\n for p in blossomendps[b][1::2]:\\r\\n assert mate[endpoint[p]] == p ^ 1\\r\\n assert mate[endpoint[p ^ 1]] == p\\r\\n # Ok.\\r\\n\\r\\n # Check optimized delta2 against a trivial computation.\\r\\n def checkDelta2():\\r\\n for v in range(nvertex):\\r\\n if label[inblossom[v]] == 0:\\r\\n bd = None\\r\\n bk = -1\\r\\n for p in neighbend[v]:\\r\\n k = p // 2\\r\\n w = endpoint[p]\\r\\n if label[inblossom[w]] == 1:\\r\\n d = slack(k)\\r\\n if bk == -1 or d < bd:\\r\\n bk = k\\r\\n bd = d\\r\\n if DEBUG and (bestedge[v] != -1 or bk != -1) and (bestedge[v] == -1 or bd != slack(bestedge[v])):\\r\\n DEBUG('v=' + str(v) + ' bk=' + str(bk) + ' bd=' + str(bd) + ' bestedge=' + str(bestedge[v]) + ' slack=' + str(slack(bestedge[v])))\\r\\n assert (bk == -1 and bestedge[v] == -1) or (bestedge[v] != -1 and bd == slack(bestedge[v]))\\r\\n\\r\\n # Check optimized delta3 against a trivial computation.\\r\\n def checkDelta3():\\r\\n bk = -1\\r\\n bd = None\\r\\n tbk = -1\\r\\n tbd = None\\r\\n for b in range(2 * nvertex):\\r\\n if blossomparent[b] == -1 and label[b] == 1:\\r\\n for v in blossomLeaves(b):\\r\\n for p in neighbend[v]:\\r\\n k = p // 2\\r\\n w = endpoint[p]\\r\\n if inblossom[w] != b and label[inblossom[w]] == 1:\\r\\n d = slack(k)\\r\\n if bk == -1 or d < bd:\\r\\n bk = k\\r\\n bd = d\\r\\n if bestedge[b] != -1:\\r\\n (i, j, wt) = edges[bestedge[b]]\\r\\n assert inblossom[i] == b or inblossom[j] == b\\r\\n assert inblossom[i] != b or inblossom[j] != b\\r\\n assert label[inblossom[i]] == 1 and label[inblossom[j]] == 1\\r\\n if tbk == -1 or slack(bestedge[b]) < tbd:\\r\\n tbk = bestedge[b]\\r\\n tbd = slack(bestedge[b])\\r\\n if DEBUG and bd != tbd:\\r\\n DEBUG('bk=%d tbk=%d bd=%s tbd=%s' % (bk, tbk, repr(bd), repr(tbd)))\\r\\n assert bd == tbd\\r\\n\\r\\n # Main loop: continue until no further improvement is possible.\\r\\n for t in range(nvertex):\\r\\n\\r\\n # Each iteration of this loop is a \\\"stage\\\".\\r\\n # A stage finds an augmenting path and uses that to improve\\r\\n # the matching.\\r\\n if DEBUG: DEBUG('STAGE %d' % t)\\r\\n\\r\\n # Remove labels from top-level blossoms/vertices.\\r\\n label[:] = (2 * nvertex) * [ 0 ]\\r\\n\\r\\n # Forget all about least-slack edges.\\r\\n bestedge[:] = (2 * nvertex) * [ -1 ]\\r\\n blossombestedges[nvertex:] = nvertex * [ None ]\\r\\n\\r\\n # Loss of labeling means that we can not be sure that currently\\r\\n # allowable edges remain allowable througout this stage.\\r\\n allowedge[:] = nedge * [ False ]\\r\\n\\r\\n # Make queue empty.\\r\\n queue[:] = [ ]\\r\\n \\r\\n # Label single blossoms/vertices with S and put them in the queue.\\r\\n for v in range(nvertex):\\r\\n if mate[v] == -1 and label[inblossom[v]] == 0:\\r\\n assignLabel(v, 1, -1)\\r\\n\\r\\n # Loop until we succeed in augmenting the matching.\\r\\n augmented = 0\\r\\n while 1:\\r\\n\\r\\n # Each iteration of this loop is a \\\"substage\\\".\\r\\n # A substage tries to find an augmenting path;\\r\\n # if found, the path is used to improve the matching and\\r\\n # the stage ends. If there is no augmenting path, the\\r\\n # primal-dual method is used to pump some slack out of\\r\\n # the dual variables.\\r\\n if DEBUG: DEBUG('SUBSTAGE')\\r\\n\\r\\n # Continue labeling until all vertices which are reachable\\r\\n # through an alternating path have got a label.\\r\\n while queue and not augmented:\\r\\n\\r\\n # Take an S vertex from the queue.\\r\\n v = queue.pop()\\r\\n if DEBUG: DEBUG('POP v=%d' % v)\\r\\n assert label[inblossom[v]] == 1\\r\\n\\r\\n # Scan its neighbours:\\r\\n for p in neighbend[v]:\\r\\n k = p // 2\\r\\n w = endpoint[p]\\r\\n # w is a neighbour to v\\r\\n if inblossom[v] == inblossom[w]:\\r\\n # this edge is internal to a blossom; ignore it\\r\\n continue\\r\\n if not allowedge[k]:\\r\\n kslack = slack(k)\\r\\n if kslack <= 0:\\r\\n # edge k has zero slack => it is allowable\\r\\n allowedge[k] = True\\r\\n if allowedge[k]:\\r\\n if label[inblossom[w]] == 0:\\r\\n # (C1) w is a free vertex;\\r\\n # label w with T and label its mate with S (R12).\\r\\n assignLabel(w, 2, p ^ 1)\\r\\n elif label[inblossom[w]] == 1:\\r\\n # (C2) w is an S-vertex (not in the same blossom);\\r\\n # follow back-links to discover either an\\r\\n # augmenting path or a new blossom.\\r\\n base = scanBlossom(v, w)\\r\\n if base >= 0:\\r\\n # Found a new blossom; add it to the blossom\\r\\n # bookkeeping and turn it into an S-blossom.\\r\\n addBlossom(base, k)\\r\\n else:\\r\\n # Found an augmenting path; augment the\\r\\n # matching and end this stage.\\r\\n augmentMatching(k)\\r\\n augmented = 1\\r\\n break\\r\\n elif label[w] == 0:\\r\\n # w is inside a T-blossom, but w itself has not\\r\\n # yet been reached from outside the blossom;\\r\\n # mark it as reached (we need this to relabel\\r\\n # during T-blossom expansion).\\r\\n assert label[inblossom[w]] == 2\\r\\n label[w] = 2\\r\\n labelend[w] = p ^ 1\\r\\n elif label[inblossom[w]] == 1:\\r\\n # keep track of the least-slack non-allowable edge to\\r\\n # a different S-blossom.\\r\\n b = inblossom[v]\\r\\n if bestedge[b] == -1 or kslack < slack(bestedge[b]):\\r\\n bestedge[b] = k\\r\\n elif label[w] == 0:\\r\\n # w is a free vertex (or an unreached vertex inside\\r\\n # a T-blossom) but we can not reach it yet;\\r\\n # keep track of the least-slack edge that reaches w.\\r\\n if bestedge[w] == -1 or kslack < slack(bestedge[w]):\\r\\n bestedge[w] = k\\r\\n\\r\\n if augmented:\\r\\n break\\r\\n\\r\\n # There is no augmenting path under these constraints;\\r\\n # compute delta and reduce slack in the optimization problem.\\r\\n # (Note that our vertex dual variables, edge slacks and delta's\\r\\n # are pre-multiplied by two.)\\r\\n deltatype = -1\\r\\n delta = deltaedge = deltablossom = None\\r\\n\\r\\n # Verify data structures for delta2/delta3 computation.\\r\\n if CHECK_DELTA:\\r\\n checkDelta2()\\r\\n checkDelta3()\\r\\n\\r\\n # Compute delta1: the minumum value of any vertex dual.\\r\\n if not maxcardinality:\\r\\n deltatype = 1\\r\\n delta = min(dualvar[:nvertex])\\r\\n\\r\\n # Compute delta2: the minimum slack on any edge between\\r\\n # an S-vertex and a free vertex.\\r\\n for v in range(nvertex):\\r\\n if label[inblossom[v]] == 0 and bestedge[v] != -1:\\r\\n d = slack(bestedge[v])\\r\\n if deltatype == -1 or d < delta:\\r\\n delta = d\\r\\n deltatype = 2\\r\\n deltaedge = bestedge[v]\\r\\n\\r\\n # Compute delta3: half the minimum slack on any edge between\\r\\n # a pair of S-blossoms.\\r\\n for b in range(2 * nvertex):\\r\\n if ( blossomparent[b] == -1 and label[b] == 1 and\\r\\n bestedge[b] != -1 ):\\r\\n kslack = slack(bestedge[b])\\r\\n if isinstance(kslack, integer_types):\\r\\n assert (kslack % 2) == 0\\r\\n d = kslack // 2\\r\\n else:\\r\\n d = kslack / 2\\r\\n if deltatype == -1 or d < delta:\\r\\n delta = d\\r\\n deltatype = 3\\r\\n deltaedge = bestedge[b]\\r\\n\\r\\n # Compute delta4: minimum z variable of any T-blossom.\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if ( blossombase[b] >= 0 and blossomparent[b] == -1 and\\r\\n label[b] == 2 and\\r\\n (deltatype == -1 or dualvar[b] < delta) ):\\r\\n delta = dualvar[b]\\r\\n deltatype = 4\\r\\n deltablossom = b\\r\\n\\r\\n if deltatype == -1:\\r\\n # No further improvement possible; max-cardinality optimum\\r\\n # reached. Do a final delta update to make the optimum\\r\\n # verifyable.\\r\\n assert maxcardinality\\r\\n deltatype = 1\\r\\n delta = max(0, min(dualvar[:nvertex]))\\r\\n\\r\\n # Update dual variables according to delta.\\r\\n for v in range(nvertex):\\r\\n if label[inblossom[v]] == 1:\\r\\n # S-vertex: 2*u = 2*u - 2*delta\\r\\n dualvar[v] -= delta\\r\\n elif label[inblossom[v]] == 2:\\r\\n # T-vertex: 2*u = 2*u + 2*delta\\r\\n dualvar[v] += delta\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if blossombase[b] >= 0 and blossomparent[b] == -1:\\r\\n if label[b] == 1:\\r\\n # top-level S-blossom: z = z + 2*delta\\r\\n dualvar[b] += delta\\r\\n elif label[b] == 2:\\r\\n # top-level T-blossom: z = z - 2*delta\\r\\n dualvar[b] -= delta\\r\\n\\r\\n # Take action at the point where minimum delta occurred.\\r\\n if DEBUG: DEBUG('delta%d=%f' % (deltatype, delta))\\r\\n if deltatype == 1: \\r\\n # No further improvement possible; optimum reached.\\r\\n break\\r\\n elif deltatype == 2:\\r\\n # Use the least-slack edge to continue the search.\\r\\n allowedge[deltaedge] = True\\r\\n (i, j, wt) = edges[deltaedge]\\r\\n if label[inblossom[i]] == 0:\\r\\n i, j = j, i\\r\\n assert label[inblossom[i]] == 1\\r\\n queue.append(i)\\r\\n elif deltatype == 3:\\r\\n # Use the least-slack edge to continue the search.\\r\\n allowedge[deltaedge] = True\\r\\n (i, j, wt) = edges[deltaedge]\\r\\n assert label[inblossom[i]] == 1\\r\\n queue.append(i)\\r\\n elif deltatype == 4:\\r\\n # Expand the least-z blossom.\\r\\n expandBlossom(deltablossom, False)\\r\\n\\r\\n # End of a this substage.\\r\\n\\r\\n # Stop when no more augmenting path can be found.\\r\\n if not augmented:\\r\\n break\\r\\n\\r\\n # End of a stage; expand all S-blossoms which have dualvar = 0.\\r\\n for b in range(nvertex, 2*nvertex):\\r\\n if ( blossomparent[b] == -1 and blossombase[b] >= 0 and\\r\\n label[b] == 1 and dualvar[b] == 0 ):\\r\\n expandBlossom(b, True)\\r\\n\\r\\n # Verify that we reached the optimum solution.\\r\\n if CHECK_OPTIMUM:\\r\\n verifyOptimum()\\r\\n\\r\\n # Transform mate[] such that mate[v] is the vertex to which v is paired.\\r\\n for v in range(nvertex):\\r\\n if mate[v] >= 0:\\r\\n mate[v] = endpoint[mate[v]]\\r\\n for v in range(nvertex):\\r\\n assert mate[v] == -1 or mate[mate[v]] == v\\r\\n\\r\\n return mate\",\n \"def get_best_path(digraph, start, end, path, max_dist_outdoors, best_dist,\\n best_path):\\n path[0] = path[0] + [start]\\n \\n if digraph.has_node(Node(start)) == False or digraph.has_node(Node(end)) == False:\\n raise ValueError('Start or end node are not valid')\\n elif start == end :\\n return path\\n else:\\n for edge in digraph.get_edges_for_node(Node(start)):\\n \\n node = str(edge.get_destination())\\n tot_distance = edge.get_total_distance() + path[1]\\n tot_outdoors = edge.get_outdoor_distance() + path[2]\\n\\n if node not in path[0] and tot_distance <= best_dist and tot_outdoors <= max_dist_outdoors :\\n updated_path = [path[0], tot_distance, tot_outdoors]\\n new_path = get_best_path(digraph, node, end, updated_path, max_dist_outdoors, best_dist, best_path)\\n \\n if new_path:\\n if not best_dist or new_path[1] < best_dist: \\n best_path = new_path[0]\\n best_dist = new_path[1]\\n\\n return best_path, best_dist\",\n \"def optimize_pipe_size(self, network_frame, lb_diam, peak_consumption, max_capacity={}):\\n\\n # Start data initialization\\n GraphParam = self.get_params(network_frame, peak_consumption)\\n GraphParam['LB_DIAM'] = lb_diam\\n\\n # In case of old network\\n if len(max_capacity) > 0:\\n GraphParam['MAX_CAPACITY'] = {}\\n for e, val in max_capacity.items():\\n GraphParam['MAX_CAPACITY'][(e[0],e[1])] = val\\n else:\\n GraphParam['MAX_CAPACITY'] = {}\\n \\n # Start the algorithm\\n # Use NLP module\\n optimizer_directory = os.path.dirname(os.path.realpath(__file__))\\n with JuliaQgisInterface() as j:\\n j.include(os.path.join(optimizer_directory, \\\"NLP\\\", \\\"NLP_variable_flows.jl\\\"))\\n j.using(\\\"Main.NLP: find_optimal_physical_parameters\\\")\\n assert (hasattr(j, \\\"find_optimal_physical_parameters\\\"))\\n nlp_start = time.time()\\n NLP_Output, status = j.find_optimal_physical_parameters(GraphParam,\\n self.conf,\\n self.solver_log_file,\\n self.energy,\\n self.logger.info)\\n nlp_end = time.time()\\n self.logger.info(\\\"nlp time: %s\\\" % str(nlp_end - nlp_start))\\n return NLP_Output, status\",\n \"def get_max_paper(link_graph: dict):\\n papers = []\\n for k, v in link_graph.items():\\n papers.extend(v.keys())\\n return max(papers, key=papers.count)\",\n \"def get_max(self):\\n\\n max_value = self.head.value\\n current_node = self.head\\n # while current_node.next is not None: # when current_node = current.tail, this will not iterate\\n while current_node.next is not None: # when current_node = current.tail, this will not iterate\\n current_node = current_node.next\\n # checks if the value is larger than our max value so far\\n if max_value < current_node.value:\\n max_value = current_node.value\\n return max_value\",\n \"def _get_lip_best(self) -> float:\\n pass\",\n \"def findMaximumDeviationJunction(junctions, wires, resistances, voltages, currents):\\n raise NotImplementedError\",\n \"def get_best_link_station_with_power(self, link_stations):\\n best_power = 0\\n best_station = link_stations[0]\\n for station in link_stations:\\n power = station.get_power(self)\\n if power > best_power:\\n best_station = station\\n best_power = power\\n return self._str_best_link_station_with_power(best_station, best_power)\",\n \"def max_surge(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"max_surge\\\")\",\n \"def compute_greedy_flow_allocations( target_graph\\n , flow_selection_fn\\n , seed_number=DEFAULT_SEED_NUMBER):\\n\\n flow_allocation_seed_number = seed_number\\n np.random.seed(flow_allocation_seed_number)\\n\\n link_utilization = {tuple(sorted(link_tuple)): 0.0 for link_tuple in target_graph.edges}\\n flows = []\\n\\n while True:\\n capacity_was_exceeded = False\\n\\n source_node, destination_node = flow_selection_fn(target_graph.nodes)\\n flow_tx_rate = np.random.uniform(FLOW_TX_RATE_LOWER_BOUND, FLOW_TX_RATE_UPPER_BOUND)\\n\\n connecting_paths = list(node_disjoint_paths(target_graph, source_node, destination_node))\\n disjoint_path_count = len(connecting_paths)\\n flow_rate_per_subpath = flow_tx_rate / disjoint_path_count\\n for path in [nx.utils.pairwise(p_i) for p_i in connecting_paths]:\\n for u, v in [tuple(sorted(t_i)) for t_i in path]:\\n if (link_utilization[u, v] + flow_rate_per_subpath) > LINK_CAPACITY:\\n capacity_was_exceeded = True\\n break\\n link_utilization[u, v] += flow_rate_per_subpath\\n if capacity_was_exceeded:\\n break\\n if capacity_was_exceeded:\\n break\\n\\n the_flow = Flow( source_node = source_node\\n , destination_node = destination_node\\n , flow_tx_rate = flow_tx_rate\\n , paths = connecting_paths\\n , splitting_ratio = [1.0/disjoint_path_count]*disjoint_path_count\\n )\\n flows.append(the_flow)\\n return flows, link_utilization\",\n \"def resource_max_constraint_rule(backend_model, node, tech, timestep):\\n timestep_resolution = backend_model.timestep_resolution[timestep]\\n\\n return backend_model.resource_con[node, tech, timestep] <= (\\n timestep_resolution * backend_model.resource_cap[node, tech]\\n )\",\n \"def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\\n #print slink_dict\\n #print \\\"FIND\\\"\\n failed_dict = model.failed_dict\\n #print failed_dict, limit\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n bw_matrix = model.cost_dict['bw']\\n #cpu_vector = model.cost_dict['cpu']\\n selected_dict = {}\\n \\n # get aggregated residual bw for all substrate nodes, and store it as a list\\n snode_bw_list = total_bw(bw_matrix)\\n \\n # get total capacity and used bw for each snode\\n node_port_list, used_bw_list = total_port(model)\\n #vnet_set = model.vnets\\n sorted_vn = sort_vnet(model)\\n\\n #for vnet in vnet_set:\\n if w_m[2] >= 10*w_m[1]:\\n threshold = 0.8\\n else:\\n threshold = 0.8\\n snode_traffic = {}\\n for vn_traffic in sorted_vn:\\n vnet = vn_traffic[0]\\n failed_vr = failed_dict[vnet.vnet_id]\\n if failed_vr != -1: \\n # this node is failed\\n standby_list = vnet.get_standby_ids()\\n standby_cost = {}\\n for s_vr in standby_list:\\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\\n failed_node = vnet.vnodes[failed_vr]\\n vneighbors = failed_node.vneighbors\\n dist_k = 0\\n rtt_k = 0\\n for k in vneighbors:\\n dist_k += float(dist_matrix[s_vr][k + 1])\\n rtt_k += float(rtt_matrix[s_vr][k + 1])\\n\\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\\\\n w_b[1] * rtt_k\\n res_cost = snode_bw_list[s_vr]\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\\n standby_cost[s_vr] = total\\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\\n #print \\\"SORTED\\\", sorted_x\\n \\n for item in sorted_x:\\n if item[0] not in snode_traffic:\\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n else:\\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n #print utilization\\n # Link-Path selsection add-on\\n path_alloc = 1\\n for k in vneighbors:\\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\\n item[0] + 1, k + 1)\\n demand = demand_dict[demand_id]['capacity']\\n find, path = find_path(demand_path, demand_id, \\n slink_dict, demand) \\n if find == 0:\\n print \\\"No available path between svr and nbr on the substrate network\\\" \\n path_alloc = 0\\n #print \\\"FIND PATH\\\", find, path\\n # End link-path block \\n #print \\\"ALLOCATED: \\\", path_alloc\\n if path_alloc == 1:\\n if selected_dict.values().count(item[0]) < limit:\\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\\n if item[0] not in snode_traffic: \\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] = vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break;\\n else:\\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \\n if min_id == item[0]:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n #threshold = (threshold + 0.01)/2\\n break\\n elif utilization < threshold:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n if item[0] not in snode_traffic: \\n snode_traffic[item[0]] = vn_traffic[1]\\n else:\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break\\n else:\\n print \\\"does not satisfy the threshold\\\" \\n # if a svr is selected -- item[0]\\n \\n \\n \\n else:\\n print \\\"cannot allocate paths\\\"\\n \\n #print slink_dict \\n return selected_dict, slink_dict\",\n \"def edge_position_max(self) -> int:\\n return int(self.graph_tuple_stats.edge_position_max or 0)\",\n \"async def max_distance(self, *args):\\n return await self._rpc.max_distance(*args)\",\n \"def find_maximum_required_assets(geotype, area_km2, capacity_lookup):\\n capacity_values = []\\n for key, values in capacity_lookup.items():\\n if key[0] == geotype:\\n for value in values:\\n capacity_values.append(value[0])\\n\\n max_assets_km2 = max(capacity_values)\\n\\n max_assets = max_assets_km2 * area_km2\\n\\n return roundup(max_assets)\",\n \"def get_objective(self):\\n self.objective = 0\\n for r in self.routes:\\n r.update_route(self.vrpdata)\\n self.objective += r.distance\\n # all() returns True if all elements of the iterable are true\\n self.solutionValid = (all([r.tourValid for r in self.routes]) and len(self.routes) <= self.vrpdata.MaxNumVeh)\\n if self.solutionValid:\\n return self.objective\\n return -1\",\n \"def estimate_resources(workflow):\\n segment = get_task_segments(workflow)\\n\\n inv_seg = dict()\\n\\n for k in segment:\\n if not segment[k] in inv_seg:\\n inv_seg[segment[k]] = 1\\n else:\\n inv_seg[segment[k]] += 1\\n\\n max_v = 0\\n for k in inv_seg:\\n max_v = max(inv_seg[k], max_v)\\n\\n return max_v\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65920657","0.6395454","0.6269792","0.62530327","0.61595035","0.60755104","0.6060538","0.6029283","0.5978314","0.594786","0.59212416","0.5899884","0.5854466","0.584627","0.5839982","0.5837012","0.58368164","0.5815957","0.5805583","0.57703376","0.57671905","0.57579577","0.57266635","0.57224804","0.5716055","0.5697326","0.5650824","0.5597299","0.55965316","0.5584685","0.5576745","0.5522797","0.5518491","0.5518042","0.5513471","0.55000633","0.5499104","0.5494657","0.5438554","0.543685","0.54358745","0.54043925","0.5379893","0.53783613","0.5373043","0.5360953","0.53595096","0.53586197","0.5358125","0.5347557","0.5342585","0.5337918","0.5336745","0.53282654","0.53091824","0.5306634","0.529352","0.5283338","0.52803653","0.5278902","0.5276191","0.5273693","0.5271276","0.5268933","0.52672386","0.52665156","0.5255673","0.5247598","0.524637","0.52445865","0.5241168","0.5238563","0.5234958","0.5230193","0.52291083","0.52232057","0.5221067","0.52197015","0.5218898","0.5217509","0.5209712","0.5209666","0.52034533","0.51969945","0.5190013","0.51880234","0.5181417","0.518018","0.51792794","0.51775485","0.5177092","0.5172825","0.516956","0.5166666","0.51624477","0.51611584","0.51608276","0.51580554","0.5156435","0.5153466"],"string":"[\n \"0.65920657\",\n \"0.6395454\",\n \"0.6269792\",\n \"0.62530327\",\n \"0.61595035\",\n \"0.60755104\",\n \"0.6060538\",\n \"0.6029283\",\n \"0.5978314\",\n \"0.594786\",\n \"0.59212416\",\n \"0.5899884\",\n \"0.5854466\",\n \"0.584627\",\n \"0.5839982\",\n \"0.5837012\",\n \"0.58368164\",\n \"0.5815957\",\n \"0.5805583\",\n \"0.57703376\",\n \"0.57671905\",\n \"0.57579577\",\n \"0.57266635\",\n \"0.57224804\",\n \"0.5716055\",\n \"0.5697326\",\n \"0.5650824\",\n \"0.5597299\",\n \"0.55965316\",\n \"0.5584685\",\n \"0.5576745\",\n \"0.5522797\",\n \"0.5518491\",\n \"0.5518042\",\n \"0.5513471\",\n \"0.55000633\",\n \"0.5499104\",\n \"0.5494657\",\n \"0.5438554\",\n \"0.543685\",\n \"0.54358745\",\n \"0.54043925\",\n \"0.5379893\",\n \"0.53783613\",\n \"0.5373043\",\n \"0.5360953\",\n \"0.53595096\",\n \"0.53586197\",\n \"0.5358125\",\n \"0.5347557\",\n \"0.5342585\",\n \"0.5337918\",\n \"0.5336745\",\n \"0.53282654\",\n \"0.53091824\",\n \"0.5306634\",\n \"0.529352\",\n \"0.5283338\",\n \"0.52803653\",\n \"0.5278902\",\n \"0.5276191\",\n \"0.5273693\",\n \"0.5271276\",\n \"0.5268933\",\n \"0.52672386\",\n \"0.52665156\",\n \"0.5255673\",\n \"0.5247598\",\n \"0.524637\",\n \"0.52445865\",\n \"0.5241168\",\n \"0.5238563\",\n \"0.5234958\",\n \"0.5230193\",\n \"0.52291083\",\n \"0.52232057\",\n \"0.5221067\",\n \"0.52197015\",\n \"0.5218898\",\n \"0.5217509\",\n \"0.5209712\",\n \"0.5209666\",\n \"0.52034533\",\n \"0.51969945\",\n \"0.5190013\",\n \"0.51880234\",\n \"0.5181417\",\n \"0.518018\",\n \"0.51792794\",\n \"0.51775485\",\n \"0.5177092\",\n \"0.5172825\",\n \"0.516956\",\n \"0.5166666\",\n \"0.51624477\",\n \"0.51611584\",\n \"0.51608276\",\n \"0.51580554\",\n \"0.5156435\",\n \"0.5153466\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5938287"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":23592,"cells":{"query":{"kind":"string","value":"SET theme accroding to configration theme path in advance"},"document":{"kind":"string","value":"def set_device_theme(dname, theme_type, number=0):\n\n # log in theme app like i theme\n activity_name = theme_config.getValue(dname,'set_theme_pkg')\n #DEVICE = device.Device(dname)\n #DEVICE.app_operation(action='LAUNCH', pkg=activity_name)\n DEVICE = adbtools.AdbTools(dname)\n #DEVICE.start_application(activity_name)\n find_text = [u'忽略本次']\n try:\n threads = []\n install_app = threading.Thread(target=DEVICE.start_application(), args=(activity_name,))\n proc_process = threading.Thread(target=myuiautomator.do_popup_windows, args=(5, find_text, dname))\n threads.append(proc_process)\n threads.append(install_app)\n for t in threads:\n t.setDaemon(True)\n t.start()\n sleep(2)\n t.join()\n except Exception, ex:\n print ex\n sleep(5)\n if number == 0:\n if theme_type.upper() == 'VLIFE':\n vlife_theme_path = theme_config.getValue(dname, 'vlife_theme_path').split('|')\n elif theme_type.upper() == 'SYSTEM':\n vlife_theme_path = theme_config.getValue(dname, 'system_theme_path').split('|')\n else:\n vlife_theme_path = theme_config.getValue(dname, 'third_party_theme_path').split('|')\n else:\n tag = 'vlife_theme_path_' + str(number)\n vlife_theme_path = theme_config.getValue(dname, tag).split('|')\n\n width, height = DEVICE.get_screen_normal_size()\n\n try:\n\n for text in vlife_theme_path:\n # try to swipe screen multiple times\n if text.startswith('NAME'):\n search_text = text.split('_')[1]\n for i in range(5):\n result = click_text(dname, search_text)\n if result:\n break\n else:\n # swipe screen\n cmd = 'input swipe {0} {1} {2} {3} 200'.format(int(width)/2, int(height)/2, int(width)/2, int(height)/2-300)\n DEVICE.shell(cmd)\n sleep(1)\n else:\n click_text(dname,text)\n\n # for i in range(3):\n # x = 0\n # y = 0\n # element = myuiautomator.Element(dname)\n # event = myuiautomator.Event(dname)\n # if text.find(':') == -1:\n # value = unicode(text)\n # # because there is not 'click' action on text, so have to click next to element\n # else:\n # value = unicode(text.split(':')[0])\n # x = text.split(':')[1]\n # y = text.split(':')[2]\n # ele = element.findElementByName(value)\n # if ele is not None:\n # event.touch(ele[0]-int(x), ele[1]-int(y))\n # sleep(2)\n # break\n # else:\n # # swipe screen\n # cmd = 'input swipe {0} {1} {2} {3} 200'.format(int(width)/2, int(height)/2, int(width)/2, int(height)/2-300)\n # DEVICE.shell(cmd)\n # sleep(1)\n\n except Exception,ex:\n print ex\n # return to HOME\n for i in range(3):\n DEVICE.send_keyevent(4)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def setup_theme(self):\r\n template_conf = self._config.template\r\n if isinstance(template_conf, str):\r\n # Either a local path or the name of built-in themes\r\n if os.path.exists(template_conf):\r\n template_conf = {\r\n 'name': os.path.split(template_conf)[-1],\r\n 'type': 'local',\r\n 'path': template_conf\r\n }\r\n elif template_conf in ['Kepler', 'Galileo']:\r\n template_conf = {\r\n 'name': template_conf,\r\n 'type': 'git',\r\n 'url': 'https://github.com/AlanDecode/Maverick-Theme-{}.git'.format(\r\n template_conf),\r\n 'branch': 'latest'\r\n }\r\n else:\r\n raise TemplateError('Can not found local theme {}'.format(\r\n self._config.template))\r\n\r\n # If its remote theme, clone it to disk first\r\n if template_conf['type'] == 'git':\r\n template_path = unify_joinpath(self._config._template_dir,\r\n template_conf['name'])\r\n if not os.path.exists(template_path):\r\n self.clone_remote_theme(self._config._template_dir, template_conf)\r\n template_conf['type'] = 'local'\r\n template_conf['path'] = template_path\r\n\r\n sys.path.insert(0, os.path.split(template_conf['path'])[0])\r\n\r\n # handle deps for theme\r\n template_dep_file = unify_joinpath(template_conf['path'],\r\n 'requirements.txt')\r\n if os.path.exists(template_dep_file) and os.path.isfile(template_dep_file):\r\n try:\r\n run('pip install -r %s' % template_dep_file, '.')\r\n except Exception:\r\n raise TemplateError('Can not install dependencies for theme.')\r\n\r\n from importlib import import_module\r\n self._template = import_module(template_conf['name'])","def use_my_theme():\n # register and enable the theme\n alt.themes.register(\"my_theme\", my_theme)\n alt.themes.enable(\"my_theme\")","def use_my_theme():\n # register and enable the theme\n alt.themes.register(\"my_theme\", my_theme)\n alt.themes.enable(\"my_theme\")","def setup_theme(app):\r\n theme = app.config['THEME']\r\n app.template_folder = os.path.join('themes', theme, 'templates')\r\n app.static_folder = os.path.join('themes', theme, 'static')","def theme(self, theme):\n\n self._theme = theme","def set_terminal_theme(theme: ApplicationTheme):\n # Change current mode.\n path = theme.path\n try:\n with open(path, 'r', encoding='utf-8') as f:\n pass\n except FileNotFoundError:\n path = theme.windows_path\n try:\n with open(path, 'r+', encoding='utf-8') as f:\n settings_string = ''\n key = theme.keys.split(theme.settings_delimiter)[-1]\n toggled_theme_name = theme.names[theme.mode == ThemeMode.light]\n\n # Search for line with key.\n current_theme_name = ''\n for line in f:\n if not current_theme_name and key in line and any(\n name in line for name in theme.names\n ):\n # Replace current theme with toggled theme.\n # Requires that theme name is either dark or\n # light theme. Else keep \"invalid\" theme rather\n # than raising an exception.\n current_theme_name = theme.names[theme.light_name in line]\n line = line.replace(current_theme_name, toggled_theme_name)\n settings_string += line\n if current_theme_name:\n f.seek(0)\n f.truncate()\n # Write new settings to file.\n f.write(settings_string)\n\n print('Set Terminal theme to:', toggled_theme_name)\n else:\n raise ValueError(\n 'Failed to find valid current theme for Terminal.')\n except Exception as e:\n print('Failed to set Terminal theme.')\n print(repr(e))","async def set_configurator_theme(self, request, theme):\n\n if theme in defaults.KERNEL_CONFIGURATOR_THEMES:\n self._configurator_theme = theme\n request.ret(READY)\n else:\n request.ret(KERNEL_CONFIGURATOR_THEME_DOES_NOT_EXIST)","def enable_theme():\r\n # Workaround for setting THEME_NAME to an empty\r\n # string which is the default due to this ansible\r\n # bug: https://github.com/ansible/ansible/issues/4812\r\n if settings.THEME_NAME == \"\":\r\n settings.THEME_NAME = None\r\n return\r\n\r\n assert settings.FEATURES['USE_CUSTOM_THEME']\r\n settings.FAVICON_PATH = 'themes/{name}/images/favicon.ico'.format(\r\n name=settings.THEME_NAME\r\n )\r\n\r\n # Calculate the location of the theme's files\r\n theme_root = settings.ENV_ROOT / \"themes\" / settings.THEME_NAME\r\n\r\n # Include the theme's templates in the template search paths\r\n settings.TEMPLATE_DIRS.insert(0, theme_root / 'templates')\r\n edxmako.paths.add_lookup('main', theme_root / 'templates', prepend=True)\r\n\r\n # Namespace the theme's static files to 'themes/<theme_name>' to\r\n # avoid collisions with default edX static files\r\n settings.STATICFILES_DIRS.append(\r\n (u'themes/{}'.format(settings.THEME_NAME), theme_root / 'static')\r\n )","def setup_theme():\n os.system('sudo apt install arc-theme')\n\n output = \"{padding}{mark} Installing theme...\"\n print(output.format(padding=LEFT_PADDING, mark=BALLOT_MARK))","def propeller_theme_url():\n return theme_url()","def theme(list_themes: bool = False, copy_theme:bool = False, theme:str = \"\"):\n if not theme:\n theme = \"dimension\"\n\n if copy_theme:\n if os.path.exists(os.path.join(THEMES_FOLDER, theme)): # If the theme exists in the themes folder\n try: # Try to copy the theme to ./<theme>\n shutil.copytree(os.path.join(THEMES_FOLDER, theme), theme)\n except FileExistsError: # If a folder exists at ./<theme> remove and then re-copy\n shutil.rmtree(theme)\n shutil.copytree(os.path.join(THEMES_FOLDER, theme), theme)\n print(f\"Copied {os.path.join(THEMES_FOLDER, theme)} to .{os.sep}{theme}\")\n else: # Theme could not be found\n print(f\"Theme {theme} not found and was unable to be copied\")\n\n if list_themes:\n # Get local themes\n print(f\"\\nAvailable local themes\\n{'='*22}\")\n for theme in os.listdir(THEMES_FOLDER):\n if not theme == \"remotes.yml\":\n print(f\" - {theme}\")\n\n # Get remote themes\n print(f\"\\nAvailable remote themes\\n{'='*23}\")\n import yaml\n with open(os.path.join(THEMES_FOLDER, \"remotes.yml\")) as remote_themes:\n for theme in yaml.safe_load(remote_themes):\n print(f\" - {theme}\")\n print() # empty newline after list","def apply_theme(self, ax):\n pass","def get_theme(self) -> str:\n return self.theme or self.account.theme","def themes(self, themes):\n\n self._themes = themes","def bootstrap_theme_url():\n return theme_url()","def get_html_theme_path():\n theme_path = os.path.abspath(Path(__file__).parent)\n return theme_path","def load_theme_values(self): \n pass","async def update_theme(q: Q):\n\n copy_expando(q.args, q.client)\n\n if q.client.theme_dark:\n logging.info('Updating theme to dark mode')\n\n q.client.path_architecture = q.app.paths_architecture['dark']\n\n q.page['meta'].theme = 'neon'\n q.page['header'].icon_color = 'black'\n else:\n logging.info('Updating theme to light mode')\n\n q.client.path_architecture = q.app.paths_architecture['light']\n\n q.page['meta'].theme = 'light'\n q.page['header'].icon_color = '#CDDD38'\n\n q.page['misc'].items[3].toggle.value = q.client.theme_dark\n\n if q.client['#'] == 'home':\n q.page['home'].items[2].text.content = f'''<center>\n <img src=\"{q.client.path_architecture}\" width=\"540px\"></center>'''\n elif q.client['#'] == 'resources':\n q.page['code_examples'] = cards.code_examples(\n code_function=q.client.code_function,\n theme_dark=q.client.theme_dark\n )\n\n await q.page.save()","def my_theme() -> Dict[str, Any]:\n return {\n \"config\": {\n \"view\": {\"height\": 400, \"width\": 600},\n \"legend\": {\"titleFontSize\": 20, \"labelFontSize\": 16},\n \"axis\": {\"grid\": False, \"labelFontSize\": 16, \"titleFontSize\": 20},\n \"header\": {\"titleFontSize\": 22, \"labelFontSize\": 18},\n \"background\": \"white\",\n }\n }","async def _theme_heist(self, ctx, theme):\r\n theme = theme.title()\r\n guild = ctx.guild\r\n\r\n if not os.path.exists(str(bundled_data_path(self)) + \"/{}.txt\".format(theme)):\r\n themes = [os.path.join(x).replace('.txt', '')\r\n for x in os.listdir(str(bundled_data_path(self))) if x.endswith(\".txt\")]\r\n msg = (\"I could not find a theme with that name. Available Themes:\"\r\n \"```\\n{}```\".format('\\n'.join(themes)))\r\n else:\r\n msg = await self.thief.theme_loader(guild, theme)\r\n\r\n await ctx.send(msg)","def new_theme(ctx, **defaults):\n from .quickstart import theme_quickstart\n\n project = ctx.get_project(silent=True)\n theme_quickstart(defaults, project=project)","def __init__(self,_dir,_theme='skyblue'):\n self.dir=_dir\n self.theme = _theme","def importTheme(context):\n\n data = context.readDataFile('theme.xml')\n if not data:\n return\n\n logger = context.getLogger('plone.app.theming.exportimport')\n\n tree = etree.fromstring(data)\n\n themeName = tree.find(\"name\")\n themeEnabled = tree.find(\"enabled\")\n\n if themeName is not None:\n themeName = themeName.text.strip()\n themeInfo = None\n\n allThemes = getAvailableThemes()\n for info in allThemes:\n if info.__name__.lower() == themeName.lower():\n themeInfo = info\n break\n\n if themeInfo is None:\n raise ValueError(\"Theme %s is not available\" % themeName)\n\n applyTheme(themeInfo)\n logger.info('Theme %s applied' % themeName)\n\n settings = getUtility(IRegistry).forInterface(IThemeSettings, False)\n\n if themeEnabled is not None:\n themeEnabled = themeEnabled.text.strip().lower()\n\n if themeEnabled in (\"y\", \"yes\", \"true\", \"t\", \"1\", \"on\",):\n settings.enabled = True\n logger.info('Theme enabled')\n elif themeEnabled in (\"n\", \"no\", \"false\", \"f\", \"0\", \"off\",):\n settings.enabled = False\n logger.info('Theme disabled')\n else:\n raise ValueError(\"%s is not a valid value for <enabled />\" % themeEnabled)","def loadTheme(self, name = \"default\"):\n themes = os.listdir(\"themes\")\n if name in themes:\n self.templates = {}\n files = glob.glob(\"themes/%s/*.tpl\" % name)\n for file in files:\n f = open(file)\n data = \"\\n\".join(f.readlines())\n f.close()\n\n key = file.replace(\".tpl\", \"\").split(os.path.sep)[-1]\n self.templates[key] = data","def set_theme(self, theme_id, is_custom):\n\t\tdata = {\"theme_id\": theme_id, \"is_custom\":is_custom}\n\t\tresponse = self.client.post(self._endpoint + \"/theme\", content=data)\n\t\treturn bool(response.json[\"success\"])","def change_theme(self):\n # get the QApplication instance, or crash if not set\n app = QtWidgets.QApplication.instance()\n if app is None:\n raise RuntimeError(\"No Qt Application found.\")\n\n if self.darkCheckBox.isChecked():\n app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())\n else:\n app.setStyleSheet(\"\")","def change_theme(self):\n # get the QApplication instance, or crash if not set\n app = QApplication.instance()\n if app is None:\n raise RuntimeError(\"No Qt Application found.\")\n\n if self.darkCheckBox.isChecked():\n app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())\n else:\n app.setStyleSheet(\"\")","def updateTheme(self):\n self.myUpdate(stateDict=None)","def theme_paths_loader(app):\n theme_paths = app.config.get('THEME_PATHS', ())\n if isinstance(theme_paths, str):\n theme_paths = [p.strip() for p in theme_paths.split(';')]\n return starchain(load_themes_from(path) for path in theme_paths)","def my_theme() -> Dict[str, Any]:\n font = \"Roboto\"\n return {\n \"config\": {\n \"view\": {\"height\": 400, \"width\": 600},\n \"legend\": {\n \"titleFontSize\": 20,\n \"labelFontSize\": 16,\n \"labelFont\": font,\n \"titleFont\": font,\n },\n \"axis\": {\n \"grid\": False,\n \"labelFontSize\": 16,\n \"titleFontSize\": 20,\n \"labelFont\": font,\n \"titleFont\": font,\n },\n \"header\": {\n \"titleFontSize\": 22,\n \"labelFontSize\": 18,\n \"titleFont\": font,\n \"labelFont\": font,\n },\n \"background\": \"white\",\n }\n }","def get_html_theme_path():\n cur_dir = path.abspath(path.dirname(path.dirname(__file__)))\n return cur_dir","def _apply_base_theme(self, app):\n\n app.setStyle(\"Fusion\")\n\n with open(self._STYLESHEET) as stylesheet:\n app.setStyleSheet(stylesheet.read())","def __init__(self, theme_dir):\n\n if not os.path.isdir(theme_dir): \n print(\"%s not a valid directory, please check!\" % theme_dir, file=sys.stderr)\n sys.exit(1)\n for dirname, dirnames, filenames in os.walk(theme_dir):\n for subdirname in dirnames:\n full_path = os.path.join(dirname, subdirname)\n self.theme_dir.append(full_path)\n print(\"read theme %s\" % full_path, file=sys.stdout)\n print(\"all themes loaded!\", file=sys.stdout)","def file(input_file):\n theme_name = \".\".join((input_file, \"json\"))\n user_theme_file = os.path.join(CONF_DIR, \"colorschemes\", theme_name)\n theme_file = os.path.join(MODULE_DIR, \"colorschemes\", theme_name)\n\n util.create_dir(os.path.dirname(user_theme_file))\n\n # Find the theme file.\n if os.path.isfile(input_file):\n theme_file = input_file\n\n elif os.path.isfile(user_theme_file):\n theme_file = user_theme_file\n\n elif input_file == \"random\":\n themes = [theme.path for theme in list_themes()]\n random.shuffle(themes)\n theme_file = themes[0]\n\n # Parse the theme file.\n if os.path.isfile(theme_file):\n logging.info(\"Set theme to \\033[1;37m%s\\033[0m.\",\n os.path.basename(theme_file))\n return parse(theme_file)\n\n else:\n logging.error(\"No colorscheme file found.\")\n sys.exit(1)","def update_theme_css():\n\n theme_file = os.path.join('app', 'static', 'app', 'css', 'theme.scss')\n try:\n Path(theme_file).touch()\n logger.info(\"刷新{}缓存\".format(theme_file))\n except:\n logger.warning(\"无法访问{}\".format(theme_file))","def main(themes):\n # Get toggled mode based on current system mode.\n toggled_mode = get_toggled_mode(get_current_mode())\n print('\\nSetting themes...')\n\n for theme in themes:\n # Set toggled mode.\n theme.mode = toggled_mode\n theme.toggle_callback(theme)\n if IS_WINDOWS:\n print(f'Setting system theme to: {toggled_mode.name}')\n toggle_mode(toggled_mode)\n print()","def theme_template_base(context):\n template_path = os.path.join(settings.THEME_NAME, 'theme.html')\n return {'THEME_TEMPLATE': template_path}","def theme_name(context):\n return {'THEME_NAME': settings.THEME_NAME}","def init(theme=\"dimension\", name=\"John Doe\"):\n print(f\"Generating site at {os.path.abspath(name)}\")\n\n shutil.copytree(os.path.join(os.path.dirname(__file__), \"example_site\"), os.path.abspath(name))\n\n # Generate initial config.yml file\n with open(os.path.join(name, \"config.yml\"), \"w+\") as config_file:\n config_file.write(f\"# See https://ezcv.readthedocs.io for documentation\\nname: {name}\\ntheme: {theme}\\nresume: false\")\n\n if theme != \"dimension\":\n # Check if theme is remote theme, and download it if it is\n \n remote_themes = get_remote_themes()\n if remote_themes.get(theme, False):\n original_directory = os.path.abspath(os.getcwd()) # Store CWD\n os.chdir(os.path.abspath(name)) # Go into new site folder\n setup_remote_theme(theme, remote_themes[theme]) # Download theme \n os.chdir(original_directory) # Navigate back to original cwd\n\n print(f\"Site generated and is available at {os.path.abspath(name)}\")","async def get_configurator_themes(self, request):\n\n request.ret(defaults.KERNEL_CONFIGURATOR_THEMES)","def dark_theme(self):\n if self.actionDark_Theme.isChecked():\n QApplication.setStyle(QStyleFactory.create(\"Fusion\"))\n palette = QPalette()\n palette.setColor(QPalette.Window, QColor(53, 53, 53))\n palette.setColor(QPalette.WindowText, Qt.white)\n palette.setColor(QPalette.Base, QColor(15, 15, 15))\n palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))\n palette.setColor(QPalette.ToolTipBase, Qt.white)\n palette.setColor(QPalette.ToolTipText, Qt.white)\n palette.setColor(QPalette.Text, Qt.white)\n palette.setColor(QPalette.Button, QColor(53, 53, 53))\n palette.setColor(QPalette.ButtonText, Qt.white)\n palette.setColor(QPalette.BrightText, Qt.red)\n palette.setColor(QPalette.Highlight, QColor(0, 24, 193).lighter())\n palette.setColor(QPalette.HighlightedText, Qt.black)\n palette.setColor(QPalette.Disabled, QPalette.Text, Qt.darkGray)\n palette.setColor(\n QPalette.Disabled, QPalette.ButtonText, Qt.darkGray)\n app.setPalette(palette)\n return\n\n app.setPalette(self.defaultPalette)","def get(self):\n themes = list(model.Theme.all().order('-start').run())\n if not themes:\n default_theme = model.Theme(display_name=\"Beautiful\")\n default_theme.start = default_theme.created\n default_theme.put()\n themes = [default_theme]\n self.send_success(themes, jsonkind=\"photohunt#themes\")","def theme_change(request):\n if request.method == \"POST\":\n form = ThemeForm(request.POST, instance=request.user.settings)\n if form.is_valid():\n form.save()\n return home(request, \"Theme Changed Successfully\")\n else:\n form = ThemeForm(instance=request.user.settings)\n \n ctx = _make_context(request, \"theme_form\", form)\n \n return TemplateResponse(request, \"users/index.html\", ctx)","def makeThemeDrawer(self,node):\n themeDrawer = self.makeDrawer(node)\n themeDrawer.getRoot().setTexture(self.image)\n return themeDrawer","def add_theme(themename,username):\n cursor = conn.cursor()\n cursor.execute(\"INSERT INTO theme(theme_name,username) VALUES (%s,%s);\",\n (themename,username))\n conn.commit()\n print(\"Theme saved.\")","def set_group_theme(request):\n\treturn render(request,\"404.html\",{})","def refresh(self):\n self._themes = {}\n for theme in starchain(ldr(self.app) for ldr in self.loaders):\n if self.valid_app_id(theme.application):\n self.themes[theme.identifier] = theme\n self.register_theme_assets()","def setWidget(self, widget: QtWidgets.QWidget):\n super().setWidget(widget)\n if globalstuff.theme == 'dark':\n w = self.widget()\n w.setPalette(globalstuff.textpal)\n if hasattr(w, 'TreeWidget'):\n w.TreeWidget.setStyleSheet(globalstuff.treeqss)","def dummy_loader(cls, context):\n log.warning(\"theme is not set -- add a theme value to your site settings\")\n theme_json = DEFAULT\n hasher = hashlib.md5()\n hasher.update(theme_json.encode(\"utf-8\"))\n theme_hash = hasher.hexdigest()\n\n theme_data = json.loads(theme_json)\n\n theme_data[\"_moya\"] = {\"path\": None, \"hash\": theme_hash}\n return theme_data","async def _themelist_heist(self, ctx):\r\n themes = [os.path.join(x).replace('.txt', '')\r\n for x in os.listdir(str(bundled_data_path(self))) if x.endswith(\".txt\")]\r\n if len(themes) > 30:\r\n themes = themes[:30]\r\n await ctx.send(\"Available Themes:```\\n{}```\".format('\\n'.join(themes)))","def themeinfo(self):\n return theme_registry.find(self.theme)","def path_for(filename):\n if settings.value(Key.Theme) == Themes.Light.value:\n return (IMAGES_PATH / Themes.Light.value / filename).as_posix()\n return (IMAGES_PATH / Themes.Dark.value / filename).as_posix()","def onStartup(event):\n\n plugins = getPlugins()\n\n for themeDirectory in iterDirectoriesOfType(THEME_RESOURCE_NAME):\n if themeDirectory.directory in reload_paths: # only for sauna.reload!\n pluginSettings = getPluginSettings(themeDirectory, plugins)\n\n for name, plugin in plugins:\n plugin.onDiscovery(themeDirectory.__name__,\n pluginSettings[name],\n pluginSettings)","def test_theme_fallback_config():\n\n class ThemeFallbackConfig(TestingConfig):\n THEME_FALLBACK = False\n\n app = create_ctfd(config=ThemeFallbackConfig)\n # Make an empty theme\n try:\n os.mkdir(os.path.join(app.root_path, \"themes\", \"foo_fallback\"))\n except OSError:\n pass\n\n # Without theme fallback, missing themes should disappear\n with app.app_context():\n app.config[\"THEME_FALLBACK\"] = False\n set_config(\"ctf_theme\", \"foo_fallback\")\n assert app.config[\"THEME_FALLBACK\"] == False\n with app.test_client() as client:\n try:\n r = client.get(\"/\")\n except TemplateNotFound:\n pass\n try:\n r = client.get(\"/themes/foo_fallback/static/js/pages/main.dev.js\")\n except TemplateNotFound:\n pass\n destroy_ctfd(app)\n\n app = create_ctfd()\n with app.app_context():\n set_config(\"ctf_theme\", \"foo_fallback\")\n assert app.config[\"THEME_FALLBACK\"] == True\n with app.test_client() as client:\n r = client.get(\"/\")\n assert r.status_code == 200\n r = client.get(\"/themes/foo_fallback/static/js/pages/main.dev.js\")\n assert r.status_code == 200\n destroy_ctfd(app)\n\n # Remove empty theme\n os.rmdir(os.path.join(app.root_path, \"themes\", \"foo_fallback\"))","def create(data):\n \n # create theme\n return Theme(\n theme_id = data['id'],\n parent_id = data.get('parent_id', None),\n name = data['name'])","def get_current_site_theme():\n # Return None if theming is disabled\n if not is_comprehensive_theming_enabled():\n return None\n\n request = get_current_request()\n if not request:\n return None\n return getattr(request, 'site_theme', None)","def read_theme_file(theme_file):\n # open and read the theme file\n with open(theme_file) as theme:\n theme_definition = theme.read()\n\n # Create a dict and separate by newlines\n theme_dictionary = dict()\n theme_definition = theme_definition.split('\\n')\n\n # Loop through lines and create a dict containing keyword and color\n for definition in theme_definition:\n theme_pattern, theme_color = definition.split(': ')\n theme_dictionary[theme_pattern] = theme_color\n return theme_dictionary","def packaged_themes_loader(app):\n themes_path = os.path.join(app.root_path, 'themes')\n if os.path.exists(themes_path):\n return load_themes_from(themes_path)\n else:\n return ()","def setup(theme='DarkAmber'):\r\n sg.theme(theme)\r\n\r\n headline_font = ('Arial bold', 20)\r\n font = ('Arial', 20)\r\n warning_font = ('Arial bold', 14)\r\n button_font = ('Arial', 14)\r\n\r\n return headline_font, font, warning_font, button_font","def apply_style(self, app):\n\n darkPalette = QPalette()\n\n # base\n darkPalette.setColor(QPalette.WindowText, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))\n darkPalette.setColor(QPalette.Light, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.Midlight, QColor(90, 90, 90))\n darkPalette.setColor(QPalette.Dark, QColor(35, 35, 35))\n darkPalette.setColor(QPalette.Text, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.BrightText, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.ButtonText, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.Base, QColor(42, 42, 42))\n darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))\n darkPalette.setColor(QPalette.Shadow, QColor(20, 20, 20))\n darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))\n darkPalette.setColor(QPalette.HighlightedText, QColor(180, 180, 180))\n darkPalette.setColor(QPalette.Link, QColor(56, 252, 196))\n darkPalette.setColor(QPalette.AlternateBase, QColor(66, 66, 66))\n darkPalette.setColor(QPalette.ToolTipBase, QColor(53, 53, 53))\n darkPalette.setColor(QPalette.ToolTipText, QColor(180, 180, 180))\n\n # disabled\n darkPalette.setColor(\n QPalette.Disabled, QPalette.WindowText, QColor(127, 127, 127)\n )\n darkPalette.setColor(\n QPalette.Disabled, QPalette.Text, QColor(127, 127, 127)\n )\n darkPalette.setColor(\n QPalette.Disabled, QPalette.ButtonText, QColor(127, 127, 127)\n )\n darkPalette.setColor(\n QPalette.Disabled, QPalette.Highlight, QColor(80, 80, 80)\n )\n darkPalette.setColor(\n QPalette.Disabled, QPalette.HighlightedText, QColor(127, 127, 127)\n )\n\n app.setPalette(darkPalette)\n self._apply_base_theme(app)\n\n IconSet.current.set_color(QColor(180, 180, 180))","def light_mode(grid: bool = False) -> sns.set_theme:\n if grid:\n return sns.set_theme(style=\"whitegrid\")\n sns.set_theme(style=\"white\")","def dark_mode(grid: bool = False) -> sns.set_theme:\n if grid:\n return sns.set_theme(style=\"darkgrid\")\n return sns.set_theme(style=\"dark\")","def get_stylesheet():\n\n return \"{static_url}/code_pygments/css/{theme}.css\".format(\n static_url=core_config['ASSETS_URL'],\n theme=module_config['PYGMENTS_THEME'])","def changeTheme(id, theme):\n try:\n Dashboard.objects(id=id).update(set__theme=theme)\n except Exception as e:\n print e\n return False\n return \"Dashboard updated successfully.\"","def _get_theme_selected():\n\n try:\n theme_selected = Configuration.objects.filter(group='theme', key='selected')[0]\n theme_name = theme_selected.value\n except:\n theme_name = 'default'\n\n return theme_name","def new_with_dark_light(dark_theme, light_theme):\n theme = {\n \"dark\": Theme(dark_theme),\n \"light\": Theme(light_theme)\n }\n return theme","def themes(self):\n if self._themes is None:\n self.refresh()\n return self._themes","def themes():\r\n for i in os.listdir(_THEMES_PATH):\r\n e = os.path.join(_THEMES_PATH, i)\r\n\r\n if os.path.isdir(e):\r\n if os.path.islink(e):\r\n yield (e, os.readlink(e))\r\n else:\r\n yield (e, None)","def validate_theme(theme):\n try:\n get_theme(theme)\n except KeyError:\n raise FlaskBBCLIError(\"Theme {} not found.\".format(theme), fg=\"red\")","def check_theme(theme: str) -> bool:\n themes = [\"dark\", \"light\"]\n\n return theme in themes","def init(args):\n\n logging.debug(\"Creating source directories\")\n for directory in paths.SOURCE_DIRS:\n os.makedirs(os.path.join(args.dir, directory), exist_ok=True)\n\n logging.debug(\"Installing default theme\")\n default_theme_path = os.path.join(args.dir, paths.THEMES_PATH, defaults.DEFAULT_THEME_NAME)\n os.makedirs(default_theme_path, exist_ok=True)\n with zipfile.ZipFile(resource_filename(__name__, \"resources/\" +\n defaults.DEFAULT_THEME_NAME + \".zip\")) as zipped_theme:\n zipped_theme.extractall(path=default_theme_path)\n\n logging.debug(\"Importing default config file\")\n shutil.copyfile(os.path.join(default_theme_path, paths.EXAMPLE_CFG_FILE),\n os.path.join(args.dir, paths.CFG_FILE))","def inject_sitecustomize(target: pathlib.Path):\n hook = textwrap.dedent(\n f\"\"\"\n import site\n site.addsitedir({os.fspath(target)!r})\n \"\"\"\n ).lstrip()\n target.joinpath('sitecustomize.py').write_text(hook, encoding='utf-8')","def set_skin( self, target, views, skin_name='Site', skin_path='custom, topic, content, generic, control, Images' ):\n self.skin_name = skin_name\n self.skin_path = skin_path\n\n skins = getToolByName( target, 'portal_skins', None )\n if skins is None:\n return\n\n skin_paths = skins.getSkinPaths()\n\n include = ()\n found = 0\n for id, path in skin_paths:\n if id == self.skin_name:\n paths = path.split(', ')\n include = filter( lambda x, cp=paths: x not in cp, views ) + paths\n found = 1\n\n if not found:\n default_path = self.skin_path.split(', ')\n include = views + default_path\n\n skins.manage_properties( add_skin=1, skinname=self.skin_name, skinpath=join(include, ', ') )\n skins.default_skin = self.skin_name","def get_theme_by_uid(theme_uid):\n return get_theme(theme_uid=theme_uid, as_instance=True)","def get_zsh_theme(file: str, logfile: str) -> Union[tuple, bool]:\n current_file = read_file_log(file, logfile)\n m = re_search(r\"ZSH_THEME=\\\".*\", current_file)\n if m is not None:\n theme_var = m.group(0)\n lst = theme_var.split(\"=\")\n theme_name = [s.strip('\"') for s in lst][1]\n return theme_name, theme_var\n return False","def apply_style(self, app):\n\n lightPalette = QPalette()\n\n # base\n lightPalette.setColor(QPalette.WindowText, QColor(0, 0, 0))\n lightPalette.setColor(QPalette.Button, QColor(240, 240, 240))\n lightPalette.setColor(QPalette.Light, QColor(180, 180, 180))\n lightPalette.setColor(QPalette.Midlight, QColor(200, 200, 200))\n lightPalette.setColor(QPalette.Dark, QColor(225, 225, 225))\n lightPalette.setColor(QPalette.Text, QColor(0, 0, 0))\n lightPalette.setColor(QPalette.BrightText, QColor(0, 0, 0))\n lightPalette.setColor(QPalette.ButtonText, QColor(0, 0, 0))\n lightPalette.setColor(QPalette.Base, QColor(237, 237, 237))\n lightPalette.setColor(QPalette.Window, QColor(240, 240, 240))\n lightPalette.setColor(QPalette.Shadow, QColor(20, 20, 20))\n lightPalette.setColor(QPalette.Highlight, QColor(76, 163, 224))\n lightPalette.setColor(QPalette.HighlightedText, QColor(0, 0, 0))\n lightPalette.setColor(QPalette.Link, QColor(0, 162, 232))\n lightPalette.setColor(QPalette.AlternateBase, QColor(225, 225, 225))\n lightPalette.setColor(QPalette.ToolTipBase, QColor(240, 240, 240))\n lightPalette.setColor(QPalette.ToolTipText, QColor(0, 0, 0))\n\n # disabled\n lightPalette.setColor(\n QPalette.Disabled, QPalette.WindowText, QColor(115, 115, 115)\n )\n lightPalette.setColor(\n QPalette.Disabled, QPalette.Text, QColor(115, 115, 115)\n )\n lightPalette.setColor(\n QPalette.Disabled, QPalette.ButtonText, QColor(115, 115, 115)\n )\n lightPalette.setColor(\n QPalette.Disabled, QPalette.Highlight, QColor(190, 190, 190)\n )\n lightPalette.setColor(\n QPalette.Disabled, QPalette.HighlightedText, QColor(115, 115, 115)\n )\n\n app.setPalette(lightPalette)\n\n self._apply_base_theme(app)\n IconSet.current.set_color(QColor(0, 0, 0))","def test_theme_header():\n app = create_ctfd()\n with app.app_context():\n\n with login_as_user(app, \"admin\") as admin:\n css_value = \"\"\".test{}\"\"\"\n css_value2 = \"\"\".test2{}\"\"\"\n r = admin.patch(\"/api/v1/configs\", json={\"theme_header\": css_value})\n assert r.status_code == 200\n assert get_config(\"theme_header\") == css_value\n\n r = admin.get(\"/\")\n assert css_value in r.get_data(as_text=True)\n\n r = admin.patch(\"/api/v1/configs\", json={\"theme_header\": css_value2})\n r = admin.get(\"/\")\n assert css_value2 in r.get_data(as_text=True)\n destroy_ctfd(app)","def get_theme_files(theme, part):\n return SUMMERNOTE_THEME_FILES[theme][part]","def on_load_theme (self):\n\n\t\tif self.has_started:\n\t\t\tself.init_buffers()\n\t\t\tself.redraw_background()\n\t\t\tself.redraw_foreground()","def configure_jinja(theme, src):\n\n # Do not enable autoescape since we actually *do not* want it. Otherwise, we\n # wouldn't be able to integrate html content in the templates properly.\n\n theme_path = os.path.join(src, paths.THEMES_PATH, theme)\n logging.debug(\"Setting up environment at \" + theme_path)\n\n return Environment(loader=FileSystemLoader(theme_path), autoescape=False)","def changeStyle(self, event=None):\n content = self.combo.get()\n try:\n self.style.theme_use(content)\n except tk.TclError as err:\n tk.messagebox.showerror('Error', err)\n else:\n self.theme.set(content)","def get_themes(themes_dir=None):\n if not is_comprehensive_theming_enabled():\n return []\n if themes_dir is None:\n themes_dir = get_theme_base_dirs_unchecked()\n return get_themes_unchecked(themes_dir, settings.PROJECT_ROOT)","def get_theme_base_dirs():\n # Return an empty list if theming is disabled\n if not is_comprehensive_theming_enabled():\n return []\n return get_theme_base_dirs_unchecked()","def get_current_theme():\n # Return None if theming is disabled\n if not is_comprehensive_theming_enabled():\n return None\n\n site_theme = get_current_site_theme()\n if not site_theme:\n return None\n try:\n return Theme(\n name=site_theme.theme_dir_name,\n theme_dir_name=site_theme.theme_dir_name,\n themes_base_dir=get_theme_base_dir(site_theme.theme_dir_name),\n project_root=get_project_root_name()\n )\n except ValueError as error:\n # Log exception message and return None, so that open source theme is used instead\n logger.exception('Theme not found in any of the themes dirs. [%s]', error)\n return None","def toggle_mode(mode: ThemeMode):\n with winreg.OpenKey(\n winreg.HKEY_CURRENT_USER,\n (r'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Themes'\n r'\\Personalize'),\n access=winreg.KEY_ALL_ACCESS) as hkey:\n # Change mode for both apps and system theme to sync mode.\n winreg.SetValueEx(\n hkey, 'AppsUseLightTheme', 0, winreg.REG_DWORD, mode.value)\n winreg.SetValueEx(\n hkey, 'SystemUsesLightTheme', 0, winreg.REG_DWORD, mode.value)","def get_theme(request=None, theme_uid=None, as_instance=False):\n ensure_autodiscover()\n\n if not theme_uid:\n theme_uid = DEFAULT_THEME\n\n Theme = theme_registry.get(theme_uid, None)\n if not Theme:\n raise ThemeDoesNotExist(\n _(\"Theme `{0}` does not exist!\").format(theme_uid)\n )\n\n if as_instance:\n return Theme()\n\n return Theme","def get_theme_base_dir(theme_dir_name, suppress_error=False):\n for themes_dir in get_theme_base_dirs():\n if theme_dir_name in get_theme_dirs(themes_dir):\n return themes_dir\n\n if suppress_error:\n return None\n\n raise ValueError(\n \"Theme '{theme}' not found in any of the following themes dirs, \\nTheme dirs: \\n{dir}\".format(\n theme=theme_dir_name,\n dir=get_theme_base_dirs(),\n ))","def loader(cls, fs):\n\n def load(context=None):\n if context is None:\n context = pilot.context\n name = context.get(\".sys.site.theme\", \"default\")\n\n path = \"{}.json\".format(name)\n try:\n theme = cls.read(fs, path, context=context)\n except Exception as e:\n log.warning(\"unable to read theme file '%s' (%s)\", path, text_type(e))\n\n if name != \"default\":\n return load(\"default\")\n\n log.error(\"unable to load 'default' theme\")\n theme = None\n\n return theme\n\n return load","def list_themes():\n themes = [*os.scandir(os.path.join(CONF_DIR, \"colorschemes\")),\n *os.scandir(os.path.join(MODULE_DIR, \"colorschemes\"))]\n\n return [t for t in themes if os.path.isfile(t.path)]","def get_registered_themes():\n return get_registered_plugins(theme_registry)","def theme_exists(theme_name, themes_dir=None):\n for theme in get_themes(themes_dir=themes_dir):\n if theme.theme_dir_name == theme_name:\n return True\n return False","def compute_theme_directories(self) -> list[str]:\n lm = g.app.loadManager\n table = lm.computeThemeDirectories()[:]\n directory = g.os_path_normslashes(g.app.theme_directory)\n if directory and directory not in table:\n table.insert(0, directory)\n # All entries are known to exist and have normalized slashes.\n return table","def set_markup_style():\n markup_language = '{{ cookiecutter.markup_language }}'\n if markup_language == \"org\":\n to_remove = Path.cwd() / 'README.md'\n to_remove.unlink()\n elif markup_language == \"markdown\":\n to_remove = Path.cwd() / 'README.org'\n to_remove.unlink()","def setHeader(object, event):\n\n request = event.request\n\n if isThemeEnabled(request):\n request.environ['HTTP_X_THEME_ENABLED'] = True","def config_war(alternate=False):\n with lcd(env.projectroot):\n sudo(\"mkdir -p /etc/lagrummet.se\")\n if alternate:\n put(\"manage/sysconf/%(target)s/alternate/lagrummet.se-config.groovy\" % env, \"/etc/lagrummet.se\",\n use_sudo=True)\n else:\n put(\"manage/sysconf/%(target)s/etc/lagrummet.se/lagrummet.se-config.groovy\" % env, \"/etc/lagrummet.se\",\n use_sudo=True)","def _set_theme_seaborn_rcparams(self, rcParams, style, gridweight, context):\n # select grid line width:\n gridweights = {'extra heavy': 1.5,\n 'heavy': 1.1,\n 'medium': 0.8,\n 'light': 0.5, }\n if gridweight is None:\n if context == \"paper\":\n glw = gridweights[\"medium\"]\n else:\n glw = gridweights['extra heavy']\n elif np.isreal(gridweight):\n glw = gridweight\n else:\n glw = gridweights[gridweight]\n\n if style == \"darkgrid\":\n lw = .8 if context == \"paper\" else 1.5\n ax_params = {\"axes.facecolor\": \"#EAEAF2\",\n \"axes.edgecolor\": \"white\",\n \"axes.linewidth\": 0,\n \"axes.grid\": True,\n \"axes.axisbelow\": True,\n \"grid.color\": \"w\",\n \"grid.linestyle\": \"-\",\n \"grid.linewidth\": glw}\n\n elif style == \"whitegrid\":\n lw = 1.0 if context == \"paper\" else 1.7\n ax_params = {\"axes.facecolor\": \"white\",\n \"axes.edgecolor\": \"#CCCCCC\",\n \"axes.linewidth\": lw,\n \"axes.grid\": True,\n \"axes.axisbelow\": True,\n \"grid.color\": \"#DDDDDD\",\n \"grid.linestyle\": \"-\",\n \"grid.linewidth\": glw}\n\n elif style == \"nogrid\":\n ax_params = {\"axes.grid\": False,\n \"axes.facecolor\": \"white\",\n \"axes.edgecolor\": \"black\",\n \"axes.linewidth\": 1}\n\n elif style == \"ticks\":\n ticksize = 3. if context == \"paper\" else 6.\n tickwidth = .5 if context == \"paper\" else 1\n ax_params = {\"axes.grid\": False,\n \"axes.facecolor\": \"white\",\n \"axes.edgecolor\": \"black\",\n \"axes.linewidth\": 1,\n \"xtick.direction\": \"out\",\n \"ytick.direction\": \"out\",\n \"xtick.major.width\": tickwidth,\n \"ytick.major.width\": tickwidth,\n \"xtick.minor.width\": tickwidth,\n \"xtick.minor.width\": tickwidth,\n \"xtick.major.size\": ticksize,\n \"xtick.minor.size\": ticksize / 2,\n \"ytick.major.size\": ticksize,\n \"ytick.minor.size\": ticksize / 2}\n else:\n ax_params = {}\n\n rcParams.update(ax_params)\n\n # Determine the font sizes\n if context == \"talk\":\n font_params = {\"axes.labelsize\": 16,\n \"axes.titlesize\": 19,\n \"xtick.labelsize\": 14,\n \"ytick.labelsize\": 14,\n \"legend.fontsize\": 13,\n }\n\n elif context == \"notebook\":\n font_params = {\"axes.labelsize\": 11,\n \"axes.titlesize\": 12,\n \"xtick.labelsize\": 10,\n \"ytick.labelsize\": 10,\n \"legend.fontsize\": 10,\n }\n\n elif context == \"poster\":\n font_params = {\"axes.labelsize\": 18,\n \"axes.titlesize\": 22,\n \"xtick.labelsize\": 16,\n \"ytick.labelsize\": 16,\n \"legend.fontsize\": 16,\n }\n\n elif context == \"paper\":\n font_params = {\"axes.labelsize\": 8,\n \"axes.titlesize\": 12,\n \"xtick.labelsize\": 8,\n \"ytick.labelsize\": 8,\n \"legend.fontsize\": 8,\n }\n\n rcParams.update(font_params)\n\n # Set other parameters\n rcParams.update({\n \"lines.linewidth\": 1.1 if context == \"paper\" else 1.4,\n \"patch.linewidth\": .1 if context == \"paper\" else .3,\n \"xtick.major.pad\": 3.5 if context == \"paper\" else 7,\n \"ytick.major.pad\": 3.5 if context == \"paper\" else 7, })\n\n rcParams[\"timezone\"] = \"UTC\"\n rcParams[\"patch.antialiased\"] = \"True\"\n rcParams[\"font.family\"] = \"sans-serif\"\n rcParams[\"font.size\"] = \"12.0\"\n rcParams[\"font.serif\"] = [\"Times\", \"Palatino\", \"New Century Schoolbook\",\n \"Bookman\", \"Computer Modern Roman\",\n \"Times New Roman\"]\n rcParams[\"font.sans-serif\"] = [\"Helvetica\", \"Avant Garde\",\n \"Computer Modern Sans serif\", \"Arial\"]\n rcParams[\"axes.color_cycle\"] = [\"#333333\", \"348ABD\", \"7A68A6\", \"A60628\",\n \"467821\", \"CF4457\", \"188487\", \"E24A33\"]\n rcParams[\"legend.fancybox\"] = \"True\"\n rcParams[\"figure.figsize\"] = \"11, 8\"\n rcParams[\"figure.facecolor\"] = \"1.0\"\n rcParams[\"figure.edgecolor\"] = \"0.50\"\n rcParams[\"figure.subplot.hspace\"] = \"0.5\"","def parse(theme_file):\n data = util.read_file_json(theme_file)\n\n if \"wallpaper\" not in data:\n data[\"wallpaper\"] = \"None\"\n\n if \"alpha\" not in data:\n data[\"alpha\"] = \"100\"\n\n # Terminal.sexy format.\n if \"color\" in data:\n data = terminal_sexy_to_wal(data)\n\n return data","def apply_preferences(self, provider):\n\n # it is possible that values have been added to common_dark,\n # common_light!\n # TODO: to be revised once color prefs are no longer floating\n # around disparate plugins\n if self.light:\n self.d.update({k: common_light[k]\n for k in common_light if k not in self.d})\n else:\n self.d.update({k: common_dark[k]\n for k in common_dark if k not in self.d})\n\n font = GPS.Preference(\n \"Src-Editor-Reference-Style\").get().split(\"@\")[0]\n\n def to_pref_str(t):\n \"\"\"Return a variant pref string from a pref tuple\"\"\"\n return \"{}@{}@{}\".format(t[0],\n t[1].to_rgba_string(),\n t[2].to_rgba_string())\n\n def pref_set(gps_pref, val):\n \"\"\"Set a preference; log any errors\"\"\"\n try:\n GPS.Preference(gps_pref).set(val)\n except GPS.Exception:\n # TODO: there is a potential issue here: some preferences\n # do not exist until their plugin is loaded (ispell, isearch);\n # we might need to move the definitions out of the plugins,\n # or reuse existing colors\n pass\n\n # Freeze the preferences\n\n with gps_utils.freeze_prefs():\n # The theme preference\n pref_set(gtk_theme_pref_name, self.d['base_theme'])\n\n # The editor fg and bg\n font = GPS.Preference(\n \"Src-Editor-Reference-Style\").get().split(\"@\")[0]\n GPS.Preference(\n \"Src-Editor-Reference-Style\").set(\"{}@{}@{}\".format(\n font,\n self.d['editor_fg'].to_rgba_string(),\n self.d['editor_bg'].to_rgba_string()))\n\n # Apply the theme preferences\n for key in variant_prefs:\n pref_set(variant_prefs[key], to_pref_str(self.d[key]))\n\n for key in rgb_prefs:\n pref_set(rgb_prefs[key], self.d[key].to_rgba_string())\n\n # Apply the CSS preference\n\n css = css_template.format(\n **{k: self.d[k].to_hex6_string() for k in css_colors}\n ).replace('[', '{').replace(']', '}')\n provider.load_from_data(css)\n GPS.Preference(gtk_css_pref_name).set(css)","def get_group_theme(request):\n\treturn render(request,\"404.html\",{})","def theme_named(self, name):\n for theme in self.themes:\n if theme.get('name', 'Error') == name:\n return theme"],"string":"[\n \"def setup_theme(self):\\r\\n template_conf = self._config.template\\r\\n if isinstance(template_conf, str):\\r\\n # Either a local path or the name of built-in themes\\r\\n if os.path.exists(template_conf):\\r\\n template_conf = {\\r\\n 'name': os.path.split(template_conf)[-1],\\r\\n 'type': 'local',\\r\\n 'path': template_conf\\r\\n }\\r\\n elif template_conf in ['Kepler', 'Galileo']:\\r\\n template_conf = {\\r\\n 'name': template_conf,\\r\\n 'type': 'git',\\r\\n 'url': 'https://github.com/AlanDecode/Maverick-Theme-{}.git'.format(\\r\\n template_conf),\\r\\n 'branch': 'latest'\\r\\n }\\r\\n else:\\r\\n raise TemplateError('Can not found local theme {}'.format(\\r\\n self._config.template))\\r\\n\\r\\n # If its remote theme, clone it to disk first\\r\\n if template_conf['type'] == 'git':\\r\\n template_path = unify_joinpath(self._config._template_dir,\\r\\n template_conf['name'])\\r\\n if not os.path.exists(template_path):\\r\\n self.clone_remote_theme(self._config._template_dir, template_conf)\\r\\n template_conf['type'] = 'local'\\r\\n template_conf['path'] = template_path\\r\\n\\r\\n sys.path.insert(0, os.path.split(template_conf['path'])[0])\\r\\n\\r\\n # handle deps for theme\\r\\n template_dep_file = unify_joinpath(template_conf['path'],\\r\\n 'requirements.txt')\\r\\n if os.path.exists(template_dep_file) and os.path.isfile(template_dep_file):\\r\\n try:\\r\\n run('pip install -r %s' % template_dep_file, '.')\\r\\n except Exception:\\r\\n raise TemplateError('Can not install dependencies for theme.')\\r\\n\\r\\n from importlib import import_module\\r\\n self._template = import_module(template_conf['name'])\",\n \"def use_my_theme():\\n # register and enable the theme\\n alt.themes.register(\\\"my_theme\\\", my_theme)\\n alt.themes.enable(\\\"my_theme\\\")\",\n \"def use_my_theme():\\n # register and enable the theme\\n alt.themes.register(\\\"my_theme\\\", my_theme)\\n alt.themes.enable(\\\"my_theme\\\")\",\n \"def setup_theme(app):\\r\\n theme = app.config['THEME']\\r\\n app.template_folder = os.path.join('themes', theme, 'templates')\\r\\n app.static_folder = os.path.join('themes', theme, 'static')\",\n \"def theme(self, theme):\\n\\n self._theme = theme\",\n \"def set_terminal_theme(theme: ApplicationTheme):\\n # Change current mode.\\n path = theme.path\\n try:\\n with open(path, 'r', encoding='utf-8') as f:\\n pass\\n except FileNotFoundError:\\n path = theme.windows_path\\n try:\\n with open(path, 'r+', encoding='utf-8') as f:\\n settings_string = ''\\n key = theme.keys.split(theme.settings_delimiter)[-1]\\n toggled_theme_name = theme.names[theme.mode == ThemeMode.light]\\n\\n # Search for line with key.\\n current_theme_name = ''\\n for line in f:\\n if not current_theme_name and key in line and any(\\n name in line for name in theme.names\\n ):\\n # Replace current theme with toggled theme.\\n # Requires that theme name is either dark or\\n # light theme. Else keep \\\"invalid\\\" theme rather\\n # than raising an exception.\\n current_theme_name = theme.names[theme.light_name in line]\\n line = line.replace(current_theme_name, toggled_theme_name)\\n settings_string += line\\n if current_theme_name:\\n f.seek(0)\\n f.truncate()\\n # Write new settings to file.\\n f.write(settings_string)\\n\\n print('Set Terminal theme to:', toggled_theme_name)\\n else:\\n raise ValueError(\\n 'Failed to find valid current theme for Terminal.')\\n except Exception as e:\\n print('Failed to set Terminal theme.')\\n print(repr(e))\",\n \"async def set_configurator_theme(self, request, theme):\\n\\n if theme in defaults.KERNEL_CONFIGURATOR_THEMES:\\n self._configurator_theme = theme\\n request.ret(READY)\\n else:\\n request.ret(KERNEL_CONFIGURATOR_THEME_DOES_NOT_EXIST)\",\n \"def enable_theme():\\r\\n # Workaround for setting THEME_NAME to an empty\\r\\n # string which is the default due to this ansible\\r\\n # bug: https://github.com/ansible/ansible/issues/4812\\r\\n if settings.THEME_NAME == \\\"\\\":\\r\\n settings.THEME_NAME = None\\r\\n return\\r\\n\\r\\n assert settings.FEATURES['USE_CUSTOM_THEME']\\r\\n settings.FAVICON_PATH = 'themes/{name}/images/favicon.ico'.format(\\r\\n name=settings.THEME_NAME\\r\\n )\\r\\n\\r\\n # Calculate the location of the theme's files\\r\\n theme_root = settings.ENV_ROOT / \\\"themes\\\" / settings.THEME_NAME\\r\\n\\r\\n # Include the theme's templates in the template search paths\\r\\n settings.TEMPLATE_DIRS.insert(0, theme_root / 'templates')\\r\\n edxmako.paths.add_lookup('main', theme_root / 'templates', prepend=True)\\r\\n\\r\\n # Namespace the theme's static files to 'themes/<theme_name>' to\\r\\n # avoid collisions with default edX static files\\r\\n settings.STATICFILES_DIRS.append(\\r\\n (u'themes/{}'.format(settings.THEME_NAME), theme_root / 'static')\\r\\n )\",\n \"def setup_theme():\\n os.system('sudo apt install arc-theme')\\n\\n output = \\\"{padding}{mark} Installing theme...\\\"\\n print(output.format(padding=LEFT_PADDING, mark=BALLOT_MARK))\",\n \"def propeller_theme_url():\\n return theme_url()\",\n \"def theme(list_themes: bool = False, copy_theme:bool = False, theme:str = \\\"\\\"):\\n if not theme:\\n theme = \\\"dimension\\\"\\n\\n if copy_theme:\\n if os.path.exists(os.path.join(THEMES_FOLDER, theme)): # If the theme exists in the themes folder\\n try: # Try to copy the theme to ./<theme>\\n shutil.copytree(os.path.join(THEMES_FOLDER, theme), theme)\\n except FileExistsError: # If a folder exists at ./<theme> remove and then re-copy\\n shutil.rmtree(theme)\\n shutil.copytree(os.path.join(THEMES_FOLDER, theme), theme)\\n print(f\\\"Copied {os.path.join(THEMES_FOLDER, theme)} to .{os.sep}{theme}\\\")\\n else: # Theme could not be found\\n print(f\\\"Theme {theme} not found and was unable to be copied\\\")\\n\\n if list_themes:\\n # Get local themes\\n print(f\\\"\\\\nAvailable local themes\\\\n{'='*22}\\\")\\n for theme in os.listdir(THEMES_FOLDER):\\n if not theme == \\\"remotes.yml\\\":\\n print(f\\\" - {theme}\\\")\\n\\n # Get remote themes\\n print(f\\\"\\\\nAvailable remote themes\\\\n{'='*23}\\\")\\n import yaml\\n with open(os.path.join(THEMES_FOLDER, \\\"remotes.yml\\\")) as remote_themes:\\n for theme in yaml.safe_load(remote_themes):\\n print(f\\\" - {theme}\\\")\\n print() # empty newline after list\",\n \"def apply_theme(self, ax):\\n pass\",\n \"def get_theme(self) -> str:\\n return self.theme or self.account.theme\",\n \"def themes(self, themes):\\n\\n self._themes = themes\",\n \"def bootstrap_theme_url():\\n return theme_url()\",\n \"def get_html_theme_path():\\n theme_path = os.path.abspath(Path(__file__).parent)\\n return theme_path\",\n \"def load_theme_values(self): \\n pass\",\n \"async def update_theme(q: Q):\\n\\n copy_expando(q.args, q.client)\\n\\n if q.client.theme_dark:\\n logging.info('Updating theme to dark mode')\\n\\n q.client.path_architecture = q.app.paths_architecture['dark']\\n\\n q.page['meta'].theme = 'neon'\\n q.page['header'].icon_color = 'black'\\n else:\\n logging.info('Updating theme to light mode')\\n\\n q.client.path_architecture = q.app.paths_architecture['light']\\n\\n q.page['meta'].theme = 'light'\\n q.page['header'].icon_color = '#CDDD38'\\n\\n q.page['misc'].items[3].toggle.value = q.client.theme_dark\\n\\n if q.client['#'] == 'home':\\n q.page['home'].items[2].text.content = f'''<center>\\n <img src=\\\"{q.client.path_architecture}\\\" width=\\\"540px\\\"></center>'''\\n elif q.client['#'] == 'resources':\\n q.page['code_examples'] = cards.code_examples(\\n code_function=q.client.code_function,\\n theme_dark=q.client.theme_dark\\n )\\n\\n await q.page.save()\",\n \"def my_theme() -> Dict[str, Any]:\\n return {\\n \\\"config\\\": {\\n \\\"view\\\": {\\\"height\\\": 400, \\\"width\\\": 600},\\n \\\"legend\\\": {\\\"titleFontSize\\\": 20, \\\"labelFontSize\\\": 16},\\n \\\"axis\\\": {\\\"grid\\\": False, \\\"labelFontSize\\\": 16, \\\"titleFontSize\\\": 20},\\n \\\"header\\\": {\\\"titleFontSize\\\": 22, \\\"labelFontSize\\\": 18},\\n \\\"background\\\": \\\"white\\\",\\n }\\n }\",\n \"async def _theme_heist(self, ctx, theme):\\r\\n theme = theme.title()\\r\\n guild = ctx.guild\\r\\n\\r\\n if not os.path.exists(str(bundled_data_path(self)) + \\\"/{}.txt\\\".format(theme)):\\r\\n themes = [os.path.join(x).replace('.txt', '')\\r\\n for x in os.listdir(str(bundled_data_path(self))) if x.endswith(\\\".txt\\\")]\\r\\n msg = (\\\"I could not find a theme with that name. Available Themes:\\\"\\r\\n \\\"```\\\\n{}```\\\".format('\\\\n'.join(themes)))\\r\\n else:\\r\\n msg = await self.thief.theme_loader(guild, theme)\\r\\n\\r\\n await ctx.send(msg)\",\n \"def new_theme(ctx, **defaults):\\n from .quickstart import theme_quickstart\\n\\n project = ctx.get_project(silent=True)\\n theme_quickstart(defaults, project=project)\",\n \"def __init__(self,_dir,_theme='skyblue'):\\n self.dir=_dir\\n self.theme = _theme\",\n \"def importTheme(context):\\n\\n data = context.readDataFile('theme.xml')\\n if not data:\\n return\\n\\n logger = context.getLogger('plone.app.theming.exportimport')\\n\\n tree = etree.fromstring(data)\\n\\n themeName = tree.find(\\\"name\\\")\\n themeEnabled = tree.find(\\\"enabled\\\")\\n\\n if themeName is not None:\\n themeName = themeName.text.strip()\\n themeInfo = None\\n\\n allThemes = getAvailableThemes()\\n for info in allThemes:\\n if info.__name__.lower() == themeName.lower():\\n themeInfo = info\\n break\\n\\n if themeInfo is None:\\n raise ValueError(\\\"Theme %s is not available\\\" % themeName)\\n\\n applyTheme(themeInfo)\\n logger.info('Theme %s applied' % themeName)\\n\\n settings = getUtility(IRegistry).forInterface(IThemeSettings, False)\\n\\n if themeEnabled is not None:\\n themeEnabled = themeEnabled.text.strip().lower()\\n\\n if themeEnabled in (\\\"y\\\", \\\"yes\\\", \\\"true\\\", \\\"t\\\", \\\"1\\\", \\\"on\\\",):\\n settings.enabled = True\\n logger.info('Theme enabled')\\n elif themeEnabled in (\\\"n\\\", \\\"no\\\", \\\"false\\\", \\\"f\\\", \\\"0\\\", \\\"off\\\",):\\n settings.enabled = False\\n logger.info('Theme disabled')\\n else:\\n raise ValueError(\\\"%s is not a valid value for <enabled />\\\" % themeEnabled)\",\n \"def loadTheme(self, name = \\\"default\\\"):\\n themes = os.listdir(\\\"themes\\\")\\n if name in themes:\\n self.templates = {}\\n files = glob.glob(\\\"themes/%s/*.tpl\\\" % name)\\n for file in files:\\n f = open(file)\\n data = \\\"\\\\n\\\".join(f.readlines())\\n f.close()\\n\\n key = file.replace(\\\".tpl\\\", \\\"\\\").split(os.path.sep)[-1]\\n self.templates[key] = data\",\n \"def set_theme(self, theme_id, is_custom):\\n\\t\\tdata = {\\\"theme_id\\\": theme_id, \\\"is_custom\\\":is_custom}\\n\\t\\tresponse = self.client.post(self._endpoint + \\\"/theme\\\", content=data)\\n\\t\\treturn bool(response.json[\\\"success\\\"])\",\n \"def change_theme(self):\\n # get the QApplication instance, or crash if not set\\n app = QtWidgets.QApplication.instance()\\n if app is None:\\n raise RuntimeError(\\\"No Qt Application found.\\\")\\n\\n if self.darkCheckBox.isChecked():\\n app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())\\n else:\\n app.setStyleSheet(\\\"\\\")\",\n \"def change_theme(self):\\n # get the QApplication instance, or crash if not set\\n app = QApplication.instance()\\n if app is None:\\n raise RuntimeError(\\\"No Qt Application found.\\\")\\n\\n if self.darkCheckBox.isChecked():\\n app.setStyleSheet(qdarkstyle.load_stylesheet_pyqt5())\\n else:\\n app.setStyleSheet(\\\"\\\")\",\n \"def updateTheme(self):\\n self.myUpdate(stateDict=None)\",\n \"def theme_paths_loader(app):\\n theme_paths = app.config.get('THEME_PATHS', ())\\n if isinstance(theme_paths, str):\\n theme_paths = [p.strip() for p in theme_paths.split(';')]\\n return starchain(load_themes_from(path) for path in theme_paths)\",\n \"def my_theme() -> Dict[str, Any]:\\n font = \\\"Roboto\\\"\\n return {\\n \\\"config\\\": {\\n \\\"view\\\": {\\\"height\\\": 400, \\\"width\\\": 600},\\n \\\"legend\\\": {\\n \\\"titleFontSize\\\": 20,\\n \\\"labelFontSize\\\": 16,\\n \\\"labelFont\\\": font,\\n \\\"titleFont\\\": font,\\n },\\n \\\"axis\\\": {\\n \\\"grid\\\": False,\\n \\\"labelFontSize\\\": 16,\\n \\\"titleFontSize\\\": 20,\\n \\\"labelFont\\\": font,\\n \\\"titleFont\\\": font,\\n },\\n \\\"header\\\": {\\n \\\"titleFontSize\\\": 22,\\n \\\"labelFontSize\\\": 18,\\n \\\"titleFont\\\": font,\\n \\\"labelFont\\\": font,\\n },\\n \\\"background\\\": \\\"white\\\",\\n }\\n }\",\n \"def get_html_theme_path():\\n cur_dir = path.abspath(path.dirname(path.dirname(__file__)))\\n return cur_dir\",\n \"def _apply_base_theme(self, app):\\n\\n app.setStyle(\\\"Fusion\\\")\\n\\n with open(self._STYLESHEET) as stylesheet:\\n app.setStyleSheet(stylesheet.read())\",\n \"def __init__(self, theme_dir):\\n\\n if not os.path.isdir(theme_dir): \\n print(\\\"%s not a valid directory, please check!\\\" % theme_dir, file=sys.stderr)\\n sys.exit(1)\\n for dirname, dirnames, filenames in os.walk(theme_dir):\\n for subdirname in dirnames:\\n full_path = os.path.join(dirname, subdirname)\\n self.theme_dir.append(full_path)\\n print(\\\"read theme %s\\\" % full_path, file=sys.stdout)\\n print(\\\"all themes loaded!\\\", file=sys.stdout)\",\n \"def file(input_file):\\n theme_name = \\\".\\\".join((input_file, \\\"json\\\"))\\n user_theme_file = os.path.join(CONF_DIR, \\\"colorschemes\\\", theme_name)\\n theme_file = os.path.join(MODULE_DIR, \\\"colorschemes\\\", theme_name)\\n\\n util.create_dir(os.path.dirname(user_theme_file))\\n\\n # Find the theme file.\\n if os.path.isfile(input_file):\\n theme_file = input_file\\n\\n elif os.path.isfile(user_theme_file):\\n theme_file = user_theme_file\\n\\n elif input_file == \\\"random\\\":\\n themes = [theme.path for theme in list_themes()]\\n random.shuffle(themes)\\n theme_file = themes[0]\\n\\n # Parse the theme file.\\n if os.path.isfile(theme_file):\\n logging.info(\\\"Set theme to \\\\033[1;37m%s\\\\033[0m.\\\",\\n os.path.basename(theme_file))\\n return parse(theme_file)\\n\\n else:\\n logging.error(\\\"No colorscheme file found.\\\")\\n sys.exit(1)\",\n \"def update_theme_css():\\n\\n theme_file = os.path.join('app', 'static', 'app', 'css', 'theme.scss')\\n try:\\n Path(theme_file).touch()\\n logger.info(\\\"刷新{}缓存\\\".format(theme_file))\\n except:\\n logger.warning(\\\"无法访问{}\\\".format(theme_file))\",\n \"def main(themes):\\n # Get toggled mode based on current system mode.\\n toggled_mode = get_toggled_mode(get_current_mode())\\n print('\\\\nSetting themes...')\\n\\n for theme in themes:\\n # Set toggled mode.\\n theme.mode = toggled_mode\\n theme.toggle_callback(theme)\\n if IS_WINDOWS:\\n print(f'Setting system theme to: {toggled_mode.name}')\\n toggle_mode(toggled_mode)\\n print()\",\n \"def theme_template_base(context):\\n template_path = os.path.join(settings.THEME_NAME, 'theme.html')\\n return {'THEME_TEMPLATE': template_path}\",\n \"def theme_name(context):\\n return {'THEME_NAME': settings.THEME_NAME}\",\n \"def init(theme=\\\"dimension\\\", name=\\\"John Doe\\\"):\\n print(f\\\"Generating site at {os.path.abspath(name)}\\\")\\n\\n shutil.copytree(os.path.join(os.path.dirname(__file__), \\\"example_site\\\"), os.path.abspath(name))\\n\\n # Generate initial config.yml file\\n with open(os.path.join(name, \\\"config.yml\\\"), \\\"w+\\\") as config_file:\\n config_file.write(f\\\"# See https://ezcv.readthedocs.io for documentation\\\\nname: {name}\\\\ntheme: {theme}\\\\nresume: false\\\")\\n\\n if theme != \\\"dimension\\\":\\n # Check if theme is remote theme, and download it if it is\\n \\n remote_themes = get_remote_themes()\\n if remote_themes.get(theme, False):\\n original_directory = os.path.abspath(os.getcwd()) # Store CWD\\n os.chdir(os.path.abspath(name)) # Go into new site folder\\n setup_remote_theme(theme, remote_themes[theme]) # Download theme \\n os.chdir(original_directory) # Navigate back to original cwd\\n\\n print(f\\\"Site generated and is available at {os.path.abspath(name)}\\\")\",\n \"async def get_configurator_themes(self, request):\\n\\n request.ret(defaults.KERNEL_CONFIGURATOR_THEMES)\",\n \"def dark_theme(self):\\n if self.actionDark_Theme.isChecked():\\n QApplication.setStyle(QStyleFactory.create(\\\"Fusion\\\"))\\n palette = QPalette()\\n palette.setColor(QPalette.Window, QColor(53, 53, 53))\\n palette.setColor(QPalette.WindowText, Qt.white)\\n palette.setColor(QPalette.Base, QColor(15, 15, 15))\\n palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53))\\n palette.setColor(QPalette.ToolTipBase, Qt.white)\\n palette.setColor(QPalette.ToolTipText, Qt.white)\\n palette.setColor(QPalette.Text, Qt.white)\\n palette.setColor(QPalette.Button, QColor(53, 53, 53))\\n palette.setColor(QPalette.ButtonText, Qt.white)\\n palette.setColor(QPalette.BrightText, Qt.red)\\n palette.setColor(QPalette.Highlight, QColor(0, 24, 193).lighter())\\n palette.setColor(QPalette.HighlightedText, Qt.black)\\n palette.setColor(QPalette.Disabled, QPalette.Text, Qt.darkGray)\\n palette.setColor(\\n QPalette.Disabled, QPalette.ButtonText, Qt.darkGray)\\n app.setPalette(palette)\\n return\\n\\n app.setPalette(self.defaultPalette)\",\n \"def get(self):\\n themes = list(model.Theme.all().order('-start').run())\\n if not themes:\\n default_theme = model.Theme(display_name=\\\"Beautiful\\\")\\n default_theme.start = default_theme.created\\n default_theme.put()\\n themes = [default_theme]\\n self.send_success(themes, jsonkind=\\\"photohunt#themes\\\")\",\n \"def theme_change(request):\\n if request.method == \\\"POST\\\":\\n form = ThemeForm(request.POST, instance=request.user.settings)\\n if form.is_valid():\\n form.save()\\n return home(request, \\\"Theme Changed Successfully\\\")\\n else:\\n form = ThemeForm(instance=request.user.settings)\\n \\n ctx = _make_context(request, \\\"theme_form\\\", form)\\n \\n return TemplateResponse(request, \\\"users/index.html\\\", ctx)\",\n \"def makeThemeDrawer(self,node):\\n themeDrawer = self.makeDrawer(node)\\n themeDrawer.getRoot().setTexture(self.image)\\n return themeDrawer\",\n \"def add_theme(themename,username):\\n cursor = conn.cursor()\\n cursor.execute(\\\"INSERT INTO theme(theme_name,username) VALUES (%s,%s);\\\",\\n (themename,username))\\n conn.commit()\\n print(\\\"Theme saved.\\\")\",\n \"def set_group_theme(request):\\n\\treturn render(request,\\\"404.html\\\",{})\",\n \"def refresh(self):\\n self._themes = {}\\n for theme in starchain(ldr(self.app) for ldr in self.loaders):\\n if self.valid_app_id(theme.application):\\n self.themes[theme.identifier] = theme\\n self.register_theme_assets()\",\n \"def setWidget(self, widget: QtWidgets.QWidget):\\n super().setWidget(widget)\\n if globalstuff.theme == 'dark':\\n w = self.widget()\\n w.setPalette(globalstuff.textpal)\\n if hasattr(w, 'TreeWidget'):\\n w.TreeWidget.setStyleSheet(globalstuff.treeqss)\",\n \"def dummy_loader(cls, context):\\n log.warning(\\\"theme is not set -- add a theme value to your site settings\\\")\\n theme_json = DEFAULT\\n hasher = hashlib.md5()\\n hasher.update(theme_json.encode(\\\"utf-8\\\"))\\n theme_hash = hasher.hexdigest()\\n\\n theme_data = json.loads(theme_json)\\n\\n theme_data[\\\"_moya\\\"] = {\\\"path\\\": None, \\\"hash\\\": theme_hash}\\n return theme_data\",\n \"async def _themelist_heist(self, ctx):\\r\\n themes = [os.path.join(x).replace('.txt', '')\\r\\n for x in os.listdir(str(bundled_data_path(self))) if x.endswith(\\\".txt\\\")]\\r\\n if len(themes) > 30:\\r\\n themes = themes[:30]\\r\\n await ctx.send(\\\"Available Themes:```\\\\n{}```\\\".format('\\\\n'.join(themes)))\",\n \"def themeinfo(self):\\n return theme_registry.find(self.theme)\",\n \"def path_for(filename):\\n if settings.value(Key.Theme) == Themes.Light.value:\\n return (IMAGES_PATH / Themes.Light.value / filename).as_posix()\\n return (IMAGES_PATH / Themes.Dark.value / filename).as_posix()\",\n \"def onStartup(event):\\n\\n plugins = getPlugins()\\n\\n for themeDirectory in iterDirectoriesOfType(THEME_RESOURCE_NAME):\\n if themeDirectory.directory in reload_paths: # only for sauna.reload!\\n pluginSettings = getPluginSettings(themeDirectory, plugins)\\n\\n for name, plugin in plugins:\\n plugin.onDiscovery(themeDirectory.__name__,\\n pluginSettings[name],\\n pluginSettings)\",\n \"def test_theme_fallback_config():\\n\\n class ThemeFallbackConfig(TestingConfig):\\n THEME_FALLBACK = False\\n\\n app = create_ctfd(config=ThemeFallbackConfig)\\n # Make an empty theme\\n try:\\n os.mkdir(os.path.join(app.root_path, \\\"themes\\\", \\\"foo_fallback\\\"))\\n except OSError:\\n pass\\n\\n # Without theme fallback, missing themes should disappear\\n with app.app_context():\\n app.config[\\\"THEME_FALLBACK\\\"] = False\\n set_config(\\\"ctf_theme\\\", \\\"foo_fallback\\\")\\n assert app.config[\\\"THEME_FALLBACK\\\"] == False\\n with app.test_client() as client:\\n try:\\n r = client.get(\\\"/\\\")\\n except TemplateNotFound:\\n pass\\n try:\\n r = client.get(\\\"/themes/foo_fallback/static/js/pages/main.dev.js\\\")\\n except TemplateNotFound:\\n pass\\n destroy_ctfd(app)\\n\\n app = create_ctfd()\\n with app.app_context():\\n set_config(\\\"ctf_theme\\\", \\\"foo_fallback\\\")\\n assert app.config[\\\"THEME_FALLBACK\\\"] == True\\n with app.test_client() as client:\\n r = client.get(\\\"/\\\")\\n assert r.status_code == 200\\n r = client.get(\\\"/themes/foo_fallback/static/js/pages/main.dev.js\\\")\\n assert r.status_code == 200\\n destroy_ctfd(app)\\n\\n # Remove empty theme\\n os.rmdir(os.path.join(app.root_path, \\\"themes\\\", \\\"foo_fallback\\\"))\",\n \"def create(data):\\n \\n # create theme\\n return Theme(\\n theme_id = data['id'],\\n parent_id = data.get('parent_id', None),\\n name = data['name'])\",\n \"def get_current_site_theme():\\n # Return None if theming is disabled\\n if not is_comprehensive_theming_enabled():\\n return None\\n\\n request = get_current_request()\\n if not request:\\n return None\\n return getattr(request, 'site_theme', None)\",\n \"def read_theme_file(theme_file):\\n # open and read the theme file\\n with open(theme_file) as theme:\\n theme_definition = theme.read()\\n\\n # Create a dict and separate by newlines\\n theme_dictionary = dict()\\n theme_definition = theme_definition.split('\\\\n')\\n\\n # Loop through lines and create a dict containing keyword and color\\n for definition in theme_definition:\\n theme_pattern, theme_color = definition.split(': ')\\n theme_dictionary[theme_pattern] = theme_color\\n return theme_dictionary\",\n \"def packaged_themes_loader(app):\\n themes_path = os.path.join(app.root_path, 'themes')\\n if os.path.exists(themes_path):\\n return load_themes_from(themes_path)\\n else:\\n return ()\",\n \"def setup(theme='DarkAmber'):\\r\\n sg.theme(theme)\\r\\n\\r\\n headline_font = ('Arial bold', 20)\\r\\n font = ('Arial', 20)\\r\\n warning_font = ('Arial bold', 14)\\r\\n button_font = ('Arial', 14)\\r\\n\\r\\n return headline_font, font, warning_font, button_font\",\n \"def apply_style(self, app):\\n\\n darkPalette = QPalette()\\n\\n # base\\n darkPalette.setColor(QPalette.WindowText, QColor(180, 180, 180))\\n darkPalette.setColor(QPalette.Button, QColor(53, 53, 53))\\n darkPalette.setColor(QPalette.Light, QColor(180, 180, 180))\\n darkPalette.setColor(QPalette.Midlight, QColor(90, 90, 90))\\n darkPalette.setColor(QPalette.Dark, QColor(35, 35, 35))\\n darkPalette.setColor(QPalette.Text, QColor(180, 180, 180))\\n darkPalette.setColor(QPalette.BrightText, QColor(180, 180, 180))\\n darkPalette.setColor(QPalette.ButtonText, QColor(180, 180, 180))\\n darkPalette.setColor(QPalette.Base, QColor(42, 42, 42))\\n darkPalette.setColor(QPalette.Window, QColor(53, 53, 53))\\n darkPalette.setColor(QPalette.Shadow, QColor(20, 20, 20))\\n darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218))\\n darkPalette.setColor(QPalette.HighlightedText, QColor(180, 180, 180))\\n darkPalette.setColor(QPalette.Link, QColor(56, 252, 196))\\n darkPalette.setColor(QPalette.AlternateBase, QColor(66, 66, 66))\\n darkPalette.setColor(QPalette.ToolTipBase, QColor(53, 53, 53))\\n darkPalette.setColor(QPalette.ToolTipText, QColor(180, 180, 180))\\n\\n # disabled\\n darkPalette.setColor(\\n QPalette.Disabled, QPalette.WindowText, QColor(127, 127, 127)\\n )\\n darkPalette.setColor(\\n QPalette.Disabled, QPalette.Text, QColor(127, 127, 127)\\n )\\n darkPalette.setColor(\\n QPalette.Disabled, QPalette.ButtonText, QColor(127, 127, 127)\\n )\\n darkPalette.setColor(\\n QPalette.Disabled, QPalette.Highlight, QColor(80, 80, 80)\\n )\\n darkPalette.setColor(\\n QPalette.Disabled, QPalette.HighlightedText, QColor(127, 127, 127)\\n )\\n\\n app.setPalette(darkPalette)\\n self._apply_base_theme(app)\\n\\n IconSet.current.set_color(QColor(180, 180, 180))\",\n \"def light_mode(grid: bool = False) -> sns.set_theme:\\n if grid:\\n return sns.set_theme(style=\\\"whitegrid\\\")\\n sns.set_theme(style=\\\"white\\\")\",\n \"def dark_mode(grid: bool = False) -> sns.set_theme:\\n if grid:\\n return sns.set_theme(style=\\\"darkgrid\\\")\\n return sns.set_theme(style=\\\"dark\\\")\",\n \"def get_stylesheet():\\n\\n return \\\"{static_url}/code_pygments/css/{theme}.css\\\".format(\\n static_url=core_config['ASSETS_URL'],\\n theme=module_config['PYGMENTS_THEME'])\",\n \"def changeTheme(id, theme):\\n try:\\n Dashboard.objects(id=id).update(set__theme=theme)\\n except Exception as e:\\n print e\\n return False\\n return \\\"Dashboard updated successfully.\\\"\",\n \"def _get_theme_selected():\\n\\n try:\\n theme_selected = Configuration.objects.filter(group='theme', key='selected')[0]\\n theme_name = theme_selected.value\\n except:\\n theme_name = 'default'\\n\\n return theme_name\",\n \"def new_with_dark_light(dark_theme, light_theme):\\n theme = {\\n \\\"dark\\\": Theme(dark_theme),\\n \\\"light\\\": Theme(light_theme)\\n }\\n return theme\",\n \"def themes(self):\\n if self._themes is None:\\n self.refresh()\\n return self._themes\",\n \"def themes():\\r\\n for i in os.listdir(_THEMES_PATH):\\r\\n e = os.path.join(_THEMES_PATH, i)\\r\\n\\r\\n if os.path.isdir(e):\\r\\n if os.path.islink(e):\\r\\n yield (e, os.readlink(e))\\r\\n else:\\r\\n yield (e, None)\",\n \"def validate_theme(theme):\\n try:\\n get_theme(theme)\\n except KeyError:\\n raise FlaskBBCLIError(\\\"Theme {} not found.\\\".format(theme), fg=\\\"red\\\")\",\n \"def check_theme(theme: str) -> bool:\\n themes = [\\\"dark\\\", \\\"light\\\"]\\n\\n return theme in themes\",\n \"def init(args):\\n\\n logging.debug(\\\"Creating source directories\\\")\\n for directory in paths.SOURCE_DIRS:\\n os.makedirs(os.path.join(args.dir, directory), exist_ok=True)\\n\\n logging.debug(\\\"Installing default theme\\\")\\n default_theme_path = os.path.join(args.dir, paths.THEMES_PATH, defaults.DEFAULT_THEME_NAME)\\n os.makedirs(default_theme_path, exist_ok=True)\\n with zipfile.ZipFile(resource_filename(__name__, \\\"resources/\\\" +\\n defaults.DEFAULT_THEME_NAME + \\\".zip\\\")) as zipped_theme:\\n zipped_theme.extractall(path=default_theme_path)\\n\\n logging.debug(\\\"Importing default config file\\\")\\n shutil.copyfile(os.path.join(default_theme_path, paths.EXAMPLE_CFG_FILE),\\n os.path.join(args.dir, paths.CFG_FILE))\",\n \"def inject_sitecustomize(target: pathlib.Path):\\n hook = textwrap.dedent(\\n f\\\"\\\"\\\"\\n import site\\n site.addsitedir({os.fspath(target)!r})\\n \\\"\\\"\\\"\\n ).lstrip()\\n target.joinpath('sitecustomize.py').write_text(hook, encoding='utf-8')\",\n \"def set_skin( self, target, views, skin_name='Site', skin_path='custom, topic, content, generic, control, Images' ):\\n self.skin_name = skin_name\\n self.skin_path = skin_path\\n\\n skins = getToolByName( target, 'portal_skins', None )\\n if skins is None:\\n return\\n\\n skin_paths = skins.getSkinPaths()\\n\\n include = ()\\n found = 0\\n for id, path in skin_paths:\\n if id == self.skin_name:\\n paths = path.split(', ')\\n include = filter( lambda x, cp=paths: x not in cp, views ) + paths\\n found = 1\\n\\n if not found:\\n default_path = self.skin_path.split(', ')\\n include = views + default_path\\n\\n skins.manage_properties( add_skin=1, skinname=self.skin_name, skinpath=join(include, ', ') )\\n skins.default_skin = self.skin_name\",\n \"def get_theme_by_uid(theme_uid):\\n return get_theme(theme_uid=theme_uid, as_instance=True)\",\n \"def get_zsh_theme(file: str, logfile: str) -> Union[tuple, bool]:\\n current_file = read_file_log(file, logfile)\\n m = re_search(r\\\"ZSH_THEME=\\\\\\\".*\\\", current_file)\\n if m is not None:\\n theme_var = m.group(0)\\n lst = theme_var.split(\\\"=\\\")\\n theme_name = [s.strip('\\\"') for s in lst][1]\\n return theme_name, theme_var\\n return False\",\n \"def apply_style(self, app):\\n\\n lightPalette = QPalette()\\n\\n # base\\n lightPalette.setColor(QPalette.WindowText, QColor(0, 0, 0))\\n lightPalette.setColor(QPalette.Button, QColor(240, 240, 240))\\n lightPalette.setColor(QPalette.Light, QColor(180, 180, 180))\\n lightPalette.setColor(QPalette.Midlight, QColor(200, 200, 200))\\n lightPalette.setColor(QPalette.Dark, QColor(225, 225, 225))\\n lightPalette.setColor(QPalette.Text, QColor(0, 0, 0))\\n lightPalette.setColor(QPalette.BrightText, QColor(0, 0, 0))\\n lightPalette.setColor(QPalette.ButtonText, QColor(0, 0, 0))\\n lightPalette.setColor(QPalette.Base, QColor(237, 237, 237))\\n lightPalette.setColor(QPalette.Window, QColor(240, 240, 240))\\n lightPalette.setColor(QPalette.Shadow, QColor(20, 20, 20))\\n lightPalette.setColor(QPalette.Highlight, QColor(76, 163, 224))\\n lightPalette.setColor(QPalette.HighlightedText, QColor(0, 0, 0))\\n lightPalette.setColor(QPalette.Link, QColor(0, 162, 232))\\n lightPalette.setColor(QPalette.AlternateBase, QColor(225, 225, 225))\\n lightPalette.setColor(QPalette.ToolTipBase, QColor(240, 240, 240))\\n lightPalette.setColor(QPalette.ToolTipText, QColor(0, 0, 0))\\n\\n # disabled\\n lightPalette.setColor(\\n QPalette.Disabled, QPalette.WindowText, QColor(115, 115, 115)\\n )\\n lightPalette.setColor(\\n QPalette.Disabled, QPalette.Text, QColor(115, 115, 115)\\n )\\n lightPalette.setColor(\\n QPalette.Disabled, QPalette.ButtonText, QColor(115, 115, 115)\\n )\\n lightPalette.setColor(\\n QPalette.Disabled, QPalette.Highlight, QColor(190, 190, 190)\\n )\\n lightPalette.setColor(\\n QPalette.Disabled, QPalette.HighlightedText, QColor(115, 115, 115)\\n )\\n\\n app.setPalette(lightPalette)\\n\\n self._apply_base_theme(app)\\n IconSet.current.set_color(QColor(0, 0, 0))\",\n \"def test_theme_header():\\n app = create_ctfd()\\n with app.app_context():\\n\\n with login_as_user(app, \\\"admin\\\") as admin:\\n css_value = \\\"\\\"\\\".test{}\\\"\\\"\\\"\\n css_value2 = \\\"\\\"\\\".test2{}\\\"\\\"\\\"\\n r = admin.patch(\\\"/api/v1/configs\\\", json={\\\"theme_header\\\": css_value})\\n assert r.status_code == 200\\n assert get_config(\\\"theme_header\\\") == css_value\\n\\n r = admin.get(\\\"/\\\")\\n assert css_value in r.get_data(as_text=True)\\n\\n r = admin.patch(\\\"/api/v1/configs\\\", json={\\\"theme_header\\\": css_value2})\\n r = admin.get(\\\"/\\\")\\n assert css_value2 in r.get_data(as_text=True)\\n destroy_ctfd(app)\",\n \"def get_theme_files(theme, part):\\n return SUMMERNOTE_THEME_FILES[theme][part]\",\n \"def on_load_theme (self):\\n\\n\\t\\tif self.has_started:\\n\\t\\t\\tself.init_buffers()\\n\\t\\t\\tself.redraw_background()\\n\\t\\t\\tself.redraw_foreground()\",\n \"def configure_jinja(theme, src):\\n\\n # Do not enable autoescape since we actually *do not* want it. Otherwise, we\\n # wouldn't be able to integrate html content in the templates properly.\\n\\n theme_path = os.path.join(src, paths.THEMES_PATH, theme)\\n logging.debug(\\\"Setting up environment at \\\" + theme_path)\\n\\n return Environment(loader=FileSystemLoader(theme_path), autoescape=False)\",\n \"def changeStyle(self, event=None):\\n content = self.combo.get()\\n try:\\n self.style.theme_use(content)\\n except tk.TclError as err:\\n tk.messagebox.showerror('Error', err)\\n else:\\n self.theme.set(content)\",\n \"def get_themes(themes_dir=None):\\n if not is_comprehensive_theming_enabled():\\n return []\\n if themes_dir is None:\\n themes_dir = get_theme_base_dirs_unchecked()\\n return get_themes_unchecked(themes_dir, settings.PROJECT_ROOT)\",\n \"def get_theme_base_dirs():\\n # Return an empty list if theming is disabled\\n if not is_comprehensive_theming_enabled():\\n return []\\n return get_theme_base_dirs_unchecked()\",\n \"def get_current_theme():\\n # Return None if theming is disabled\\n if not is_comprehensive_theming_enabled():\\n return None\\n\\n site_theme = get_current_site_theme()\\n if not site_theme:\\n return None\\n try:\\n return Theme(\\n name=site_theme.theme_dir_name,\\n theme_dir_name=site_theme.theme_dir_name,\\n themes_base_dir=get_theme_base_dir(site_theme.theme_dir_name),\\n project_root=get_project_root_name()\\n )\\n except ValueError as error:\\n # Log exception message and return None, so that open source theme is used instead\\n logger.exception('Theme not found in any of the themes dirs. [%s]', error)\\n return None\",\n \"def toggle_mode(mode: ThemeMode):\\n with winreg.OpenKey(\\n winreg.HKEY_CURRENT_USER,\\n (r'SOFTWARE\\\\Microsoft\\\\Windows\\\\CurrentVersion\\\\Themes'\\n r'\\\\Personalize'),\\n access=winreg.KEY_ALL_ACCESS) as hkey:\\n # Change mode for both apps and system theme to sync mode.\\n winreg.SetValueEx(\\n hkey, 'AppsUseLightTheme', 0, winreg.REG_DWORD, mode.value)\\n winreg.SetValueEx(\\n hkey, 'SystemUsesLightTheme', 0, winreg.REG_DWORD, mode.value)\",\n \"def get_theme(request=None, theme_uid=None, as_instance=False):\\n ensure_autodiscover()\\n\\n if not theme_uid:\\n theme_uid = DEFAULT_THEME\\n\\n Theme = theme_registry.get(theme_uid, None)\\n if not Theme:\\n raise ThemeDoesNotExist(\\n _(\\\"Theme `{0}` does not exist!\\\").format(theme_uid)\\n )\\n\\n if as_instance:\\n return Theme()\\n\\n return Theme\",\n \"def get_theme_base_dir(theme_dir_name, suppress_error=False):\\n for themes_dir in get_theme_base_dirs():\\n if theme_dir_name in get_theme_dirs(themes_dir):\\n return themes_dir\\n\\n if suppress_error:\\n return None\\n\\n raise ValueError(\\n \\\"Theme '{theme}' not found in any of the following themes dirs, \\\\nTheme dirs: \\\\n{dir}\\\".format(\\n theme=theme_dir_name,\\n dir=get_theme_base_dirs(),\\n ))\",\n \"def loader(cls, fs):\\n\\n def load(context=None):\\n if context is None:\\n context = pilot.context\\n name = context.get(\\\".sys.site.theme\\\", \\\"default\\\")\\n\\n path = \\\"{}.json\\\".format(name)\\n try:\\n theme = cls.read(fs, path, context=context)\\n except Exception as e:\\n log.warning(\\\"unable to read theme file '%s' (%s)\\\", path, text_type(e))\\n\\n if name != \\\"default\\\":\\n return load(\\\"default\\\")\\n\\n log.error(\\\"unable to load 'default' theme\\\")\\n theme = None\\n\\n return theme\\n\\n return load\",\n \"def list_themes():\\n themes = [*os.scandir(os.path.join(CONF_DIR, \\\"colorschemes\\\")),\\n *os.scandir(os.path.join(MODULE_DIR, \\\"colorschemes\\\"))]\\n\\n return [t for t in themes if os.path.isfile(t.path)]\",\n \"def get_registered_themes():\\n return get_registered_plugins(theme_registry)\",\n \"def theme_exists(theme_name, themes_dir=None):\\n for theme in get_themes(themes_dir=themes_dir):\\n if theme.theme_dir_name == theme_name:\\n return True\\n return False\",\n \"def compute_theme_directories(self) -> list[str]:\\n lm = g.app.loadManager\\n table = lm.computeThemeDirectories()[:]\\n directory = g.os_path_normslashes(g.app.theme_directory)\\n if directory and directory not in table:\\n table.insert(0, directory)\\n # All entries are known to exist and have normalized slashes.\\n return table\",\n \"def set_markup_style():\\n markup_language = '{{ cookiecutter.markup_language }}'\\n if markup_language == \\\"org\\\":\\n to_remove = Path.cwd() / 'README.md'\\n to_remove.unlink()\\n elif markup_language == \\\"markdown\\\":\\n to_remove = Path.cwd() / 'README.org'\\n to_remove.unlink()\",\n \"def setHeader(object, event):\\n\\n request = event.request\\n\\n if isThemeEnabled(request):\\n request.environ['HTTP_X_THEME_ENABLED'] = True\",\n \"def config_war(alternate=False):\\n with lcd(env.projectroot):\\n sudo(\\\"mkdir -p /etc/lagrummet.se\\\")\\n if alternate:\\n put(\\\"manage/sysconf/%(target)s/alternate/lagrummet.se-config.groovy\\\" % env, \\\"/etc/lagrummet.se\\\",\\n use_sudo=True)\\n else:\\n put(\\\"manage/sysconf/%(target)s/etc/lagrummet.se/lagrummet.se-config.groovy\\\" % env, \\\"/etc/lagrummet.se\\\",\\n use_sudo=True)\",\n \"def _set_theme_seaborn_rcparams(self, rcParams, style, gridweight, context):\\n # select grid line width:\\n gridweights = {'extra heavy': 1.5,\\n 'heavy': 1.1,\\n 'medium': 0.8,\\n 'light': 0.5, }\\n if gridweight is None:\\n if context == \\\"paper\\\":\\n glw = gridweights[\\\"medium\\\"]\\n else:\\n glw = gridweights['extra heavy']\\n elif np.isreal(gridweight):\\n glw = gridweight\\n else:\\n glw = gridweights[gridweight]\\n\\n if style == \\\"darkgrid\\\":\\n lw = .8 if context == \\\"paper\\\" else 1.5\\n ax_params = {\\\"axes.facecolor\\\": \\\"#EAEAF2\\\",\\n \\\"axes.edgecolor\\\": \\\"white\\\",\\n \\\"axes.linewidth\\\": 0,\\n \\\"axes.grid\\\": True,\\n \\\"axes.axisbelow\\\": True,\\n \\\"grid.color\\\": \\\"w\\\",\\n \\\"grid.linestyle\\\": \\\"-\\\",\\n \\\"grid.linewidth\\\": glw}\\n\\n elif style == \\\"whitegrid\\\":\\n lw = 1.0 if context == \\\"paper\\\" else 1.7\\n ax_params = {\\\"axes.facecolor\\\": \\\"white\\\",\\n \\\"axes.edgecolor\\\": \\\"#CCCCCC\\\",\\n \\\"axes.linewidth\\\": lw,\\n \\\"axes.grid\\\": True,\\n \\\"axes.axisbelow\\\": True,\\n \\\"grid.color\\\": \\\"#DDDDDD\\\",\\n \\\"grid.linestyle\\\": \\\"-\\\",\\n \\\"grid.linewidth\\\": glw}\\n\\n elif style == \\\"nogrid\\\":\\n ax_params = {\\\"axes.grid\\\": False,\\n \\\"axes.facecolor\\\": \\\"white\\\",\\n \\\"axes.edgecolor\\\": \\\"black\\\",\\n \\\"axes.linewidth\\\": 1}\\n\\n elif style == \\\"ticks\\\":\\n ticksize = 3. if context == \\\"paper\\\" else 6.\\n tickwidth = .5 if context == \\\"paper\\\" else 1\\n ax_params = {\\\"axes.grid\\\": False,\\n \\\"axes.facecolor\\\": \\\"white\\\",\\n \\\"axes.edgecolor\\\": \\\"black\\\",\\n \\\"axes.linewidth\\\": 1,\\n \\\"xtick.direction\\\": \\\"out\\\",\\n \\\"ytick.direction\\\": \\\"out\\\",\\n \\\"xtick.major.width\\\": tickwidth,\\n \\\"ytick.major.width\\\": tickwidth,\\n \\\"xtick.minor.width\\\": tickwidth,\\n \\\"xtick.minor.width\\\": tickwidth,\\n \\\"xtick.major.size\\\": ticksize,\\n \\\"xtick.minor.size\\\": ticksize / 2,\\n \\\"ytick.major.size\\\": ticksize,\\n \\\"ytick.minor.size\\\": ticksize / 2}\\n else:\\n ax_params = {}\\n\\n rcParams.update(ax_params)\\n\\n # Determine the font sizes\\n if context == \\\"talk\\\":\\n font_params = {\\\"axes.labelsize\\\": 16,\\n \\\"axes.titlesize\\\": 19,\\n \\\"xtick.labelsize\\\": 14,\\n \\\"ytick.labelsize\\\": 14,\\n \\\"legend.fontsize\\\": 13,\\n }\\n\\n elif context == \\\"notebook\\\":\\n font_params = {\\\"axes.labelsize\\\": 11,\\n \\\"axes.titlesize\\\": 12,\\n \\\"xtick.labelsize\\\": 10,\\n \\\"ytick.labelsize\\\": 10,\\n \\\"legend.fontsize\\\": 10,\\n }\\n\\n elif context == \\\"poster\\\":\\n font_params = {\\\"axes.labelsize\\\": 18,\\n \\\"axes.titlesize\\\": 22,\\n \\\"xtick.labelsize\\\": 16,\\n \\\"ytick.labelsize\\\": 16,\\n \\\"legend.fontsize\\\": 16,\\n }\\n\\n elif context == \\\"paper\\\":\\n font_params = {\\\"axes.labelsize\\\": 8,\\n \\\"axes.titlesize\\\": 12,\\n \\\"xtick.labelsize\\\": 8,\\n \\\"ytick.labelsize\\\": 8,\\n \\\"legend.fontsize\\\": 8,\\n }\\n\\n rcParams.update(font_params)\\n\\n # Set other parameters\\n rcParams.update({\\n \\\"lines.linewidth\\\": 1.1 if context == \\\"paper\\\" else 1.4,\\n \\\"patch.linewidth\\\": .1 if context == \\\"paper\\\" else .3,\\n \\\"xtick.major.pad\\\": 3.5 if context == \\\"paper\\\" else 7,\\n \\\"ytick.major.pad\\\": 3.5 if context == \\\"paper\\\" else 7, })\\n\\n rcParams[\\\"timezone\\\"] = \\\"UTC\\\"\\n rcParams[\\\"patch.antialiased\\\"] = \\\"True\\\"\\n rcParams[\\\"font.family\\\"] = \\\"sans-serif\\\"\\n rcParams[\\\"font.size\\\"] = \\\"12.0\\\"\\n rcParams[\\\"font.serif\\\"] = [\\\"Times\\\", \\\"Palatino\\\", \\\"New Century Schoolbook\\\",\\n \\\"Bookman\\\", \\\"Computer Modern Roman\\\",\\n \\\"Times New Roman\\\"]\\n rcParams[\\\"font.sans-serif\\\"] = [\\\"Helvetica\\\", \\\"Avant Garde\\\",\\n \\\"Computer Modern Sans serif\\\", \\\"Arial\\\"]\\n rcParams[\\\"axes.color_cycle\\\"] = [\\\"#333333\\\", \\\"348ABD\\\", \\\"7A68A6\\\", \\\"A60628\\\",\\n \\\"467821\\\", \\\"CF4457\\\", \\\"188487\\\", \\\"E24A33\\\"]\\n rcParams[\\\"legend.fancybox\\\"] = \\\"True\\\"\\n rcParams[\\\"figure.figsize\\\"] = \\\"11, 8\\\"\\n rcParams[\\\"figure.facecolor\\\"] = \\\"1.0\\\"\\n rcParams[\\\"figure.edgecolor\\\"] = \\\"0.50\\\"\\n rcParams[\\\"figure.subplot.hspace\\\"] = \\\"0.5\\\"\",\n \"def parse(theme_file):\\n data = util.read_file_json(theme_file)\\n\\n if \\\"wallpaper\\\" not in data:\\n data[\\\"wallpaper\\\"] = \\\"None\\\"\\n\\n if \\\"alpha\\\" not in data:\\n data[\\\"alpha\\\"] = \\\"100\\\"\\n\\n # Terminal.sexy format.\\n if \\\"color\\\" in data:\\n data = terminal_sexy_to_wal(data)\\n\\n return data\",\n \"def apply_preferences(self, provider):\\n\\n # it is possible that values have been added to common_dark,\\n # common_light!\\n # TODO: to be revised once color prefs are no longer floating\\n # around disparate plugins\\n if self.light:\\n self.d.update({k: common_light[k]\\n for k in common_light if k not in self.d})\\n else:\\n self.d.update({k: common_dark[k]\\n for k in common_dark if k not in self.d})\\n\\n font = GPS.Preference(\\n \\\"Src-Editor-Reference-Style\\\").get().split(\\\"@\\\")[0]\\n\\n def to_pref_str(t):\\n \\\"\\\"\\\"Return a variant pref string from a pref tuple\\\"\\\"\\\"\\n return \\\"{}@{}@{}\\\".format(t[0],\\n t[1].to_rgba_string(),\\n t[2].to_rgba_string())\\n\\n def pref_set(gps_pref, val):\\n \\\"\\\"\\\"Set a preference; log any errors\\\"\\\"\\\"\\n try:\\n GPS.Preference(gps_pref).set(val)\\n except GPS.Exception:\\n # TODO: there is a potential issue here: some preferences\\n # do not exist until their plugin is loaded (ispell, isearch);\\n # we might need to move the definitions out of the plugins,\\n # or reuse existing colors\\n pass\\n\\n # Freeze the preferences\\n\\n with gps_utils.freeze_prefs():\\n # The theme preference\\n pref_set(gtk_theme_pref_name, self.d['base_theme'])\\n\\n # The editor fg and bg\\n font = GPS.Preference(\\n \\\"Src-Editor-Reference-Style\\\").get().split(\\\"@\\\")[0]\\n GPS.Preference(\\n \\\"Src-Editor-Reference-Style\\\").set(\\\"{}@{}@{}\\\".format(\\n font,\\n self.d['editor_fg'].to_rgba_string(),\\n self.d['editor_bg'].to_rgba_string()))\\n\\n # Apply the theme preferences\\n for key in variant_prefs:\\n pref_set(variant_prefs[key], to_pref_str(self.d[key]))\\n\\n for key in rgb_prefs:\\n pref_set(rgb_prefs[key], self.d[key].to_rgba_string())\\n\\n # Apply the CSS preference\\n\\n css = css_template.format(\\n **{k: self.d[k].to_hex6_string() for k in css_colors}\\n ).replace('[', '{').replace(']', '}')\\n provider.load_from_data(css)\\n GPS.Preference(gtk_css_pref_name).set(css)\",\n \"def get_group_theme(request):\\n\\treturn render(request,\\\"404.html\\\",{})\",\n \"def theme_named(self, name):\\n for theme in self.themes:\\n if theme.get('name', 'Error') == name:\\n return theme\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7291386","0.72200936","0.72200936","0.7041518","0.70217","0.6841499","0.68290067","0.67453665","0.6707492","0.6679242","0.65246654","0.6497607","0.6458891","0.6432759","0.64274865","0.6375833","0.63486564","0.63367087","0.63211995","0.63092625","0.6297673","0.6275412","0.62443596","0.6237724","0.62134033","0.6204341","0.6201641","0.61752635","0.61371344","0.6103399","0.6090607","0.6069697","0.5987731","0.5984857","0.59775835","0.59587765","0.59369975","0.5874002","0.58652365","0.58313084","0.5829319","0.5817112","0.57841885","0.5764236","0.5752659","0.57414144","0.5676314","0.5674359","0.56728995","0.56396097","0.56149316","0.55546004","0.5548629","0.55362284","0.5516616","0.5506057","0.54943806","0.5490306","0.546674","0.5460748","0.5459788","0.54583406","0.5438106","0.5438091","0.5405464","0.53797424","0.5361414","0.5350059","0.5345828","0.53445685","0.53156275","0.5290245","0.5278088","0.5262349","0.52493054","0.52489495","0.5231385","0.52192646","0.52177346","0.5207166","0.5202262","0.5196459","0.5187579","0.5179664","0.51613265","0.515952","0.51313233","0.5129057","0.5128881","0.51137596","0.507803","0.5065179","0.50551635","0.50527525","0.50487083","0.50415134","0.5030237","0.50101495","0.50045717","0.49517274"],"string":"[\n \"0.7291386\",\n \"0.72200936\",\n \"0.72200936\",\n \"0.7041518\",\n \"0.70217\",\n \"0.6841499\",\n \"0.68290067\",\n \"0.67453665\",\n \"0.6707492\",\n \"0.6679242\",\n \"0.65246654\",\n \"0.6497607\",\n \"0.6458891\",\n \"0.6432759\",\n \"0.64274865\",\n \"0.6375833\",\n \"0.63486564\",\n \"0.63367087\",\n \"0.63211995\",\n \"0.63092625\",\n \"0.6297673\",\n \"0.6275412\",\n \"0.62443596\",\n \"0.6237724\",\n \"0.62134033\",\n \"0.6204341\",\n \"0.6201641\",\n \"0.61752635\",\n \"0.61371344\",\n \"0.6103399\",\n \"0.6090607\",\n \"0.6069697\",\n \"0.5987731\",\n \"0.5984857\",\n \"0.59775835\",\n \"0.59587765\",\n \"0.59369975\",\n \"0.5874002\",\n \"0.58652365\",\n \"0.58313084\",\n \"0.5829319\",\n \"0.5817112\",\n \"0.57841885\",\n \"0.5764236\",\n \"0.5752659\",\n \"0.57414144\",\n \"0.5676314\",\n \"0.5674359\",\n \"0.56728995\",\n \"0.56396097\",\n \"0.56149316\",\n \"0.55546004\",\n \"0.5548629\",\n \"0.55362284\",\n \"0.5516616\",\n \"0.5506057\",\n \"0.54943806\",\n \"0.5490306\",\n \"0.546674\",\n \"0.5460748\",\n \"0.5459788\",\n \"0.54583406\",\n \"0.5438106\",\n \"0.5438091\",\n \"0.5405464\",\n \"0.53797424\",\n \"0.5361414\",\n \"0.5350059\",\n \"0.5345828\",\n \"0.53445685\",\n \"0.53156275\",\n \"0.5290245\",\n \"0.5278088\",\n \"0.5262349\",\n \"0.52493054\",\n \"0.52489495\",\n \"0.5231385\",\n \"0.52192646\",\n \"0.52177346\",\n \"0.5207166\",\n \"0.5202262\",\n \"0.5196459\",\n \"0.5187579\",\n \"0.5179664\",\n \"0.51613265\",\n \"0.515952\",\n \"0.51313233\",\n \"0.5129057\",\n \"0.5128881\",\n \"0.51137596\",\n \"0.507803\",\n \"0.5065179\",\n \"0.50551635\",\n \"0.50527525\",\n \"0.50487083\",\n \"0.50415134\",\n \"0.5030237\",\n \"0.50101495\",\n \"0.50045717\",\n \"0.49517274\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5805374"},"document_rank":{"kind":"string","value":"42"}}},{"rowIdx":23593,"cells":{"query":{"kind":"string","value":"Takes the adjacency matrix, payment matrix (or matrices), relationship matrix and initial state of all vertices to return the increments in each strategy for each vertex"},"document":{"kind":"string","value":"def hr_egn(A, B, R, x0):\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Degree and degree of preferences\n d = np.zeros([N, 2])\n d[:, 0] = np.dot(A, np.ones(N))\n\n for v in range(N):\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\n\n # Player v neighborhood\n k = np.zeros([N, S], dtype='double')\n for v in range(N):\n for u in range(N):\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\n # Weights the neighborhood\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\n\n # This variable is the increments that x0 receives, the derivative\n x = np.zeros([N, S], dtype='double')\n # This is the unit vector with 1 in some entry\n es = np.zeros(S, dtype='int')\n\n # Phi and gamma\n p = 0\n g = 0\n\n # Auxiliary variables for better clarity\n aux1 = 0\n aux2 = 0\n\n # Here is the derivative calculation\n # We first test if all payoffs are the same so we do less comparisons\n if B.ndim == 2:\n for v in range(N):\n for s in range(S):\n # Set es value\n es[s] = 1\n for u in range(N):\n if v == u:\n # Same payoff personal equation\n # First we will do the dot products\n # e_s*B*k_v\n aux1 = np.dot(es, np.dot(B, k[v, :]))\n # x_v*B*k_v\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\n # Finally we subtract them to multiply by r_vv\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Same payoff social equation\n # x_u*B*e_s\n aux1 = np.dot(x0[u, :], np.dot(B, es))\n # x_u*B*x_v\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n else:\n for v in range(N):\n for s in range(S):\n # Same thing as before, but now with individual payoffs\n es[s] = 1\n for u in range(N):\n if v == u:\n # Individual payoffs personal equation\n # e_s*B_v*k_v\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\n # x_u*B_v*k_v\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Individual payoffs social equation\n # x_u*B_u*e_s\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\n # x_u*B_u*x_v\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n return x"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_matrix(self):\n matrix = np.zeros([len(self.states), len(self.states)])\n starting_states = []\n transitions = []\n\n for chords in self.training_data:\n states = []\n is_starting_state = True\n chunks = [chords[x:x+self.order] for x in range(0,\n len(chords), self.order)]\n for chunk in chunks:\n chunk_string = \" \".join(chunk)\n if is_starting_state:\n starting_states.append(chunk_string)\n is_starting_state = False\n states.append(chunk_string)\n\n for i in range(0, len(states)):\n if i < (len(states)) - 1:\n transitions.append([states[i], states[i + 1]])\n else:\n transitions.append([states[i]])\n\n self.starting_probabilities = np.zeros([len(self.states)])\n\n for transition in transitions:\n for row, row_contents in enumerate(self.transitions):\n for col, _ in enumerate(row_contents):\n if transition == self.transitions[row][col]:\n matrix[row][col] += 1\n\n for i, state in enumerate(self.states):\n for j, possible_state in enumerate(starting_states):\n if state == possible_state:\n self.starting_probabilities[j] += 1\n\n num = sum(self.starting_probabilities)\n for i, prob in enumerate(self.starting_probabilities):\n self.starting_probabilities[i] = prob / num\n\n for m in range(len(matrix)):\n num = sum(matrix[m])\n if int(num) is not 0:\n for i in range(len(matrix[m])):\n matrix[m][i] = (matrix[m][i] / num)\n else:\n matrix[m] = self.starting_probabilities\n return matrix","def back_prop(nodes_in_path, playout_result):\n for temp_node in nodes_in_path:\n temp_node.visited += 1\n if str(playout_result) == str(temp_node.side):\n temp_node.winning += 1","def init_graph(self):\n import dgl\n\n adj_list = []\n for rel_type in range(1, self.n_relations, 1):\n edge_idxs = self.ckg.filter_edges(\n lambda edge: edge.data[\"relation_id\"] == rel_type\n )\n sub_graph = (\n dgl.edge_subgraph(self.ckg, edge_idxs, preserve_nodes=True)\n .adjacency_matrix(transpose=False, scipy_fmt=\"coo\")\n .astype(\"float\")\n )\n rowsum = np.array(sub_graph.sum(1))\n d_inv = np.power(rowsum, -1).flatten()\n d_inv[np.isinf(d_inv)] = 0.0\n d_mat_inv = sp.diags(d_inv)\n norm_adj = d_mat_inv.dot(sub_graph).tocoo()\n adj_list.append(norm_adj)\n\n final_adj_matrix = sum(adj_list).tocoo()\n indices = torch.LongTensor([final_adj_matrix.row, final_adj_matrix.col])\n values = torch.FloatTensor(final_adj_matrix.data)\n adj_matrix_tensor = torch.sparse.FloatTensor(indices, values, self.matrix_size)\n return adj_matrix_tensor.to(self.device)","def _generate_adjacency_matrices(self):\n self.adj_matrices = dict()\n mes = []\n args = []\n for metaedge in self.metaedges:\n mes.append(metaedge)\n args.append(self._prepare_parallel_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.adj_matrices[metaedge] = matrix","def demukron_network_order_function(vertices: List[Vertice], adj_matrix: np.ndarray) -> np.ndarray:\n current_level = 0\n vertice_indices_set = set(range(len(vertices)))\n m = adj_matrix.sum(axis=0) # array of in-degrees\n degrees_array = np.zeros(len(vertices))\n\n while vertice_indices_set:\n zero_on_the_current_step = {i for i in vertice_indices_set if m[i] == 0}\n for i in zero_on_the_current_step:\n degrees_array[i] = current_level\n m = m - adj_matrix[i]\n vertice_indices_set = vertice_indices_set - zero_on_the_current_step\n current_level += 1\n return degrees_array","def adjacency_matrix():\n file_path = PROJECT_PATH + \"/geographycal_data/adjacency_matrix/Howgrp.txt\"\n router = Router(adjacency_metrix=file_path)\n # router.write2vtk(router.graph, \"adjacency_matrix\")\n # nx.draw(router.graph)\n # plt.show()\n # adjacency matrix\n A = nx.adjacency_matrix(router.graph, weight=None).toarray()\n # ... and its spectrum\n nx.adjacency_spectrum(router.graph, weight=None)\n # weighted adjacency\n W = nx.adjacency_matrix(router.graph)\n # D\n I = np.reshape(np.ones(12), (-1, 1))\n D = np.matmul(A, I)\n # combinatorial graph Laplacian L = D - A\n L = nx.laplacian_matrix(router.graph, weight=None)\n # ... and his spectrum\n nx.laplacian_spectrum(router.graph, weight=None)\n # weighted Laplacian\n Y = nx.laplacian_matrix(router.graph)\n\n # Note\n sumD = np.matmul(I.transpose(), D)\n sumD = sumD[0][0]\n sumA = 0\n for row in np.nditer(A):\n for e in np.nditer(row):\n sumA += e\n\n # Fielder vector\n fiedler_vector = nx.fiedler_vector(router.graph, weight=None)\n\n # Matrix Double index Sum\n\n def D_app(F):\n return D * F\n\n def A_app(F):\n AF = np.zeros(len(F))\n for i, e_i in enumerate(F):\n for j, e_j in enumerate(F):\n if (A[i][j] != 0):\n AF[i] += F[j]\n return AF","def compute_transition_rates(adj_mat):\n\n # compute the node degrees\n degrees = np.sum(adj_mat, axis=0)\n degrees[degrees == 0] = adj_mat.shape[0]\n\n # compute D = diag(1 / degree_i), for each node i\n D = scipy.sparse.csr_matrix(np.diag(1. / degrees))\n\n # compute the transition matrix M = A\\D\n M = D.dot(adj_mat)\n\n return M","def generate_adj_matrix(vertices, inhibition_degree=2):\n value_pool = [-1, 1, 0] + [0]*10 + [1]*2\n matrix = [[0 for _ in xrange(vertices)] for _ in xrange(vertices)]\n for i, row in enumerate(matrix):\n for j, element in enumerate(row):\n if i > j:\n if row.count(-1) + row.count(1) >= 2 and row.count(-1) != 0:\n matrix[i][j] = 0\n elif row.count(-1) == 1:\n matrix[i][j] = rnd.choice(value_pool)\n elif row.count(-1) == 2:\n matrix[i][j] = 0\n else:\n matrix[i][j] = rnd.choice(value_pool)\n matrix = [list(i) for i in zip(*matrix)]\n return matrix","def _estimate_adjacency_matrix(self, X):\r\n\t\tB = np.zeros([X.shape[1], X.shape[1]], dtype='float64')\r\n\t\tfor i in range(1, len(self._causal_order)):\r\n\t\t\tcoef = self._predict_adaptive_lasso(\r\n\t\t\t\tX, self._causal_order[:i], self._causal_order[i])\r\n\t\t\tB[self._causal_order[i], self._causal_order[:i]] = coef\r\n\t\tself.adjacency_matrix_ = B\r\n\t\treturn self","def viterbi_path(prior, transmat, observ_likelihood):\n T = observ_likelihood.shape[-1]\n N = observ_likelihood.shape[0]\n\n path = numpy.zeros(T, dtype=numpy.int32)\n global_score = numpy.zeros(shape=(N,T))\n predecessor_state_index = numpy.zeros(shape=(N,T), dtype=numpy.int32)\n\n t = 1\n global_score[:, 0] = prior * observ_likelihood[:, 0]\n # need to normalize the data\n global_score[:, 0] = global_score[:, 0] /sum(global_score[:, 0] )\n \n for t in range(1, T):\n for j in range(N):\n temp = global_score[:, t-1] * transmat[:, j] * observ_likelihood[j, t]\n global_score[j, t] = max(temp)\n predecessor_state_index[j, t] = temp.argmax()\n\n global_score[:, t] = global_score[:, t] / sum(global_score[:, t])\n\n path[T-1] = global_score[:, T-1].argmax()\n \n for t in range(T-2, -1, -1):\n path[t] = predecessor_state_index[ path[t+1], t+1]\n\n return [path, predecessor_state_index, global_score]","def viterbi(adj_matrix, label_sequence, starting_vertex):\n\n assert adj_matrix, \"adj_matrix is None or empty.\"\n n = len(adj_matrix) # vertex count.\n for row in adj_matrix:\n assert len(row) == n, \"adj_matrix is not square.\"\n\n assert 0 <= starting_vertex <= n - 1, \"starting_vertex out of range.\"\n\n assert label_sequence, \"label_sequence is None or empty.\"\n k = len(label_sequence)\n for l in label_sequence:\n assert isinstance(l, int) and l > 0, \"label ids must be positive integers.\"\n\n p = [[0 for _ in range(0, k)] for _ in range(0, n)]\n for j in range(k - 1, -1, -1):\n for beg in range(0, n):\n for end in range(0, n):\n if not adj_matrix[beg][end]: # No edge from i to r.\n continue\n\n assert isinstance(adj_matrix[beg][end], AdjMatrixElem),\\\n \"adj_matrix[%d][%r] is not an AdjMatrixElem\" % (beg, end)\n elem = adj_matrix[beg][end]\n if elem.label_id != label_sequence[j]:\n continue\n\n later_prob = 1 if j == k - 1 else p[end][j + 1]\n if elem.probability * later_prob > p[beg][j]:\n p[beg][j] = elem.probability * later_prob\n\n if round(p[starting_vertex][0] - 0.0, PROBABILITY_PRECISION) == 0:\n return 0, NO_SUCH_PATH\n\n path = [starting_vertex]\n for j in range(0, k):\n beg = path[j]\n for end in range(0, n):\n later_prob = 1 if j == k - 1 else p[end][j + 1]\n if adj_matrix[beg][end] and adj_matrix[beg][end].label_id == label_sequence[j]\\\n and round(p[beg][j] - adj_matrix[beg][end].probability * later_prob, PROBABILITY_PRECISION) == 0:\n path.append(end)\n break\n\n return p[starting_vertex][0], tuple(path)","def _triangulate(self,x):\n\n t = tr.triangulate({\"vertices\": x},\"-n\")\n tri = t[\"triangles\"]\n neighbours = t[\"neighbors\"]\n\n b_cells = np.zeros(self.n_c)\n b_cells[self.n_C:] = 1\n\n three_b_cell_mask = b_cells[tri].sum(axis=1)==3\n tri = tri[~three_b_cell_mask]\n\n neigh_map = np.cumsum(~three_b_cell_mask)-1\n neigh_map[three_b_cell_mask] = -1\n neigh_map = np.concatenate((neigh_map,[-1]))\n\n neighbours = neighbours[~three_b_cell_mask]\n neighbours = neigh_map[neighbours]\n\n #6. Store outputs\n self.tris = tri\n self.n_v = tri.shape[0]\n self.Cents = x[self.tris]\n self.vs = self.get_vertex()\n\n\n #7. Manually calculate the neighbours. See doc_string for conventions.\n self.v_neighbours = neighbours\n self.neighbours = self.vs[neighbours]\n self.neighbours[neighbours == -1] = np.nan\n\n self.reset_k2s()","def matrix_contribution(self):\r\n \r\n import numpy as np\r\n import copy\r\n \r\n # The functions F and G sometimes return NaN, errors we catch through\r\n # np.nan_to_num. Suppress these error messages.\r\n import warnings\r\n warnings.filterwarnings('ignore')\r\n \r\n # Define the segment influence functions\r\n def F(Z):\r\n return np.nan_to_num(-0.5*(Z-1)*np.log((Z-1)/(Z+1))) - 1\r\n def G(Z):\r\n return np.nan_to_num(+0.5*(Z+1)*np.log((Z-1)/(Z+1))) + 1\r\n \r\n # We evaluate this block at its own vertices\r\n z = self.polygon\r\n \r\n # Pre-allocate an empty matrix for the block\r\n block = np.zeros((self.segments,self.segments))\r\n \r\n self.angles = []\r\n self.temp = []\r\n \r\n # Go through all vertices in the polygon\r\n for seg in range(self.segments):\r\n \r\n # Set the previous, current, and next vertex of the polygon\r\n if seg == self.segments-1:\r\n seg_minus = seg-1\r\n seg_center = seg\r\n seg_plus = 0\r\n else:\r\n seg_minus = seg-1\r\n seg_center = seg\r\n seg_plus = seg+1\r\n \r\n self.temp.append([self.polygon[seg_plus]-self.polygon[seg_center],\r\n self.polygon[seg_center]-self.polygon[seg_minus]])\r\n \r\n # To evaluate the effect of a vertex on itself, it is computationally\r\n # cleanest to evaluate it in terms of angles; these angles are \r\n # calculated according to Strack 1989, Eq. 35.29 and 35.30\r\n newtemp = np.angle(self.polygon[seg_plus]-self.polygon[seg_center]) - \\\r\n np.angle(self.polygon[seg_center]-self.polygon[seg_minus])\r\n \r\n if newtemp < -np.pi: newtemp += 2*np.pi\r\n if newtemp > +np.pi: newtemp -= 2*np.pi\r\n \r\n # self.angles.append(newtemp)\r\n # Sometimes, numerical imprecision causes the angle to fall outside\r\n # the range 0 and 2 pi; in that case, flip it back inside\r\n # if newtemp < 0: newtemp += 2*np.pi\r\n # if newtemp > 2*np.pi: newtemp -= 2*np.pi\r\n newtemp -= np.pi\r\n \r\n\r\n \r\n self.angles.append(newtemp)\r\n \r\n # Write the diagonal entries of the matrix\r\n block[seg,seg] = 1/(2*np.pi)*newtemp\r\n \r\n # Here we would normally add the factor for the conductivity difference\r\n # to the diagonal entries; since we only prepare the matrix here, \r\n # we skip it\r\n \r\n # # Determine the A_star variable (Strack 1989 35.4, 35.38)\r\n # A_star = self.model.k/(self.k - self.model.k)\r\n # block[seg,seg] -= A_star\r\n\r\n # Then handle all off-diagonal contributions\r\n for seg2 in range(self.segments):\r\n \r\n # Skip the diagonal\r\n if seg2 != seg:\r\n \r\n # Get the indices of the past, current, and next vertex\r\n if seg2 == self.segments-1:\r\n seg_minus = seg2-1\r\n seg_center = seg2\r\n seg_plus = 0\r\n else:\r\n seg_minus = seg2-1\r\n seg_center = seg2\r\n seg_plus = seg2+1\r\n \r\n # Calculate the local coordinates\r\n Z_before = \\\r\n (2*z[seg] - (self.polygon[seg_minus] + self.polygon[seg_center]))/(self.polygon[seg_center] - self.polygon[seg_minus])\r\n Z_after = \\\r\n (2*z[seg] - (self.polygon[seg_center] + self.polygon[seg_plus]))/(self.polygon[seg_plus] - self.polygon[seg_center])\r\n \r\n # And write the result into the correct matrix entries\r\n block[seg,seg2] = copy.copy(np.real(1/(2*np.pi*1j)*(G(Z_before)+F(Z_after))))\r\n \r\n return block","def feature_calculator(args, graph):\n index_1 = [edge[0] for edge in graph.edges()]\n index_2 = [edge[1] for edge in graph.edges()]\n values = [1 for edge in graph.edges()]\n node_count = max(max(index_1)+1,max(index_2)+1)\n adjacency_matrix = sparse.coo_matrix((values, (index_1,index_2)),shape=(node_count,node_count),dtype=np.float32)\n degrees = adjacency_matrix.sum(axis=0)[0].tolist()\n degs = sparse.diags(degrees, [0])\n normalized_adjacency_matrix = degs.dot(adjacency_matrix)\n target_matrices = [normalized_adjacency_matrix.todense()]\n powered_A = normalized_adjacency_matrix\n if args.window_size > 1:\n for power in tqdm(range(args.window_size-1), desc = \"Adjacency matrix powers\"):\n powered_A = powered_A.dot(normalized_adjacency_matrix)\n to_add = powered_A.todense()\n target_matrices.append(to_add)\n target_matrices = np.array(target_matrices)\n return target_matrices","def ComputeAccumulatedCostMatrix( self, iterative=False ):\n start = 0\n if not iterative: # if first time, make a matrix of zeros\n self.D = [[0 for x in range(len(self.C[0]))] for y in range(len(self.C))]\n else: # else add rows of zeros until D has the same dimensions as C\n start = len(self.D)-1\n for row in range( len(self.C) - len(self.D) ):\n self.D.append( [ 0 for x in range(len(self.C[0])) ] )\n for n in range( start, len(self.C) ):\n for m in range( len(self.C[0]) ):\n if n == 0:\n if(self.subsequence):\n self.D[n][m] = 0+self.C[n][m]\n else:\n self.D[n][m] = sum( self.C[n][:m] )\n if m == 0:\n ## print \"col 0, row %d, sum=%f\"%(n,sum( [row[m] for row in C[:n]] ))\n ## print [row[m] for row in C[:n]]\n self.D[n][m] = sum( [row[m]+self.penalty[1] for row in self.C[:n]] )\n else:\n self.D[n][m] = self.C[n][m] + min( self.D[n-1][m-1], self.D[n-1][m]+self.penalty[0], self.D[n][m-1]+self.penalty[1])\n if n == len(self.C)-1: # last row\n self.D[n][m] += self.penalty[1]*(len(self.C[0])-m) # bias the cost of the last row, so that the algorithm prefers to start near the bottom right corner","def _compute_adjacency_matrix(self):\n\n # Set up a quick-reference index to map cells to indexes\n for i, cell in enumerate(self.sim.cells):\n self._cell_indexes[cell] = i\n\n if all([self.sim.hub.cells == [self.sim.damaged],\n self.sim.damaged not in self.sim.cells]):\n # Add the \"damaged\" virtual cell to the index if we need it\n self._cell_indexes[self.sim.damaged] = len(self.sim.cells)\n\n node_count = len(list(self._cell_indexes.keys()))\n g_sparse = np.zeros((node_count, node_count), dtype=float)\n g_sparse[:] = np.inf\n\n for cluster in self.sim.clusters + [self.sim.hub]:\n cluster_tour = cluster.tour\n i = len(cluster_tour.vertices) - 1\n j = 0\n while j < len(cluster_tour.vertices):\n start_vertex = cluster_tour.vertices[i]\n stop_vertex = cluster_tour.vertices[j]\n\n start_pt = cluster_tour.points[start_vertex]\n stop_pt = cluster_tour.points[stop_vertex]\n distance = np.linalg.norm(stop_pt - start_pt)\n\n start_seg = cluster_tour.objects[start_vertex]\n stop_seg = cluster_tour.objects[stop_vertex]\n\n start_index = self._cell_indexes[start_seg]\n stop_index = self._cell_indexes[stop_seg]\n\n g_sparse[start_index, stop_index] = distance\n\n i = j\n j += 1\n\n g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)\n return g_sparse","def M(self,i,j):\n node_i = self.internal[i]\n node_j = self.internal[j]\n adj_i = self.adj_triangles(node_i)\n adj_j = self.adj_triangles(node_j)\n shared_tri = [] \n for tri_i in adj_i:\n for tri_j in adj_j:\n if sorted(tri_i) == sorted(tri_j):\n shared_tri.append(tri_i)\n break \n\n # print(len(shared_tri))\n\n\n total_integral = 0.0\n for tri_h in shared_tri:\n beta_i, gamma_i = self.calc_param(tri_h,node_i)\n beta_j, gamma_j = self.calc_param(tri_h,node_j)\n total_integral += ((beta_i*beta_j)+(gamma_i*gamma_j))*self.area \n \n return total_integral","def interaction_matrix(self):\n\n self.int_M_called = True\n int_M = np.zeros((self.n, self.n))\n for k in range(self.n):\n for j in range(k+1):\n o = self.attribute_interactions(k, j)\n int_M[k, j] = o.rel_total_ig_ab # Store total information gain\n int_M[j, k] = o.rel_total_ig_ab # TODO: Maybe storing interactions too is not a bad idea\n # TODO: We can than easily sort either by total gain or by positive interaction\n for k in range(self.n):\n int_M[k, k] = self.info_gains[self.data.domain.attributes[k].name]\n self.int_matrix = Orange.misc.distmatrix.DistMatrix(int_M)","def connectivity_matrix(self):\n # TODO: make this more memory efficient by ordering i,j in code when needed.\n temp = []\n for i in range(self.n_atom):\n for j in range(i+1, self.n_atom):\n if self.bond(i, j):\n temp.append([i+1, j+1])\n self.connect = np.asarray(temp)","def get_direction_matrix(self) -> int:","def _compute_node_degrees(self):\n mes = []\n args = []\n for metaedge, matrix in self.adj_matrices.items():\n mes.append(metaedge)\n args.append(matrix)\n res = parallel_process(array=args, function=mt.calculate_degrees, n_jobs=self.n_jobs, front_num=0)\n for metaedge, (out_degree, in_degree) in zip(mes, res):\n self.out_degree[metaedge] = out_degree\n self.in_degree[metaedge] = in_degree","def solve(list_of_kingdom_names, starting_kingdom, adjacency_matrix, params=[]):\n\n #A = adjacency matrix, u = vertex u, v = vertex v\n def weight(A, u, v):\n return A[u][v]\n\n #A = adjacency matrix, u = vertex u\n def adjacent(A, u):\n L = []\n for x in range(len(A)):\n if A[u][x] > 0 and x != u and A[u][x] != 'x':\n L.insert(0,x)\n return L\n\n #Q = min queue\n def extractMin(Q):\n q = Q[0]\n Q.remove(Q[0])\n return q\n\n #Q = min queue, V = vertex list\n def decreaseKey(Q, K):\n for i in range(len(Q)):\n for j in range(len(Q)):\n if K[Q[i]] < K[Q[j]]:\n s = Q[i]\n Q[i] = Q[j]\n Q[j] = s\n\n #V = vertex list, A = adjacency list, r = root\n def prim(V, A, r):\n u = 0\n v = 0\n\n # initialize and set each value of the array P (pi) to none\n # pi holds the parent of u, so P(v)=u means u is the parent of v\n P=[None]*len(V)\n\n # initialize and set each value of the array K (key) to some large number (simulate infinity)\n K = [999999]*len(V)\n\n # initialize the min queue and fill it with all vertices in V\n Q=[0]*len(V)\n for u in range(len(Q)):\n Q[u] = V[u]\n\n # set the key of the root to 0\n K[r] = 0\n decreaseKey(Q, K) # maintain the min queue\n\n # loop while the min queue is not empty\n while len(Q) > 0:\n u = extractMin(Q) # pop the first vertex off the min queue\n\n # loop through the vertices adjacent to u\n Adj = adjacent(A, u)\n for v in Adj:\n w = weight(A, u, v) # get the weight of the edge uv\n\n # proceed if v is in Q and the weight of uv is less than v's key\n if Q.count(v)>0 and w < K[v]:\n # set v's parent to u\n P[v] = u\n # v's key to the weight of uv\n K[v] = w\n decreaseKey(Q, K) # maintain the min queue\n return P\n\n\n # graph is a list of kingdoms that previous i is the parent of j where j = i + 1 \n graph = prim(adjacency_matrix, list_of_kingdom_names, starting_kingdom)\n\n # key = parent, value = children\n g = {}\n\n for x in range(len(list_of_kingdom_names)):\n g[x] = []\n\n for x in range(len(graph)):\n for y in range(len(graph)):\n if x == graph[y]:\n g[x].append(y) \n\n\n def path(k):\n if not g[k]:\n return [k]\n\n lst = [k]\n\n for child in g[k]:\n lst += path(child) + [k]\n # print(lst)\n\n return lst\n\n\n full_path = path(starting_kingdom)\n\n # print(full_path)\n\n\n\n # return closed_walk, conquered_kingdoms","def adj(self):\n\t\tres = SquareMatrix(self._rows)\n\t\tfor i in range(self._rows):\n\t\t\tfor j in range(self._rows):\n\t\t\t\tres[i][j] = ((-1) ** (i + j)) * self.minor(j, i)\n\t\treturn res","def formAdjacencyMatrix(self):\n self.adjacencyMatrix = dict()\n for i in self.node:\n self.adjacencyMatrix[i] = dict()\n for j in self.node:\n self.adjacencyMatrix[i][j] = 0\n \n for ij in self.link:\n self.adjacencyMatrix[self.link[ij].tail][self.link[ij].head] = 1","def generate_full_adj(self):\n edges = np.zeros(shape=(self.n_balls, self.n_balls))\n row_idx = 0 # start filling adjacency mat from root node\n col_idx = 1 # skip the root node and start from 2nd node\n\n # generate hierarchical interaction strength matrix\n int_strngth = np.zeros(shape=(self.n_balls, self.n_balls))\n # generate hierarchical edge lengths matrix\n lengths = np.zeros(shape=(self.n_balls, self.n_balls))\n for l in range(self.nl):\n for n in range(self.nn[l]):\n edges[row_idx, col_idx:col_idx + self.nc[l]] = 1\n # Fill symmetric the lower triangular (undirected graph)\n edges[col_idx:col_idx + self.nc[l], row_idx] = 1\n\n # same for interaction strength\n int_strngth[row_idx, col_idx:col_idx + self.nc[l]] = self.per_level_l2a_a2d_force[l]\n int_strngth[col_idx:col_idx + self.nc[l], row_idx] = self.per_level_l2a_a2d_force[l]\n\n # same for lengths\n lengths[row_idx, col_idx:col_idx + self.nc[l]] = self.per_level_l2a_a2d_length[l]\n lengths[col_idx:col_idx + self.nc[l], row_idx] = self.per_level_l2a_a2d_length[l]\n\n if l == self.nl - 1 or self.randomize_all_clusters:\n # create full cluster adjacency matrix\n edges[col_idx:col_idx + self.nc[l],\n col_idx:col_idx + self.nc[l]] = \\\n np.ones((self.nc[l], self.nc[l])) - np.eye(self.nc[l])\n # same for interaction strength\n int_strngth[col_idx:col_idx + self.nc[l],\n col_idx:col_idx + self.nc[l]] = \\\n np.ones((self.nc[l], self.nc[l])) * self.per_level_ws_force[l]\n # same for lengths\n lengths[col_idx:col_idx + self.nc[l],\n col_idx:col_idx + self.nc[l]] = \\\n np.ones((self.nc[l], self.nc[l])) * self.per_level_ws_length[l]\n\n # Increase counters after filling connections for a parent node\n col_idx += self.nc[l]\n row_idx += 1\n\n return edges, int_strngth, lengths","def generate_full_adj(self):\n edges = np.zeros(shape=(self.n_balls, self.n_balls))\n row_idx = 0 # start filling adjacency mat from root node\n col_idx = 1 # skip the root node and start from 2nd node\n for l in range(self.nl):\n for n in range(self.nn[l]):\n edges[row_idx, col_idx:col_idx + self.nc[l]] = 1\n # Increase counters after filling connections for a parent node\n col_idx += self.nc[l]\n row_idx += 1\n return edges","def dynamic_programming_path_counter(grid_size):\n G = [1] * grid_size\n for i in range(grid_size):\n for j in range(i):\n G[j] = G[j] + G[j-1]\n G[i] = 2 * G[i - 1]\n return G[grid_size - 1]","def enumerate_lattice(self):\n node_to_succs = dict()\n node_to_preds = dict()\n start_node = self.state_to_node([self.x_lims[0], self.y_lims[0]])\n for i in range(self.num_cells[0]):\n x = start_node[0] + i\n for j in range(self.num_cells[1]):\n y = start_node[1] + j\n node = (x,y)\n node_to_succs[node] = self.get_successors(node)\n node_to_preds[node] = self.get_predecessors(node)\n \n assert(len(node_to_succs.keys()) == self.total_cells), \"Did not enumerate all possible successor cells\"\n assert(len(node_to_preds.keys()) == self.total_cells), \"Did not enumerate all possible predecessor cells\"\n return node_to_succs, node_to_preds","def ancmig_adj_1(params, ns):\n #11 parameters \n nu1, nuA, nu2, nu3, m1_1, m2_1, m2_2, m2_3, T1, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1\n nu_T1 = [nu1, nuA]\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\n fs.integrate(nu_T1, T1, m=mig1)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1, nu2, nu3]\n mig2 = numpy.array([[0, m2_1, m2_3],[m2_1, 0, m2_2], [m2_3, m2_2, 0]]) \n fs.integrate(nu_T2, T2, m=mig2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1, nu2, nu3]\n fs.integrate(nu_T3, T3) \n return fs","def connection(self, sampleseq, num):\n self.Adjmatrix = np.zeros((self.nodenum, self.nodenum), dtype = int)\n \n for i in range(self.supplynum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.trandemandseries], sampleseq[self.supplyseries[i]]))\n self.Adjmatrix[self.supplyseries[i], self.trandemandseries[minindex]] = 1\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\n \n for i in range(self.trannum):\n if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) == 0):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\n self.Adjmatrix[minindex, self.transeries[i]] = 1\n# self.Adjmatrix[self.transeries[i], minindex] = 1\n \n \n# for i in range(self.supplynum):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.supplyseries], num))\n# self.Adjmatrix[self.supplyseries[i], minindex] = 1\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\n \n# for i in range(self.trannum):\n# if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) != 0):\n# continue\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\n## self.Adjmatrix[self.transeries[i], minindex] = 1\n# \n for i in range(self.trannum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.demandseries], min(sampleseq[self.transeries[i]], self.demandnum))) + self.supplynum + self.trannum\n self.Adjmatrix[self.transeries[i], minindex] = 1\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\n \n# for i in range(self.demandnum):\n# if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], 1)) + self.supplynum\n# self.Adjmatrix[minindex, self.demandseries[i]] = 1\n \n# for i in range(self.trannum):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.transeries], num)) + self.supplynum\n# self.Adjmatrix[self.transeries[i], minindex] = 1\n \n for i in range(self.demandnum):\n if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], num)) + self.supplynum\n self.Adjmatrix[minindex, self.demandseries[i]] = 1\n# self.Adjmatrix[self.demandseries[i], minindex] = 1\n \n for i in range(self.demandnum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.demandseries[i], self.demandseries], min(sampleseq[self.demandseries[i]] + 1, self.demandnum))) + self.supplynum + self.trannum\n minindex = minindex[1:-1]\n for j in range(len(minindex)):\n if(self.Adjmatrix[self.demandseries[i], minindex[j]] == 1 or self.Adjmatrix[minindex[j], self.demandseries[i]] == 1):\n continue\n self.Adjmatrix[self.demandseries[i], minindex[j]] = 1","def power_iteration(self, adjacency_matrix, old_unique_id):\n convergence = False\n iteration = 0\n\n degree_with_beta = adjacency_matrix.sum(axis=0).T / self.beta\n\n # Initializing a vector\n r_0 = np.ones((self.num_nodes, 1)) / self.num_nodes\n\n while not convergence:\n\n # Ignoring division by 0\n with np.errstate(divide='ignore'):\n # Calculating the Matrix-by-Vector product r_1\n r_1 = adjacency_matrix.dot(r_0 / degree_with_beta)\n\n r_1 += (1 - r_1.sum()) / self.num_nodes\n\n # Convergence condition\n norm = np.linalg.norm(r_0 - r_1, ord=1)\n if norm < self.epsilon:\n convergence = True\n\n # Reassign vector r_0\n r_0 = r_1\n iteration += 1\n\n print(\"Iteration : \", iteration, ' Norm:', norm)\n\n print(\"Resulting PageRank array:\", r_0)\n print()\n print(\"Element with the lowest PageRank:\", old_unique_id[np.argmin(r_0)])\n print(\"Element with the highest PageRank:\", old_unique_id[np.argmax(r_0)])\n print()","def deg_mat(adj_mat, size, vertices):\n deg_mat = np.zeros((size,size))\n for i in vertices:\n deg_mat[i][i] = degree(adj_mat, i)\n return deg_mat","def get_equation_matrix(obj_dict, node_dict):\n\n v_src_count = len(obj_dict['V'])\n v_src_map = {}\n for ind in range(len(obj_dict['V'])):\n v_src_map[obj_dict['V'][ind].name] = ind \n \n node_count = len(node_dict.keys())-1 # excluded GND\n \n A = np.zeros((node_count, node_count), dtype='complex') # top left quad\n B = np.zeros((node_count, v_src_count), dtype='complex') # top right quad\n aux = np.zeros((v_src_count, node_count), dtype='complex') # bottom left quad\n zero_quad = np.zeros((v_src_count,v_src_count), dtype='complex') # bottom right quad\n const_vec_nodes = np.zeros((node_count), dtype='complex')\n const_vec_aux = np.zeros((v_src_count), dtype='complex')\n\n for k in obj_dict.keys():\n lst = obj_dict[k]\n for obj in lst:\n n1 = node_dict[obj.n1]-1\n n2 = node_dict[obj.n2]-1\n value = obj.value\n\n if obj.el_type in 'RLC':\n if obj.imp == None: # dc\n if obj.el_type == 'L':\n value = EPS\n elif obj.el_type == 'C':\n value = INF\n else:\n value = obj.imp + EPS\n\n if n1 != -1 and n2 != -1:\n A[n1,n1] += 1/value\n A[n1,n2] += -1/value\n A[n2,n1] += -1/value\n A[n2,n2] += 1/value\n\n elif n1 == -1:\n A[n2,n2] += 1/value\n\n elif n2 == -1:\n A[n1,n1] += 1/value\n\n elif obj.el_type == 'V':\n nv = v_src_map[obj.name]\n if n1 != -1 and n2 != -1:\n B[n1,nv] += 1\n B[n2,nv] += -1\n aux[nv,n1] += 1\n aux[nv,n2] += -1\n \n elif n1 == -1:\n B[n2,nv] += -1\n aux[nv,n2] += -1\n \n elif n2 == -1:\n B[n1,nv] += 1\n aux[nv,n1] += 1\n\n const_vec_aux[nv] += value\n\n elif obj.el_type == 'I':\n if n1 != -1 and n2 != -1:\n const_vec_nodes[n1] += obj.value\n const_vec_nodes[n2] += -obj.value\n elif n1 == -1:\n const_vec_nodes[n2] += -obj.value\n elif n2 == -1:\n const_vec_nodes[n1] += obj.value\n\n elif obj.el_type in 'EGHF':\n print(\"ERR: Controlled sources not supported yet\")\n return None\n\n top_half = np.concatenate((A, B), axis=1) \n bot_half = np.concatenate((aux, zero_quad), axis=1)\n coeff_mat = np.concatenate((top_half, bot_half), axis=0)\n const_vec = np.concatenate((const_vec_nodes, const_vec_aux), axis=0)\n\n return [coeff_mat, const_vec]","def generate_full_adj(self):\n adj_mat = np.ones([self.n_balls, self.n_balls])\n adj_mat -= np.eye(self.n_balls)\n\n int_st = self.interaction_strength * adj_mat\n lengths = adj_mat.copy()\n return adj_mat, int_st, lengths","def block_adjacency_matrix(self, block_id, ctx): # -> tuple[Unknown, Unknown]:\n ...","def refugia_adj_4(params, ns):\n #11 parameters \n nu1, nuA, nu2, nu3, m1_1, m3_2, m3_3, T1a, T1b, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1a\n nu_T1 = [nu1, nuA]\n fs.integrate(nu_T1, T1a)\n ## Population function and migration matrix for T1b\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\n fs.integrate(nu_T1, T1b, m=mig1) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1, nu2, nu3]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1, nu2, nu3]\n mig3 = numpy.array([[0, 0, 0],[0, 0, 0], [m3_3, m3_2, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def main():\n n = 34\n # create the adjacency matrix\n stripped_lines = Util.get_stripped_lines(g_karate_data.splitlines())\n string_rows = [line.split() for line in stripped_lines if line]\n assert len(string_rows) == n\n for row in string_rows:\n assert len(row) == n\n data_rows = [[float(x) for x in string_row] for string_row in string_rows]\n A = np.array(data_rows)\n # create the ordered module indices\n first_cluster_one_based_indices = [1, 3, 4, 14, 2, 8, 20, 18, 22, 13, 12, 6, 7, 17, 5, 11]\n second_cluster_one_based_indices = [25, 32, 26, 29, 24, 28, 9, 34, 33, 19, 16, 31, 15, 10, 23, 30, 21, 27]\n assert len(first_cluster_one_based_indices + second_cluster_one_based_indices) == n\n assert list(sorted(first_cluster_one_based_indices + second_cluster_one_based_indices)) == range(1, n+1)\n ordered_module_indices = []\n for i in range(n):\n if i+1 in first_cluster_one_based_indices:\n ordered_module_indices.append(0)\n else:\n ordered_module_indices.append(1)\n # print the modularity\n Q = get_modularity_other_b(A, ordered_module_indices)\n print 'modularity calculated using my interpretation of the method of the paper', Q\n Q = get_modularity_other_b2(A, ordered_module_indices)\n print 'modularity calculated using a modification of my interpretation of the method of the paper', Q\n Q = get_modularity_other_c(A, ordered_module_indices)\n print 'modularity calculated using the method on wikipedia', Q\n Q = get_eric_modularity(A, ordered_module_indices)\n print 'modularity calculated using the method eric used:', Q\n print 'expected modularity: .375 +/- .025'","def degree(adj_mat, vertex):\n return np.sum(adj_mat[vertex][:])","def __get_pairwise(self, image):\n # We will use the adjacency matrix\n\n P=[]\n (n,m, _)= image.shape\n\n sigma=5\n def B(p,q):\n Ip=np.mean(p) # Itensity\n Iq=np.mean(q)\n \n return np.exp(-0.5*((Ip-Iq)/sigma)**2 ) \n \n L=[]\n for i in range(n):\n for j in range(m):\n L.append(image[i,j])\n image_flat=np.array(L)\n for i in range(n*m-m):\n B01=B(image_flat[i], image_flat[i+1])\n B01_=B(image_flat[i], image_flat[i+m])\n \n P.append([i,i+m,0,B01_,B01_,0]) # vertice with the node below\n if i %(m-1)!=0: # Check if it is not the end of a line\n P.append([i,i+1,0,B01,B01,0]) # vertice with the node on the right \n \n for i in range(n*m-m,n*m-1):\n B01__=B(image_flat[i], image_flat[i+1])\n P.append([i,i+1,0,B01__,B01__,0])\n\n \n return np.array(P)","def original_solution():\n matrix = get_data()\n # Construct Graph\n G = nx.DiGraph()\n rows, cols = len(matrix), len(matrix[0])\n for r in xrange(rows):\n for c in xrange(cols):\n if 0 < c:\n G.add_edge(r*cols + c, r*cols + c - 1, weight=matrix[r][c-1])\n if c < cols-1:\n G.add_edge(r*cols + c, r*cols + c + 1, weight=matrix[r][c+1])\n if 0 < r:\n G.add_edge(r*cols + c, (r-1)*cols + c, weight=matrix[r-1][c])\n if r < rows-1:\n G.add_edge(r*cols + c, (r+1)*cols + c, weight=matrix[r+1][c])\n # Calculate shortest path\n path = nx.shortest_path(G, 0, rows*cols-1, weighted=True)\n \n # Get cost for path\n s = 0\n for p in path:\n c = p % cols\n r = (p - c) / rows\n s += matrix[r][c]\n return s","def rwgraph_analyze2(input=(None)):\r\n\r\n\r\n #set up graph and degree distribution arrays\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n Nt=100\r\n M=20000\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n\r\n #set inital conditions and D\r\n y0=np.zeros(n,dtype=int)\r\n y0[j]=200\r\n D=1\r\n #define time for odi Int\r\n t=np.arange(Nt+1,dtype=int)\r\n #set up operators\r\n A = nx.adjacency_matrix(G)\r\n Q = A.toarray().sum(axis=1)\r\n L=np.diag(Q)-A.toarray()\r\n Q_inv=1/Q\r\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\r\n Ls_tran=np.transpose(Ls)\r\n\r\n #convert to sparse operators and include diffusion\r\n L_spar = scipy.sparse.csr_matrix(-D*L)\r\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\r\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\r\n A=nx.adjacency_matrix(G)\r\n L=-D*(scipy.sparse.diags(degree_arr)-A)\r\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\r\n\r\n #define operators\r\n def Lap(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\r\n def Lap_Ls(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\r\n def Lap_Ls_tran(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\r\n\r\n #solutions of different operators\r\n solL=scipy.integrate.odeint(Lap,y0,t)\r\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\r\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\r\n\r\n\r\n #finds eigen values and vectors and puts them into order\r\n def eigen(L):\r\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\r\n idx = eigen_values.argsort()[::-1]\r\n eigen_values = eigen_values[idx]\r\n eigen_vectors = eigen_vectors[:,idx]\r\n return eigen_values,eigen_vectors\r\n\r\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\r\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\r\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\r\n eigen_values_L,eigen_vectors_L=eigen(L)\r\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\r\n\r\n ### could have eigs here as didn't end up using all eigenvalues ####\r\n #eigen values graph\r\n n0=len(eigen_values_L)\r\n eig_nums=np.arange(n0)\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\"x\" ,label='L , D=0.36')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\"|\",label='LS , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\"+\" ,label='L , D=1')\r\n plt.legend(loc=\"lower left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.xlabel('eigen value number')\r\n plt.ylabel('eigenvalue')\r\n plt.title(\"Eigenvlaues of Laplacian Matrixs\")\r\n plt.show()\r\n\r\n print(\"4 biggest eigenvalues for each operater\")\r\n print('L=',eigen_values_L[0:4])\r\n print('Ls=',eigen_values_LS[0:4])\r\n print('Ls_tran=',eigen_values_LS_tran[0:4])\r\n #prints 4 biggest eigen values\r\n #counts node distrubtion by creating dictionary\r\n def result_count(sol,Nt,G):\r\n \"\"\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\"\"\"\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq\r\n\r\n #frequency count of solutions\r\n dict_freq=result_count(solL,Nt,G)\r\n dict_freq2=result_count(solLs,Nt,G)\r\n dict_freq3=result_count(solLs_tran,Nt,G)\r\n\r\n #random walk data\r\n X=rwgraph(G,j,20000,100)\r\n Listnodes7=[]\r\n for i in range(20000):\r\n Listnodes7.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,200,100)\r\n Listnodes8=[]\r\n for i in range(200):\r\n Listnodes8.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,50000,5000)\r\n Listnodes9=[]\r\n for i in range(50000):\r\n Listnodes9.append(G.degree(X[i,5000]))\r\n listfreq7=CountFrequency(Listnodes7)\r\n listfreq8=CountFrequency(Listnodes8)\r\n listfreq9=CountFrequency(Listnodes9)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n z2=[]\r\n z3=[]\r\n z1=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n z_deg1=[]\r\n for i in listfreq7:\r\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq8:\r\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n for i in listfreq8:\r\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\r\n z_deg1.append(i)\r\n #operator solutions compared to node degree frequency\r\n z4,z5,z6=[],[],[]\r\n z_deg4,z_deg5,z_deg6=[],[],[]\r\n for i in dict_freq:\r\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\r\n z_deg4.append(i)\r\n for i in dict_freq2:\r\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\r\n z_deg5.append(i)\r\n for i in dict_freq3:\r\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\r\n z_deg6.append(i)\r\n\r\n plt.figure(figsize=(15, 10))\r\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\r\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\r\n plt.scatter(z_deg4, z4,label='L, Nt=100')\r\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\r\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\r\n plt.ylim((-0.005,0.020))\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n\r\n #code to produce final graph\r\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\r\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\r\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\r\n tarray = np.linspace(0,5,Nt+1)\r\n plt.figure(figsize=(12, 6))\r\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\r\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\r\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\r\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\r\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\r\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\r\n plt.xlabel('time')\r\n plt.ylabel('representive frequency')\r\n plt.legend()\r\n plt.title(\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\")\r\n plt.show()\r\n return None #modify as needed\r","def _learn_node_parameter_w(outputs, inputs=None):\n num_inputs = 0 if inputs is None else inputs.shape[1]\n weights = np.zeros(shape=num_inputs + 1)\n\n \"\"\" YOUR CODE HERE \"\"\"\n # Ax = b, A\n N_observe = outputs.shape[0]\n A = np.zeros(shape = (num_inputs+1, num_inputs+1))\n for i in range(A.shape[0]):\n for j in range(A.shape[1]):\n if i==0 and j==0:\n A[i][j] = N_observe\n elif i==0 and j!=0:\n A[i][j] = np.sum(inputs[:,j-1])\n elif i!=0 and j==0:\n A[i][j] = np.sum(inputs[:,i-1])\n else:\n for k in range(N_observe):\n A[i][j] += inputs[k,i-1]*inputs[k, j-1]\n b = np.zeros(shape=num_inputs + 1)\n for i in range(len(b)):\n if i==0:\n b[i] = np.sum(outputs)\n else:\n for k in range(N_observe):\n b[i] += inputs[k,i-1]*outputs[k]\n\n weights = np.linalg.solve(A, b)\n \"\"\" END YOUR CODE HERE \"\"\"\n\n return weights","def vertex_adjacency_matrix(self):\n if '_V_adjacency_matrix' not in self.__dict__:\n self._init_vertex_adjacency_matrix()\n return self._V_adjacency_matrix;","def circulant_adj(js, num_vertices):\n\n # make a fresh/empty adjacency matrix\n adj = np.zeros((num_vertices, num_vertices), dtype=\"uint8\")\n\n # make a connect between each node and a node\n # that is j spaces to the left and to right of the node\n for i in range(num_vertices):\n for j in js:\n adj[i][(i - j) % num_vertices] = 1\n adj[i][(i + j) % num_vertices] = 1\n\n return adj","def convert_sparse_to_igraph(indices, matrix):\n # sources, targets = matrix.nonzero()\n # weights = matrix[sources, targets]\n # weights = np.array(weights)[0]\n # print(dir(louvain))\n # ig = igraph.Graph(zip(sources, targets), directed=True,\n # edge_attrs={'weight': weights})\n # return ig\n g = igraph.Graph.Adjacency((matrix > 0).tolist())\n g.es['weight'] = matrix[matrix.nonzero()]\n # g.vs['label'] = node_names # or a.index/a.columns\n return g","def adjacency_matrix(g):\n nodes = sorted(g.keys())\n adj = []\n for row_node in nodes:\n row = []\n for column_node in nodes:\n if column_node in g[row_node]:\n row.append(1)\n else:\n row.append(0)\n adj.append(row)\n \n return adj","def NPL(self):\n self.edge = np.zeros((np.sum(self.Adjmatrix), 3))\n Temp = 0\n for i in range(self.nodenum):\n for j in range(self.nodenum):\n if(self.Adjmatrix[i, j] == 1):\n self.edge[Temp, 0], self.edge[Temp, 1], self.edge[Temp, 2] = i, j, self.Dismatrix[i, j]\n Temp += 1\n \n self.Totallength = ((np.max(self.Geox) - np.min(self.Geox))**2 + (np.max(self.Geoy) - np.min(self.Geoy))**2)**0.5\n self.norm_edge = self.edge[:, 2]/self.Totallength","def _updateTransitionMatrix(self):\n N = self.N\n K = self.K\n T= self.T\n\n for i in range(1,self.K+1):\n den = 0\n for t in range(1,self.T):\n for n in range(1,N+1):\n den = den + self.posterior_state_trellis[n][(t,i)]\n \n for j in range(1,self.K+1): \n # For some state i,j\n s = 0\n for n in range(1,N+1): \n for t in range(1,self.T): \n cur_prob = self.posterior_transition_trellis[n][(t,t+1,j,i)]\n s = s+cur_prob\n\n # Compute total \n self.state_transition_mat[(j,i)] = (s/den)","def _initializeAdjacencyList(self):\n\n if self.comm.rank == 0:\n # First, create a dictionary of common edges shared by components\n edgeToFace = {}\n for elemID in self.bdfInfo.elements:\n elemInfo = self.bdfInfo.elements[elemID]\n elemConn = elemInfo.nodes\n compID = self.meshLoader.nastranToTACSCompIDDict[elemInfo.pid]\n nnodes = len(elemConn)\n if nnodes >= 2:\n for j in range(nnodes):\n nodeID1 = elemConn[j]\n nodeID2 = elemConn[(j + 1) % nnodes]\n\n if nodeID1 < nodeID2:\n key = (nodeID1, nodeID2)\n else:\n key = (nodeID2, nodeID1)\n\n if key not in edgeToFace:\n edgeToFace[key] = [compID]\n elif compID not in edgeToFace[key]:\n edgeToFace[key].append(compID)\n\n # Now we loop back over each element and each edge. By\n # using the edgeToFace dictionary, we can now determine\n # which components IDs (jComp) are connected to the\n # current component ID (iComp).\n self.adjacentComps = []\n\n for edgeKey in edgeToFace:\n if len(edgeToFace[edgeKey]) >= 2:\n for i, iComp in enumerate(edgeToFace[edgeKey][:-1]):\n for jComp in edgeToFace[edgeKey][i + 1 :]:\n if iComp < jComp:\n dvKey = (iComp, jComp)\n else:\n dvKey = (jComp, iComp)\n if dvKey not in self.adjacentComps:\n self.adjacentComps.append(dvKey)\n\n else:\n self.adjacentComps = None\n\n # Wait for root\n self.comm.barrier()","def get_adjacency_matrix(self):\n m = zeros(self.size)\n perm = self.array_form\n for i in xrange(self.size - 1):\n m[perm[i], perm[i + 1]] = 1\n return m","def internal_adjacency(self, node_list):\n # Create igraph Graph object describing the subgraph\n subgraph = self.graph.subgraph(node_list)\n # Get adjacency matrix\n return np.array(subgraph.get_adjacency(type=2).data).astype(np.int8)","def calc_dependency_matrix(encoder: nn.Module, latents: torch.Tensor) -> torch.Tensor:\n\n # calculate the jacobian\n jacob = jacobian(encoder.forward, latents)\n # take the absolute value\n return jacob.abs()","def compute_node_dissociation_index(community_vect, sparse_mat):\n dense_mat = sparse_mat.todense()\n undir_dense_mat = dense_mat + np.transpose(dense_mat)\n bin_dense_mat = np.array(undir_dense_mat != 0, dtype=int)\n\n degree_vect = np.array(np.sum(bin_dense_mat != 0, axis=1), dtype='float')\n community_indexes = np.unique(community_vect)\n\n ndi_values = np.ones(\n shape=(community_vect.shape[0]), dtype='float')\n\n for i in range(ndi_values.shape[0]):\n\n \"\"\"\n same_com = np.where(\n np.array([community_vect[i] == community_vect[j] for j in\n range(ndi_values.shape[0])],dtype = \"bool\") == True)\n\n print (same_com[0])\n\n val = 1.0-(np.sum(bin_dense_mat[i,\n same_com[0]])/float(degree_vect[i]))\n \"\"\"\n\n val2 = 0.0\n\n for j in community_indexes:\n if j != -1 and j != community_vect[i]:\n val2 += np.sum(bin_dense_mat[i, community_vect == j])\n\n if degree_vect[i]:\n ndi_values[i] = val2/float(degree_vect[i])\n\n else:\n print(\"Warning, degree is null for node {}\".format(i))\n print(bin_dense_mat)\n\n ndi_values[i] = 0.0\n\n return ndi_values","def cost_change(adjacency_matrix, n1, n2, n3, n4):\n return adjacency_matrix[n1][n3] + adjacency_matrix[n2][n4] - \\\n adjacency_matrix[n1][n2] - adjacency_matrix[n3][n4]","def find_topo_order(s,graph):\n\n ## initialization\n matrix = graph.get_adjacency()\n n, c = matrix.shape\n sym_matrix = np.empty((n,c), dtype=object)\n # cost_matrix = np.zeros((n,c))\n cache = {}\n\n def symbolize(i,j):\n \"given two indices, create a symbolic variable\"\n s = z.Int('edge_{0}{1}'.format(i,j))\n return s\n\n\n def value_of(i,j):\n \"given two indices, return the (i,j)th value in the adjacency matrix\"\n return sym_matrix[i][j]\n\n\n def constraint_1(n,i,j,k):\n y_ij = value_of(i,j)\n y_jk = value_of(j,k)\n y_ik = value_of(i,k)\n\n name = \"c1\" + str((n,i,j,k))\n constraint = (y_ij + y_jk - y_ik) <= 1\n\n # if name not in cache:\n # cache[name] = constraint\n s.assert_and_track(constraint, name)\n\n\n def constraint_2(n,i,j,k):\n y_ij = value_of(i,j)\n y_jk = value_of(j,k)\n y_ik = value_of(i,k)\n\n name = \"c2\" + str((n,i,j,k))\n constraint = (-y_ij - y_jk + y_ik) <= 0\n\n # if name not in cache:\n # cache[name] = constraint\n s.assert_and_track(constraint, name)\n\n\n def constraint_3(symbolic):\n s.add(z.Or([symbolic == 0, symbolic == 1]))\n\n\n def int_formulation(j):\n left = z.Sum([matrix[k][j] * sym_matrix[k][j] for k in range(j)])\n right = z.Sum([matrix[l][j] * (1 - sym_matrix[j][l]) for l in range(j+1, n)])\n\n return [left, right]\n\n\n ## constraint 3, every edge must be a 0 or a 1, we get the 0 or 1 directly\n ## from the adjacency matrix\n ## we do this first so that the sym_matrix is populated\n for n_iter in range(n):\n for j in range(n_iter+1):\n for i in range(j):\n s_edge = symbolize(i,j)\n sym_matrix[i][j] = s_edge\n constraint_3(s_edge)\n\n ## Iteration for triangle inequalities\n for n_iter in range(n):\n for k in range(n_iter+1):\n for j in range(k):\n for i in range(j):\n constraint_1(n_iter,i,j,k)\n constraint_2(n_iter,i,j,k)\n\n\n ## minimization\n o = z.Optimize()\n y = z.Int('y')\n\n y = z.Sum(u.flatten([int_formulation(j) for j in range(n)]))\n o.minimize(y)\n\n result = []\n\n if s.check() == z.sat:\n result = s.model()\n\n return result","def generate_adjacents(node):\n # Makes a dictionary where keys are current upper token positions and\n # values are the list of positions attainable from one slide move\n slide_moves = {}\n for key, value in node.boardstate.items():\n if value.isupper() and value != \"B\":\n slide_moves[key] = get_slide_moves(key, node.boardstate)\n\n # Append list of swing moves to get all moves\n moves_dict = {}\n #relevant_pieces = [name ]\n for key in slide_moves:\n all_moves = set(slide_moves[key] + get_swing_moves(key, slide_moves))\n moves_dict[key] = list(all_moves)\n\n # Convert from dictionary to list of list of tuples of the form:\n #[[(curr_move, next_move)...]...] where each tokens moves occupy a list\n moves_list = []\n for curr, news in moves_dict.items():\n moves_list.append([(curr, new) for new in news])\n\n # Get all combinations of moves and for each combo construct a new board state\n adjacent_states = []\n turns = list(product(*moves_list))\n\n for turn in turns:\n new_board = apply_turn(node, turn)\n if new_board:\n adjacent_states.append((turn, new_board))\n return adjacent_states","def build_AGS_matrix(mesh: meshio.Mesh) -> tf.sparse.SparseTensor:\n\n tf_indices: List\n tf_values: List\n tf_shape: Tuple[int]\n tf_indices, tf_values, tf_shape = [], [], (3 * len(mesh.points), len(mesh.points))\n rot: np.ndarray = np.array([[0, -1, 0], [1, 0, 0], [0, 0, 0]])\n\n prev: int\n curr: int\n next: int\n vid: int\n prev_triangle: np.ndarray\n curr_triangle: np.ndarray\n area: float\n c_prev: float\n c_next: float\n vert_contr: List\n indx_node: int\n node: np.ndarray\n i: int\n for indx_node, node in enumerate(mesh.points):\n triangles: List[Tuple[int]]\n flag_b: bool \n triangles, flag_b = get_cycle(mesh, indx_node)\n if len(triangles) > 0:\n prev_triangle = triangles[0]\n area = 0.0\n vert_contr = []\n for i in range(1, len(triangles) + (1 - int(flag_b))):\n curr_triangle = triangles[i % len(triangles)]\n vid = curr_triangle[1]\n\n prev = prev_triangle[0]\n curr = prev_triangle[2]\n next = curr_triangle[2]\n\n if i == 0 and flag_b: area += get_area_from_points(mesh, (prev, vid, curr))\n\n area += get_area_from_points(mesh, (curr, vid, next))\n\n c_prev = np.matmul(rot, (mesh.points[curr] - mesh.points[prev]))\n c_next = np.matmul(rot, (mesh.points[next] - mesh.points[curr]))\n\n vert_contr.append((curr, 0.5 * (c_prev + c_next)))\n\n if flag_b:\n if i == 0:\n vert_contr.append((vid, 0.5 * (c_prev)))\n if i == len(triangles) - 1:\n vert_contr.append((vid, 0.5 * (c_next)))\n\n prev_triangle = curr_triangle\n\n for col, value in vert_contr:\n for i in range(3):\n tf_indices.append([indx_node * 3 + i, col])\n tf_values.append(value[i] / area)\n\n Sp_tf_AGS_matrix: tf.sparse.SparseTensor = tf.sparse.SparseTensor(\n tf_indices, tf.cast(tf_values, dtype=tf.float32), tf_shape\n )\n\n return Sp_tf_AGS_matrix","def construct_4adj_graph(X):\n s0, s1, s2 = X.shape\n \n size_data = s0*s1\n \n xGrid, yGrid = np.meshgrid(np.arange(s0), np.arange(s1))\n totGrid = (xGrid*s1 + yGrid).transpose()\n \n horiz_edges = np.sqrt(np.sum((X[1:,:,:] - X[:-1,:,:])**2, axis=-1).flatten())\n indx_horiz_edges = totGrid[1:,:].flatten()\n indy_horiz_edges = totGrid[:-1,:].flatten()\n \n vert_edges = np.sqrt(np.sum((X[:,1:,:] - X[:,:-1,:])**2, axis=-1).flatten())\n indx_vert_edges = totGrid[:,1:].flatten()\n indy_vert_edges = totGrid[:,:-1].flatten()\n \n w = np.concatenate((horiz_edges, vert_edges), axis=0) + 1e-6\n u = np.concatenate((indx_horiz_edges, indx_vert_edges), axis=0)\n v = np.concatenate((indy_horiz_edges, indy_vert_edges), axis=0)\n \n return sp.sparse.csr_matrix((w,(u,v)), shape=(size_data, size_data))","def adj_matrix(self):\n return nx.adj_matrix(self.network)","def _estimate_assignments(self, graph: GraphRepresentation) -> None:\n embed_graph = augment_diagonal(graph)\n latent = AdjacencySpectralEmbed(\n n_components=self.n_components, **self.embed_kws\n ).fit_transform(embed_graph)\n if isinstance(latent, tuple):\n latent = np.concatenate(latent, axis=1)\n gc = GaussianCluster(\n min_components=self.min_comm,\n max_components=self.max_comm,\n **self.cluster_kws\n )\n vertex_assignments = gc.fit_predict(latent) # type: ignore\n self.vertex_assignments_ = vertex_assignments","def additive_phylogeny(matrix, n, G):\n new_node = n\n\n def additive_recur_helper(matrix, n, G):\n\n nonlocal new_node\n\n if n == 2:\n print(\"d add_edge (%s,%s):%s\" % (0, 1, matrix[0, 1]))\n G.add_edge(0, 1, weight=matrix[0, 1])\n return\n\n limblen = limblength(n - 1, matrix)\n i, k = find_i_k(matrix, n - 1, limblen)\n x = matrix[i, n - 1] - limblen\n\n print(\"n=%s limblen=%s i=%s k=%s x=%s\" % (n, limblen, i, k, x))\n\n additive_recur_helper(matrix[0 : n - 1, 0 : n - 1], n - 1, G)\n\n v = node_at_distance(G, i, k, x, matrix[i, k], new_node)\n if v == new_node:\n new_node += 1\n\n print(\"node_at_distance %s from %s is %s\" % (x, i, v))\n\n print(\"e add_edge (%s,%s):%s\" % (v, n - 1, limblen))\n G.add_edge(v, n - 1, weight=limblen)\n\n # draw graph if small\n if len(G) < 30:\n global plot_cnt\n pos = nx.kamada_kawai_layout(G)\n labels = nx.get_edge_attributes(G, \"weight\")\n nx.draw(G, pos, with_labels=True)\n nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)\n plt.draw()\n plt.savefig(\"Graph\" + str(plot_cnt) + \".png\", format=\"PNG\")\n plt.clf()\n plot_cnt += 1\n\n return\n\n additive_recur_helper(matrix, n, G)\n\n return","def contracting_channel(m, n, W_upstream = 1., W_downstream = 0.75,\n L_1 = 5.0, L_2 = 2.0, L_3 = 10, origin = (0.0, 0.0)):\n\n import math\n\n from anuga.config import epsilon\n\n\n lenx = L_1 + L_2 + L_3\n leny = W_upstream\n deltax = lenx/float(m)\n deltay = leny/float(n)\n\n x1 = 0\n y1 = 0\n x2 = L_1\n y2 = 0\n x3 = L_1 + L_2\n y3 = (W_upstream - W_downstream)/2\n x4 = L_1 + L_2 + L_3\n y4 = y3\n x5 = x4\n y5 = y4 + W_downstream\n x6 = L_1 + L_2\n y6 = y5\n x7 = L_1\n y7 = W_upstream\n x8 = 0\n y8 = W_upstream\n a1 = 0\n a2 = (W_upstream - W_downstream)/(2*L_2)\n a3 = 1\n a4 = (W_downstream - W_upstream)/(L_2*W_upstream)\n\n # Dictionary of vertex objects\n vertices = {}\n points = []\n\n for i in range(m+1):\n x = deltax*i\n for j in range(n+1):\n y = deltay*j\n if x > L_1 and x <= (L_1 + L_2):\n y = a1 + a2*(x - L_1) + a3*y + a4*(x - L_1)*y\n elif x > L_1 + L_2:\n y = (W_upstream - W_downstream)/2 + deltay*j*W_downstream/W_upstream\n\n vertices[i,j] = len(points)\n points.append([x + origin[0], y + origin[1]])\n\n # Construct 2 triangles per element\n elements = []\n boundary = {}\n for i in range(m):\n for j in range(n):\n v1 = vertices[i,j+1]\n v2 = vertices[i,j]\n v3 = vertices[i+1,j+1]\n v4 = vertices[i+1,j]\n\n #Update boundary dictionary and create elements\n if i == m-1:\n boundary[(len(elements), 2)] = 'right'\n if j == 0:\n boundary[(len(elements), 1)] = 'bottom'\n elements.append([v4,v3,v2]) #Lower\n\n if i == 0:\n boundary[(len(elements), 2)] = 'left'\n if j == n-1:\n boundary[(len(elements), 1)] = 'top'\n\n elements.append([v1,v2,v3]) #Upper\n\n return points, elements, boundary","def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\n\n\n\n\n path = [starting_car_location]\n dict = {}\n index = 0\n for i in range(len(list_of_locations)):\n if list_of_locations[i] == starting_car_location:\n index = i\n\n path = [index]\n\n G, m = adjacency_matrix_to_graph(adjacency_matrix)\n\n home_indexes = []\n\n for home in list_of_homes:\n for i in range(len(list_of_locations)):\n if list_of_locations[i] == home:\n home_indexes.append(i)\n break\n\n new_adjacency = [[\"x\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\n\n # for sake of figuring out where to walk\n for home in home_indexes:\n di_path = nx.dijkstra_path(G, index, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n for home1 in home_indexes:\n for home2 in home_indexes:\n if not home1 == home2:\n di_path = nx.dijkstra_path(G, home1, home2)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n\n\n G2, m = adjacency_matrix_to_graph(new_adjacency)\n\n all_driving_path = list(nx.dfs_edges(G2))\n\n\n\n\n walking_to = []\n walking_from = {}\n\n for i in range(len(new_adjacency)):\n if i in home_indexes:\n count = 0\n edge_to = 0\n for j in range(len(new_adjacency)):\n if new_adjacency[i][j] != \"x\":\n count += 1\n edge_to = j\n\n #must ensure that this is not a home that we are already dropping someone off at, otherwise it will cut off a line of two homes\n if count == 1 and i != index and i not in walking_from.keys():\n new_adjacency[i][edge_to] = \"x\"\n new_adjacency[edge_to][i] = \"x\"\n walking_to.append(i)\n if edge_to in walking_from:\n walking_from[edge_to] = walking_from[edge_to] + [i]\n else:\n walking_from[edge_to] = [i]\n\n #\n # for i in range(len(all_driving_path) - 1):\n # #if first vertex in edge is the same, we should walk\n # if all_driving_path[i][0] == all_driving_path[i + 1][0]:\n # print(all_driving_path[i][0])\n # print(all_driving_path[i][1])\n # #get rid of only edge connected to this home\n # new_adjacency[all_driving_path[i][0]][all_driving_path[i][1]] = \"x\"\n # new_adjacency[all_driving_path[i][1]][all_driving_path[i][0]] = \"x\"\n # walking_to.append(all_driving_path[i][1])\n # if all_driving_path[i][0] in walking_from:\n # walking_from[all_driving_path[i][0]] = walking_from[all_driving_path[i][0]] + [all_driving_path[i][1]]\n # else:\n # walking_from[all_driving_path[i][0]] = [all_driving_path[i][1]]\n\n\n\n dropoff_locations = list(walking_from.keys())\n for loc in dropoff_locations:\n if loc in home_indexes:\n dropoff_locations.remove(loc)\n\n\n for loc in dropoff_locations:\n di_path = nx.dijkstra_path(G, loc, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n for home in home_indexes:\n di_path = nx.dijkstra_path(G, loc, home)\n for i in range(len(di_path) - 1):\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\n\n\n G2, m = adjacency_matrix_to_graph(new_adjacency)\n # G = G2\n # pos=nx.spring_layout(G2)\n # nx.draw_networkx_nodes(G2,pos)\n # nx.draw_networkx_labels(G2, pos)\n # nx.draw_networkx_edges(G2,pos,width=1.0,alpha=0.5)\n #\n # plt.draw()\n # plt.show()\n\n # condensed shortest paths to edges - use G3 for real\n\n new_adjacency2 = [[\"x\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\n\n for home in home_indexes:\n if home not in walking_to:\n di_path = nx.dijkstra_path(G2, index, home)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n\n for home1 in home_indexes:\n for home2 in home_indexes:\n if not home1 == home2 and home1 not in walking_to and home2 not in walking_to:\n di_path = nx.dijkstra_path(G2, home1, home2)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n di_path = nx.dijkstra_path(G2, index, loc)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n for loc in dropoff_locations:\n for home in home_indexes:\n di_path = nx.dijkstra_path(G2, loc, home)\n start = di_path[0]\n end = di_path[len(di_path) - 1]\n new_adjacency2[start][end] = 0\n new_adjacency2[end][start] = 0\n for i in range(len(di_path) - 1):\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\n\n\n\n\n final_G, m = adjacency_matrix_to_graph(new_adjacency2)\n drive_path = list(nx.dfs_edges(final_G, source=index))\n drive_path.append(index)\n\n mst = nx.minimum_spanning_tree(final_G)\n\n\n\n new_mst = nx.MultiGraph(mst)\n for edge in mst.edges():\n new_mst.add_edge(edge[0], edge[1])\n\n\n if new_mst.degree[index] != 0:\n to_remove = []\n for node in new_mst:\n if (new_mst.degree[node] == 0):\n to_remove.append(node)\n new_mst.remove_nodes_from(to_remove)\n\n eulerian = list(nx.eulerian_circuit(new_mst, index))\n\n path = []\n for edge in eulerian:\n path.append(edge[0])\n\n path.append(eulerian[len(eulerian) - 1][1])\n\n already_seen = []\n to_remove = []\n for i in range(len(path) - 1):\n if path[i] in already_seen:\n to_remove.append(i)\n else:\n already_seen.append(path[i])\n\n new_path = []\n for i in range(len(path) - 1):\n if i not in to_remove:\n new_path.append(path[i])\n path = new_path\n print(eulerian)\n else:\n path = [index]\n print(path)\n\n\n\n\n\n\n\n # print(path)\n final_path = []\n for node in path:\n if node == index:\n final_path.append(node)\n # print(\"Index: \", node)\n elif node in home_indexes and node not in walking_to:\n final_path.append(node)\n # print(\"Home but not walking: \", node)\n elif node in dropoff_locations:\n final_path.append(node)\n # print(\"Dropoff loc: \", node)\n final_path.append(index)\n #print(walking_from)\n # print(final_path)\n # nx.draw(mst)\n # plt.draw()\n # plt.show()\n for node in final_path:\n if node in walking_from and node in home_indexes:\n dict[node] = [node] + walking_from[node]\n elif node in home_indexes:\n dict[node] = [node]\n elif node in walking_from:\n dict[node] = walking_from[node]\n\n very_final_path = []\n for i in range(len(final_path) - 1):\n condensed_path = nx.dijkstra_path(G2, final_path[i], final_path[i+1])\n for j in range(len(condensed_path) - 1):\n if condensed_path[j] != condensed_path[j + 1]:\n very_final_path.append(condensed_path[j])\n\n if len(very_final_path) >= 1 and [len(very_final_path) - 1] != index:\n very_final_path.append(index)\n\n if len(very_final_path) == 0:\n very_final_path = [index]\n\n print(very_final_path)\n print(dict)\n\n\n path2 = list(nx.dfs_preorder_nodes(mst, index))\n\n final_path2 = []\n for node in path2:\n if node == index:\n final_path2.append(node)\n # print(\"Index: \", node)\n elif node in home_indexes and node not in walking_to:\n final_path2.append(node)\n # print(\"Home but not walking: \", node)\n elif node in dropoff_locations:\n final_path2.append(node)\n # print(\"Dropoff loc: \", node)\n final_path2.append(index)\n\n\n for node in final_path2:\n if node in walking_from and node in home_indexes:\n dict[node] = [node] + walking_from[node]\n elif node in home_indexes:\n dict[node] = [node]\n elif node in walking_from:\n dict[node] = walking_from[node]\n\n very_final_path2 = []\n for i in range(len(final_path2) - 1):\n condensed_path = nx.dijkstra_path(G2, final_path2[i], final_path2[i+1])\n for j in range(len(condensed_path) - 1):\n if condensed_path[j] != condensed_path[j + 1]:\n very_final_path2.append(condensed_path[j])\n\n if len(very_final_path2) >= 1 and [len(very_final_path2) - 1] != index:\n very_final_path2.append(index)\n\n if len(very_final_path2) == 0:\n very_final_path2 = [index]\n\n opt1 = cost_of_solution(G, very_final_path, dict)\n opt2 = cost_of_solution(G, very_final_path2, dict)\n\n ultra_final_path = []\n if (opt1 <= opt2):\n ultra_final_path = very_final_path\n else:\n ultra_final_path = very_final_path2\n\n return ultra_final_path, dict\n\n pass","def refugia_adj_5_full_2_iter4 (params, ns):\n #33 parameters \n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\n nu_T0 = [nu1x, nuA]\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\n fs.integrate(nu_T0, T0, m=mig0)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def _build_adjacency_matrix_1(self):\n\n from scipy import sparse as sparse\n \n down_neighbour = np.empty(self.tri.npoints)\n\n for node in range (0,self.tri.npoints):\n down_neighbour[node] = self.neighbour_array_lo_hi[node][0]\n\n # Build a matrix of downhill-ness - one entry per node ! \n \n size = self.tri.npoints\n row_array = np.empty(size)\n col_array = np.empty(size)\n down_array = np.ones(size)\n\n # Catch cases where node is local low point (i.e. it is its own low neighbour)\n\n for row in range(0, self.tri.npoints): \n row_array[row] = row\n col_array[row] = down_neighbour[row]\n if row == down_neighbour[row]:\n down_array[row] = 0.0\n \n\n downMCOO = sparse.coo_matrix( (down_array, (row_array, col_array)), shape=(size,size) ).T \n\n self.adjacency1 = downMCOO.tocsr() \n\n # Catch pathological cases - sometimes if there is a flat spot on the boundary, then \n # the filling method above will produce a non-square matrix. This is caused by\n # repetition of values in the COO list which are summed on conversion.\n\n if downMCOO.shape[0] != downMCOO.shape[1]:\n # This approach works but is a lot slower\n\n print \"\"\"\n Warning: the downhill matrices require a slow build method. This is probably\n Because there are degeneracies in the slope - particularly at the boundaries\n A small random perturbation is usually enough to fix this problem\n \"\"\"\n downMat = sparse.lil_matrix((size, size))\n\n for row in range(0, self.tri.npoints): \n downMat[down_neighbour[row],row] = 1.0\n\n for row in range(0, self.tri.npoints): \n if down_neighbour[row] == row:\n downMat[row,row] = 0.0\n \n self.adjacency1 = downMat.T.tocsr() \n \n return","def assign_vertices(self):\n CV_matrix = np.zeros((self.n_c, self.n_v, 3))\n for i in range(3):\n CV_matrix[self.tris[:, i], np.arange(self.n_v), i] = 1\n self.CV_matrix = CV_matrix\n return self.CV_matrix","def get_score_matrix(self) -> int:","def _init_vertex_adjacency_matrix(self, verbose=False):\n self._init_from_cdd_input(self.cdd_Vrepresentation(),\n '--adjacency', verbose)","def __init__(self, adj_mat, directed = True):\n\n\t\tedges = 0\n\t\tadj_list = {i: [] for i in range(len(adj_mat))}\n\t\tfor i in range(len(adj_mat)):\n\t\t\tfor j in range(len(adj_mat)):\n\t\t\t\tif not adj_mat[i][j] == 0:\n\t\t\t\t\tadj_list[i].append(j)\n\t\t\t\t\tedges += 1\n\n\t\tself.adj_mat = copy.deepcopy(adj_mat)\n\t\tself.nodes = len(adj_mat)\n\t\tself.edges = edges\n\t\tself.is_directed = directed\n\t\tself.adj_list = adj_list\n\t\tself.active_nodes = [False for i in range(len(adj_mat))]\n\t\tself.theta = [nprnd.random() for i in range(len(adj_mat))]\n\t\tself.shapley_rank = dict()","def gen_graph(self):","def combinations(graph, all_combs, all_costs, all_values, start, prev_cost, prev_value, prev_nodes):\n for ii in range(start, graph.size):\n # combination\n nodes = prev_nodes + [ii]\n all_combs.append(nodes)\n # cost\n cost = prev_cost + graph.node_weights[ii][0]\n all_costs.append(cost)\n # value\n value = prev_value + graph.node_weights[ii][1] - graph.node_weights[ii][0]\n for node in prev_nodes: # complementarity\n for adjacent in graph.graph[node]:\n if adjacent[0] == ii:\n value += adjacent[1]\n all_values.append(value)\n # recurse\n combinations(graph, all_combs, all_costs, all_values, ii+1, cost, value, nodes)","def __init_matrix(self, adjacencyMatrix, **optional):\n\t\t# Error handling\n if adjacencyMatrix.ndim!=2 or adjacencyMatrix.shape[0]!=adjacencyMatrix.shape[1]:\n raise TypeError(\"\\'adjacencyMatrix\\' has to be a square matrix.\")\n elif np.any(adjacencyMatrix<0):\n raise ValueError(\"The weights have to be positive.\")\n elif not (str(adjacencyMatrix.dtype).startswith(\"float\") or str(adjacencyMatrix.dtype).startswith(\"int\")):\n raise TypeError(\"Weights have to be of the type \\'float*\\' or \\'int*\\'.\")\n elif np.any(np.diagonal(adjacencyMatrix)):\n raise ValueError(\"The graph is not allowed to contain circles of length 1.\")\n\t\t# Save shape and type\n self.__size = adjacencyMatrix.shape[0]\n self.__type = adjacencyMatrix.dtype\n if \"vertexNames\" in optional:\n # List of names\n self.__name_list = optional[\"vertexNames\"]\n if len(self.__name_list)!=self.__size:\n raise ValueError(\"There have not been specified as many names in \\'vertexNames\\' as there are nodes.\")\n else:\n if len(set(self.__name_list)) != len(self.__name_list):\n raise ValueError(\"Vertex names are not unique.\")\n else:\n # Hashmap name->index\n self.__names = {self.__name_list[i]:i for i in range(0,self.__size)}\n else:\n warn(Warning(\"If node names in adjacency matrix representation are not explicitly set with the parameter \\'vertexNames\\', partial and supergraphs cannot be recognized reliably.\"))\n self.__name_list = [i for i in range(0,self.__size)]\n self.__names = {self.__name_list[i]:i for i in range(0,self.__size)}\n \n # Adjacency matrix\n self.__mat = adjacencyMatrix\n # Adjacency matrix\n self.__adj = [[(i,self.__mat[vertices][i]) for i in np.arange(self.__size) if self.__mat[vertices][i]>0] for vertices in np.arange(0,self.__size)]\n \n # List of known supergraphs\n self.__supergraph = []","def viterbi_path_log(prior, transmat, observ_likelihood):\n T = observ_likelihood.shape[-1]\n N = observ_likelihood.shape[0]\n\n path = numpy.zeros(T, dtype=numpy.int32)\n global_score = numpy.zeros(shape=(N,T))\n predecessor_state_index = numpy.zeros(shape=(N,T), dtype=numpy.int32)\n\n t = 1\n global_score[:, 0] = prior + observ_likelihood[:, 0]\n # need to normalize the data\n \n for t in range(1, T):\n for j in range(N):\n temp = global_score[:, t-1] + transmat[:, j] + observ_likelihood[j, t]\n global_score[j, t] = max(temp)\n predecessor_state_index[j, t] = temp.argmax()\n\n path[T-1] = global_score[:, T-1].argmax()\n \n for t in range(T-2, -1, -1):\n path[t] = predecessor_state_index[ path[t+1], t+1]\n\n return [path, predecessor_state_index, global_score]","def refugia_adj_5_full_2_iter1 (params, ns):\n #33 parameters \n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\n nu_T0 = [nu1x, nuA]\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\n fs.integrate(nu_T0, T0, m=mig0)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def update_pheromones(attr_keys, pattern, p_matrix):\n idx = [attr_keys.index(x.as_string()) for x in pattern.gradual_items]\n for n in range(len(idx)):\n for m in range(n + 1, len(idx)):\n i = idx[n]\n j = idx[m]\n p_matrix[i][j] += 1\n p_matrix[j][i] += 1\n return p_matrix","def _create_adjacency_matrix(layer_edges):\n A = defaultdict(int)\n for l, edges in list(layer_edges.items()):\n for edge in edges:\n A[(edge[0], edge[1], l)] += 1\n A[(edge[1], edge[0], l)] += 1 \n return A","def get_stain_matrix(I):","def objective(V,m,adj):\r\n #number of edges in G = (V,E)\r\n link = 0\r\n for i in range(m):\r\n for j in range(i,m):\r\n if i != j and (V[i],V[j]) in adj or (V[j],V[i]) in adj:\r\n link += 1\r\n #number of expected edges to have a module\r\n edges = factorial(m)/(factorial(m-2)*2)\r\n obj = edges - link\r\n\r\n return obj","def process_input(input_path):\n\n # Parse lines from input file into list\n with open(input_path, 'r') as input_file:\n lines = input_file.readlines()\n\n # Declare component lists and helper variables\n vertex_map = {} # Mapping of named vertices to indices, handles duplicate connections\n idx = 0\n edges = [] # List of (src, dst) tuples\n weights = [] # Weight of each edge\n\n for line in lines:\n # Parse each line of csv or text file\n if input_path.endswith('.csv'):\n parts = line.split(',')\n else:\n parts = line.split()\n\n # Add source vertex to list of vertices\n src = parts[0]\n if src not in vertex_map:\n vertex_map[src] = idx\n idx += 1\n\n # Add destination vertex to list of vertices\n dst = parts[1]\n if dst not in vertex_map:\n vertex_map[dst] = idx\n idx += 1\n\n # Add integer representation of edges to list of connections\n edges.append((vertex_map[src], vertex_map[dst]))\n weights.append(parts[2])\n\n # Get definite list of vertices\n vertices = vertex_map.keys()\n\n # Print graph information\n vprint(str(len(vertices)) + ' vertices')\n vprint(str(len(edges)) + ' edges')\n\n # Build IGraph representation of network\n graph = ig.Graph(edges, directed=False)\n graph.es['weight'] = [weights[e] for e in range(len(graph.es))]\n\n return graph, vertices","def add_vertices(self, vertices: Iterable[\"Vertex\"]) -> Sequence[int]:\n indices = []\n for vertex in vertices:\n key = self.key(vertex)\n try:\n indices.append(self.ledger[key])\n except KeyError:\n index = len(self.vertices)\n self.vertices.append(vertex)\n self.ledger[key] = index\n indices.append(index)\n return tuple(indices)","def create_propagator_matrix(graph):\n A = create_adjacency_matrix(graph)\n I = sparse.eye(A.shape[0])\n A_tilde_hat = normalize_adjacency_matrix(A, I)\n propagator = dict()\n A_tilde_hat = sparse.coo_matrix(A_tilde_hat)\n propagator[\"indices\"] = torch.LongTensor(np.concatenate([A_tilde_hat.row.reshape(-1,1), A_tilde_hat.col.reshape(-1,1)],axis=1).T)\n propagator[\"values\"] = torch.FloatTensor(A_tilde_hat.data)\n return propagator","def computeTransitionMatrix(self, mu = False):\n\n available_strategies = self.getAvailableStrategies()\n t_matrix = np.matrix([[0. for strategy in available_strategies] for strategy in available_strategies])\n\n for i, resident in enumerate(available_strategies):\n for j, invader in enumerate(available_strategies):\n if (i != j):\n fixation_proba = self.rho(resident, invader)\n if(mu):\n fixation_proba *= self.getExplorationRate()\n t_matrix[i, j] = 1./(len(available_strategies) - 1) * fixation_proba\n\n # calculate diagonal elements\n for i in range(len(available_strategies)):\n t_matrix[i, i] = 1 - t_matrix[i].sum(axis = 1)\n\n return t_matrix","def __init__(self, matrix):\n if not matrix:\n self.dp = None\n return\n \n m = len(matrix)\n n = len(matrix[0])\n \n dp = self.dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]\n \n for x in range(1, m + 1): # 0 的都是零就不用单独处理了。\n for y in range(1, n + 1):\n dp[x][y] = dp[x-1][y] + dp[x][y-1] - dp[x-1][y-1] + matrix[x-1][y-1]","def find_min_hamiltonian_path(G,weights,probs_instead_of_weights=False):\n\n # Create a new model\n m = Model(\"hamiltonian_cycle\")\n \n # Create variables\n x_vars = {}\n u_vars = {}\n for var1 in permute(G.vertices()):\n for var2 in permute(G.vertices()):\n if var1 != var2:\n x_vars[(var1,var2)] = m.addVar(vtype='B', name=\"x_\"+str(var1)+'_'+str(var2))\n u_vars[var1] = m.addVar(vtype=GRB.INTEGER, name=\"u_\"+str(var1))\n m.update()\n \n for var in G.vertices():\n if var != START_NODE:\n cur_incoming = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[1] == var)])\n #print(cur_incoming)\n m.addConstr(cur_incoming,GRB.EQUAL,1.0)\n \n if var != END_NODE:\n cur_outgoing = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[0] == var)])\n #print(cur_outgoing)\n m.addConstr(cur_outgoing,GRB.EQUAL,1.0)\n \n for var1 in G.vertices():\n for var2 in G.vertices():\n if var1 != var2:\n c = LinExpr([(1.0,u_vars[var1]),(-1.0,u_vars[var2]),(G.num_vertices(),x_vars[(var1,var2)])])\n #print(c)\n m.addConstr(c,GRB.LESS_EQUAL,G.num_vertices()-1)\n \n # Set objective\n #try:\n edge_weights = permute(G.get_edge_weights(weights))\n if probs_instead_of_weights:\n all_probs = []\n for v in G.vertices():\n if v != END_NODE:\n batch_scores = [(e,w) for e,w in edge_weights if e[0] == v]\n S = logsumexp([x[1] for x in batch_scores])\n batch_scores = [(e,np.exp(w-S)) for e,w in batch_scores]\n all_probs.extend(batch_scores)\n edge_weights = all_probs\n objective = LinExpr([(weight,x_vars[edge]) for edge,weight in edge_weights])\n #except TypeError:\n # return None\n \n m.setObjective(objective,GRB.MINIMIZE)\n m.update()\n code = m.optimize()\n \n try:\n return [k for k,v in x_vars.items() if v.x > 0.98]\n except GurobiError:\n return None","def adjacency(self):\n if self.E > 0:\n i = self.edges[:, 0]\n j = self.edges[:, 1]\n adj = coo_matrix((np.ones(self.E), (i, j)),\n shape=(self.V, self.V))\n else:\n adj = coo_matrix((self.V, self.V))\n return adj","def generate_nodes(self):\n \n # For all state nodes\n node = 0\n \n for i in range(self.x0_n):\n for j in range(self.x1_n):\n \n # State\n x = np.array([ self.xd[0][i] , self.xd[1][j] ])\n \n # State and grid index based on node #\n self.nodes_state[node,:] = x\n self.nodes_index[node,:] = np.array([i,j])\n \n # Node # based on index ij\n self.x_grid2node[i,j] = node\n\n # Increment node number\n node = node + 1","def eqcounter(nodes):\r\n nnodes = nodes.shape[0]\r\n IBC = np.zeros([nnodes, 3], dtype=np.integer)\r\n for i in range(nnodes):\r\n for k in range(3):\r\n IBC[i, k] = int(nodes[i, k+3])\r\n neq = 0\r\n for i in range(nnodes):\r\n for j in range(3):\r\n if IBC[i, j] == 0:\r\n IBC[i, j] = neq\r\n neq = neq + 1\r\n return neq, IBC","def refugia_adj_5_full_2_iter3 (params, ns):\n #33 parameters \n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\n nu_T0 = [nu1x, nuA]\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\n fs.integrate(nu_T0, T0, m=mig0)\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\n nu_T1 = [nu1a, nu2a, nu3a]\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \n fs.integrate(nu_T1, T1, m=mig1)\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\n nu_T2 = [nu1b, nu2b, nu3b]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\n nu_T3 = [nu1c, nu2c, nu3c]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3)\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\n nu_T4 = [nu1d, nu2d, nu3d]\n fs.integrate(nu_T4, T4) \n return fs","def get_sparse_adj(ent_num, triples):\n adj, degree = get_mat(ent_num, triples)\n\n indices = []\n values = []\n\n for fir, sec in adj:\n indices.append((sec, fir))\n values.append(adj[(fir, sec)] / math.sqrt(degree[fir]) / math.sqrt(degree[sec]))\n\n indices = torch.tensor(indices).t()\n\n adj = torch.sparse_coo_tensor(indices=indices, values=values, size=[ent_num, ent_num])\n\n return adj, degree","def Init_Adaptive_Grid(self,):\n self.Indicator[0] = 0\n self.Old[0] = 0\n \n for i in range(self.num_dim):\n self.Active[i] = i+1\n self.Indicator[i+1] = 1\n self.N_Forward[i,0] = i+2\n self.N_Backward[i,i+1] = 1\n self.Idx[i,i+1] = 1","def laplace_matrix(self):\n n = self.number_of_vertices\n laplace_matrix = np.zeros((n, n))\n for i in range(n):\n laplace_matrix[i][i] = 1\n vertice = self.list_of_vertices[i]\n for edge in vertice.edges_list:\n laplace_matrix[i][edge.linked[1].index] = 1\n return laplace_matrix","def generate_nodes(self):\n \n # For all state nodes\n node = 0\n \n for i in range(self.x0_n):\n for j in range(self.x1_n):\n for k in range(self.x2_n):\n \n # State\n x = np.array([ self.xd[0][i] , self.xd[1][j] , self.xd[2][k] ])\n \n # State and grid index based on node #\n self.nodes_state[node,:] = x\n self.nodes_index[node,:] = np.array([i,j,k])\n \n # Node # based on index ijk\n self.x_grid2node[i,j,k] = node\n \n # Increment node number\n node = node + 1","def calculate(self) :\n #self.graph\n self.val_i = 0\n while (len(self.undefined_vertices) > 0) :\n cond = True\n while cond:\n cond = False\n for node in self.undefined_vertices:\n if self.condition_satisfied(node, self.val_i) :\n cond = True\n self.undefined_vertices.remove(node)\n self.val_l[node] = self.val_i\n self.val_c[node] = self.val_m\n self.val_m += 1\n for node in self.undefined_vertices:\n if self.val_i not in [self.val_l[n] for n in\n self.graph.next_nodes(node)]:\n self.undefined_vertices.remove(node)\n self.val_l[node] = self.infinity\n self.val_c[node] = 0\n self.val_i += 1\n self.graph.save_graph(\"check\")\n self.save(\"this.value\")\n return self.graph.to_dictionary(), self.val_l, self.val_c","def count_automorphisms(g: Graph) -> int:\n\n def generate_mapping(g: Graph, h: Graph):\n \"\"\"\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\n We map g to h.\n :param g: A graph\n :param h: A graph\n :return: A permutation with the mapping from g to h\n \"\"\"\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)\n\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\n \"\"\"\n Is called recursively to traverse through the branching tree and to find all automorphisms.\n :param g: A copy of the original graph\n :param h: Another copy of the original graph\n :param d: A list with pre-colored vertices for graph g\n :param i: A list with pre-colored vertices for graph h\n \"\"\"\n\n # Refine the graphs g and h.\n color_refinement([g, h])\n\n # Make sure that the colors are balanced, and check for a bijection.\n if not is_balanced(g, h):\n return\n if is_bijection(g, h):\n\n # Generate the mapping from g -> h.\n p = generate_mapping(g, h)\n\n # If the permutation cannot be generated by this generating set, we need to add it.\n if not is_member(generating_set, p):\n generating_set.append(p)\n\n # We can now back to the last trivial ancestor nodes in the branching tree.\n while [v.label for v in d] != [v.label for v in i]:\n # We remove the vertices from d and i and mark them as 'used'.\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\n d.pop().pre_labeled = True\n i.pop().pre_labeled = True\n\n return\n\n c, next_color = get_c([g, h])\n for v_g in g:\n if v_g.colornum == c:# and not v_g.pre_labeled:\n x = v_g\n break\n\n for v_h in h:\n if v_h.colornum == c and not v_h.pre_labeled:\n g1 = g + Graph(False)\n h1 = h + Graph(False)\n g1.vertices[g.vertices.index(x)].colornum = next_color\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\n d.append(x)\n i.append(v_h)\n generate_automorphisms(g1, h1, d, i)\n\n generating_set = []\n graph_copy_1 = g + Graph(False)\n graph_copy_2 = g + Graph(False)\n for v in graph_copy_1.vertices:\n v.pre_labeled = False\n for v in graph_copy_2.vertices:\n v.pre_labeled = False\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\n return compute_order(generating_set)","def plan(self):\n return [(0, 0), (1, 0), (1, 1), (1, 2), (1, 3)]","def _generate_weighted_adj_matrices(self):\n self.weighted_adj_matrices = dict()\n mes = []\n args = []\n for metaedge in self.metaedges:\n mes.append(metaedge)\n args.append(self._prepare_parallel_weighted_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.weighted_adj_matrices[metaedge] = matrix","def refugia_adj_5_full(params, ns):\n #22 parameters \n nu1_1a, nu1_1b, nu1_2, nu1_3, nuA_a, nuA_b, nu2_2, nu2_3, nu3_2, nu3_3, m1_12, m1_21, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1a, T1b, T2, T3 = params\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\n fs = moments.Spectrum(sts)\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\n ## Population function and migration matrix for T1a\n nu_T1a = [nu1_1a, nuA_a]\n fs.integrate(nu_T1a, T1a)\n ## Population function and migration matrix for T1b\n nu_T1b = [nu1_1b, nuA_b] \n mig1 = numpy.array([[0, m1_12],[m1_21, 0]])\n fs.integrate(nu_T1b, T1b, m=mig1) \n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\n ## Population function and migration matrix for T2\n nu_T2 = [nu1_2, nu2_2, nu3_2]\n fs.integrate(nu_T2, T2)\n ## Population function and migration matrix for T3\n nu_T3 = [nu1_3, nu2_3, nu3_3]\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \n fs.integrate(nu_T3, T3, m=mig3) \n return fs","def __init__(self, matrix):\n m, n = len(matrix), len(matrix[0]) if len(matrix) > 0 else 0\n self.total = [[0 for x in xrange(n + 1)] for x in xrange(m + 1)]\n for i in xrange(1, m+1):\n for j in xrange(1, n+1):\n self.total[i][j] = matrix[i-1][j-1] + self.total[i-1][j] + self.total[i][j-1] - self.total[i-1][j-1]","def vert_degree(input_vertices):\n\tvertex_map = {}\n\tfor element in input_vertices:\n\t\tvertex_map[element] = 0\n\t\tfor x in prob:\n\t\t\tfor vertex in x:\n\t\t\t\tif element == vertex:\n\t\t\t\t\tvertex_map[element] += 1\n\treturn vertex_map","def compute_adjacency_matrix(G):\n\n iG = nx.convert_node_labels_to_integers(G)\n adj_list = iG.adjacency_list()\n n_nodes = len(iG.nodes())\n\n adj_mat = np.zeros((n_nodes, n_nodes))\n for x in xrange(n_nodes):\n adj_mat[x, adj_list[x]] = 1\n\n return adj_mat","def gale_transform(self):\n if not self.is_compact(): raise ValueError('Not a polytope.')\n\n A = matrix(self.n_vertices(), \n [ [1]+list(x) for x in self.vertex_generator()])\n A = A.transpose()\n A_ker = A.right_kernel()\n return A_ker.basis_matrix().transpose().rows()"],"string":"[\n \"def get_matrix(self):\\n matrix = np.zeros([len(self.states), len(self.states)])\\n starting_states = []\\n transitions = []\\n\\n for chords in self.training_data:\\n states = []\\n is_starting_state = True\\n chunks = [chords[x:x+self.order] for x in range(0,\\n len(chords), self.order)]\\n for chunk in chunks:\\n chunk_string = \\\" \\\".join(chunk)\\n if is_starting_state:\\n starting_states.append(chunk_string)\\n is_starting_state = False\\n states.append(chunk_string)\\n\\n for i in range(0, len(states)):\\n if i < (len(states)) - 1:\\n transitions.append([states[i], states[i + 1]])\\n else:\\n transitions.append([states[i]])\\n\\n self.starting_probabilities = np.zeros([len(self.states)])\\n\\n for transition in transitions:\\n for row, row_contents in enumerate(self.transitions):\\n for col, _ in enumerate(row_contents):\\n if transition == self.transitions[row][col]:\\n matrix[row][col] += 1\\n\\n for i, state in enumerate(self.states):\\n for j, possible_state in enumerate(starting_states):\\n if state == possible_state:\\n self.starting_probabilities[j] += 1\\n\\n num = sum(self.starting_probabilities)\\n for i, prob in enumerate(self.starting_probabilities):\\n self.starting_probabilities[i] = prob / num\\n\\n for m in range(len(matrix)):\\n num = sum(matrix[m])\\n if int(num) is not 0:\\n for i in range(len(matrix[m])):\\n matrix[m][i] = (matrix[m][i] / num)\\n else:\\n matrix[m] = self.starting_probabilities\\n return matrix\",\n \"def back_prop(nodes_in_path, playout_result):\\n for temp_node in nodes_in_path:\\n temp_node.visited += 1\\n if str(playout_result) == str(temp_node.side):\\n temp_node.winning += 1\",\n \"def init_graph(self):\\n import dgl\\n\\n adj_list = []\\n for rel_type in range(1, self.n_relations, 1):\\n edge_idxs = self.ckg.filter_edges(\\n lambda edge: edge.data[\\\"relation_id\\\"] == rel_type\\n )\\n sub_graph = (\\n dgl.edge_subgraph(self.ckg, edge_idxs, preserve_nodes=True)\\n .adjacency_matrix(transpose=False, scipy_fmt=\\\"coo\\\")\\n .astype(\\\"float\\\")\\n )\\n rowsum = np.array(sub_graph.sum(1))\\n d_inv = np.power(rowsum, -1).flatten()\\n d_inv[np.isinf(d_inv)] = 0.0\\n d_mat_inv = sp.diags(d_inv)\\n norm_adj = d_mat_inv.dot(sub_graph).tocoo()\\n adj_list.append(norm_adj)\\n\\n final_adj_matrix = sum(adj_list).tocoo()\\n indices = torch.LongTensor([final_adj_matrix.row, final_adj_matrix.col])\\n values = torch.FloatTensor(final_adj_matrix.data)\\n adj_matrix_tensor = torch.sparse.FloatTensor(indices, values, self.matrix_size)\\n return adj_matrix_tensor.to(self.device)\",\n \"def _generate_adjacency_matrices(self):\\n self.adj_matrices = dict()\\n mes = []\\n args = []\\n for metaedge in self.metaedges:\\n mes.append(metaedge)\\n args.append(self._prepare_parallel_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.adj_matrices[metaedge] = matrix\",\n \"def demukron_network_order_function(vertices: List[Vertice], adj_matrix: np.ndarray) -> np.ndarray:\\n current_level = 0\\n vertice_indices_set = set(range(len(vertices)))\\n m = adj_matrix.sum(axis=0) # array of in-degrees\\n degrees_array = np.zeros(len(vertices))\\n\\n while vertice_indices_set:\\n zero_on_the_current_step = {i for i in vertice_indices_set if m[i] == 0}\\n for i in zero_on_the_current_step:\\n degrees_array[i] = current_level\\n m = m - adj_matrix[i]\\n vertice_indices_set = vertice_indices_set - zero_on_the_current_step\\n current_level += 1\\n return degrees_array\",\n \"def adjacency_matrix():\\n file_path = PROJECT_PATH + \\\"/geographycal_data/adjacency_matrix/Howgrp.txt\\\"\\n router = Router(adjacency_metrix=file_path)\\n # router.write2vtk(router.graph, \\\"adjacency_matrix\\\")\\n # nx.draw(router.graph)\\n # plt.show()\\n # adjacency matrix\\n A = nx.adjacency_matrix(router.graph, weight=None).toarray()\\n # ... and its spectrum\\n nx.adjacency_spectrum(router.graph, weight=None)\\n # weighted adjacency\\n W = nx.adjacency_matrix(router.graph)\\n # D\\n I = np.reshape(np.ones(12), (-1, 1))\\n D = np.matmul(A, I)\\n # combinatorial graph Laplacian L = D - A\\n L = nx.laplacian_matrix(router.graph, weight=None)\\n # ... and his spectrum\\n nx.laplacian_spectrum(router.graph, weight=None)\\n # weighted Laplacian\\n Y = nx.laplacian_matrix(router.graph)\\n\\n # Note\\n sumD = np.matmul(I.transpose(), D)\\n sumD = sumD[0][0]\\n sumA = 0\\n for row in np.nditer(A):\\n for e in np.nditer(row):\\n sumA += e\\n\\n # Fielder vector\\n fiedler_vector = nx.fiedler_vector(router.graph, weight=None)\\n\\n # Matrix Double index Sum\\n\\n def D_app(F):\\n return D * F\\n\\n def A_app(F):\\n AF = np.zeros(len(F))\\n for i, e_i in enumerate(F):\\n for j, e_j in enumerate(F):\\n if (A[i][j] != 0):\\n AF[i] += F[j]\\n return AF\",\n \"def compute_transition_rates(adj_mat):\\n\\n # compute the node degrees\\n degrees = np.sum(adj_mat, axis=0)\\n degrees[degrees == 0] = adj_mat.shape[0]\\n\\n # compute D = diag(1 / degree_i), for each node i\\n D = scipy.sparse.csr_matrix(np.diag(1. / degrees))\\n\\n # compute the transition matrix M = A\\\\D\\n M = D.dot(adj_mat)\\n\\n return M\",\n \"def generate_adj_matrix(vertices, inhibition_degree=2):\\n value_pool = [-1, 1, 0] + [0]*10 + [1]*2\\n matrix = [[0 for _ in xrange(vertices)] for _ in xrange(vertices)]\\n for i, row in enumerate(matrix):\\n for j, element in enumerate(row):\\n if i > j:\\n if row.count(-1) + row.count(1) >= 2 and row.count(-1) != 0:\\n matrix[i][j] = 0\\n elif row.count(-1) == 1:\\n matrix[i][j] = rnd.choice(value_pool)\\n elif row.count(-1) == 2:\\n matrix[i][j] = 0\\n else:\\n matrix[i][j] = rnd.choice(value_pool)\\n matrix = [list(i) for i in zip(*matrix)]\\n return matrix\",\n \"def _estimate_adjacency_matrix(self, X):\\r\\n\\t\\tB = np.zeros([X.shape[1], X.shape[1]], dtype='float64')\\r\\n\\t\\tfor i in range(1, len(self._causal_order)):\\r\\n\\t\\t\\tcoef = self._predict_adaptive_lasso(\\r\\n\\t\\t\\t\\tX, self._causal_order[:i], self._causal_order[i])\\r\\n\\t\\t\\tB[self._causal_order[i], self._causal_order[:i]] = coef\\r\\n\\t\\tself.adjacency_matrix_ = B\\r\\n\\t\\treturn self\",\n \"def viterbi_path(prior, transmat, observ_likelihood):\\n T = observ_likelihood.shape[-1]\\n N = observ_likelihood.shape[0]\\n\\n path = numpy.zeros(T, dtype=numpy.int32)\\n global_score = numpy.zeros(shape=(N,T))\\n predecessor_state_index = numpy.zeros(shape=(N,T), dtype=numpy.int32)\\n\\n t = 1\\n global_score[:, 0] = prior * observ_likelihood[:, 0]\\n # need to normalize the data\\n global_score[:, 0] = global_score[:, 0] /sum(global_score[:, 0] )\\n \\n for t in range(1, T):\\n for j in range(N):\\n temp = global_score[:, t-1] * transmat[:, j] * observ_likelihood[j, t]\\n global_score[j, t] = max(temp)\\n predecessor_state_index[j, t] = temp.argmax()\\n\\n global_score[:, t] = global_score[:, t] / sum(global_score[:, t])\\n\\n path[T-1] = global_score[:, T-1].argmax()\\n \\n for t in range(T-2, -1, -1):\\n path[t] = predecessor_state_index[ path[t+1], t+1]\\n\\n return [path, predecessor_state_index, global_score]\",\n \"def viterbi(adj_matrix, label_sequence, starting_vertex):\\n\\n assert adj_matrix, \\\"adj_matrix is None or empty.\\\"\\n n = len(adj_matrix) # vertex count.\\n for row in adj_matrix:\\n assert len(row) == n, \\\"adj_matrix is not square.\\\"\\n\\n assert 0 <= starting_vertex <= n - 1, \\\"starting_vertex out of range.\\\"\\n\\n assert label_sequence, \\\"label_sequence is None or empty.\\\"\\n k = len(label_sequence)\\n for l in label_sequence:\\n assert isinstance(l, int) and l > 0, \\\"label ids must be positive integers.\\\"\\n\\n p = [[0 for _ in range(0, k)] for _ in range(0, n)]\\n for j in range(k - 1, -1, -1):\\n for beg in range(0, n):\\n for end in range(0, n):\\n if not adj_matrix[beg][end]: # No edge from i to r.\\n continue\\n\\n assert isinstance(adj_matrix[beg][end], AdjMatrixElem),\\\\\\n \\\"adj_matrix[%d][%r] is not an AdjMatrixElem\\\" % (beg, end)\\n elem = adj_matrix[beg][end]\\n if elem.label_id != label_sequence[j]:\\n continue\\n\\n later_prob = 1 if j == k - 1 else p[end][j + 1]\\n if elem.probability * later_prob > p[beg][j]:\\n p[beg][j] = elem.probability * later_prob\\n\\n if round(p[starting_vertex][0] - 0.0, PROBABILITY_PRECISION) == 0:\\n return 0, NO_SUCH_PATH\\n\\n path = [starting_vertex]\\n for j in range(0, k):\\n beg = path[j]\\n for end in range(0, n):\\n later_prob = 1 if j == k - 1 else p[end][j + 1]\\n if adj_matrix[beg][end] and adj_matrix[beg][end].label_id == label_sequence[j]\\\\\\n and round(p[beg][j] - adj_matrix[beg][end].probability * later_prob, PROBABILITY_PRECISION) == 0:\\n path.append(end)\\n break\\n\\n return p[starting_vertex][0], tuple(path)\",\n \"def _triangulate(self,x):\\n\\n t = tr.triangulate({\\\"vertices\\\": x},\\\"-n\\\")\\n tri = t[\\\"triangles\\\"]\\n neighbours = t[\\\"neighbors\\\"]\\n\\n b_cells = np.zeros(self.n_c)\\n b_cells[self.n_C:] = 1\\n\\n three_b_cell_mask = b_cells[tri].sum(axis=1)==3\\n tri = tri[~three_b_cell_mask]\\n\\n neigh_map = np.cumsum(~three_b_cell_mask)-1\\n neigh_map[three_b_cell_mask] = -1\\n neigh_map = np.concatenate((neigh_map,[-1]))\\n\\n neighbours = neighbours[~three_b_cell_mask]\\n neighbours = neigh_map[neighbours]\\n\\n #6. Store outputs\\n self.tris = tri\\n self.n_v = tri.shape[0]\\n self.Cents = x[self.tris]\\n self.vs = self.get_vertex()\\n\\n\\n #7. Manually calculate the neighbours. See doc_string for conventions.\\n self.v_neighbours = neighbours\\n self.neighbours = self.vs[neighbours]\\n self.neighbours[neighbours == -1] = np.nan\\n\\n self.reset_k2s()\",\n \"def matrix_contribution(self):\\r\\n \\r\\n import numpy as np\\r\\n import copy\\r\\n \\r\\n # The functions F and G sometimes return NaN, errors we catch through\\r\\n # np.nan_to_num. Suppress these error messages.\\r\\n import warnings\\r\\n warnings.filterwarnings('ignore')\\r\\n \\r\\n # Define the segment influence functions\\r\\n def F(Z):\\r\\n return np.nan_to_num(-0.5*(Z-1)*np.log((Z-1)/(Z+1))) - 1\\r\\n def G(Z):\\r\\n return np.nan_to_num(+0.5*(Z+1)*np.log((Z-1)/(Z+1))) + 1\\r\\n \\r\\n # We evaluate this block at its own vertices\\r\\n z = self.polygon\\r\\n \\r\\n # Pre-allocate an empty matrix for the block\\r\\n block = np.zeros((self.segments,self.segments))\\r\\n \\r\\n self.angles = []\\r\\n self.temp = []\\r\\n \\r\\n # Go through all vertices in the polygon\\r\\n for seg in range(self.segments):\\r\\n \\r\\n # Set the previous, current, and next vertex of the polygon\\r\\n if seg == self.segments-1:\\r\\n seg_minus = seg-1\\r\\n seg_center = seg\\r\\n seg_plus = 0\\r\\n else:\\r\\n seg_minus = seg-1\\r\\n seg_center = seg\\r\\n seg_plus = seg+1\\r\\n \\r\\n self.temp.append([self.polygon[seg_plus]-self.polygon[seg_center],\\r\\n self.polygon[seg_center]-self.polygon[seg_minus]])\\r\\n \\r\\n # To evaluate the effect of a vertex on itself, it is computationally\\r\\n # cleanest to evaluate it in terms of angles; these angles are \\r\\n # calculated according to Strack 1989, Eq. 35.29 and 35.30\\r\\n newtemp = np.angle(self.polygon[seg_plus]-self.polygon[seg_center]) - \\\\\\r\\n np.angle(self.polygon[seg_center]-self.polygon[seg_minus])\\r\\n \\r\\n if newtemp < -np.pi: newtemp += 2*np.pi\\r\\n if newtemp > +np.pi: newtemp -= 2*np.pi\\r\\n \\r\\n # self.angles.append(newtemp)\\r\\n # Sometimes, numerical imprecision causes the angle to fall outside\\r\\n # the range 0 and 2 pi; in that case, flip it back inside\\r\\n # if newtemp < 0: newtemp += 2*np.pi\\r\\n # if newtemp > 2*np.pi: newtemp -= 2*np.pi\\r\\n newtemp -= np.pi\\r\\n \\r\\n\\r\\n \\r\\n self.angles.append(newtemp)\\r\\n \\r\\n # Write the diagonal entries of the matrix\\r\\n block[seg,seg] = 1/(2*np.pi)*newtemp\\r\\n \\r\\n # Here we would normally add the factor for the conductivity difference\\r\\n # to the diagonal entries; since we only prepare the matrix here, \\r\\n # we skip it\\r\\n \\r\\n # # Determine the A_star variable (Strack 1989 35.4, 35.38)\\r\\n # A_star = self.model.k/(self.k - self.model.k)\\r\\n # block[seg,seg] -= A_star\\r\\n\\r\\n # Then handle all off-diagonal contributions\\r\\n for seg2 in range(self.segments):\\r\\n \\r\\n # Skip the diagonal\\r\\n if seg2 != seg:\\r\\n \\r\\n # Get the indices of the past, current, and next vertex\\r\\n if seg2 == self.segments-1:\\r\\n seg_minus = seg2-1\\r\\n seg_center = seg2\\r\\n seg_plus = 0\\r\\n else:\\r\\n seg_minus = seg2-1\\r\\n seg_center = seg2\\r\\n seg_plus = seg2+1\\r\\n \\r\\n # Calculate the local coordinates\\r\\n Z_before = \\\\\\r\\n (2*z[seg] - (self.polygon[seg_minus] + self.polygon[seg_center]))/(self.polygon[seg_center] - self.polygon[seg_minus])\\r\\n Z_after = \\\\\\r\\n (2*z[seg] - (self.polygon[seg_center] + self.polygon[seg_plus]))/(self.polygon[seg_plus] - self.polygon[seg_center])\\r\\n \\r\\n # And write the result into the correct matrix entries\\r\\n block[seg,seg2] = copy.copy(np.real(1/(2*np.pi*1j)*(G(Z_before)+F(Z_after))))\\r\\n \\r\\n return block\",\n \"def feature_calculator(args, graph):\\n index_1 = [edge[0] for edge in graph.edges()]\\n index_2 = [edge[1] for edge in graph.edges()]\\n values = [1 for edge in graph.edges()]\\n node_count = max(max(index_1)+1,max(index_2)+1)\\n adjacency_matrix = sparse.coo_matrix((values, (index_1,index_2)),shape=(node_count,node_count),dtype=np.float32)\\n degrees = adjacency_matrix.sum(axis=0)[0].tolist()\\n degs = sparse.diags(degrees, [0])\\n normalized_adjacency_matrix = degs.dot(adjacency_matrix)\\n target_matrices = [normalized_adjacency_matrix.todense()]\\n powered_A = normalized_adjacency_matrix\\n if args.window_size > 1:\\n for power in tqdm(range(args.window_size-1), desc = \\\"Adjacency matrix powers\\\"):\\n powered_A = powered_A.dot(normalized_adjacency_matrix)\\n to_add = powered_A.todense()\\n target_matrices.append(to_add)\\n target_matrices = np.array(target_matrices)\\n return target_matrices\",\n \"def ComputeAccumulatedCostMatrix( self, iterative=False ):\\n start = 0\\n if not iterative: # if first time, make a matrix of zeros\\n self.D = [[0 for x in range(len(self.C[0]))] for y in range(len(self.C))]\\n else: # else add rows of zeros until D has the same dimensions as C\\n start = len(self.D)-1\\n for row in range( len(self.C) - len(self.D) ):\\n self.D.append( [ 0 for x in range(len(self.C[0])) ] )\\n for n in range( start, len(self.C) ):\\n for m in range( len(self.C[0]) ):\\n if n == 0:\\n if(self.subsequence):\\n self.D[n][m] = 0+self.C[n][m]\\n else:\\n self.D[n][m] = sum( self.C[n][:m] )\\n if m == 0:\\n ## print \\\"col 0, row %d, sum=%f\\\"%(n,sum( [row[m] for row in C[:n]] ))\\n ## print [row[m] for row in C[:n]]\\n self.D[n][m] = sum( [row[m]+self.penalty[1] for row in self.C[:n]] )\\n else:\\n self.D[n][m] = self.C[n][m] + min( self.D[n-1][m-1], self.D[n-1][m]+self.penalty[0], self.D[n][m-1]+self.penalty[1])\\n if n == len(self.C)-1: # last row\\n self.D[n][m] += self.penalty[1]*(len(self.C[0])-m) # bias the cost of the last row, so that the algorithm prefers to start near the bottom right corner\",\n \"def _compute_adjacency_matrix(self):\\n\\n # Set up a quick-reference index to map cells to indexes\\n for i, cell in enumerate(self.sim.cells):\\n self._cell_indexes[cell] = i\\n\\n if all([self.sim.hub.cells == [self.sim.damaged],\\n self.sim.damaged not in self.sim.cells]):\\n # Add the \\\"damaged\\\" virtual cell to the index if we need it\\n self._cell_indexes[self.sim.damaged] = len(self.sim.cells)\\n\\n node_count = len(list(self._cell_indexes.keys()))\\n g_sparse = np.zeros((node_count, node_count), dtype=float)\\n g_sparse[:] = np.inf\\n\\n for cluster in self.sim.clusters + [self.sim.hub]:\\n cluster_tour = cluster.tour\\n i = len(cluster_tour.vertices) - 1\\n j = 0\\n while j < len(cluster_tour.vertices):\\n start_vertex = cluster_tour.vertices[i]\\n stop_vertex = cluster_tour.vertices[j]\\n\\n start_pt = cluster_tour.points[start_vertex]\\n stop_pt = cluster_tour.points[stop_vertex]\\n distance = np.linalg.norm(stop_pt - start_pt)\\n\\n start_seg = cluster_tour.objects[start_vertex]\\n stop_seg = cluster_tour.objects[stop_vertex]\\n\\n start_index = self._cell_indexes[start_seg]\\n stop_index = self._cell_indexes[stop_seg]\\n\\n g_sparse[start_index, stop_index] = distance\\n\\n i = j\\n j += 1\\n\\n g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)\\n return g_sparse\",\n \"def M(self,i,j):\\n node_i = self.internal[i]\\n node_j = self.internal[j]\\n adj_i = self.adj_triangles(node_i)\\n adj_j = self.adj_triangles(node_j)\\n shared_tri = [] \\n for tri_i in adj_i:\\n for tri_j in adj_j:\\n if sorted(tri_i) == sorted(tri_j):\\n shared_tri.append(tri_i)\\n break \\n\\n # print(len(shared_tri))\\n\\n\\n total_integral = 0.0\\n for tri_h in shared_tri:\\n beta_i, gamma_i = self.calc_param(tri_h,node_i)\\n beta_j, gamma_j = self.calc_param(tri_h,node_j)\\n total_integral += ((beta_i*beta_j)+(gamma_i*gamma_j))*self.area \\n \\n return total_integral\",\n \"def interaction_matrix(self):\\n\\n self.int_M_called = True\\n int_M = np.zeros((self.n, self.n))\\n for k in range(self.n):\\n for j in range(k+1):\\n o = self.attribute_interactions(k, j)\\n int_M[k, j] = o.rel_total_ig_ab # Store total information gain\\n int_M[j, k] = o.rel_total_ig_ab # TODO: Maybe storing interactions too is not a bad idea\\n # TODO: We can than easily sort either by total gain or by positive interaction\\n for k in range(self.n):\\n int_M[k, k] = self.info_gains[self.data.domain.attributes[k].name]\\n self.int_matrix = Orange.misc.distmatrix.DistMatrix(int_M)\",\n \"def connectivity_matrix(self):\\n # TODO: make this more memory efficient by ordering i,j in code when needed.\\n temp = []\\n for i in range(self.n_atom):\\n for j in range(i+1, self.n_atom):\\n if self.bond(i, j):\\n temp.append([i+1, j+1])\\n self.connect = np.asarray(temp)\",\n \"def get_direction_matrix(self) -> int:\",\n \"def _compute_node_degrees(self):\\n mes = []\\n args = []\\n for metaedge, matrix in self.adj_matrices.items():\\n mes.append(metaedge)\\n args.append(matrix)\\n res = parallel_process(array=args, function=mt.calculate_degrees, n_jobs=self.n_jobs, front_num=0)\\n for metaedge, (out_degree, in_degree) in zip(mes, res):\\n self.out_degree[metaedge] = out_degree\\n self.in_degree[metaedge] = in_degree\",\n \"def solve(list_of_kingdom_names, starting_kingdom, adjacency_matrix, params=[]):\\n\\n #A = adjacency matrix, u = vertex u, v = vertex v\\n def weight(A, u, v):\\n return A[u][v]\\n\\n #A = adjacency matrix, u = vertex u\\n def adjacent(A, u):\\n L = []\\n for x in range(len(A)):\\n if A[u][x] > 0 and x != u and A[u][x] != 'x':\\n L.insert(0,x)\\n return L\\n\\n #Q = min queue\\n def extractMin(Q):\\n q = Q[0]\\n Q.remove(Q[0])\\n return q\\n\\n #Q = min queue, V = vertex list\\n def decreaseKey(Q, K):\\n for i in range(len(Q)):\\n for j in range(len(Q)):\\n if K[Q[i]] < K[Q[j]]:\\n s = Q[i]\\n Q[i] = Q[j]\\n Q[j] = s\\n\\n #V = vertex list, A = adjacency list, r = root\\n def prim(V, A, r):\\n u = 0\\n v = 0\\n\\n # initialize and set each value of the array P (pi) to none\\n # pi holds the parent of u, so P(v)=u means u is the parent of v\\n P=[None]*len(V)\\n\\n # initialize and set each value of the array K (key) to some large number (simulate infinity)\\n K = [999999]*len(V)\\n\\n # initialize the min queue and fill it with all vertices in V\\n Q=[0]*len(V)\\n for u in range(len(Q)):\\n Q[u] = V[u]\\n\\n # set the key of the root to 0\\n K[r] = 0\\n decreaseKey(Q, K) # maintain the min queue\\n\\n # loop while the min queue is not empty\\n while len(Q) > 0:\\n u = extractMin(Q) # pop the first vertex off the min queue\\n\\n # loop through the vertices adjacent to u\\n Adj = adjacent(A, u)\\n for v in Adj:\\n w = weight(A, u, v) # get the weight of the edge uv\\n\\n # proceed if v is in Q and the weight of uv is less than v's key\\n if Q.count(v)>0 and w < K[v]:\\n # set v's parent to u\\n P[v] = u\\n # v's key to the weight of uv\\n K[v] = w\\n decreaseKey(Q, K) # maintain the min queue\\n return P\\n\\n\\n # graph is a list of kingdoms that previous i is the parent of j where j = i + 1 \\n graph = prim(adjacency_matrix, list_of_kingdom_names, starting_kingdom)\\n\\n # key = parent, value = children\\n g = {}\\n\\n for x in range(len(list_of_kingdom_names)):\\n g[x] = []\\n\\n for x in range(len(graph)):\\n for y in range(len(graph)):\\n if x == graph[y]:\\n g[x].append(y) \\n\\n\\n def path(k):\\n if not g[k]:\\n return [k]\\n\\n lst = [k]\\n\\n for child in g[k]:\\n lst += path(child) + [k]\\n # print(lst)\\n\\n return lst\\n\\n\\n full_path = path(starting_kingdom)\\n\\n # print(full_path)\\n\\n\\n\\n # return closed_walk, conquered_kingdoms\",\n \"def adj(self):\\n\\t\\tres = SquareMatrix(self._rows)\\n\\t\\tfor i in range(self._rows):\\n\\t\\t\\tfor j in range(self._rows):\\n\\t\\t\\t\\tres[i][j] = ((-1) ** (i + j)) * self.minor(j, i)\\n\\t\\treturn res\",\n \"def formAdjacencyMatrix(self):\\n self.adjacencyMatrix = dict()\\n for i in self.node:\\n self.adjacencyMatrix[i] = dict()\\n for j in self.node:\\n self.adjacencyMatrix[i][j] = 0\\n \\n for ij in self.link:\\n self.adjacencyMatrix[self.link[ij].tail][self.link[ij].head] = 1\",\n \"def generate_full_adj(self):\\n edges = np.zeros(shape=(self.n_balls, self.n_balls))\\n row_idx = 0 # start filling adjacency mat from root node\\n col_idx = 1 # skip the root node and start from 2nd node\\n\\n # generate hierarchical interaction strength matrix\\n int_strngth = np.zeros(shape=(self.n_balls, self.n_balls))\\n # generate hierarchical edge lengths matrix\\n lengths = np.zeros(shape=(self.n_balls, self.n_balls))\\n for l in range(self.nl):\\n for n in range(self.nn[l]):\\n edges[row_idx, col_idx:col_idx + self.nc[l]] = 1\\n # Fill symmetric the lower triangular (undirected graph)\\n edges[col_idx:col_idx + self.nc[l], row_idx] = 1\\n\\n # same for interaction strength\\n int_strngth[row_idx, col_idx:col_idx + self.nc[l]] = self.per_level_l2a_a2d_force[l]\\n int_strngth[col_idx:col_idx + self.nc[l], row_idx] = self.per_level_l2a_a2d_force[l]\\n\\n # same for lengths\\n lengths[row_idx, col_idx:col_idx + self.nc[l]] = self.per_level_l2a_a2d_length[l]\\n lengths[col_idx:col_idx + self.nc[l], row_idx] = self.per_level_l2a_a2d_length[l]\\n\\n if l == self.nl - 1 or self.randomize_all_clusters:\\n # create full cluster adjacency matrix\\n edges[col_idx:col_idx + self.nc[l],\\n col_idx:col_idx + self.nc[l]] = \\\\\\n np.ones((self.nc[l], self.nc[l])) - np.eye(self.nc[l])\\n # same for interaction strength\\n int_strngth[col_idx:col_idx + self.nc[l],\\n col_idx:col_idx + self.nc[l]] = \\\\\\n np.ones((self.nc[l], self.nc[l])) * self.per_level_ws_force[l]\\n # same for lengths\\n lengths[col_idx:col_idx + self.nc[l],\\n col_idx:col_idx + self.nc[l]] = \\\\\\n np.ones((self.nc[l], self.nc[l])) * self.per_level_ws_length[l]\\n\\n # Increase counters after filling connections for a parent node\\n col_idx += self.nc[l]\\n row_idx += 1\\n\\n return edges, int_strngth, lengths\",\n \"def generate_full_adj(self):\\n edges = np.zeros(shape=(self.n_balls, self.n_balls))\\n row_idx = 0 # start filling adjacency mat from root node\\n col_idx = 1 # skip the root node and start from 2nd node\\n for l in range(self.nl):\\n for n in range(self.nn[l]):\\n edges[row_idx, col_idx:col_idx + self.nc[l]] = 1\\n # Increase counters after filling connections for a parent node\\n col_idx += self.nc[l]\\n row_idx += 1\\n return edges\",\n \"def dynamic_programming_path_counter(grid_size):\\n G = [1] * grid_size\\n for i in range(grid_size):\\n for j in range(i):\\n G[j] = G[j] + G[j-1]\\n G[i] = 2 * G[i - 1]\\n return G[grid_size - 1]\",\n \"def enumerate_lattice(self):\\n node_to_succs = dict()\\n node_to_preds = dict()\\n start_node = self.state_to_node([self.x_lims[0], self.y_lims[0]])\\n for i in range(self.num_cells[0]):\\n x = start_node[0] + i\\n for j in range(self.num_cells[1]):\\n y = start_node[1] + j\\n node = (x,y)\\n node_to_succs[node] = self.get_successors(node)\\n node_to_preds[node] = self.get_predecessors(node)\\n \\n assert(len(node_to_succs.keys()) == self.total_cells), \\\"Did not enumerate all possible successor cells\\\"\\n assert(len(node_to_preds.keys()) == self.total_cells), \\\"Did not enumerate all possible predecessor cells\\\"\\n return node_to_succs, node_to_preds\",\n \"def ancmig_adj_1(params, ns):\\n #11 parameters \\n nu1, nuA, nu2, nu3, m1_1, m2_1, m2_2, m2_3, T1, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1\\n nu_T1 = [nu1, nuA]\\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\\n fs.integrate(nu_T1, T1, m=mig1)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1, nu2, nu3]\\n mig2 = numpy.array([[0, m2_1, m2_3],[m2_1, 0, m2_2], [m2_3, m2_2, 0]]) \\n fs.integrate(nu_T2, T2, m=mig2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1, nu2, nu3]\\n fs.integrate(nu_T3, T3) \\n return fs\",\n \"def connection(self, sampleseq, num):\\n self.Adjmatrix = np.zeros((self.nodenum, self.nodenum), dtype = int)\\n \\n for i in range(self.supplynum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.trandemandseries], sampleseq[self.supplyseries[i]]))\\n self.Adjmatrix[self.supplyseries[i], self.trandemandseries[minindex]] = 1\\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\\n \\n for i in range(self.trannum):\\n if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) == 0):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\\n self.Adjmatrix[minindex, self.transeries[i]] = 1\\n# self.Adjmatrix[self.transeries[i], minindex] = 1\\n \\n \\n# for i in range(self.supplynum):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.supplyseries], num))\\n# self.Adjmatrix[self.supplyseries[i], minindex] = 1\\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\\n \\n# for i in range(self.trannum):\\n# if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) != 0):\\n# continue\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\\n## self.Adjmatrix[self.transeries[i], minindex] = 1\\n# \\n for i in range(self.trannum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.demandseries], min(sampleseq[self.transeries[i]], self.demandnum))) + self.supplynum + self.trannum\\n self.Adjmatrix[self.transeries[i], minindex] = 1\\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\\n \\n# for i in range(self.demandnum):\\n# if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], 1)) + self.supplynum\\n# self.Adjmatrix[minindex, self.demandseries[i]] = 1\\n \\n# for i in range(self.trannum):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.transeries], num)) + self.supplynum\\n# self.Adjmatrix[self.transeries[i], minindex] = 1\\n \\n for i in range(self.demandnum):\\n if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], num)) + self.supplynum\\n self.Adjmatrix[minindex, self.demandseries[i]] = 1\\n# self.Adjmatrix[self.demandseries[i], minindex] = 1\\n \\n for i in range(self.demandnum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.demandseries[i], self.demandseries], min(sampleseq[self.demandseries[i]] + 1, self.demandnum))) + self.supplynum + self.trannum\\n minindex = minindex[1:-1]\\n for j in range(len(minindex)):\\n if(self.Adjmatrix[self.demandseries[i], minindex[j]] == 1 or self.Adjmatrix[minindex[j], self.demandseries[i]] == 1):\\n continue\\n self.Adjmatrix[self.demandseries[i], minindex[j]] = 1\",\n \"def power_iteration(self, adjacency_matrix, old_unique_id):\\n convergence = False\\n iteration = 0\\n\\n degree_with_beta = adjacency_matrix.sum(axis=0).T / self.beta\\n\\n # Initializing a vector\\n r_0 = np.ones((self.num_nodes, 1)) / self.num_nodes\\n\\n while not convergence:\\n\\n # Ignoring division by 0\\n with np.errstate(divide='ignore'):\\n # Calculating the Matrix-by-Vector product r_1\\n r_1 = adjacency_matrix.dot(r_0 / degree_with_beta)\\n\\n r_1 += (1 - r_1.sum()) / self.num_nodes\\n\\n # Convergence condition\\n norm = np.linalg.norm(r_0 - r_1, ord=1)\\n if norm < self.epsilon:\\n convergence = True\\n\\n # Reassign vector r_0\\n r_0 = r_1\\n iteration += 1\\n\\n print(\\\"Iteration : \\\", iteration, ' Norm:', norm)\\n\\n print(\\\"Resulting PageRank array:\\\", r_0)\\n print()\\n print(\\\"Element with the lowest PageRank:\\\", old_unique_id[np.argmin(r_0)])\\n print(\\\"Element with the highest PageRank:\\\", old_unique_id[np.argmax(r_0)])\\n print()\",\n \"def deg_mat(adj_mat, size, vertices):\\n deg_mat = np.zeros((size,size))\\n for i in vertices:\\n deg_mat[i][i] = degree(adj_mat, i)\\n return deg_mat\",\n \"def get_equation_matrix(obj_dict, node_dict):\\n\\n v_src_count = len(obj_dict['V'])\\n v_src_map = {}\\n for ind in range(len(obj_dict['V'])):\\n v_src_map[obj_dict['V'][ind].name] = ind \\n \\n node_count = len(node_dict.keys())-1 # excluded GND\\n \\n A = np.zeros((node_count, node_count), dtype='complex') # top left quad\\n B = np.zeros((node_count, v_src_count), dtype='complex') # top right quad\\n aux = np.zeros((v_src_count, node_count), dtype='complex') # bottom left quad\\n zero_quad = np.zeros((v_src_count,v_src_count), dtype='complex') # bottom right quad\\n const_vec_nodes = np.zeros((node_count), dtype='complex')\\n const_vec_aux = np.zeros((v_src_count), dtype='complex')\\n\\n for k in obj_dict.keys():\\n lst = obj_dict[k]\\n for obj in lst:\\n n1 = node_dict[obj.n1]-1\\n n2 = node_dict[obj.n2]-1\\n value = obj.value\\n\\n if obj.el_type in 'RLC':\\n if obj.imp == None: # dc\\n if obj.el_type == 'L':\\n value = EPS\\n elif obj.el_type == 'C':\\n value = INF\\n else:\\n value = obj.imp + EPS\\n\\n if n1 != -1 and n2 != -1:\\n A[n1,n1] += 1/value\\n A[n1,n2] += -1/value\\n A[n2,n1] += -1/value\\n A[n2,n2] += 1/value\\n\\n elif n1 == -1:\\n A[n2,n2] += 1/value\\n\\n elif n2 == -1:\\n A[n1,n1] += 1/value\\n\\n elif obj.el_type == 'V':\\n nv = v_src_map[obj.name]\\n if n1 != -1 and n2 != -1:\\n B[n1,nv] += 1\\n B[n2,nv] += -1\\n aux[nv,n1] += 1\\n aux[nv,n2] += -1\\n \\n elif n1 == -1:\\n B[n2,nv] += -1\\n aux[nv,n2] += -1\\n \\n elif n2 == -1:\\n B[n1,nv] += 1\\n aux[nv,n1] += 1\\n\\n const_vec_aux[nv] += value\\n\\n elif obj.el_type == 'I':\\n if n1 != -1 and n2 != -1:\\n const_vec_nodes[n1] += obj.value\\n const_vec_nodes[n2] += -obj.value\\n elif n1 == -1:\\n const_vec_nodes[n2] += -obj.value\\n elif n2 == -1:\\n const_vec_nodes[n1] += obj.value\\n\\n elif obj.el_type in 'EGHF':\\n print(\\\"ERR: Controlled sources not supported yet\\\")\\n return None\\n\\n top_half = np.concatenate((A, B), axis=1) \\n bot_half = np.concatenate((aux, zero_quad), axis=1)\\n coeff_mat = np.concatenate((top_half, bot_half), axis=0)\\n const_vec = np.concatenate((const_vec_nodes, const_vec_aux), axis=0)\\n\\n return [coeff_mat, const_vec]\",\n \"def generate_full_adj(self):\\n adj_mat = np.ones([self.n_balls, self.n_balls])\\n adj_mat -= np.eye(self.n_balls)\\n\\n int_st = self.interaction_strength * adj_mat\\n lengths = adj_mat.copy()\\n return adj_mat, int_st, lengths\",\n \"def block_adjacency_matrix(self, block_id, ctx): # -> tuple[Unknown, Unknown]:\\n ...\",\n \"def refugia_adj_4(params, ns):\\n #11 parameters \\n nu1, nuA, nu2, nu3, m1_1, m3_2, m3_3, T1a, T1b, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1a\\n nu_T1 = [nu1, nuA]\\n fs.integrate(nu_T1, T1a)\\n ## Population function and migration matrix for T1b\\n mig1 = numpy.array([[0, m1_1],[m1_1, 0]])\\n fs.integrate(nu_T1, T1b, m=mig1) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1, nu2, nu3]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1, nu2, nu3]\\n mig3 = numpy.array([[0, 0, 0],[0, 0, 0], [m3_3, m3_2, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def main():\\n n = 34\\n # create the adjacency matrix\\n stripped_lines = Util.get_stripped_lines(g_karate_data.splitlines())\\n string_rows = [line.split() for line in stripped_lines if line]\\n assert len(string_rows) == n\\n for row in string_rows:\\n assert len(row) == n\\n data_rows = [[float(x) for x in string_row] for string_row in string_rows]\\n A = np.array(data_rows)\\n # create the ordered module indices\\n first_cluster_one_based_indices = [1, 3, 4, 14, 2, 8, 20, 18, 22, 13, 12, 6, 7, 17, 5, 11]\\n second_cluster_one_based_indices = [25, 32, 26, 29, 24, 28, 9, 34, 33, 19, 16, 31, 15, 10, 23, 30, 21, 27]\\n assert len(first_cluster_one_based_indices + second_cluster_one_based_indices) == n\\n assert list(sorted(first_cluster_one_based_indices + second_cluster_one_based_indices)) == range(1, n+1)\\n ordered_module_indices = []\\n for i in range(n):\\n if i+1 in first_cluster_one_based_indices:\\n ordered_module_indices.append(0)\\n else:\\n ordered_module_indices.append(1)\\n # print the modularity\\n Q = get_modularity_other_b(A, ordered_module_indices)\\n print 'modularity calculated using my interpretation of the method of the paper', Q\\n Q = get_modularity_other_b2(A, ordered_module_indices)\\n print 'modularity calculated using a modification of my interpretation of the method of the paper', Q\\n Q = get_modularity_other_c(A, ordered_module_indices)\\n print 'modularity calculated using the method on wikipedia', Q\\n Q = get_eric_modularity(A, ordered_module_indices)\\n print 'modularity calculated using the method eric used:', Q\\n print 'expected modularity: .375 +/- .025'\",\n \"def degree(adj_mat, vertex):\\n return np.sum(adj_mat[vertex][:])\",\n \"def __get_pairwise(self, image):\\n # We will use the adjacency matrix\\n\\n P=[]\\n (n,m, _)= image.shape\\n\\n sigma=5\\n def B(p,q):\\n Ip=np.mean(p) # Itensity\\n Iq=np.mean(q)\\n \\n return np.exp(-0.5*((Ip-Iq)/sigma)**2 ) \\n \\n L=[]\\n for i in range(n):\\n for j in range(m):\\n L.append(image[i,j])\\n image_flat=np.array(L)\\n for i in range(n*m-m):\\n B01=B(image_flat[i], image_flat[i+1])\\n B01_=B(image_flat[i], image_flat[i+m])\\n \\n P.append([i,i+m,0,B01_,B01_,0]) # vertice with the node below\\n if i %(m-1)!=0: # Check if it is not the end of a line\\n P.append([i,i+1,0,B01,B01,0]) # vertice with the node on the right \\n \\n for i in range(n*m-m,n*m-1):\\n B01__=B(image_flat[i], image_flat[i+1])\\n P.append([i,i+1,0,B01__,B01__,0])\\n\\n \\n return np.array(P)\",\n \"def original_solution():\\n matrix = get_data()\\n # Construct Graph\\n G = nx.DiGraph()\\n rows, cols = len(matrix), len(matrix[0])\\n for r in xrange(rows):\\n for c in xrange(cols):\\n if 0 < c:\\n G.add_edge(r*cols + c, r*cols + c - 1, weight=matrix[r][c-1])\\n if c < cols-1:\\n G.add_edge(r*cols + c, r*cols + c + 1, weight=matrix[r][c+1])\\n if 0 < r:\\n G.add_edge(r*cols + c, (r-1)*cols + c, weight=matrix[r-1][c])\\n if r < rows-1:\\n G.add_edge(r*cols + c, (r+1)*cols + c, weight=matrix[r+1][c])\\n # Calculate shortest path\\n path = nx.shortest_path(G, 0, rows*cols-1, weighted=True)\\n \\n # Get cost for path\\n s = 0\\n for p in path:\\n c = p % cols\\n r = (p - c) / rows\\n s += matrix[r][c]\\n return s\",\n \"def rwgraph_analyze2(input=(None)):\\r\\n\\r\\n\\r\\n #set up graph and degree distribution arrays\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n Nt=100\\r\\n M=20000\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n\\r\\n #set inital conditions and D\\r\\n y0=np.zeros(n,dtype=int)\\r\\n y0[j]=200\\r\\n D=1\\r\\n #define time for odi Int\\r\\n t=np.arange(Nt+1,dtype=int)\\r\\n #set up operators\\r\\n A = nx.adjacency_matrix(G)\\r\\n Q = A.toarray().sum(axis=1)\\r\\n L=np.diag(Q)-A.toarray()\\r\\n Q_inv=1/Q\\r\\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\\r\\n Ls_tran=np.transpose(Ls)\\r\\n\\r\\n #convert to sparse operators and include diffusion\\r\\n L_spar = scipy.sparse.csr_matrix(-D*L)\\r\\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\\r\\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\\r\\n A=nx.adjacency_matrix(G)\\r\\n L=-D*(scipy.sparse.diags(degree_arr)-A)\\r\\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\\r\\n\\r\\n #define operators\\r\\n def Lap(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\\r\\n def Lap_Ls(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\\r\\n def Lap_Ls_tran(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\\r\\n\\r\\n #solutions of different operators\\r\\n solL=scipy.integrate.odeint(Lap,y0,t)\\r\\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\\r\\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\\r\\n\\r\\n\\r\\n #finds eigen values and vectors and puts them into order\\r\\n def eigen(L):\\r\\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\\r\\n idx = eigen_values.argsort()[::-1]\\r\\n eigen_values = eigen_values[idx]\\r\\n eigen_vectors = eigen_vectors[:,idx]\\r\\n return eigen_values,eigen_vectors\\r\\n\\r\\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\\r\\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\\r\\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\\r\\n eigen_values_L,eigen_vectors_L=eigen(L)\\r\\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\\r\\n\\r\\n ### could have eigs here as didn't end up using all eigenvalues ####\\r\\n #eigen values graph\\r\\n n0=len(eigen_values_L)\\r\\n eig_nums=np.arange(n0)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\\\"x\\\" ,label='L , D=0.36')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\\\"|\\\",label='LS , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\\\"+\\\" ,label='L , D=1')\\r\\n plt.legend(loc=\\\"lower left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.xlabel('eigen value number')\\r\\n plt.ylabel('eigenvalue')\\r\\n plt.title(\\\"Eigenvlaues of Laplacian Matrixs\\\")\\r\\n plt.show()\\r\\n\\r\\n print(\\\"4 biggest eigenvalues for each operater\\\")\\r\\n print('L=',eigen_values_L[0:4])\\r\\n print('Ls=',eigen_values_LS[0:4])\\r\\n print('Ls_tran=',eigen_values_LS_tran[0:4])\\r\\n #prints 4 biggest eigen values\\r\\n #counts node distrubtion by creating dictionary\\r\\n def result_count(sol,Nt,G):\\r\\n \\\"\\\"\\\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\\\"\\\"\\\"\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\\r\\n\\r\\n #frequency count of solutions\\r\\n dict_freq=result_count(solL,Nt,G)\\r\\n dict_freq2=result_count(solLs,Nt,G)\\r\\n dict_freq3=result_count(solLs_tran,Nt,G)\\r\\n\\r\\n #random walk data\\r\\n X=rwgraph(G,j,20000,100)\\r\\n Listnodes7=[]\\r\\n for i in range(20000):\\r\\n Listnodes7.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,200,100)\\r\\n Listnodes8=[]\\r\\n for i in range(200):\\r\\n Listnodes8.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,50000,5000)\\r\\n Listnodes9=[]\\r\\n for i in range(50000):\\r\\n Listnodes9.append(G.degree(X[i,5000]))\\r\\n listfreq7=CountFrequency(Listnodes7)\\r\\n listfreq8=CountFrequency(Listnodes8)\\r\\n listfreq9=CountFrequency(Listnodes9)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n z2=[]\\r\\n z3=[]\\r\\n z1=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n z_deg1=[]\\r\\n for i in listfreq7:\\r\\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq8:\\r\\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n for i in listfreq8:\\r\\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\\r\\n z_deg1.append(i)\\r\\n #operator solutions compared to node degree frequency\\r\\n z4,z5,z6=[],[],[]\\r\\n z_deg4,z_deg5,z_deg6=[],[],[]\\r\\n for i in dict_freq:\\r\\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\\r\\n z_deg4.append(i)\\r\\n for i in dict_freq2:\\r\\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\\r\\n z_deg5.append(i)\\r\\n for i in dict_freq3:\\r\\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg6.append(i)\\r\\n\\r\\n plt.figure(figsize=(15, 10))\\r\\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\\r\\n plt.scatter(z_deg4, z4,label='L, Nt=100')\\r\\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\\r\\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\\r\\n plt.ylim((-0.005,0.020))\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n\\r\\n #code to produce final graph\\r\\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\\r\\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\\r\\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\\r\\n tarray = np.linspace(0,5,Nt+1)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\\r\\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\\r\\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\\r\\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\\r\\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\\r\\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\\r\\n plt.xlabel('time')\\r\\n plt.ylabel('representive frequency')\\r\\n plt.legend()\\r\\n plt.title(\\\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def _learn_node_parameter_w(outputs, inputs=None):\\n num_inputs = 0 if inputs is None else inputs.shape[1]\\n weights = np.zeros(shape=num_inputs + 1)\\n\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n # Ax = b, A\\n N_observe = outputs.shape[0]\\n A = np.zeros(shape = (num_inputs+1, num_inputs+1))\\n for i in range(A.shape[0]):\\n for j in range(A.shape[1]):\\n if i==0 and j==0:\\n A[i][j] = N_observe\\n elif i==0 and j!=0:\\n A[i][j] = np.sum(inputs[:,j-1])\\n elif i!=0 and j==0:\\n A[i][j] = np.sum(inputs[:,i-1])\\n else:\\n for k in range(N_observe):\\n A[i][j] += inputs[k,i-1]*inputs[k, j-1]\\n b = np.zeros(shape=num_inputs + 1)\\n for i in range(len(b)):\\n if i==0:\\n b[i] = np.sum(outputs)\\n else:\\n for k in range(N_observe):\\n b[i] += inputs[k,i-1]*outputs[k]\\n\\n weights = np.linalg.solve(A, b)\\n \\\"\\\"\\\" END YOUR CODE HERE \\\"\\\"\\\"\\n\\n return weights\",\n \"def vertex_adjacency_matrix(self):\\n if '_V_adjacency_matrix' not in self.__dict__:\\n self._init_vertex_adjacency_matrix()\\n return self._V_adjacency_matrix;\",\n \"def circulant_adj(js, num_vertices):\\n\\n # make a fresh/empty adjacency matrix\\n adj = np.zeros((num_vertices, num_vertices), dtype=\\\"uint8\\\")\\n\\n # make a connect between each node and a node\\n # that is j spaces to the left and to right of the node\\n for i in range(num_vertices):\\n for j in js:\\n adj[i][(i - j) % num_vertices] = 1\\n adj[i][(i + j) % num_vertices] = 1\\n\\n return adj\",\n \"def convert_sparse_to_igraph(indices, matrix):\\n # sources, targets = matrix.nonzero()\\n # weights = matrix[sources, targets]\\n # weights = np.array(weights)[0]\\n # print(dir(louvain))\\n # ig = igraph.Graph(zip(sources, targets), directed=True,\\n # edge_attrs={'weight': weights})\\n # return ig\\n g = igraph.Graph.Adjacency((matrix > 0).tolist())\\n g.es['weight'] = matrix[matrix.nonzero()]\\n # g.vs['label'] = node_names # or a.index/a.columns\\n return g\",\n \"def adjacency_matrix(g):\\n nodes = sorted(g.keys())\\n adj = []\\n for row_node in nodes:\\n row = []\\n for column_node in nodes:\\n if column_node in g[row_node]:\\n row.append(1)\\n else:\\n row.append(0)\\n adj.append(row)\\n \\n return adj\",\n \"def NPL(self):\\n self.edge = np.zeros((np.sum(self.Adjmatrix), 3))\\n Temp = 0\\n for i in range(self.nodenum):\\n for j in range(self.nodenum):\\n if(self.Adjmatrix[i, j] == 1):\\n self.edge[Temp, 0], self.edge[Temp, 1], self.edge[Temp, 2] = i, j, self.Dismatrix[i, j]\\n Temp += 1\\n \\n self.Totallength = ((np.max(self.Geox) - np.min(self.Geox))**2 + (np.max(self.Geoy) - np.min(self.Geoy))**2)**0.5\\n self.norm_edge = self.edge[:, 2]/self.Totallength\",\n \"def _updateTransitionMatrix(self):\\n N = self.N\\n K = self.K\\n T= self.T\\n\\n for i in range(1,self.K+1):\\n den = 0\\n for t in range(1,self.T):\\n for n in range(1,N+1):\\n den = den + self.posterior_state_trellis[n][(t,i)]\\n \\n for j in range(1,self.K+1): \\n # For some state i,j\\n s = 0\\n for n in range(1,N+1): \\n for t in range(1,self.T): \\n cur_prob = self.posterior_transition_trellis[n][(t,t+1,j,i)]\\n s = s+cur_prob\\n\\n # Compute total \\n self.state_transition_mat[(j,i)] = (s/den)\",\n \"def _initializeAdjacencyList(self):\\n\\n if self.comm.rank == 0:\\n # First, create a dictionary of common edges shared by components\\n edgeToFace = {}\\n for elemID in self.bdfInfo.elements:\\n elemInfo = self.bdfInfo.elements[elemID]\\n elemConn = elemInfo.nodes\\n compID = self.meshLoader.nastranToTACSCompIDDict[elemInfo.pid]\\n nnodes = len(elemConn)\\n if nnodes >= 2:\\n for j in range(nnodes):\\n nodeID1 = elemConn[j]\\n nodeID2 = elemConn[(j + 1) % nnodes]\\n\\n if nodeID1 < nodeID2:\\n key = (nodeID1, nodeID2)\\n else:\\n key = (nodeID2, nodeID1)\\n\\n if key not in edgeToFace:\\n edgeToFace[key] = [compID]\\n elif compID not in edgeToFace[key]:\\n edgeToFace[key].append(compID)\\n\\n # Now we loop back over each element and each edge. By\\n # using the edgeToFace dictionary, we can now determine\\n # which components IDs (jComp) are connected to the\\n # current component ID (iComp).\\n self.adjacentComps = []\\n\\n for edgeKey in edgeToFace:\\n if len(edgeToFace[edgeKey]) >= 2:\\n for i, iComp in enumerate(edgeToFace[edgeKey][:-1]):\\n for jComp in edgeToFace[edgeKey][i + 1 :]:\\n if iComp < jComp:\\n dvKey = (iComp, jComp)\\n else:\\n dvKey = (jComp, iComp)\\n if dvKey not in self.adjacentComps:\\n self.adjacentComps.append(dvKey)\\n\\n else:\\n self.adjacentComps = None\\n\\n # Wait for root\\n self.comm.barrier()\",\n \"def get_adjacency_matrix(self):\\n m = zeros(self.size)\\n perm = self.array_form\\n for i in xrange(self.size - 1):\\n m[perm[i], perm[i + 1]] = 1\\n return m\",\n \"def internal_adjacency(self, node_list):\\n # Create igraph Graph object describing the subgraph\\n subgraph = self.graph.subgraph(node_list)\\n # Get adjacency matrix\\n return np.array(subgraph.get_adjacency(type=2).data).astype(np.int8)\",\n \"def calc_dependency_matrix(encoder: nn.Module, latents: torch.Tensor) -> torch.Tensor:\\n\\n # calculate the jacobian\\n jacob = jacobian(encoder.forward, latents)\\n # take the absolute value\\n return jacob.abs()\",\n \"def compute_node_dissociation_index(community_vect, sparse_mat):\\n dense_mat = sparse_mat.todense()\\n undir_dense_mat = dense_mat + np.transpose(dense_mat)\\n bin_dense_mat = np.array(undir_dense_mat != 0, dtype=int)\\n\\n degree_vect = np.array(np.sum(bin_dense_mat != 0, axis=1), dtype='float')\\n community_indexes = np.unique(community_vect)\\n\\n ndi_values = np.ones(\\n shape=(community_vect.shape[0]), dtype='float')\\n\\n for i in range(ndi_values.shape[0]):\\n\\n \\\"\\\"\\\"\\n same_com = np.where(\\n np.array([community_vect[i] == community_vect[j] for j in\\n range(ndi_values.shape[0])],dtype = \\\"bool\\\") == True)\\n\\n print (same_com[0])\\n\\n val = 1.0-(np.sum(bin_dense_mat[i,\\n same_com[0]])/float(degree_vect[i]))\\n \\\"\\\"\\\"\\n\\n val2 = 0.0\\n\\n for j in community_indexes:\\n if j != -1 and j != community_vect[i]:\\n val2 += np.sum(bin_dense_mat[i, community_vect == j])\\n\\n if degree_vect[i]:\\n ndi_values[i] = val2/float(degree_vect[i])\\n\\n else:\\n print(\\\"Warning, degree is null for node {}\\\".format(i))\\n print(bin_dense_mat)\\n\\n ndi_values[i] = 0.0\\n\\n return ndi_values\",\n \"def cost_change(adjacency_matrix, n1, n2, n3, n4):\\n return adjacency_matrix[n1][n3] + adjacency_matrix[n2][n4] - \\\\\\n adjacency_matrix[n1][n2] - adjacency_matrix[n3][n4]\",\n \"def find_topo_order(s,graph):\\n\\n ## initialization\\n matrix = graph.get_adjacency()\\n n, c = matrix.shape\\n sym_matrix = np.empty((n,c), dtype=object)\\n # cost_matrix = np.zeros((n,c))\\n cache = {}\\n\\n def symbolize(i,j):\\n \\\"given two indices, create a symbolic variable\\\"\\n s = z.Int('edge_{0}{1}'.format(i,j))\\n return s\\n\\n\\n def value_of(i,j):\\n \\\"given two indices, return the (i,j)th value in the adjacency matrix\\\"\\n return sym_matrix[i][j]\\n\\n\\n def constraint_1(n,i,j,k):\\n y_ij = value_of(i,j)\\n y_jk = value_of(j,k)\\n y_ik = value_of(i,k)\\n\\n name = \\\"c1\\\" + str((n,i,j,k))\\n constraint = (y_ij + y_jk - y_ik) <= 1\\n\\n # if name not in cache:\\n # cache[name] = constraint\\n s.assert_and_track(constraint, name)\\n\\n\\n def constraint_2(n,i,j,k):\\n y_ij = value_of(i,j)\\n y_jk = value_of(j,k)\\n y_ik = value_of(i,k)\\n\\n name = \\\"c2\\\" + str((n,i,j,k))\\n constraint = (-y_ij - y_jk + y_ik) <= 0\\n\\n # if name not in cache:\\n # cache[name] = constraint\\n s.assert_and_track(constraint, name)\\n\\n\\n def constraint_3(symbolic):\\n s.add(z.Or([symbolic == 0, symbolic == 1]))\\n\\n\\n def int_formulation(j):\\n left = z.Sum([matrix[k][j] * sym_matrix[k][j] for k in range(j)])\\n right = z.Sum([matrix[l][j] * (1 - sym_matrix[j][l]) for l in range(j+1, n)])\\n\\n return [left, right]\\n\\n\\n ## constraint 3, every edge must be a 0 or a 1, we get the 0 or 1 directly\\n ## from the adjacency matrix\\n ## we do this first so that the sym_matrix is populated\\n for n_iter in range(n):\\n for j in range(n_iter+1):\\n for i in range(j):\\n s_edge = symbolize(i,j)\\n sym_matrix[i][j] = s_edge\\n constraint_3(s_edge)\\n\\n ## Iteration for triangle inequalities\\n for n_iter in range(n):\\n for k in range(n_iter+1):\\n for j in range(k):\\n for i in range(j):\\n constraint_1(n_iter,i,j,k)\\n constraint_2(n_iter,i,j,k)\\n\\n\\n ## minimization\\n o = z.Optimize()\\n y = z.Int('y')\\n\\n y = z.Sum(u.flatten([int_formulation(j) for j in range(n)]))\\n o.minimize(y)\\n\\n result = []\\n\\n if s.check() == z.sat:\\n result = s.model()\\n\\n return result\",\n \"def generate_adjacents(node):\\n # Makes a dictionary where keys are current upper token positions and\\n # values are the list of positions attainable from one slide move\\n slide_moves = {}\\n for key, value in node.boardstate.items():\\n if value.isupper() and value != \\\"B\\\":\\n slide_moves[key] = get_slide_moves(key, node.boardstate)\\n\\n # Append list of swing moves to get all moves\\n moves_dict = {}\\n #relevant_pieces = [name ]\\n for key in slide_moves:\\n all_moves = set(slide_moves[key] + get_swing_moves(key, slide_moves))\\n moves_dict[key] = list(all_moves)\\n\\n # Convert from dictionary to list of list of tuples of the form:\\n #[[(curr_move, next_move)...]...] where each tokens moves occupy a list\\n moves_list = []\\n for curr, news in moves_dict.items():\\n moves_list.append([(curr, new) for new in news])\\n\\n # Get all combinations of moves and for each combo construct a new board state\\n adjacent_states = []\\n turns = list(product(*moves_list))\\n\\n for turn in turns:\\n new_board = apply_turn(node, turn)\\n if new_board:\\n adjacent_states.append((turn, new_board))\\n return adjacent_states\",\n \"def build_AGS_matrix(mesh: meshio.Mesh) -> tf.sparse.SparseTensor:\\n\\n tf_indices: List\\n tf_values: List\\n tf_shape: Tuple[int]\\n tf_indices, tf_values, tf_shape = [], [], (3 * len(mesh.points), len(mesh.points))\\n rot: np.ndarray = np.array([[0, -1, 0], [1, 0, 0], [0, 0, 0]])\\n\\n prev: int\\n curr: int\\n next: int\\n vid: int\\n prev_triangle: np.ndarray\\n curr_triangle: np.ndarray\\n area: float\\n c_prev: float\\n c_next: float\\n vert_contr: List\\n indx_node: int\\n node: np.ndarray\\n i: int\\n for indx_node, node in enumerate(mesh.points):\\n triangles: List[Tuple[int]]\\n flag_b: bool \\n triangles, flag_b = get_cycle(mesh, indx_node)\\n if len(triangles) > 0:\\n prev_triangle = triangles[0]\\n area = 0.0\\n vert_contr = []\\n for i in range(1, len(triangles) + (1 - int(flag_b))):\\n curr_triangle = triangles[i % len(triangles)]\\n vid = curr_triangle[1]\\n\\n prev = prev_triangle[0]\\n curr = prev_triangle[2]\\n next = curr_triangle[2]\\n\\n if i == 0 and flag_b: area += get_area_from_points(mesh, (prev, vid, curr))\\n\\n area += get_area_from_points(mesh, (curr, vid, next))\\n\\n c_prev = np.matmul(rot, (mesh.points[curr] - mesh.points[prev]))\\n c_next = np.matmul(rot, (mesh.points[next] - mesh.points[curr]))\\n\\n vert_contr.append((curr, 0.5 * (c_prev + c_next)))\\n\\n if flag_b:\\n if i == 0:\\n vert_contr.append((vid, 0.5 * (c_prev)))\\n if i == len(triangles) - 1:\\n vert_contr.append((vid, 0.5 * (c_next)))\\n\\n prev_triangle = curr_triangle\\n\\n for col, value in vert_contr:\\n for i in range(3):\\n tf_indices.append([indx_node * 3 + i, col])\\n tf_values.append(value[i] / area)\\n\\n Sp_tf_AGS_matrix: tf.sparse.SparseTensor = tf.sparse.SparseTensor(\\n tf_indices, tf.cast(tf_values, dtype=tf.float32), tf_shape\\n )\\n\\n return Sp_tf_AGS_matrix\",\n \"def construct_4adj_graph(X):\\n s0, s1, s2 = X.shape\\n \\n size_data = s0*s1\\n \\n xGrid, yGrid = np.meshgrid(np.arange(s0), np.arange(s1))\\n totGrid = (xGrid*s1 + yGrid).transpose()\\n \\n horiz_edges = np.sqrt(np.sum((X[1:,:,:] - X[:-1,:,:])**2, axis=-1).flatten())\\n indx_horiz_edges = totGrid[1:,:].flatten()\\n indy_horiz_edges = totGrid[:-1,:].flatten()\\n \\n vert_edges = np.sqrt(np.sum((X[:,1:,:] - X[:,:-1,:])**2, axis=-1).flatten())\\n indx_vert_edges = totGrid[:,1:].flatten()\\n indy_vert_edges = totGrid[:,:-1].flatten()\\n \\n w = np.concatenate((horiz_edges, vert_edges), axis=0) + 1e-6\\n u = np.concatenate((indx_horiz_edges, indx_vert_edges), axis=0)\\n v = np.concatenate((indy_horiz_edges, indy_vert_edges), axis=0)\\n \\n return sp.sparse.csr_matrix((w,(u,v)), shape=(size_data, size_data))\",\n \"def adj_matrix(self):\\n return nx.adj_matrix(self.network)\",\n \"def _estimate_assignments(self, graph: GraphRepresentation) -> None:\\n embed_graph = augment_diagonal(graph)\\n latent = AdjacencySpectralEmbed(\\n n_components=self.n_components, **self.embed_kws\\n ).fit_transform(embed_graph)\\n if isinstance(latent, tuple):\\n latent = np.concatenate(latent, axis=1)\\n gc = GaussianCluster(\\n min_components=self.min_comm,\\n max_components=self.max_comm,\\n **self.cluster_kws\\n )\\n vertex_assignments = gc.fit_predict(latent) # type: ignore\\n self.vertex_assignments_ = vertex_assignments\",\n \"def additive_phylogeny(matrix, n, G):\\n new_node = n\\n\\n def additive_recur_helper(matrix, n, G):\\n\\n nonlocal new_node\\n\\n if n == 2:\\n print(\\\"d add_edge (%s,%s):%s\\\" % (0, 1, matrix[0, 1]))\\n G.add_edge(0, 1, weight=matrix[0, 1])\\n return\\n\\n limblen = limblength(n - 1, matrix)\\n i, k = find_i_k(matrix, n - 1, limblen)\\n x = matrix[i, n - 1] - limblen\\n\\n print(\\\"n=%s limblen=%s i=%s k=%s x=%s\\\" % (n, limblen, i, k, x))\\n\\n additive_recur_helper(matrix[0 : n - 1, 0 : n - 1], n - 1, G)\\n\\n v = node_at_distance(G, i, k, x, matrix[i, k], new_node)\\n if v == new_node:\\n new_node += 1\\n\\n print(\\\"node_at_distance %s from %s is %s\\\" % (x, i, v))\\n\\n print(\\\"e add_edge (%s,%s):%s\\\" % (v, n - 1, limblen))\\n G.add_edge(v, n - 1, weight=limblen)\\n\\n # draw graph if small\\n if len(G) < 30:\\n global plot_cnt\\n pos = nx.kamada_kawai_layout(G)\\n labels = nx.get_edge_attributes(G, \\\"weight\\\")\\n nx.draw(G, pos, with_labels=True)\\n nx.draw_networkx_edge_labels(G, pos, edge_labels=labels)\\n plt.draw()\\n plt.savefig(\\\"Graph\\\" + str(plot_cnt) + \\\".png\\\", format=\\\"PNG\\\")\\n plt.clf()\\n plot_cnt += 1\\n\\n return\\n\\n additive_recur_helper(matrix, n, G)\\n\\n return\",\n \"def contracting_channel(m, n, W_upstream = 1., W_downstream = 0.75,\\n L_1 = 5.0, L_2 = 2.0, L_3 = 10, origin = (0.0, 0.0)):\\n\\n import math\\n\\n from anuga.config import epsilon\\n\\n\\n lenx = L_1 + L_2 + L_3\\n leny = W_upstream\\n deltax = lenx/float(m)\\n deltay = leny/float(n)\\n\\n x1 = 0\\n y1 = 0\\n x2 = L_1\\n y2 = 0\\n x3 = L_1 + L_2\\n y3 = (W_upstream - W_downstream)/2\\n x4 = L_1 + L_2 + L_3\\n y4 = y3\\n x5 = x4\\n y5 = y4 + W_downstream\\n x6 = L_1 + L_2\\n y6 = y5\\n x7 = L_1\\n y7 = W_upstream\\n x8 = 0\\n y8 = W_upstream\\n a1 = 0\\n a2 = (W_upstream - W_downstream)/(2*L_2)\\n a3 = 1\\n a4 = (W_downstream - W_upstream)/(L_2*W_upstream)\\n\\n # Dictionary of vertex objects\\n vertices = {}\\n points = []\\n\\n for i in range(m+1):\\n x = deltax*i\\n for j in range(n+1):\\n y = deltay*j\\n if x > L_1 and x <= (L_1 + L_2):\\n y = a1 + a2*(x - L_1) + a3*y + a4*(x - L_1)*y\\n elif x > L_1 + L_2:\\n y = (W_upstream - W_downstream)/2 + deltay*j*W_downstream/W_upstream\\n\\n vertices[i,j] = len(points)\\n points.append([x + origin[0], y + origin[1]])\\n\\n # Construct 2 triangles per element\\n elements = []\\n boundary = {}\\n for i in range(m):\\n for j in range(n):\\n v1 = vertices[i,j+1]\\n v2 = vertices[i,j]\\n v3 = vertices[i+1,j+1]\\n v4 = vertices[i+1,j]\\n\\n #Update boundary dictionary and create elements\\n if i == m-1:\\n boundary[(len(elements), 2)] = 'right'\\n if j == 0:\\n boundary[(len(elements), 1)] = 'bottom'\\n elements.append([v4,v3,v2]) #Lower\\n\\n if i == 0:\\n boundary[(len(elements), 2)] = 'left'\\n if j == n-1:\\n boundary[(len(elements), 1)] = 'top'\\n\\n elements.append([v1,v2,v3]) #Upper\\n\\n return points, elements, boundary\",\n \"def solve(list_of_locations, list_of_homes, starting_car_location, adjacency_matrix, params=[]):\\n\\n\\n\\n\\n path = [starting_car_location]\\n dict = {}\\n index = 0\\n for i in range(len(list_of_locations)):\\n if list_of_locations[i] == starting_car_location:\\n index = i\\n\\n path = [index]\\n\\n G, m = adjacency_matrix_to_graph(adjacency_matrix)\\n\\n home_indexes = []\\n\\n for home in list_of_homes:\\n for i in range(len(list_of_locations)):\\n if list_of_locations[i] == home:\\n home_indexes.append(i)\\n break\\n\\n new_adjacency = [[\\\"x\\\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\\n\\n # for sake of figuring out where to walk\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G, index, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n for home1 in home_indexes:\\n for home2 in home_indexes:\\n if not home1 == home2:\\n di_path = nx.dijkstra_path(G, home1, home2)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n\\n\\n G2, m = adjacency_matrix_to_graph(new_adjacency)\\n\\n all_driving_path = list(nx.dfs_edges(G2))\\n\\n\\n\\n\\n walking_to = []\\n walking_from = {}\\n\\n for i in range(len(new_adjacency)):\\n if i in home_indexes:\\n count = 0\\n edge_to = 0\\n for j in range(len(new_adjacency)):\\n if new_adjacency[i][j] != \\\"x\\\":\\n count += 1\\n edge_to = j\\n\\n #must ensure that this is not a home that we are already dropping someone off at, otherwise it will cut off a line of two homes\\n if count == 1 and i != index and i not in walking_from.keys():\\n new_adjacency[i][edge_to] = \\\"x\\\"\\n new_adjacency[edge_to][i] = \\\"x\\\"\\n walking_to.append(i)\\n if edge_to in walking_from:\\n walking_from[edge_to] = walking_from[edge_to] + [i]\\n else:\\n walking_from[edge_to] = [i]\\n\\n #\\n # for i in range(len(all_driving_path) - 1):\\n # #if first vertex in edge is the same, we should walk\\n # if all_driving_path[i][0] == all_driving_path[i + 1][0]:\\n # print(all_driving_path[i][0])\\n # print(all_driving_path[i][1])\\n # #get rid of only edge connected to this home\\n # new_adjacency[all_driving_path[i][0]][all_driving_path[i][1]] = \\\"x\\\"\\n # new_adjacency[all_driving_path[i][1]][all_driving_path[i][0]] = \\\"x\\\"\\n # walking_to.append(all_driving_path[i][1])\\n # if all_driving_path[i][0] in walking_from:\\n # walking_from[all_driving_path[i][0]] = walking_from[all_driving_path[i][0]] + [all_driving_path[i][1]]\\n # else:\\n # walking_from[all_driving_path[i][0]] = [all_driving_path[i][1]]\\n\\n\\n\\n dropoff_locations = list(walking_from.keys())\\n for loc in dropoff_locations:\\n if loc in home_indexes:\\n dropoff_locations.remove(loc)\\n\\n\\n for loc in dropoff_locations:\\n di_path = nx.dijkstra_path(G, loc, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G, loc, home)\\n for i in range(len(di_path) - 1):\\n new_adjacency[di_path[i]][di_path[i + 1]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n new_adjacency[di_path[i + 1]][di_path[i]] = adjacency_matrix[di_path[i]][di_path[i + 1]]\\n\\n\\n G2, m = adjacency_matrix_to_graph(new_adjacency)\\n # G = G2\\n # pos=nx.spring_layout(G2)\\n # nx.draw_networkx_nodes(G2,pos)\\n # nx.draw_networkx_labels(G2, pos)\\n # nx.draw_networkx_edges(G2,pos,width=1.0,alpha=0.5)\\n #\\n # plt.draw()\\n # plt.show()\\n\\n # condensed shortest paths to edges - use G3 for real\\n\\n new_adjacency2 = [[\\\"x\\\" for i in range(len(list_of_locations))] for j in range(len(list_of_locations))]\\n\\n for home in home_indexes:\\n if home not in walking_to:\\n di_path = nx.dijkstra_path(G2, index, home)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n\\n for home1 in home_indexes:\\n for home2 in home_indexes:\\n if not home1 == home2 and home1 not in walking_to and home2 not in walking_to:\\n di_path = nx.dijkstra_path(G2, home1, home2)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n di_path = nx.dijkstra_path(G2, index, loc)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n for loc in dropoff_locations:\\n for home in home_indexes:\\n di_path = nx.dijkstra_path(G2, loc, home)\\n start = di_path[0]\\n end = di_path[len(di_path) - 1]\\n new_adjacency2[start][end] = 0\\n new_adjacency2[end][start] = 0\\n for i in range(len(di_path) - 1):\\n new_adjacency2[start][end] += new_adjacency[di_path[i]][di_path[i + 1]]\\n new_adjacency2[end][start] += new_adjacency[di_path[i]][di_path[i + 1]]\\n\\n\\n\\n\\n final_G, m = adjacency_matrix_to_graph(new_adjacency2)\\n drive_path = list(nx.dfs_edges(final_G, source=index))\\n drive_path.append(index)\\n\\n mst = nx.minimum_spanning_tree(final_G)\\n\\n\\n\\n new_mst = nx.MultiGraph(mst)\\n for edge in mst.edges():\\n new_mst.add_edge(edge[0], edge[1])\\n\\n\\n if new_mst.degree[index] != 0:\\n to_remove = []\\n for node in new_mst:\\n if (new_mst.degree[node] == 0):\\n to_remove.append(node)\\n new_mst.remove_nodes_from(to_remove)\\n\\n eulerian = list(nx.eulerian_circuit(new_mst, index))\\n\\n path = []\\n for edge in eulerian:\\n path.append(edge[0])\\n\\n path.append(eulerian[len(eulerian) - 1][1])\\n\\n already_seen = []\\n to_remove = []\\n for i in range(len(path) - 1):\\n if path[i] in already_seen:\\n to_remove.append(i)\\n else:\\n already_seen.append(path[i])\\n\\n new_path = []\\n for i in range(len(path) - 1):\\n if i not in to_remove:\\n new_path.append(path[i])\\n path = new_path\\n print(eulerian)\\n else:\\n path = [index]\\n print(path)\\n\\n\\n\\n\\n\\n\\n\\n # print(path)\\n final_path = []\\n for node in path:\\n if node == index:\\n final_path.append(node)\\n # print(\\\"Index: \\\", node)\\n elif node in home_indexes and node not in walking_to:\\n final_path.append(node)\\n # print(\\\"Home but not walking: \\\", node)\\n elif node in dropoff_locations:\\n final_path.append(node)\\n # print(\\\"Dropoff loc: \\\", node)\\n final_path.append(index)\\n #print(walking_from)\\n # print(final_path)\\n # nx.draw(mst)\\n # plt.draw()\\n # plt.show()\\n for node in final_path:\\n if node in walking_from and node in home_indexes:\\n dict[node] = [node] + walking_from[node]\\n elif node in home_indexes:\\n dict[node] = [node]\\n elif node in walking_from:\\n dict[node] = walking_from[node]\\n\\n very_final_path = []\\n for i in range(len(final_path) - 1):\\n condensed_path = nx.dijkstra_path(G2, final_path[i], final_path[i+1])\\n for j in range(len(condensed_path) - 1):\\n if condensed_path[j] != condensed_path[j + 1]:\\n very_final_path.append(condensed_path[j])\\n\\n if len(very_final_path) >= 1 and [len(very_final_path) - 1] != index:\\n very_final_path.append(index)\\n\\n if len(very_final_path) == 0:\\n very_final_path = [index]\\n\\n print(very_final_path)\\n print(dict)\\n\\n\\n path2 = list(nx.dfs_preorder_nodes(mst, index))\\n\\n final_path2 = []\\n for node in path2:\\n if node == index:\\n final_path2.append(node)\\n # print(\\\"Index: \\\", node)\\n elif node in home_indexes and node not in walking_to:\\n final_path2.append(node)\\n # print(\\\"Home but not walking: \\\", node)\\n elif node in dropoff_locations:\\n final_path2.append(node)\\n # print(\\\"Dropoff loc: \\\", node)\\n final_path2.append(index)\\n\\n\\n for node in final_path2:\\n if node in walking_from and node in home_indexes:\\n dict[node] = [node] + walking_from[node]\\n elif node in home_indexes:\\n dict[node] = [node]\\n elif node in walking_from:\\n dict[node] = walking_from[node]\\n\\n very_final_path2 = []\\n for i in range(len(final_path2) - 1):\\n condensed_path = nx.dijkstra_path(G2, final_path2[i], final_path2[i+1])\\n for j in range(len(condensed_path) - 1):\\n if condensed_path[j] != condensed_path[j + 1]:\\n very_final_path2.append(condensed_path[j])\\n\\n if len(very_final_path2) >= 1 and [len(very_final_path2) - 1] != index:\\n very_final_path2.append(index)\\n\\n if len(very_final_path2) == 0:\\n very_final_path2 = [index]\\n\\n opt1 = cost_of_solution(G, very_final_path, dict)\\n opt2 = cost_of_solution(G, very_final_path2, dict)\\n\\n ultra_final_path = []\\n if (opt1 <= opt2):\\n ultra_final_path = very_final_path\\n else:\\n ultra_final_path = very_final_path2\\n\\n return ultra_final_path, dict\\n\\n pass\",\n \"def refugia_adj_5_full_2_iter4 (params, ns):\\n #33 parameters \\n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\\n nu_T0 = [nu1x, nuA]\\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\\n fs.integrate(nu_T0, T0, m=mig0)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def _build_adjacency_matrix_1(self):\\n\\n from scipy import sparse as sparse\\n \\n down_neighbour = np.empty(self.tri.npoints)\\n\\n for node in range (0,self.tri.npoints):\\n down_neighbour[node] = self.neighbour_array_lo_hi[node][0]\\n\\n # Build a matrix of downhill-ness - one entry per node ! \\n \\n size = self.tri.npoints\\n row_array = np.empty(size)\\n col_array = np.empty(size)\\n down_array = np.ones(size)\\n\\n # Catch cases where node is local low point (i.e. it is its own low neighbour)\\n\\n for row in range(0, self.tri.npoints): \\n row_array[row] = row\\n col_array[row] = down_neighbour[row]\\n if row == down_neighbour[row]:\\n down_array[row] = 0.0\\n \\n\\n downMCOO = sparse.coo_matrix( (down_array, (row_array, col_array)), shape=(size,size) ).T \\n\\n self.adjacency1 = downMCOO.tocsr() \\n\\n # Catch pathological cases - sometimes if there is a flat spot on the boundary, then \\n # the filling method above will produce a non-square matrix. This is caused by\\n # repetition of values in the COO list which are summed on conversion.\\n\\n if downMCOO.shape[0] != downMCOO.shape[1]:\\n # This approach works but is a lot slower\\n\\n print \\\"\\\"\\\"\\n Warning: the downhill matrices require a slow build method. This is probably\\n Because there are degeneracies in the slope - particularly at the boundaries\\n A small random perturbation is usually enough to fix this problem\\n \\\"\\\"\\\"\\n downMat = sparse.lil_matrix((size, size))\\n\\n for row in range(0, self.tri.npoints): \\n downMat[down_neighbour[row],row] = 1.0\\n\\n for row in range(0, self.tri.npoints): \\n if down_neighbour[row] == row:\\n downMat[row,row] = 0.0\\n \\n self.adjacency1 = downMat.T.tocsr() \\n \\n return\",\n \"def assign_vertices(self):\\n CV_matrix = np.zeros((self.n_c, self.n_v, 3))\\n for i in range(3):\\n CV_matrix[self.tris[:, i], np.arange(self.n_v), i] = 1\\n self.CV_matrix = CV_matrix\\n return self.CV_matrix\",\n \"def get_score_matrix(self) -> int:\",\n \"def _init_vertex_adjacency_matrix(self, verbose=False):\\n self._init_from_cdd_input(self.cdd_Vrepresentation(),\\n '--adjacency', verbose)\",\n \"def __init__(self, adj_mat, directed = True):\\n\\n\\t\\tedges = 0\\n\\t\\tadj_list = {i: [] for i in range(len(adj_mat))}\\n\\t\\tfor i in range(len(adj_mat)):\\n\\t\\t\\tfor j in range(len(adj_mat)):\\n\\t\\t\\t\\tif not adj_mat[i][j] == 0:\\n\\t\\t\\t\\t\\tadj_list[i].append(j)\\n\\t\\t\\t\\t\\tedges += 1\\n\\n\\t\\tself.adj_mat = copy.deepcopy(adj_mat)\\n\\t\\tself.nodes = len(adj_mat)\\n\\t\\tself.edges = edges\\n\\t\\tself.is_directed = directed\\n\\t\\tself.adj_list = adj_list\\n\\t\\tself.active_nodes = [False for i in range(len(adj_mat))]\\n\\t\\tself.theta = [nprnd.random() for i in range(len(adj_mat))]\\n\\t\\tself.shapley_rank = dict()\",\n \"def gen_graph(self):\",\n \"def combinations(graph, all_combs, all_costs, all_values, start, prev_cost, prev_value, prev_nodes):\\n for ii in range(start, graph.size):\\n # combination\\n nodes = prev_nodes + [ii]\\n all_combs.append(nodes)\\n # cost\\n cost = prev_cost + graph.node_weights[ii][0]\\n all_costs.append(cost)\\n # value\\n value = prev_value + graph.node_weights[ii][1] - graph.node_weights[ii][0]\\n for node in prev_nodes: # complementarity\\n for adjacent in graph.graph[node]:\\n if adjacent[0] == ii:\\n value += adjacent[1]\\n all_values.append(value)\\n # recurse\\n combinations(graph, all_combs, all_costs, all_values, ii+1, cost, value, nodes)\",\n \"def __init_matrix(self, adjacencyMatrix, **optional):\\n\\t\\t# Error handling\\n if adjacencyMatrix.ndim!=2 or adjacencyMatrix.shape[0]!=adjacencyMatrix.shape[1]:\\n raise TypeError(\\\"\\\\'adjacencyMatrix\\\\' has to be a square matrix.\\\")\\n elif np.any(adjacencyMatrix<0):\\n raise ValueError(\\\"The weights have to be positive.\\\")\\n elif not (str(adjacencyMatrix.dtype).startswith(\\\"float\\\") or str(adjacencyMatrix.dtype).startswith(\\\"int\\\")):\\n raise TypeError(\\\"Weights have to be of the type \\\\'float*\\\\' or \\\\'int*\\\\'.\\\")\\n elif np.any(np.diagonal(adjacencyMatrix)):\\n raise ValueError(\\\"The graph is not allowed to contain circles of length 1.\\\")\\n\\t\\t# Save shape and type\\n self.__size = adjacencyMatrix.shape[0]\\n self.__type = adjacencyMatrix.dtype\\n if \\\"vertexNames\\\" in optional:\\n # List of names\\n self.__name_list = optional[\\\"vertexNames\\\"]\\n if len(self.__name_list)!=self.__size:\\n raise ValueError(\\\"There have not been specified as many names in \\\\'vertexNames\\\\' as there are nodes.\\\")\\n else:\\n if len(set(self.__name_list)) != len(self.__name_list):\\n raise ValueError(\\\"Vertex names are not unique.\\\")\\n else:\\n # Hashmap name->index\\n self.__names = {self.__name_list[i]:i for i in range(0,self.__size)}\\n else:\\n warn(Warning(\\\"If node names in adjacency matrix representation are not explicitly set with the parameter \\\\'vertexNames\\\\', partial and supergraphs cannot be recognized reliably.\\\"))\\n self.__name_list = [i for i in range(0,self.__size)]\\n self.__names = {self.__name_list[i]:i for i in range(0,self.__size)}\\n \\n # Adjacency matrix\\n self.__mat = adjacencyMatrix\\n # Adjacency matrix\\n self.__adj = [[(i,self.__mat[vertices][i]) for i in np.arange(self.__size) if self.__mat[vertices][i]>0] for vertices in np.arange(0,self.__size)]\\n \\n # List of known supergraphs\\n self.__supergraph = []\",\n \"def viterbi_path_log(prior, transmat, observ_likelihood):\\n T = observ_likelihood.shape[-1]\\n N = observ_likelihood.shape[0]\\n\\n path = numpy.zeros(T, dtype=numpy.int32)\\n global_score = numpy.zeros(shape=(N,T))\\n predecessor_state_index = numpy.zeros(shape=(N,T), dtype=numpy.int32)\\n\\n t = 1\\n global_score[:, 0] = prior + observ_likelihood[:, 0]\\n # need to normalize the data\\n \\n for t in range(1, T):\\n for j in range(N):\\n temp = global_score[:, t-1] + transmat[:, j] + observ_likelihood[j, t]\\n global_score[j, t] = max(temp)\\n predecessor_state_index[j, t] = temp.argmax()\\n\\n path[T-1] = global_score[:, T-1].argmax()\\n \\n for t in range(T-2, -1, -1):\\n path[t] = predecessor_state_index[ path[t+1], t+1]\\n\\n return [path, predecessor_state_index, global_score]\",\n \"def refugia_adj_5_full_2_iter1 (params, ns):\\n #33 parameters \\n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\\n nu_T0 = [nu1x, nuA]\\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\\n fs.integrate(nu_T0, T0, m=mig0)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def update_pheromones(attr_keys, pattern, p_matrix):\\n idx = [attr_keys.index(x.as_string()) for x in pattern.gradual_items]\\n for n in range(len(idx)):\\n for m in range(n + 1, len(idx)):\\n i = idx[n]\\n j = idx[m]\\n p_matrix[i][j] += 1\\n p_matrix[j][i] += 1\\n return p_matrix\",\n \"def _create_adjacency_matrix(layer_edges):\\n A = defaultdict(int)\\n for l, edges in list(layer_edges.items()):\\n for edge in edges:\\n A[(edge[0], edge[1], l)] += 1\\n A[(edge[1], edge[0], l)] += 1 \\n return A\",\n \"def get_stain_matrix(I):\",\n \"def objective(V,m,adj):\\r\\n #number of edges in G = (V,E)\\r\\n link = 0\\r\\n for i in range(m):\\r\\n for j in range(i,m):\\r\\n if i != j and (V[i],V[j]) in adj or (V[j],V[i]) in adj:\\r\\n link += 1\\r\\n #number of expected edges to have a module\\r\\n edges = factorial(m)/(factorial(m-2)*2)\\r\\n obj = edges - link\\r\\n\\r\\n return obj\",\n \"def process_input(input_path):\\n\\n # Parse lines from input file into list\\n with open(input_path, 'r') as input_file:\\n lines = input_file.readlines()\\n\\n # Declare component lists and helper variables\\n vertex_map = {} # Mapping of named vertices to indices, handles duplicate connections\\n idx = 0\\n edges = [] # List of (src, dst) tuples\\n weights = [] # Weight of each edge\\n\\n for line in lines:\\n # Parse each line of csv or text file\\n if input_path.endswith('.csv'):\\n parts = line.split(',')\\n else:\\n parts = line.split()\\n\\n # Add source vertex to list of vertices\\n src = parts[0]\\n if src not in vertex_map:\\n vertex_map[src] = idx\\n idx += 1\\n\\n # Add destination vertex to list of vertices\\n dst = parts[1]\\n if dst not in vertex_map:\\n vertex_map[dst] = idx\\n idx += 1\\n\\n # Add integer representation of edges to list of connections\\n edges.append((vertex_map[src], vertex_map[dst]))\\n weights.append(parts[2])\\n\\n # Get definite list of vertices\\n vertices = vertex_map.keys()\\n\\n # Print graph information\\n vprint(str(len(vertices)) + ' vertices')\\n vprint(str(len(edges)) + ' edges')\\n\\n # Build IGraph representation of network\\n graph = ig.Graph(edges, directed=False)\\n graph.es['weight'] = [weights[e] for e in range(len(graph.es))]\\n\\n return graph, vertices\",\n \"def add_vertices(self, vertices: Iterable[\\\"Vertex\\\"]) -> Sequence[int]:\\n indices = []\\n for vertex in vertices:\\n key = self.key(vertex)\\n try:\\n indices.append(self.ledger[key])\\n except KeyError:\\n index = len(self.vertices)\\n self.vertices.append(vertex)\\n self.ledger[key] = index\\n indices.append(index)\\n return tuple(indices)\",\n \"def create_propagator_matrix(graph):\\n A = create_adjacency_matrix(graph)\\n I = sparse.eye(A.shape[0])\\n A_tilde_hat = normalize_adjacency_matrix(A, I)\\n propagator = dict()\\n A_tilde_hat = sparse.coo_matrix(A_tilde_hat)\\n propagator[\\\"indices\\\"] = torch.LongTensor(np.concatenate([A_tilde_hat.row.reshape(-1,1), A_tilde_hat.col.reshape(-1,1)],axis=1).T)\\n propagator[\\\"values\\\"] = torch.FloatTensor(A_tilde_hat.data)\\n return propagator\",\n \"def computeTransitionMatrix(self, mu = False):\\n\\n available_strategies = self.getAvailableStrategies()\\n t_matrix = np.matrix([[0. for strategy in available_strategies] for strategy in available_strategies])\\n\\n for i, resident in enumerate(available_strategies):\\n for j, invader in enumerate(available_strategies):\\n if (i != j):\\n fixation_proba = self.rho(resident, invader)\\n if(mu):\\n fixation_proba *= self.getExplorationRate()\\n t_matrix[i, j] = 1./(len(available_strategies) - 1) * fixation_proba\\n\\n # calculate diagonal elements\\n for i in range(len(available_strategies)):\\n t_matrix[i, i] = 1 - t_matrix[i].sum(axis = 1)\\n\\n return t_matrix\",\n \"def __init__(self, matrix):\\n if not matrix:\\n self.dp = None\\n return\\n \\n m = len(matrix)\\n n = len(matrix[0])\\n \\n dp = self.dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]\\n \\n for x in range(1, m + 1): # 0 的都是零就不用单独处理了。\\n for y in range(1, n + 1):\\n dp[x][y] = dp[x-1][y] + dp[x][y-1] - dp[x-1][y-1] + matrix[x-1][y-1]\",\n \"def find_min_hamiltonian_path(G,weights,probs_instead_of_weights=False):\\n\\n # Create a new model\\n m = Model(\\\"hamiltonian_cycle\\\")\\n \\n # Create variables\\n x_vars = {}\\n u_vars = {}\\n for var1 in permute(G.vertices()):\\n for var2 in permute(G.vertices()):\\n if var1 != var2:\\n x_vars[(var1,var2)] = m.addVar(vtype='B', name=\\\"x_\\\"+str(var1)+'_'+str(var2))\\n u_vars[var1] = m.addVar(vtype=GRB.INTEGER, name=\\\"u_\\\"+str(var1))\\n m.update()\\n \\n for var in G.vertices():\\n if var != START_NODE:\\n cur_incoming = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[1] == var)])\\n #print(cur_incoming)\\n m.addConstr(cur_incoming,GRB.EQUAL,1.0)\\n \\n if var != END_NODE:\\n cur_outgoing = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[0] == var)])\\n #print(cur_outgoing)\\n m.addConstr(cur_outgoing,GRB.EQUAL,1.0)\\n \\n for var1 in G.vertices():\\n for var2 in G.vertices():\\n if var1 != var2:\\n c = LinExpr([(1.0,u_vars[var1]),(-1.0,u_vars[var2]),(G.num_vertices(),x_vars[(var1,var2)])])\\n #print(c)\\n m.addConstr(c,GRB.LESS_EQUAL,G.num_vertices()-1)\\n \\n # Set objective\\n #try:\\n edge_weights = permute(G.get_edge_weights(weights))\\n if probs_instead_of_weights:\\n all_probs = []\\n for v in G.vertices():\\n if v != END_NODE:\\n batch_scores = [(e,w) for e,w in edge_weights if e[0] == v]\\n S = logsumexp([x[1] for x in batch_scores])\\n batch_scores = [(e,np.exp(w-S)) for e,w in batch_scores]\\n all_probs.extend(batch_scores)\\n edge_weights = all_probs\\n objective = LinExpr([(weight,x_vars[edge]) for edge,weight in edge_weights])\\n #except TypeError:\\n # return None\\n \\n m.setObjective(objective,GRB.MINIMIZE)\\n m.update()\\n code = m.optimize()\\n \\n try:\\n return [k for k,v in x_vars.items() if v.x > 0.98]\\n except GurobiError:\\n return None\",\n \"def adjacency(self):\\n if self.E > 0:\\n i = self.edges[:, 0]\\n j = self.edges[:, 1]\\n adj = coo_matrix((np.ones(self.E), (i, j)),\\n shape=(self.V, self.V))\\n else:\\n adj = coo_matrix((self.V, self.V))\\n return adj\",\n \"def generate_nodes(self):\\n \\n # For all state nodes\\n node = 0\\n \\n for i in range(self.x0_n):\\n for j in range(self.x1_n):\\n \\n # State\\n x = np.array([ self.xd[0][i] , self.xd[1][j] ])\\n \\n # State and grid index based on node #\\n self.nodes_state[node,:] = x\\n self.nodes_index[node,:] = np.array([i,j])\\n \\n # Node # based on index ij\\n self.x_grid2node[i,j] = node\\n\\n # Increment node number\\n node = node + 1\",\n \"def eqcounter(nodes):\\r\\n nnodes = nodes.shape[0]\\r\\n IBC = np.zeros([nnodes, 3], dtype=np.integer)\\r\\n for i in range(nnodes):\\r\\n for k in range(3):\\r\\n IBC[i, k] = int(nodes[i, k+3])\\r\\n neq = 0\\r\\n for i in range(nnodes):\\r\\n for j in range(3):\\r\\n if IBC[i, j] == 0:\\r\\n IBC[i, j] = neq\\r\\n neq = neq + 1\\r\\n return neq, IBC\",\n \"def refugia_adj_5_full_2_iter3 (params, ns):\\n #33 parameters \\n nu1x, nuA, nu1a, nu2a, nu3a, nu1b, nu2b, nu3b, nu1c, nu2c, nu3c, nu1d, nu2d, nu3d, m0_12, m0_21, m1_12, m1_13, m1_21, m1_23, m1_31, m1_32, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T0, T1, T2, T3, T4 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T0 (initial split; the definition of this time epoch differentiates this model from refugia_adj_5_simsplit_4epochs)\\n nu_T0 = [nu1x, nuA]\\n mig0 = numpy.array([[0, m0_12],[m0_21, 0]])\\n fs.integrate(nu_T0, T0, m=mig0)\\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T1 (to reflect sum effect of all previous glacial-interglacial cycles)\\n nu_T1 = [nu1a, nu2a, nu3a]\\n mig1 = numpy.array([[0, m1_12, m1_13],[m1_21, 0, m1_23], [m1_31, m1_32, 0]]) \\n fs.integrate(nu_T1, T1, m=mig1)\\n ## Population function and migration matrix for T2 (to reflect period of isolation during last glacial)\\n nu_T2 = [nu1b, nu2b, nu3b]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3 (to reflect inter-glacial expansion)\\n nu_T3 = [nu1c, nu2c, nu3c]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3)\\n ## Population function and migration matrix for T3 (bottleneck to capture single population representation of lineage)\\n nu_T4 = [nu1d, nu2d, nu3d]\\n fs.integrate(nu_T4, T4) \\n return fs\",\n \"def get_sparse_adj(ent_num, triples):\\n adj, degree = get_mat(ent_num, triples)\\n\\n indices = []\\n values = []\\n\\n for fir, sec in adj:\\n indices.append((sec, fir))\\n values.append(adj[(fir, sec)] / math.sqrt(degree[fir]) / math.sqrt(degree[sec]))\\n\\n indices = torch.tensor(indices).t()\\n\\n adj = torch.sparse_coo_tensor(indices=indices, values=values, size=[ent_num, ent_num])\\n\\n return adj, degree\",\n \"def Init_Adaptive_Grid(self,):\\n self.Indicator[0] = 0\\n self.Old[0] = 0\\n \\n for i in range(self.num_dim):\\n self.Active[i] = i+1\\n self.Indicator[i+1] = 1\\n self.N_Forward[i,0] = i+2\\n self.N_Backward[i,i+1] = 1\\n self.Idx[i,i+1] = 1\",\n \"def laplace_matrix(self):\\n n = self.number_of_vertices\\n laplace_matrix = np.zeros((n, n))\\n for i in range(n):\\n laplace_matrix[i][i] = 1\\n vertice = self.list_of_vertices[i]\\n for edge in vertice.edges_list:\\n laplace_matrix[i][edge.linked[1].index] = 1\\n return laplace_matrix\",\n \"def generate_nodes(self):\\n \\n # For all state nodes\\n node = 0\\n \\n for i in range(self.x0_n):\\n for j in range(self.x1_n):\\n for k in range(self.x2_n):\\n \\n # State\\n x = np.array([ self.xd[0][i] , self.xd[1][j] , self.xd[2][k] ])\\n \\n # State and grid index based on node #\\n self.nodes_state[node,:] = x\\n self.nodes_index[node,:] = np.array([i,j,k])\\n \\n # Node # based on index ijk\\n self.x_grid2node[i,j,k] = node\\n \\n # Increment node number\\n node = node + 1\",\n \"def calculate(self) :\\n #self.graph\\n self.val_i = 0\\n while (len(self.undefined_vertices) > 0) :\\n cond = True\\n while cond:\\n cond = False\\n for node in self.undefined_vertices:\\n if self.condition_satisfied(node, self.val_i) :\\n cond = True\\n self.undefined_vertices.remove(node)\\n self.val_l[node] = self.val_i\\n self.val_c[node] = self.val_m\\n self.val_m += 1\\n for node in self.undefined_vertices:\\n if self.val_i not in [self.val_l[n] for n in\\n self.graph.next_nodes(node)]:\\n self.undefined_vertices.remove(node)\\n self.val_l[node] = self.infinity\\n self.val_c[node] = 0\\n self.val_i += 1\\n self.graph.save_graph(\\\"check\\\")\\n self.save(\\\"this.value\\\")\\n return self.graph.to_dictionary(), self.val_l, self.val_c\",\n \"def count_automorphisms(g: Graph) -> int:\\n\\n def generate_mapping(g: Graph, h: Graph):\\n \\\"\\\"\\\"\\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\\n We map g to h.\\n :param g: A graph\\n :param h: A graph\\n :return: A permutation with the mapping from g to h\\n \\\"\\\"\\\"\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\\n\\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\\n \\\"\\\"\\\"\\n Is called recursively to traverse through the branching tree and to find all automorphisms.\\n :param g: A copy of the original graph\\n :param h: Another copy of the original graph\\n :param d: A list with pre-colored vertices for graph g\\n :param i: A list with pre-colored vertices for graph h\\n \\\"\\\"\\\"\\n\\n # Refine the graphs g and h.\\n color_refinement([g, h])\\n\\n # Make sure that the colors are balanced, and check for a bijection.\\n if not is_balanced(g, h):\\n return\\n if is_bijection(g, h):\\n\\n # Generate the mapping from g -> h.\\n p = generate_mapping(g, h)\\n\\n # If the permutation cannot be generated by this generating set, we need to add it.\\n if not is_member(generating_set, p):\\n generating_set.append(p)\\n\\n # We can now back to the last trivial ancestor nodes in the branching tree.\\n while [v.label for v in d] != [v.label for v in i]:\\n # We remove the vertices from d and i and mark them as 'used'.\\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\\n d.pop().pre_labeled = True\\n i.pop().pre_labeled = True\\n\\n return\\n\\n c, next_color = get_c([g, h])\\n for v_g in g:\\n if v_g.colornum == c:# and not v_g.pre_labeled:\\n x = v_g\\n break\\n\\n for v_h in h:\\n if v_h.colornum == c and not v_h.pre_labeled:\\n g1 = g + Graph(False)\\n h1 = h + Graph(False)\\n g1.vertices[g.vertices.index(x)].colornum = next_color\\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\\n d.append(x)\\n i.append(v_h)\\n generate_automorphisms(g1, h1, d, i)\\n\\n generating_set = []\\n graph_copy_1 = g + Graph(False)\\n graph_copy_2 = g + Graph(False)\\n for v in graph_copy_1.vertices:\\n v.pre_labeled = False\\n for v in graph_copy_2.vertices:\\n v.pre_labeled = False\\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\\n return compute_order(generating_set)\",\n \"def plan(self):\\n return [(0, 0), (1, 0), (1, 1), (1, 2), (1, 3)]\",\n \"def _generate_weighted_adj_matrices(self):\\n self.weighted_adj_matrices = dict()\\n mes = []\\n args = []\\n for metaedge in self.metaedges:\\n mes.append(metaedge)\\n args.append(self._prepare_parallel_weighted_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.weighted_adj_matrices[metaedge] = matrix\",\n \"def refugia_adj_5_full(params, ns):\\n #22 parameters \\n nu1_1a, nu1_1b, nu1_2, nu1_3, nuA_a, nuA_b, nu2_2, nu2_3, nu3_2, nu3_3, m1_12, m1_21, m3_12, m3_13, m3_21, m3_23, m3_31, m3_32, T1a, T1b, T2, T3 = params\\n sts = moments.LinearSystem_1D.steady_state_1D(ns[0] + ns[1] + ns[2])\\n fs = moments.Spectrum(sts)\\n fs = moments.Manips.split_1D_to_2D(fs, ns[0], ns[1] + ns[2])\\n ## Population function and migration matrix for T1a\\n nu_T1a = [nu1_1a, nuA_a]\\n fs.integrate(nu_T1a, T1a)\\n ## Population function and migration matrix for T1b\\n nu_T1b = [nu1_1b, nuA_b] \\n mig1 = numpy.array([[0, m1_12],[m1_21, 0]])\\n fs.integrate(nu_T1b, T1b, m=mig1) \\n fs = moments.Manips.split_2D_to_3D_2(fs, ns[1], ns[2])\\n ## Population function and migration matrix for T2\\n nu_T2 = [nu1_2, nu2_2, nu3_2]\\n fs.integrate(nu_T2, T2)\\n ## Population function and migration matrix for T3\\n nu_T3 = [nu1_3, nu2_3, nu3_3]\\n mig3 = numpy.array([[0, m3_12, m3_13],[m3_21, 0, m3_23], [m3_31, m3_32, 0]]) \\n fs.integrate(nu_T3, T3, m=mig3) \\n return fs\",\n \"def __init__(self, matrix):\\n m, n = len(matrix), len(matrix[0]) if len(matrix) > 0 else 0\\n self.total = [[0 for x in xrange(n + 1)] for x in xrange(m + 1)]\\n for i in xrange(1, m+1):\\n for j in xrange(1, n+1):\\n self.total[i][j] = matrix[i-1][j-1] + self.total[i-1][j] + self.total[i][j-1] - self.total[i-1][j-1]\",\n \"def vert_degree(input_vertices):\\n\\tvertex_map = {}\\n\\tfor element in input_vertices:\\n\\t\\tvertex_map[element] = 0\\n\\t\\tfor x in prob:\\n\\t\\t\\tfor vertex in x:\\n\\t\\t\\t\\tif element == vertex:\\n\\t\\t\\t\\t\\tvertex_map[element] += 1\\n\\treturn vertex_map\",\n \"def compute_adjacency_matrix(G):\\n\\n iG = nx.convert_node_labels_to_integers(G)\\n adj_list = iG.adjacency_list()\\n n_nodes = len(iG.nodes())\\n\\n adj_mat = np.zeros((n_nodes, n_nodes))\\n for x in xrange(n_nodes):\\n adj_mat[x, adj_list[x]] = 1\\n\\n return adj_mat\",\n \"def gale_transform(self):\\n if not self.is_compact(): raise ValueError('Not a polytope.')\\n\\n A = matrix(self.n_vertices(), \\n [ [1]+list(x) for x in self.vertex_generator()])\\n A = A.transpose()\\n A_ker = A.right_kernel()\\n return A_ker.basis_matrix().transpose().rows()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.58972126","0.5740013","0.5628643","0.5628604","0.56055963","0.56013095","0.55628353","0.55471677","0.5523483","0.5455894","0.5450417","0.5443276","0.54323477","0.5426158","0.54141635","0.54007095","0.53644186","0.53399026","0.5322008","0.5318355","0.53004825","0.5282856","0.52815497","0.5272694","0.52606136","0.5255693","0.52550817","0.52347136","0.5232225","0.523083","0.52241","0.5222609","0.5203043","0.5189913","0.5189205","0.517547","0.51721877","0.5157066","0.5151208","0.5142951","0.5138999","0.5131931","0.5128789","0.5125985","0.5125475","0.51177824","0.5113534","0.5103536","0.5101774","0.5097053","0.5095476","0.50916183","0.5084298","0.50779027","0.50755686","0.50724614","0.506706","0.5065495","0.5064535","0.5060644","0.5060444","0.5054721","0.50528073","0.5052076","0.5046421","0.50464195","0.5042103","0.5041068","0.5040596","0.5037987","0.50374895","0.50363433","0.50306016","0.5030527","0.5024674","0.50216293","0.5012664","0.5006287","0.50035566","0.5002815","0.50001675","0.49971864","0.49951363","0.4990753","0.49890143","0.49881074","0.4986444","0.4985086","0.4980698","0.4979008","0.4974437","0.49692807","0.49689344","0.49676648","0.4959594","0.4952926","0.49509555","0.49497852","0.4943007","0.4940227","0.4939961"],"string":"[\n \"0.58972126\",\n \"0.5740013\",\n \"0.5628643\",\n \"0.5628604\",\n \"0.56055963\",\n \"0.56013095\",\n \"0.55628353\",\n \"0.55471677\",\n \"0.5523483\",\n \"0.5455894\",\n \"0.5450417\",\n \"0.5443276\",\n \"0.54323477\",\n \"0.5426158\",\n \"0.54141635\",\n \"0.54007095\",\n \"0.53644186\",\n \"0.53399026\",\n \"0.5322008\",\n \"0.5318355\",\n \"0.53004825\",\n \"0.5282856\",\n \"0.52815497\",\n \"0.5272694\",\n \"0.52606136\",\n \"0.5255693\",\n \"0.52550817\",\n \"0.52347136\",\n \"0.5232225\",\n \"0.523083\",\n \"0.52241\",\n \"0.5222609\",\n \"0.5203043\",\n \"0.5189913\",\n \"0.5189205\",\n \"0.517547\",\n \"0.51721877\",\n \"0.5157066\",\n \"0.5151208\",\n \"0.5142951\",\n \"0.5138999\",\n \"0.5131931\",\n \"0.5128789\",\n \"0.5125985\",\n \"0.5125475\",\n \"0.51177824\",\n \"0.5113534\",\n \"0.5103536\",\n \"0.5101774\",\n \"0.5097053\",\n \"0.5095476\",\n \"0.50916183\",\n \"0.5084298\",\n \"0.50779027\",\n \"0.50755686\",\n \"0.50724614\",\n \"0.506706\",\n \"0.5065495\",\n \"0.5064535\",\n \"0.5060644\",\n \"0.5060444\",\n \"0.5054721\",\n \"0.50528073\",\n \"0.5052076\",\n \"0.5046421\",\n \"0.50464195\",\n \"0.5042103\",\n \"0.5041068\",\n \"0.5040596\",\n \"0.5037987\",\n \"0.50374895\",\n \"0.50363433\",\n \"0.50306016\",\n \"0.5030527\",\n \"0.5024674\",\n \"0.50216293\",\n \"0.5012664\",\n \"0.5006287\",\n \"0.50035566\",\n \"0.5002815\",\n \"0.50001675\",\n \"0.49971864\",\n \"0.49951363\",\n \"0.4990753\",\n \"0.49890143\",\n \"0.49881074\",\n \"0.4986444\",\n \"0.4985086\",\n \"0.4980698\",\n \"0.4979008\",\n \"0.4974437\",\n \"0.49692807\",\n \"0.49689344\",\n \"0.49676648\",\n \"0.4959594\",\n \"0.4952926\",\n \"0.49509555\",\n \"0.49497852\",\n \"0.4943007\",\n \"0.4940227\",\n \"0.4939961\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":23594,"cells":{"query":{"kind":"string","value":"Takes a time interval, number of steps, adjacency matrix, payment matrix (or matrices), relationship matrix and initial state of all vertices to return the result of the hyperrational evolutionary game played on the given graph in that time interval"},"document":{"kind":"string","value":"def hr_game(t0, tf, n, A, B, R, x0):\n # t0 - Initial time\n # tf - Final time\n # n - Number of steps\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Step in each iteration\n h = (tf - t0) / n\n # Result of each step, np.ndarray (N, S, n+1)\n y = np.zeros([N, S, n+1], dtype='double')\n y[:, :, 0] = x0\n k = np.zeros([N, S])\n # I still don't know why, but theres a problem with negative payoffs\n B = matrixTranslate(B)\n\n # Fourth order Runge-Kutta\n for t in range(n):\n k1 = np.multiply(h, hr_egn(A, B, R, y[:, :, t]))\n k2 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k1, 2))))\n k3 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], np.divide(k2, 2))))\n k4 = np.multiply(h, hr_egn(A, B, R, np.add(y[:, :, t], k3)))\n # k = (k1 + 2*k2 + 2*k3 + k4)/6\n k = np.divide(np.add(np.add(k1, np.multiply(2, k2)), np.add(np.multiply(2, k3), k4)), 6)\n\n y[:, :, t+1] = np.add(y[:, :, t], k)\n\n # Filter results with machine epsilon\n for v in range(N):\n for s in range(S):\n if y[v, s, t+1] < np.sqrt(np.finfo('double').eps):\n y[v, s, t+1] = 0\n elif y[v, s, t+1] > np.subtract(1, np.sqrt(np.finfo('double').eps)):\n y[v, s, t + 1] = 1\n\n return y"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def params(timeseries_input):\n # Settings for Nelder Mead Algorithm\n global timeseries\n timeseries=timeseries_input\n\n NumIters = 1 # First Iteration\n MaxIters = 1e3 # Maximum number of iterations\n Tolerance = 1e-5 # Tolerance on best and worst function values\n N = 5 # Number of Heston and Nandi parameters\n r = 0.01 / 252.0 # Risk Free Rate\n\n # Heston and Nandi parameter starting values (vertices) in vector form\n\n x = [[0 for i in range(N + 1)] for j in range(N)]\n x[0][0] = 5.02e-6;\n x[0][1] = 5.12e-6;\n x[0][2] = 5.00e-6;\n x[0][3] = 4.90e-6;\n x[0][4] = 4.95e-6;\n x[0][5] = 4.99e-6 # omega\n x[1][0] = 1.32e-6;\n x[1][1] = 1.25e-6;\n x[1][2] = 1.35e-6;\n x[1][3] = 1.36e-6;\n x[1][4] = 1.30e-6;\n x[1][5] = 1.44e-6 # alpha\n x[2][0] = 0.79;\n x[2][1] = 0.80;\n x[2][2] = 0.78;\n x[2][3] = 0.77;\n x[2][4] = 0.81;\n x[2][5] = 0.82 # beta\n x[3][0] = 427.0;\n x[3][1] = 421.0;\n x[3][2] = 425.0;\n x[3][3] = 419.1;\n x[3][4] = 422.1;\n x[3][5] = 430.0 # gamma\n x[4][0] = 0.21;\n x[4][1] = 0.20;\n x[4][2] = 0.22;\n x[4][3] = 0.19;\n x[4][4] = 0.18;\n x[4][5] = 0.205 # lambda\n\n # Run Nelder Mead and output Nelder Mead results\n B = NelderMead(LogLike, N, NumIters, MaxIters, Tolerance, x, r)\n\n #\tprint(\"Nelder Mead Minimization of Log-Likelihood for Heston and Nandi parameters\")\n #\tprint(\"---------------------------------\")\n #\tprint(\"omega = \", B[0])\n #\tprint(\"alpha = \", B[1])\n #\tprint(\"beta = \", B[2])\n #\tprint(\"gamma = \", B[3])\n #\tprint(\"lambda = \", B[4])\n #\tprint(\"Value of Objective Function = \", B[N])\n #\tprint(\"Number of Iterations = \", B[N+1])\n #\tprint(\"Persistence \", B[2]+B[1]*(B[3]**2) )\n #\tprint(\"---------------------------------\")\n\n # alpha,beta,gamma,omega,lambda\n return [B[1], B[2], B[3], B[0], B[4]]","def rwgraph_analyze2(input=(None)):\r\n\r\n\r\n #set up graph and degree distribution arrays\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n Nt=100\r\n M=20000\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n\r\n #set inital conditions and D\r\n y0=np.zeros(n,dtype=int)\r\n y0[j]=200\r\n D=1\r\n #define time for odi Int\r\n t=np.arange(Nt+1,dtype=int)\r\n #set up operators\r\n A = nx.adjacency_matrix(G)\r\n Q = A.toarray().sum(axis=1)\r\n L=np.diag(Q)-A.toarray()\r\n Q_inv=1/Q\r\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\r\n Ls_tran=np.transpose(Ls)\r\n\r\n #convert to sparse operators and include diffusion\r\n L_spar = scipy.sparse.csr_matrix(-D*L)\r\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\r\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\r\n A=nx.adjacency_matrix(G)\r\n L=-D*(scipy.sparse.diags(degree_arr)-A)\r\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\r\n\r\n #define operators\r\n def Lap(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\r\n def Lap_Ls(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\r\n def Lap_Ls_tran(y,t):\r\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\r\n\r\n #solutions of different operators\r\n solL=scipy.integrate.odeint(Lap,y0,t)\r\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\r\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\r\n\r\n\r\n #finds eigen values and vectors and puts them into order\r\n def eigen(L):\r\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\r\n idx = eigen_values.argsort()[::-1]\r\n eigen_values = eigen_values[idx]\r\n eigen_vectors = eigen_vectors[:,idx]\r\n return eigen_values,eigen_vectors\r\n\r\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\r\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\r\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\r\n eigen_values_L,eigen_vectors_L=eigen(L)\r\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\r\n\r\n ### could have eigs here as didn't end up using all eigenvalues ####\r\n #eigen values graph\r\n n0=len(eigen_values_L)\r\n eig_nums=np.arange(n0)\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\"x\" ,label='L , D=0.36')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\"|\",label='LS , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\r\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\"+\" ,label='L , D=1')\r\n plt.legend(loc=\"lower left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.xlabel('eigen value number')\r\n plt.ylabel('eigenvalue')\r\n plt.title(\"Eigenvlaues of Laplacian Matrixs\")\r\n plt.show()\r\n\r\n print(\"4 biggest eigenvalues for each operater\")\r\n print('L=',eigen_values_L[0:4])\r\n print('Ls=',eigen_values_LS[0:4])\r\n print('Ls_tran=',eigen_values_LS_tran[0:4])\r\n #prints 4 biggest eigen values\r\n #counts node distrubtion by creating dictionary\r\n def result_count(sol,Nt,G):\r\n \"\"\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\"\"\"\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq\r\n\r\n #frequency count of solutions\r\n dict_freq=result_count(solL,Nt,G)\r\n dict_freq2=result_count(solLs,Nt,G)\r\n dict_freq3=result_count(solLs_tran,Nt,G)\r\n\r\n #random walk data\r\n X=rwgraph(G,j,20000,100)\r\n Listnodes7=[]\r\n for i in range(20000):\r\n Listnodes7.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,200,100)\r\n Listnodes8=[]\r\n for i in range(200):\r\n Listnodes8.append(G.degree(X[i,100]))\r\n X=rwgraph(G,j,50000,5000)\r\n Listnodes9=[]\r\n for i in range(50000):\r\n Listnodes9.append(G.degree(X[i,5000]))\r\n listfreq7=CountFrequency(Listnodes7)\r\n listfreq8=CountFrequency(Listnodes8)\r\n listfreq9=CountFrequency(Listnodes9)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n z2=[]\r\n z3=[]\r\n z1=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n z_deg1=[]\r\n for i in listfreq7:\r\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq8:\r\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n for i in listfreq8:\r\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\r\n z_deg1.append(i)\r\n #operator solutions compared to node degree frequency\r\n z4,z5,z6=[],[],[]\r\n z_deg4,z_deg5,z_deg6=[],[],[]\r\n for i in dict_freq:\r\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\r\n z_deg4.append(i)\r\n for i in dict_freq2:\r\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\r\n z_deg5.append(i)\r\n for i in dict_freq3:\r\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\r\n z_deg6.append(i)\r\n\r\n plt.figure(figsize=(15, 10))\r\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\r\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\r\n plt.scatter(z_deg4, z4,label='L, Nt=100')\r\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\r\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\r\n plt.ylim((-0.005,0.020))\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n\r\n #code to produce final graph\r\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\r\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\r\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\r\n tarray = np.linspace(0,5,Nt+1)\r\n plt.figure(figsize=(12, 6))\r\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\r\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\r\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\r\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\r\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\r\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\r\n plt.xlabel('time')\r\n plt.ylabel('representive frequency')\r\n plt.legend()\r\n plt.title(\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\")\r\n plt.show()\r\n return None #modify as needed\r","def hr_egn(A, B, R, x0):\n # A - Adjacency matrix, np.ndarray (N,N)\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\n # R - Relationship or preference matrix, np.ndarray (N,N)\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\n\n # Number of players\n N = A[:, 0].size\n # Number of strategies\n S = x0[0, :].size\n # Degree and degree of preferences\n d = np.zeros([N, 2])\n d[:, 0] = np.dot(A, np.ones(N))\n\n for v in range(N):\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\n\n # Player v neighborhood\n k = np.zeros([N, S], dtype='double')\n for v in range(N):\n for u in range(N):\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\n # Weights the neighborhood\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\n\n # This variable is the increments that x0 receives, the derivative\n x = np.zeros([N, S], dtype='double')\n # This is the unit vector with 1 in some entry\n es = np.zeros(S, dtype='int')\n\n # Phi and gamma\n p = 0\n g = 0\n\n # Auxiliary variables for better clarity\n aux1 = 0\n aux2 = 0\n\n # Here is the derivative calculation\n # We first test if all payoffs are the same so we do less comparisons\n if B.ndim == 2:\n for v in range(N):\n for s in range(S):\n # Set es value\n es[s] = 1\n for u in range(N):\n if v == u:\n # Same payoff personal equation\n # First we will do the dot products\n # e_s*B*k_v\n aux1 = np.dot(es, np.dot(B, k[v, :]))\n # x_v*B*k_v\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\n # Finally we subtract them to multiply by r_vv\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Same payoff social equation\n # x_u*B*e_s\n aux1 = np.dot(x0[u, :], np.dot(B, es))\n # x_u*B*x_v\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n else:\n for v in range(N):\n for s in range(S):\n # Same thing as before, but now with individual payoffs\n es[s] = 1\n for u in range(N):\n if v == u:\n # Individual payoffs personal equation\n # e_s*B_v*k_v\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\n # x_u*B_v*k_v\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\n elif A[v, u] != 0:\n # Individual payoffs social equation\n # x_u*B_u*e_s\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\n # x_u*B_u*x_v\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\n # Subtract then multiply\n aux1 = np.subtract(aux1, aux2)\n aux2 = np.multiply(R[v, u], A[v, u])\n g = np.add(g, np.multiply(aux2, aux1))\n # Weights the social part\n if d[v, 1] != 0:\n g = np.multiply(np.divide(1, d[v, 1]), g)\n # Estimates the derivative\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\n # Prepare variables to next iteration\n p = 0\n g = 0\n es[s] = 0\n return x","def energies():\n # Hardcoded initial values\n numsteps = 10000\n time_max = 1\n # Running the calculation in the solver class using the velocity verlet method\n # for better accuracy.\n verlet = solver(input_matrix, 'verlet', time_max, numsteps)\n output_matrix, KE, PE, AM = verlet.main()\n # Creating a simple time axis for plotting\n x = np.linspace(0, 1, numsteps+1)\n\n # Plotting kinetic energy over time\n plt.figure(1, figsize=(10, 10))\n plt.plot(x, KE)\n plt.suptitle('Total kinetic energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['KE'])\n\n # Plotting potential energy over time\n plt.figure(2, figsize=(10, 10))\n plt.plot(x, PE)\n plt.suptitle('Total potential energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['PE'])\n\n # Plotting total energy against time\n plt.figure(3, figsize=(10, 10))\n plt.plot(x, PE+KE)\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['KE+PE'])\n\n # Plotting angular momentum against time. print the amplitude to terminal\n amplitude = max(AM)-min(AM)\n print('Amplitude of angular momentum during 1 year: %g[AU²/yr²]' %(amplitude))\n plt.figure(4, figsize=(10, 10))\n plt.plot(x, AM)\n plt.suptitle('Total angular momentum in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²/yr²]', fontsize=16)\n plt.legend(['AM'])\n\n # Plotting the kinetic, potential and total energy against time to see\n # how great the variations are\n plt.figure(5, figsize=(10, 10))\n plt.plot(x, PE, x, KE, x, KE+PE)\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\n plt.xlabel('time [yr]', fontsize=16)\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\n plt.legend(['PE', 'KE', 'KE+PE'])\n plt.show()","def task2_extra():\n N = 0\n lam = 0\n Ls = numpy.array([2*L for L in range(1,23)])\n h = 0.01\n tau = 0.000099\n\n iterss = []\n\n for L in Ls:\n a = L // 2\n print(L)\n x = numpy.linspace(-L, L, int(2*L/h) + 1)\n # eps = int(0.1 * len(x))\n\n Vm = V1D(lam, x)\n state = phi(N, x-a)\n\n iters = 0\n while True:\n prob = numpy.abs(state)**2\n mid = int(2*L/h) // 2\n # if max(prob) in prob[mid-eps:mid+eps]:\n if numpy.argmax(prob) <= mid:\n print(iters)\n iterss.append(iters)\n break\n\n state[0] = 0\n state[-1] = 0\n state = implicit_scheme_step(state, tau, h, Vm)\n iters += 1\n\n fig = plt.figure()\n plt.title(\"Iterations of Gaussian travel to center\")\n plt.xlabel(\"$L$\")\n plt.ylabel(\"Time\")\n plt.plot(Ls, tau*numpy.array(iterss))\n plt.show()\n fig.savefig(\"naloga2_iters_of_gaussian_travel.pdf\", bbox_inches=\"tight\")","def solve(self, state, times):","def general_solver(heat_flux, temp_initial, temp_air, k, alpha, x_grid,t_grid, upsilon, \n bc_surface, sigma):\n\n # temperatures are reported as a data frame, where each column is a step in time\n temperatures = pd.DataFrame(columns = [n for n in t_grid])\n\n # extract the necessary parameters to determine the surface heat losses\n if bc_surface[0] == \"linear\":\n h = bc_surface[1] + bc_surface[2]\n hc = 0\n emissivity = 0\n elif bc_surface[0] == \"non-linear\":\n h = 0\n hc = bc_surface[1]\n emissivity = bc_surface[2]\n\n # initialize temperature arrays for present and future temperatures\n T = np.zeros_like(x_grid) + temp_initial\n Tn = np.zeros_like(x_grid)\n\n # iterate over each time step\n temperatures.iloc[:,0] = T\n for j, t in enumerate(t_grid[:-1]):\n \n # create tri-diagonal matrix A\n A = tridiag_matrix(bc_surface_type = bc_surface[0], upsilon = upsilon, \n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \n k = k, T = T, h = h, hc = hc, emissivity = emissivity, sigma = sigma)\n \n # create vector b\n b = vector_b(bc_surface_type = bc_surface[0], upsilon = upsilon, \n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \n k = k, T = T, T_air = temp_air, heat_flux = heat_flux, h = h, hc = hc, \n emissivity = emissivity, sigma = sigma, j = j)\n \n # calculate value of future temperature\n Tn = np.linalg.solve(A,b)\n \n # update present temperature\n T = Tn.copy()\n \n # store temperature profile at this time in the data frame\n temperatures.iloc[:, j+1] = Tn\n \n return temperatures","def task2_extra2():\n N = 0\n lam = 0\n L = 10\n h = 0.001\n tau = 0.000099\n aa = numpy.array([0.25*a for a in range((L-1)*4)])\n x = numpy.linspace(-L, L, int(2*L/h) + 1)\n Vm = V1D(lam, x)\n # eps=int(0.1*len(x))\n\n iterss = []\n for a in aa:\n print(a)\n state = phi(N, x-a)\n\n iters = 0\n while True:\n prob = numpy.abs(state)**2\n mid = int(2*L/h) // 2\n # if max(prob) in prob[mid-eps:mid+eps]:\n if numpy.argmax(prob) <= mid:\n print(iters)\n iterss.append(iters)\n break\n\n state[0] = 0\n state[-1] = 0\n state = implicit_scheme_step(state, tau, h, Vm)\n iters += 1\n\n fig = plt.figure()\n plt.title(\"Iterations of Gaussian travel to center ($L={}$)\".format(L))\n plt.xlabel(\"$a$\")\n plt.ylabel(\"Time\")\n plt.plot(aa, tau*numpy.array(iterss))\n plt.show()\n fig.savefig(\"naloga2_iters_of_gaussian_travel_fixedL={}.pdf\".format(L), bbox_inches=\"tight\")","def FigA7(case):\n \n #set the parameter, arrays\n \n n_array=np.array([1,2,3])\n\n #set the result arrays\n if case==0:\n class_number=5\n elif case==1:\n class_number=6\n fate=np.zeros([class_number])#number of evolutionary fate\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\n \n time=np.linspace(0,100000, 1000000)\n loop=10**6\n \"\"\"\n 0 Co and/or Ch cannot survive in mono-culture\n 1 Co cannot invade\n 2 Only equilibrium of exclusion is stable\n 3 Only equilibrium of coexistence is stable\n 4 Two equilibria are UNstable\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\n \"\"\"\n for tri in range(np.size(n_array)):\n counter=0\n n=n_array[tri]\n print(str(\"Hill coefficient is %d\" %(n)))\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\n if case==0 or case==1:\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\n else:\n print(\"Error in case\")\n return 1\n \n for i in range(loop):\n if(i+1)%10000==0:\n print(i+1)\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\n #check whether r is positive or not\n if case==0:\n r1=rmax*(1-cr-cd)#rCO\n r2=rmax#sCH\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\n elif case==1:\n r1=rmax*(1-cd)#sCo\n r2=rmax*(1-cr)#rCh\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\n stab_e=0#initialize the falgs of stability\n stab_c=0\n if W0Co<0 or W0Ch<0:\n fate[0]+=1\n res=0\n else:\n #succeed in mono-culture \n init=np.array([T0,10**(-6)])\n if case==0: \n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\n x2s=solCh[-1,1]\n else:\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\n Ts=solCo[-1,0]\n #x1s=solCo[-1,1]\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\n x2s=solCh[-1,1]\n \n #Evolutionary dynamics \n if case==0:\n K=Kr\n else:\n K=Ks\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\n #Co cannot invade\n fate[1]+=1\n res=1\n else:\n #Co can invade\n #calculate Tdagger Td and check whether coexist or exclude\n if case==0:\n #rCo vs sCh\n #in this case, at most one equilbrium is stable\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\n Td=tau**(1/n)\n if Td<Ts:\n #Co exclude Ch\n fate[2]+=1\n res=2\n else:\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #unstable coexistence nor exclusion\n fate[4]+=1\n res=4\n print(Td, x1d, x2d)\n else:\n #sCo vs rCh\n # in this case two equilibria can be stable at the same time\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\n if tau_m>Ts**n or tau_p<Ts**n:\n # cexclusion is stable\n stab_e=1\n # stability in coexistence \n if tau_p<0:\n stab_c=0\n else:\n Td=tau_p**(1/n)\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\n #check the stability condition\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\n if stab==0:\n #stable coexistence\n stab_c=1\n #classify\n if stab_e==1 and stab_c==1:\n # two stable equilbria\n fate[5]+=1\n res=5\n elif stab_e==1 and stab_c==0:\n #only stable cexclusion\n fate[2]+=1\n res=2\n elif stab_e==0 and stab_c==1:\n #stable coexistence\n fate[3]+=1\n res=3\n else:\n #both unstable\n fate[4]+=1\n res=4\n \n #save the results\n if counter==0:\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n #save the result with parameter values\n \n else:\n #add array of results\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\n result=np.concatenate((result, R), axis=0)\n counter+=1\n \n #save csv file and graph\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \n print(fate)\n fate_matrix[tri,:]=fate \n if case==0: \n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\n else:\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\n Plot(case)","def enthalpy(temp,pres):\n g = liq_g(0,0,temp,pres)\n g_t = liq_g(1,0,temp,pres)\n h = g - temp*g_t\n return h","def graphformation(time_lower, time_upper):\n\tprm = param.Para()\n\ttry:\n\t\tdb_connection = mysql.connector.connect(\n\t\t host=prm.hostname,\n\t\t user=prm.username,\n\t\t passwd=prm.password,\n\t\t database= prm.dbname\n\t\t )\n\t\tdb_cursor = db_connection.cursor()\n\texcept:\n\t\tprint(\"Can't Connect to database, check credentials in parameter file\")\n\tquery = (\"SELECT * FROM identity \")\n\tdb_cursor.execute(query)\n\tdf1=pd.DataFrame(db_cursor.fetchall())\n\tdf1.columns= ['node','deviceid','student','rollno']\n\tdict_identity = dict(zip(df1.deviceid, df1.node))\n\trev_dict_identity = dict(zip(df1.node, df1.deviceid ))\n\tquery = (\"SELECT * FROM activity WHERE time BETWEEN '{}' AND '{}'\".format(time_lower,time_upper)) ## incomplete\n\tdb_cursor.execute(query)\n\tactivity_data = pd.DataFrame(db_cursor.fetchall())\n\tif activity_data.empty==False:\n\t\tactivity_data.columns=[\"sl_no\",\"time\",\"node\",\"latitude\",\"longitude\"]\n\telse:\n\t\tprint(\"No Activity in the selected Time Window\")\n\t\treturn\n\tnumnodes= len(df1)\n\tedges= []\n\tscore = {}\n\t#print(activity_data)\n\ttime_groups = activity_data.groupby('time')\n\twith open(r'C:\\Users\\HP\\Desktop\\project\\Contact_Graph\\bluetooth.txt') as json_file:\n\t\tdata1 = json.load(json_file)\n\tfor name, group in time_groups:\n\t\tscore_tmp = decayfunc(name,time_upper)\n\t\tgroup = group.sort_values('node')\n\t\tfor i in range(len(group)-1):\n\t\t\tnode1 = group.iloc[i,2]\n\t\t\t###########################\n\t\t\tlistnearby=[]\n\t\t\ttry:\n\t\t\t\tlistnearby = data1[rev_dict_identity[node1]][str(name)]\n\t\t\t\tlistnearby = [dict_identity[i] for i in listnearby if dict_identity[i]>node1]\n\t\t\t\tfor i in listnearby:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tscore[(node1,i)]+=1\n\t\t\t\t\texcept:\n\t\t\t\t\t\tscore[(node1,i)]=1\n\t\t\texcept:\n\t\t\t\tpass\n\t\t\t###########################\n\t\t\tfor j in range(i+1,len(group)):\n\t\t\t\tnode2 =group.iloc[j,2]\n\t\t\t\tif proximityfunc(group.iloc[i,3],group.iloc[i,4],group.iloc[j,3],group.iloc[j,4]) and node2 not in listnearby:\n\t\t\t\t\ttry:\n\t\t\t\t\t\tscore[(group.iloc[i,2],group.iloc[j,2])]+=1\n\t\t\t\t\texcept:\n\t\t\t\t\t\tscore[(group.iloc[i,2],group.iloc[j,2])]=1\n\tnode_list = list(df1.node)\n\ttitle_list = list(df1.deviceid)\n\tedges_list = []\n\tfor edge,val in score.items():\n\t\tedges_list.append((int(edge[0]),int(edge[1]),float(val)))\n\n\treturn edges_list,node_list,title_list","def run(graph, time_axis, initial, element2edge, var, element_component_clause_literal_node, ts, type_num,\n type_robot_label, buchi, show, last_subtask=None, loop=False):\n\n frontier = [[initial, -1, []]]\n # iterate until the accepting state is reached\n while True:\n if show:\n print([f[0] for f in frontier])\n node, clock, acpt_run_ = frontier.pop()\n\n # Determine the set of identical time instants\n instant_element = time_axis[clock + 1]\n if acpt_run_:\n pre_neg_edge = acpt_run_[-1]['neg_edge']\n else:\n pre_neg_edge = []\n # loop over each successor to see whether progress can be made\n for succ in graph.succ[node]:\n # equivalent subtask\n if graph.edges[element2edge[instant_element[1]]]['formula'] == graph.edges[(node, succ)]['formula'] and \\\n graph.nodes[element2edge[instant_element[1]][0]]['formula'] == graph.nodes[node]['formula']:\n # if isEquivalent(graph.edges[element2edge[instant_element[1]]]['formula'], graph.edges[(node, succ)]['formula']) and \\\n # isEquivalent(graph.nodes[element2edge[instant_element[1]][0]]['formula'], graph.nodes[node]['formula']):\n\n # print((node, succ), graph.edges[(node, succ)]['formula'])\n # whether the collection of paths at clock satisfies the edge label\n # neg_literal: negative clause that needs to be addressed\n # exe_robot: set of robots that takes the subtask with nonzero id\n\n essential_clause_edge, neg_clause_edge, exe_robots_edge \\\n = determine_essentials(instant_element, var, graph.edges[(node, succ)]['label'],\n graph.edges[(node, succ)]['neg_label'], 1,\n element_component_clause_literal_node, ts, type_num,\n type_robot_label, last_subtask, buchi, [], loop)\n\n essential_clause_vertex, neg_clause_vertex, exe_robots_vertex \\\n = determine_essentials(instant_element, var, graph.nodes[node]['label'],\n graph.nodes[node]['neg_label'], 0,\n element_component_clause_literal_node, ts, type_num, dict(),\n last_subtask, buchi,\n pre_neg_edge, loop)\n\n # clock, the exact time when transition occurs\n acpt_run = acpt_run_.copy() # copy the history\n acpt_run.append({'subtask': (node, succ), 'time_element': time_axis[clock + 1],\n 'essential_robot_edge': exe_robots_edge,\n 'essential_clause_edge': essential_clause_edge, 'neg_edge': neg_clause_edge,\n 'essential_robot_vertex': exe_robots_vertex,\n 'neg_vertex': neg_clause_vertex})\n\n # stop when accept is reached\n if 'accept' in succ:\n return acpt_run\n # clock + 1, after reaching succ, the immediate time clock that should be verified\n frontier.append([succ, clock + 1, acpt_run])","def create_graph_hyp_space(t=0.8, b=0.01):\n\n # enumerate all graphs with three nodes\n common_cause_1 = np.array([[0, 1, 1], [0, 0, 0], [0, 0, 0]])\n common_cause_1_cpd = [np.array([1-b, b]),\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]]),\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]])]\n\n common_cause_2 = np.array([[0, 0, 0], [1, 0, 1], [0, 0, 0]])\n common_cause_2_cpd = [common_cause_1_cpd[i] for i in [1, 0, 2]]\n\n common_cause_3 = np.array([[0, 0, 0], [0, 0, 0], [1, 1, 0]])\n common_cause_3_cpd = [common_cause_1_cpd[i] for i in [1, 2, 0]]\n\n common_effect_1 = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 0]])\n common_effect_1_cpd = [np.array([1-b, b]),\n np.array([1-b, b]),\n np.array([[[1-b, b], [(1-t)*(1-b), (t + (1-t)*b)]],\n [[(1-t)*(1-b), (t + (1-t)*b)],\n [(1-t)*(1-b)*(1-t),\n (t)**2 + (t*(1-t))*2 + b*(1-t)**2]]])]\n\n common_effect_2 = np.array([[0, 1, 0], [0, 0, 0], [0, 1, 0]])\n common_effect_2_cpd = [common_effect_1_cpd[i] for i in [0, 2, 1]]\n\n common_effect_3 = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0]])\n common_effect_3_cpd = [common_effect_1_cpd[i] for i in [2, 0, 1]]\n\n causal_chain_1 = np.array([[0, 1, 0], [0, 0, 1], [0, 0, 0]])\n causal_chain_1_cpd = [np.array([1-b, b]),\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]]),\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]])]\n\n causal_chain_2 = np.array([[0, 0, 1], [0, 0, 0], [0, 1, 0]])\n causal_chain_2_cpd = [causal_chain_1_cpd[i] for i in [0, 2, 1]]\n\n causal_chain_3 = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 0]])\n causal_chain_3_cpd = [causal_chain_1_cpd[i] for i in [1, 0, 2]]\n\n causal_chain_4 = np.array([[0, 0, 1], [1, 0, 0], [0, 0, 0]])\n causal_chain_4_cpd = [causal_chain_1_cpd[i] for i in [2, 0, 1]]\n\n causal_chain_5 = np.array([[0, 1, 0], [0, 0, 0], [1, 0, 0]])\n causal_chain_5_cpd = [causal_chain_1_cpd[i] for i in [1, 2, 0]]\n\n causal_chain_6 = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]])\n causal_chain_6_cpd = [causal_chain_1_cpd[i] for i in [2, 1, 0]]\n\n single_link_1 = np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]])\n single_link_1_cpd = [np.array([1-b, b]),\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]]),\n np.array([1-b, b])]\n\n single_link_2 = np.array([[0, 0, 1], [0, 0, 0], [0, 0, 0]])\n single_link_2_cpd = [single_link_1_cpd[i] for i in [0, 2, 1]]\n\n single_link_3 = np.array([[0, 0, 0], [1, 0, 0], [0, 0, 0]])\n single_link_3_cpd = [single_link_1_cpd[i] for i in [1, 0, 2]]\n\n single_link_4 = np.array([[0, 0, 0], [0, 0, 1], [0, 0, 0]])\n single_link_4_cpd = [single_link_1_cpd[i] for i in [2, 0, 1]]\n\n single_link_5 = np.array([[0, 0, 0], [0, 0, 0], [1, 0, 0]])\n single_link_5_cpd = [single_link_1_cpd[i] for i in [1, 2, 0]]\n\n single_link_6 = np.array([[0, 0, 0], [0, 0, 0], [0, 1, 0]])\n single_link_6_cpd = [single_link_1_cpd[i] for i in [2, 1, 0]]\n\n graph_names = [\"common_cause_1\", \"common_cause_2\", \"common_cause_3\",\n \"common_effect_1\", \"common_effect_2\", \"common_effect_3\",\n \"causal_chain_1\", \"causal_chain_2\", \"causal_chain_3\",\n \"causal_chain_4\", \"causal_chain_5\", \"causal_chain_6\",\n \"single_link_1\", \"single_link_2\", \"single_link_3\",\n \"single_link_4\", \"single_link_5\", \"single_link_6\"]\n\n graphs = [common_cause_1, common_cause_2, common_cause_3,\n common_effect_1, common_effect_2, common_effect_3,\n causal_chain_1, causal_chain_2, causal_chain_3,\n causal_chain_4, causal_chain_5, causal_chain_6,\n single_link_1, single_link_2, single_link_3,\n single_link_4, single_link_5, single_link_6]\n\n cpds = [common_cause_1_cpd, common_cause_2_cpd, common_cause_3_cpd,\n common_effect_1_cpd, common_effect_2_cpd, common_effect_3_cpd,\n causal_chain_1_cpd, causal_chain_2_cpd, causal_chain_3_cpd,\n causal_chain_4_cpd, causal_chain_5_cpd, causal_chain_6_cpd,\n single_link_1_cpd, single_link_2_cpd, single_link_3_cpd,\n single_link_4_cpd, single_link_5_cpd, single_link_6_cpd]\n\n hyp_space = {graph_names: dag.DirectedGraph(graph, cpd, t, b)\n for (graph_names, graph, cpd) in\n zip(graph_names, graphs, cpds)}\n\n return hyp_space","def SIRD_graph(graph_obj, config):\n\n N = len(graph_obj.nodes)\n T = config['horizon']\n si, ir, id = config['infection_rate'], config['recovery_rate'], config['death_rate']\n sv, iv, vi = config['vaccination_rate'], config['vaccination_rate'], config['reinfection_rate']\n\n # ensure that sum of probabilities don't exceed 1\n assert ir + id + iv < 1\n assert si + sv < 1\n\n # initial state\n I0, R0, D0, V0 = config['init_state']['I'], config['init_state']['R'], config['init_state']['D'], config['init_state']['V']\n S0 = N - I0 - R0 - D0\n assert S0 > 0\n\n # shuffle node list and assign initial state\n shuffled_nodes = np.array(range(N))\n np.random.shuffle(shuffled_nodes)\n\n # state array is a Nx1 vector with array[i] denoting state of ith person\n # states for S,I,R,D,V -> (0,1,2,3,4)\n category_array = np.zeros(N, dtype=np.uint8)\n category_array[shuffled_nodes[:I0]] = 1\n category_array[shuffled_nodes[I0: I0+R0]] = 2\n category_array[shuffled_nodes[I0+R0: I0+R0+D0]] = 3\n category_array[shuffled_nodes[I0+R0+D0: I0+R0+D0+V0]] = 4\n\n # state array [i][j] = category of node j after time step i\n state_array = np.zeros((T + 1, N))\n state_array[0] = np.copy(category_array)\n\n for t in range(1, T + 1):\n if t % (T // 3) == 0:\n print('Time step:', t, '/', T)\n\n cur_categories = np.copy(state_array[t - 1])\n\n for node in graph_obj.nodes:\n # initialise new state with old state\n new_state = cur_categories[node]\n neighbours = graph_obj.adj[node]\n i_neighbours = np.sum(cur_categories[neighbours] == 1)\n\n if cur_categories[node] == 0: # susceptible\n prob_i = si * (i_neighbours / len(neighbours))\n # S can either be vaccinated or become infected\n next_possible_states = [1, 4, 0]\n next_possible_probs = [prob_i, sv, 1 - prob_i - sv]\n new_state = np.random.choice(a=next_possible_states, size=1, p=next_possible_probs)\n\n elif cur_categories[node] == 1: # infectious\n # I can either recover or die\n next_possible_states = [2, 3, 4, 1]\n next_possible_probs = [ir, id, iv, 1 - ir - id - iv]\n new_state = np.random.choice(a=next_possible_states, size=1, p=next_possible_probs)\n\n elif cur_categories[node] == 4: # vaccinated\n prob_r = vi * (i_neighbours / len(neighbours))\n next_possible_states = [1, 4]\n next_possible_probs = [prob_r, 1 - prob_r]\n new_state = np.random.choice(a=next_possible_states, size=1, p=next_possible_probs)\n\n # do nothing for recovered and dead\n\n # assign new state to current time vector\n cur_categories[node] = new_state\n\n # store new time step results in final array\n state_array[t] = cur_categories\n\n return state_array","def inverse_q_learning(feature_matrix,nA, gamma, transitions, alpha_r, alpha_q, alpha_sh, epochs, real_distribution):\n nS = feature_matrix.shape[0]\n\n \n # initialize tables for reward function, value functions and state-action visitation counter.\n r = np.zeros((nS, nA))\n q = np.zeros((nS, nA))\n q_sh = np.zeros((nS, nA))\n state_action_visitation = np.zeros((nS, nA))\n\n for i in range(epochs):\n if i%10 == 0:\n print(\"Epoch %s/%s\" %(i+1, epochs))\n \n for traj in transitions:\n for (s, a, _, ns) in traj:\n state_action_visitation[s][a] += 1\n d = False # no terminal state\n\n # compute shifted q-function.\n q_sh[s, a] = (1-alpha_sh) * q_sh[s, a] + alpha_sh * (gamma * (1-d) * np.max(q[ns]))\n \n # compute log probabilities.\n sum_of_state_visitations = np.sum(state_action_visitation[s])\n log_prob = np.log((state_action_visitation[s]/sum_of_state_visitations) + epsilon)\n \n # compute eta_a and eta_b for Eq. (9).\n eta_a = log_prob[a] - q_sh[s][a]\n other_actions = [oa for oa in range(nA) if oa != a]\n eta_b = log_prob[other_actions] - q_sh[s][other_actions]\n sum_oa = (1/(nA-1)) * np.sum(r[s][other_actions] - eta_b)\n\n # update reward-function.\n r[s][a] = (1-alpha_r) * r[s][a] + alpha_r * (eta_a + sum_oa)\n\n # update value-function.\n q[s, a] = (1-alpha_q) * q[s, a] + alpha_q * (r[s, a] + gamma * (1-d) * np.max(q[ns]))\n s = ns\n\n # compute Boltzmann distribution.\n boltzman_distribution = []\n for s in range(nS):\n boltzman_distribution.append([])\n for a in range(nA):\n boltzman_distribution[-1].append(np.exp(q[s][a]))\n boltzman_distribution = np.array(boltzman_distribution)\n boltzman_distribution /= np.sum(boltzman_distribution, axis=1).reshape(-1, 1)\n return q, r, boltzman_distribution","def viterbi(self):\n # initialisation\n self.phi = zeros((self.noOfEmmittingStates+2, self.T + 1))\n self.phi[0,0] = 1.0\n for i in range(1,self.noOfEmmittingStates+2):\n self.phi[i,0] = 0.0\n for t in range(1,self.T+1):\n self.phi[0,t] = 0.0\n self.traceback = zeros((self.noOfEmmittingStates+1, self.T+1))\n\n # main recursion\n for t in range(1, self.T + 1):\n for j in range(1, self.noOfEmmittingStates + 1):\n phiTemp = zeros((self.noOfEmmittingStates + 1, 1))\n for k in range(self.noOfEmmittingStates+1):\n phiTemp[k,0] = self.phi[k,t-1] * self.transitionMatrix[k, j-1]\n self.traceback[j-1,t-1] = nonzero(phiTemp == phiTemp.max(0))[0][0]\n self.phi[j, t] = phiTemp.max(0) * self.b[j-1, t-1]\n\n # last column - set states which can't reach term to 0, sub for term\n for j in range(1,self.noOfEmmittingStates + 1):\n if self.transitionMatrix[j,-1] == 0:\n self.phi[j,-1] = 0\n phiTemp = zeros((self.noOfEmmittingStates+1, 1))\n for k in range(self.noOfEmmittingStates + 1):\n phiTemp[k,0] = self.phi[k,-1] * self.transitionMatrix[k,-1]\n self.traceback[-1,-1] = nonzero(phiTemp == phiTemp.max(0))[0][0]\n self.phi[-1,-1] = phiTemp.max(0)","def make_euler_circuit(start_node, updated_graph_instance):\n\n current_edges_on_graph_list = make_edges_list(updated_graph_instance.edges_dict)\n\n current_node = start_node\n\n node_visit_order = [current_node]\n edge_visit_order = []\n\n # print(\"\\n\\n\\ncurrent_edges_on_graph_list:\", current_edges_on_graph_list)\n\n while len(current_edges_on_graph_list) > 0:\n\n # print(\"current_edges_on_graph_list:\", current_edges_on_graph_list)\n # while there are still edges on the graph, keep traversing\n\n current_bridges_on_graph = get_bridges(current_edges_on_graph_list)\n\n edges_conn_to_current_node = get_all_conn_edges_remaining_in_graph(\n current_node, current_edges_on_graph_list, updated_graph_instance.nodes_dict\n )\n\n edge_to_traverse = choose_edge_to_traverse(\n current_node, edges_conn_to_current_node, current_bridges_on_graph\n )\n\n if edge_to_traverse in current_edges_on_graph_list:\n\n current_edges_on_graph_list.remove(edge_to_traverse)\n\n else:\n\n current_edges_on_graph_list.remove(edge_to_traverse[::-1])\n\n edge_to_traverse_list = list(edge_to_traverse)\n # remove current node from edge to traverse\n edge_to_traverse_list.remove(current_node)\n # update current node to be the only node left in the edge list\n\n # update edge traveral list with edge just traversed\n edge_traversed = (current_node, edge_to_traverse_list[0])\n\n edge_visit_order.append(edge_traversed)\n\n current_node = edge_to_traverse_list[0]\n\n # add the new current node to the nodes visit order list\n node_visit_order.append(current_node)\n\n # add node visit order and edge_visit order to graph instance\n\n updated_graph_instance.node_visit_order = node_visit_order\n\n updated_graph_instance.edge_visit_order = edge_visit_order\n\n updated_graph_instance.node_geojson = make_node_geojson(updated_graph_instance)\n\n updated_graph_instance.edge_geojson = make_edge_geojson(updated_graph_instance)\n\n updated_graph_instance.route_geojson = make_route_geojson(updated_graph_instance)\n\n print(\"\\n\\n\\n\\n\\nROUTE COLLECTION\", updated_graph_instance.route_geojson)\n\n print(\"check done\")\n\n return updated_graph_instance","def get_problem():\n\n problem = beluga.optim.Problem('Track_demo')\n problem.mode='analytical' #Other options: 'numerical', 'dae'\n\n #Define independent variables\n problem.independent('t', 's')\n\n # Define equations of motion\n problem.state('x','V*cos(hdg)','k') \\\n .state('y','V*sin(hdg)','k') \\\n\n # Define controls\n problem.control('hdg','rad')\n\n # Define cost functional\n problem.cost['path'] = Expression('(1-w)+w*V*conv*elev*terrain(x,y)', 's')\n\n #Define constraints\n problem.constraints().initial('x-x_0','k') \\\n .initial('y-y_0','k') \\\n .terminal('x-x_f','k') \\\n .terminal('y-y_f','k')\n\n #Define constants\n problem.constant('w',0.9,'1') #Initial Terrain weighting factor\n problem.constant('conv',1,'s/k^2') #Integral conversion factor\n problem.constant('V',1,'k/s') #Vehicle speed\n problem.constant('elev',0.001,'k') #Units for the elevation\n\n #Unit scaling\n problem.scale.unit('k',1) \\\n .unit('s',1) \\\n .unit('rad',1)\n\n #Configure solver\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=50, verbose = True, cached = False, number_arcs=8)\n #problem.bvp_solver = algorithms.SingleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=50, verbose = True, cached = False)\n\n #Initial Guess\n problem.guess.setup('auto',start=[16,10], costate_guess=[0.0,-0.1])\n\n #Add continuation steps\n problem.steps.add_step(strategy='HPA') \\\n .terminal('x', 180, 50) \\\n .terminal('y', 98, 50)\n\n return problem","def E_generator(beta, eta, h):\n def E(x, y):\n \"\"\"Calculate energy for matrices x, y.\n\n Note: the computation is not localized, so this is quite expensive.\n \"\"\"\n # sum of products of neighboring paris {xi, yi}\n xxm = np.zeros_like(x)\n xxm[:-1, :] = x[1:, :] # down\n xxm[1:, :] += x[:-1, :] # up\n xxm[:, :-1] += x[:, 1:] # right\n xxm[:, 1:] += x[:, :-1] # left\n xx = np.sum(xxm * x)\n xy = np.sum(x * y)\n xsum = np.sum(x)\n return h * xsum - beta * xx - eta * xy\n\n def is_valid(i, j, shape):\n \"\"\"Check if coordinate i, j is valid in shape.\"\"\"\n return i >= 0 and j >= 0 and i < shape[0] and j < shape[1]\n\n def localized_E(E1, i, j, x, y):\n \"\"\"Localized version of Energy function E.\n\n Usage: old_x_ij, new_x_ij, E1, E2 = localized_E(Ecur, i, j, x, y)\n \"\"\"\n oldval = x[i, j]\n newval = oldval * -1 # flip\n # local computations\n E2 = E1 - (h * oldval) + (h * newval)\n E2 = E2 + (eta * y[i, j] * oldval) - (eta * y[i, j] * newval)\n adjacent = [(0, 1), (0, -1), (1, 0), (-1, 0)]\n neighbors = [x[i + di, j + dj] for di, dj in adjacent\n if is_valid(i + di, j + dj, x.shape)]\n E2 = E2 + beta * sum(a * oldval for a in neighbors)\n E2 = E2 - beta * sum(a * newval for a in neighbors)\n return oldval, newval, E1, E2\n\n return E, localized_E","def test_tdsp_dijsktra_with_timesteps_key_error(self):\n input_file = \"/home/andy/code/python/om_task/data/input_data2.txt\"\n graph_data = process_input_file(input_file)\n\n graphs = {}\n\n today = datetime.today()\n t = time(0, 0) # input time value\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\n\n #print(\"graph_data = \", graph_data)\n print(\"graph_data[4] = \", graph_data[4])\n\n for timestep in graph_data:\n # print(\"Timestep=\", timestep)\n # Create a graph for each timestep\n graphs[timestep] = Graph()\n for edge in graph_data.get(timestep):\n graphs[timestep].add_edge(*edge)\n\n for graph in graphs:\n print(graphs[graph].edges)\n print(graphs[graph].weights)\n\n print(\"graph[4].weights = \", graphs[4].weights)\n\n print(\"Start Test 1\")\n path = tdsp_dijsktra(graphs, start_time, 'A0', 'E1')\n print(\"Path = \", path)\n self.assertEqual(['A0', 'B9', 'C0', 'D0', 'E1'], path)","def algo_graph_iht(\n x_mat, y_tr, max_epochs, lr, x_star, x0, tol_algo, edges, costs, s,\n g=1, root=-1, gamma=0.1, proj_max_num_iter=50, verbose=0):\n start_time = time.time()\n x_hat = np.copy(x0)\n xtx = np.dot(np.transpose(x_mat), x_mat)\n xty = np.dot(np.transpose(x_mat), y_tr)\n\n # graph projection para\n h_low = int(len(x0) / 2)\n h_high = int(h_low * (1. + gamma))\n t_low = int(s)\n t_high = int(s * (1. + gamma))\n\n num_epochs = 0\n for epoch_i in range(max_epochs):\n num_epochs += 1\n grad = -1. * (xty - np.dot(xtx, x_hat))\n head_nodes, proj_gradient = algo_head_tail_bisearch(\n edges, grad, costs, g, root, h_low, h_high,\n proj_max_num_iter, verbose)\n bt = x_hat - lr * proj_gradient\n tail_nodes, proj_bt = algo_head_tail_bisearch(\n edges, bt, costs, g, root, t_low, t_high,\n proj_max_num_iter, verbose)\n x_hat = proj_bt\n\n # early stopping for diverge cases due to the large learning rate\n if np.linalg.norm(x_hat) >= 1e3: # diverge cases.\n break\n if np.linalg.norm(y_tr - np.dot(x_mat, x_hat)) <= tol_algo:\n break\n x_err = np.linalg.norm(x_hat - x_star)\n run_time = time.time() - start_time\n return x_err, num_epochs, run_time","def graph_eigenvalues(N, eigenvalues,interval):\n (a,b) =interval\n a=abs(a-b)\n n=[]\n E_numeric=[]\n E_anlytic=[]\n E_anlytic_harm=[]\n \n for i in range(N-1):\n n.append(i)\n E_numeric.append(eigenvalues[0,i])\n E_anlytic.append((((math.pi)**2)*(i**2))/(a**2))\n E_anlytic_harm.append(((1/2)**0.5)*((i)+(1/2)))\n plt.plot(n,E_numeric,'b')\n plt.plot(n,E_anlytic,'g')\n plt.plot(n,E_anlytic_harm,'r')\n plt.xlabel('n', fontsize=20, color='black')\n plt.ylabel('E', fontsize=20, color='black')\n plt.show()\n return None","def solve_rocket_equations():\n # initial data\n u0 = numpy.array([h0,v0,mp0])\n t = [0.0] # The array of times\n u = [u0] # The array of evolved solutions\n # Evolve!\n while u[-1][0] >= 0.0:\n t.append(t[-1]+dt)\n u.append(euler_step(u[-1],t[-1],rhs,dt))\n return numpy.array(t),numpy.array(u)","def get_problem():\n\n # Rename this and/or move to optim package?\n problem = beluga.optim.Problem('Hannibal_HPAdemo')\n problem.mode='analytical' #Other options: 'numerical', 'dae'\n\n #Define independent variables\n problem.independent('t', 's')\n\n #~~~~~!!!\n #problem.quantity('terrain3','(-0.3*exp(-0.5*((x-2.7)^2+1.5*(y-2.1)^2))+2.6*exp(-0.55*(0.87*(x-6.7)^2+(y-2.2)^2))+2.1*exp(-0.27*(0.2*(x-5.5)^2+(y-7.2)^2))+1.6*(cos(0.8*y))^2*(sin(0.796*x))^2)')\n\n # Define equations of motion\n problem.state('x','V*cos(hdg)','m') \\\n .state('y','V*sin(hdg)','m') \\\n\n # Define controls\n problem.control('hdg','rad')\n\n # Define Cost Functional\n problem.cost['path'] = Expression('(1-w)+w*V*conv*elev*terrain(x,y)', 's')\n\n #Define constraints\n problem.constraints().initial('x-x_0','m') \\\n .initial('y-y_0','m') \\\n .terminal('x-x_f','m') \\\n .terminal('y-y_f','m')\n\n #Define constants\n problem.constant('w',0.9,'1') #Initial Terrain weighting factor\n problem.constant('conv',1,'s/m^2') #Integral conversion factor\n problem.constant('V',1,'m/s') #Vehicle speed\n problem.constant('elev',1,'m') #Initial Elevation\n\n #Unit scaling\n problem.scale.unit('m',1) \\\n .unit('s',1) \\\n .unit('rad',1)\n\n #Configure solver\n #problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=8)\n problem.bvp_solver = algorithms.SingleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=15, verbose = True, cached = False)\n\n #Initial Guess (Classic test example [4.9,0.4])\n problem.guess.setup('auto',start=[9.0,0.5], costate_guess=[0.0,-0.1]) #City A\n #problem.guess.setup('auto',start=[4.9,0.4], costate_guess=[0.1,-0.1]) #City A\n\n #Add Continuation Steps (Classic test example [7.2,8.5]) [8, 4.5]\n problem.steps.add_step(strategy='HPA',hweight=0.9) \\\n .terminal('x', 3.0, 10) \\\n .terminal('y', 9.5, 10) \\\n # .const('w', 0.9, 2, confined=True)\n\n #problem.steps.add_step(strategy='manual').num_cases(10) \\\n # .terminal('x', 3.0) \\\n # .terminal('y', 9.5) \\\n\n #problem.steps.add_step().num_cases(30) \\\n # .const('w',0.99) #Final Terrain weighting factor\n\n\n return problem","def hyperbolic_generator():\n\n hyperbolicRadius = np.arccosh(1 + N / (2 * np.pi * pointDensity))\n hyperbolicThreshold = np.arccosh(1 + thresholdFrac * (np.cosh(hyperbolicRadius) - 1))\n\n data_hyperbolic = []\n for r in range(num_graphs):\n # generates dictionary of positions (in a circle of radius) for each node: node_pos = {node_i: (radius, theta)} <-- uses polar coordinates\n # uses the inversion sampling idea to give Euclidean radii sampled uniformly across a hyperbolic sheet\n node_pos = {}\n for i in range(N):\n rnd_angle = np.random.random() * 2 * np.pi\n p = np.random.random() # random float between 0 and 1\n rnd_radii = np.arccosh(1 + p * (np.cosh(hyperbolicRadius) - 1)) # <-- inversion sampling\n node_pos.update({i: (rnd_radii, rnd_angle)})\n\n # computes the adjacency matrix\n Adj_Matrix = np.zeros((N, N))\n for i in range(N):\n for j in range(N):\n ij_dist = hyp_dist(node_pos[i], node_pos[j])\n if ij_dist < hyperbolicThreshold:\n Adj_Matrix[i, j] = 1 # nodes that are connected are assigned a 1 in the matrix\n\n data_hyperbolic.append(Adj_Matrix)\n\n return data_hyperbolic","def integration_testing(solver):\n time_step = [g_initial_time + step for step in g_time_steps]\n u = 0.0\n system_equation = lambda t, state, u: system(t, state, u)\n system_jacobian = lambda t, state, u: jacobian(t, state, u)\n solver.set_system_equation(system_equation, system_jacobian)\n solver.set_initial_value(g_initial_value, g_initial_time)\n assert g_initial_time == solver.t\n for steps in time_step:\n solver.set_f_params(u)\n state = solver.integrate(steps)\n assert all(state == solver.y), \"state error\"\n assert solver.t == steps, \"time error, desired and actual time are not the same\"","def tryEverything(g, verbose, graphname):\r\n prio = ['rku', 'random', 'BIL', 'rkd', 'cluHPS', 'rkusd', 'rkuad']\r\n placement = ['eft', 'BIM*', 'OLB', 'MET', 'DL', 'GDL']\r\n costFunction = ['mean', 'median', 'maxmax', 'minmax', 'minmin', 'maxmin']\r\n desc = ['DLS/DC', None, 'DCP']\r\n useOfBIM = [False, True]\r\n insertion = [False, True]\r\n BSA = [False, True]\r\n res: Dict[str, List[float]] = {}\r\n cnt = 0\r\n\r\n for ip, p in enumerate(prio):\r\n for ipl, pl in enumerate(placement):\r\n for ic, c in enumerate(costFunction):\r\n if p != 'BIL' or c == 'mean' or pl in ['DL', 'GDL']:\r\n for idd, d in enumerate(desc):\r\n for iu, u in enumerate(useOfBIM):\r\n for ii, i in enumerate(insertion):\r\n for ib, b in enumerate(BSA):\r\n cnt += 1\r\n name = \";\".join(map(str, [ip, ic, ipl, idd, iu, ii, ib]))\r\n\r\n # dispName = \"-\".join(map(str, [p, pl, c, d, u, i, b]))\r\n # print(\"Heuristic n°\", cnt, \"-\", dispName)\r\n # print(\"Heuristic n°\", cnt, \"-\", name)\r\n\r\n startScheduling = timeit.default_timer()\r\n try:\r\n schedule = computeSchedule(g, strategyPrio=p, costFunction=c,\r\n strategyPlacement=pl,\r\n useOfBIM=u, desc=d,\r\n insertion=i, bsa=b, verbose=verbose)\r\n verifPrec(g, schedule, verbose)\r\n endScheduling = timeit.default_timer()\r\n # print(\"Ended in :\", 1000*(endScheduling - startScheduling), \"ms\")\r\n # print(\"Ended in :\", round(1000 * (endScheduling - startScheduling),2), \"ms\")\r\n timeS = round(1000 * (endScheduling - startScheduling), 2)\r\n # print(f\"timeS : {timeS}\")\r\n if verbose:\r\n print(f\"Time : {timeS}ms\")\r\n res[name] = [round(schedule[getExitTask(g)][2], 6), timeS]\r\n except Exception as _:\r\n\r\n print(\"Error for : \" + name + \" on file \" + graphname)\r\n file = open(\"error.log\", 'a')\r\n file.write(f\"Error for {name} on file {graphname}\\n\")\r\n file.close()\r\n raise _\r\n return res\r\n return res","def test_tdsp_dijsktra_with_timesteps(self):\n input_file = \"/home/andy/code/python/om_task/data/test_data3.txt\"\n graph_data = process_input_file(input_file)\n\n graphs = {}\n\n today = datetime.today()\n t = time(0, 0) # input time value\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\n\n for timestep in graph_data:\n # print(\"Timestep=\", timestep)\n # Create a graph for each timestep\n graphs[timestep] = Graph()\n for edge in graph_data.get(timestep):\n graphs[timestep].add_edge(*edge)\n\n for graph in graphs:\n print(graphs[graph].edges)\n print(graphs[graph].weights)\n\n print(\"Start Test 1\")\n path = tdsp_dijsktra(graphs, start_time, 'A0', 'A1')\n print(path)\n self.assertEqual(['A0', 'B0', 'B1', 'A1'], path)\n\n print(\"Start Test 2\")\n t = time(0, 0) # input time value\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\n path = tdsp_dijsktra(graphs, start_time, 'B0', 'A1')\n print(path)\n self.assertEqual(['B0', 'B1', 'A1'], path)\n\n print(\"Start Test 3\")\n t = time(1, 1) # input time value\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\n path = tdsp_dijsktra(graphs, start_time, 'B0', 'A1')\n print(path)\n self.assertEqual(['B0', 'A1'], path)","def g_dynamic_programming_algorithm(self, vehicle_id, Flag):\r\n for t in range(self.g_number_of_time_intervals):\r\n self.g_time_dependent_state_vector[vehicle_id][t] = C_time_indexed_state_vector()\r\n self.g_time_dependent_state_vector[vehicle_id][t].Reset()\r\n self.g_time_dependent_state_vector[vehicle_id][t].current_time = t\r\n\r\n self.g_ending_state_vector[vehicle_id] = C_time_indexed_state_vector()\r\n self.g_ending_state_vector[vehicle_id].Reset()\r\n max_time_interval = 0\r\n # 1.Initial state for original depot\r\n new_element = CVSState()\r\n new_element.current_node_id = self.origin\r\n new_element.remaining_capacity = self.capacity\r\n new_element.node_seq.append(self.origin)\r\n new_element.node_serving_state = [0] * self.g_number_of_nodes\r\n self.g_time_dependent_state_vector[vehicle_id][0].update_state(new_element, Flag)\r\n for t in range(self.g_number_of_time_intervals):\r\n for index in range(min(len(self.g_time_dependent_state_vector[vehicle_id][t].VSStateVector), self.Best_K_Size)):\r\n pElement = self.g_time_dependent_state_vector[vehicle_id][t].VSStateVector[index]\r\n from_node_id = pElement.current_node_id # 起点ID\r\n from_node = self.node_list[from_node_id] # 起点\r\n for i in range(from_node.outbound_size): # 邻接点\r\n to_node_id = from_node.outbound_nodes_list[i] # 从当前点可以到达哪些点ID\r\n to_node = self.node_list[to_node_id] # 邻接点\r\n link_to = from_node.outbound_links_list[i] # 邻接路段\r\n if link_to.mean == 0:\r\n next_time =t+1\r\n else:\r\n next_time = t + link_to.mean\r\n\r\n if next_time > self.g_number_of_time_intervals - 1:\r\n continue\r\n # Case 1: to_node is the destination\r\n if to_node_id == self.destination:\r\n new_element = CVSState()\r\n new_element.my_copy(pElement)\r\n # new_element.current_node_id = to_node_id\r\n # new_element.remaining_capacity -= to_node.demand\r\n new_element.node_seq.append(to_node_id)\r\n # new_element.node_serving_state[to_node_id] = 1\r\n new_element.Calculate_Label_Cost(to_node, link_to,self.multiplier_v)\r\n self.g_ending_state_vector[vehicle_id].VSStateVector.append(new_element)\r\n\r\n # self.g_ending_state_vector[vehicle_id].update_state(new_element, Flag)\r\n\r\n # Case 2: to_node is not the destination\r\n if to_node_id != self.destination:\r\n # check 1: vehicle capacity\r\n if pElement.remaining_capacity < to_node.demand:\r\n continue\r\n # check 2: if the to node is served\r\n node_serving_state = pElement.node_serving_state\r\n if node_serving_state[to_node_id] == 1:\r\n continue\r\n\r\n new_element = CVSState()\r\n new_element.my_copy(pElement)\r\n new_element.current_node_id = to_node_id\r\n new_element.remaining_capacity -= to_node.demand\r\n new_element.node_seq.append(to_node_id)\r\n new_element.node_serving_state[to_node_id] = 1\r\n new_element.Calculate_Label_Cost(to_node, link_to,self.multiplier_v)\r\n self.g_time_dependent_state_vector[vehicle_id][next_time].update_state(new_element, Flag)\r\n if next_time > max_time_interval:\r\n max_time_interval = next_time\r\n # check\r\n if max_time_interval <= t:\r\n break\r\n self.g_ending_state_vector[vehicle_id].Sort(Flag)","def __init__(self,\n game,\n exploration_strategy='uniform-exhaustive',\n confidence_method='ucb-standard',\n delta=0.01,\n ucb_eps=0,\n per_payoff_confidence=True,\n time_dependent_delta=False):\n self.exploration_strategy = exploration_strategy\n self.confidence_method = confidence_method\n self.ucb_eps = ucb_eps\n self.G = game # pylint: disable=invalid-name\n self.per_payoff_confidence = per_payoff_confidence\n self.time_dependent_delta = time_dependent_delta\n if self.per_payoff_confidence:\n self._delta = delta\n else:\n self._delta = delta / (\n self.G.n_players *\n functools.reduce(operator.mul, self.G.strategy_spaces, 1))\n\n # Compute the graph\n self.V = list( # pylint: disable=invalid-name\n itertools.product(*[range(smax) for smax in self.G.strategy_spaces]))\n self.E = [] # pylint: disable=invalid-name\n for v in self.V:\n adj_strats = [\n list(range(v[k] + 1, self.G.strategy_spaces[k]))\n for k in range(self.G.n_players)\n ]\n for k in range(self.G.n_players):\n for new_s in adj_strats[k]:\n second_vertex = list(v)\n second_vertex[k] = new_s\n second_vertex = tuple(second_vertex)\n self.E.append((v, second_vertex))\n self.count_history = {v: [] for v in self.V}\n self.total_interactions = 0","def main():\r\n start = input(\"Enter the starting state: \").replace(\" \", \"\") # Remove whitespace from states\r\n goal = input(\"Enter the goal state: \").replace(\" \", \"\")\r\n if validate_input(start, goal) == False:\r\n return print(\"Invalid input.\")\r\n\r\n start_list = [] # Convert into list for efficieny\r\n for i in start:\r\n start_list.append(int(i))\r\n\r\n goal_list = [] # Convert into list for efficieny\r\n for i in goal:\r\n goal_list.append(int(i))\r\n\r\n state_inversions = inversions(start_list)\r\n print(\"\\nStart state inversions:\", state_inversions)\r\n goal_inversions = inversions(goal_list)\r\n print(\"Goal state inversions:\", goal_inversions)\r\n\r\n if state_inversions % 2 != goal_inversions % 2: # If polarity is uneven, not solvable\r\n print(\"Unsolvable configurations.\\nPolarities do not match.\")\r\n exit(1)\r\n\r\n heuristic = -1 # Set heuristic option for A* search\r\n while heuristic != 0 and heuristic != 1:\r\n try:\r\n heuristic = int(input(\"\\nEnter heuristic function: \\n0 for Manhattan\\n1 for Eucledian\\n= \"))\r\n except (EOFError, KeyboardInterrupt):\r\n print('Terminating.')\r\n exit()\r\n except (KeyError, ValueError):\r\n print('Invalid option.')\r\n\r\n start_time = time.time() # Start search time\r\n nodes_searched = astar_search(start_list, goal_list, heuristic)\r\n end_time = time.time() # Stop search timer\r\n\r\n print(\"\\nSolved in: {:.2f}\".format(end_time-start_time), \"seconds\")\r\n print(\"Nodes explored:\", nodes_searched)\r\n exit()","def execute_inner_graph(*args):\r\n # Check if you need to go back in time over the sequences (the\r\n # first argument is n_steps, the second is go_backwards)\r\n nsteps = args[0]\r\n invert = False\r\n if args[1]:\r\n nsteps = nsteps * -1\r\n if nsteps < 0:\r\n new_ins = [x[::-1] for x in args[2: 2 + n_ins]]\r\n else:\r\n new_ins = [x for x in args[2: 2 + n_ins]]\r\n nsteps = abs(nsteps)\r\n # Simplify the inputs by slicing them according to the taps\r\n nw_inputs = []\r\n for inp, info in zip(new_ins, inputs_info):\r\n taps = [x['tap'] for x in info]\r\n\r\n if numpy.min(taps) < 0:\r\n _offset = abs(numpy.min(taps))\r\n else:\r\n _offset = 0\r\n nw_inputs += [inp[_offset + k:] for k in taps]\r\n # Simplify the states by slicing them according to the taps.\r\n # Note that if the memory buffer for the inputs and outputs is\r\n # the same, by changing the outputs we also change the outputs\r\n nw_states_inputs = []\r\n nw_states_outs = []\r\n for st, info in zip(args[2 + n_ins:2 + n_ins + n_states],\r\n states_info):\r\n taps = [x['tap'] for x in info]\r\n\r\n membuf = numpy.zeros((nsteps + abs(numpy.min(taps)), 4))\r\n if abs(numpy.min(taps)) != 1:\r\n membuf[:abs(numpy.min(taps))] = st[:abs(numpy.min(taps))]\r\n else:\r\n membuf[:abs(numpy.min(taps))] = st\r\n\r\n nw_states_inputs += [membuf[abs(numpy.min(taps)) + k:]\r\n for k in taps]\r\n nw_states_outs.append(membuf[abs(numpy.min(taps)):])\r\n\r\n parameters_vals = args[2 + n_ins + n_states:]\r\n out_mem_buffers = [numpy.zeros((nsteps, 4)) for k in\r\n xrange(n_outputs)]\r\n shared_values = [x.copy() for x in original_shared_values]\r\n\r\n for step in xrange(nsteps):\r\n arg_pos = 0\r\n to_add = None\r\n for in_info in inputs_info:\r\n for info in in_info:\r\n arg = nw_inputs[arg_pos][step]\r\n arg_pos += 1\r\n # Construct dummy graph around input\r\n if info['use']:\r\n if to_add is None:\r\n to_add = arg * 2\r\n else:\r\n to_add = to_add + arg * 2\r\n arg_pos = 0\r\n for dx, st_info in enumerate(states_info):\r\n if to_add is not None:\r\n nw_states_outs[dx][step] = to_add\r\n for info in st_info:\r\n arg = nw_states_inputs[arg_pos][step]\r\n arg_pos += 1\r\n if info['use']:\r\n nw_states_outs[dx][step] += arg * 3\r\n for arg, info in zip(parameters_vals, parameters_info):\r\n if info['use']:\r\n if to_add is None:\r\n to_add = arg * 4\r\n else:\r\n to_add = to_add + arg * 4\r\n if to_add is not None:\r\n shared_values = [sh * 5 + to_add for sh in shared_values]\r\n for state in nw_states_outs:\r\n state[step] += to_add\r\n for out in out_mem_buffers:\r\n out[step] = to_add ** 2\r\n else:\r\n shared_values = [sh * 5 for sh in shared_values]\r\n for out in out_mem_buffers:\r\n out[step] = 2\r\n return nw_states_outs + out_mem_buffers, shared_values","def compute_CTMC_flow_in_logspace(adj_mat, time_resolution=.1,\n n_timepoints=10):\n\n n = len(adj_mat)\n\n # compute infinitesimal generator\n degrees = np.sum(adj_mat, axis=0) * 1.\n D = scipy.sparse.csr_matrix(np.diag(degrees))\n\n generator_mat = compute_infinitesimal_generator(adj_mat)\n\n # compute 2nd-order approximation to e^(time_resolution * generator_mat)\n tmp = time_resolution * generator_mat\n U = np.eye(n) + tmp + np.linalg.matrix_power(\n tmp, 2) / 2.\n\n print \"Bridge passed ..\"\n # Techinique: U^2k = (U^k)^2\n for j in xrange(n_timepoints):\n # compute flow matrix at time t = time_resolution * 2 ^j\n V = D.dot(U)\n\n # update U\n U = np.linalg.matrix_power(U, 2)\n\n # yield compouted flow matrix\n yield V","def current(edges, transition_matrix):\n ### Calculate the state frequecies ###\n # Eigenvalues and Eigenvectors of transition matrix\n vals, vl, vr = sp.linalg.eig(transition_matrix, left=True)\n # Find the eigenvalue that == 1\n index = list(vals).index(1)\n state_freq = vl[:,index]\n\n committor_plus = np.linalg.eig\n\n\n ### Calculate the flux matrix ###\n flux_matrix = np.multiply(transition_matrix, state_freq)\n return flux_matrix / flux_matrix.sum(axis=1)","def one_backward_pass(t,states,init_vals,traces,delta,unit_cube,edges,P):\n \n next_vals = -1e100 * np.ones_like(init_vals)\n \n S,T = states.shape\n \n for i in range(len(states)):\n for j in range(len(unit_cube)):\n# print('State, unitcube subtracted',s,c)\n if (states[i] - unit_cube[j]).min() >= 0:\n \n state_idx = edges[i,j]\n \n tau = np.where(unit_cube[j] == 0)\n \n if len(tau[0]) == 0:\n next_vals[state_idx] = log_sum_exp([next_vals[state_idx],\\\n init_vals[i]+T*np.log(delta)])\n \n else:\n flag = 0\n temp = []\n for k in tau[0]:\n if (t-states[i,k] >=0 and t-states[i,k]< len(traces[k])):\n temp.append(traces[k][t-states[i][k]])\n else:\n flag = 1\n break\n\n if (len(set(temp)) == 1 and flag == 0):\n bit = temp[0]\n next_vals[state_idx] = log_sum_exp([next_vals[state_idx],init_vals[i]\\\n + (T-len(temp)) * np.log(delta)\\\n + np.log(1-delta) * (len(temp))\\\n + np.log(P[t,bit] + 1e-100)])\n \n return next_vals","def gstate(N, periodic):\n\n # Create Hamiltonian matrix\n H = kronH(N, periodic)\n \n # Diagonalize\n print('Diagonalizing...', end=' ', flush=True)\n w, v = eigsh(H, k=1, which='SA')\n print('Done')\n\n return w[0]","def G(self, (k,t), (j,x), **params):\n return 0","def solver(self, theta):\n\n m = len(self.x)\n n = len(self.t[0])\n h = self.step_x\n k = self.step_t\n lamb = k / (h * h)\n w = np.zeros(m + 1)\n l = np.zeros(m + 1)\n u = np.zeros(m + 1)\n\n uK = np.zeros(self.x.shape)\n print('comecei para k= ({},{})'.format(theta[0], theta[1]))\n startTime = time.clock()\n if self.first:\n self.uR = np.zeros(self.x.shape)\n self.first = False\n error = 0\n errorCurve = np.zeros(self.x.shape)\n z = np.zeros(m + 1)\n w[m] = 0 # following the initial condition u(0,t) = u(l,t) = 0. If needed, change this.\n for i in range(1, m - 1):\n w[i] = self.g(i * h)\n\n l[1] = 1 + lamb\n u[1] = -lamb / (2 * l[1])\n for i in range(2, m - 1):\n l[i] = 1 + lamb + lamb * u[i - 1] / 2\n u[i] = -lamb / (2 * l[i])\n\n l[m - 1] = 1 + lamb + lamb * u[m - 2] / 2\n for j in range(1, n + 1):\n t = j * k # current t\n z[1] = ((1 - lamb) * w[1] + lamb / 2 * w[2] + self.f(t, theta)) / l[1]\n for i in range(2, m):\n z[i] = ((1 - lamb) * w[i] + lamb / 2 * (w[i + 1] + w[i - 1] + z[i - 1]) + self.f(t, theta)) / l[i]\n w[m - 1] = z[m - 1]\n for i in range(m - 2, 0, -1):\n w[i] = z[i] - u[i] * w[i + 1]\n\n for i in range(0, m + 1):\n x = i * h\n # print(x, w[i])\n # print('oi')\n uK[i - 1, j - 1] = w[i]\n self.t[i - 1, j - 1] = t\n self.x[i - 1, j - 1] = x\n error += pow(w[i] - self.uR[i - 1, j - 1], 2) / uK.size\n errorCurve[i - 1, j - 1] = (pow(w[i] - self.uR[i - 1, j - 1], 2)) / uK.size\n print('acabei para k= ({},{}) em {} segundos'.format(theta[0], theta[1], time.clock() - startTime))\n return (uK, error, errorCurve, theta)","def get_problem():\n\n #User Defined Terrain Elevation\n #def terr( x_pos, y_pos ):\n #Defines terrain elevation [m] as a function of x and y positions [m]\n # elev=100.0*(np.sin(0.5*(x_pos/1000.0)))**2.0 #User defined elevation map\n # return elev\n\n #User Defined Tunnel Cost\n #def tunnel(depth):\n #Defines additional cost for placing a 1 meter length of track a non-zero\n #depth below the ground.\n # TunnelCost=(50e3)/(1+np.exp(-(depth-5))) #Tunneling Cost (2016 USD)\n # return TunnelCost\n\n #def bridge(height):\n #Defines additional cost for placing a 1 meter length of track a non-zero\n #heigh above the ground.\n # BridgeCost=10e3*(height/10)**2 #Bridge Cost (2016 USD)\n # return BridgeCost\n\n # Rename this and/or move to optim package?\n problem = beluga.optim.Problem('surftest_noinc')\n\n #Define independent variables\n problem.independent('t', 's')\n\n # Define equations of motion\n problem.state('x','V*cos(hdg)','m') \\\n .state('y','V*sin(hdg)','m') \\\n .state('V','amax*sin(thrA) + eps*(cos(thrA)+cos(hdgA))','m/s') \\\n .state('hdg','cmax/V*sin(hdgA)','rad')\n\n # Define controls\n #problem.control('thrA','rad') \\\n # .control('hdgA','rad')\n problem.control('hdgA','rad')\n\n # Define Cost Functional\n problem.cost['path'] = Expression('1','s')\n\n #problem.cost['path'] = Expression('TimeToUSD+trk*V', 'USD')\n\n #+ \\\n #'(50e3)/(1.0+exp(-1.0*(z-0.0*(sin(0.5*(x/1000.0)))**2.0-5.0)))+'+ \\\n #'10e3*((0.0*(sin(0.5*(x/1000.0)))**2.0-z)/10.0)**2.0','USD')\n\n #Define constraints\n problem.constraints().initial('x-x_0','m') \\\n .initial('y-y_0','m') \\\n .initial('V-V_0','m/s') \\\n .initial('hdg-hdg_0','rad') \\\n .terminal('x-x_f','m') \\\n .terminal('y-y_f','m')\n #.terminal('V-V_f','m/s')\n #.initial('hdg-hdg_0','rad') \\\n\n #Define constants\n problem.constant('g',9.81,'m/s^2') #Acceleration due to gravity\n problem.constant('trk',1,'USD/m') #Basic cost of 1 m of track on ground (10k per m)\n problem.constant('amax',1.0,'m/s^2') #Maximum thrust acceleration of vehicle\n problem.constant('cmax',1.0,'m/s^2') #Maximum allowed centripetal acceleration\n problem.constant('eps',10,'m/s^2') #Error constant\n problem.constant('TimeToUSD',1,'USD/s') #Time is Money!!\n problem.constant('thrA',0,'rad')\n\n #Unit scaling\n problem.scale.unit('m','x') \\\n .unit('s','x/V') \\\n .unit('rad',1) \\\n .unit('USD',1)\n\n #Configure solver\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=2)\n\n #Initial Guess\n problem.guess.setup('auto',start=[0.0,0.0,1.0,pi/4-0.2], costate_guess=-0.1) #City A\n\n #Add Continuation Steps\n problem.steps.add_step().num_cases(10) \\\n .terminal('x', 10) \\\n .terminal('y', 0)\n\n problem.steps.add_step().num_cases(10) \\\n .const('eps', 0.2)\n\n #problem.steps.add_step().num_cases(10) \\\n # .terminal('y', 2*pi*1000) \\\n # .terminal('z', 0.0) \\\n # .terminal('inc', 0.0)\n #^ City B\n return problem","def init_compute(params):\n\n # unzip dictionary and assign parameters\n N, M, K, T = params.values()\n\n p0 = np.fft.fftfreq(N, 1.0 / N)\n x0 = np.arange(0, 2 * np.pi, 2 * np.pi / N)\n\n p_time_evolution = np.zeros((N, T), dtype=\"complex_\")\n x_time_evolution = np.zeros((N, T), dtype=\"complex_\")\n p_time_evolution[:, 0] = p0\n x_time_evolution[:, 0] = x0\n\n # Initialise b,c tensor to hold b,c matrices iteravtively\n b_tensor = np.zeros((N, N, T), dtype=\"complex_\")\n c_tensor = np.zeros((N, N, T), dtype=\"complex_\")\n c_trace = np.zeros(T, dtype=\"complex_\")\n for i in range(T - 1): # Evolve\n b = coeff_b(N, N) * p_time_evolution[:, i]\n c = b @ b.T.conj()\n print(c.trace())\n c_trace[i] = c.trace()\n p_time_evolution[:, i + 1] = evolve(\n p_time_evolution[:, i],\n \"momentum\",\n x_time_evolution[:, i],\n p_time_evolution[:, i],\n params,\n )\n x_time_evolution[:, i + 1] = evolve(\n x_time_evolution[:, i],\n \"position\",\n x_time_evolution[:, i],\n p_time_evolution[:, i],\n params,\n )\n b_tensor[:, :, i], c_tensor[:, :, i] = b, c\n return b_tensor, c_tensor","def algo_graph_sto_iht(\n x_mat, y_tr, max_epochs, lr, x_star, x0, tol_algo, edges, costs, s, b,\n g=1, root=-1, gamma=0.1, proj_max_num_iter=50, verbose=0):\n np.random.seed()\n start_time = time.time()\n x_hat = np.copy(x0)\n x_tr_t = np.transpose(x_mat)\n\n # graph projection para\n h_low = int(len(x0) / 2)\n h_high = int(h_low * (1. + gamma))\n t_low = int(s)\n t_high = int(s * (1. + gamma))\n\n (n, p) = x_mat.shape\n # if block size is larger than n,\n # just treat it as a single block (batch)\n b = n if n < b else b\n num_blocks = int(n) / int(b)\n prob = [1. / num_blocks] * num_blocks\n\n num_epochs = 0\n\n for epoch_i in range(max_epochs):\n num_epochs += 1\n for _ in range(num_blocks):\n ii = np.random.randint(0, num_blocks)\n block = range(b * ii, b * (ii + 1))\n xtx = np.dot(x_tr_t[:, block], x_mat[block])\n xty = np.dot(x_tr_t[:, block], y_tr[block])\n gradient = -2. * (xty - np.dot(xtx, x_hat))\n head_nodes, proj_grad = algo_head_tail_bisearch(\n edges, gradient, costs, g, root, h_low, h_high,\n proj_max_num_iter, verbose)\n bt = x_hat - (lr / (prob[ii] * num_blocks)) * proj_grad\n tail_nodes, proj_bt = algo_head_tail_bisearch(\n edges, bt, costs, g, root,\n t_low, t_high, proj_max_num_iter, verbose)\n x_hat = proj_bt\n if np.linalg.norm(x_hat) >= 1e3: # diverge cases.\n break\n if np.linalg.norm(y_tr - np.dot(x_mat, x_hat)) <= tol_algo:\n break\n x_err = np.linalg.norm(x_hat - x_star)\n run_time = time.time() - start_time\n return x_err, num_epochs, run_time","def build_graph(mesh, evals, nevals,nfix, step=1.0, params=OptimizationParams()): #smoothing='absolute', numsteps=40000):\n [Xori,TRIV,n, m, Ik, Ih, Ik_k, Ih_k, Tpi, Txi, Tni, iM, Windices, Ael, Bary] = mesh\n\n dtype='float32'\n if(Xori.dtype=='float64'):\n dtype='float64'\n if(Xori.dtype=='float16'):\n dtype='float16'\n print(dtype)\n graph = lambda: None\n \n #model the shape deformation as a displacement vector field\n dX = tf.Variable((0*Xori).astype(dtype) );\n scaleX = tf.Variable(1,dtype=dtype); #not used in shape alignment\n \n graph.input_X = tf.placeholder(shape=dX.shape,dtype=dtype);\n graph.assign_X = tf.assign(dX, graph.input_X-Xori*scaleX).op;\n \n graph.X=Xori*scaleX+dX;\n \n Lx,S,L,Ak = tf_calc_lap(mesh,graph.X)\n\n #Normalized Laplacian\n Si = tf.diag(tf.sqrt(1/S[:,0]))\n Lap = tf.matmul(Si,tf.matmul(Lx,Si));\n\n \n #Spectral decomposition approach\n [s_,v] = tf.self_adjoint_eig( Lap )\n graph.cost_evals_f1 = 1e2*tf.nn.l2_loss( (s_[0:nevals]-evals[0:nevals])* (1/np.asarray(range(1,nevals+1),dtype)) )/nevals # \\\n \n \n #Approach avoiding spectral decomposition - NOT USED\n # [_,EigsOpt,lap] = tfeig(Lap)\n # v = tf.Variable(EigsOpt[:,0:nevals].astype(dtype) );\n # cost_evals_a = 1e3*tf.nn.l2_loss(tf.matmul(tf.transpose(v),v)-tf.eye(nevals,dtype=dtype));\n # cost_evals_b = 1e1*tf.nn.l2_loss( (tf.matmul(Lap,v) - tf.matmul(v,np.diag(evals[0:nevals]).astype(dtype))) )/nevals\n # graph.cost_evals_f2 = cost_evals_a + cost_evals_b\n \n \n meanA, varA = tf.nn.moments(Ak, axes=[0])\n meanL, varL = tf.nn.moments(L, axes=[0])\n\n graph.global_step = tf.Variable(step+1.0, name='global_step',trainable=False, dtype=dtype)\n graph.global_step_val = tf.placeholder(dtype)\n graph.set_global_step = tf.assign(graph.global_step, graph.global_step_val).op \n \n #regularizers decay factor\n cosine_decay = 0.5 * (1 + tf.cos(3.14 * tf.minimum(np.asarray(params.numsteps/2.0,dtype=dtype),graph.global_step) / (params.numsteps/2.0)))\n graph.decay= (1 - params.decay_target) * cosine_decay + params.decay_target\n \n if(params.smoothing=='displacement'): \n graph.vcL = params.curvature_reg*graph.decay * tf.nn.l2_loss( tf.matmul(Bary.astype(dtype),dX)[nfix:,:]);\n graph.vcW = params.smoothness_reg*graph.decay *tf.nn.l2_loss( tf.matmul(Lx,dX)[nfix:,:]) \n if(params.smoothing=='absolute'):\n graph.vcL = params.curvature_reg*graph.decay * tf.nn.l2_loss( tf.matmul(Bary.astype(dtype),S*graph.X)[nfix:,:]);\n graph.vcW = params.smoothness_reg**graph.decay *tf.nn.l2_loss( tf.matmul(Lx,graph.X)[nfix:,:]) \n \n #Volume compuation\n T1 = tf.gather(graph.X, TRIV[:,0])\n T2 = tf.gather(graph.X, TRIV[:,1])\n T3 = tf.gather(graph.X, TRIV[:,2])\n XP = tf.cross(T2-T1, T3-T2)\n T_C = (T1+T2+T3)/3\n graph.Volume = params.volume_reg*graph.decay*tf.reduce_sum(XP*T_C/2)/3\n\n\n #L2 regularizer on total displacement weighted by area elements\n graph.l2_reg = params.l2_reg*tf.nn.l2_loss(S*dX)\n\n \n graph.cost_spectral = graph.cost_evals_f1 + graph.vcW + graph.vcL - graph.Volume + graph.l2_reg\n\n optimizer = tf.train.AdamOptimizer(params.opt_step)\n \n #gradient clipping \n gvs = optimizer.compute_gradients(graph.cost_spectral)\n capped_gvs = [(tf.clip_by_value(grad, -0.0001, 0.0001), var) for grad, var in gvs if grad!=None]\n graph.train_op_spectral = optimizer.apply_gradients(capped_gvs, global_step=graph.global_step)\n\n [graph.s_,v] = tf.self_adjoint_eig( Lap ) \n return graph","def __init__(self, trap=2.5*10**16, Keq=1.0*10**17,\n EHdecay=1.0*10**-10, Etrap=2.0*10**-10, FHloss=8.0*10**-12,\n G3decay = 0, step=200*ps, pretime=2, reprate=80000000,\n verbose=False, trackQ=False, scalar=1, Gdecay=0, GHdecay=0,\n tolerance=0.005, G2decay=0. ,Gescape=1., Gform=1., G3loss=0.):\n # Some other variables used\n self.tolerance = tolerance\n self.scalar = scalar\n self.verbose = verbose\n self.reprate = reprate\n self.duration = 1.00 / reprate\n self.step = step\n self.steps = int(self.duration / self.step)\n self.powers = []\n self.pretime = pretime\n # Variables which hold state densities\n self.exciton = []\n self.hole = []\n self.electron = []\n self.trap = (trap) # Total number of traps\n self.filled = [] # Filled traps\n self.signal = []\n self.xsignal = []\n self.ehsignal = []\n self.xloss = []\n self.tloss = []\n self.pulses = []\n self.qk = []\n self.trackQ = trackQ\n # Rate and equilibrium constants, corrected for time step size\n self.Keq = Gescape/Gform # Equilibrium constant for X<-->e+h\n self.EHdecay = (EHdecay * step) # e+h->ground\n self.Etrap = (Etrap * step) # e+trap->filled\n self.FHloss = (FHloss * step) # filled+h->ground\n self.Gdecay = Gdecay * step\n self.G2decay = G2decay * step\n self.G3decay = G3decay * step\n self.GHdecay = GHdecay * step\n self.Gescape = Gescape * step\n self.G3loss = G3loss * step\n self.Gform = Gform * step","def build_linear_system(u, dt, dx, D = 3, P = 3,time_diff = 'poly',space_diff = 'poly',lam_t = None,lam_x = None, width_x = None,width_t = None, deg_x = 5,deg_t = None,sigma = 2):\n\n n, m = u.shape\n\n if width_x == None: width_x = n/10\n if width_t == None: width_t = m/10\n if deg_t == None: deg_t = deg_x\n\n # If we're using polynomials to take derviatives, then we toss the data around the edges.\n if time_diff == 'poly': \n m2 = m-2*width_t\n offset_t = width_t\n else: \n m2 = m\n offset_t = 0\n if space_diff == 'poly': \n n2 = n-2*width_x\n offset_x = width_x\n else: \n n2 = n\n offset_x = 0\n\n if lam_t == None: lam_t = 1.0/m\n if lam_x == None: lam_x = 1.0/n\n\n ########################\n # First take the time derivaitve for the left hand side of the equation\n ########################\n ut = np.zeros((n2,m2), dtype=u.dtype)\n\n if time_diff == 'FDconv':\n Usmooth = np.zeros((n,m), dtype=u.dtype)\n # Smooth across x cross-sections\n for j in range(m):\n Usmooth[:,j] = ConvSmoother(u[:,j],width_t,sigma)\n # Now take finite differences\n for i in range(n2):\n ut[i,:] = FiniteDiff(Usmooth[i + offset_x,:],dt,1)\n\n elif time_diff == 'poly':\n T= np.linspace(0,(m-1)*dt,m)\n for i in range(n2):\n ut[i,:] = PolyDiff(u[i+offset_x,:],T,diff=1,width=width_t,deg=deg_t)[:,0]\n\n elif time_diff == 'Tik':\n for i in range(n2):\n ut[i,:] = TikhonovDiff(u[i + offset_x,:], dt, lam_t)\n\n else:\n for i in range(n2):\n ut[i,:] = FiniteDiff(u[i + offset_x,:],dt,1)\n \n ut = np.reshape(ut, (n2*m2,1), order='F')\n\n ########################\n # Now form the rhs one column at a time, and record what each one is\n ########################\n\n u2 = u[offset_x:n-offset_x,offset_t:m-offset_t]\n Theta = np.zeros((n2*m2, (D+1)*(P+1)), dtype=u.dtype)\n ux = np.zeros((n2,m2), dtype=u.dtype)\n rhs_description = ['' for i in range((D+1)*(P+1))]\n\n if space_diff == 'poly': \n Du = {}\n for i in range(m2):\n Du[i] = PolyDiff(u[:,i+offset_t],np.linspace(0,(n-1)*dx,n),diff=D,width=width_x,deg=deg_x)\n if space_diff == 'Fourier': ik = 2*np.pi*1j*np.fft.fftfreq(n, d = dx)\n \n for d in range(D+1):\n\n if d > 0:\n for i in range(m2):\n if space_diff == 'Tik': ux[:,i] = TikhonovDiff(u[:,i+offset_t], dx, lam_x, d=d)\n elif space_diff == 'FDconv':\n Usmooth = ConvSmoother(u[:,i+offset_t],width_x,sigma)\n ux[:,i] = FiniteDiff(Usmooth,dx,d)\n elif space_diff == 'FD': ux[:,i] = FiniteDiff(u[:,i+offset_t],dx,d)\n elif space_diff == 'poly': ux[:,i] = Du[i][:,d-1]\n elif space_diff == 'Fourier': ux[:,i] = np.fft.ifft(ik**d*np.fft.fft(u[:,i]))\n else: ux = np.ones((n2,m2), dtype=u.dtype) \n \n for p in range(P+1):\n Theta[:, d*(P+1)+p] = np.reshape(np.multiply(ux, np.power(u2,p)), (n2*m2), order='F')\n\n if p == 1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u'\n elif p>1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u^' + str(p)\n if d > 0: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+\\\n 'u_{' + ''.join(['x' for _ in range(d)]) + '}'\n\n return ut, Theta, rhs_description","def process_graph(graph):\n init_globals()\n\n # If the graph contains integers this is triggered.\n # See the check_graph() function description for more information\n if type(graph.keys()[0]) == int:\n graph = check_graph(graph)\n\n \n balances = get_node_balances(graph)\n\n\n if is_eulerian(balances):\n splits = find_cycles(graph, sorted(graph.keys())[0])\n for node in splits:\n find_cycles(graph, node)\n\n print(\"graph is eulerian:\\n{}\\n\".format(\n \"->\".join(merge_cycles(cycles))))\n\n\n else:\n print(\"graph is not eulerian\")\n\n if has_eulerian_path(balances):\n print(\"graph has an eulerian path:\\n{}\\n\".format(\n \"->\".join(get_eulerian_path(graph, balances))))\n else:\n print(\"graph has no eulerian path\")","def ha(env, cstate=0):\n T1 = 10\n T2 = 10\n thM = 20\n thm = 5\n vr = 10.5\n v1 = -1.3\n v2 = -2.7\n assert(T1 == T2)\n\n delta = None # None to cause failure\n # The continous variables used in this ha\n x = T1 # clock1 variable\n y = T2 # clock2 variable\n th = 11.5 # The reactor temperature\n\n # You need vtol here, because of floating point error.\n loc0_ode_x = ODE(env, S.sympify('diff(x(t))'), S.sympify('1.0'),\n ttol=10**-3, iterations=100)\n loc0_ode_y = ODE(env, S.sympify('diff(y(t))'), S.sympify('1.0'),\n ttol=10**-3, iterations=100)\n loc0_ode_th = ODE(env, S.sympify('diff(th(t))'), S.sympify(vr),\n ttol=10**-3, iterations=100, vtol=10**-10)\n loc0_FT = False\n\n loc1_ode_x = ODE(env, S.sympify('diff(x(t))'), S.sympify('1.0'),\n ttol=10**-3, iterations=100)\n loc1_ode_y = ODE(env, S.sympify('diff(y(t))'), S.sympify('1.0'),\n ttol=10**-3, iterations=100)\n loc1_ode_th = ODE(env, S.sympify('diff(th(t))'), S.sympify(v1),\n ttol=10**-3, iterations=100, vtol=10**-10)\n loc1_FT = False\n\n loc2_ode_x = ODE(env, S.sympify('diff(x(t))'), S.sympify('1.0'),\n ttol=10**-3, iterations=100)\n loc2_ode_y = ODE(env, S.sympify('diff(y(t))'), S.sympify('1.0'),\n ttol=10**-3, iterations=100)\n loc2_ode_th = ODE(env, S.sympify('diff(th(t))'), S.sympify(v2),\n ttol=10**-3, iterations=100, vtol=10**-10)\n loc2_FT = False\n\n # Location 3 is reactor shutdown\n loc3_FT = False\n\n # Location 0\n def location0(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\n vals = {S.sympify('x(t)'): x,\n S.sympify('y(t)'): y,\n S.sympify('th(t)'): th}\n curr_time = env.now\n # The edge guard takes preference\n if th == thM and x >= T1:\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n return 1, 0, x, y, th, None, True, None, None, curr_time\n elif th == thM and y >= T2:\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n return 2, 0, x, y, th, None, None, True, None, curr_time\n elif th == thM and x < T1 and y < T2:\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n return 3, 0, x, y, th, None, None, None, True, curr_time\n # The invariant\n elif th <= thM:\n if not loc0_FT:\n x = loc0_ode_x.compute(vals, curr_time-prev_time)\n y = loc0_ode_y.compute(vals, curr_time-prev_time)\n th = loc0_ode_th.compute(vals, curr_time-prev_time)\n loc0_FT = True\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n if abs(th-thM) > loc0_ode_th.vtol:\n deltath = loc0_ode_th.delta(vals, quanta=(thM-th))\n else:\n th = thM\n deltath = 0\n return 0, deltath, x, y, th, False, None, None, None, curr_time\n else:\n # print('th:', th)\n raise RuntimeError('Reached unreachable branch'\n ' in location 0')\n\n def location1(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\n vals = {S.sympify('x(t)'): x,\n S.sympify('y(t)'): y,\n S.sympify('th(t)'): th}\n curr_time = env.now\n # The edge guard takes preference\n if th == thm:\n x = 0 # Reset\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n return 0, 0, x, y, th, True, None, None, None, curr_time\n # The invariant\n elif th >= thm:\n if not loc1_FT:\n x = loc1_ode_x.compute(vals, curr_time-prev_time)\n y = loc1_ode_y.compute(vals, curr_time-prev_time)\n th = loc1_ode_th.compute(vals, curr_time-prev_time)\n loc1_FT = True\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n if abs(th-thm) > loc1_ode_th.vtol:\n deltath = loc1_ode_th.delta(vals, quanta=(thm-th))\n else:\n th = thm\n deltath = 0\n return 1, deltath, x, y, th, False, None, None, None, curr_time\n else:\n raise RuntimeError('Reached unreachable branch'\n ' in location 1')\n\n def location2(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\n vals = {S.sympify('x(t)'): x,\n S.sympify('y(t)'): y,\n S.sympify('th(t)'): th}\n curr_time = env.now\n # The edge guard takes preference\n if th == thm:\n y = 0 # Reset\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n return 0, 0, x, y, th, True, None, None, None, curr_time\n # The invariant\n elif th >= thm:\n if not loc2_FT:\n x = loc2_ode_x.compute(vals, curr_time-prev_time)\n y = loc2_ode_y.compute(vals, curr_time-prev_time)\n th = loc2_ode_th.compute(vals, curr_time-prev_time)\n loc2_FT = True\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\n if abs(th-thm) > loc2_ode_th.vtol:\n deltath = loc2_ode_th.delta(vals, quanta=(thm-th))\n else:\n th = thm\n deltath = 0\n return 2, deltath, x, y, th, False, None, None, None, curr_time\n else:\n raise RuntimeError('Reached unreachable branch'\n ' in location 2')\n\n def location3(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\n global step\n # print('total steps: ', step)\n # Done\n print(time.time()-start)\n sys.exit(1)\n\n # The dictionary for the switch statement.\n switch_case = {\n 0: location0,\n 1: location1,\n 2: location2,\n 3: location3\n }\n\n prev_time = env.now\n while(True):\n (cstate, delta, x, y, th,\n loc0_FT, loc1_FT, loc2_FT, loc3_FT,\n prev_time) = switch_case[cstate](x, y, th,\n loc0_FT,\n loc1_FT,\n loc2_FT,\n loc3_FT,\n prev_time)\n # This should always be the final statement in this function\n global step\n step += 1\n yield env.timeout(delta)","def th_cell_diff(th_state, time, d):\n assert d[\"alpha_int\"] < d[\"alpha\"]\n \n # divide array into cell states\n tnaive = th_state[:d[\"alpha_int\"]]\n tint = th_state[d[\"alpha_int\"]:d[\"alpha\"]]\n teff = th_state[d[\"alpha\"]:]\n \n assert len(tnaive)+len(tint)+len(teff) == len(th_state)\n tnaive = np.sum(tnaive)\n tint = np.sum(tint)\n teff = np.sum(teff)\n \n # IL2 production\n il2_producers = tnaive+tint\n il2_consumers = teff+tint \n conc_il2 = d[\"rate_il2\"]*il2_producers/(d[\"K_il2\"]+il2_consumers)\n \n # IL7 production\n il7_consumers = il2_consumers\n conc_il7 = d[\"rate_il7\"] / (d[\"K_il2\"]+il7_consumers)\n \n # apply feedback on rate beta\n fb_ifn = 0\n if d[\"fb_ifn\"] != 0:\n conc_ifn = d[\"rate_ifn\"]*(il2_producers)\n fb_ifn = (d[\"fb_ifn\"]*conc_ifn**3)/(conc_ifn**3+d[\"K_ifn\"]**3)\n \n beta = (fb_ifn+1)*d[\"beta\"] \n beta_p = d[\"beta_p\"] \n rate_death = d[\"d_eff\"]\n\n # check homeostasis criteria\n if d[\"crit\"] == False:\n update_t0(d, time, conc_il2, conc_il7)\n elif d[\"death_mode\"] == False:\n beta_p = beta_p*np.exp(-d[\"decay_p\"]*(time-d[\"t0\"]))\n else:\n rate_death = rate_death*np.exp(0.1*(time-d[\"t0\"]))\n \n # differentiation \n dt_state = diff_effector_new(th_state, teff, d, beta, rate_death, beta_p)\n \n \n return dt_state","def two_temps(L, n_cycles, temp):\n\n E = np.zeros((2, len(temp), n_cycles))\n Mag = np.zeros((2, len(temp), n_cycles))\n MagAbs = np.zeros((2, len(temp), n_cycles))\n SH = np.zeros((2, len(temp), n_cycles))\n Suscept = np.zeros((2, len(temp), n_cycles))\n\n Naccept = np.zeros((2, len(temp), n_cycles))\n\n ground_spin_mat = np.ones((L, L), np.int8) # initial state (ground state)\n\n for m in range(2):\n for t in range(len(temp)):\n\n #m=0 is ground state, all spin-up\n #m=1 is random state\n if m==0:\n spin_matrix = ground_spin_mat\n else:\n s_mat_random = np.ones((L, L), np.int8) # spin matrix of ones\n #random indices switched to -1\n for sw in range(len(s_mat_random)):\n for sl in range(len(s_mat_random)):\n rint = np.random.randint(-1,1)\n if rint == -1:\n s_mat_random[sw,sl] *= -1\n spin_matrix = s_mat_random\n\n\n print(\"hi\")#; sys.exit(1)\n Energy, Magnetization, MagnetizationAbs, SpecificHeat, Susceptibility, Nacc \\\n = numerical_solution(spin_matrix, n_cycles, temp[t], L, abs=False)\n\n\n E[m,t,:] = Energy\n Mag[m,t,:] = Magnetization\n MagAbs[m,t,:] = MagnetizationAbs\n SH[m,t,:] = SpecificHeat\n Suscept[m,t,:] = Susceptibility\n\n Naccept[m,t,:] = Nacc\n\n return E, Mag, MagAbs, SH, Suscept, Naccept","def main(graph=None, model=None):\n\n mjd = [57433.4816, 57436.4815, 57439.4817, 57451.4604, 57454.4397, 57459.3963, 57462.418, 57465.4385, 57468.3768,\n 57473.3606, 57487.3364, 57490.3341, 57493.3154, 57496.3352, 57505.3144, 57513.2542, 57532.2717, 57536.2531,\n 57543.2545, 57546.2703, 57551.2115, 57555.2669, 57558.2769, 57561.1899, 57573.2133, 57433.5019, 57436.4609,\n 57439.4587, 57444.4357, 57459.4189, 57468.3142, 57476.355, 57479.3568, 57487.3586, 57490.3562, 57493.3352,\n 57496.2949, 57505.3557, 57509.2932, 57513.2934, 57518.2735, 57521.2739, 57536.2321, 57539.2115, 57543.2301,\n 57551.1701, 57555.2107, 57558.191, 57573.1923, 57576.1749, 57586.1854]\n flux = [2.0357230e+00, -2.0382695e+00, 1.0084588e+02, 5.5482742e+01, 1.4867026e+01, -6.5136810e+01, 1.6740545e+01,\n -5.7269131e+01, 1.0649184e+02, 1.5505235e+02, 3.2445984e+02, 2.8735449e+02, 2.0898877e+02, 2.8958893e+02,\n 1.9793906e+02, -1.3370536e+01, -3.9001358e+01, 7.4040916e+01, -1.7343750e+00, 2.7844931e+01, 6.0861992e+01,\n 4.2057487e+01, 7.1565346e+01, -2.6085690e-01, -6.8435440e+01, 17.573107, 41.445435, -110.72664, 111.328964,\n -63.48336, 352.44907, 199.59058, 429.83075, 338.5255, 409.94604, 389.71262, 195.63905, 267.13318, 123.92461,\n 200.3431, 106.994514, 142.96387, 56.491238, 55.17521, 97.556946, -29.263103, 142.57687, -20.85057,\n -0.67210346, 63.353024, -40.02601]\n fluxerr = [42.784702, 43.83665, 99.98704, 45.26248, 43.040398, 44.00679, 41.856007, 49.354336, 105.86439, 114.0044,\n 45.697918, 44.15781, 60.574158, 93.08788, 66.04482, 44.26264, 91.525085, 42.768955, 43.228336, 44.178196,\n 62.15593, 109.270035, 174.49638, 72.6023, 48.021034, 44.86118, 48.659588, 100.97703, 148.94061, 44.98218,\n 139.11194, 71.4585, 47.766987, 45.77923, 45.610615, 60.50458, 105.11658, 71.41217, 43.945534, 45.154167,\n 43.84058, 52.93122, 44.722775, 44.250145, 43.95989, 68.101326, 127.122025, 124.1893, 49.952255, 54.50728,\n 114.91599]\n passband = ['g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g',\n 'g', 'g', 'g', 'g', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r',\n 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r']\n photflag = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4096, 4096, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4096,\n 6144, 4096, 4096, 4096, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\n objid = 'MSIP_01_NONIa-0001_10400862'\n ra = 3.75464531293933\n dec = 0.205076187109334\n redshift = 0.233557\n mwebv = 0.0228761\n\n light_curve_list = [(mjd, flux, fluxerr, passband, photflag, ra, dec, objid, redshift, mwebv)]\n\n classification = Classify(known_redshift=True)\n predictions, time_steps = classification.get_predictions(light_curve_list, return_predictions_at_obstime=False)\n print(predictions)\n\n # classification.plot_light_curves_and_classifications(step=False)\n # classification.plot_classification_animation()\n # classification.plot_classification_animation_step()\n\n predictions, time_steps = classification.get_predictions(light_curve_list, return_predictions_at_obstime=True)\n\n if predictions is not None:\n import matplotlib.pyplot as plt\n for i, class_name in enumerate(classification.class_names):\n plt.plot(time_steps[0], predictions[0][:, i], label=class_name)\n plt.legend()\n plt.show()","def leapfrog(params, momentum, log_prob_func, steps=10, step_size=0.1, jitter=0.01, normalizing_const=1., softabs_const=1e6, explicit_binding_const=100, fixed_point_threshold=1e-20, fixed_point_max_iterations=6, jitter_max_tries=10, inv_mass=None, ham_func=None, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, store_on_GPU = True, debug=False, pass_grad = None):\n\n params = params.clone(); momentum = momentum.clone()\n # TodO detach graph when storing ret_params for memory saving\n if sampler == Sampler.HMC and integrator != Integrator.SPLITTING and integrator != Integrator.SPLITTING_RAND and integrator != Integrator.SPLITTING_KMID:\n def params_grad(p):\n p = p.detach().requires_grad_()\n log_prob = log_prob_func(p)\n # log_prob.backward()\n p = collect_gradients(log_prob, p, pass_grad)\n # print(p.grad.std())\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n return p.grad\n ret_params = []\n ret_momenta = []\n momentum += 0.5 * step_size * params_grad(params)\n for n in range(steps):\n if inv_mass is None:\n params = params + step_size * momentum #/normalizing_const\n else:\n #Assum G is diag here so 1/Mass = G inverse\n if type(inv_mass) is list:\n i = 0\n for block in inv_mass:\n it = block[0].shape[0]\n params[i:it+i] = params[i:it+i] + step_size * torch.matmul(block,momentum[i:it+i].view(-1,1)).view(-1) #/normalizing_const\n i += it\n elif len(inv_mass.shape) == 2:\n params = params + step_size * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params = params + step_size * inv_mass * momentum #/normalizing_const\n p_grad = params_grad(params)\n momentum += step_size * p_grad\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n # only need last for Hamiltoninian check (see p.14) https://arxiv.org/pdf/1206.1901.pdf\n ret_momenta[-1] = ret_momenta[-1] - 0.5 * step_size * p_grad.clone()\n # import pdb; pdb.set_trace()\n return ret_params, ret_momenta\n elif sampler == Sampler.RMHMC and (integrator == Integrator.IMPLICIT or integrator == Integrator.S3):\n if integrator is not Integrator.S3:\n ham_func = None\n # Else we are doing semi sep and need auxiliary for Riemann version.\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\n\n def fixed_point_momentum(params, momentum):\n momentum_old = momentum.clone()\n # print('s')\n for i in range(fixed_point_max_iterations):\n momentum_prev = momentum.clone()\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n # import pdb; pdb.set_trace()\n raise util.LogProbError()\n # import pdb; pdb.set_trace()\n # break\n\n momentum = momentum_old - 0.5 * step_size * params.grad\n momenta_diff = torch.max((momentum_prev-momentum)**2)\n if momenta_diff < fixed_point_threshold:\n break\n if debug == 1:\n print('Converged (momentum), iterations: {}, momenta_diff: {}'.format(i, momenta_diff))\n return momentum\n\n def fixed_point_params(params, momentum):\n params_old = params.clone()\n momentum = momentum.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n momentum = collect_gradients(ham,momentum)\n momentum_grad_old = momentum.grad.clone()\n for i in range(fixed_point_max_iterations):\n params_prev = params.clone()\n momentum = momentum.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n momentum = collect_gradients(ham,momentum)#collect_gradients(ham, params)\n params = params_old + 0.5 * step_size * momentum.grad + 0.5 * step_size * momentum_grad_old\n params_diff = torch.max((params_prev-params)**2)\n if params_diff < fixed_point_threshold:\n break\n if debug == 1:\n print('Converged (params), iterations: {}, params_diff: {}'.format(i, params_diff))\n return params\n ret_params = []\n ret_momenta = []\n for n in range(steps):\n # import pdb; pdb.set_trace()\n momentum = fixed_point_momentum(params, momentum)\n params = fixed_point_params(params, momentum)\n\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n raise util.LogProbError()\n # break\n momentum -= 0.5 * step_size * params.grad\n\n ret_params.append(params)\n ret_momenta.append(momentum)\n return ret_params, ret_momenta\n\n elif sampler == Sampler.RMHMC and integrator == Integrator.EXPLICIT:\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\n\n #During leapfrog define integrator as implict when passing into riemannian_hamiltonian\n leapfrog_hamiltonian_flag = Integrator.IMPLICIT\n def hamAB_grad_params(params,momentum):\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n params = collect_gradients(ham, params)\n\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\n tries = 0\n while util.has_nan_or_inf(params.grad):\n # import pdb; pdb.set_trace()\n params = params.detach().requires_grad_()\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n params = collect_gradients(ham, params)\n tries += 1\n if tries > jitter_max_tries:\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\n raise util.LogProbError()\n # import pdb; pdb.set_trace()\n # break\n\n return params.grad\n def hamAB_grad_momentum(params,momentum):\n momentum = momentum.detach().requires_grad_()\n params = params.detach().requires_grad_()\n # Can't detach p as we still need grad to do derivatives\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\n # import pdb; pdb.set_trace()\n momentum = collect_gradients(ham,momentum)\n return momentum.grad\n ret_params = []\n ret_momenta = []\n params_copy = params.clone()\n momentum_copy = momentum.clone()\n for n in range(steps):\n # \\phi_{H_A}\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\n # \\phi_{H_B}\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\n # \\phi_{H_C}\n c = torch.cos(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\n s = torch.sin(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\n # params_add = params + params_copy\n # params_sub = params - params_copy\n # momentum_add = momentum + momentum_copy\n # momentum_sub = momentum - momentum_copy\n # ### CHECK IF THE VALUES ON THE RIGHT NEED TO BE THE OLD OR UPDATED ones\n # ### INSTINCT IS THAT USING UPDATED ONES IS BETTER\n # params = 0.5 * ((params_add) + c*(params_sub) + s*(momentum_sub))\n # momentum = 0.5 * ((momentum_add) - s*(params_sub) + c*(momentum_sub))\n # params_copy = 0.5 * ((params_add) - c*(params_sub) - s*(momentum_sub))\n # momentum_copy = 0.5 * ((momentum_add) + s*(params_sub) - c*(momentum_sub))\n params = 0.5 * ((params+params_copy) + c*(params-params_copy) + s*(momentum-momentum_copy))\n momentum = 0.5 * ((momentum+momentum_copy) - s*(params-params_copy) + c*(momentum-momentum_copy))\n params_copy = 0.5 * ((params+params_copy) - c*(params-params_copy) - s*(momentum-momentum_copy))\n momentum_copy = 0.5 * ((momentum+momentum_copy) + s*(params-params_copy) - c*(momentum-momentum_copy))\n\n\n # \\phi_{H_B}\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\n # \\phi_{H_A}\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n return [ret_params,params_copy], [ret_momenta, momentum_copy]\n\n # PAGE 35 MCMC Using Hamiltonian dynamics (Neal 2011)\n elif sampler == Sampler.HMC and (integrator == Integrator.SPLITTING or integrator == Integrator.SPLITTING_RAND or Integrator.SPLITTING_KMID):\n if type(log_prob_func) is not list:\n raise RuntimeError('For splitting log_prob_func must be list of functions')\n if pass_grad is not None:\n raise RuntimeError('Passing user-determined gradients not implemented for splitting')\n\n def params_grad(p,log_prob_func):\n # OLD:\n # p = p.detach().requires_grad_()\n # log_prob = log_prob_func(p)\n # # log_prob.backward()\n # p = collect_gradients(log_prob, p)\n # grad = p.grad\n # # For removing GPU memory for large data sets.\n # del p, log_prob\n # torch.cuda.empty_cache()\n\n p = p.detach().requires_grad_()\n log_prob = log_prob_func(p)\n # Need to check memory issues in collect_gradients\n grad = torch.autograd.grad(log_prob,p)[0]\n # For removing GPU memory for large data sets.\n del p, log_prob, log_prob_func\n torch.cuda.empty_cache()\n return grad\n\n params = params.detach() # Detach as we do not need to remember graph until we pass into log_prob\n ret_params = []\n ret_momenta = []\n if integrator == Integrator.SPLITTING:\n M = len(log_prob_func)\n K_div = (M - 1) * 2\n if M == 1:\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\n for n in range(steps):\n # Symmetric loop to ensure reversible\n for m in range(M):\n # print('p ',n)\n grad = params_grad(params,log_prob_func[m])\n with torch.no_grad():\n momentum += 0.5 * step_size * grad\n del grad\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n if m < M-1:\n # print('q ',n)\n if inv_mass is None:\n params += (step_size/K_div) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\n for m in reversed(range(M)):\n # print('p ', n )\n grad = params_grad(params,log_prob_func[m])\n with torch.no_grad():\n momentum += 0.5 * step_size * grad\n del grad\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n if m > 0:\n # print('q ', n-1)\n if inv_mass is None:\n params += (step_size/K_div) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\n\n if store_on_GPU:\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n else:\n ret_params.append(params.clone().cpu())\n ret_momenta.append(momentum.clone().cpu())\n elif integrator == Integrator.SPLITTING_RAND:\n M = len(log_prob_func)\n idx = torch.randperm(M)\n for n in range(steps):\n # \"Labelling of subsets is randomised for each iteration\"\n # idx = torch.randperm(M)\n for m in range(M):\n # print('p ',n)\n momentum += 0.5 * step_size * params_grad(params, log_prob_func[idx[m]])\n # print('q ',n)\n if inv_mass is None:\n params += (step_size/M) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params += (step_size/M) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params += (step_size/M) * inv_mass * momentum #/normalizing_const\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[idx[m]])\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n # import pdb; pdb.set_trace()\n\n\n elif integrator == Integrator.SPLITTING_KMID:\n M = len(log_prob_func)\n if M == 1:\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\n for n in range(steps):\n # Symmetric loop to ensure reversible\n for m in range(M):\n # print('p ',n)\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\n\n if inv_mass is None:\n params = params + (step_size) * momentum #/normalizing_const\n else:\n if type(inv_mass) is list:\n pass\n #Assum G is diag here so 1/Mass = G inverse\n elif len(inv_mass.shape) == 2:\n params = params + (step_size) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\n else:\n params = params + (step_size) * inv_mass * momentum #/normalizing_const\n\n for m in reversed(range(M)):\n # print('p ', n )\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\n\n ret_params.append(params.clone())\n ret_momenta.append(momentum.clone())\n\n return ret_params, ret_momenta\n\n else:\n raise NotImplementedError()","def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\n\n if action == 'UP':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.0 #DOWN\n elif action == 'LEFT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.0 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'RIGHT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'DOWN':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.0 # UP\n state_probabilities[row, col - 1] = 0.33 # LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 # DOWN\n\n for row in range (0, tot_row+1):\n if state_probabilities[row, 0] != 0:\n state_probabilities[row, 1] += state_probabilities[row, 0]\n elif state_probabilities[row, -1] != 0:\n state_probabilities[row, -2] += state_probabilities[row, -1]\n\n for col in range (0, tot_col+1):\n if state_probabilities[0, col] != 0:\n state_probabilities[1, col] += state_probabilities[0, col]\n elif state_probabilities[-1, col] != 0:\n state_probabilities[-2, col] += state_probabilities[-1, col]\n\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]","def get_transition(self, row, col, action, tot_row, tot_col):\n\n '''\n Expand the grid of the environment to handle when the \n agent decides to move in the direction of a wall \n '''\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\n\n if action == 'UP':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.0 #DOWN\n elif action == 'LEFT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\n state_probabilities[row, col + 1] = 0.0 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'RIGHT':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.33 #UP\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 #DOWN\n elif action == 'DOWN':\n row += 1\n col += 1\n state_probabilities[row - 1, col] = 0.0 # UP\n state_probabilities[row, col - 1] = 0.33 # LEFT\n state_probabilities[row, col + 1] = 0.33 # RIGHT\n state_probabilities[row + 1, col] = 0.33 # DOWN\n\n for row in range (0, tot_row+1):\n if state_probabilities[row, 0] != 0:\n state_probabilities[row, 1] += state_probabilities[row, 0]\n elif state_probabilities[row, -1] != 0:\n state_probabilities[row, -2] += state_probabilities[row, -1]\n\n for col in range (0, tot_col+1):\n if state_probabilities[0, col] != 0:\n state_probabilities[1, col] += state_probabilities[0, col]\n elif state_probabilities[-1, col] != 0:\n state_probabilities[-2, col] += state_probabilities[-1, col]\n\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]","def __init__(self,numagents,bits,in_nodes,print_flag=False):\n self.numagents = numagents\n self.agent = []\n self.in_bits = in_nodes\n\n \"\"\" initialize empty dict for trajectories\"\"\"\n self.trajectories={}\n self.accepted_changes = 0\n self.learning_rate = numpy.zeros((3,1),dtype=int)\n\n \"\"\" initialize network topology \"\"\"\n self.adjacency = numpy.zeros((numagents,numagents),dtype=int)\n\n\n # Erdös Renyi network; symmetric G(n,p) with p=0.5;\n # if p > ln(n)/n graph is almost surely connected\n \n p0=0.75\n for ia1 in range(self.numagents):\n for ia2 in range(ia1+1,self.numagents):\n if ia1 < 3 and ia2 < 3: self.adjacency[ia1,ia2] = 1 #fully connected in_nodes\n else:\n pER = numpy.random.random()\n if pER <= p0: self.adjacency[ia1,ia2] = 1\n self.adjacency[ia2,ia1] = self.adjacency[ia1,ia2] #symmetrize\n\n\n\n \"\"\"#complete graph (dense)\n for ia1 in range(self.numagents):\n for ia2 in range(ia1+1,self.numagents):\n self.adjacency[ia1,ia2] = 1\n self.adjacency[ia2,ia1] = 1\n \"\"\"\n\n\n \"\"\"\n #4-lattice\n for ia in range(self.numagents):\n if ia > 1 and ia < self.numagents-2:\n ia1 = ia + 1\n ia2 = ia + 2\n ia3 = ia - 1\n ia4 = ia - 2\n\n elif ia == 0:\n ia1 = ia + 1\n ia2 = ia + 2\n ia3 = self.numagents-1\n ia4 = self.numagents-2\n\n elif ia == 1:\n ia1 = ia + 1\n ia2 = ia + 2\n ia3 = ia - 1\n ia4 = self.numagents-1\n\n elif ia == self.numagents-2:\n ia1 = ia + 1\n ia2 = 0\n ia3 = ia - 1\n ia4 = ia - 2\n elif ia == self.numagents-1:\n ia1 = 0\n ia2 = 1\n ia3 = ia- 1\n ia4 = ia -2\n\n self.adjacency[ia,ia1] = 1\n self.adjacency[ia1,ia] = 1\n self.adjacency[ia,ia2] = 1\n self.adjacency[ia2,ia] = 1\n self.adjacency[ia,ia3] = 1\n self.adjacency[ia3,ia] = 1\n self.adjacency[ia, ia4] = 1\n self.adjacency[ia4, ia] = 1\n \"\"\"\n\n \n #SF-network, BA(m=1)\n \"\"\"\n m=1\n main_graph = networkx.barabasi_albert_graph(self.numagents, m)\n self.adjacency = networkx.to_numpy_array(main_graph)\n \"\"\"\n\n # density is number of edges/number of possible edges\n self.graph_density = numpy.sum(self.adjacency)/(self.numagents*(self.numagents-1) )\n\n\n \"\"\" initialize agents: \"\"\"\n iagents = range(self.in_bits)\n majority = True\n for ia in range(self.numagents):\n nbh = 3 #ALT: take mean neighborhood from graph; nbh = global_functions.dict_from_adj(self.adjacency)\n mu1 = numpy.random.randint(1, nbh + 1) # int(thresh)\n mu2 = numpy.random.randint(mu1, nbh + 1) #\n if ia in iagents: i = True\n else: i = False\n self.agent.append(agent(ia,ia,bits,nbh,i,mu1,mu2,majority=majority)) #initialize with majority rule\n #print(ia,self.agent[ia].rule)\n\n if print_flag:\n adj_dict = global_functions.dict_from_adj(self.adjacency)\n numagents = 0\n for ia in range(len(self.adjacency)):\n if numpy.sum(self.adjacency[ia]) != 0 or numpy.sum(self.adjacency[:, ia]) != 0: numagents += 1\n print(\"Initialize network with\", self.numagents, \"agents on a graph with\"\n , len(adj_dict), \"edges and density of\", numpy.around(self.graph_density,2))\n print(\"Input agents:\", iagents)\n print(\"Average degree:\", numpy.around(numpy.sum(self.adjacency)/self.numagents,2))\n\n if self.numagents <= 12:\n for l in self.adjacency: print(l)\n else:\n for key in adj_dict: print(key,\"->\",adj_dict[key])\n\n print(\"Perceptual rule of type:\")\n if majority: print(\"majority rule: x -> 1: if sum(input) >= out_degree/2\")\n else:\n print(\"x -> 1: if mu1 <= sum(input) <= mu2\")\n print(\"mu1 =\",[self.agent[ia].mu1 for ia in range(self.numagents)],\n \"mu2 =\",[self.agent[ia].mu2 for ia in range(self.numagents)])\n #for key in itertools.product({0, 1}, repeat = self.out_bits):\n # print(key, self.agent[0].update(key))\n print(\"Network successfully initialized\")","def run_viterbi(emission_scores, trans_scores, start_scores, end_scores):\r\n L = start_scores.shape[0]\r\n assert end_scores.shape[0] == L\r\n assert trans_scores.shape[0] == L\r\n assert trans_scores.shape[1] == L\r\n assert emission_scores.shape[1] == L\r\n N = emission_scores.shape[0]\r\n\r\n # SHAPES \r\n # N = 5, L = 3\r\n # emission_scores = (5,3), trans_scores = (3,3)\r\n # start_scores = (3,), end_scores = (3,)\r\n\r\n # Creating the transition DP matrix\r\n T = [[0 for _ in range(N)] for _ in range(L)]\r\n backpointers = [[0 for _ in range(N)] for _ in range(L)]\r\n\r\n # Filling the first column\r\n for row in range(L):\r\n T[row][0] = emission_scores[0][row] + start_scores[row] # emission_scores matrix is (N X L)\r\n \r\n # Filling the rest of the transition matrix\r\n for col in range(1, N):\r\n for row in range(L):\r\n prev_list = []\r\n for prev_label in range(L):\r\n prev_list.append(trans_scores[prev_label, row] + T[prev_label][col-1])\r\n T[row][col] = max(prev_list) + emission_scores[col][row] \r\n backpointers[row][col] = np.argmax(prev_list)\r\n\r\n # Filling the last column\r\n for row in range(L):\r\n T[row][N-1] += end_scores[row]\r\n\r\n # print for debug\r\n # print \"T\"\r\n # for i in T:\r\n # print i\r\n \r\n # print \r\n # print\r\n\r\n # print \"B\"\r\n # for i in backpointers:\r\n # print i\r\n\r\n # Finding max score in last column of T matrix\r\n T = np.array(T)\r\n score = np.asscalar(np.max(T[:,N-1]))\r\n location = np.asscalar(np.argmax(T[:,N-1]))\r\n\r\n # Getting best sequence from right to left using backpointers\r\n y = [location]\r\n for col in range(N-1, 0, -1):\r\n y.insert(0, backpointers[location][col])\r\n location = backpointers[location][col]\r\n\r\n '''\r\n y = []\r\n for i in xrange(N):\r\n # stupid sequence\r\n y.append(i % L)\r\n # score set to 0\r\n return (0.0, y)\r\n '''\r\n return (score, y)","def decode_MST(energies, lengths, leading_symbolic=0, labeled=True):\n\n def find_cycle(par):\n added = np.zeros([length], np.bool)\n added[0] = True\n cycle = set()\n findcycle = False\n for i in range(1, length):\n if findcycle:\n break\n\n if added[i] or not curr_nodes[i]:\n continue\n\n # init cycle\n tmp_cycle = set()\n tmp_cycle.add(i)\n added[i] = True\n findcycle = True\n l = i\n\n while par[l] not in tmp_cycle:\n l = par[l]\n if added[l]:\n findcycle = False\n break\n added[l] = True\n tmp_cycle.add(l)\n\n if findcycle:\n lorg = l\n cycle.add(lorg)\n l = par[lorg]\n while l != lorg:\n cycle.add(l)\n l = par[l]\n break\n\n return findcycle, cycle\n\n def chuLiuEdmonds():\n par = np.zeros([length], dtype=np.int32)\n # create best graph\n par[0] = -1\n for i in range(1, length):\n # only interested at current nodes\n if curr_nodes[i]:\n max_score = score_matrix[0, i]\n par[i] = 0\n for j in range(1, length):\n if j == i or not curr_nodes[j]:\n continue\n\n new_score = score_matrix[j, i]\n if new_score > max_score:\n max_score = new_score\n par[i] = j\n\n # find a cycle\n findcycle, cycle = find_cycle(par)\n # no cycles, get all edges and return them.\n if not findcycle:\n final_edges[0] = -1\n for i in range(1, length):\n if not curr_nodes[i]:\n continue\n\n pr = oldI[par[i], i]\n ch = oldO[par[i], i]\n final_edges[ch] = pr\n return\n\n cyc_len = len(cycle)\n cyc_weight = 0.0\n cyc_nodes = np.zeros([cyc_len], dtype=np.int32)\n id = 0\n for cyc_node in cycle:\n cyc_nodes[id] = cyc_node\n id += 1\n cyc_weight += score_matrix[par[cyc_node], cyc_node]\n\n rep = cyc_nodes[0]\n for i in range(length):\n if not curr_nodes[i] or i in cycle:\n continue\n\n max1 = float(\"-inf\")\n wh1 = -1\n max2 = float(\"-inf\")\n wh2 = -1\n\n for j in range(cyc_len):\n j1 = cyc_nodes[j]\n if score_matrix[j1, i] > max1:\n max1 = score_matrix[j1, i]\n wh1 = j1\n\n scr = cyc_weight + score_matrix[i, j1] - score_matrix[par[j1], j1]\n\n if scr > max2:\n max2 = scr\n wh2 = j1\n\n score_matrix[rep, i] = max1\n oldI[rep, i] = oldI[wh1, i]\n oldO[rep, i] = oldO[wh1, i]\n score_matrix[i, rep] = max2\n oldO[i, rep] = oldO[i, wh2]\n oldI[i, rep] = oldI[i, wh2]\n\n rep_cons = []\n for i in range(cyc_len):\n rep_cons.append(set())\n cyc_node = cyc_nodes[i]\n for cc in reps[cyc_node]:\n rep_cons[i].add(cc)\n\n for i in range(1, cyc_len):\n cyc_node = cyc_nodes[i]\n curr_nodes[cyc_node] = False\n for cc in reps[cyc_node]:\n reps[rep].add(cc)\n\n chuLiuEdmonds()\n\n # check each node in cycle, if one of its representatives is a key in the final_edges, it is the one.\n found = False\n wh = -1\n for i in range(cyc_len):\n for repc in rep_cons[i]:\n if repc in final_edges:\n wh = cyc_nodes[i]\n found = True\n break\n if found:\n break\n\n l = par[wh]\n while l != wh:\n ch = oldO[par[l], l]\n pr = oldI[par[l], l]\n final_edges[ch] = pr\n l = par[l]\n\n if labeled:\n assert energies.ndim == 4, 'dimension of energies is not equal to 4'\n else:\n assert energies.ndim == 3, 'dimension of energies is not equal to 3'\n input_shape = energies.shape\n batch_size = input_shape[0]\n max_length = input_shape[2]\n\n pars = np.zeros([batch_size, max_length], dtype=np.int32)\n arc_tags = np.zeros([batch_size, max_length], dtype=np.int32) if labeled else None\n for i in range(batch_size):\n energy = energies[i]\n\n # calc the real length of this instance\n length = lengths[i]\n\n # calc real energy matrix shape = [length, length, num_labels - #symbolic] (remove the label for symbolic arcs).\n if labeled:\n energy = energy[leading_symbolic:, :length, :length]\n # get best label for each edge.\n label_id_matrix = energy.argmax(axis=0) + leading_symbolic\n energy = energy.max(axis=0)\n else:\n energy = energy[:length, :length]\n label_id_matrix = None\n # get original score matrix\n orig_score_matrix = energy\n # initialize score matrix to original score matrix\n score_matrix = np.array(orig_score_matrix, copy=True)\n\n oldI = np.zeros([length, length], dtype=np.int32)\n oldO = np.zeros([length, length], dtype=np.int32)\n curr_nodes = np.zeros([length], dtype=np.bool)\n reps = []\n\n for s in range(length):\n orig_score_matrix[s, s] = 0.0\n score_matrix[s, s] = 0.0\n curr_nodes[s] = True\n reps.append(set())\n reps[s].add(s)\n for t in range(s + 1, length):\n oldI[s, t] = s\n oldO[s, t] = t\n\n oldI[t, s] = t\n oldO[t, s] = s\n\n final_edges = dict()\n chuLiuEdmonds()\n par = np.zeros([max_length], np.int32)\n if labeled:\n arc_tag = np.ones([max_length], np.int32)\n arc_tag[0] = 0\n else:\n arc_tag = None\n\n for ch, pr in final_edges.items():\n par[ch] = pr\n if labeled and ch != 0:\n arc_tag[ch] = label_id_matrix[pr, ch]\n\n par[0] = 0\n pars[i] = par\n if labeled:\n arc_tags[i] = arc_tag\n\n return pars, arc_tags","def simulation(G, # graph object\n pos = None, # positions of nodes\n n = 5, # number of simulation steps\n \n # wrapped args for simulation_step function\n kernel = 'weights', # simulation kernel\n custom_kernel = None, # custom simulation kernel\n WERE_multiplier = 10, # multiplier for WERE kernel\n oblivion = False, # enable information oblivion\n engagement_enforcement = 1.01,\n draw = False, # draw graph\n show_attr = False): # show attributes \n \n #=======================================#\n # append nodes data from 0 step to list #\n #=======================================#\n \n graph_list = []\n graph_list.append(copy.deepcopy(list(G.nodes.data() ) ) )\n \n\n #===================#\n # Run n simulations #\n #===================#\n \n for i in range(n):\n dp.simulation_step(G = G, \n pos = pos, \n \n kernel = kernel,\n custom_kernel = custom_kernel,\n WERE_multiplier = WERE_multiplier, \n oblivion = oblivion, \n engagement_enforcement = engagement_enforcement,\n draw = draw, \n show_attr = show_attr)\n\n # save nodes data to to list\n graph_list.append(copy.deepcopy(list(G.nodes.data() ) ) )\n \n \n #======================================================#\n # Count aware agents before and after simulation steps #\n #======================================================#\n \n # Check number of aware agents in 0 step\n #global aware_first\n aware_first = []\n for i in range(len(graph_list[0])):\n aware_first.append(graph_list[0][i][1]['state'])\n aware_first_c = aware_first.count('aware')\n \n # graph_list[0][1][1]['state']\n \n # Check number of aware agents in the last step\n #global aware_last\n aware_last = []\n graph_list_len = len(graph_list) - 1\n for i in range(len(graph_list[0])):\n aware_last.append(graph_list[graph_list_len][i][1]['state']) # n is the last sim\n aware_last_c = aware_last.count('aware')\n \n #graph_list[5][0][1]['state']\n \n #=================================#\n # diffusion performance measuring #\n #=================================#\n \n # equation for diffusion performance measuring\n avg_aware_inc_per_step = (aware_last_c - aware_first_c) / n\n \n # show graph statistics\n return graph_list, avg_aware_inc_per_step","def metropolis_hastings(states, n_steps, n_particles=100, beta=0.1):\n\n spin_change = [-1, 1]\n energy_output = np.zeros((n_steps, 2))\n\n n = 0\n for i in range(n_steps):\n\n n += 1\n\n # generate the random change variables\n random_particle = np.random.randint(n_particles)\n random_direction = np.random.randint(3)\n random_change = spin_change[np.random.randint(2)]\n\n # calculate the energy of the initial state\n E_i = E(states)\n # make copy of initial states to compare\n changed_states = states.copy()\n\n # change a random state\n changed_states[random_particle][random_direction] += random_change\n\n if changed_states[random_particle][random_direction] < 1:\n changed_states[random_particle][random_direction] = \\\n states[random_particle][random_direction]\n # n can't be less than 1, so go back to original state\n\n E_j = E(changed_states) # calculate the energy of the new states\n\n if E_j < E_i:\n # accept E_j value\n energy = E_j\n states = changed_states\n else:\n # calculate the probabilty for the transistion to happen\n prob_accept = np.exp(-1 * beta * (E_j - E_i))\n # pull random number and compare to prob_accept\n rand_num_accept = np.random.rand(1)\n if rand_num_accept <= prob_accept:\n # accept E_j\n energy = E_j\n states = changed_states\n else:\n # reject E_j\n energy = E_i\n\n energy_output[i][0], energy_output[i][1] = energy, n\n\n return energy_output","def sim(self, (K,T), (j0,x0), dt, rx, **params):\n dt0 = dt \n\n k = 0\n t = [0.]\n j = deepcopy(j0)\n x = [deepcopy(x0)]\n\n trj = dict(k=k,t=t,j=j,x=x)\n trjs = []\n\n while ( trj['t'][-1] <= T # don't exceed max continuous time\n and trj['k'] < K # don't exceed max discrete transitions\n and not trj['j'] is None ): # don't allow discrete state is None\n k0 = trj['k']\n t0 = trj['t'][-1]\n j0 = trj['j']\n x0 = trj['x'][-1]\n if 0: # forward Euler\n dx = self.F((k0,t0), (j0,x0), **params)\n else: # 4th-order Runge-Kutta \n f = lambda t,x : self.F((k0,t), (j0,x), **params)\n dx1 = f( t0, x0 ) * dt\n dx2 = f( t0+.5*dt, x0+.5*dx1 ) * dt\n dx3 = f( t0+.5*dt, x0+.5*dx2 ) * dt\n dx4 = f( t0+dt, x0+dx3 ) * dt\n dx = (1./6.)*( dx1 + 2*dx2 + 2*dx3 + dx4 ) / dt\n\n k = k0\n j = j0\n t = t0 + dt\n x = x0 + dt * dx\n g = self.G((k,t), (j,x), **params)\n\n # halve step size until trajectory doesn't violate guard more than rx\n i = 0\n imax = 50\n while np.any(g < -rx) and (i <= imax):\n dt = dt/2.\n t = t0 + dt\n x = x0 + dt * dx\n g = self.G((k,t), (j,x), **params)\n i += 1\n\n #if (i >= imax):\n # raise RuntimeError,'(sim) guard iterations exceeded -- you probably have a buggy guard'\n\n # append state to trj\n trj['t'].append(t)\n trj['x'].append(x)\n\n if 0 and 'debug' in params and params['debug']:\n print ' : (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s, dx = %s' % (k,t,j,x,dt,g,x,dx)\n\n # if in guard \n if np.any(g < 0):\n\n # spend time in guard\n if i >= imax:\n t = t + rx\n else:\n t = t + (rx + g.min())\n trj['t'].append(t)\n trj['x'].append(x)\n\n if 'debug' in params and params['debug']:\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\n\n # append trj to trjs\n trjs.append(trj)\n\n if 'Zeno' in params and params['Zeno'] and (len(trj['t']) <= 4):\n\n print '(sim) possible Zeno @ stepsize dt = %0.6f' % dt0\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\n return trjs\n\n # apply reset to modify trj\n (k,t),(j,x) = self.R((k,t), (j,x), **params)\n trj = dict(k=k,t=[t],j=j,x=[x])\n\n # re-initialize step size\n dt = dt0\n\n if 'debug' in params and params['debug']:\n g = self.G((k,t), (j,x), **params)\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\n\n trjs.append(trj)\n\n return trjs","def time_path_iteration(params=params, S=3, T=50, weight=0.3, tol=1e-12, maxiter=100):\n ss_output = get_SS()\n b_ss = ss_output['b_ss']\n b_init = np.array([0, 0.8 * b_ss[0], 1.1 * b_ss[1]]) # t=0\n\n # Guess transition path, finishes at steady_state\n Kguess = np.linspace(b_init.sum(), ss_output['K_ss'], T)\n\n s = 1\n K_dynamic = Kguess\n b_current = np.zeros((S,T)) # initialize array to store savings decisions\n b_current[:,0] = b_init\n\n # Update b_path until convergence\n its = 0\n ee_diff = 7.0\n while ee_diff > tol and its < maxiter:\n its += 1\n w_dynamic = find_w(L=params['labor_supply'].sum(), K=K_dynamic)\n r_dynamic = find_r(L=params['labor_supply'].sum(), K=K_dynamic)\n for t in range(T-2):\n\n #solve for b32, savings decision of middle-aged in first period\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_current[:,t], s, t)\n b_current[s+1,t+1] = opt.root(ee_err_1, 0, args=ee_param).x\n\n # solve for b22, b33, savings decision of young gen in middle/old generations\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_init, s, t)\n b_current[s,t+1], b_current[s+1, t+2]= opt.root(ee_err_23, [0,0], args=ee_param).x\n # fill in table\n b_current[s,T-1] = b_current[s,T-2]\n\n # Check for convergence\n K_prime = b_current.sum(axis=0)\n ee_diff = (K_prime - K_dynamic).max()\n\n# rc_diff = production(K_prime, L=params['labor_supply'].sum())\n# - Ct = (1 + r_dynamic) * ()\n# - np.roll(K_prime, len(K_prime)-1)\n# - (1 - delta) * K_prime\n\n print('Iteration number: ', its, 'Current EE difference: ', ee_diff)\n # update new capital path\n K_dynamic = weight * K_prime + (1-weight) * K_dynamic\n\n fig, ax = plt.subplots(1,1,figsize=(8,6))\n plt.plot(range(T), Kguess, 'r--',lw=0.7, label='Kguess')\n plt.plot(range(T), K_dynamic , label='Capital Path Solution')\n plt.title('Transition Path of Aggregate Capital')\n plt.xlabel('Time period')\n plt.ylabel('Aggregate Capital')\n plt.legend()\n\n fig, ax = plt.subplots(1,1,figsize=(8,6))\n plt.plot(range(T), r_dynamic, 'g-o',label='Interest rate Path Solution')\n plt.title('Transition Path of Aggregate Interest rate')\n plt.xlabel('Time period')\n plt.ylabel('Interest Rate')\n plt.legend()\n\n fig, ax = plt.subplots(1,1,figsize=(8,6))\n plt.plot(range(T), w_dynamic, 'k-o',label='Wage Path Solution')\n plt.title('Transition Path of Wages')\n plt.xlabel('Time period')\n plt.ylabel('Wages')\n plt.legend()\n\n return K_dynamic","def hEqn(g, e, h, f, Gescape, Gform, EHdecay, FHloss, stepsize):\n hchange = (g * Gescape\n - h * e * EHdecay\n - h * f * FHloss\n - e * h * Gform)\n return hchange * stepsize","def main(args):\n\n # Take the adjacency matrix of the graph\n adjacency_mat_graph = parse_adjacency_matrix_csv(args.i)\n\n # Check if the number of row == number of columns of the matrix\n logging.info(\"Checking the matrix shape...\")\n number_row_edges = len(adjacency_mat_graph)\n number_col_edges = len(adjacency_mat_graph[0])\n if number_row_edges != number_col_edges:\n raise ValueError(f\"The number of nodes detected in row\"\n f\"{number_row_edges} not equal to the \"\n f\"number of nodes found in column \"\n f\"{number_col_edges}.\")\n\n # check and verify if graph has only one root\n logging.info(\"Checking if graph has only one root and verify...\")\n root, number_root = unique_root_node_checking(adjacency_mat_graph)\n\n if root == \"NA\" and number_root == 0:\n raise ValueError(f\"No root node found in graph\")\n elif root == \"NA\" and number_root > 0:\n raise ValueError(\"More than one root node found in graph\")\n\n # check if identify root is the same as the one provided\n if root != \"NA\" and root != args.r:\n raise ValueError(f\"Expected {args.r} as root node but {root}\"\n f\" found in graph.\")\n\n # Convert adjacency matrix to dict representation for further steps\n logging.info(\"Converting matrix to dictionary graph...\")\n dict_graph = adjacency_matrix_to_dict_graph(adjacency_mat_graph)\n\n # Check if provided node is in the graph\n logging.info(\"Checking if node of interest n in graph...\")\n if args.n not in dict_graph:\n raise ValueError(f\"Provided node of interest {args.n} \"\n f\"is not found in the provided graph.\")\n\n # Check if the provided graph is acyclic\n logging.info(\"Checking if graph is acyclic...\")\n is_cyclic = is_cyclic_graph(dict_graph)\n if is_cyclic:\n raise ValueError(\"The provided graph is not acyclic. \"\n \"At least one cycle was detected in graph.\")\n logging.info(\"THE PROVIDED GRAPH IS DAG !!!\")\n\n # Get depth\n logging.info(f\"Getting the depth of node {args.n}...\")\n path, depth = get_node_depth(dict_graph, args.r, args.n, [])\n assert len(path) -1 == depth, f\"Length path {path} != depth {depth}\"\n logging.info(f\"The depth of node {args.n} is equal to {depth}\")","def astar(model, start, end):\n\n # Create start and end node\n start_node = Node(None,0.0, start)\n start_node.g = 0\n start_node.h = calculate_h(start_node,end)\n start_node.f = start_node.g + start_node.h \n \n end_node = Node(None,0.0, end)\n end_node.g = end_node.h = end_node.f = 0\n\n # Initialize both open and closed list\n open_list = []\n closed_list = []\n\n # Add the start node\n open_list.append(start_node)\n\n\n\n iterations = 0\n # Loop until you find the end\n while len(open_list) > 0:\n iterations += 1\n # print(iterations)\n print('openlist={},closed_list={}'.format(len(open_list),len(closed_list)))\n\n # Get the current node\n current_node = open_list[0]\n current_index = 0\n for index, item in enumerate(open_list):\n if item.f < current_node.f:\n current_node = item\n current_index = index\n\n # Pop current off open list, add to closed list\n open_list.pop(current_index)\n closed_list.append(current_node)\n\n print('currentstate={}, parentaction={}, f={}'.format(current_node.state, current_node.parent_action, current_node.f))\n\n # run_sim(current_node.parent_action)\n\n # Found the goal\n if current_node == end_node: \n actions = []\t\n current = current_node\n while current is not None:\n actions.append(current.parent_action)\n current = current.parent_state\n # print(current.state)\n return actions[::-1] # Return reversed path\n\n # Generate children states\n children = []\n\n for action in discretized_action: # all possible actions\n\n # Get new state node (closest to discretized state space)\n \n # new_state = get_next_state_from_model(model,current_node,action)\n new_state = get_next_state_from_eqn(current_node,action)\n # new_state = run_sim(action)\n # print(new_state)\n\n # # Make sure within range\n # if node_position[0] > (len(maze) - 1) or node_position[0] < 0 or node_position[1] > (len(maze[len(maze)-1]) -1) or node_position[1] < 0:\n # continue\n\n # # Make sure walkable terrain\n # if maze[node_position[0]][node_position[1]] != 0:\n # continue\n\n #############Make sure to wrap theta \n \n # Create new node\n new_node = Node(current_node, action, new_state)\n\n # Append\n children.append(new_node)\n\n # Loop through children\n for child in children:\n\n # Child is on the closed list\n for closed_child in closed_list:\n if child == closed_child:\t\n continue\n\n # Create the f, g, and h values\n child.g = calculate_g(child,current_node) #current_node.g + 1\n child.h = calculate_h(child,end_node)\n child.f = child.g + child.h\n \n # \tprint(child.state, child.parent_action, child.f) \n \n # Child is already in the open list\n for open_node in open_list:\n if child == open_node and child.g > open_node.g:\n continue\n\n # Add the child to the open list\n open_list.append(child)","def alpha_correction_ar(graph=line_graph(n=2), mode='hybrid', angle=np.pi/4, which='S', verbose=False):\n if which == 'S':\n index = 0\n elif which == 'L':\n index = graph.num_independent_sets - 1\n else:\n index = which\n\n energies = []\n bad_indices = []\n target_energy = graph.independent_sets[index][1]\n degeneracy = 0\n # Compute maximum independent set size and \"bad\" energies\n for IS in graph.independent_sets:\n if graph.independent_sets[IS][1] != target_energy:\n energies.append(graph.independent_sets[IS][1])\n bad_indices.append(IS)\n else:\n degeneracy += 1\n energies = np.array(energies)\n energies = np.abs(target_energy-energies)\n\n # Good is a list of good eigenvalues\n # Bad is a list of bad eigenvalues. If 'other', defaults to all remaining eigenvalues outside of 'good'\n def schedule_hybrid(t, tf):\n phi = (tf - t) / tf * np.pi / 2\n energy_shift.energies = (np.sin(2*((tf - t) / tf-1/2) * np.pi),)\n laser.omega_g = np.cos(phi)\n laser.omega_r = np.sin(phi)\n dissipation.omega_g = np.cos(phi)\n dissipation.omega_r = np.sin(phi)\n\n def schedule_reit(t, tf):\n phi = (tf - t) / tf * np.pi / 2\n laser.omega_g = np.cos(phi)\n laser.omega_r = np.sin(phi)\n dissipation.omega_g = np.cos(phi)\n dissipation.omega_r = np.sin(phi)\n\n def schedule_adiabatic(t, tf):\n phi = (tf - t) / tf * np.pi / 2\n energy_shift.energies = (np.sin(2*((tf - t) / tf-1/2) * np.pi),)\n laser.omega_g = np.cos(angle) * np.sin(phi) * np.cos(phi)\n laser.omega_r = np.sin(angle) * np.sin(phi) * np.cos(phi)\n dissipation.omega_g = np.cos(angle) * np.cos(phi) * np.sin(phi)\n dissipation.omega_r = np.sin(angle) * np.cos(phi) * np.sin(phi)\n\n laser = EffectiveOperatorHamiltonian(graph=graph, IS_subspace=True,\n energies=(1,),\n omega_g=np.cos(np.pi / 4),\n omega_r=np.sin(np.pi / 4))\n energy_shift = hamiltonian.HamiltonianEnergyShift(IS_subspace=True, graph=graph,\n energies=(2.5,), index=0)\n dissipation = EffectiveOperatorDissipation(graph=graph, omega_r=1, omega_g=1,\n rates=(1,))\n if mode == 'hybrid':\n schedule = schedule_hybrid\n elif mode == 'adiabatic':\n schedule = schedule_adiabatic\n elif mode == 'reit':\n schedule = schedule_reit\n if mode != 'reit':\n eq = SchrodingerEquation(hamiltonians=[laser, energy_shift])\n else:\n eq = SchrodingerEquation(hamiltonians=[laser])\n\n def compute_rate(t):\n if verbose:\n print(t)\n schedule(t, 1)\n # Construct the first order transition matrix\n eigval, eigvec = eq.eig(k='all')\n eigvec = eigvec.T\n rates = np.zeros(eigval.shape[0] ** 2)\n for op in dissipation.jump_operators:\n rates = rates + ((eigvec.conj().T @ op @ eigvec)**2).flatten()\n # Select the relevant rates from 'good' to 'bad'\n\n rates = np.reshape(rates.real, (graph.num_independent_sets, graph.num_independent_sets))\n bad_rates = np.zeros(len(bad_indices))\n for i in range(len(bad_indices)):\n bad_rates[i] = bad_rates[i] + rates[bad_indices[i], index]\n return np.dot(bad_rates, energies)\n\n # Integrate to find the correction\n res, error = scipy.integrate.quad_vec(compute_rate, 1e-5, .9999)\n return res/target_energy, error","def time_expand(graph, nodes, obstruction):\n time_steps = len(obstruction)\n exp_size = len(nodes)\n new_size = (time_steps+1)*exp_size\n expanded_graph = np.zeros((new_size,new_size))\n \n for i in range(time_steps):\n new_graph = np.copy(graph)\n tc = i*exp_size\n bc = tc + exp_size\n node_at_time_step = obstruction[i]\n new_graph[:,node_at_time_step] = 0 # remove \"to\"-columns from the graph\n new_graph[node_at_time_step,:] = 0 # remove \"from\"-rows from the graph\n expanded_graph[tc:bc, bc:bc+exp_size] = new_graph # Fill upper subdiagonal with A:s\n # Fill bottom-right corner of the expanded graph with the A\n # here the obstruction stops moving\n expanded_graph[new_size - exp_size:new_size,new_size - exp_size:new_size] = new_graph\n new_nodes = np.tile(nodes, ((time_steps+1),1))\n return expanded_graph, new_nodes","def J_E(h, integration_start_time=None):\n\n hdot = MTS(h).dot\n\n J_ℰ = 0.5 * 𝔇inverse(0.25 * (hdot * hdot.bar).int).ethbar.ethbar\n\n if integration_start_time is not None:\n integration_start_time_index = np.argmin(abs(h.t - integration_start_time))\n J_ℰ -= J_ℰ[integration_start_time_index, :]\n\n return J_ℰ","def rwgraph_analyze1(input=(None)):\r\n #generates graph\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n\r\n Nt=100\r\n M=20000\r\n #finds max degree of graph and stores list of degrees of nodes\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n #generates data and stores them in lists for varyin M and Nt\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes=[]\r\n for i in range(M):\r\n Listnodes.append(G.degree(X[i,Nt]))\r\n Nt=10000\r\n M=20000\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes2=[]\r\n for i in range(M):\r\n Listnodes2.append(G.degree(X[i,Nt]))\r\n Nt=10\r\n M=20000\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes3=[]\r\n for i in range(M):\r\n Listnodes3.append(G.degree(X[i,Nt]))\r\n Nt=10000\r\n M=200\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes4=[]\r\n for i in range(M):\r\n Listnodes4.append(G.degree(X[i,Nt]))\r\n fig, ax1 = plt.subplots(figsize =(14,7))\r\n\r\n ##### creates histo gram figure with 2 axis####\r\n ax1.hist([Listnodes,Listnodes2], bins=maxdeg, label=['Nt=100', 'Nt=10000'],color=['g','r'],alpha=0.6)\r\n ax1.set_xlabel('degree of node')\r\n ax1.set_ylabel('frequency of final position of random walks')\r\n\r\n ax1.tick_params(axis='y')\r\n ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\r\n\r\n ax2.hist([degree_dist], bins=maxdeg, label=['graph node frequency'],color=['b'],alpha=0.6)\r\n ax2.set_ylabel('frequency of node degrees for graph')\r\n ax2.tick_params(axis='y')\r\n\r\n ax1.legend(loc=\"center right\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n ax2.legend(loc=\"upper right\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title('M=20000, node degree of final position of random walk, for varying amounts of time', y=1.10, fontsize=20)\r\n fig.tight_layout() # otherwise the right y-label is slightly clipped\r\n plt.grid(b=None)\r\n plt.show()\r\n\r\n #function to generate diction of frequency\r\n def CountFrequency(my_list):\r\n\r\n # Creating an empty dictionary\r\n freq = {}\r\n for item in my_list:\r\n if (item in freq):\r\n freq[item] += 1\r\n else:\r\n freq[item] = 1\r\n return freq\r\n #converts data to approprate form so it can plotted on scatter plot\r\n #frequecy\r\n listfreq1=CountFrequency(Listnodes2)\r\n listfreq2=CountFrequency(Listnodes3)\r\n listfreq3=CountFrequency(Listnodes4)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n #set up lists\r\n z=[]\r\n z2=[]\r\n z3=[]\r\n z_deg=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n #code to create list of only degrees used in simulations\r\n for i in listfreq1:\r\n z.append(listfreq1[i]/(listfreq_deg[i]*20000))\r\n z_deg.append(i)\r\n for i in listfreq2:\r\n z2.append(listfreq2[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq3:\r\n z3.append(listfreq3[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n #extpected prob distribution\r\n E=G.number_of_edges()\r\n z0=[]\r\n z_deg0=[]\r\n for i in listfreq_deg:\r\n z0.append(i/(2*E))\r\n z_deg0.append(i)\r\n #genrates scatter plot figure\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(z_deg, z, label='Nt=10000, M=20000')\r\n plt.scatter(z_deg2, z2,label='Nt=10, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=10, M=200')\r\n plt.plot(z_deg0,z0,label=\"expected prob dist\",alpha=0.5)\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n return None #modify as needed\r","def objective(trial):\n %time\n env = gym.make('Delivery-v0')\n alpha = trial.suggest_discrete_uniform('alpha', 0.3,0.9,0.3)\n gamma = trial.suggest_discrete_uniform('gamma', 0.6, 1,0.1)\n epsilon = trial.suggest_discrete_uniform('epsilon', 0.01, 0.11, 0.04)\n episodes = 1000000\n \n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n if random.uniform(0, 1) < epsilon:\n action = env.action_space.sample() # Explore action space randomly\n else:\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n\n next_state, reward, done, info = env.step(action) \n\n old_value = q_table[state, action]\n next_max = np.max(q_table[next_state])\n\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\n q_table[state, action] = new_value\n\n if reward == -10:\n penalties += 1\n \n\n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n rewards.append(np.sum(episode_rewards))\n \n last_reward = np.mean(rewards)\n # trial.report(-1 * last_reward)\n\n return -1 * last_reward","def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\n\n # We check if parameters are all positive\n\n list_parameters = [t_upper, h, m1, m2, m3,\n a1, a2]\n\n for parameters in list_parameters:\n\n if parameters < 0:\n print(f'You have entered a negative parameter')\n\n # initial values for planet 1 in x, y and z direction\n x_i1 = a1\n y_i1 = 0\n v_x1i = 0\n v_y1i = 29779.301841746023\n z_i1 = 0\n v_z1i = 0\n\n # initial values for planet 2 in x, y and z direction\n x_i2 = a2\n y_i2 = 0\n v_x2i = 0\n v_y2i = 24154.203325249873\n z_i2 = 0\n v_z2i = 0\n\n # initial values for Sun in x, y and z direction\n x_i3 = 0\n y_i3 = 0\n v_x3i = 0\n v_y3i = 0\n z_i3 = 0\n v_z3i = 0\n\n# Initial positions and velocities\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\n\n # We create vectors which will contains the trajectories\n # and velocities of each bodies\n x_pnts1 = [x_i1]\n y_pnts1 = [y_i1]\n v_x_pnts1 = [v_x1i]\n v_y_pnts1 = [v_y1i]\n\n x_pnts2 = [x_i2]\n y_pnts2 = [y_i2]\n v_x_pnts2 = [v_x2i]\n v_y_pnts2 = [v_y2i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n x_pnts3 = [x_i3]\n y_pnts3 = [y_i3]\n v_x_pnts3 = [v_x3i]\n v_y_pnts3 = [v_y3i]\n\n z_pnts1 = [z_i1]\n z_pnts2 = [z_i2]\n z_pnts3 = [z_i3]\n\n v_z_pnts1 = [v_z1i]\n v_z_pnts2 = [v_z2i]\n v_z_pnts3 = [v_z3i]\n\n m1 = m1\n m2 = m2\n m3 = m3\n a1 = a1\n a2 = a2\n\n # We create a vector which will contain the time\n # Initial value\n t_i = 0.0\n t_values = [t_i]\n\n for t in range(0, t_upper, h):\n\n # We used the RK4 formula here\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\n a1=a1, a2=1.52*1.496e+11)\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\n a2=1.52*1.496e+11)\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\n\n # We calculate the new vector r\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\n\n # We add the new points calculated\n x_pnts1.append(r[0])\n y_pnts1.append(r[1])\n\n v_x_pnts1.append(r[2])\n v_y_pnts1.append(r[3])\n\n x_pnts2.append(r[4])\n y_pnts2.append(r[5])\n v_x_pnts2.append(r[6])\n v_y_pnts2.append(r[7])\n\n x_pnts3.append(r[8])\n y_pnts3.append(r[9])\n v_x_pnts3.append(r[10])\n v_y_pnts3.append(r[11])\n\n z_pnts1.append(r[12])\n z_pnts2.append(r[13])\n z_pnts3.append(r[14])\n\n v_z_pnts1.append(r[15])\n v_z_pnts2.append(r[16])\n v_z_pnts3.append(r[17])\n\n t_values.append(t)\n\n # We return all the trajectories\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3","def compute_eigvals(*params, **hyperparams):\n phi = params[0]\n d, t = hyperparams[\"dimension\"]\n\n if qml.math.get_interface(phi) == \"tensorflow\":\n phase = qml.math.exp(1j * qml.math.cast_like(phi, 1j))\n minus_phase = qml.math.exp(-1j * qml.math.cast_like(phi, 1j))\n return stack_last([phase if index < d else minus_phase for index in range(t)])\n\n arg = 1j * phi\n prefactors = qml.math.array([1 if index < d else -1 for index in range(t)], like=phi)\n\n if qml.math.ndim(phi) == 0:\n product = arg * prefactors\n else:\n product = qml.math.outer(arg, prefactors)\n return qml.math.exp(product)","def test_loss_hamiltonian_incomplete(self):\n g = nx.lollipop_graph(4, 1).to_directed()\n edge_weight_data = {edge: (i + 1) * 0.5 for i, edge in enumerate(g.edges)}\n for k, v in edge_weight_data.items():\n g[k[0]][k[1]][\"weight\"] = v\n h = loss_hamiltonian(g)\n\n expected_ops = [\n qml.PauliZ(0),\n qml.PauliZ(1),\n qml.PauliZ(2),\n qml.PauliZ(3),\n qml.PauliZ(4),\n qml.PauliZ(5),\n qml.PauliZ(6),\n qml.PauliZ(7),\n qml.PauliZ(8),\n qml.PauliZ(9),\n qml.PauliZ(10),\n qml.PauliZ(11),\n qml.PauliZ(12),\n qml.PauliZ(13),\n ]\n expected_coeffs = [\n np.log(0.5),\n np.log(1),\n np.log(1.5),\n np.log(2),\n np.log(2.5),\n np.log(3),\n np.log(3.5),\n np.log(4),\n np.log(4.5),\n np.log(5),\n np.log(5.5),\n np.log(6),\n np.log(6.5),\n np.log(7),\n ]\n\n assert expected_coeffs == h.coeffs\n assert all([op.wires == exp.wires for op, exp in zip(h.ops, expected_ops)])\n assert all([type(op) is type(exp) for op, exp in zip(h.ops, expected_ops)])","def test_tdsp_dijsktra_with_timesteps_real_data(self):\n input_file = \"/home/andy/code/python/om_task/data/input_data1.txt\"\n graph_data = process_input_file(input_file)\n\n graphs = {}\n\n today = datetime.today()\n t = time(0, 0) # input time value\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\n\n for timestep in graph_data:\n # print(\"Timestep=\", timestep)\n # Create a graph for each timestep\n graphs[timestep] = Graph()\n for edge in graph_data.get(timestep):\n graphs[timestep].add_edge(*edge)\n\n for graph in graphs:\n print(graphs[graph].edges)\n print(graphs[graph].weights)\n\n print(\"Start Test 1\")\n path = tdsp_dijsktra(graphs, start_time, 'B1', 'F4')\n print(path)\n self.assertEqual(['B1', 'C2', 'D3', 'E4', 'F4'], path)","def hmm(pc, n1, n2, w, dt, rounding):\n\n t = 0 # start time\n ts = 0 #start time of stimulus \n \n x = 'default' #start hidden state\n obs = [] #observations\n states = [] #hidden states\n count = 0 #counter\n transitionYes = 0 #keeps track of whether transition has happened\n foreperiodSteps = int((6/dt)+1)\n \n \n while round(ts,rounding) < w: #this ends when w is over, rounding to avoid\n #floating point no. comaparison errors\n states.append(x)\n \n \n if transitionYes == 1:\n ts = ts+dt\n \n #generating observations, 1 is cue, 0 is default\n if x == 'cue':\n k = np.random.binomial(1,n2)\n if k == 1:\n obs.append(1) \n else:\n obs.append(0)\n \n if x == 'default':\n k = np.random.binomial(1,n1)\n if k == 1:\n obs.append(0) \n else:\n obs.append(1)\n \n if count < foreperiodSteps and transitionYes == 0:\n #\n r = 1/(foreperiodSteps-count)\n #print(r)\n i = np.random.binomial(1, r) #transition out of default if i == 1\n if i == 1:\n transitionYes = 1\n #tLeft = round(t,rounding)\n j = np.random.binomial(1, pc) #on transitioning out of default, prob of \n if j == 1: #cue is pc, and going back to default is 1-pc\n x = 'cue'\n else:\n x = 'default'\n \n #print(r, t, count, ts, sep=' ')\n t = t+dt\n count = count +1\n \n \n return obs, states","def run_agent(self):\n '''\n The child class is created in order to override the value method which will take into account\n previous states of the agent. The reward function is made exponential rather than linear, which\n decreases the probability of agent visiting the state which was already visited.\n '''\n\n class GraphProblemSpecialised(GraphProblem):\n def __init__(self, initial, goal, graph, reward_dict, already_visited_reward):\n GraphProblem.__init__(self, initial, goal, graph)\n self.rewards = reward_dict\n self.already_visited_reward = already_visited_reward\n\n def value(self, state, history):\n if state in history.keys():\n return self.rewards[state] - (self.already_visited_reward ** history[state])\n return self.rewards[state]\n\n # -- Load and init mission --#\n print('Generate and load the ' + self.mission_type + ' mission with seed ' + str(\n self.mission_seed) + ' allowing ' + self.AGENT_MOVEMENT_TYPE + ' movements')\n mission_xml = init_mission(self.agent_host, self.agent_port, self.AGENT_NAME, self.mission_type,\n self.mission_seed, self.AGENT_MOVEMENT_TYPE)\n self.solution_report.setMissionXML(mission_xml)\n self.solution_report.start()\n\n # -- Get the state of the world along with internal state... --#\n state_t = self.agent_host.getWorldState()\n\n # -- Main loop: --#\n while state_t.is_mission_running:\n state_t = self.agent_host.getWorldState()\n\n # -- Check if anything went wrong along the way --#\n for error in state_t.errors:\n print(\"Error:\", error.text)\n\n # -- Oracle and Internal Sensors--#\n if state_t.number_of_observations_since_last_state > 0: # Has any Oracle-like and/or internal sensor observations come in?\n msg = state_t.observations[-1].text # Get the details for the last observed state\n oracle_and_internal = json.loads(msg) # Parse the Oracle JSON\n # print oracle_and_internal\n # -- Oracle sensor --#\n grid = oracle_and_internal.get(u'grid', 0) # Demo only, string with the\n # -- GPS-like sensor --#\n xpos = oracle_and_internal.get(u'XPos', 0) # Demo only, position in 2D plane, 1st axis\n zpos = oracle_and_internal.get(u'ZPos', 0) # Demo only, position in 2D plane, 2nd axis (yes Z!)\n ypos = oracle_and_internal.get(u'YPos', 0) # Demo only, height as measured from surface! (yes Y!)\n\n current_location_id = self._get_current_location_id((xpos, zpos))\n\n if self.history.get(current_location_id):\n self.history[current_location_id] += 1\n else:\n self.history[current_location_id] = 1\n\n if self.first_time_flag:\n start_location = current_location_id\n\n # Gets the possible actions and checks for goal block\n state_space_actions, state_space_locations, reached_goal = self._get_local_state_space_actions(grid,\n [xpos,\n zpos])\n\n if reached_goal:\n break\n\n self.rewards_by_location_id, self.previous_rewards_total = self._get_rewards(\n self.rewards_by_location_id,\n state_space_actions,\n state_space_locations,\n oracle_and_internal,\n self.previous_rewards_total)\n\n # Creates a graph for local (neighbourhood) actions\n local_map = UndirectedGraph(state_space_actions)\n local_problem = GraphProblemSpecialised(initial=start_location, goal=None, graph=local_map,\n reward_dict=self.rewards_by_location_id,\n already_visited_reward=self.already_visited_reward)\n # Looks for most optimal next step\n next_step = self.hill_climbing(local_problem, self.history)\n\n # If the next step is already in history the reward will be exponentially increased (but is negated)\n if next_step in self.history.keys():\n print \"You already visited that so will be punished!\"\n self.rewards_by_location_id[next_step] -= self.already_visited_reward ** self.history[next_step]\n self.history[next_step] += 1\n\n next_x, next_z = state_space_locations[next_step]\n self.agent_host.sendCommand(\"tp \" + str(next_x) + \" \" + str(217) + \" \" + str(next_z))\n time.sleep(0.1)\n\n # -- Collect the number of rewards and add to reward_cumulative --#\n # -- Note: Since we only observe the sensors and environment every a number of rewards may have accumulated in the buffer --#\n for reward_t in state_t.rewards:\n print(\"Reward_t:\", reward_t.getValue())\n self.solution_report.addReward(reward_t.getValue(), datetime.datetime.now())\n\n # -- Check if anything went wrong along the way --#\n for error in state_t.errors:\n print(\"Error:\", error.text)\n\n print(\"Mission has ended.either because time has passed or you reached the goal.\")\n return","def test_floyd_warshall(self):\n dag = retworkx.PyDAG()\n # inputs\n qr_0 = dag.add_node('qr[0]')\n qr_1 = dag.add_node('qr[1]')\n qr_2 = dag.add_node('qr[2]')\n cr_0 = dag.add_node('cr[0]')\n cr_1 = dag.add_node('cr[1]')\n # wires\n cx_1 = dag.add_node('cx_1')\n dag.add_edge(qr_0, cx_1, 'qr[0]')\n dag.add_edge(qr_1, cx_1, 'qr[1]')\n h_1 = dag.add_node('h_1')\n dag.add_edge(cx_1, h_1, 'qr[0]')\n cx_2 = dag.add_node('cx_2')\n dag.add_edge(cx_1, cx_2, 'qr[1]')\n dag.add_edge(qr_2, cx_2, 'qr[2]')\n cx_3 = dag.add_node('cx_3')\n dag.add_edge(h_1, cx_3, 'qr[0]')\n dag.add_edge(cx_2, cx_3, 'qr[2]')\n h_2 = dag.add_node('h_2')\n dag.add_edge(cx_3, h_2, 'qr[2]')\n # # outputs\n qr_0_out = dag.add_node('qr[0]_out')\n dag.add_edge(cx_3, qr_0_out, 'qr[0]')\n qr_1_out = dag.add_node('qr[1]_out')\n dag.add_edge(cx_2, qr_1_out, 'qr[1]')\n qr_2_out = dag.add_node('qr[2]_out')\n dag.add_edge(h_2, qr_2_out, 'qr[2]')\n cr_0_out = dag.add_node('cr[0]_out')\n dag.add_edge(cr_0, cr_0_out, 'qr[2]')\n cr_1_out = dag.add_node('cr[1]_out')\n dag.add_edge(cr_1, cr_1_out, 'cr[1]')\n\n result = retworkx.floyd_warshall(dag)\n expected = {\n 0: {0: 0, 5: 1, 6: 2, 7: 2, 8: 3, 9: 4, 10: 4, 11: 3, 12: 5},\n 1: {1: 0, 5: 1, 6: 2, 7: 2, 8: 3, 9: 4, 10: 4, 11: 3, 12: 5},\n 2: {2: 0, 7: 1, 8: 2, 9: 3, 10: 3, 11: 2, 12: 4},\n 3: {3: 0, 13: 1},\n 4: {4: 0, 14: 1},\n 5: {5: 0, 6: 1, 7: 1, 8: 2, 9: 3, 10: 3, 11: 2, 12: 4},\n 6: {6: 0, 8: 1, 9: 2, 10: 2, 12: 3},\n 7: {7: 0, 8: 1, 9: 2, 10: 2, 11: 1, 12: 3},\n 8: {8: 0, 9: 1, 10: 1, 12: 2},\n 9: {9: 0, 12: 1},\n 10: {10: 0},\n 11: {11: 0},\n 12: {12: 0},\n 13: {13: 0},\n 14: {14: 0},\n }\n self.assertDictEqual(result, expected)","def el_ph(om,eig,q,zs,mass,eps,rG,nmodes,nqpt,nat):\n\n # Initiate\n g = np.zeros((nqpt,nmodes),dtype=complex)\n\n # Initiate q+G\n qpG = np.zeros((nqpt,3))\n\n q_c = q[:,0:3] \n q2 = np.zeros(nqpt)\n N = 5 # Initial size of G-point grid used for sum\n\n alpha = 5.0 # Convergence parameter\n\n for nn in range(-N,N+1):\n for mm in range(-N,N+1):\n for ll in range(-N,N+1):\n #\n for ic in range(3):\n qpG[:,ic] = q_c[:,ic] + nn*rG[0,ic] + mm*rG[1,ic] + ll*rG[2,ic]\n # IMPORTANT : Put a check here that qpG is nonzero! (break the loop if so)\n # Denominator\n q2[:] = 0.0\n for ia in range(3): \n for ib in range(3):\n q2[:] += qpG[:,ia]*eps[ia,ib]*qpG[:,ib]\n # \n inv_q2 = 1.0 / (q2 + 1e-10)\n arg = np.exp(-0.25 * np.sum(qpG**2, axis=1) / alpha) * inv_q2 # exp((q+G)^2/4a)\n \n for imod in range(nmodes):\n for ia in range(3):\n for ib in range(3):\n for iat in range(nat):\n g[:,imod] += arg[:]*qpG[:,ia]*zs[iat,ia,ib]*eig[imod,:,iat,ib] \\\n / np.sqrt(2.0*mass[iat]*np.abs(om[imod,:])+1e-10)\n\n return g","def compute_global_error(g):\n Fx = 0\n for edge in g.edges:\n\n # pose-pose constraint\n if edge.Type == 'P':\n\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node state for the current edge\n x1 = g.x[fromIdx:fromIdx + 3]\n x2 = g.x[toIdx:toIdx + 3]\n\n # get measurement and information matrix for the edge\n z12 = edge.measurement\n info12 = edge.information\n\n # (TODO) compute the error due to this edge`\n z12 = v2t(z12)\n x1 = v2t(x1)\n x2 = v2t(x2)\n eij = t2v(np.linalg.inv(z12) @ np.linalg.inv(x1) @ x2)\n Fx = Fx + eij.transpose() @ info12 @ eij\n # pose-pose constraint\n elif edge.Type == 'L':\n print(\"You shouldn't be here.\")\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node states for the current edge\n x = g.x[fromIdx:fromIdx + 3]\n l = g.x[toIdx:toIdx + 2]\n\n # get measurement and information matrix for the edge\n z = edge.measurement\n info12 = edge.information\n\n # (TODO) compute the error due to this edge\n # TODO2 : do on homo matrices\n xtr = v2t(x)\n R = xtr[0:2, 0:2]\n eil = R.transpose() @ (l - x[0:2]) - z\n Fx = Fx + eil.transpose() @ info12 @ eil\n\n return Fx","def test_tdsp_dijsktra_with_timesteps_2(self):\n input_file = \"/home/andy/code/python/om_task/data/test_data3.txt\"\n graph_data = process_input_file(input_file)\n\n graphs = {}\n\n today = datetime.today()\n t = time(0, 0) # input time value\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\n\n for timestep in graph_data:\n # print(\"Timestep=\", timestep)\n # Create a graph for each timestep\n graphs[timestep] = Graph()\n for edge in graph_data.get(timestep):\n graphs[timestep].add_edge(*edge)\n\n for graph in graphs:\n print(graphs[graph].edges)\n print(graphs[graph].weights)\n\n path = tdsp_dijsktra(graphs, start_time, 'A0', 'B1')\n\n print(path)\n\n self.assertEqual(['A0', 'B0', 'B1'], path)","def main():\n\n global time\n global MAX_ITER\n global output_dt\n\n # ==========================================================================\n # Initialize\n # - Returns a dictionary of dictionaries, which are the parameters from the\n # configuration file (by section) and from the command line (listed as\n # section 'CommandLine')\n params = init()\n\n # ==========================================================================\n # Evolution loop\n\n prev_write = -1\n\n for n_iter in xrange(MAX_ITER):\n\n # Exceeded maximum time\n if time >= tmax:\n break\n\n # Unexpected exit? (e.g. like \"touch .dump_restart\")\n # TODO\n\n # Write output\n do_write = False\n if output_dt > 0:\n curr_write = int(math.floor(time / output_dt))\n if curr_write > prev_write:\n do_write = True\n prev_write = curr_write\n if do_write: # to allow for a condition based on step number\n Grid.write_data(n_iter)\n\n # Boundary condition fill\n Grid.fill_boundary_conditions()\n\n # Compute step size\n dt = compute_time_step()\n\n # Evolve a single step\n Hydro.one_step(dt)\n\n # Update time\n time = time + dt\n\n # End evolution loop\n\n # ==========================================================================\n # Finalize\n\n # Write final output\n Grid.write_data(n_iter+1)\n finalize()","def solve_csp(nodes, arcs, max_steps):\n\n nodes = list(nodes)\n print 'nodes:', nodes\n\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\n print 'initial random assignment', node_values_dict\n indexes = np.arange(len(nodes))\n\n graph = {}\n for arc in arcs:\n if not arc[0] in graph:\n graph[arc[0]] = []\n if not arc[1] in graph:\n graph[arc[1]] = []\n graph[arc[0]].append(arc[1])\n graph[arc[1]].append(arc[0])\n for i in indexes:\n if i in graph:\n continue\n else:\n graph[i] = []\n graph = dict(sorted(graph.items()))\n print 'graph:', graph\n\n domain = [i for i in np.arange(1, 10, 1)]\n print 'initial domain for each node:', domain\n\n superAdjacency ={}\n for i in np.arange(len(nodes)):\n superAdjacency[i] = []\n superAdjacency[i].append(nodes[i])\n superAdjacency[i].append(node_values_dict[nodes[i]])\n superAdjacency[i].append(graph[i])\n superAdjacency[i].append(domain)\n\n print 'superAdjacency', superAdjacency\n\n def getNodeType(superAdjacency, index):\n return list(superAdjacency[index])[0]\n\n def getCurrentAssignment(superAdjacency, index):\n return list(superAdjacency[index])[1]\n\n def getCurrentAssignmentForList(superAdjacency, indexList):\n return [int(list(superAdjacency[index])[1]) for index in indexList]\n\n def getSolution(superAdjacency):\n return [int(list(superAdjacency[index])[1]) for index in superAdjacency]\n\n def getNeighbours(superAdjacency, index):\n return list(superAdjacency[index])[2]\n\n def getDomain(superAdjacency, index):\n return list(superAdjacency[index])[3]\n\n def updateSuperAdjacency(superAdjacency, nodeType, newValue):\n updateList =[]\n for i in superAdjacency:\n if str(getNodeType(superAdjacency, i)) == nodeType:\n updateList.append(i)\n for i in updateList:\n superAdjacency[i][1] = newValue\n\n def isSolution():\n return graphConstraints(superAdjacency)\n\n def graphConstraints(superAdjacency):\n graphEval = []\n\n for index in superAdjacency:\n neighbours = getNeighbours(superAdjacency, index)\n nodeType = getNodeType(superAdjacency, index)\n\n if nodeType == 'T':\n graphEval.append(int(str(eval(str(\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]))\n elif nodeType == 'C':\n return 'NA'\n elif nodeType == 'S':\n graphEval.append(int(str(eval(str(\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]))\n elif nodeType == 'H':\n graphEval.append(int(str(np.sum(\n getCurrentAssignmentForList(superAdjacency, neighbours)))[0]))\n if nodeType == 'P':\n graphEval.append(int(str(np.sum(\n getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]))\n\n currentAssignment = [item[1] for item in superAdjacency.values()]\n difference = map(sub, currentAssignment, graphEval)\n\n if sum(difference) == 0:\n return True\n else:\n return difference\n\n def findConflictVariable(superAdjacency, lastUpdateNode):\n node_conflict_count = {}\n for node in node_values_dict:\n node_conflict_count[node] = 0\n for index in superAdjacency:\n neighbours = getNeighbours(superAdjacency, index)\n nodeType = getNodeType(superAdjacency, index)\n if nodeType == 'T':\n try:\n if getCurrentAssignment(superAdjacency, index) != \\\n int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n elif nodeType == 'S':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n elif nodeType == 'H':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n if nodeType == 'P':\n try:\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]):\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\n except:\n continue\n choices = [k for k, v in node_conflict_count.items() if v > 0]\n if len(choices) > 0:\n updateNode = random.choice(choices)\n\n if updateNode == lastUpdateNode:\n choices.pop(choices.index(updateNode))\n try:\n lastUpdateNode = random.choice(choices)\n return lastUpdateNode, lastUpdateNode\n except:\n return lastUpdateNode, lastUpdateNode\n else:\n lastUpdateNode = updateNode\n return updateNode, lastUpdateNode\n else:\n return 'NA', 'NA'\n\n\n\n def valueForConflictedVariable(superAdjacency, var):\n for index in superAdjacency:\n nodeType = getNodeType(superAdjacency, index)\n neighbours = getNeighbours(superAdjacency, index)\n if not neighbours:\n continue\n elif str(nodeType) == str(var):\n domain = getDomain(superAdjacency, index)\n\n choice = random.choice(domain)\n if nodeType == 'T':\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0])\n elif nodeType == 'S':\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0])\n elif nodeType == 'H':\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0])\n if nodeType == 'P':\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0])\n\n choice = int(choice)\n if choice % 2 == 0:\n return choice\n else:\n return choice\n\n def min_conflicts(nodes, arcs, max_steps):\n lastUpdateNode = ''\n for i in range(max_steps):\n if isSolution() == True:\n return\n var, lastUpdateNode = findConflictVariable(superAdjacency, lastUpdateNode)\n if var != 'NA':\n value = valueForConflictedVariable(superAdjacency, var)\n updateSuperAdjacency(superAdjacency, var, value)\n node_values_dict[var] = value\n else:\n pass\n\n return\n\n min_conflicts(nodes, arcs, max_steps)\n node_values = getSolution(superAdjacency)\n return node_values","def rhs(states, t, parameters, values=None):\n # Imports\n import numpy as np\n import math\n\n # Assign states\n assert(len(states) == 6)\n vlv, vrv, v1s, v2s, v1p, v2p = states\n\n # Assign parameters\n assert(len(parameters) == 38)\n restVlvd=parameters[0]; restVlvs=parameters[1]; restVrvd=parameters[2];\\\n restVrvs=parameters[3]; Emaxlv=parameters[4]; Emaxrv=parameters[5];\\\n Eminlv=parameters[6]; Eminrv=parameters[7]; R1_s=parameters[16];\\\n Rao_s=parameters[18]; Rmit=parameters[19]; c1s=parameters[20];\\\n c2s=parameters[21]; pext_s=parameters[22]; rest_v1s=parameters[23];\\\n rest_v2s=parameters[24]; R1_p=parameters[25]; Rao_p=parameters[27];\\\n Rtric=parameters[28]; c1p=parameters[29]; c2p=parameters[30];\\\n p_epi=parameters[31]; pext_p=parameters[32]; rest_v1p=parameters[33];\\\n rest_v2p=parameters[34]; bcl=parameters[35];\\\n twitchperiod=parameters[37]\n\n # Init return args\n if values is None:\n values = np.zeros((6,), dtype=np.float_)\n else:\n assert isinstance(values, np.ndarray) and values.shape == (6,)\n\n # Expressions for the Time varying elastance component\n t_lv = math.fmod(t, bcl)\n yv = (0.5 - 0.5*math.cos(2.0*math.pi*t_lv/twitchperiod) if t_lv <\\\n twitchperiod else 0)\n Elv = Eminlv + (Emaxlv - Eminlv)*yv\n restVlv = restVlvs + (1 - yv)*(restVlvd - restVlvs)\n plv = p_epi + (-restVlv + vlv)*Elv\n Erv = Eminrv + (Emaxrv - Eminrv)*yv\n restVrv = restVrvs + (1 - yv)*(restVrvd - restVrvs)\n prv = p_epi + (-restVrv + vrv)*Erv\n\n # Expressions for the Pressures and flows component\n p1s = (-pext_s + (-rest_v1s + v1s)/c1s if v1s > 0 else -pext_s -\\\n rest_v1s/c1s)\n p2s = (-pext_s + (-rest_v2s + v2s)/c2s if v2s > 0 else -pext_s -\\\n rest_v2s/c2s)\n p1p = (-pext_p + (-rest_v1p + v1p)/c1p if v1p > 0 else -pext_p -\\\n rest_v1p/c1p)\n p2p = (-pext_p + (-rest_v2p + v2p)/c2p if v2p > 0 else -pext_p -\\\n rest_v2p/c2p)\n qart_s = ((-p1s + plv)/Rao_s if plv > p1s else 0)\n q_mit = ((-plv + p2p)/Rmit if p2p > plv else 0)\n q1_s = (-p2s + p1s)/R1_s\n qart_p = ((-p1p + prv)/Rao_p if prv > p1p else 0)\n q_tric = ((-prv + p2s)/Rtric if p2s > prv else 0)\n q1_p = (-p2p + p1p)/R1_p\n\n # Expressions for the Ventricular volumes component\n values[0] = -qart_s + q_mit\n values[1] = -qart_p + q_tric\n\n # Expressions for the Systemic volumes component\n values[2] = -q1_s + qart_s\n values[3] = -q_tric + q1_s\n\n # Expressions for the Pulmonary volumes component\n values[4] = -q1_p + qart_p\n values[5] = -q_mit + q1_p\n\n # Return results\n return values","def forward_backward(observations):\n\n # -------------------------------------------------------------------------\n # YOUR CODE GOES HERE\n #\n # observations = [(4, 3), (4, 2), (3, 2), (4, 0), (2, 0), (2, 0), (3, 2), \n # (4, 2), (2, 3), (3, 5)]\n num_time_steps = len(observations)\n forward_messages = [None] * num_time_steps\n forward_messages[0] = prior_matrix\n # # # TODO: Compute the forward messages\n for i,x_i in enumerate(observations):\n if x_i:\n obs_index = obs_state_index_map[x_i]\n pi_0 = forward_messages[i]\n # print(len(B[:obs_index]))\n weights = np.multiply(pi_0, B[:,obs_index])\n # x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\n else:\n weights = forward_messages[i]\n # print(weights)\n x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\n if i+1 < len(forward_messages):\n forward_messages[i+1] = x#normalize(x)\n # break\n\n ## forward messages as dictionary\n # for_dict = [None]*num_time_steps\n # for j,f in enumerate(forward_messages):\n # x = Distribution()\n # for i,x_i in enumerate(f):\n # if x_i == 0:\n # continue\n # # print(i,x_i)\n # x[all_possible_hidden_states[i]] = x_i\n # for_dict[j] = x.renormalize()\n # print(for_dict[3])\n\n # print('--------------\\n-----------------\\n')\n\n\n backward_messages = [None] * num_time_steps\n # backward_messages[-1] = [1]*len(prior_matrix)\n message = np.ones(len(all_possible_hidden_states), dtype=np.float64)\n backward_messages[-1] = message/len(all_possible_hidden_states)\n \n# ****\n ## Backwards messages\n for i,x_i in enumerate(reversed(observations)):\n # print(x_i)\n if x_i:\n obs_index = obs_state_index_map[x_i]\n pi = backward_messages[-1-i]\n weights = np.multiply(pi, B[:,obs_index])\n else:\n weights = backward_messages[-1-i]\n # print(i)\n x = sum([A[:,j]*w_i for j,w_i in enumerate(weights)])\n\n if i+1 < len(backward_messages):\n backward_messages[-2-i] = x#normalize(x)\n\n ## backward messages as dictionary\n # back_dict = [None]*num_time_steps\n # for j,b in enumerate(backward_messages):\n # x = Distribution()\n # if b == None:\n # continue\n # for i,x_i in enumerate(b):\n # if x_i == 0 or x_i==None:\n # continue\n # # print(i,x_i)\n # x[all_possible_hidden_states[i]] = x_i\n # back_dict[j] = x.renormalize()\n \n # print(back_dict[0])\n # print(A[:10,:10])\n # print('\\n-----------------\\n', B[:10,:10])\n\n # print(backward_messages[2])\n # backward_messages[0] = forward_messages[0]\n # # ## marginals as matrix\n marginals = [None] * num_time_steps \n for i,x_i in enumerate(observations):\n if x_i:\n obs_index = obs_state_index_map[x_i]\n marginals[i] = np.multiply(np.multiply(backward_messages[i],\n forward_messages[i]),\n B[:,obs_index])\n else:\n marginals[i] = np.multiply(backward_messages[i],forward_messages[i])\n # if i == 0:\n # marginals[i] = np.multiply(backward_messages[i], B[:,obs_index])\n # elif i == len(observations)-1:\n # marginals[i] = np.multiply(forward_messages[i], B[:,obs_index])\n # else:\n\n ## marginals as dictionary\n marg_dict = [None]*num_time_steps\n for j,m in enumerate(marginals):\n x = Distribution()\n for i,x_i in enumerate(m):\n if x_i == 0 or x_i==None:\n continue\n x[all_possible_hidden_states[i]] = x_i\n marg_dict[j] = x.renormalize()\n # print(marginals[i])\n # print(A[:10, :10], '\\n')\n # print(B[:10, :10], '\\n')\n # print(marg_dict)\n return marg_dict","def solve(self,init=None,g_init=1e-3,g_step=5e-3,g_fin=None,evol=False,movingGrid=False):\n if(g_fin==None): g_fin=self.g\n #Check if all signs are correct\n if(g_fin<0):\n if(g_step>0): g_step*=-1.\n if(g_init>0): g_init*=-1.\n else:\n if(g_step<0): g_step*=-1.\n if(g_init<0): g_step*=-1.\n\n #If no initial distribution is given, start from the BCS ground state\n if(init==None): init=[1 if i<self.N else 0 for i in range(self.n)]\n var_init=np.array([-2.*init[i]-g_init/(1-2.*init[i])*np.sum([self.XXZ.Z(j,i)*(init[j]-init[i]) for j in range(self.n) if j!=i]) for i in range(self.n)])\n n_step=int((g_fin-g_init)/g_step)\n g=g_init\n\n #Define necessary variables if evol or movingGrid=True\n if(evol or movingGrid):\n var_evol=np.zeros([n_step,self.n])\n g_evol=np.zeros(n_step)\n if(movingGrid):\n rap_evol = np.zeros([n_step,self.N],dtype=complex)\n rap_evol[0] = [self.levels[i] for i in range(self.n) if init[i]!=0 ]\n rap=np.array([self.levels[i]+0.5*np.abs(np.random.rand()) for i in range(self.n) if init[i]!=0])\n grid=np.zeros(self.N+1,dtype=complex)\n grid[0]=1e3\n for k in range(self.N): grid[k+1]=rap[k]\n n_grid=n_step/20 #Calculates rapidities at 20 intermediate steps\n\n #Gradually increase the coupling constant g and solve iteratively at each step starting from the Taylor approximation from the previous step\n for i in range(n_step):\n var_new=self.newtonraphson(g,var_init)\n der=self.get_derivative(var_new,g)\n #var_init=self.taylor_expansion(g,g_step,var_new)\n var_init = var_new+g_step*der\n g+=g_step\n #print g\n\n #Save variables at current step if evol =True\n if(evol or movingGrid):\n var_evol[i]=var_init\n g_evol[i]=g\n if(movingGrid and i%n_grid==0 and i!=0):\n #Method for obtaining the rapidities starting from the set of Lambda_i\n rf=RootFinder(self.XXZ,var_evol[i]/g_evol[i],g_evol[i],self.N)\n u=rf.solveForU(grid)\n lm=LaguerreMethod(grid,u)\n rap=lm.laguerre()\n rap_evol[i]=np.sort(lm.laguerre())\n for k in range(self.N): grid[k+1]=rap[k]\n grid[0]=10*max(rap)\n elif(movingGrid and i!=0):\n rf=RootFinder(self.XXZ,var_evol[i]/g_evol[i],g_evol[i],self.N)\n u=rf.solveForU(grid)\n lm=LaguerreMethod(grid,u)\n rap_evol[i]=np.sort(lm.laguerre())\n \n \n #One final iterative solution at g=g_fin\n self.solution=self.newtonraphson(g_fin,var_init)\n #Calculate the occupation numbers\n self.occupation=0.5*(-1.-self.solution+g_fin*self.get_derivative(self.solution,g_fin))\n\n #One final calculation of the rapidities\n if(movingGrid):\n rf=RootFinder(self.XXZ,self.solution/g_fin,g_fin,self.N)\n u=rf.solveForU(grid)\n lm=LaguerreMethod(grid,u)\n rap=lm.laguerre()\n self.rapidities=rap\n\n if movingGrid: return [g_evol,var_evol,rap_evol]\n if evol: return [g_evol,var_evol]\n return self.solution","def one_forward_pass(t,states,init_vals,traces,delta,unit_cube,edges,P):\n \n next_vals = -1e100 * np.ones(init_vals.shape)\n \n S,T = states.shape\n \n for i in range(len(states)):\n for j in range(len(unit_cube)):\n# print('State, unitcube subtracted',s,c)\n if (states[i] - unit_cube[j]).min() >= 0:\n \n state_idx = edges[i,j]\n \n tau = np.where(unit_cube[j] == 0)\n \n if len(tau[0]) == 0:\n next_vals[i] = log_sum_exp([next_vals[i],\\\n init_vals[state_idx]+T*np.log(delta)])\n \n else:\n \n flag = 0\n temp = []\n for k in tau[0]:\n if (t-states[i,k] >=0 and t-states[i,k]< len(traces[k])):\n temp.append(traces[k][t-states[i][k]])\n else:\n flag = 1\n break\n\n if (len(set(temp)) == 1 and flag == 0):\n bit = temp[0]\n next_vals[i] = log_sum_exp([next_vals[i],init_vals[state_idx]\\\n +(T-len(temp)) * np.log(delta)\\\n + np.log(1-delta) * (len(temp))\n + np.log(P[t,bit]+1e-100)])\n \n return next_vals","def _generate_hourly_seasonality(\n self,\n time_range: np.ndarray,\n hourly_seasonality_params: List[Tuple[float, float]],\n ) -> np.ndarray:\n\n return sum(\n [\n alpha * np.cos(2 * np.pi * (i + 1) * time_range / 24)\n + beta * np.sin(2 * np.pi * (i + 1) * time_range / 24)\n for i, (alpha, beta) in enumerate(hourly_seasonality_params)\n ]\n )","def communityGraph(graph):\n\n lapgr = nx.laplacian_matrix(graph)\n\n # Get the eigenvalues and eigenvectors of the Laplacian matrix\n evals, evec = np.linalg.eigh(lapgr.todense())\n\n fiedler = evec[1]\n results = []\n ## \"Fiedler\", fiedler\n median = np.median(fiedler, axis=1) # median of the second eigenvalue\n for i in range(0, fiedler.size): # divide the graph nodes into two\n if(fiedler[0, i] < median):\n results.append(0)\n else:\n results.append(1)\n return results, evals, evec","def execute_algorithm_with_params(params):\n\n # unpack the algorithm and its parameters\n algorithm, algorithm_name, problem, show_solution_plot, solution_plot_save_path, calculate_times, calculate_value_evolution = params\n\n start_time = time.time()\n value_evolution = None\n times_dict = None\n if calculate_value_evolution:\n if algorithm == evolutionary.solve_problem:\n if calculate_times:\n solution, times_dict, value_evolution = algorithm(problem, calculate_times=calculate_times, return_population_fitness_per_generation=calculate_value_evolution)\n else:\n solution, value_evolution = algorithm(problem, calculate_times=calculate_times, return_population_fitness_per_generation=calculate_value_evolution)\n else:\n if calculate_times:\n solution, times_dict, value_evolution = algorithm(problem, calculate_times=calculate_times, return_value_evolution=calculate_value_evolution)\n else:\n solution, value_evolution = algorithm(problem, calculate_times=calculate_times, return_value_evolution=calculate_value_evolution)\n elif calculate_times:\n solution, times_dict = algorithm(problem, calculate_times=calculate_times)\n else:\n solution = algorithm(problem)\n elapsed_time = get_time_since(start_time)\n\n if solution and (show_solution_plot or solution_plot_save_path):\n solution.visualize(show_plot=show_solution_plot, save_path=solution_plot_save_path)\n\n return solution, solution.value, value_evolution, elapsed_time, times_dict","def timeEvolve(state, Hamiltonian, t):\n state_t = expm(1j * Hamiltonian * t).dot(state)\n return state_t","def generate_aima_grid():\n\n # https://stats.stackexchange.com/questions/339592/how-to-get-p-and-r-values-for-a-markov-decision-process-grid-world-problem\n\n actions_map = {0: '^', 1: 'V', 2: '<', 3: '>'}\n\n transitions = np.zeros((4, 12, 12)) # (A, S, S)\n transitions[0] = [[0.9, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.8, 0., 0., 0., 0.2, 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.8, 0., 0., 0.1, 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.1],\n [0., 0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.1]]\n\n transitions[1] = [[0.1, 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.2, 0., 0., 0., 0.8, 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0.1, 0., 0., 0.8, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.9, 0.1, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.9]]\n\n transitions[2] = [[0.9, 0., 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\n [0.8, 0.2, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.8, 0.1, 0., 0., 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\n [0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.1, 0., 0.],\n [0., 0., 0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.9, 0., 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0.8, 0.2, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1]]\n\n transitions[3] = [[0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\n [0., 0.2, 0.8, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0., 0., 0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0.],\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\n [0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.],\n [0., 0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.],\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8, 0., 0.],\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.2, 0.8, 0.],\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8],\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.9]]\n\n rewards = np.asarray((-0.02, -0.02, -0.02, 1, -0.02, -0.02, -0.02, -1, -0.02, -0.02, -0.02, -0.02))\n\n print('\\n***** aima grid world *****\\n')\n print('Transition matrix:', transitions.shape)\n print('Reward matrix:', rewards.shape)\n\n return transitions, rewards","def jmt(start, end, time):\n # the first 3 coefficients are from s(t=0) derivatives\n c_1, c_2, c_3 = start[0], start[1], start[2] / 2\n\n matrix_a = np.array([\n [time**3, time**4, time**5],\n [3 * time**2, 4 * time**3, 5 * time**4],\n [6 * time, 12 * time**2, 20 * time**3]\n ])\n\n vector_b = np.array(\n [end[0] - (start[0] + start[1] * time + 0.5 * start[2] * time**2),\n end[1] - (start[1] + start[2] * time),\n end[2] - start[2]])\n\n x_r = inv(matrix_a).dot(vector_b) # solve AX = B system\n\n c_4, c_5, c_6 = x_r[0], x_r[1], x_r[2]\n\n return [c_1, c_2, c_3, c_4, c_5, c_6]","def calc_harmony_dynamics(self):\n Hg = self.B + self.inpS + self.W.matmul(self.state)\n #Hg += self.bowl.calc_bowl_gradient(self.state)\n return Hg","def calculate(self) :\n #self.graph\n self.val_i = 0\n while (len(self.undefined_vertices) > 0) :\n cond = True\n while cond:\n cond = False\n for node in self.undefined_vertices:\n if self.condition_satisfied(node, self.val_i) :\n cond = True\n self.undefined_vertices.remove(node)\n self.val_l[node] = self.val_i\n self.val_c[node] = self.val_m\n self.val_m += 1\n for node in self.undefined_vertices:\n if self.val_i not in [self.val_l[n] for n in\n self.graph.next_nodes(node)]:\n self.undefined_vertices.remove(node)\n self.val_l[node] = self.infinity\n self.val_c[node] = 0\n self.val_i += 1\n self.graph.save_graph(\"check\")\n self.save(\"this.value\")\n return self.graph.to_dictionary(), self.val_l, self.val_c","def return_list_of_states(graphs_list,\n times, pulses, evol='xy', verbose=0):\n all_states = []\n for G in tqdm(graphs_list, disable=verbose==0):\n all_states.append(return_evolution(G, times, pulses, evol))\n return all_states","def timlinucb_parallel_t(\n df_edges,\n df_feats,\n times,\n nodes,\n num_seeds=5,\n sigma=4,\n c=0.1,\n epsilon=0.4,\n num_repeats_oim=10,\n num_repeats_oim_reward=10,\n style=\"additive\",\n process_id=1,\n persist=False,\n):\n if \"tim\" not in os.listdir():\n logger_tlu.warning(\"Couldn't find TIM in the program directory\")\n return False\n\n tim_name = f\"tim_tlu_{process_id}\"\n dir_name = f\"{tim_name}_dir\"\n logger_tlu.debug(f\"Name of the new TIM file: {tim_name}\")\n shutil.copyfile(\"tim\", tim_name)\n\n # Making the new tim file executable\n st = os.stat(tim_name)\n os.chmod(tim_name, st.st_mode | stat.S_IEXEC)\n\n results = []\n\n # For persistent parameters - making the b and M matrices\n if persist:\n b = np.zeros((df_feats.shape[1], 1))\n m_inv = np.eye(df_feats.shape[1], df_feats.shape[1])\n else:\n b = None\n m_inv = None\n\n for t in times:\n if style == \"additive\":\n df_t = df_edges[df_edges[\"day\"] <= t].sort_values(\"source\").reset_index()\n elif style == \"dynamic\":\n df_t = df_edges[df_edges[\"day\"] == t].sort_values(\"source\").reset_index()\n\n df_feats_t = df_t[\"index\"].apply(lambda x: df_feats.loc[x])\n\n result_oim = oim_node2vec(\n df_t,\n df_feats_t,\n nodes,\n num_inf=num_seeds,\n sigma=sigma,\n c=c,\n epsilon=epsilon,\n num_repeats=num_repeats_oim,\n num_repeats_reward=num_repeats_oim_reward,\n oracle=partial(tim_parallel, tim_file=tim_name, temp_dir=dir_name),\n hide_tqdm=True,\n persist=persist,\n m_inv=m_inv,\n b=b,\n )\n\n result_oim[\"time\"] = t\n\n if persist:\n m_inv = result_oim.pop(\"m_inv\")\n b = result_oim.pop(\"b\")\n\n results.append(result_oim)\n\n logger_tlu.debug(\n f\"Removing the new TIM files {tim_name} and the temp directories {dir_name}\"\n )\n os.remove(tim_name)\n shutil.rmtree(dir_name)\n\n return pd.DataFrame(results)","def find_min_hamiltonian_path(G,weights,probs_instead_of_weights=False):\n\n # Create a new model\n m = Model(\"hamiltonian_cycle\")\n \n # Create variables\n x_vars = {}\n u_vars = {}\n for var1 in permute(G.vertices()):\n for var2 in permute(G.vertices()):\n if var1 != var2:\n x_vars[(var1,var2)] = m.addVar(vtype='B', name=\"x_\"+str(var1)+'_'+str(var2))\n u_vars[var1] = m.addVar(vtype=GRB.INTEGER, name=\"u_\"+str(var1))\n m.update()\n \n for var in G.vertices():\n if var != START_NODE:\n cur_incoming = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[1] == var)])\n #print(cur_incoming)\n m.addConstr(cur_incoming,GRB.EQUAL,1.0)\n \n if var != END_NODE:\n cur_outgoing = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[0] == var)])\n #print(cur_outgoing)\n m.addConstr(cur_outgoing,GRB.EQUAL,1.0)\n \n for var1 in G.vertices():\n for var2 in G.vertices():\n if var1 != var2:\n c = LinExpr([(1.0,u_vars[var1]),(-1.0,u_vars[var2]),(G.num_vertices(),x_vars[(var1,var2)])])\n #print(c)\n m.addConstr(c,GRB.LESS_EQUAL,G.num_vertices()-1)\n \n # Set objective\n #try:\n edge_weights = permute(G.get_edge_weights(weights))\n if probs_instead_of_weights:\n all_probs = []\n for v in G.vertices():\n if v != END_NODE:\n batch_scores = [(e,w) for e,w in edge_weights if e[0] == v]\n S = logsumexp([x[1] for x in batch_scores])\n batch_scores = [(e,np.exp(w-S)) for e,w in batch_scores]\n all_probs.extend(batch_scores)\n edge_weights = all_probs\n objective = LinExpr([(weight,x_vars[edge]) for edge,weight in edge_weights])\n #except TypeError:\n # return None\n \n m.setObjective(objective,GRB.MINIMIZE)\n m.update()\n code = m.optimize()\n \n try:\n return [k for k,v in x_vars.items() if v.x > 0.98]\n except GurobiError:\n return None","def _get_full_graph(self):","def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\n\n # Raise('NotImplementedError: only adjusted the arguments.')\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\n #precompute the expensive operation:\n lin_penalties = 1/np.sqrt(2*eta_lin)\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\n #!!!!\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\n #!!!!\n u_prev = u_init + 1\n u = u_init\n count = 0\n obj_history = []\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\n start = time.time()\n \n u_prev = np.copy(u)\n w_0 = w_0_update(eta_0, u, T, alpha, B) \n w = w_update(u, H, gamma, D, C) \n w_lin = w_lin_update(u, L_lhs, L_rhs)\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\n #!!!!\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\n #!!!!\n count += 1 \n if count == 10:\n u_inf = np.copy(u)\n w_0_inf = w_0[:]\n w_inf = w[:]\n w_lin_inf = w_lin[:]\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\n \n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\n obj_history.append(cur_obj)\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\n relaxed_obj_history.append(cur_relaxed_obj) \n \n stop = time.time()\n duration = stop-start\n \n if count%1 == 0 and verbose: \n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\n print(' This iteration took: {}'.format(duration))\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history","def theta_v_time():\n pass","def hessian_cost(self, joint_angles: dict, ee_goals) -> np.ndarray:\n kinematic_map = self.kinematic_map[\"p0\"] # get map to all nodes from root\n end_effector_nodes = ee_goals.keys()\n H = np.zeros((self.n, self.n))\n for (\n ee\n ) in end_effector_nodes: # iterate through end-effector nodes, assumes sorted\n ee_path = kinematic_map[ee][\n 1:\n ] # [:-1] # no last node, only phys. joint locations\n t_ee = self.get_pose(joint_angles, ee).trans\n dg_ee_x = t_ee[0] - ee_goals[ee].trans[0]\n dg_ee_y = t_ee[1] - ee_goals[ee].trans[1]\n for (pdx, joint_p) in enumerate(ee_path): # algorithm fills Hess per column\n p_idx = int(joint_p[1:]) - 1\n sin_p_term = 0.0\n cos_p_term = 0.0\n for jdx in range(pdx, len(ee_path)):\n node_jdx = ee_path[jdx]\n theta_jdx = sum([joint_angles[key] for key in ee_path[0 : jdx + 1]])\n sin_p_term += self.a[node_jdx] * np.sin(theta_jdx)\n cos_p_term += self.a[node_jdx] * np.cos(theta_jdx)\n\n for (qdx, joint_q) in enumerate(\n ee_path[pdx:]\n ): # TODO: check if starting from pdx works\n qdx = qdx + pdx\n q_idx = int(joint_q[1:]) - 1\n sin_q_term = 0.0\n cos_q_term = 0.0\n for kdx in range(qdx, len(ee_path)):\n node_kdx = ee_path[kdx]\n theta_kdx = sum(\n [joint_angles[key] for key in ee_path[0 : kdx + 1]]\n )\n sin_q_term += self.a[node_kdx] * np.sin(theta_kdx)\n cos_q_term += self.a[node_kdx] * np.cos(theta_kdx)\n\n # assert(q_idx >= p_idx)\n H[p_idx, q_idx] += (\n 2.0 * sin_q_term * sin_p_term\n - 2.0 * dg_ee_x * cos_q_term\n + 2.0 * cos_p_term * cos_q_term\n - 2.0 * dg_ee_y * sin_q_term\n )\n\n return H + H.T - np.diag(np.diag(H))","def linearize_and_solve(g):\n\n # initialize the sparse H and the vector b\n H = np.zeros((len(g.x), len(g.x)), dtype='float')\n b = np.zeros(len(g.x), dtype='float')\n\n # set flag to fix gauge\n needToAddPrior = True\n Fx = 0\n\n # compute the addend term to H and b for each of our constraints\n print('linearize and build system')\n\n for edge in g.edges:\n\n # pose-pose constraint\n if edge.Type == 'P':\n\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node state for the current edge\n x_i = g.x[fromIdx:fromIdx + 3]\n x_j = g.x[toIdx:toIdx + 3]\n\n # (TODO) compute the error and the Jacobians\n e, A, B = linearize_pose_pose_constraint(\n x_i, x_j, edge.measurement)\n\n # # (TODO) compute the terms\n b_i = e.transpose() @ edge.information @ A\n b_j = e.transpose() @ edge.information @ B\n H_ii = A.transpose() @ edge.information @ A\n H_ij = A.transpose() @ edge.information @ B\n H_jj = B.transpose() @ edge.information @ B\n\n # (TODO) add the terms to H matrix and b\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\n H[toIdx:toIdx + 3, toIdx:toIdx + 3] += H_jj\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 3] += H_ij\n H[toIdx:toIdx + 3, fromIdx:fromIdx + 3, ] += H_ij.transpose()\n b[fromIdx:fromIdx + 3] += b_i[0, :]\n b[toIdx:toIdx + 3] += b_j[0, :]\n\n # Add the prior for one pose of this edge\n # This fixes one node to remain at its current location\n if needToAddPrior:\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx +\n 3] = H[fromIdx:fromIdx + 3,\n fromIdx:fromIdx + 3] + 1000 * np.eye(3)\n needToAddPrior = False\n\n # pose-pose constraint\n elif edge.Type == 'L':\n print(\"you shouldn't be here...\")\n # compute idx for nodes using lookup table\n fromIdx = g.lut[edge.fromNode]\n toIdx = g.lut[edge.toNode]\n\n # get node states for the current edge\n x = g.x[fromIdx:fromIdx + 3]\n l = g.x[toIdx:toIdx + 2]\n\n # (TODO) compute the error and the Jacobians\n e, A, B = linearize_pose_landmark_constraint(\n x, l, edge.measurement)\n\n # (TODO) compute the terms\n b_i = e.transpose() @ edge.information @ A\n b_j = e.transpose() @ edge.information @ B\n H_ii = A.transpose() @ edge.information @ A\n H_ij = A.transpose() @ edge.information @ B\n H_jj = B.transpose() @ edge.information @ B\n\n # (TODO )add the terms to H matrix and b\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\n H[toIdx:toIdx + 2, toIdx:toIdx + 2] += H_jj\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 2] += H_ij\n H[toIdx:toIdx + 2, fromIdx:fromIdx + 3, ] += H_ij.transpose()\n b[fromIdx:fromIdx + 3] = b_i\n b[toIdx:toIdx + 2] = b_j\n # solve system\n dx = np.linalg.solve(H, b)\n\n return dx","def floydWarshall(graph):\n \"\"\" initializing the solution matrix same as input graph matrix\n OR we can say that the initial values of shortest distances\n are based on shortest paths considerting no \n intermedidate vertices \"\"\"\n V = len(graph[0])\n dist = [[elem for elem in line] for line in graph]\n \n \"\"\" Add all vertices one by one to the set of intermediate\n vertices.\n ---> Before start of a iteration, we have shortest distances\n between all pairs of vertices such that the shortest\n distances consider only the vertices in set \n {0, 1, 2, .. k-1} as intermediate vertices.\n ----> After the end of a iteration, vertex no. k is\n added to the set of intermediate vertices and the \n set becomes {0, 1, 2, .. k}\n \"\"\"\n for k in range(V):\n \n # pick all vertices as source one by one\n for i in range(V):\n \n # Pick all vertices as destination for the\n # above picked source\n for j in range(V):\n \n # If vertex k is on the shortest path from \n # i to j, then update the value of dist[i][j]\n dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])\n\n for line in dist:\n print line\n\n return dist"],"string":"[\n \"def params(timeseries_input):\\n # Settings for Nelder Mead Algorithm\\n global timeseries\\n timeseries=timeseries_input\\n\\n NumIters = 1 # First Iteration\\n MaxIters = 1e3 # Maximum number of iterations\\n Tolerance = 1e-5 # Tolerance on best and worst function values\\n N = 5 # Number of Heston and Nandi parameters\\n r = 0.01 / 252.0 # Risk Free Rate\\n\\n # Heston and Nandi parameter starting values (vertices) in vector form\\n\\n x = [[0 for i in range(N + 1)] for j in range(N)]\\n x[0][0] = 5.02e-6;\\n x[0][1] = 5.12e-6;\\n x[0][2] = 5.00e-6;\\n x[0][3] = 4.90e-6;\\n x[0][4] = 4.95e-6;\\n x[0][5] = 4.99e-6 # omega\\n x[1][0] = 1.32e-6;\\n x[1][1] = 1.25e-6;\\n x[1][2] = 1.35e-6;\\n x[1][3] = 1.36e-6;\\n x[1][4] = 1.30e-6;\\n x[1][5] = 1.44e-6 # alpha\\n x[2][0] = 0.79;\\n x[2][1] = 0.80;\\n x[2][2] = 0.78;\\n x[2][3] = 0.77;\\n x[2][4] = 0.81;\\n x[2][5] = 0.82 # beta\\n x[3][0] = 427.0;\\n x[3][1] = 421.0;\\n x[3][2] = 425.0;\\n x[3][3] = 419.1;\\n x[3][4] = 422.1;\\n x[3][5] = 430.0 # gamma\\n x[4][0] = 0.21;\\n x[4][1] = 0.20;\\n x[4][2] = 0.22;\\n x[4][3] = 0.19;\\n x[4][4] = 0.18;\\n x[4][5] = 0.205 # lambda\\n\\n # Run Nelder Mead and output Nelder Mead results\\n B = NelderMead(LogLike, N, NumIters, MaxIters, Tolerance, x, r)\\n\\n #\\tprint(\\\"Nelder Mead Minimization of Log-Likelihood for Heston and Nandi parameters\\\")\\n #\\tprint(\\\"---------------------------------\\\")\\n #\\tprint(\\\"omega = \\\", B[0])\\n #\\tprint(\\\"alpha = \\\", B[1])\\n #\\tprint(\\\"beta = \\\", B[2])\\n #\\tprint(\\\"gamma = \\\", B[3])\\n #\\tprint(\\\"lambda = \\\", B[4])\\n #\\tprint(\\\"Value of Objective Function = \\\", B[N])\\n #\\tprint(\\\"Number of Iterations = \\\", B[N+1])\\n #\\tprint(\\\"Persistence \\\", B[2]+B[1]*(B[3]**2) )\\n #\\tprint(\\\"---------------------------------\\\")\\n\\n # alpha,beta,gamma,omega,lambda\\n return [B[1], B[2], B[3], B[0], B[4]]\",\n \"def rwgraph_analyze2(input=(None)):\\r\\n\\r\\n\\r\\n #set up graph and degree distribution arrays\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n Nt=100\\r\\n M=20000\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n\\r\\n #set inital conditions and D\\r\\n y0=np.zeros(n,dtype=int)\\r\\n y0[j]=200\\r\\n D=1\\r\\n #define time for odi Int\\r\\n t=np.arange(Nt+1,dtype=int)\\r\\n #set up operators\\r\\n A = nx.adjacency_matrix(G)\\r\\n Q = A.toarray().sum(axis=1)\\r\\n L=np.diag(Q)-A.toarray()\\r\\n Q_inv=1/Q\\r\\n Ls=np.diag(np.ones(n))-np.matmul(np.diag(Q_inv),A.toarray())\\r\\n Ls_tran=np.transpose(Ls)\\r\\n\\r\\n #convert to sparse operators and include diffusion\\r\\n L_spar = scipy.sparse.csr_matrix(-D*L)\\r\\n Ls_spar = scipy.sparse.csr_matrix(-D*Ls)\\r\\n Ls_tran_spar = scipy.sparse.csr_matrix(-D*Ls_tran)\\r\\n A=nx.adjacency_matrix(G)\\r\\n L=-D*(scipy.sparse.diags(degree_arr)-A)\\r\\n Ls=-D*(scipy.sparse.diags(np.ones(N))-scipy.sparse.diags(1/degree_arr).dot(A))\\r\\n\\r\\n #define operators\\r\\n def Lap(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(L_spar,y)\\r\\n def Lap_Ls(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_spar,y)\\r\\n def Lap_Ls_tran(y,t):\\r\\n return scipy.sparse.csr_matrix.__mul__(Ls_tran_spar,y)\\r\\n\\r\\n #solutions of different operators\\r\\n solL=scipy.integrate.odeint(Lap,y0,t)\\r\\n solLs=scipy.integrate.odeint(Lap_Ls,y0,t)\\r\\n solLs_tran=scipy.integrate.odeint(Lap_Ls_tran,y0,t)\\r\\n\\r\\n\\r\\n #finds eigen values and vectors and puts them into order\\r\\n def eigen(L):\\r\\n eigen_values,eigen_vectors=scipy.linalg.eig(-L)\\r\\n idx = eigen_values.argsort()[::-1]\\r\\n eigen_values = eigen_values[idx]\\r\\n eigen_vectors = eigen_vectors[:,idx]\\r\\n return eigen_values,eigen_vectors\\r\\n\\r\\n #finds all eigen values and eigen vectors of the different operators. can use sparse matrics\\r\\n eigen_values_LS,eigen_vectors_LS=eigen(Ls)\\r\\n eigen_values_LS_tran,eigen_vectors_LS_tran=eigen(Ls_tran)\\r\\n eigen_values_L,eigen_vectors_L=eigen(L)\\r\\n eigen_values_L2,eigen_vectors_L2=eigen(L*0.36)\\r\\n\\r\\n ### could have eigs here as didn't end up using all eigenvalues ####\\r\\n #eigen values graph\\r\\n n0=len(eigen_values_L)\\r\\n eig_nums=np.arange(n0)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L2[0:10],s=50,marker=\\\"x\\\" ,label='L , D=0.36')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS[0:10],s=50, marker=\\\"|\\\",label='LS , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_LS_tran[0:10],s=50,marker='_',label='LS_tran , D=1')\\r\\n plt.scatter(eig_nums[0:10],eigen_values_L[0:10],s=50,marker=\\\"+\\\" ,label='L , D=1')\\r\\n plt.legend(loc=\\\"lower left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.xlabel('eigen value number')\\r\\n plt.ylabel('eigenvalue')\\r\\n plt.title(\\\"Eigenvlaues of Laplacian Matrixs\\\")\\r\\n plt.show()\\r\\n\\r\\n print(\\\"4 biggest eigenvalues for each operater\\\")\\r\\n print('L=',eigen_values_L[0:4])\\r\\n print('Ls=',eigen_values_LS[0:4])\\r\\n print('Ls_tran=',eigen_values_LS_tran[0:4])\\r\\n #prints 4 biggest eigen values\\r\\n #counts node distrubtion by creating dictionary\\r\\n def result_count(sol,Nt,G):\\r\\n \\\"\\\"\\\" returns cumlative frequency/probailties for nodes of same degree and returns dictionary\\\"\\\"\\\"\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\\r\\n\\r\\n #frequency count of solutions\\r\\n dict_freq=result_count(solL,Nt,G)\\r\\n dict_freq2=result_count(solLs,Nt,G)\\r\\n dict_freq3=result_count(solLs_tran,Nt,G)\\r\\n\\r\\n #random walk data\\r\\n X=rwgraph(G,j,20000,100)\\r\\n Listnodes7=[]\\r\\n for i in range(20000):\\r\\n Listnodes7.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,200,100)\\r\\n Listnodes8=[]\\r\\n for i in range(200):\\r\\n Listnodes8.append(G.degree(X[i,100]))\\r\\n X=rwgraph(G,j,50000,5000)\\r\\n Listnodes9=[]\\r\\n for i in range(50000):\\r\\n Listnodes9.append(G.degree(X[i,5000]))\\r\\n listfreq7=CountFrequency(Listnodes7)\\r\\n listfreq8=CountFrequency(Listnodes8)\\r\\n listfreq9=CountFrequency(Listnodes9)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n z2=[]\\r\\n z3=[]\\r\\n z1=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n z_deg1=[]\\r\\n for i in listfreq7:\\r\\n z2.append(listfreq7[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq8:\\r\\n z3.append(listfreq8[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n for i in listfreq8:\\r\\n z1.append(listfreq9[i]/(listfreq_deg[i]*50000))\\r\\n z_deg1.append(i)\\r\\n #operator solutions compared to node degree frequency\\r\\n z4,z5,z6=[],[],[]\\r\\n z_deg4,z_deg5,z_deg6=[],[],[]\\r\\n for i in dict_freq:\\r\\n z4.append(dict_freq[i]/(listfreq_deg[i]*200))\\r\\n z_deg4.append(i)\\r\\n for i in dict_freq2:\\r\\n z5.append(dict_freq2[i]/(listfreq_deg[i]*200))\\r\\n z_deg5.append(i)\\r\\n for i in dict_freq3:\\r\\n z6.append(dict_freq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg6.append(i)\\r\\n\\r\\n plt.figure(figsize=(15, 10))\\r\\n plt.scatter(z_deg1, z1,label='Nt=5000, M=50000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=100, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=100, M=200')\\r\\n plt.scatter(z_deg4, z4,label='L, Nt=100')\\r\\n plt.scatter(z_deg5, z5,label='Ls, Nt=100')\\r\\n plt.scatter(z_deg6, z6,label='Ls_tran, Nt=100')\\r\\n plt.ylim((-0.005,0.020))\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n\\r\\n #code to produce final graph\\r\\n iarray1=LinearModel(G,x=j,i0=1,L1='L',D=1,tf=20,Nt=Nt)\\r\\n iarray2=LinearModel(G,x=j,i0=1,L1='Ls',D=1,tf=20,Nt=Nt)\\r\\n iarray3=LinearModel(G,x=j,i0=1,L1='Lst',D=1,tf=20,Nt=Nt)\\r\\n tarray = np.linspace(0,5,Nt+1)\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.plot(tarray, iarray1[:,7] ,label='rand node L,deg=46',color='b',alpha=0.5)\\r\\n plt.plot(tarray, iarray2[:,7] ,label='rand node Ls,deg=46',marker='|',color='r')\\r\\n plt.scatter(tarray, iarray3[:,7] ,label='rand node LST,deg=46',marker='_',color='y')\\r\\n plt.scatter(tarray, iarray1[:,1801] ,label='rand node L, deg=5',color='m',alpha=0.5,marker='+')\\r\\n plt.plot(tarray, iarray2[:,1801] ,label='rand node Ls,deg=5',marker='|',color='c')\\r\\n plt.scatter(tarray, iarray3[:,1801] ,label='rand node LST,deg=5',marker='_',color='g')\\r\\n plt.xlabel('time')\\r\\n plt.ylabel('representive frequency')\\r\\n plt.legend()\\r\\n plt.title(\\\"Comparing repestive frequency of a random nodes, for the different linear models,time step=50,D=0.1\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def hr_egn(A, B, R, x0):\\n # A - Adjacency matrix, np.ndarray (N,N)\\n # B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)\\n # R - Relationship or preference matrix, np.ndarray (N,N)\\n # x0 - Initial state of our system, np.ndarray (N,S), must be double\\n\\n # Number of players\\n N = A[:, 0].size\\n # Number of strategies\\n S = x0[0, :].size\\n # Degree and degree of preferences\\n d = np.zeros([N, 2])\\n d[:, 0] = np.dot(A, np.ones(N))\\n\\n for v in range(N):\\n d[v, 1] = np.dot(np.ceil(np.abs(R[v, :])), A[v, :])\\n\\n # Player v neighborhood\\n k = np.zeros([N, S], dtype='double')\\n for v in range(N):\\n for u in range(N):\\n k[v, :] = np.add(k[v, :], np.multiply(A[v, u], x0[u, :]))\\n # Weights the neighborhood\\n k[v, :] = np.multiply(np.divide(1, d[v, 0]), k[v, :])\\n\\n # This variable is the increments that x0 receives, the derivative\\n x = np.zeros([N, S], dtype='double')\\n # This is the unit vector with 1 in some entry\\n es = np.zeros(S, dtype='int')\\n\\n # Phi and gamma\\n p = 0\\n g = 0\\n\\n # Auxiliary variables for better clarity\\n aux1 = 0\\n aux2 = 0\\n\\n # Here is the derivative calculation\\n # We first test if all payoffs are the same so we do less comparisons\\n if B.ndim == 2:\\n for v in range(N):\\n for s in range(S):\\n # Set es value\\n es[s] = 1\\n for u in range(N):\\n if v == u:\\n # Same payoff personal equation\\n # First we will do the dot products\\n # e_s*B*k_v\\n aux1 = np.dot(es, np.dot(B, k[v, :]))\\n # x_v*B*k_v\\n aux2 = np.dot(x0[v, :], np.dot(B, k[v, :]))\\n # Finally we subtract them to multiply by r_vv\\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\\n elif A[v, u] != 0:\\n # Same payoff social equation\\n # x_u*B*e_s\\n aux1 = np.dot(x0[u, :], np.dot(B, es))\\n # x_u*B*x_v\\n aux2 = np.dot(x0[u, :], np.dot(B, x0[v, :]))\\n # Subtract then multiply\\n aux1 = np.subtract(aux1, aux2)\\n aux2 = np.multiply(R[v, u], A[v, u])\\n g = np.add(g, np.multiply(aux2, aux1))\\n # Weights the social part\\n if d[v, 1] != 0:\\n g = np.multiply(np.divide(1, d[v, 1]), g)\\n # Estimates the derivative\\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\\n # Prepare variables to next iteration\\n p = 0\\n g = 0\\n es[s] = 0\\n else:\\n for v in range(N):\\n for s in range(S):\\n # Same thing as before, but now with individual payoffs\\n es[s] = 1\\n for u in range(N):\\n if v == u:\\n # Individual payoffs personal equation\\n # e_s*B_v*k_v\\n aux1 = np.dot(es, np.dot(B[:, :, v], k[v, :]))\\n # x_u*B_v*k_v\\n aux2 = np.dot(x0[v, :], np.dot(B[:, :, v], k[v, :]))\\n p = np.multiply(R[v, u], np.subtract(aux1, aux2))\\n elif A[v, u] != 0:\\n # Individual payoffs social equation\\n # x_u*B_u*e_s\\n aux1 = np.dot(x0[u, :], np.dot(B[:, :, u], es))\\n # x_u*B_u*x_v\\n aux2 = np.dot(x0[u, :], np.dot(B[:, :, u], x0[v, :]))\\n # Subtract then multiply\\n aux1 = np.subtract(aux1, aux2)\\n aux2 = np.multiply(R[v, u], A[v, u])\\n g = np.add(g, np.multiply(aux2, aux1))\\n # Weights the social part\\n if d[v, 1] != 0:\\n g = np.multiply(np.divide(1, d[v, 1]), g)\\n # Estimates the derivative\\n x[v, s] = np.multiply(x0[v, s], np.add(p, g))\\n # Prepare variables to next iteration\\n p = 0\\n g = 0\\n es[s] = 0\\n return x\",\n \"def energies():\\n # Hardcoded initial values\\n numsteps = 10000\\n time_max = 1\\n # Running the calculation in the solver class using the velocity verlet method\\n # for better accuracy.\\n verlet = solver(input_matrix, 'verlet', time_max, numsteps)\\n output_matrix, KE, PE, AM = verlet.main()\\n # Creating a simple time axis for plotting\\n x = np.linspace(0, 1, numsteps+1)\\n\\n # Plotting kinetic energy over time\\n plt.figure(1, figsize=(10, 10))\\n plt.plot(x, KE)\\n plt.suptitle('Total kinetic energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['KE'])\\n\\n # Plotting potential energy over time\\n plt.figure(2, figsize=(10, 10))\\n plt.plot(x, PE)\\n plt.suptitle('Total potential energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['PE'])\\n\\n # Plotting total energy against time\\n plt.figure(3, figsize=(10, 10))\\n plt.plot(x, PE+KE)\\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['KE+PE'])\\n\\n # Plotting angular momentum against time. print the amplitude to terminal\\n amplitude = max(AM)-min(AM)\\n print('Amplitude of angular momentum during 1 year: %g[AU²/yr²]' %(amplitude))\\n plt.figure(4, figsize=(10, 10))\\n plt.plot(x, AM)\\n plt.suptitle('Total angular momentum in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²/yr²]', fontsize=16)\\n plt.legend(['AM'])\\n\\n # Plotting the kinetic, potential and total energy against time to see\\n # how great the variations are\\n plt.figure(5, figsize=(10, 10))\\n plt.plot(x, PE, x, KE, x, KE+PE)\\n plt.suptitle('Total energy in the Earth-Sun system.', fontsize=24)\\n plt.xlabel('time [yr]', fontsize=16)\\n plt.ylabel('energy [AU²*kg/yr²]', fontsize=16)\\n plt.legend(['PE', 'KE', 'KE+PE'])\\n plt.show()\",\n \"def task2_extra():\\n N = 0\\n lam = 0\\n Ls = numpy.array([2*L for L in range(1,23)])\\n h = 0.01\\n tau = 0.000099\\n\\n iterss = []\\n\\n for L in Ls:\\n a = L // 2\\n print(L)\\n x = numpy.linspace(-L, L, int(2*L/h) + 1)\\n # eps = int(0.1 * len(x))\\n\\n Vm = V1D(lam, x)\\n state = phi(N, x-a)\\n\\n iters = 0\\n while True:\\n prob = numpy.abs(state)**2\\n mid = int(2*L/h) // 2\\n # if max(prob) in prob[mid-eps:mid+eps]:\\n if numpy.argmax(prob) <= mid:\\n print(iters)\\n iterss.append(iters)\\n break\\n\\n state[0] = 0\\n state[-1] = 0\\n state = implicit_scheme_step(state, tau, h, Vm)\\n iters += 1\\n\\n fig = plt.figure()\\n plt.title(\\\"Iterations of Gaussian travel to center\\\")\\n plt.xlabel(\\\"$L$\\\")\\n plt.ylabel(\\\"Time\\\")\\n plt.plot(Ls, tau*numpy.array(iterss))\\n plt.show()\\n fig.savefig(\\\"naloga2_iters_of_gaussian_travel.pdf\\\", bbox_inches=\\\"tight\\\")\",\n \"def solve(self, state, times):\",\n \"def general_solver(heat_flux, temp_initial, temp_air, k, alpha, x_grid,t_grid, upsilon, \\n bc_surface, sigma):\\n\\n # temperatures are reported as a data frame, where each column is a step in time\\n temperatures = pd.DataFrame(columns = [n for n in t_grid])\\n\\n # extract the necessary parameters to determine the surface heat losses\\n if bc_surface[0] == \\\"linear\\\":\\n h = bc_surface[1] + bc_surface[2]\\n hc = 0\\n emissivity = 0\\n elif bc_surface[0] == \\\"non-linear\\\":\\n h = 0\\n hc = bc_surface[1]\\n emissivity = bc_surface[2]\\n\\n # initialize temperature arrays for present and future temperatures\\n T = np.zeros_like(x_grid) + temp_initial\\n Tn = np.zeros_like(x_grid)\\n\\n # iterate over each time step\\n temperatures.iloc[:,0] = T\\n for j, t in enumerate(t_grid[:-1]):\\n \\n # create tri-diagonal matrix A\\n A = tridiag_matrix(bc_surface_type = bc_surface[0], upsilon = upsilon, \\n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \\n k = k, T = T, h = h, hc = hc, emissivity = emissivity, sigma = sigma)\\n \\n # create vector b\\n b = vector_b(bc_surface_type = bc_surface[0], upsilon = upsilon, \\n space_divisions = len(x_grid), dx = x_grid[1] - x_grid[0], \\n k = k, T = T, T_air = temp_air, heat_flux = heat_flux, h = h, hc = hc, \\n emissivity = emissivity, sigma = sigma, j = j)\\n \\n # calculate value of future temperature\\n Tn = np.linalg.solve(A,b)\\n \\n # update present temperature\\n T = Tn.copy()\\n \\n # store temperature profile at this time in the data frame\\n temperatures.iloc[:, j+1] = Tn\\n \\n return temperatures\",\n \"def task2_extra2():\\n N = 0\\n lam = 0\\n L = 10\\n h = 0.001\\n tau = 0.000099\\n aa = numpy.array([0.25*a for a in range((L-1)*4)])\\n x = numpy.linspace(-L, L, int(2*L/h) + 1)\\n Vm = V1D(lam, x)\\n # eps=int(0.1*len(x))\\n\\n iterss = []\\n for a in aa:\\n print(a)\\n state = phi(N, x-a)\\n\\n iters = 0\\n while True:\\n prob = numpy.abs(state)**2\\n mid = int(2*L/h) // 2\\n # if max(prob) in prob[mid-eps:mid+eps]:\\n if numpy.argmax(prob) <= mid:\\n print(iters)\\n iterss.append(iters)\\n break\\n\\n state[0] = 0\\n state[-1] = 0\\n state = implicit_scheme_step(state, tau, h, Vm)\\n iters += 1\\n\\n fig = plt.figure()\\n plt.title(\\\"Iterations of Gaussian travel to center ($L={}$)\\\".format(L))\\n plt.xlabel(\\\"$a$\\\")\\n plt.ylabel(\\\"Time\\\")\\n plt.plot(aa, tau*numpy.array(iterss))\\n plt.show()\\n fig.savefig(\\\"naloga2_iters_of_gaussian_travel_fixedL={}.pdf\\\".format(L), bbox_inches=\\\"tight\\\")\",\n \"def FigA7(case):\\n \\n #set the parameter, arrays\\n \\n n_array=np.array([1,2,3])\\n\\n #set the result arrays\\n if case==0:\\n class_number=5\\n elif case==1:\\n class_number=6\\n fate=np.zeros([class_number])#number of evolutionary fate\\n fate_matrix=np.zeros([np.size(n_array),np.size(fate)])\\n \\n time=np.linspace(0,100000, 1000000)\\n loop=10**6\\n \\\"\\\"\\\"\\n 0 Co and/or Ch cannot survive in mono-culture\\n 1 Co cannot invade\\n 2 Only equilibrium of exclusion is stable\\n 3 Only equilibrium of coexistence is stable\\n 4 Two equilibria are UNstable\\n 5 two Equilibrium are stable (which may occur only when sCO vs rCh)\\n \\\"\\\"\\\"\\n for tri in range(np.size(n_array)):\\n counter=0\\n n=n_array[tri]\\n print(str(\\\"Hill coefficient is %d\\\" %(n)))\\n fate=np.zeros([class_number])#number of evolutionary fate should be reset\\n if case==0 or case==1:\\n fname=str('parameter-sweep-MC-n%d-case%d' %(n, case))\\n else:\\n print(\\\"Error in case\\\")\\n return 1\\n \\n for i in range(loop):\\n if(i+1)%10000==0:\\n print(i+1)\\n Ks,cd,T0, alpha,=np.random.uniform(0,1,4)\\n Kr,cr=np.random.uniform([Ks,0],[1,1],2)#Kr>Ks and cr.cd\\n #check whether r is positive or not\\n if case==0:\\n r1=rmax*(1-cr-cd)#rCO\\n r2=rmax#sCH\\n W0Co=r1-dmax*T0**n/(T0**n+Kr**n)-alpha#initial growth of Cooperator\\n W0Ch=r2-dmax*T0**n/(T0**n+Ks**n)-alpha#initial growth of Cheater\\n elif case==1:\\n r1=rmax*(1-cd)#sCo\\n r2=rmax*(1-cr)#rCh\\n W0Co=r1-dmax*T0**n/(T0**n+Ks**n)-alpha\\n W0Ch=r2-dmax*T0**n/(T0**n+Kr**n)-alpha\\n stab_e=0#initialize the falgs of stability\\n stab_c=0\\n if W0Co<0 or W0Ch<0:\\n fate[0]+=1\\n res=0\\n else:\\n #succeed in mono-culture \\n init=np.array([T0,10**(-6)])\\n if case==0: \\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Kr, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Ks, alpha, n))\\n x2s=solCh[-1,1]\\n else:\\n solCo=odeint(DyCoop, init, time, args=(T0, r1, Ks, alpha, n))\\n Ts=solCo[-1,0]\\n #x1s=solCo[-1,1]\\n solCh=odeint(DyCheat, init, time, args=(T0, r2, Kr, alpha, n))\\n x2s=solCh[-1,1]\\n \\n #Evolutionary dynamics \\n if case==0:\\n K=Kr\\n else:\\n K=Ks\\n if r1*(1-x2s)-dmax*T0**n/(T0**n+K**n)<alpha:\\n #Co cannot invade\\n fate[1]+=1\\n res=1\\n else:\\n #Co can invade\\n #calculate Tdagger Td and check whether coexist or exclude\\n if case==0:\\n #rCo vs sCh\\n #in this case, at most one equilbrium is stable\\n tau=Quad(case,alpha,cr+cd,0,Kr, Ks, n)\\n Td=tau**(1/n)\\n if Td<Ts:\\n #Co exclude Ch\\n fate[2]+=1\\n res=2\\n else:\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #unstable coexistence nor exclusion\\n fate[4]+=1\\n res=4\\n print(Td, x1d, x2d)\\n else:\\n #sCo vs rCh\\n # in this case two equilibria can be stable at the same time\\n [tau_p,tau_m]=Quad(case,alpha,cd,cr,Ks, Kr, n)\\n if tau_m>Ts**n or tau_p<Ts**n:\\n # cexclusion is stable\\n stab_e=1\\n # stability in coexistence \\n if tau_p<0:\\n stab_c=0\\n else:\\n Td=tau_p**(1/n)\\n x1d=alpha*Kd*(T0-Td)/(fmax*Td-alpha*(T0-Td))\\n x2d=1-x1d-(dmax*Td**n/(Td**n+K**n)+alpha)/r1\\n #check the stability condition\\n stab=Stab_cond(alpha, T0, Td,x1d,x2d, r1,r2,n, K)\\n if stab==0:\\n #stable coexistence\\n stab_c=1\\n #classify\\n if stab_e==1 and stab_c==1:\\n # two stable equilbria\\n fate[5]+=1\\n res=5\\n elif stab_e==1 and stab_c==0:\\n #only stable cexclusion\\n fate[2]+=1\\n res=2\\n elif stab_e==0 and stab_c==1:\\n #stable coexistence\\n fate[3]+=1\\n res=3\\n else:\\n #both unstable\\n fate[4]+=1\\n res=4\\n \\n #save the results\\n if counter==0:\\n result=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n #save the result with parameter values\\n \\n else:\\n #add array of results\\n R=np.array([[Ks, Kr, cr, cd, alpha, T0,res]])\\n result=np.concatenate((result, R), axis=0)\\n counter+=1\\n \\n #save csv file and graph\\n np.savetxt(fname+'.csv',result, delimiter=',', header='Ks, Kr, cr, cd, alpha, T0, class', fmt='%.6f') \\n print(fate)\\n fate_matrix[tri,:]=fate \\n if case==0: \\n np.savetxt('parameter_sweep_MC_total_case0.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4', fmt='%d')\\n else:\\n np.savetxt('parameter_sweep_MC_total_case1.csv',fate_matrix, delimiter=',', header='cl0,l1,cl2,cl3,cl4,cl5', fmt='%d')\\n Plot(case)\",\n \"def enthalpy(temp,pres):\\n g = liq_g(0,0,temp,pres)\\n g_t = liq_g(1,0,temp,pres)\\n h = g - temp*g_t\\n return h\",\n \"def graphformation(time_lower, time_upper):\\n\\tprm = param.Para()\\n\\ttry:\\n\\t\\tdb_connection = mysql.connector.connect(\\n\\t\\t host=prm.hostname,\\n\\t\\t user=prm.username,\\n\\t\\t passwd=prm.password,\\n\\t\\t database= prm.dbname\\n\\t\\t )\\n\\t\\tdb_cursor = db_connection.cursor()\\n\\texcept:\\n\\t\\tprint(\\\"Can't Connect to database, check credentials in parameter file\\\")\\n\\tquery = (\\\"SELECT * FROM identity \\\")\\n\\tdb_cursor.execute(query)\\n\\tdf1=pd.DataFrame(db_cursor.fetchall())\\n\\tdf1.columns= ['node','deviceid','student','rollno']\\n\\tdict_identity = dict(zip(df1.deviceid, df1.node))\\n\\trev_dict_identity = dict(zip(df1.node, df1.deviceid ))\\n\\tquery = (\\\"SELECT * FROM activity WHERE time BETWEEN '{}' AND '{}'\\\".format(time_lower,time_upper)) ## incomplete\\n\\tdb_cursor.execute(query)\\n\\tactivity_data = pd.DataFrame(db_cursor.fetchall())\\n\\tif activity_data.empty==False:\\n\\t\\tactivity_data.columns=[\\\"sl_no\\\",\\\"time\\\",\\\"node\\\",\\\"latitude\\\",\\\"longitude\\\"]\\n\\telse:\\n\\t\\tprint(\\\"No Activity in the selected Time Window\\\")\\n\\t\\treturn\\n\\tnumnodes= len(df1)\\n\\tedges= []\\n\\tscore = {}\\n\\t#print(activity_data)\\n\\ttime_groups = activity_data.groupby('time')\\n\\twith open(r'C:\\\\Users\\\\HP\\\\Desktop\\\\project\\\\Contact_Graph\\\\bluetooth.txt') as json_file:\\n\\t\\tdata1 = json.load(json_file)\\n\\tfor name, group in time_groups:\\n\\t\\tscore_tmp = decayfunc(name,time_upper)\\n\\t\\tgroup = group.sort_values('node')\\n\\t\\tfor i in range(len(group)-1):\\n\\t\\t\\tnode1 = group.iloc[i,2]\\n\\t\\t\\t###########################\\n\\t\\t\\tlistnearby=[]\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tlistnearby = data1[rev_dict_identity[node1]][str(name)]\\n\\t\\t\\t\\tlistnearby = [dict_identity[i] for i in listnearby if dict_identity[i]>node1]\\n\\t\\t\\t\\tfor i in listnearby:\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tscore[(node1,i)]+=1\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tscore[(node1,i)]=1\\n\\t\\t\\texcept:\\n\\t\\t\\t\\tpass\\n\\t\\t\\t###########################\\n\\t\\t\\tfor j in range(i+1,len(group)):\\n\\t\\t\\t\\tnode2 =group.iloc[j,2]\\n\\t\\t\\t\\tif proximityfunc(group.iloc[i,3],group.iloc[i,4],group.iloc[j,3],group.iloc[j,4]) and node2 not in listnearby:\\n\\t\\t\\t\\t\\ttry:\\n\\t\\t\\t\\t\\t\\tscore[(group.iloc[i,2],group.iloc[j,2])]+=1\\n\\t\\t\\t\\t\\texcept:\\n\\t\\t\\t\\t\\t\\tscore[(group.iloc[i,2],group.iloc[j,2])]=1\\n\\tnode_list = list(df1.node)\\n\\ttitle_list = list(df1.deviceid)\\n\\tedges_list = []\\n\\tfor edge,val in score.items():\\n\\t\\tedges_list.append((int(edge[0]),int(edge[1]),float(val)))\\n\\n\\treturn edges_list,node_list,title_list\",\n \"def run(graph, time_axis, initial, element2edge, var, element_component_clause_literal_node, ts, type_num,\\n type_robot_label, buchi, show, last_subtask=None, loop=False):\\n\\n frontier = [[initial, -1, []]]\\n # iterate until the accepting state is reached\\n while True:\\n if show:\\n print([f[0] for f in frontier])\\n node, clock, acpt_run_ = frontier.pop()\\n\\n # Determine the set of identical time instants\\n instant_element = time_axis[clock + 1]\\n if acpt_run_:\\n pre_neg_edge = acpt_run_[-1]['neg_edge']\\n else:\\n pre_neg_edge = []\\n # loop over each successor to see whether progress can be made\\n for succ in graph.succ[node]:\\n # equivalent subtask\\n if graph.edges[element2edge[instant_element[1]]]['formula'] == graph.edges[(node, succ)]['formula'] and \\\\\\n graph.nodes[element2edge[instant_element[1]][0]]['formula'] == graph.nodes[node]['formula']:\\n # if isEquivalent(graph.edges[element2edge[instant_element[1]]]['formula'], graph.edges[(node, succ)]['formula']) and \\\\\\n # isEquivalent(graph.nodes[element2edge[instant_element[1]][0]]['formula'], graph.nodes[node]['formula']):\\n\\n # print((node, succ), graph.edges[(node, succ)]['formula'])\\n # whether the collection of paths at clock satisfies the edge label\\n # neg_literal: negative clause that needs to be addressed\\n # exe_robot: set of robots that takes the subtask with nonzero id\\n\\n essential_clause_edge, neg_clause_edge, exe_robots_edge \\\\\\n = determine_essentials(instant_element, var, graph.edges[(node, succ)]['label'],\\n graph.edges[(node, succ)]['neg_label'], 1,\\n element_component_clause_literal_node, ts, type_num,\\n type_robot_label, last_subtask, buchi, [], loop)\\n\\n essential_clause_vertex, neg_clause_vertex, exe_robots_vertex \\\\\\n = determine_essentials(instant_element, var, graph.nodes[node]['label'],\\n graph.nodes[node]['neg_label'], 0,\\n element_component_clause_literal_node, ts, type_num, dict(),\\n last_subtask, buchi,\\n pre_neg_edge, loop)\\n\\n # clock, the exact time when transition occurs\\n acpt_run = acpt_run_.copy() # copy the history\\n acpt_run.append({'subtask': (node, succ), 'time_element': time_axis[clock + 1],\\n 'essential_robot_edge': exe_robots_edge,\\n 'essential_clause_edge': essential_clause_edge, 'neg_edge': neg_clause_edge,\\n 'essential_robot_vertex': exe_robots_vertex,\\n 'neg_vertex': neg_clause_vertex})\\n\\n # stop when accept is reached\\n if 'accept' in succ:\\n return acpt_run\\n # clock + 1, after reaching succ, the immediate time clock that should be verified\\n frontier.append([succ, clock + 1, acpt_run])\",\n \"def create_graph_hyp_space(t=0.8, b=0.01):\\n\\n # enumerate all graphs with three nodes\\n common_cause_1 = np.array([[0, 1, 1], [0, 0, 0], [0, 0, 0]])\\n common_cause_1_cpd = [np.array([1-b, b]),\\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]]),\\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]])]\\n\\n common_cause_2 = np.array([[0, 0, 0], [1, 0, 1], [0, 0, 0]])\\n common_cause_2_cpd = [common_cause_1_cpd[i] for i in [1, 0, 2]]\\n\\n common_cause_3 = np.array([[0, 0, 0], [0, 0, 0], [1, 1, 0]])\\n common_cause_3_cpd = [common_cause_1_cpd[i] for i in [1, 2, 0]]\\n\\n common_effect_1 = np.array([[0, 0, 1], [0, 0, 1], [0, 0, 0]])\\n common_effect_1_cpd = [np.array([1-b, b]),\\n np.array([1-b, b]),\\n np.array([[[1-b, b], [(1-t)*(1-b), (t + (1-t)*b)]],\\n [[(1-t)*(1-b), (t + (1-t)*b)],\\n [(1-t)*(1-b)*(1-t),\\n (t)**2 + (t*(1-t))*2 + b*(1-t)**2]]])]\\n\\n common_effect_2 = np.array([[0, 1, 0], [0, 0, 0], [0, 1, 0]])\\n common_effect_2_cpd = [common_effect_1_cpd[i] for i in [0, 2, 1]]\\n\\n common_effect_3 = np.array([[0, 0, 0], [1, 0, 0], [1, 0, 0]])\\n common_effect_3_cpd = [common_effect_1_cpd[i] for i in [2, 0, 1]]\\n\\n causal_chain_1 = np.array([[0, 1, 0], [0, 0, 1], [0, 0, 0]])\\n causal_chain_1_cpd = [np.array([1-b, b]),\\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]]),\\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]])]\\n\\n causal_chain_2 = np.array([[0, 0, 1], [0, 0, 0], [0, 1, 0]])\\n causal_chain_2_cpd = [causal_chain_1_cpd[i] for i in [0, 2, 1]]\\n\\n causal_chain_3 = np.array([[0, 0, 0], [0, 0, 1], [1, 0, 0]])\\n causal_chain_3_cpd = [causal_chain_1_cpd[i] for i in [1, 0, 2]]\\n\\n causal_chain_4 = np.array([[0, 0, 1], [1, 0, 0], [0, 0, 0]])\\n causal_chain_4_cpd = [causal_chain_1_cpd[i] for i in [2, 0, 1]]\\n\\n causal_chain_5 = np.array([[0, 1, 0], [0, 0, 0], [1, 0, 0]])\\n causal_chain_5_cpd = [causal_chain_1_cpd[i] for i in [1, 2, 0]]\\n\\n causal_chain_6 = np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0]])\\n causal_chain_6_cpd = [causal_chain_1_cpd[i] for i in [2, 1, 0]]\\n\\n single_link_1 = np.array([[0, 1, 0], [0, 0, 0], [0, 0, 0]])\\n single_link_1_cpd = [np.array([1-b, b]),\\n np.array([[1-b, b], [(1-t)*(1-b), t + (1-t)*b]]),\\n np.array([1-b, b])]\\n\\n single_link_2 = np.array([[0, 0, 1], [0, 0, 0], [0, 0, 0]])\\n single_link_2_cpd = [single_link_1_cpd[i] for i in [0, 2, 1]]\\n\\n single_link_3 = np.array([[0, 0, 0], [1, 0, 0], [0, 0, 0]])\\n single_link_3_cpd = [single_link_1_cpd[i] for i in [1, 0, 2]]\\n\\n single_link_4 = np.array([[0, 0, 0], [0, 0, 1], [0, 0, 0]])\\n single_link_4_cpd = [single_link_1_cpd[i] for i in [2, 0, 1]]\\n\\n single_link_5 = np.array([[0, 0, 0], [0, 0, 0], [1, 0, 0]])\\n single_link_5_cpd = [single_link_1_cpd[i] for i in [1, 2, 0]]\\n\\n single_link_6 = np.array([[0, 0, 0], [0, 0, 0], [0, 1, 0]])\\n single_link_6_cpd = [single_link_1_cpd[i] for i in [2, 1, 0]]\\n\\n graph_names = [\\\"common_cause_1\\\", \\\"common_cause_2\\\", \\\"common_cause_3\\\",\\n \\\"common_effect_1\\\", \\\"common_effect_2\\\", \\\"common_effect_3\\\",\\n \\\"causal_chain_1\\\", \\\"causal_chain_2\\\", \\\"causal_chain_3\\\",\\n \\\"causal_chain_4\\\", \\\"causal_chain_5\\\", \\\"causal_chain_6\\\",\\n \\\"single_link_1\\\", \\\"single_link_2\\\", \\\"single_link_3\\\",\\n \\\"single_link_4\\\", \\\"single_link_5\\\", \\\"single_link_6\\\"]\\n\\n graphs = [common_cause_1, common_cause_2, common_cause_3,\\n common_effect_1, common_effect_2, common_effect_3,\\n causal_chain_1, causal_chain_2, causal_chain_3,\\n causal_chain_4, causal_chain_5, causal_chain_6,\\n single_link_1, single_link_2, single_link_3,\\n single_link_4, single_link_5, single_link_6]\\n\\n cpds = [common_cause_1_cpd, common_cause_2_cpd, common_cause_3_cpd,\\n common_effect_1_cpd, common_effect_2_cpd, common_effect_3_cpd,\\n causal_chain_1_cpd, causal_chain_2_cpd, causal_chain_3_cpd,\\n causal_chain_4_cpd, causal_chain_5_cpd, causal_chain_6_cpd,\\n single_link_1_cpd, single_link_2_cpd, single_link_3_cpd,\\n single_link_4_cpd, single_link_5_cpd, single_link_6_cpd]\\n\\n hyp_space = {graph_names: dag.DirectedGraph(graph, cpd, t, b)\\n for (graph_names, graph, cpd) in\\n zip(graph_names, graphs, cpds)}\\n\\n return hyp_space\",\n \"def SIRD_graph(graph_obj, config):\\n\\n N = len(graph_obj.nodes)\\n T = config['horizon']\\n si, ir, id = config['infection_rate'], config['recovery_rate'], config['death_rate']\\n sv, iv, vi = config['vaccination_rate'], config['vaccination_rate'], config['reinfection_rate']\\n\\n # ensure that sum of probabilities don't exceed 1\\n assert ir + id + iv < 1\\n assert si + sv < 1\\n\\n # initial state\\n I0, R0, D0, V0 = config['init_state']['I'], config['init_state']['R'], config['init_state']['D'], config['init_state']['V']\\n S0 = N - I0 - R0 - D0\\n assert S0 > 0\\n\\n # shuffle node list and assign initial state\\n shuffled_nodes = np.array(range(N))\\n np.random.shuffle(shuffled_nodes)\\n\\n # state array is a Nx1 vector with array[i] denoting state of ith person\\n # states for S,I,R,D,V -> (0,1,2,3,4)\\n category_array = np.zeros(N, dtype=np.uint8)\\n category_array[shuffled_nodes[:I0]] = 1\\n category_array[shuffled_nodes[I0: I0+R0]] = 2\\n category_array[shuffled_nodes[I0+R0: I0+R0+D0]] = 3\\n category_array[shuffled_nodes[I0+R0+D0: I0+R0+D0+V0]] = 4\\n\\n # state array [i][j] = category of node j after time step i\\n state_array = np.zeros((T + 1, N))\\n state_array[0] = np.copy(category_array)\\n\\n for t in range(1, T + 1):\\n if t % (T // 3) == 0:\\n print('Time step:', t, '/', T)\\n\\n cur_categories = np.copy(state_array[t - 1])\\n\\n for node in graph_obj.nodes:\\n # initialise new state with old state\\n new_state = cur_categories[node]\\n neighbours = graph_obj.adj[node]\\n i_neighbours = np.sum(cur_categories[neighbours] == 1)\\n\\n if cur_categories[node] == 0: # susceptible\\n prob_i = si * (i_neighbours / len(neighbours))\\n # S can either be vaccinated or become infected\\n next_possible_states = [1, 4, 0]\\n next_possible_probs = [prob_i, sv, 1 - prob_i - sv]\\n new_state = np.random.choice(a=next_possible_states, size=1, p=next_possible_probs)\\n\\n elif cur_categories[node] == 1: # infectious\\n # I can either recover or die\\n next_possible_states = [2, 3, 4, 1]\\n next_possible_probs = [ir, id, iv, 1 - ir - id - iv]\\n new_state = np.random.choice(a=next_possible_states, size=1, p=next_possible_probs)\\n\\n elif cur_categories[node] == 4: # vaccinated\\n prob_r = vi * (i_neighbours / len(neighbours))\\n next_possible_states = [1, 4]\\n next_possible_probs = [prob_r, 1 - prob_r]\\n new_state = np.random.choice(a=next_possible_states, size=1, p=next_possible_probs)\\n\\n # do nothing for recovered and dead\\n\\n # assign new state to current time vector\\n cur_categories[node] = new_state\\n\\n # store new time step results in final array\\n state_array[t] = cur_categories\\n\\n return state_array\",\n \"def inverse_q_learning(feature_matrix,nA, gamma, transitions, alpha_r, alpha_q, alpha_sh, epochs, real_distribution):\\n nS = feature_matrix.shape[0]\\n\\n \\n # initialize tables for reward function, value functions and state-action visitation counter.\\n r = np.zeros((nS, nA))\\n q = np.zeros((nS, nA))\\n q_sh = np.zeros((nS, nA))\\n state_action_visitation = np.zeros((nS, nA))\\n\\n for i in range(epochs):\\n if i%10 == 0:\\n print(\\\"Epoch %s/%s\\\" %(i+1, epochs))\\n \\n for traj in transitions:\\n for (s, a, _, ns) in traj:\\n state_action_visitation[s][a] += 1\\n d = False # no terminal state\\n\\n # compute shifted q-function.\\n q_sh[s, a] = (1-alpha_sh) * q_sh[s, a] + alpha_sh * (gamma * (1-d) * np.max(q[ns]))\\n \\n # compute log probabilities.\\n sum_of_state_visitations = np.sum(state_action_visitation[s])\\n log_prob = np.log((state_action_visitation[s]/sum_of_state_visitations) + epsilon)\\n \\n # compute eta_a and eta_b for Eq. (9).\\n eta_a = log_prob[a] - q_sh[s][a]\\n other_actions = [oa for oa in range(nA) if oa != a]\\n eta_b = log_prob[other_actions] - q_sh[s][other_actions]\\n sum_oa = (1/(nA-1)) * np.sum(r[s][other_actions] - eta_b)\\n\\n # update reward-function.\\n r[s][a] = (1-alpha_r) * r[s][a] + alpha_r * (eta_a + sum_oa)\\n\\n # update value-function.\\n q[s, a] = (1-alpha_q) * q[s, a] + alpha_q * (r[s, a] + gamma * (1-d) * np.max(q[ns]))\\n s = ns\\n\\n # compute Boltzmann distribution.\\n boltzman_distribution = []\\n for s in range(nS):\\n boltzman_distribution.append([])\\n for a in range(nA):\\n boltzman_distribution[-1].append(np.exp(q[s][a]))\\n boltzman_distribution = np.array(boltzman_distribution)\\n boltzman_distribution /= np.sum(boltzman_distribution, axis=1).reshape(-1, 1)\\n return q, r, boltzman_distribution\",\n \"def viterbi(self):\\n # initialisation\\n self.phi = zeros((self.noOfEmmittingStates+2, self.T + 1))\\n self.phi[0,0] = 1.0\\n for i in range(1,self.noOfEmmittingStates+2):\\n self.phi[i,0] = 0.0\\n for t in range(1,self.T+1):\\n self.phi[0,t] = 0.0\\n self.traceback = zeros((self.noOfEmmittingStates+1, self.T+1))\\n\\n # main recursion\\n for t in range(1, self.T + 1):\\n for j in range(1, self.noOfEmmittingStates + 1):\\n phiTemp = zeros((self.noOfEmmittingStates + 1, 1))\\n for k in range(self.noOfEmmittingStates+1):\\n phiTemp[k,0] = self.phi[k,t-1] * self.transitionMatrix[k, j-1]\\n self.traceback[j-1,t-1] = nonzero(phiTemp == phiTemp.max(0))[0][0]\\n self.phi[j, t] = phiTemp.max(0) * self.b[j-1, t-1]\\n\\n # last column - set states which can't reach term to 0, sub for term\\n for j in range(1,self.noOfEmmittingStates + 1):\\n if self.transitionMatrix[j,-1] == 0:\\n self.phi[j,-1] = 0\\n phiTemp = zeros((self.noOfEmmittingStates+1, 1))\\n for k in range(self.noOfEmmittingStates + 1):\\n phiTemp[k,0] = self.phi[k,-1] * self.transitionMatrix[k,-1]\\n self.traceback[-1,-1] = nonzero(phiTemp == phiTemp.max(0))[0][0]\\n self.phi[-1,-1] = phiTemp.max(0)\",\n \"def make_euler_circuit(start_node, updated_graph_instance):\\n\\n current_edges_on_graph_list = make_edges_list(updated_graph_instance.edges_dict)\\n\\n current_node = start_node\\n\\n node_visit_order = [current_node]\\n edge_visit_order = []\\n\\n # print(\\\"\\\\n\\\\n\\\\ncurrent_edges_on_graph_list:\\\", current_edges_on_graph_list)\\n\\n while len(current_edges_on_graph_list) > 0:\\n\\n # print(\\\"current_edges_on_graph_list:\\\", current_edges_on_graph_list)\\n # while there are still edges on the graph, keep traversing\\n\\n current_bridges_on_graph = get_bridges(current_edges_on_graph_list)\\n\\n edges_conn_to_current_node = get_all_conn_edges_remaining_in_graph(\\n current_node, current_edges_on_graph_list, updated_graph_instance.nodes_dict\\n )\\n\\n edge_to_traverse = choose_edge_to_traverse(\\n current_node, edges_conn_to_current_node, current_bridges_on_graph\\n )\\n\\n if edge_to_traverse in current_edges_on_graph_list:\\n\\n current_edges_on_graph_list.remove(edge_to_traverse)\\n\\n else:\\n\\n current_edges_on_graph_list.remove(edge_to_traverse[::-1])\\n\\n edge_to_traverse_list = list(edge_to_traverse)\\n # remove current node from edge to traverse\\n edge_to_traverse_list.remove(current_node)\\n # update current node to be the only node left in the edge list\\n\\n # update edge traveral list with edge just traversed\\n edge_traversed = (current_node, edge_to_traverse_list[0])\\n\\n edge_visit_order.append(edge_traversed)\\n\\n current_node = edge_to_traverse_list[0]\\n\\n # add the new current node to the nodes visit order list\\n node_visit_order.append(current_node)\\n\\n # add node visit order and edge_visit order to graph instance\\n\\n updated_graph_instance.node_visit_order = node_visit_order\\n\\n updated_graph_instance.edge_visit_order = edge_visit_order\\n\\n updated_graph_instance.node_geojson = make_node_geojson(updated_graph_instance)\\n\\n updated_graph_instance.edge_geojson = make_edge_geojson(updated_graph_instance)\\n\\n updated_graph_instance.route_geojson = make_route_geojson(updated_graph_instance)\\n\\n print(\\\"\\\\n\\\\n\\\\n\\\\n\\\\nROUTE COLLECTION\\\", updated_graph_instance.route_geojson)\\n\\n print(\\\"check done\\\")\\n\\n return updated_graph_instance\",\n \"def get_problem():\\n\\n problem = beluga.optim.Problem('Track_demo')\\n problem.mode='analytical' #Other options: 'numerical', 'dae'\\n\\n #Define independent variables\\n problem.independent('t', 's')\\n\\n # Define equations of motion\\n problem.state('x','V*cos(hdg)','k') \\\\\\n .state('y','V*sin(hdg)','k') \\\\\\n\\n # Define controls\\n problem.control('hdg','rad')\\n\\n # Define cost functional\\n problem.cost['path'] = Expression('(1-w)+w*V*conv*elev*terrain(x,y)', 's')\\n\\n #Define constraints\\n problem.constraints().initial('x-x_0','k') \\\\\\n .initial('y-y_0','k') \\\\\\n .terminal('x-x_f','k') \\\\\\n .terminal('y-y_f','k')\\n\\n #Define constants\\n problem.constant('w',0.9,'1') #Initial Terrain weighting factor\\n problem.constant('conv',1,'s/k^2') #Integral conversion factor\\n problem.constant('V',1,'k/s') #Vehicle speed\\n problem.constant('elev',0.001,'k') #Units for the elevation\\n\\n #Unit scaling\\n problem.scale.unit('k',1) \\\\\\n .unit('s',1) \\\\\\n .unit('rad',1)\\n\\n #Configure solver\\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=50, verbose = True, cached = False, number_arcs=8)\\n #problem.bvp_solver = algorithms.SingleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=50, verbose = True, cached = False)\\n\\n #Initial Guess\\n problem.guess.setup('auto',start=[16,10], costate_guess=[0.0,-0.1])\\n\\n #Add continuation steps\\n problem.steps.add_step(strategy='HPA') \\\\\\n .terminal('x', 180, 50) \\\\\\n .terminal('y', 98, 50)\\n\\n return problem\",\n \"def E_generator(beta, eta, h):\\n def E(x, y):\\n \\\"\\\"\\\"Calculate energy for matrices x, y.\\n\\n Note: the computation is not localized, so this is quite expensive.\\n \\\"\\\"\\\"\\n # sum of products of neighboring paris {xi, yi}\\n xxm = np.zeros_like(x)\\n xxm[:-1, :] = x[1:, :] # down\\n xxm[1:, :] += x[:-1, :] # up\\n xxm[:, :-1] += x[:, 1:] # right\\n xxm[:, 1:] += x[:, :-1] # left\\n xx = np.sum(xxm * x)\\n xy = np.sum(x * y)\\n xsum = np.sum(x)\\n return h * xsum - beta * xx - eta * xy\\n\\n def is_valid(i, j, shape):\\n \\\"\\\"\\\"Check if coordinate i, j is valid in shape.\\\"\\\"\\\"\\n return i >= 0 and j >= 0 and i < shape[0] and j < shape[1]\\n\\n def localized_E(E1, i, j, x, y):\\n \\\"\\\"\\\"Localized version of Energy function E.\\n\\n Usage: old_x_ij, new_x_ij, E1, E2 = localized_E(Ecur, i, j, x, y)\\n \\\"\\\"\\\"\\n oldval = x[i, j]\\n newval = oldval * -1 # flip\\n # local computations\\n E2 = E1 - (h * oldval) + (h * newval)\\n E2 = E2 + (eta * y[i, j] * oldval) - (eta * y[i, j] * newval)\\n adjacent = [(0, 1), (0, -1), (1, 0), (-1, 0)]\\n neighbors = [x[i + di, j + dj] for di, dj in adjacent\\n if is_valid(i + di, j + dj, x.shape)]\\n E2 = E2 + beta * sum(a * oldval for a in neighbors)\\n E2 = E2 - beta * sum(a * newval for a in neighbors)\\n return oldval, newval, E1, E2\\n\\n return E, localized_E\",\n \"def test_tdsp_dijsktra_with_timesteps_key_error(self):\\n input_file = \\\"/home/andy/code/python/om_task/data/input_data2.txt\\\"\\n graph_data = process_input_file(input_file)\\n\\n graphs = {}\\n\\n today = datetime.today()\\n t = time(0, 0) # input time value\\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\\n\\n #print(\\\"graph_data = \\\", graph_data)\\n print(\\\"graph_data[4] = \\\", graph_data[4])\\n\\n for timestep in graph_data:\\n # print(\\\"Timestep=\\\", timestep)\\n # Create a graph for each timestep\\n graphs[timestep] = Graph()\\n for edge in graph_data.get(timestep):\\n graphs[timestep].add_edge(*edge)\\n\\n for graph in graphs:\\n print(graphs[graph].edges)\\n print(graphs[graph].weights)\\n\\n print(\\\"graph[4].weights = \\\", graphs[4].weights)\\n\\n print(\\\"Start Test 1\\\")\\n path = tdsp_dijsktra(graphs, start_time, 'A0', 'E1')\\n print(\\\"Path = \\\", path)\\n self.assertEqual(['A0', 'B9', 'C0', 'D0', 'E1'], path)\",\n \"def algo_graph_iht(\\n x_mat, y_tr, max_epochs, lr, x_star, x0, tol_algo, edges, costs, s,\\n g=1, root=-1, gamma=0.1, proj_max_num_iter=50, verbose=0):\\n start_time = time.time()\\n x_hat = np.copy(x0)\\n xtx = np.dot(np.transpose(x_mat), x_mat)\\n xty = np.dot(np.transpose(x_mat), y_tr)\\n\\n # graph projection para\\n h_low = int(len(x0) / 2)\\n h_high = int(h_low * (1. + gamma))\\n t_low = int(s)\\n t_high = int(s * (1. + gamma))\\n\\n num_epochs = 0\\n for epoch_i in range(max_epochs):\\n num_epochs += 1\\n grad = -1. * (xty - np.dot(xtx, x_hat))\\n head_nodes, proj_gradient = algo_head_tail_bisearch(\\n edges, grad, costs, g, root, h_low, h_high,\\n proj_max_num_iter, verbose)\\n bt = x_hat - lr * proj_gradient\\n tail_nodes, proj_bt = algo_head_tail_bisearch(\\n edges, bt, costs, g, root, t_low, t_high,\\n proj_max_num_iter, verbose)\\n x_hat = proj_bt\\n\\n # early stopping for diverge cases due to the large learning rate\\n if np.linalg.norm(x_hat) >= 1e3: # diverge cases.\\n break\\n if np.linalg.norm(y_tr - np.dot(x_mat, x_hat)) <= tol_algo:\\n break\\n x_err = np.linalg.norm(x_hat - x_star)\\n run_time = time.time() - start_time\\n return x_err, num_epochs, run_time\",\n \"def graph_eigenvalues(N, eigenvalues,interval):\\n (a,b) =interval\\n a=abs(a-b)\\n n=[]\\n E_numeric=[]\\n E_anlytic=[]\\n E_anlytic_harm=[]\\n \\n for i in range(N-1):\\n n.append(i)\\n E_numeric.append(eigenvalues[0,i])\\n E_anlytic.append((((math.pi)**2)*(i**2))/(a**2))\\n E_anlytic_harm.append(((1/2)**0.5)*((i)+(1/2)))\\n plt.plot(n,E_numeric,'b')\\n plt.plot(n,E_anlytic,'g')\\n plt.plot(n,E_anlytic_harm,'r')\\n plt.xlabel('n', fontsize=20, color='black')\\n plt.ylabel('E', fontsize=20, color='black')\\n plt.show()\\n return None\",\n \"def solve_rocket_equations():\\n # initial data\\n u0 = numpy.array([h0,v0,mp0])\\n t = [0.0] # The array of times\\n u = [u0] # The array of evolved solutions\\n # Evolve!\\n while u[-1][0] >= 0.0:\\n t.append(t[-1]+dt)\\n u.append(euler_step(u[-1],t[-1],rhs,dt))\\n return numpy.array(t),numpy.array(u)\",\n \"def get_problem():\\n\\n # Rename this and/or move to optim package?\\n problem = beluga.optim.Problem('Hannibal_HPAdemo')\\n problem.mode='analytical' #Other options: 'numerical', 'dae'\\n\\n #Define independent variables\\n problem.independent('t', 's')\\n\\n #~~~~~!!!\\n #problem.quantity('terrain3','(-0.3*exp(-0.5*((x-2.7)^2+1.5*(y-2.1)^2))+2.6*exp(-0.55*(0.87*(x-6.7)^2+(y-2.2)^2))+2.1*exp(-0.27*(0.2*(x-5.5)^2+(y-7.2)^2))+1.6*(cos(0.8*y))^2*(sin(0.796*x))^2)')\\n\\n # Define equations of motion\\n problem.state('x','V*cos(hdg)','m') \\\\\\n .state('y','V*sin(hdg)','m') \\\\\\n\\n # Define controls\\n problem.control('hdg','rad')\\n\\n # Define Cost Functional\\n problem.cost['path'] = Expression('(1-w)+w*V*conv*elev*terrain(x,y)', 's')\\n\\n #Define constraints\\n problem.constraints().initial('x-x_0','m') \\\\\\n .initial('y-y_0','m') \\\\\\n .terminal('x-x_f','m') \\\\\\n .terminal('y-y_f','m')\\n\\n #Define constants\\n problem.constant('w',0.9,'1') #Initial Terrain weighting factor\\n problem.constant('conv',1,'s/m^2') #Integral conversion factor\\n problem.constant('V',1,'m/s') #Vehicle speed\\n problem.constant('elev',1,'m') #Initial Elevation\\n\\n #Unit scaling\\n problem.scale.unit('m',1) \\\\\\n .unit('s',1) \\\\\\n .unit('rad',1)\\n\\n #Configure solver\\n #problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=8)\\n problem.bvp_solver = algorithms.SingleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=15, verbose = True, cached = False)\\n\\n #Initial Guess (Classic test example [4.9,0.4])\\n problem.guess.setup('auto',start=[9.0,0.5], costate_guess=[0.0,-0.1]) #City A\\n #problem.guess.setup('auto',start=[4.9,0.4], costate_guess=[0.1,-0.1]) #City A\\n\\n #Add Continuation Steps (Classic test example [7.2,8.5]) [8, 4.5]\\n problem.steps.add_step(strategy='HPA',hweight=0.9) \\\\\\n .terminal('x', 3.0, 10) \\\\\\n .terminal('y', 9.5, 10) \\\\\\n # .const('w', 0.9, 2, confined=True)\\n\\n #problem.steps.add_step(strategy='manual').num_cases(10) \\\\\\n # .terminal('x', 3.0) \\\\\\n # .terminal('y', 9.5) \\\\\\n\\n #problem.steps.add_step().num_cases(30) \\\\\\n # .const('w',0.99) #Final Terrain weighting factor\\n\\n\\n return problem\",\n \"def hyperbolic_generator():\\n\\n hyperbolicRadius = np.arccosh(1 + N / (2 * np.pi * pointDensity))\\n hyperbolicThreshold = np.arccosh(1 + thresholdFrac * (np.cosh(hyperbolicRadius) - 1))\\n\\n data_hyperbolic = []\\n for r in range(num_graphs):\\n # generates dictionary of positions (in a circle of radius) for each node: node_pos = {node_i: (radius, theta)} <-- uses polar coordinates\\n # uses the inversion sampling idea to give Euclidean radii sampled uniformly across a hyperbolic sheet\\n node_pos = {}\\n for i in range(N):\\n rnd_angle = np.random.random() * 2 * np.pi\\n p = np.random.random() # random float between 0 and 1\\n rnd_radii = np.arccosh(1 + p * (np.cosh(hyperbolicRadius) - 1)) # <-- inversion sampling\\n node_pos.update({i: (rnd_radii, rnd_angle)})\\n\\n # computes the adjacency matrix\\n Adj_Matrix = np.zeros((N, N))\\n for i in range(N):\\n for j in range(N):\\n ij_dist = hyp_dist(node_pos[i], node_pos[j])\\n if ij_dist < hyperbolicThreshold:\\n Adj_Matrix[i, j] = 1 # nodes that are connected are assigned a 1 in the matrix\\n\\n data_hyperbolic.append(Adj_Matrix)\\n\\n return data_hyperbolic\",\n \"def integration_testing(solver):\\n time_step = [g_initial_time + step for step in g_time_steps]\\n u = 0.0\\n system_equation = lambda t, state, u: system(t, state, u)\\n system_jacobian = lambda t, state, u: jacobian(t, state, u)\\n solver.set_system_equation(system_equation, system_jacobian)\\n solver.set_initial_value(g_initial_value, g_initial_time)\\n assert g_initial_time == solver.t\\n for steps in time_step:\\n solver.set_f_params(u)\\n state = solver.integrate(steps)\\n assert all(state == solver.y), \\\"state error\\\"\\n assert solver.t == steps, \\\"time error, desired and actual time are not the same\\\"\",\n \"def tryEverything(g, verbose, graphname):\\r\\n prio = ['rku', 'random', 'BIL', 'rkd', 'cluHPS', 'rkusd', 'rkuad']\\r\\n placement = ['eft', 'BIM*', 'OLB', 'MET', 'DL', 'GDL']\\r\\n costFunction = ['mean', 'median', 'maxmax', 'minmax', 'minmin', 'maxmin']\\r\\n desc = ['DLS/DC', None, 'DCP']\\r\\n useOfBIM = [False, True]\\r\\n insertion = [False, True]\\r\\n BSA = [False, True]\\r\\n res: Dict[str, List[float]] = {}\\r\\n cnt = 0\\r\\n\\r\\n for ip, p in enumerate(prio):\\r\\n for ipl, pl in enumerate(placement):\\r\\n for ic, c in enumerate(costFunction):\\r\\n if p != 'BIL' or c == 'mean' or pl in ['DL', 'GDL']:\\r\\n for idd, d in enumerate(desc):\\r\\n for iu, u in enumerate(useOfBIM):\\r\\n for ii, i in enumerate(insertion):\\r\\n for ib, b in enumerate(BSA):\\r\\n cnt += 1\\r\\n name = \\\";\\\".join(map(str, [ip, ic, ipl, idd, iu, ii, ib]))\\r\\n\\r\\n # dispName = \\\"-\\\".join(map(str, [p, pl, c, d, u, i, b]))\\r\\n # print(\\\"Heuristic n°\\\", cnt, \\\"-\\\", dispName)\\r\\n # print(\\\"Heuristic n°\\\", cnt, \\\"-\\\", name)\\r\\n\\r\\n startScheduling = timeit.default_timer()\\r\\n try:\\r\\n schedule = computeSchedule(g, strategyPrio=p, costFunction=c,\\r\\n strategyPlacement=pl,\\r\\n useOfBIM=u, desc=d,\\r\\n insertion=i, bsa=b, verbose=verbose)\\r\\n verifPrec(g, schedule, verbose)\\r\\n endScheduling = timeit.default_timer()\\r\\n # print(\\\"Ended in :\\\", 1000*(endScheduling - startScheduling), \\\"ms\\\")\\r\\n # print(\\\"Ended in :\\\", round(1000 * (endScheduling - startScheduling),2), \\\"ms\\\")\\r\\n timeS = round(1000 * (endScheduling - startScheduling), 2)\\r\\n # print(f\\\"timeS : {timeS}\\\")\\r\\n if verbose:\\r\\n print(f\\\"Time : {timeS}ms\\\")\\r\\n res[name] = [round(schedule[getExitTask(g)][2], 6), timeS]\\r\\n except Exception as _:\\r\\n\\r\\n print(\\\"Error for : \\\" + name + \\\" on file \\\" + graphname)\\r\\n file = open(\\\"error.log\\\", 'a')\\r\\n file.write(f\\\"Error for {name} on file {graphname}\\\\n\\\")\\r\\n file.close()\\r\\n raise _\\r\\n return res\\r\\n return res\",\n \"def test_tdsp_dijsktra_with_timesteps(self):\\n input_file = \\\"/home/andy/code/python/om_task/data/test_data3.txt\\\"\\n graph_data = process_input_file(input_file)\\n\\n graphs = {}\\n\\n today = datetime.today()\\n t = time(0, 0) # input time value\\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\\n\\n for timestep in graph_data:\\n # print(\\\"Timestep=\\\", timestep)\\n # Create a graph for each timestep\\n graphs[timestep] = Graph()\\n for edge in graph_data.get(timestep):\\n graphs[timestep].add_edge(*edge)\\n\\n for graph in graphs:\\n print(graphs[graph].edges)\\n print(graphs[graph].weights)\\n\\n print(\\\"Start Test 1\\\")\\n path = tdsp_dijsktra(graphs, start_time, 'A0', 'A1')\\n print(path)\\n self.assertEqual(['A0', 'B0', 'B1', 'A1'], path)\\n\\n print(\\\"Start Test 2\\\")\\n t = time(0, 0) # input time value\\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\\n path = tdsp_dijsktra(graphs, start_time, 'B0', 'A1')\\n print(path)\\n self.assertEqual(['B0', 'B1', 'A1'], path)\\n\\n print(\\\"Start Test 3\\\")\\n t = time(1, 1) # input time value\\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\\n path = tdsp_dijsktra(graphs, start_time, 'B0', 'A1')\\n print(path)\\n self.assertEqual(['B0', 'A1'], path)\",\n \"def g_dynamic_programming_algorithm(self, vehicle_id, Flag):\\r\\n for t in range(self.g_number_of_time_intervals):\\r\\n self.g_time_dependent_state_vector[vehicle_id][t] = C_time_indexed_state_vector()\\r\\n self.g_time_dependent_state_vector[vehicle_id][t].Reset()\\r\\n self.g_time_dependent_state_vector[vehicle_id][t].current_time = t\\r\\n\\r\\n self.g_ending_state_vector[vehicle_id] = C_time_indexed_state_vector()\\r\\n self.g_ending_state_vector[vehicle_id].Reset()\\r\\n max_time_interval = 0\\r\\n # 1.Initial state for original depot\\r\\n new_element = CVSState()\\r\\n new_element.current_node_id = self.origin\\r\\n new_element.remaining_capacity = self.capacity\\r\\n new_element.node_seq.append(self.origin)\\r\\n new_element.node_serving_state = [0] * self.g_number_of_nodes\\r\\n self.g_time_dependent_state_vector[vehicle_id][0].update_state(new_element, Flag)\\r\\n for t in range(self.g_number_of_time_intervals):\\r\\n for index in range(min(len(self.g_time_dependent_state_vector[vehicle_id][t].VSStateVector), self.Best_K_Size)):\\r\\n pElement = self.g_time_dependent_state_vector[vehicle_id][t].VSStateVector[index]\\r\\n from_node_id = pElement.current_node_id # 起点ID\\r\\n from_node = self.node_list[from_node_id] # 起点\\r\\n for i in range(from_node.outbound_size): # 邻接点\\r\\n to_node_id = from_node.outbound_nodes_list[i] # 从当前点可以到达哪些点ID\\r\\n to_node = self.node_list[to_node_id] # 邻接点\\r\\n link_to = from_node.outbound_links_list[i] # 邻接路段\\r\\n if link_to.mean == 0:\\r\\n next_time =t+1\\r\\n else:\\r\\n next_time = t + link_to.mean\\r\\n\\r\\n if next_time > self.g_number_of_time_intervals - 1:\\r\\n continue\\r\\n # Case 1: to_node is the destination\\r\\n if to_node_id == self.destination:\\r\\n new_element = CVSState()\\r\\n new_element.my_copy(pElement)\\r\\n # new_element.current_node_id = to_node_id\\r\\n # new_element.remaining_capacity -= to_node.demand\\r\\n new_element.node_seq.append(to_node_id)\\r\\n # new_element.node_serving_state[to_node_id] = 1\\r\\n new_element.Calculate_Label_Cost(to_node, link_to,self.multiplier_v)\\r\\n self.g_ending_state_vector[vehicle_id].VSStateVector.append(new_element)\\r\\n\\r\\n # self.g_ending_state_vector[vehicle_id].update_state(new_element, Flag)\\r\\n\\r\\n # Case 2: to_node is not the destination\\r\\n if to_node_id != self.destination:\\r\\n # check 1: vehicle capacity\\r\\n if pElement.remaining_capacity < to_node.demand:\\r\\n continue\\r\\n # check 2: if the to node is served\\r\\n node_serving_state = pElement.node_serving_state\\r\\n if node_serving_state[to_node_id] == 1:\\r\\n continue\\r\\n\\r\\n new_element = CVSState()\\r\\n new_element.my_copy(pElement)\\r\\n new_element.current_node_id = to_node_id\\r\\n new_element.remaining_capacity -= to_node.demand\\r\\n new_element.node_seq.append(to_node_id)\\r\\n new_element.node_serving_state[to_node_id] = 1\\r\\n new_element.Calculate_Label_Cost(to_node, link_to,self.multiplier_v)\\r\\n self.g_time_dependent_state_vector[vehicle_id][next_time].update_state(new_element, Flag)\\r\\n if next_time > max_time_interval:\\r\\n max_time_interval = next_time\\r\\n # check\\r\\n if max_time_interval <= t:\\r\\n break\\r\\n self.g_ending_state_vector[vehicle_id].Sort(Flag)\",\n \"def __init__(self,\\n game,\\n exploration_strategy='uniform-exhaustive',\\n confidence_method='ucb-standard',\\n delta=0.01,\\n ucb_eps=0,\\n per_payoff_confidence=True,\\n time_dependent_delta=False):\\n self.exploration_strategy = exploration_strategy\\n self.confidence_method = confidence_method\\n self.ucb_eps = ucb_eps\\n self.G = game # pylint: disable=invalid-name\\n self.per_payoff_confidence = per_payoff_confidence\\n self.time_dependent_delta = time_dependent_delta\\n if self.per_payoff_confidence:\\n self._delta = delta\\n else:\\n self._delta = delta / (\\n self.G.n_players *\\n functools.reduce(operator.mul, self.G.strategy_spaces, 1))\\n\\n # Compute the graph\\n self.V = list( # pylint: disable=invalid-name\\n itertools.product(*[range(smax) for smax in self.G.strategy_spaces]))\\n self.E = [] # pylint: disable=invalid-name\\n for v in self.V:\\n adj_strats = [\\n list(range(v[k] + 1, self.G.strategy_spaces[k]))\\n for k in range(self.G.n_players)\\n ]\\n for k in range(self.G.n_players):\\n for new_s in adj_strats[k]:\\n second_vertex = list(v)\\n second_vertex[k] = new_s\\n second_vertex = tuple(second_vertex)\\n self.E.append((v, second_vertex))\\n self.count_history = {v: [] for v in self.V}\\n self.total_interactions = 0\",\n \"def main():\\r\\n start = input(\\\"Enter the starting state: \\\").replace(\\\" \\\", \\\"\\\") # Remove whitespace from states\\r\\n goal = input(\\\"Enter the goal state: \\\").replace(\\\" \\\", \\\"\\\")\\r\\n if validate_input(start, goal) == False:\\r\\n return print(\\\"Invalid input.\\\")\\r\\n\\r\\n start_list = [] # Convert into list for efficieny\\r\\n for i in start:\\r\\n start_list.append(int(i))\\r\\n\\r\\n goal_list = [] # Convert into list for efficieny\\r\\n for i in goal:\\r\\n goal_list.append(int(i))\\r\\n\\r\\n state_inversions = inversions(start_list)\\r\\n print(\\\"\\\\nStart state inversions:\\\", state_inversions)\\r\\n goal_inversions = inversions(goal_list)\\r\\n print(\\\"Goal state inversions:\\\", goal_inversions)\\r\\n\\r\\n if state_inversions % 2 != goal_inversions % 2: # If polarity is uneven, not solvable\\r\\n print(\\\"Unsolvable configurations.\\\\nPolarities do not match.\\\")\\r\\n exit(1)\\r\\n\\r\\n heuristic = -1 # Set heuristic option for A* search\\r\\n while heuristic != 0 and heuristic != 1:\\r\\n try:\\r\\n heuristic = int(input(\\\"\\\\nEnter heuristic function: \\\\n0 for Manhattan\\\\n1 for Eucledian\\\\n= \\\"))\\r\\n except (EOFError, KeyboardInterrupt):\\r\\n print('Terminating.')\\r\\n exit()\\r\\n except (KeyError, ValueError):\\r\\n print('Invalid option.')\\r\\n\\r\\n start_time = time.time() # Start search time\\r\\n nodes_searched = astar_search(start_list, goal_list, heuristic)\\r\\n end_time = time.time() # Stop search timer\\r\\n\\r\\n print(\\\"\\\\nSolved in: {:.2f}\\\".format(end_time-start_time), \\\"seconds\\\")\\r\\n print(\\\"Nodes explored:\\\", nodes_searched)\\r\\n exit()\",\n \"def execute_inner_graph(*args):\\r\\n # Check if you need to go back in time over the sequences (the\\r\\n # first argument is n_steps, the second is go_backwards)\\r\\n nsteps = args[0]\\r\\n invert = False\\r\\n if args[1]:\\r\\n nsteps = nsteps * -1\\r\\n if nsteps < 0:\\r\\n new_ins = [x[::-1] for x in args[2: 2 + n_ins]]\\r\\n else:\\r\\n new_ins = [x for x in args[2: 2 + n_ins]]\\r\\n nsteps = abs(nsteps)\\r\\n # Simplify the inputs by slicing them according to the taps\\r\\n nw_inputs = []\\r\\n for inp, info in zip(new_ins, inputs_info):\\r\\n taps = [x['tap'] for x in info]\\r\\n\\r\\n if numpy.min(taps) < 0:\\r\\n _offset = abs(numpy.min(taps))\\r\\n else:\\r\\n _offset = 0\\r\\n nw_inputs += [inp[_offset + k:] for k in taps]\\r\\n # Simplify the states by slicing them according to the taps.\\r\\n # Note that if the memory buffer for the inputs and outputs is\\r\\n # the same, by changing the outputs we also change the outputs\\r\\n nw_states_inputs = []\\r\\n nw_states_outs = []\\r\\n for st, info in zip(args[2 + n_ins:2 + n_ins + n_states],\\r\\n states_info):\\r\\n taps = [x['tap'] for x in info]\\r\\n\\r\\n membuf = numpy.zeros((nsteps + abs(numpy.min(taps)), 4))\\r\\n if abs(numpy.min(taps)) != 1:\\r\\n membuf[:abs(numpy.min(taps))] = st[:abs(numpy.min(taps))]\\r\\n else:\\r\\n membuf[:abs(numpy.min(taps))] = st\\r\\n\\r\\n nw_states_inputs += [membuf[abs(numpy.min(taps)) + k:]\\r\\n for k in taps]\\r\\n nw_states_outs.append(membuf[abs(numpy.min(taps)):])\\r\\n\\r\\n parameters_vals = args[2 + n_ins + n_states:]\\r\\n out_mem_buffers = [numpy.zeros((nsteps, 4)) for k in\\r\\n xrange(n_outputs)]\\r\\n shared_values = [x.copy() for x in original_shared_values]\\r\\n\\r\\n for step in xrange(nsteps):\\r\\n arg_pos = 0\\r\\n to_add = None\\r\\n for in_info in inputs_info:\\r\\n for info in in_info:\\r\\n arg = nw_inputs[arg_pos][step]\\r\\n arg_pos += 1\\r\\n # Construct dummy graph around input\\r\\n if info['use']:\\r\\n if to_add is None:\\r\\n to_add = arg * 2\\r\\n else:\\r\\n to_add = to_add + arg * 2\\r\\n arg_pos = 0\\r\\n for dx, st_info in enumerate(states_info):\\r\\n if to_add is not None:\\r\\n nw_states_outs[dx][step] = to_add\\r\\n for info in st_info:\\r\\n arg = nw_states_inputs[arg_pos][step]\\r\\n arg_pos += 1\\r\\n if info['use']:\\r\\n nw_states_outs[dx][step] += arg * 3\\r\\n for arg, info in zip(parameters_vals, parameters_info):\\r\\n if info['use']:\\r\\n if to_add is None:\\r\\n to_add = arg * 4\\r\\n else:\\r\\n to_add = to_add + arg * 4\\r\\n if to_add is not None:\\r\\n shared_values = [sh * 5 + to_add for sh in shared_values]\\r\\n for state in nw_states_outs:\\r\\n state[step] += to_add\\r\\n for out in out_mem_buffers:\\r\\n out[step] = to_add ** 2\\r\\n else:\\r\\n shared_values = [sh * 5 for sh in shared_values]\\r\\n for out in out_mem_buffers:\\r\\n out[step] = 2\\r\\n return nw_states_outs + out_mem_buffers, shared_values\",\n \"def compute_CTMC_flow_in_logspace(adj_mat, time_resolution=.1,\\n n_timepoints=10):\\n\\n n = len(adj_mat)\\n\\n # compute infinitesimal generator\\n degrees = np.sum(adj_mat, axis=0) * 1.\\n D = scipy.sparse.csr_matrix(np.diag(degrees))\\n\\n generator_mat = compute_infinitesimal_generator(adj_mat)\\n\\n # compute 2nd-order approximation to e^(time_resolution * generator_mat)\\n tmp = time_resolution * generator_mat\\n U = np.eye(n) + tmp + np.linalg.matrix_power(\\n tmp, 2) / 2.\\n\\n print \\\"Bridge passed ..\\\"\\n # Techinique: U^2k = (U^k)^2\\n for j in xrange(n_timepoints):\\n # compute flow matrix at time t = time_resolution * 2 ^j\\n V = D.dot(U)\\n\\n # update U\\n U = np.linalg.matrix_power(U, 2)\\n\\n # yield compouted flow matrix\\n yield V\",\n \"def current(edges, transition_matrix):\\n ### Calculate the state frequecies ###\\n # Eigenvalues and Eigenvectors of transition matrix\\n vals, vl, vr = sp.linalg.eig(transition_matrix, left=True)\\n # Find the eigenvalue that == 1\\n index = list(vals).index(1)\\n state_freq = vl[:,index]\\n\\n committor_plus = np.linalg.eig\\n\\n\\n ### Calculate the flux matrix ###\\n flux_matrix = np.multiply(transition_matrix, state_freq)\\n return flux_matrix / flux_matrix.sum(axis=1)\",\n \"def one_backward_pass(t,states,init_vals,traces,delta,unit_cube,edges,P):\\n \\n next_vals = -1e100 * np.ones_like(init_vals)\\n \\n S,T = states.shape\\n \\n for i in range(len(states)):\\n for j in range(len(unit_cube)):\\n# print('State, unitcube subtracted',s,c)\\n if (states[i] - unit_cube[j]).min() >= 0:\\n \\n state_idx = edges[i,j]\\n \\n tau = np.where(unit_cube[j] == 0)\\n \\n if len(tau[0]) == 0:\\n next_vals[state_idx] = log_sum_exp([next_vals[state_idx],\\\\\\n init_vals[i]+T*np.log(delta)])\\n \\n else:\\n flag = 0\\n temp = []\\n for k in tau[0]:\\n if (t-states[i,k] >=0 and t-states[i,k]< len(traces[k])):\\n temp.append(traces[k][t-states[i][k]])\\n else:\\n flag = 1\\n break\\n\\n if (len(set(temp)) == 1 and flag == 0):\\n bit = temp[0]\\n next_vals[state_idx] = log_sum_exp([next_vals[state_idx],init_vals[i]\\\\\\n + (T-len(temp)) * np.log(delta)\\\\\\n + np.log(1-delta) * (len(temp))\\\\\\n + np.log(P[t,bit] + 1e-100)])\\n \\n return next_vals\",\n \"def gstate(N, periodic):\\n\\n # Create Hamiltonian matrix\\n H = kronH(N, periodic)\\n \\n # Diagonalize\\n print('Diagonalizing...', end=' ', flush=True)\\n w, v = eigsh(H, k=1, which='SA')\\n print('Done')\\n\\n return w[0]\",\n \"def G(self, (k,t), (j,x), **params):\\n return 0\",\n \"def solver(self, theta):\\n\\n m = len(self.x)\\n n = len(self.t[0])\\n h = self.step_x\\n k = self.step_t\\n lamb = k / (h * h)\\n w = np.zeros(m + 1)\\n l = np.zeros(m + 1)\\n u = np.zeros(m + 1)\\n\\n uK = np.zeros(self.x.shape)\\n print('comecei para k= ({},{})'.format(theta[0], theta[1]))\\n startTime = time.clock()\\n if self.first:\\n self.uR = np.zeros(self.x.shape)\\n self.first = False\\n error = 0\\n errorCurve = np.zeros(self.x.shape)\\n z = np.zeros(m + 1)\\n w[m] = 0 # following the initial condition u(0,t) = u(l,t) = 0. If needed, change this.\\n for i in range(1, m - 1):\\n w[i] = self.g(i * h)\\n\\n l[1] = 1 + lamb\\n u[1] = -lamb / (2 * l[1])\\n for i in range(2, m - 1):\\n l[i] = 1 + lamb + lamb * u[i - 1] / 2\\n u[i] = -lamb / (2 * l[i])\\n\\n l[m - 1] = 1 + lamb + lamb * u[m - 2] / 2\\n for j in range(1, n + 1):\\n t = j * k # current t\\n z[1] = ((1 - lamb) * w[1] + lamb / 2 * w[2] + self.f(t, theta)) / l[1]\\n for i in range(2, m):\\n z[i] = ((1 - lamb) * w[i] + lamb / 2 * (w[i + 1] + w[i - 1] + z[i - 1]) + self.f(t, theta)) / l[i]\\n w[m - 1] = z[m - 1]\\n for i in range(m - 2, 0, -1):\\n w[i] = z[i] - u[i] * w[i + 1]\\n\\n for i in range(0, m + 1):\\n x = i * h\\n # print(x, w[i])\\n # print('oi')\\n uK[i - 1, j - 1] = w[i]\\n self.t[i - 1, j - 1] = t\\n self.x[i - 1, j - 1] = x\\n error += pow(w[i] - self.uR[i - 1, j - 1], 2) / uK.size\\n errorCurve[i - 1, j - 1] = (pow(w[i] - self.uR[i - 1, j - 1], 2)) / uK.size\\n print('acabei para k= ({},{}) em {} segundos'.format(theta[0], theta[1], time.clock() - startTime))\\n return (uK, error, errorCurve, theta)\",\n \"def get_problem():\\n\\n #User Defined Terrain Elevation\\n #def terr( x_pos, y_pos ):\\n #Defines terrain elevation [m] as a function of x and y positions [m]\\n # elev=100.0*(np.sin(0.5*(x_pos/1000.0)))**2.0 #User defined elevation map\\n # return elev\\n\\n #User Defined Tunnel Cost\\n #def tunnel(depth):\\n #Defines additional cost for placing a 1 meter length of track a non-zero\\n #depth below the ground.\\n # TunnelCost=(50e3)/(1+np.exp(-(depth-5))) #Tunneling Cost (2016 USD)\\n # return TunnelCost\\n\\n #def bridge(height):\\n #Defines additional cost for placing a 1 meter length of track a non-zero\\n #heigh above the ground.\\n # BridgeCost=10e3*(height/10)**2 #Bridge Cost (2016 USD)\\n # return BridgeCost\\n\\n # Rename this and/or move to optim package?\\n problem = beluga.optim.Problem('surftest_noinc')\\n\\n #Define independent variables\\n problem.independent('t', 's')\\n\\n # Define equations of motion\\n problem.state('x','V*cos(hdg)','m') \\\\\\n .state('y','V*sin(hdg)','m') \\\\\\n .state('V','amax*sin(thrA) + eps*(cos(thrA)+cos(hdgA))','m/s') \\\\\\n .state('hdg','cmax/V*sin(hdgA)','rad')\\n\\n # Define controls\\n #problem.control('thrA','rad') \\\\\\n # .control('hdgA','rad')\\n problem.control('hdgA','rad')\\n\\n # Define Cost Functional\\n problem.cost['path'] = Expression('1','s')\\n\\n #problem.cost['path'] = Expression('TimeToUSD+trk*V', 'USD')\\n\\n #+ \\\\\\n #'(50e3)/(1.0+exp(-1.0*(z-0.0*(sin(0.5*(x/1000.0)))**2.0-5.0)))+'+ \\\\\\n #'10e3*((0.0*(sin(0.5*(x/1000.0)))**2.0-z)/10.0)**2.0','USD')\\n\\n #Define constraints\\n problem.constraints().initial('x-x_0','m') \\\\\\n .initial('y-y_0','m') \\\\\\n .initial('V-V_0','m/s') \\\\\\n .initial('hdg-hdg_0','rad') \\\\\\n .terminal('x-x_f','m') \\\\\\n .terminal('y-y_f','m')\\n #.terminal('V-V_f','m/s')\\n #.initial('hdg-hdg_0','rad') \\\\\\n\\n #Define constants\\n problem.constant('g',9.81,'m/s^2') #Acceleration due to gravity\\n problem.constant('trk',1,'USD/m') #Basic cost of 1 m of track on ground (10k per m)\\n problem.constant('amax',1.0,'m/s^2') #Maximum thrust acceleration of vehicle\\n problem.constant('cmax',1.0,'m/s^2') #Maximum allowed centripetal acceleration\\n problem.constant('eps',10,'m/s^2') #Error constant\\n problem.constant('TimeToUSD',1,'USD/s') #Time is Money!!\\n problem.constant('thrA',0,'rad')\\n\\n #Unit scaling\\n problem.scale.unit('m','x') \\\\\\n .unit('s','x/V') \\\\\\n .unit('rad',1) \\\\\\n .unit('USD',1)\\n\\n #Configure solver\\n problem.bvp_solver = algorithms.MultipleShooting(derivative_method='fd',tolerance=1e-4, max_iterations=1000, verbose = True, cached = False, number_arcs=2)\\n\\n #Initial Guess\\n problem.guess.setup('auto',start=[0.0,0.0,1.0,pi/4-0.2], costate_guess=-0.1) #City A\\n\\n #Add Continuation Steps\\n problem.steps.add_step().num_cases(10) \\\\\\n .terminal('x', 10) \\\\\\n .terminal('y', 0)\\n\\n problem.steps.add_step().num_cases(10) \\\\\\n .const('eps', 0.2)\\n\\n #problem.steps.add_step().num_cases(10) \\\\\\n # .terminal('y', 2*pi*1000) \\\\\\n # .terminal('z', 0.0) \\\\\\n # .terminal('inc', 0.0)\\n #^ City B\\n return problem\",\n \"def init_compute(params):\\n\\n # unzip dictionary and assign parameters\\n N, M, K, T = params.values()\\n\\n p0 = np.fft.fftfreq(N, 1.0 / N)\\n x0 = np.arange(0, 2 * np.pi, 2 * np.pi / N)\\n\\n p_time_evolution = np.zeros((N, T), dtype=\\\"complex_\\\")\\n x_time_evolution = np.zeros((N, T), dtype=\\\"complex_\\\")\\n p_time_evolution[:, 0] = p0\\n x_time_evolution[:, 0] = x0\\n\\n # Initialise b,c tensor to hold b,c matrices iteravtively\\n b_tensor = np.zeros((N, N, T), dtype=\\\"complex_\\\")\\n c_tensor = np.zeros((N, N, T), dtype=\\\"complex_\\\")\\n c_trace = np.zeros(T, dtype=\\\"complex_\\\")\\n for i in range(T - 1): # Evolve\\n b = coeff_b(N, N) * p_time_evolution[:, i]\\n c = b @ b.T.conj()\\n print(c.trace())\\n c_trace[i] = c.trace()\\n p_time_evolution[:, i + 1] = evolve(\\n p_time_evolution[:, i],\\n \\\"momentum\\\",\\n x_time_evolution[:, i],\\n p_time_evolution[:, i],\\n params,\\n )\\n x_time_evolution[:, i + 1] = evolve(\\n x_time_evolution[:, i],\\n \\\"position\\\",\\n x_time_evolution[:, i],\\n p_time_evolution[:, i],\\n params,\\n )\\n b_tensor[:, :, i], c_tensor[:, :, i] = b, c\\n return b_tensor, c_tensor\",\n \"def algo_graph_sto_iht(\\n x_mat, y_tr, max_epochs, lr, x_star, x0, tol_algo, edges, costs, s, b,\\n g=1, root=-1, gamma=0.1, proj_max_num_iter=50, verbose=0):\\n np.random.seed()\\n start_time = time.time()\\n x_hat = np.copy(x0)\\n x_tr_t = np.transpose(x_mat)\\n\\n # graph projection para\\n h_low = int(len(x0) / 2)\\n h_high = int(h_low * (1. + gamma))\\n t_low = int(s)\\n t_high = int(s * (1. + gamma))\\n\\n (n, p) = x_mat.shape\\n # if block size is larger than n,\\n # just treat it as a single block (batch)\\n b = n if n < b else b\\n num_blocks = int(n) / int(b)\\n prob = [1. / num_blocks] * num_blocks\\n\\n num_epochs = 0\\n\\n for epoch_i in range(max_epochs):\\n num_epochs += 1\\n for _ in range(num_blocks):\\n ii = np.random.randint(0, num_blocks)\\n block = range(b * ii, b * (ii + 1))\\n xtx = np.dot(x_tr_t[:, block], x_mat[block])\\n xty = np.dot(x_tr_t[:, block], y_tr[block])\\n gradient = -2. * (xty - np.dot(xtx, x_hat))\\n head_nodes, proj_grad = algo_head_tail_bisearch(\\n edges, gradient, costs, g, root, h_low, h_high,\\n proj_max_num_iter, verbose)\\n bt = x_hat - (lr / (prob[ii] * num_blocks)) * proj_grad\\n tail_nodes, proj_bt = algo_head_tail_bisearch(\\n edges, bt, costs, g, root,\\n t_low, t_high, proj_max_num_iter, verbose)\\n x_hat = proj_bt\\n if np.linalg.norm(x_hat) >= 1e3: # diverge cases.\\n break\\n if np.linalg.norm(y_tr - np.dot(x_mat, x_hat)) <= tol_algo:\\n break\\n x_err = np.linalg.norm(x_hat - x_star)\\n run_time = time.time() - start_time\\n return x_err, num_epochs, run_time\",\n \"def build_graph(mesh, evals, nevals,nfix, step=1.0, params=OptimizationParams()): #smoothing='absolute', numsteps=40000):\\n [Xori,TRIV,n, m, Ik, Ih, Ik_k, Ih_k, Tpi, Txi, Tni, iM, Windices, Ael, Bary] = mesh\\n\\n dtype='float32'\\n if(Xori.dtype=='float64'):\\n dtype='float64'\\n if(Xori.dtype=='float16'):\\n dtype='float16'\\n print(dtype)\\n graph = lambda: None\\n \\n #model the shape deformation as a displacement vector field\\n dX = tf.Variable((0*Xori).astype(dtype) );\\n scaleX = tf.Variable(1,dtype=dtype); #not used in shape alignment\\n \\n graph.input_X = tf.placeholder(shape=dX.shape,dtype=dtype);\\n graph.assign_X = tf.assign(dX, graph.input_X-Xori*scaleX).op;\\n \\n graph.X=Xori*scaleX+dX;\\n \\n Lx,S,L,Ak = tf_calc_lap(mesh,graph.X)\\n\\n #Normalized Laplacian\\n Si = tf.diag(tf.sqrt(1/S[:,0]))\\n Lap = tf.matmul(Si,tf.matmul(Lx,Si));\\n\\n \\n #Spectral decomposition approach\\n [s_,v] = tf.self_adjoint_eig( Lap )\\n graph.cost_evals_f1 = 1e2*tf.nn.l2_loss( (s_[0:nevals]-evals[0:nevals])* (1/np.asarray(range(1,nevals+1),dtype)) )/nevals # \\\\\\n \\n \\n #Approach avoiding spectral decomposition - NOT USED\\n # [_,EigsOpt,lap] = tfeig(Lap)\\n # v = tf.Variable(EigsOpt[:,0:nevals].astype(dtype) );\\n # cost_evals_a = 1e3*tf.nn.l2_loss(tf.matmul(tf.transpose(v),v)-tf.eye(nevals,dtype=dtype));\\n # cost_evals_b = 1e1*tf.nn.l2_loss( (tf.matmul(Lap,v) - tf.matmul(v,np.diag(evals[0:nevals]).astype(dtype))) )/nevals\\n # graph.cost_evals_f2 = cost_evals_a + cost_evals_b\\n \\n \\n meanA, varA = tf.nn.moments(Ak, axes=[0])\\n meanL, varL = tf.nn.moments(L, axes=[0])\\n\\n graph.global_step = tf.Variable(step+1.0, name='global_step',trainable=False, dtype=dtype)\\n graph.global_step_val = tf.placeholder(dtype)\\n graph.set_global_step = tf.assign(graph.global_step, graph.global_step_val).op \\n \\n #regularizers decay factor\\n cosine_decay = 0.5 * (1 + tf.cos(3.14 * tf.minimum(np.asarray(params.numsteps/2.0,dtype=dtype),graph.global_step) / (params.numsteps/2.0)))\\n graph.decay= (1 - params.decay_target) * cosine_decay + params.decay_target\\n \\n if(params.smoothing=='displacement'): \\n graph.vcL = params.curvature_reg*graph.decay * tf.nn.l2_loss( tf.matmul(Bary.astype(dtype),dX)[nfix:,:]);\\n graph.vcW = params.smoothness_reg*graph.decay *tf.nn.l2_loss( tf.matmul(Lx,dX)[nfix:,:]) \\n if(params.smoothing=='absolute'):\\n graph.vcL = params.curvature_reg*graph.decay * tf.nn.l2_loss( tf.matmul(Bary.astype(dtype),S*graph.X)[nfix:,:]);\\n graph.vcW = params.smoothness_reg**graph.decay *tf.nn.l2_loss( tf.matmul(Lx,graph.X)[nfix:,:]) \\n \\n #Volume compuation\\n T1 = tf.gather(graph.X, TRIV[:,0])\\n T2 = tf.gather(graph.X, TRIV[:,1])\\n T3 = tf.gather(graph.X, TRIV[:,2])\\n XP = tf.cross(T2-T1, T3-T2)\\n T_C = (T1+T2+T3)/3\\n graph.Volume = params.volume_reg*graph.decay*tf.reduce_sum(XP*T_C/2)/3\\n\\n\\n #L2 regularizer on total displacement weighted by area elements\\n graph.l2_reg = params.l2_reg*tf.nn.l2_loss(S*dX)\\n\\n \\n graph.cost_spectral = graph.cost_evals_f1 + graph.vcW + graph.vcL - graph.Volume + graph.l2_reg\\n\\n optimizer = tf.train.AdamOptimizer(params.opt_step)\\n \\n #gradient clipping \\n gvs = optimizer.compute_gradients(graph.cost_spectral)\\n capped_gvs = [(tf.clip_by_value(grad, -0.0001, 0.0001), var) for grad, var in gvs if grad!=None]\\n graph.train_op_spectral = optimizer.apply_gradients(capped_gvs, global_step=graph.global_step)\\n\\n [graph.s_,v] = tf.self_adjoint_eig( Lap ) \\n return graph\",\n \"def __init__(self, trap=2.5*10**16, Keq=1.0*10**17,\\n EHdecay=1.0*10**-10, Etrap=2.0*10**-10, FHloss=8.0*10**-12,\\n G3decay = 0, step=200*ps, pretime=2, reprate=80000000,\\n verbose=False, trackQ=False, scalar=1, Gdecay=0, GHdecay=0,\\n tolerance=0.005, G2decay=0. ,Gescape=1., Gform=1., G3loss=0.):\\n # Some other variables used\\n self.tolerance = tolerance\\n self.scalar = scalar\\n self.verbose = verbose\\n self.reprate = reprate\\n self.duration = 1.00 / reprate\\n self.step = step\\n self.steps = int(self.duration / self.step)\\n self.powers = []\\n self.pretime = pretime\\n # Variables which hold state densities\\n self.exciton = []\\n self.hole = []\\n self.electron = []\\n self.trap = (trap) # Total number of traps\\n self.filled = [] # Filled traps\\n self.signal = []\\n self.xsignal = []\\n self.ehsignal = []\\n self.xloss = []\\n self.tloss = []\\n self.pulses = []\\n self.qk = []\\n self.trackQ = trackQ\\n # Rate and equilibrium constants, corrected for time step size\\n self.Keq = Gescape/Gform # Equilibrium constant for X<-->e+h\\n self.EHdecay = (EHdecay * step) # e+h->ground\\n self.Etrap = (Etrap * step) # e+trap->filled\\n self.FHloss = (FHloss * step) # filled+h->ground\\n self.Gdecay = Gdecay * step\\n self.G2decay = G2decay * step\\n self.G3decay = G3decay * step\\n self.GHdecay = GHdecay * step\\n self.Gescape = Gescape * step\\n self.G3loss = G3loss * step\\n self.Gform = Gform * step\",\n \"def build_linear_system(u, dt, dx, D = 3, P = 3,time_diff = 'poly',space_diff = 'poly',lam_t = None,lam_x = None, width_x = None,width_t = None, deg_x = 5,deg_t = None,sigma = 2):\\n\\n n, m = u.shape\\n\\n if width_x == None: width_x = n/10\\n if width_t == None: width_t = m/10\\n if deg_t == None: deg_t = deg_x\\n\\n # If we're using polynomials to take derviatives, then we toss the data around the edges.\\n if time_diff == 'poly': \\n m2 = m-2*width_t\\n offset_t = width_t\\n else: \\n m2 = m\\n offset_t = 0\\n if space_diff == 'poly': \\n n2 = n-2*width_x\\n offset_x = width_x\\n else: \\n n2 = n\\n offset_x = 0\\n\\n if lam_t == None: lam_t = 1.0/m\\n if lam_x == None: lam_x = 1.0/n\\n\\n ########################\\n # First take the time derivaitve for the left hand side of the equation\\n ########################\\n ut = np.zeros((n2,m2), dtype=u.dtype)\\n\\n if time_diff == 'FDconv':\\n Usmooth = np.zeros((n,m), dtype=u.dtype)\\n # Smooth across x cross-sections\\n for j in range(m):\\n Usmooth[:,j] = ConvSmoother(u[:,j],width_t,sigma)\\n # Now take finite differences\\n for i in range(n2):\\n ut[i,:] = FiniteDiff(Usmooth[i + offset_x,:],dt,1)\\n\\n elif time_diff == 'poly':\\n T= np.linspace(0,(m-1)*dt,m)\\n for i in range(n2):\\n ut[i,:] = PolyDiff(u[i+offset_x,:],T,diff=1,width=width_t,deg=deg_t)[:,0]\\n\\n elif time_diff == 'Tik':\\n for i in range(n2):\\n ut[i,:] = TikhonovDiff(u[i + offset_x,:], dt, lam_t)\\n\\n else:\\n for i in range(n2):\\n ut[i,:] = FiniteDiff(u[i + offset_x,:],dt,1)\\n \\n ut = np.reshape(ut, (n2*m2,1), order='F')\\n\\n ########################\\n # Now form the rhs one column at a time, and record what each one is\\n ########################\\n\\n u2 = u[offset_x:n-offset_x,offset_t:m-offset_t]\\n Theta = np.zeros((n2*m2, (D+1)*(P+1)), dtype=u.dtype)\\n ux = np.zeros((n2,m2), dtype=u.dtype)\\n rhs_description = ['' for i in range((D+1)*(P+1))]\\n\\n if space_diff == 'poly': \\n Du = {}\\n for i in range(m2):\\n Du[i] = PolyDiff(u[:,i+offset_t],np.linspace(0,(n-1)*dx,n),diff=D,width=width_x,deg=deg_x)\\n if space_diff == 'Fourier': ik = 2*np.pi*1j*np.fft.fftfreq(n, d = dx)\\n \\n for d in range(D+1):\\n\\n if d > 0:\\n for i in range(m2):\\n if space_diff == 'Tik': ux[:,i] = TikhonovDiff(u[:,i+offset_t], dx, lam_x, d=d)\\n elif space_diff == 'FDconv':\\n Usmooth = ConvSmoother(u[:,i+offset_t],width_x,sigma)\\n ux[:,i] = FiniteDiff(Usmooth,dx,d)\\n elif space_diff == 'FD': ux[:,i] = FiniteDiff(u[:,i+offset_t],dx,d)\\n elif space_diff == 'poly': ux[:,i] = Du[i][:,d-1]\\n elif space_diff == 'Fourier': ux[:,i] = np.fft.ifft(ik**d*np.fft.fft(u[:,i]))\\n else: ux = np.ones((n2,m2), dtype=u.dtype) \\n \\n for p in range(P+1):\\n Theta[:, d*(P+1)+p] = np.reshape(np.multiply(ux, np.power(u2,p)), (n2*m2), order='F')\\n\\n if p == 1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u'\\n elif p>1: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+'u^' + str(p)\\n if d > 0: rhs_description[d*(P+1)+p] = rhs_description[d*(P+1)+p]+\\\\\\n 'u_{' + ''.join(['x' for _ in range(d)]) + '}'\\n\\n return ut, Theta, rhs_description\",\n \"def process_graph(graph):\\n init_globals()\\n\\n # If the graph contains integers this is triggered.\\n # See the check_graph() function description for more information\\n if type(graph.keys()[0]) == int:\\n graph = check_graph(graph)\\n\\n \\n balances = get_node_balances(graph)\\n\\n\\n if is_eulerian(balances):\\n splits = find_cycles(graph, sorted(graph.keys())[0])\\n for node in splits:\\n find_cycles(graph, node)\\n\\n print(\\\"graph is eulerian:\\\\n{}\\\\n\\\".format(\\n \\\"->\\\".join(merge_cycles(cycles))))\\n\\n\\n else:\\n print(\\\"graph is not eulerian\\\")\\n\\n if has_eulerian_path(balances):\\n print(\\\"graph has an eulerian path:\\\\n{}\\\\n\\\".format(\\n \\\"->\\\".join(get_eulerian_path(graph, balances))))\\n else:\\n print(\\\"graph has no eulerian path\\\")\",\n \"def ha(env, cstate=0):\\n T1 = 10\\n T2 = 10\\n thM = 20\\n thm = 5\\n vr = 10.5\\n v1 = -1.3\\n v2 = -2.7\\n assert(T1 == T2)\\n\\n delta = None # None to cause failure\\n # The continous variables used in this ha\\n x = T1 # clock1 variable\\n y = T2 # clock2 variable\\n th = 11.5 # The reactor temperature\\n\\n # You need vtol here, because of floating point error.\\n loc0_ode_x = ODE(env, S.sympify('diff(x(t))'), S.sympify('1.0'),\\n ttol=10**-3, iterations=100)\\n loc0_ode_y = ODE(env, S.sympify('diff(y(t))'), S.sympify('1.0'),\\n ttol=10**-3, iterations=100)\\n loc0_ode_th = ODE(env, S.sympify('diff(th(t))'), S.sympify(vr),\\n ttol=10**-3, iterations=100, vtol=10**-10)\\n loc0_FT = False\\n\\n loc1_ode_x = ODE(env, S.sympify('diff(x(t))'), S.sympify('1.0'),\\n ttol=10**-3, iterations=100)\\n loc1_ode_y = ODE(env, S.sympify('diff(y(t))'), S.sympify('1.0'),\\n ttol=10**-3, iterations=100)\\n loc1_ode_th = ODE(env, S.sympify('diff(th(t))'), S.sympify(v1),\\n ttol=10**-3, iterations=100, vtol=10**-10)\\n loc1_FT = False\\n\\n loc2_ode_x = ODE(env, S.sympify('diff(x(t))'), S.sympify('1.0'),\\n ttol=10**-3, iterations=100)\\n loc2_ode_y = ODE(env, S.sympify('diff(y(t))'), S.sympify('1.0'),\\n ttol=10**-3, iterations=100)\\n loc2_ode_th = ODE(env, S.sympify('diff(th(t))'), S.sympify(v2),\\n ttol=10**-3, iterations=100, vtol=10**-10)\\n loc2_FT = False\\n\\n # Location 3 is reactor shutdown\\n loc3_FT = False\\n\\n # Location 0\\n def location0(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\\n vals = {S.sympify('x(t)'): x,\\n S.sympify('y(t)'): y,\\n S.sympify('th(t)'): th}\\n curr_time = env.now\\n # The edge guard takes preference\\n if th == thM and x >= T1:\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n return 1, 0, x, y, th, None, True, None, None, curr_time\\n elif th == thM and y >= T2:\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n return 2, 0, x, y, th, None, None, True, None, curr_time\\n elif th == thM and x < T1 and y < T2:\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n return 3, 0, x, y, th, None, None, None, True, curr_time\\n # The invariant\\n elif th <= thM:\\n if not loc0_FT:\\n x = loc0_ode_x.compute(vals, curr_time-prev_time)\\n y = loc0_ode_y.compute(vals, curr_time-prev_time)\\n th = loc0_ode_th.compute(vals, curr_time-prev_time)\\n loc0_FT = True\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n if abs(th-thM) > loc0_ode_th.vtol:\\n deltath = loc0_ode_th.delta(vals, quanta=(thM-th))\\n else:\\n th = thM\\n deltath = 0\\n return 0, deltath, x, y, th, False, None, None, None, curr_time\\n else:\\n # print('th:', th)\\n raise RuntimeError('Reached unreachable branch'\\n ' in location 0')\\n\\n def location1(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\\n vals = {S.sympify('x(t)'): x,\\n S.sympify('y(t)'): y,\\n S.sympify('th(t)'): th}\\n curr_time = env.now\\n # The edge guard takes preference\\n if th == thm:\\n x = 0 # Reset\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n return 0, 0, x, y, th, True, None, None, None, curr_time\\n # The invariant\\n elif th >= thm:\\n if not loc1_FT:\\n x = loc1_ode_x.compute(vals, curr_time-prev_time)\\n y = loc1_ode_y.compute(vals, curr_time-prev_time)\\n th = loc1_ode_th.compute(vals, curr_time-prev_time)\\n loc1_FT = True\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n if abs(th-thm) > loc1_ode_th.vtol:\\n deltath = loc1_ode_th.delta(vals, quanta=(thm-th))\\n else:\\n th = thm\\n deltath = 0\\n return 1, deltath, x, y, th, False, None, None, None, curr_time\\n else:\\n raise RuntimeError('Reached unreachable branch'\\n ' in location 1')\\n\\n def location2(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\\n vals = {S.sympify('x(t)'): x,\\n S.sympify('y(t)'): y,\\n S.sympify('th(t)'): th}\\n curr_time = env.now\\n # The edge guard takes preference\\n if th == thm:\\n y = 0 # Reset\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n return 0, 0, x, y, th, True, None, None, None, curr_time\\n # The invariant\\n elif th >= thm:\\n if not loc2_FT:\\n x = loc2_ode_x.compute(vals, curr_time-prev_time)\\n y = loc2_ode_y.compute(vals, curr_time-prev_time)\\n th = loc2_ode_th.compute(vals, curr_time-prev_time)\\n loc2_FT = True\\n # print('%7.4f %7.4f %7.4f %7.4f' % (curr_time, x, y, th))\\n if abs(th-thm) > loc2_ode_th.vtol:\\n deltath = loc2_ode_th.delta(vals, quanta=(thm-th))\\n else:\\n th = thm\\n deltath = 0\\n return 2, deltath, x, y, th, False, None, None, None, curr_time\\n else:\\n raise RuntimeError('Reached unreachable branch'\\n ' in location 2')\\n\\n def location3(x, y, th, loc0_FT, loc1_FT, loc2_FT, loc3_FT, prev_time):\\n global step\\n # print('total steps: ', step)\\n # Done\\n print(time.time()-start)\\n sys.exit(1)\\n\\n # The dictionary for the switch statement.\\n switch_case = {\\n 0: location0,\\n 1: location1,\\n 2: location2,\\n 3: location3\\n }\\n\\n prev_time = env.now\\n while(True):\\n (cstate, delta, x, y, th,\\n loc0_FT, loc1_FT, loc2_FT, loc3_FT,\\n prev_time) = switch_case[cstate](x, y, th,\\n loc0_FT,\\n loc1_FT,\\n loc2_FT,\\n loc3_FT,\\n prev_time)\\n # This should always be the final statement in this function\\n global step\\n step += 1\\n yield env.timeout(delta)\",\n \"def th_cell_diff(th_state, time, d):\\n assert d[\\\"alpha_int\\\"] < d[\\\"alpha\\\"]\\n \\n # divide array into cell states\\n tnaive = th_state[:d[\\\"alpha_int\\\"]]\\n tint = th_state[d[\\\"alpha_int\\\"]:d[\\\"alpha\\\"]]\\n teff = th_state[d[\\\"alpha\\\"]:]\\n \\n assert len(tnaive)+len(tint)+len(teff) == len(th_state)\\n tnaive = np.sum(tnaive)\\n tint = np.sum(tint)\\n teff = np.sum(teff)\\n \\n # IL2 production\\n il2_producers = tnaive+tint\\n il2_consumers = teff+tint \\n conc_il2 = d[\\\"rate_il2\\\"]*il2_producers/(d[\\\"K_il2\\\"]+il2_consumers)\\n \\n # IL7 production\\n il7_consumers = il2_consumers\\n conc_il7 = d[\\\"rate_il7\\\"] / (d[\\\"K_il2\\\"]+il7_consumers)\\n \\n # apply feedback on rate beta\\n fb_ifn = 0\\n if d[\\\"fb_ifn\\\"] != 0:\\n conc_ifn = d[\\\"rate_ifn\\\"]*(il2_producers)\\n fb_ifn = (d[\\\"fb_ifn\\\"]*conc_ifn**3)/(conc_ifn**3+d[\\\"K_ifn\\\"]**3)\\n \\n beta = (fb_ifn+1)*d[\\\"beta\\\"] \\n beta_p = d[\\\"beta_p\\\"] \\n rate_death = d[\\\"d_eff\\\"]\\n\\n # check homeostasis criteria\\n if d[\\\"crit\\\"] == False:\\n update_t0(d, time, conc_il2, conc_il7)\\n elif d[\\\"death_mode\\\"] == False:\\n beta_p = beta_p*np.exp(-d[\\\"decay_p\\\"]*(time-d[\\\"t0\\\"]))\\n else:\\n rate_death = rate_death*np.exp(0.1*(time-d[\\\"t0\\\"]))\\n \\n # differentiation \\n dt_state = diff_effector_new(th_state, teff, d, beta, rate_death, beta_p)\\n \\n \\n return dt_state\",\n \"def two_temps(L, n_cycles, temp):\\n\\n E = np.zeros((2, len(temp), n_cycles))\\n Mag = np.zeros((2, len(temp), n_cycles))\\n MagAbs = np.zeros((2, len(temp), n_cycles))\\n SH = np.zeros((2, len(temp), n_cycles))\\n Suscept = np.zeros((2, len(temp), n_cycles))\\n\\n Naccept = np.zeros((2, len(temp), n_cycles))\\n\\n ground_spin_mat = np.ones((L, L), np.int8) # initial state (ground state)\\n\\n for m in range(2):\\n for t in range(len(temp)):\\n\\n #m=0 is ground state, all spin-up\\n #m=1 is random state\\n if m==0:\\n spin_matrix = ground_spin_mat\\n else:\\n s_mat_random = np.ones((L, L), np.int8) # spin matrix of ones\\n #random indices switched to -1\\n for sw in range(len(s_mat_random)):\\n for sl in range(len(s_mat_random)):\\n rint = np.random.randint(-1,1)\\n if rint == -1:\\n s_mat_random[sw,sl] *= -1\\n spin_matrix = s_mat_random\\n\\n\\n print(\\\"hi\\\")#; sys.exit(1)\\n Energy, Magnetization, MagnetizationAbs, SpecificHeat, Susceptibility, Nacc \\\\\\n = numerical_solution(spin_matrix, n_cycles, temp[t], L, abs=False)\\n\\n\\n E[m,t,:] = Energy\\n Mag[m,t,:] = Magnetization\\n MagAbs[m,t,:] = MagnetizationAbs\\n SH[m,t,:] = SpecificHeat\\n Suscept[m,t,:] = Susceptibility\\n\\n Naccept[m,t,:] = Nacc\\n\\n return E, Mag, MagAbs, SH, Suscept, Naccept\",\n \"def main(graph=None, model=None):\\n\\n mjd = [57433.4816, 57436.4815, 57439.4817, 57451.4604, 57454.4397, 57459.3963, 57462.418, 57465.4385, 57468.3768,\\n 57473.3606, 57487.3364, 57490.3341, 57493.3154, 57496.3352, 57505.3144, 57513.2542, 57532.2717, 57536.2531,\\n 57543.2545, 57546.2703, 57551.2115, 57555.2669, 57558.2769, 57561.1899, 57573.2133, 57433.5019, 57436.4609,\\n 57439.4587, 57444.4357, 57459.4189, 57468.3142, 57476.355, 57479.3568, 57487.3586, 57490.3562, 57493.3352,\\n 57496.2949, 57505.3557, 57509.2932, 57513.2934, 57518.2735, 57521.2739, 57536.2321, 57539.2115, 57543.2301,\\n 57551.1701, 57555.2107, 57558.191, 57573.1923, 57576.1749, 57586.1854]\\n flux = [2.0357230e+00, -2.0382695e+00, 1.0084588e+02, 5.5482742e+01, 1.4867026e+01, -6.5136810e+01, 1.6740545e+01,\\n -5.7269131e+01, 1.0649184e+02, 1.5505235e+02, 3.2445984e+02, 2.8735449e+02, 2.0898877e+02, 2.8958893e+02,\\n 1.9793906e+02, -1.3370536e+01, -3.9001358e+01, 7.4040916e+01, -1.7343750e+00, 2.7844931e+01, 6.0861992e+01,\\n 4.2057487e+01, 7.1565346e+01, -2.6085690e-01, -6.8435440e+01, 17.573107, 41.445435, -110.72664, 111.328964,\\n -63.48336, 352.44907, 199.59058, 429.83075, 338.5255, 409.94604, 389.71262, 195.63905, 267.13318, 123.92461,\\n 200.3431, 106.994514, 142.96387, 56.491238, 55.17521, 97.556946, -29.263103, 142.57687, -20.85057,\\n -0.67210346, 63.353024, -40.02601]\\n fluxerr = [42.784702, 43.83665, 99.98704, 45.26248, 43.040398, 44.00679, 41.856007, 49.354336, 105.86439, 114.0044,\\n 45.697918, 44.15781, 60.574158, 93.08788, 66.04482, 44.26264, 91.525085, 42.768955, 43.228336, 44.178196,\\n 62.15593, 109.270035, 174.49638, 72.6023, 48.021034, 44.86118, 48.659588, 100.97703, 148.94061, 44.98218,\\n 139.11194, 71.4585, 47.766987, 45.77923, 45.610615, 60.50458, 105.11658, 71.41217, 43.945534, 45.154167,\\n 43.84058, 52.93122, 44.722775, 44.250145, 43.95989, 68.101326, 127.122025, 124.1893, 49.952255, 54.50728,\\n 114.91599]\\n passband = ['g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g', 'g',\\n 'g', 'g', 'g', 'g', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r',\\n 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r', 'r']\\n photflag = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4096, 4096, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4096,\\n 6144, 4096, 4096, 4096, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]\\n objid = 'MSIP_01_NONIa-0001_10400862'\\n ra = 3.75464531293933\\n dec = 0.205076187109334\\n redshift = 0.233557\\n mwebv = 0.0228761\\n\\n light_curve_list = [(mjd, flux, fluxerr, passband, photflag, ra, dec, objid, redshift, mwebv)]\\n\\n classification = Classify(known_redshift=True)\\n predictions, time_steps = classification.get_predictions(light_curve_list, return_predictions_at_obstime=False)\\n print(predictions)\\n\\n # classification.plot_light_curves_and_classifications(step=False)\\n # classification.plot_classification_animation()\\n # classification.plot_classification_animation_step()\\n\\n predictions, time_steps = classification.get_predictions(light_curve_list, return_predictions_at_obstime=True)\\n\\n if predictions is not None:\\n import matplotlib.pyplot as plt\\n for i, class_name in enumerate(classification.class_names):\\n plt.plot(time_steps[0], predictions[0][:, i], label=class_name)\\n plt.legend()\\n plt.show()\",\n \"def leapfrog(params, momentum, log_prob_func, steps=10, step_size=0.1, jitter=0.01, normalizing_const=1., softabs_const=1e6, explicit_binding_const=100, fixed_point_threshold=1e-20, fixed_point_max_iterations=6, jitter_max_tries=10, inv_mass=None, ham_func=None, sampler=Sampler.HMC, integrator=Integrator.IMPLICIT, metric=Metric.HESSIAN, store_on_GPU = True, debug=False, pass_grad = None):\\n\\n params = params.clone(); momentum = momentum.clone()\\n # TodO detach graph when storing ret_params for memory saving\\n if sampler == Sampler.HMC and integrator != Integrator.SPLITTING and integrator != Integrator.SPLITTING_RAND and integrator != Integrator.SPLITTING_KMID:\\n def params_grad(p):\\n p = p.detach().requires_grad_()\\n log_prob = log_prob_func(p)\\n # log_prob.backward()\\n p = collect_gradients(log_prob, p, pass_grad)\\n # print(p.grad.std())\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n return p.grad\\n ret_params = []\\n ret_momenta = []\\n momentum += 0.5 * step_size * params_grad(params)\\n for n in range(steps):\\n if inv_mass is None:\\n params = params + step_size * momentum #/normalizing_const\\n else:\\n #Assum G is diag here so 1/Mass = G inverse\\n if type(inv_mass) is list:\\n i = 0\\n for block in inv_mass:\\n it = block[0].shape[0]\\n params[i:it+i] = params[i:it+i] + step_size * torch.matmul(block,momentum[i:it+i].view(-1,1)).view(-1) #/normalizing_const\\n i += it\\n elif len(inv_mass.shape) == 2:\\n params = params + step_size * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params = params + step_size * inv_mass * momentum #/normalizing_const\\n p_grad = params_grad(params)\\n momentum += step_size * p_grad\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n # only need last for Hamiltoninian check (see p.14) https://arxiv.org/pdf/1206.1901.pdf\\n ret_momenta[-1] = ret_momenta[-1] - 0.5 * step_size * p_grad.clone()\\n # import pdb; pdb.set_trace()\\n return ret_params, ret_momenta\\n elif sampler == Sampler.RMHMC and (integrator == Integrator.IMPLICIT or integrator == Integrator.S3):\\n if integrator is not Integrator.S3:\\n ham_func = None\\n # Else we are doing semi sep and need auxiliary for Riemann version.\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\\n\\n def fixed_point_momentum(params, momentum):\\n momentum_old = momentum.clone()\\n # print('s')\\n for i in range(fixed_point_max_iterations):\\n momentum_prev = momentum.clone()\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n # import pdb; pdb.set_trace()\\n raise util.LogProbError()\\n # import pdb; pdb.set_trace()\\n # break\\n\\n momentum = momentum_old - 0.5 * step_size * params.grad\\n momenta_diff = torch.max((momentum_prev-momentum)**2)\\n if momenta_diff < fixed_point_threshold:\\n break\\n if debug == 1:\\n print('Converged (momentum), iterations: {}, momenta_diff: {}'.format(i, momenta_diff))\\n return momentum\\n\\n def fixed_point_params(params, momentum):\\n params_old = params.clone()\\n momentum = momentum.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n momentum = collect_gradients(ham,momentum)\\n momentum_grad_old = momentum.grad.clone()\\n for i in range(fixed_point_max_iterations):\\n params_prev = params.clone()\\n momentum = momentum.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n momentum = collect_gradients(ham,momentum)#collect_gradients(ham, params)\\n params = params_old + 0.5 * step_size * momentum.grad + 0.5 * step_size * momentum_grad_old\\n params_diff = torch.max((params_prev-params)**2)\\n if params_diff < fixed_point_threshold:\\n break\\n if debug == 1:\\n print('Converged (params), iterations: {}, params_diff: {}'.format(i, params_diff))\\n return params\\n ret_params = []\\n ret_momenta = []\\n for n in range(steps):\\n # import pdb; pdb.set_trace()\\n momentum = fixed_point_momentum(params, momentum)\\n params = fixed_point_params(params, momentum)\\n\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, softabs_const=softabs_const, normalizing_const=normalizing_const, ham_func=ham_func, sampler=sampler, integrator=integrator, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n raise util.LogProbError()\\n # break\\n momentum -= 0.5 * step_size * params.grad\\n\\n ret_params.append(params)\\n ret_momenta.append(momentum)\\n return ret_params, ret_momenta\\n\\n elif sampler == Sampler.RMHMC and integrator == Integrator.EXPLICIT:\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for RMHMC')\\n\\n #During leapfrog define integrator as implict when passing into riemannian_hamiltonian\\n leapfrog_hamiltonian_flag = Integrator.IMPLICIT\\n def hamAB_grad_params(params,momentum):\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n params = collect_gradients(ham, params)\\n\\n # draw the jitter on the diagonal of Fisher again (probably a better place to do this)\\n tries = 0\\n while util.has_nan_or_inf(params.grad):\\n # import pdb; pdb.set_trace()\\n params = params.detach().requires_grad_()\\n ham = hamiltonian(params, momentum.detach(), log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n params = collect_gradients(ham, params)\\n tries += 1\\n if tries > jitter_max_tries:\\n print('Warning: reached jitter_max_tries {}'.format(jitter_max_tries))\\n raise util.LogProbError()\\n # import pdb; pdb.set_trace()\\n # break\\n\\n return params.grad\\n def hamAB_grad_momentum(params,momentum):\\n momentum = momentum.detach().requires_grad_()\\n params = params.detach().requires_grad_()\\n # Can't detach p as we still need grad to do derivatives\\n ham = hamiltonian(params, momentum, log_prob_func, jitter=jitter, normalizing_const=normalizing_const, softabs_const=softabs_const, explicit_binding_const=explicit_binding_const, sampler=sampler, integrator=leapfrog_hamiltonian_flag, metric=metric)\\n # import pdb; pdb.set_trace()\\n momentum = collect_gradients(ham,momentum)\\n return momentum.grad\\n ret_params = []\\n ret_momenta = []\\n params_copy = params.clone()\\n momentum_copy = momentum.clone()\\n for n in range(steps):\\n # \\\\phi_{H_A}\\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\\n # \\\\phi_{H_B}\\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\\n # \\\\phi_{H_C}\\n c = torch.cos(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\\n s = torch.sin(torch.FloatTensor([2* explicit_binding_const * step_size])).to(params.device)\\n # params_add = params + params_copy\\n # params_sub = params - params_copy\\n # momentum_add = momentum + momentum_copy\\n # momentum_sub = momentum - momentum_copy\\n # ### CHECK IF THE VALUES ON THE RIGHT NEED TO BE THE OLD OR UPDATED ones\\n # ### INSTINCT IS THAT USING UPDATED ONES IS BETTER\\n # params = 0.5 * ((params_add) + c*(params_sub) + s*(momentum_sub))\\n # momentum = 0.5 * ((momentum_add) - s*(params_sub) + c*(momentum_sub))\\n # params_copy = 0.5 * ((params_add) - c*(params_sub) - s*(momentum_sub))\\n # momentum_copy = 0.5 * ((momentum_add) + s*(params_sub) - c*(momentum_sub))\\n params = 0.5 * ((params+params_copy) + c*(params-params_copy) + s*(momentum-momentum_copy))\\n momentum = 0.5 * ((momentum+momentum_copy) - s*(params-params_copy) + c*(momentum-momentum_copy))\\n params_copy = 0.5 * ((params+params_copy) - c*(params-params_copy) - s*(momentum-momentum_copy))\\n momentum_copy = 0.5 * ((momentum+momentum_copy) + s*(params-params_copy) - c*(momentum-momentum_copy))\\n\\n\\n # \\\\phi_{H_B}\\n params = params + 0.5 * step_size * hamAB_grad_momentum(params_copy,momentum)\\n momentum_copy = momentum_copy - 0.5 * step_size * hamAB_grad_params(params_copy,momentum)\\n # \\\\phi_{H_A}\\n momentum = momentum - 0.5 * step_size * hamAB_grad_params(params,momentum_copy)\\n params_copy = params_copy + 0.5 * step_size * hamAB_grad_momentum(params,momentum_copy)\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n return [ret_params,params_copy], [ret_momenta, momentum_copy]\\n\\n # PAGE 35 MCMC Using Hamiltonian dynamics (Neal 2011)\\n elif sampler == Sampler.HMC and (integrator == Integrator.SPLITTING or integrator == Integrator.SPLITTING_RAND or Integrator.SPLITTING_KMID):\\n if type(log_prob_func) is not list:\\n raise RuntimeError('For splitting log_prob_func must be list of functions')\\n if pass_grad is not None:\\n raise RuntimeError('Passing user-determined gradients not implemented for splitting')\\n\\n def params_grad(p,log_prob_func):\\n # OLD:\\n # p = p.detach().requires_grad_()\\n # log_prob = log_prob_func(p)\\n # # log_prob.backward()\\n # p = collect_gradients(log_prob, p)\\n # grad = p.grad\\n # # For removing GPU memory for large data sets.\\n # del p, log_prob\\n # torch.cuda.empty_cache()\\n\\n p = p.detach().requires_grad_()\\n log_prob = log_prob_func(p)\\n # Need to check memory issues in collect_gradients\\n grad = torch.autograd.grad(log_prob,p)[0]\\n # For removing GPU memory for large data sets.\\n del p, log_prob, log_prob_func\\n torch.cuda.empty_cache()\\n return grad\\n\\n params = params.detach() # Detach as we do not need to remember graph until we pass into log_prob\\n ret_params = []\\n ret_momenta = []\\n if integrator == Integrator.SPLITTING:\\n M = len(log_prob_func)\\n K_div = (M - 1) * 2\\n if M == 1:\\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\\n for n in range(steps):\\n # Symmetric loop to ensure reversible\\n for m in range(M):\\n # print('p ',n)\\n grad = params_grad(params,log_prob_func[m])\\n with torch.no_grad():\\n momentum += 0.5 * step_size * grad\\n del grad\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n if m < M-1:\\n # print('q ',n)\\n if inv_mass is None:\\n params += (step_size/K_div) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\\n for m in reversed(range(M)):\\n # print('p ', n )\\n grad = params_grad(params,log_prob_func[m])\\n with torch.no_grad():\\n momentum += 0.5 * step_size * grad\\n del grad\\n if torch.cuda.is_available():\\n torch.cuda.empty_cache()\\n if m > 0:\\n # print('q ', n-1)\\n if inv_mass is None:\\n params += (step_size/K_div) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/K_div) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/K_div) * inv_mass * momentum #/normalizing_const\\n\\n if store_on_GPU:\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n else:\\n ret_params.append(params.clone().cpu())\\n ret_momenta.append(momentum.clone().cpu())\\n elif integrator == Integrator.SPLITTING_RAND:\\n M = len(log_prob_func)\\n idx = torch.randperm(M)\\n for n in range(steps):\\n # \\\"Labelling of subsets is randomised for each iteration\\\"\\n # idx = torch.randperm(M)\\n for m in range(M):\\n # print('p ',n)\\n momentum += 0.5 * step_size * params_grad(params, log_prob_func[idx[m]])\\n # print('q ',n)\\n if inv_mass is None:\\n params += (step_size/M) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params += (step_size/M) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params += (step_size/M) * inv_mass * momentum #/normalizing_const\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[idx[m]])\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n # import pdb; pdb.set_trace()\\n\\n\\n elif integrator == Integrator.SPLITTING_KMID:\\n M = len(log_prob_func)\\n if M == 1:\\n raise RuntimeError('For symmetric splitting log_prob_func must be list of functions greater than length 1')\\n for n in range(steps):\\n # Symmetric loop to ensure reversible\\n for m in range(M):\\n # print('p ',n)\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\\n\\n if inv_mass is None:\\n params = params + (step_size) * momentum #/normalizing_const\\n else:\\n if type(inv_mass) is list:\\n pass\\n #Assum G is diag here so 1/Mass = G inverse\\n elif len(inv_mass.shape) == 2:\\n params = params + (step_size) * torch.matmul(inv_mass,momentum.view(-1,1)).view(-1) #/normalizing_const\\n else:\\n params = params + (step_size) * inv_mass * momentum #/normalizing_const\\n\\n for m in reversed(range(M)):\\n # print('p ', n )\\n momentum += 0.5 * step_size * params_grad(params,log_prob_func[m])\\n\\n ret_params.append(params.clone())\\n ret_momenta.append(momentum.clone())\\n\\n return ret_params, ret_momenta\\n\\n else:\\n raise NotImplementedError()\",\n \"def get_transition(self, row, col, action, tot_row, tot_col):\\n\\n '''\\n Expand the grid of the environment to handle when the \\n agent decides to move in the direction of a wall \\n '''\\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\\n\\n if action == 'UP':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.0 #DOWN\\n elif action == 'LEFT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.0 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'RIGHT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'DOWN':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.0 # UP\\n state_probabilities[row, col - 1] = 0.33 # LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 # DOWN\\n\\n for row in range (0, tot_row+1):\\n if state_probabilities[row, 0] != 0:\\n state_probabilities[row, 1] += state_probabilities[row, 0]\\n elif state_probabilities[row, -1] != 0:\\n state_probabilities[row, -2] += state_probabilities[row, -1]\\n\\n for col in range (0, tot_col+1):\\n if state_probabilities[0, col] != 0:\\n state_probabilities[1, col] += state_probabilities[0, col]\\n elif state_probabilities[-1, col] != 0:\\n state_probabilities[-2, col] += state_probabilities[-1, col]\\n\\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]\",\n \"def get_transition(self, row, col, action, tot_row, tot_col):\\n\\n '''\\n Expand the grid of the environment to handle when the \\n agent decides to move in the direction of a wall \\n '''\\n state_probabilities = np.zeros((int(np.sqrt(self.env.observation_space.n)) + 2, int(np.sqrt(self.env.observation_space.n)) + 2), dtype=float)\\n\\n if action == 'UP':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.0 #DOWN\\n elif action == 'LEFT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.33 #LEFT\\n state_probabilities[row, col + 1] = 0.0 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'RIGHT':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.33 #UP\\n state_probabilities[row, col - 1 ] = 0.0 #LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 #DOWN\\n elif action == 'DOWN':\\n row += 1\\n col += 1\\n state_probabilities[row - 1, col] = 0.0 # UP\\n state_probabilities[row, col - 1] = 0.33 # LEFT\\n state_probabilities[row, col + 1] = 0.33 # RIGHT\\n state_probabilities[row + 1, col] = 0.33 # DOWN\\n\\n for row in range (0, tot_row+1):\\n if state_probabilities[row, 0] != 0:\\n state_probabilities[row, 1] += state_probabilities[row, 0]\\n elif state_probabilities[row, -1] != 0:\\n state_probabilities[row, -2] += state_probabilities[row, -1]\\n\\n for col in range (0, tot_col+1):\\n if state_probabilities[0, col] != 0:\\n state_probabilities[1, col] += state_probabilities[0, col]\\n elif state_probabilities[-1, col] != 0:\\n state_probabilities[-2, col] += state_probabilities[-1, col]\\n\\n return state_probabilities[1: 1+tot_row, 1:1+tot_col]\",\n \"def __init__(self,numagents,bits,in_nodes,print_flag=False):\\n self.numagents = numagents\\n self.agent = []\\n self.in_bits = in_nodes\\n\\n \\\"\\\"\\\" initialize empty dict for trajectories\\\"\\\"\\\"\\n self.trajectories={}\\n self.accepted_changes = 0\\n self.learning_rate = numpy.zeros((3,1),dtype=int)\\n\\n \\\"\\\"\\\" initialize network topology \\\"\\\"\\\"\\n self.adjacency = numpy.zeros((numagents,numagents),dtype=int)\\n\\n\\n # Erdös Renyi network; symmetric G(n,p) with p=0.5;\\n # if p > ln(n)/n graph is almost surely connected\\n \\n p0=0.75\\n for ia1 in range(self.numagents):\\n for ia2 in range(ia1+1,self.numagents):\\n if ia1 < 3 and ia2 < 3: self.adjacency[ia1,ia2] = 1 #fully connected in_nodes\\n else:\\n pER = numpy.random.random()\\n if pER <= p0: self.adjacency[ia1,ia2] = 1\\n self.adjacency[ia2,ia1] = self.adjacency[ia1,ia2] #symmetrize\\n\\n\\n\\n \\\"\\\"\\\"#complete graph (dense)\\n for ia1 in range(self.numagents):\\n for ia2 in range(ia1+1,self.numagents):\\n self.adjacency[ia1,ia2] = 1\\n self.adjacency[ia2,ia1] = 1\\n \\\"\\\"\\\"\\n\\n\\n \\\"\\\"\\\"\\n #4-lattice\\n for ia in range(self.numagents):\\n if ia > 1 and ia < self.numagents-2:\\n ia1 = ia + 1\\n ia2 = ia + 2\\n ia3 = ia - 1\\n ia4 = ia - 2\\n\\n elif ia == 0:\\n ia1 = ia + 1\\n ia2 = ia + 2\\n ia3 = self.numagents-1\\n ia4 = self.numagents-2\\n\\n elif ia == 1:\\n ia1 = ia + 1\\n ia2 = ia + 2\\n ia3 = ia - 1\\n ia4 = self.numagents-1\\n\\n elif ia == self.numagents-2:\\n ia1 = ia + 1\\n ia2 = 0\\n ia3 = ia - 1\\n ia4 = ia - 2\\n elif ia == self.numagents-1:\\n ia1 = 0\\n ia2 = 1\\n ia3 = ia- 1\\n ia4 = ia -2\\n\\n self.adjacency[ia,ia1] = 1\\n self.adjacency[ia1,ia] = 1\\n self.adjacency[ia,ia2] = 1\\n self.adjacency[ia2,ia] = 1\\n self.adjacency[ia,ia3] = 1\\n self.adjacency[ia3,ia] = 1\\n self.adjacency[ia, ia4] = 1\\n self.adjacency[ia4, ia] = 1\\n \\\"\\\"\\\"\\n\\n \\n #SF-network, BA(m=1)\\n \\\"\\\"\\\"\\n m=1\\n main_graph = networkx.barabasi_albert_graph(self.numagents, m)\\n self.adjacency = networkx.to_numpy_array(main_graph)\\n \\\"\\\"\\\"\\n\\n # density is number of edges/number of possible edges\\n self.graph_density = numpy.sum(self.adjacency)/(self.numagents*(self.numagents-1) )\\n\\n\\n \\\"\\\"\\\" initialize agents: \\\"\\\"\\\"\\n iagents = range(self.in_bits)\\n majority = True\\n for ia in range(self.numagents):\\n nbh = 3 #ALT: take mean neighborhood from graph; nbh = global_functions.dict_from_adj(self.adjacency)\\n mu1 = numpy.random.randint(1, nbh + 1) # int(thresh)\\n mu2 = numpy.random.randint(mu1, nbh + 1) #\\n if ia in iagents: i = True\\n else: i = False\\n self.agent.append(agent(ia,ia,bits,nbh,i,mu1,mu2,majority=majority)) #initialize with majority rule\\n #print(ia,self.agent[ia].rule)\\n\\n if print_flag:\\n adj_dict = global_functions.dict_from_adj(self.adjacency)\\n numagents = 0\\n for ia in range(len(self.adjacency)):\\n if numpy.sum(self.adjacency[ia]) != 0 or numpy.sum(self.adjacency[:, ia]) != 0: numagents += 1\\n print(\\\"Initialize network with\\\", self.numagents, \\\"agents on a graph with\\\"\\n , len(adj_dict), \\\"edges and density of\\\", numpy.around(self.graph_density,2))\\n print(\\\"Input agents:\\\", iagents)\\n print(\\\"Average degree:\\\", numpy.around(numpy.sum(self.adjacency)/self.numagents,2))\\n\\n if self.numagents <= 12:\\n for l in self.adjacency: print(l)\\n else:\\n for key in adj_dict: print(key,\\\"->\\\",adj_dict[key])\\n\\n print(\\\"Perceptual rule of type:\\\")\\n if majority: print(\\\"majority rule: x -> 1: if sum(input) >= out_degree/2\\\")\\n else:\\n print(\\\"x -> 1: if mu1 <= sum(input) <= mu2\\\")\\n print(\\\"mu1 =\\\",[self.agent[ia].mu1 for ia in range(self.numagents)],\\n \\\"mu2 =\\\",[self.agent[ia].mu2 for ia in range(self.numagents)])\\n #for key in itertools.product({0, 1}, repeat = self.out_bits):\\n # print(key, self.agent[0].update(key))\\n print(\\\"Network successfully initialized\\\")\",\n \"def run_viterbi(emission_scores, trans_scores, start_scores, end_scores):\\r\\n L = start_scores.shape[0]\\r\\n assert end_scores.shape[0] == L\\r\\n assert trans_scores.shape[0] == L\\r\\n assert trans_scores.shape[1] == L\\r\\n assert emission_scores.shape[1] == L\\r\\n N = emission_scores.shape[0]\\r\\n\\r\\n # SHAPES \\r\\n # N = 5, L = 3\\r\\n # emission_scores = (5,3), trans_scores = (3,3)\\r\\n # start_scores = (3,), end_scores = (3,)\\r\\n\\r\\n # Creating the transition DP matrix\\r\\n T = [[0 for _ in range(N)] for _ in range(L)]\\r\\n backpointers = [[0 for _ in range(N)] for _ in range(L)]\\r\\n\\r\\n # Filling the first column\\r\\n for row in range(L):\\r\\n T[row][0] = emission_scores[0][row] + start_scores[row] # emission_scores matrix is (N X L)\\r\\n \\r\\n # Filling the rest of the transition matrix\\r\\n for col in range(1, N):\\r\\n for row in range(L):\\r\\n prev_list = []\\r\\n for prev_label in range(L):\\r\\n prev_list.append(trans_scores[prev_label, row] + T[prev_label][col-1])\\r\\n T[row][col] = max(prev_list) + emission_scores[col][row] \\r\\n backpointers[row][col] = np.argmax(prev_list)\\r\\n\\r\\n # Filling the last column\\r\\n for row in range(L):\\r\\n T[row][N-1] += end_scores[row]\\r\\n\\r\\n # print for debug\\r\\n # print \\\"T\\\"\\r\\n # for i in T:\\r\\n # print i\\r\\n \\r\\n # print \\r\\n # print\\r\\n\\r\\n # print \\\"B\\\"\\r\\n # for i in backpointers:\\r\\n # print i\\r\\n\\r\\n # Finding max score in last column of T matrix\\r\\n T = np.array(T)\\r\\n score = np.asscalar(np.max(T[:,N-1]))\\r\\n location = np.asscalar(np.argmax(T[:,N-1]))\\r\\n\\r\\n # Getting best sequence from right to left using backpointers\\r\\n y = [location]\\r\\n for col in range(N-1, 0, -1):\\r\\n y.insert(0, backpointers[location][col])\\r\\n location = backpointers[location][col]\\r\\n\\r\\n '''\\r\\n y = []\\r\\n for i in xrange(N):\\r\\n # stupid sequence\\r\\n y.append(i % L)\\r\\n # score set to 0\\r\\n return (0.0, y)\\r\\n '''\\r\\n return (score, y)\",\n \"def decode_MST(energies, lengths, leading_symbolic=0, labeled=True):\\n\\n def find_cycle(par):\\n added = np.zeros([length], np.bool)\\n added[0] = True\\n cycle = set()\\n findcycle = False\\n for i in range(1, length):\\n if findcycle:\\n break\\n\\n if added[i] or not curr_nodes[i]:\\n continue\\n\\n # init cycle\\n tmp_cycle = set()\\n tmp_cycle.add(i)\\n added[i] = True\\n findcycle = True\\n l = i\\n\\n while par[l] not in tmp_cycle:\\n l = par[l]\\n if added[l]:\\n findcycle = False\\n break\\n added[l] = True\\n tmp_cycle.add(l)\\n\\n if findcycle:\\n lorg = l\\n cycle.add(lorg)\\n l = par[lorg]\\n while l != lorg:\\n cycle.add(l)\\n l = par[l]\\n break\\n\\n return findcycle, cycle\\n\\n def chuLiuEdmonds():\\n par = np.zeros([length], dtype=np.int32)\\n # create best graph\\n par[0] = -1\\n for i in range(1, length):\\n # only interested at current nodes\\n if curr_nodes[i]:\\n max_score = score_matrix[0, i]\\n par[i] = 0\\n for j in range(1, length):\\n if j == i or not curr_nodes[j]:\\n continue\\n\\n new_score = score_matrix[j, i]\\n if new_score > max_score:\\n max_score = new_score\\n par[i] = j\\n\\n # find a cycle\\n findcycle, cycle = find_cycle(par)\\n # no cycles, get all edges and return them.\\n if not findcycle:\\n final_edges[0] = -1\\n for i in range(1, length):\\n if not curr_nodes[i]:\\n continue\\n\\n pr = oldI[par[i], i]\\n ch = oldO[par[i], i]\\n final_edges[ch] = pr\\n return\\n\\n cyc_len = len(cycle)\\n cyc_weight = 0.0\\n cyc_nodes = np.zeros([cyc_len], dtype=np.int32)\\n id = 0\\n for cyc_node in cycle:\\n cyc_nodes[id] = cyc_node\\n id += 1\\n cyc_weight += score_matrix[par[cyc_node], cyc_node]\\n\\n rep = cyc_nodes[0]\\n for i in range(length):\\n if not curr_nodes[i] or i in cycle:\\n continue\\n\\n max1 = float(\\\"-inf\\\")\\n wh1 = -1\\n max2 = float(\\\"-inf\\\")\\n wh2 = -1\\n\\n for j in range(cyc_len):\\n j1 = cyc_nodes[j]\\n if score_matrix[j1, i] > max1:\\n max1 = score_matrix[j1, i]\\n wh1 = j1\\n\\n scr = cyc_weight + score_matrix[i, j1] - score_matrix[par[j1], j1]\\n\\n if scr > max2:\\n max2 = scr\\n wh2 = j1\\n\\n score_matrix[rep, i] = max1\\n oldI[rep, i] = oldI[wh1, i]\\n oldO[rep, i] = oldO[wh1, i]\\n score_matrix[i, rep] = max2\\n oldO[i, rep] = oldO[i, wh2]\\n oldI[i, rep] = oldI[i, wh2]\\n\\n rep_cons = []\\n for i in range(cyc_len):\\n rep_cons.append(set())\\n cyc_node = cyc_nodes[i]\\n for cc in reps[cyc_node]:\\n rep_cons[i].add(cc)\\n\\n for i in range(1, cyc_len):\\n cyc_node = cyc_nodes[i]\\n curr_nodes[cyc_node] = False\\n for cc in reps[cyc_node]:\\n reps[rep].add(cc)\\n\\n chuLiuEdmonds()\\n\\n # check each node in cycle, if one of its representatives is a key in the final_edges, it is the one.\\n found = False\\n wh = -1\\n for i in range(cyc_len):\\n for repc in rep_cons[i]:\\n if repc in final_edges:\\n wh = cyc_nodes[i]\\n found = True\\n break\\n if found:\\n break\\n\\n l = par[wh]\\n while l != wh:\\n ch = oldO[par[l], l]\\n pr = oldI[par[l], l]\\n final_edges[ch] = pr\\n l = par[l]\\n\\n if labeled:\\n assert energies.ndim == 4, 'dimension of energies is not equal to 4'\\n else:\\n assert energies.ndim == 3, 'dimension of energies is not equal to 3'\\n input_shape = energies.shape\\n batch_size = input_shape[0]\\n max_length = input_shape[2]\\n\\n pars = np.zeros([batch_size, max_length], dtype=np.int32)\\n arc_tags = np.zeros([batch_size, max_length], dtype=np.int32) if labeled else None\\n for i in range(batch_size):\\n energy = energies[i]\\n\\n # calc the real length of this instance\\n length = lengths[i]\\n\\n # calc real energy matrix shape = [length, length, num_labels - #symbolic] (remove the label for symbolic arcs).\\n if labeled:\\n energy = energy[leading_symbolic:, :length, :length]\\n # get best label for each edge.\\n label_id_matrix = energy.argmax(axis=0) + leading_symbolic\\n energy = energy.max(axis=0)\\n else:\\n energy = energy[:length, :length]\\n label_id_matrix = None\\n # get original score matrix\\n orig_score_matrix = energy\\n # initialize score matrix to original score matrix\\n score_matrix = np.array(orig_score_matrix, copy=True)\\n\\n oldI = np.zeros([length, length], dtype=np.int32)\\n oldO = np.zeros([length, length], dtype=np.int32)\\n curr_nodes = np.zeros([length], dtype=np.bool)\\n reps = []\\n\\n for s in range(length):\\n orig_score_matrix[s, s] = 0.0\\n score_matrix[s, s] = 0.0\\n curr_nodes[s] = True\\n reps.append(set())\\n reps[s].add(s)\\n for t in range(s + 1, length):\\n oldI[s, t] = s\\n oldO[s, t] = t\\n\\n oldI[t, s] = t\\n oldO[t, s] = s\\n\\n final_edges = dict()\\n chuLiuEdmonds()\\n par = np.zeros([max_length], np.int32)\\n if labeled:\\n arc_tag = np.ones([max_length], np.int32)\\n arc_tag[0] = 0\\n else:\\n arc_tag = None\\n\\n for ch, pr in final_edges.items():\\n par[ch] = pr\\n if labeled and ch != 0:\\n arc_tag[ch] = label_id_matrix[pr, ch]\\n\\n par[0] = 0\\n pars[i] = par\\n if labeled:\\n arc_tags[i] = arc_tag\\n\\n return pars, arc_tags\",\n \"def simulation(G, # graph object\\n pos = None, # positions of nodes\\n n = 5, # number of simulation steps\\n \\n # wrapped args for simulation_step function\\n kernel = 'weights', # simulation kernel\\n custom_kernel = None, # custom simulation kernel\\n WERE_multiplier = 10, # multiplier for WERE kernel\\n oblivion = False, # enable information oblivion\\n engagement_enforcement = 1.01,\\n draw = False, # draw graph\\n show_attr = False): # show attributes \\n \\n #=======================================#\\n # append nodes data from 0 step to list #\\n #=======================================#\\n \\n graph_list = []\\n graph_list.append(copy.deepcopy(list(G.nodes.data() ) ) )\\n \\n\\n #===================#\\n # Run n simulations #\\n #===================#\\n \\n for i in range(n):\\n dp.simulation_step(G = G, \\n pos = pos, \\n \\n kernel = kernel,\\n custom_kernel = custom_kernel,\\n WERE_multiplier = WERE_multiplier, \\n oblivion = oblivion, \\n engagement_enforcement = engagement_enforcement,\\n draw = draw, \\n show_attr = show_attr)\\n\\n # save nodes data to to list\\n graph_list.append(copy.deepcopy(list(G.nodes.data() ) ) )\\n \\n \\n #======================================================#\\n # Count aware agents before and after simulation steps #\\n #======================================================#\\n \\n # Check number of aware agents in 0 step\\n #global aware_first\\n aware_first = []\\n for i in range(len(graph_list[0])):\\n aware_first.append(graph_list[0][i][1]['state'])\\n aware_first_c = aware_first.count('aware')\\n \\n # graph_list[0][1][1]['state']\\n \\n # Check number of aware agents in the last step\\n #global aware_last\\n aware_last = []\\n graph_list_len = len(graph_list) - 1\\n for i in range(len(graph_list[0])):\\n aware_last.append(graph_list[graph_list_len][i][1]['state']) # n is the last sim\\n aware_last_c = aware_last.count('aware')\\n \\n #graph_list[5][0][1]['state']\\n \\n #=================================#\\n # diffusion performance measuring #\\n #=================================#\\n \\n # equation for diffusion performance measuring\\n avg_aware_inc_per_step = (aware_last_c - aware_first_c) / n\\n \\n # show graph statistics\\n return graph_list, avg_aware_inc_per_step\",\n \"def metropolis_hastings(states, n_steps, n_particles=100, beta=0.1):\\n\\n spin_change = [-1, 1]\\n energy_output = np.zeros((n_steps, 2))\\n\\n n = 0\\n for i in range(n_steps):\\n\\n n += 1\\n\\n # generate the random change variables\\n random_particle = np.random.randint(n_particles)\\n random_direction = np.random.randint(3)\\n random_change = spin_change[np.random.randint(2)]\\n\\n # calculate the energy of the initial state\\n E_i = E(states)\\n # make copy of initial states to compare\\n changed_states = states.copy()\\n\\n # change a random state\\n changed_states[random_particle][random_direction] += random_change\\n\\n if changed_states[random_particle][random_direction] < 1:\\n changed_states[random_particle][random_direction] = \\\\\\n states[random_particle][random_direction]\\n # n can't be less than 1, so go back to original state\\n\\n E_j = E(changed_states) # calculate the energy of the new states\\n\\n if E_j < E_i:\\n # accept E_j value\\n energy = E_j\\n states = changed_states\\n else:\\n # calculate the probabilty for the transistion to happen\\n prob_accept = np.exp(-1 * beta * (E_j - E_i))\\n # pull random number and compare to prob_accept\\n rand_num_accept = np.random.rand(1)\\n if rand_num_accept <= prob_accept:\\n # accept E_j\\n energy = E_j\\n states = changed_states\\n else:\\n # reject E_j\\n energy = E_i\\n\\n energy_output[i][0], energy_output[i][1] = energy, n\\n\\n return energy_output\",\n \"def sim(self, (K,T), (j0,x0), dt, rx, **params):\\n dt0 = dt \\n\\n k = 0\\n t = [0.]\\n j = deepcopy(j0)\\n x = [deepcopy(x0)]\\n\\n trj = dict(k=k,t=t,j=j,x=x)\\n trjs = []\\n\\n while ( trj['t'][-1] <= T # don't exceed max continuous time\\n and trj['k'] < K # don't exceed max discrete transitions\\n and not trj['j'] is None ): # don't allow discrete state is None\\n k0 = trj['k']\\n t0 = trj['t'][-1]\\n j0 = trj['j']\\n x0 = trj['x'][-1]\\n if 0: # forward Euler\\n dx = self.F((k0,t0), (j0,x0), **params)\\n else: # 4th-order Runge-Kutta \\n f = lambda t,x : self.F((k0,t), (j0,x), **params)\\n dx1 = f( t0, x0 ) * dt\\n dx2 = f( t0+.5*dt, x0+.5*dx1 ) * dt\\n dx3 = f( t0+.5*dt, x0+.5*dx2 ) * dt\\n dx4 = f( t0+dt, x0+dx3 ) * dt\\n dx = (1./6.)*( dx1 + 2*dx2 + 2*dx3 + dx4 ) / dt\\n\\n k = k0\\n j = j0\\n t = t0 + dt\\n x = x0 + dt * dx\\n g = self.G((k,t), (j,x), **params)\\n\\n # halve step size until trajectory doesn't violate guard more than rx\\n i = 0\\n imax = 50\\n while np.any(g < -rx) and (i <= imax):\\n dt = dt/2.\\n t = t0 + dt\\n x = x0 + dt * dx\\n g = self.G((k,t), (j,x), **params)\\n i += 1\\n\\n #if (i >= imax):\\n # raise RuntimeError,'(sim) guard iterations exceeded -- you probably have a buggy guard'\\n\\n # append state to trj\\n trj['t'].append(t)\\n trj['x'].append(x)\\n\\n if 0 and 'debug' in params and params['debug']:\\n print ' : (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s, dx = %s' % (k,t,j,x,dt,g,x,dx)\\n\\n # if in guard \\n if np.any(g < 0):\\n\\n # spend time in guard\\n if i >= imax:\\n t = t + rx\\n else:\\n t = t + (rx + g.min())\\n trj['t'].append(t)\\n trj['x'].append(x)\\n\\n if 'debug' in params and params['debug']:\\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\\n\\n # append trj to trjs\\n trjs.append(trj)\\n\\n if 'Zeno' in params and params['Zeno'] and (len(trj['t']) <= 4):\\n\\n print '(sim) possible Zeno @ stepsize dt = %0.6f' % dt0\\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\\n return trjs\\n\\n # apply reset to modify trj\\n (k,t),(j,x) = self.R((k,t), (j,x), **params)\\n trj = dict(k=k,t=[t],j=j,x=[x])\\n\\n # re-initialize step size\\n dt = dt0\\n\\n if 'debug' in params and params['debug']:\\n g = self.G((k,t), (j,x), **params)\\n print 'rx: (k,t)=(%s,%0.3f), (j,x)=(%s,%s), dt=%0.2e, g = %s, x = %s' % (k,t,j,x,dt,g,x)\\n\\n trjs.append(trj)\\n\\n return trjs\",\n \"def time_path_iteration(params=params, S=3, T=50, weight=0.3, tol=1e-12, maxiter=100):\\n ss_output = get_SS()\\n b_ss = ss_output['b_ss']\\n b_init = np.array([0, 0.8 * b_ss[0], 1.1 * b_ss[1]]) # t=0\\n\\n # Guess transition path, finishes at steady_state\\n Kguess = np.linspace(b_init.sum(), ss_output['K_ss'], T)\\n\\n s = 1\\n K_dynamic = Kguess\\n b_current = np.zeros((S,T)) # initialize array to store savings decisions\\n b_current[:,0] = b_init\\n\\n # Update b_path until convergence\\n its = 0\\n ee_diff = 7.0\\n while ee_diff > tol and its < maxiter:\\n its += 1\\n w_dynamic = find_w(L=params['labor_supply'].sum(), K=K_dynamic)\\n r_dynamic = find_r(L=params['labor_supply'].sum(), K=K_dynamic)\\n for t in range(T-2):\\n\\n #solve for b32, savings decision of middle-aged in first period\\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_current[:,t], s, t)\\n b_current[s+1,t+1] = opt.root(ee_err_1, 0, args=ee_param).x\\n\\n # solve for b22, b33, savings decision of young gen in middle/old generations\\n ee_param = (w_dynamic, r_dynamic, params['labor_supply'], b_init, s, t)\\n b_current[s,t+1], b_current[s+1, t+2]= opt.root(ee_err_23, [0,0], args=ee_param).x\\n # fill in table\\n b_current[s,T-1] = b_current[s,T-2]\\n\\n # Check for convergence\\n K_prime = b_current.sum(axis=0)\\n ee_diff = (K_prime - K_dynamic).max()\\n\\n# rc_diff = production(K_prime, L=params['labor_supply'].sum())\\n# - Ct = (1 + r_dynamic) * ()\\n# - np.roll(K_prime, len(K_prime)-1)\\n# - (1 - delta) * K_prime\\n\\n print('Iteration number: ', its, 'Current EE difference: ', ee_diff)\\n # update new capital path\\n K_dynamic = weight * K_prime + (1-weight) * K_dynamic\\n\\n fig, ax = plt.subplots(1,1,figsize=(8,6))\\n plt.plot(range(T), Kguess, 'r--',lw=0.7, label='Kguess')\\n plt.plot(range(T), K_dynamic , label='Capital Path Solution')\\n plt.title('Transition Path of Aggregate Capital')\\n plt.xlabel('Time period')\\n plt.ylabel('Aggregate Capital')\\n plt.legend()\\n\\n fig, ax = plt.subplots(1,1,figsize=(8,6))\\n plt.plot(range(T), r_dynamic, 'g-o',label='Interest rate Path Solution')\\n plt.title('Transition Path of Aggregate Interest rate')\\n plt.xlabel('Time period')\\n plt.ylabel('Interest Rate')\\n plt.legend()\\n\\n fig, ax = plt.subplots(1,1,figsize=(8,6))\\n plt.plot(range(T), w_dynamic, 'k-o',label='Wage Path Solution')\\n plt.title('Transition Path of Wages')\\n plt.xlabel('Time period')\\n plt.ylabel('Wages')\\n plt.legend()\\n\\n return K_dynamic\",\n \"def hEqn(g, e, h, f, Gescape, Gform, EHdecay, FHloss, stepsize):\\n hchange = (g * Gescape\\n - h * e * EHdecay\\n - h * f * FHloss\\n - e * h * Gform)\\n return hchange * stepsize\",\n \"def main(args):\\n\\n # Take the adjacency matrix of the graph\\n adjacency_mat_graph = parse_adjacency_matrix_csv(args.i)\\n\\n # Check if the number of row == number of columns of the matrix\\n logging.info(\\\"Checking the matrix shape...\\\")\\n number_row_edges = len(adjacency_mat_graph)\\n number_col_edges = len(adjacency_mat_graph[0])\\n if number_row_edges != number_col_edges:\\n raise ValueError(f\\\"The number of nodes detected in row\\\"\\n f\\\"{number_row_edges} not equal to the \\\"\\n f\\\"number of nodes found in column \\\"\\n f\\\"{number_col_edges}.\\\")\\n\\n # check and verify if graph has only one root\\n logging.info(\\\"Checking if graph has only one root and verify...\\\")\\n root, number_root = unique_root_node_checking(adjacency_mat_graph)\\n\\n if root == \\\"NA\\\" and number_root == 0:\\n raise ValueError(f\\\"No root node found in graph\\\")\\n elif root == \\\"NA\\\" and number_root > 0:\\n raise ValueError(\\\"More than one root node found in graph\\\")\\n\\n # check if identify root is the same as the one provided\\n if root != \\\"NA\\\" and root != args.r:\\n raise ValueError(f\\\"Expected {args.r} as root node but {root}\\\"\\n f\\\" found in graph.\\\")\\n\\n # Convert adjacency matrix to dict representation for further steps\\n logging.info(\\\"Converting matrix to dictionary graph...\\\")\\n dict_graph = adjacency_matrix_to_dict_graph(adjacency_mat_graph)\\n\\n # Check if provided node is in the graph\\n logging.info(\\\"Checking if node of interest n in graph...\\\")\\n if args.n not in dict_graph:\\n raise ValueError(f\\\"Provided node of interest {args.n} \\\"\\n f\\\"is not found in the provided graph.\\\")\\n\\n # Check if the provided graph is acyclic\\n logging.info(\\\"Checking if graph is acyclic...\\\")\\n is_cyclic = is_cyclic_graph(dict_graph)\\n if is_cyclic:\\n raise ValueError(\\\"The provided graph is not acyclic. \\\"\\n \\\"At least one cycle was detected in graph.\\\")\\n logging.info(\\\"THE PROVIDED GRAPH IS DAG !!!\\\")\\n\\n # Get depth\\n logging.info(f\\\"Getting the depth of node {args.n}...\\\")\\n path, depth = get_node_depth(dict_graph, args.r, args.n, [])\\n assert len(path) -1 == depth, f\\\"Length path {path} != depth {depth}\\\"\\n logging.info(f\\\"The depth of node {args.n} is equal to {depth}\\\")\",\n \"def astar(model, start, end):\\n\\n # Create start and end node\\n start_node = Node(None,0.0, start)\\n start_node.g = 0\\n start_node.h = calculate_h(start_node,end)\\n start_node.f = start_node.g + start_node.h \\n \\n end_node = Node(None,0.0, end)\\n end_node.g = end_node.h = end_node.f = 0\\n\\n # Initialize both open and closed list\\n open_list = []\\n closed_list = []\\n\\n # Add the start node\\n open_list.append(start_node)\\n\\n\\n\\n iterations = 0\\n # Loop until you find the end\\n while len(open_list) > 0:\\n iterations += 1\\n # print(iterations)\\n print('openlist={},closed_list={}'.format(len(open_list),len(closed_list)))\\n\\n # Get the current node\\n current_node = open_list[0]\\n current_index = 0\\n for index, item in enumerate(open_list):\\n if item.f < current_node.f:\\n current_node = item\\n current_index = index\\n\\n # Pop current off open list, add to closed list\\n open_list.pop(current_index)\\n closed_list.append(current_node)\\n\\n print('currentstate={}, parentaction={}, f={}'.format(current_node.state, current_node.parent_action, current_node.f))\\n\\n # run_sim(current_node.parent_action)\\n\\n # Found the goal\\n if current_node == end_node: \\n actions = []\\t\\n current = current_node\\n while current is not None:\\n actions.append(current.parent_action)\\n current = current.parent_state\\n # print(current.state)\\n return actions[::-1] # Return reversed path\\n\\n # Generate children states\\n children = []\\n\\n for action in discretized_action: # all possible actions\\n\\n # Get new state node (closest to discretized state space)\\n \\n # new_state = get_next_state_from_model(model,current_node,action)\\n new_state = get_next_state_from_eqn(current_node,action)\\n # new_state = run_sim(action)\\n # print(new_state)\\n\\n # # Make sure within range\\n # if node_position[0] > (len(maze) - 1) or node_position[0] < 0 or node_position[1] > (len(maze[len(maze)-1]) -1) or node_position[1] < 0:\\n # continue\\n\\n # # Make sure walkable terrain\\n # if maze[node_position[0]][node_position[1]] != 0:\\n # continue\\n\\n #############Make sure to wrap theta \\n \\n # Create new node\\n new_node = Node(current_node, action, new_state)\\n\\n # Append\\n children.append(new_node)\\n\\n # Loop through children\\n for child in children:\\n\\n # Child is on the closed list\\n for closed_child in closed_list:\\n if child == closed_child:\\t\\n continue\\n\\n # Create the f, g, and h values\\n child.g = calculate_g(child,current_node) #current_node.g + 1\\n child.h = calculate_h(child,end_node)\\n child.f = child.g + child.h\\n \\n # \\tprint(child.state, child.parent_action, child.f) \\n \\n # Child is already in the open list\\n for open_node in open_list:\\n if child == open_node and child.g > open_node.g:\\n continue\\n\\n # Add the child to the open list\\n open_list.append(child)\",\n \"def alpha_correction_ar(graph=line_graph(n=2), mode='hybrid', angle=np.pi/4, which='S', verbose=False):\\n if which == 'S':\\n index = 0\\n elif which == 'L':\\n index = graph.num_independent_sets - 1\\n else:\\n index = which\\n\\n energies = []\\n bad_indices = []\\n target_energy = graph.independent_sets[index][1]\\n degeneracy = 0\\n # Compute maximum independent set size and \\\"bad\\\" energies\\n for IS in graph.independent_sets:\\n if graph.independent_sets[IS][1] != target_energy:\\n energies.append(graph.independent_sets[IS][1])\\n bad_indices.append(IS)\\n else:\\n degeneracy += 1\\n energies = np.array(energies)\\n energies = np.abs(target_energy-energies)\\n\\n # Good is a list of good eigenvalues\\n # Bad is a list of bad eigenvalues. If 'other', defaults to all remaining eigenvalues outside of 'good'\\n def schedule_hybrid(t, tf):\\n phi = (tf - t) / tf * np.pi / 2\\n energy_shift.energies = (np.sin(2*((tf - t) / tf-1/2) * np.pi),)\\n laser.omega_g = np.cos(phi)\\n laser.omega_r = np.sin(phi)\\n dissipation.omega_g = np.cos(phi)\\n dissipation.omega_r = np.sin(phi)\\n\\n def schedule_reit(t, tf):\\n phi = (tf - t) / tf * np.pi / 2\\n laser.omega_g = np.cos(phi)\\n laser.omega_r = np.sin(phi)\\n dissipation.omega_g = np.cos(phi)\\n dissipation.omega_r = np.sin(phi)\\n\\n def schedule_adiabatic(t, tf):\\n phi = (tf - t) / tf * np.pi / 2\\n energy_shift.energies = (np.sin(2*((tf - t) / tf-1/2) * np.pi),)\\n laser.omega_g = np.cos(angle) * np.sin(phi) * np.cos(phi)\\n laser.omega_r = np.sin(angle) * np.sin(phi) * np.cos(phi)\\n dissipation.omega_g = np.cos(angle) * np.cos(phi) * np.sin(phi)\\n dissipation.omega_r = np.sin(angle) * np.cos(phi) * np.sin(phi)\\n\\n laser = EffectiveOperatorHamiltonian(graph=graph, IS_subspace=True,\\n energies=(1,),\\n omega_g=np.cos(np.pi / 4),\\n omega_r=np.sin(np.pi / 4))\\n energy_shift = hamiltonian.HamiltonianEnergyShift(IS_subspace=True, graph=graph,\\n energies=(2.5,), index=0)\\n dissipation = EffectiveOperatorDissipation(graph=graph, omega_r=1, omega_g=1,\\n rates=(1,))\\n if mode == 'hybrid':\\n schedule = schedule_hybrid\\n elif mode == 'adiabatic':\\n schedule = schedule_adiabatic\\n elif mode == 'reit':\\n schedule = schedule_reit\\n if mode != 'reit':\\n eq = SchrodingerEquation(hamiltonians=[laser, energy_shift])\\n else:\\n eq = SchrodingerEquation(hamiltonians=[laser])\\n\\n def compute_rate(t):\\n if verbose:\\n print(t)\\n schedule(t, 1)\\n # Construct the first order transition matrix\\n eigval, eigvec = eq.eig(k='all')\\n eigvec = eigvec.T\\n rates = np.zeros(eigval.shape[0] ** 2)\\n for op in dissipation.jump_operators:\\n rates = rates + ((eigvec.conj().T @ op @ eigvec)**2).flatten()\\n # Select the relevant rates from 'good' to 'bad'\\n\\n rates = np.reshape(rates.real, (graph.num_independent_sets, graph.num_independent_sets))\\n bad_rates = np.zeros(len(bad_indices))\\n for i in range(len(bad_indices)):\\n bad_rates[i] = bad_rates[i] + rates[bad_indices[i], index]\\n return np.dot(bad_rates, energies)\\n\\n # Integrate to find the correction\\n res, error = scipy.integrate.quad_vec(compute_rate, 1e-5, .9999)\\n return res/target_energy, error\",\n \"def time_expand(graph, nodes, obstruction):\\n time_steps = len(obstruction)\\n exp_size = len(nodes)\\n new_size = (time_steps+1)*exp_size\\n expanded_graph = np.zeros((new_size,new_size))\\n \\n for i in range(time_steps):\\n new_graph = np.copy(graph)\\n tc = i*exp_size\\n bc = tc + exp_size\\n node_at_time_step = obstruction[i]\\n new_graph[:,node_at_time_step] = 0 # remove \\\"to\\\"-columns from the graph\\n new_graph[node_at_time_step,:] = 0 # remove \\\"from\\\"-rows from the graph\\n expanded_graph[tc:bc, bc:bc+exp_size] = new_graph # Fill upper subdiagonal with A:s\\n # Fill bottom-right corner of the expanded graph with the A\\n # here the obstruction stops moving\\n expanded_graph[new_size - exp_size:new_size,new_size - exp_size:new_size] = new_graph\\n new_nodes = np.tile(nodes, ((time_steps+1),1))\\n return expanded_graph, new_nodes\",\n \"def J_E(h, integration_start_time=None):\\n\\n hdot = MTS(h).dot\\n\\n J_ℰ = 0.5 * 𝔇inverse(0.25 * (hdot * hdot.bar).int).ethbar.ethbar\\n\\n if integration_start_time is not None:\\n integration_start_time_index = np.argmin(abs(h.t - integration_start_time))\\n J_ℰ -= J_ℰ[integration_start_time_index, :]\\n\\n return J_ℰ\",\n \"def rwgraph_analyze1(input=(None)):\\r\\n #generates graph\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n\\r\\n Nt=100\\r\\n M=20000\\r\\n #finds max degree of graph and stores list of degrees of nodes\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n #generates data and stores them in lists for varyin M and Nt\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes=[]\\r\\n for i in range(M):\\r\\n Listnodes.append(G.degree(X[i,Nt]))\\r\\n Nt=10000\\r\\n M=20000\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes2=[]\\r\\n for i in range(M):\\r\\n Listnodes2.append(G.degree(X[i,Nt]))\\r\\n Nt=10\\r\\n M=20000\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes3=[]\\r\\n for i in range(M):\\r\\n Listnodes3.append(G.degree(X[i,Nt]))\\r\\n Nt=10000\\r\\n M=200\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes4=[]\\r\\n for i in range(M):\\r\\n Listnodes4.append(G.degree(X[i,Nt]))\\r\\n fig, ax1 = plt.subplots(figsize =(14,7))\\r\\n\\r\\n ##### creates histo gram figure with 2 axis####\\r\\n ax1.hist([Listnodes,Listnodes2], bins=maxdeg, label=['Nt=100', 'Nt=10000'],color=['g','r'],alpha=0.6)\\r\\n ax1.set_xlabel('degree of node')\\r\\n ax1.set_ylabel('frequency of final position of random walks')\\r\\n\\r\\n ax1.tick_params(axis='y')\\r\\n ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\\r\\n\\r\\n ax2.hist([degree_dist], bins=maxdeg, label=['graph node frequency'],color=['b'],alpha=0.6)\\r\\n ax2.set_ylabel('frequency of node degrees for graph')\\r\\n ax2.tick_params(axis='y')\\r\\n\\r\\n ax1.legend(loc=\\\"center right\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n ax2.legend(loc=\\\"upper right\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title('M=20000, node degree of final position of random walk, for varying amounts of time', y=1.10, fontsize=20)\\r\\n fig.tight_layout() # otherwise the right y-label is slightly clipped\\r\\n plt.grid(b=None)\\r\\n plt.show()\\r\\n\\r\\n #function to generate diction of frequency\\r\\n def CountFrequency(my_list):\\r\\n\\r\\n # Creating an empty dictionary\\r\\n freq = {}\\r\\n for item in my_list:\\r\\n if (item in freq):\\r\\n freq[item] += 1\\r\\n else:\\r\\n freq[item] = 1\\r\\n return freq\\r\\n #converts data to approprate form so it can plotted on scatter plot\\r\\n #frequecy\\r\\n listfreq1=CountFrequency(Listnodes2)\\r\\n listfreq2=CountFrequency(Listnodes3)\\r\\n listfreq3=CountFrequency(Listnodes4)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n #set up lists\\r\\n z=[]\\r\\n z2=[]\\r\\n z3=[]\\r\\n z_deg=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n #code to create list of only degrees used in simulations\\r\\n for i in listfreq1:\\r\\n z.append(listfreq1[i]/(listfreq_deg[i]*20000))\\r\\n z_deg.append(i)\\r\\n for i in listfreq2:\\r\\n z2.append(listfreq2[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq3:\\r\\n z3.append(listfreq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n #extpected prob distribution\\r\\n E=G.number_of_edges()\\r\\n z0=[]\\r\\n z_deg0=[]\\r\\n for i in listfreq_deg:\\r\\n z0.append(i/(2*E))\\r\\n z_deg0.append(i)\\r\\n #genrates scatter plot figure\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(z_deg, z, label='Nt=10000, M=20000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=10, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=10, M=200')\\r\\n plt.plot(z_deg0,z0,label=\\\"expected prob dist\\\",alpha=0.5)\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def objective(trial):\\n %time\\n env = gym.make('Delivery-v0')\\n alpha = trial.suggest_discrete_uniform('alpha', 0.3,0.9,0.3)\\n gamma = trial.suggest_discrete_uniform('gamma', 0.6, 1,0.1)\\n epsilon = trial.suggest_discrete_uniform('epsilon', 0.01, 0.11, 0.04)\\n episodes = 1000000\\n \\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n if random.uniform(0, 1) < epsilon:\\n action = env.action_space.sample() # Explore action space randomly\\n else:\\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n\\n next_state, reward, done, info = env.step(action) \\n\\n old_value = q_table[state, action]\\n next_max = np.max(q_table[next_state])\\n\\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\\n q_table[state, action] = new_value\\n\\n if reward == -10:\\n penalties += 1\\n \\n\\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n rewards.append(np.sum(episode_rewards))\\n \\n last_reward = np.mean(rewards)\\n # trial.report(-1 * last_reward)\\n\\n return -1 * last_reward\",\n \"def trajectories(t_upper=3600*24*687, h=100, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11):\\n\\n # We check if parameters are all positive\\n\\n list_parameters = [t_upper, h, m1, m2, m3,\\n a1, a2]\\n\\n for parameters in list_parameters:\\n\\n if parameters < 0:\\n print(f'You have entered a negative parameter')\\n\\n # initial values for planet 1 in x, y and z direction\\n x_i1 = a1\\n y_i1 = 0\\n v_x1i = 0\\n v_y1i = 29779.301841746023\\n z_i1 = 0\\n v_z1i = 0\\n\\n # initial values for planet 2 in x, y and z direction\\n x_i2 = a2\\n y_i2 = 0\\n v_x2i = 0\\n v_y2i = 24154.203325249873\\n z_i2 = 0\\n v_z2i = 0\\n\\n # initial values for Sun in x, y and z direction\\n x_i3 = 0\\n y_i3 = 0\\n v_x3i = 0\\n v_y3i = 0\\n z_i3 = 0\\n v_z3i = 0\\n\\n# Initial positions and velocities\\n r = np.array([x_i1, y_i1, v_x1i, v_y1i, x_i2,\\n y_i2, v_x2i, v_y2i, x_i3, y_i3, v_x3i, v_y3i,\\n z_i1, z_i2, z_i3, v_z1i, v_z2i, v_z3i])\\n\\n # We create vectors which will contains the trajectories\\n # and velocities of each bodies\\n x_pnts1 = [x_i1]\\n y_pnts1 = [y_i1]\\n v_x_pnts1 = [v_x1i]\\n v_y_pnts1 = [v_y1i]\\n\\n x_pnts2 = [x_i2]\\n y_pnts2 = [y_i2]\\n v_x_pnts2 = [v_x2i]\\n v_y_pnts2 = [v_y2i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n x_pnts3 = [x_i3]\\n y_pnts3 = [y_i3]\\n v_x_pnts3 = [v_x3i]\\n v_y_pnts3 = [v_y3i]\\n\\n z_pnts1 = [z_i1]\\n z_pnts2 = [z_i2]\\n z_pnts3 = [z_i3]\\n\\n v_z_pnts1 = [v_z1i]\\n v_z_pnts2 = [v_z2i]\\n v_z_pnts3 = [v_z3i]\\n\\n m1 = m1\\n m2 = m2\\n m3 = m3\\n a1 = a1\\n a2 = a2\\n\\n # We create a vector which will contain the time\\n # Initial value\\n t_i = 0.0\\n t_values = [t_i]\\n\\n for t in range(0, t_upper, h):\\n\\n # We used the RK4 formula here\\n k1 = h*derivative(r=r, t=0, m1=5.972e+24, m2=m2, m3=1.989e+30,\\n a1=a1, a2=1.52*1.496e+11)\\n k2 = h*derivative(r=r + 0.5*k1, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k3 = h*derivative(r=r + 0.5*k2, t=t + (h/2), m1=5.972e+24,\\n m2=6.417e+23, m3=1.989e+30, a1=1.0*1.496e+11,\\n a2=1.52*1.496e+11)\\n k4 = h*derivative(r=r + h*k3, t=t+h, m1=5.972e+24, m2=6.417e+23,\\n m3=1.989e+30, a1=1.0*1.496e+11, a2=1.52*1.496e+11)\\n\\n # We calculate the new vector r\\n r += (k1 + 2*k2 + 2*k3 + k4)*(1.0/6.0)\\n\\n # We add the new points calculated\\n x_pnts1.append(r[0])\\n y_pnts1.append(r[1])\\n\\n v_x_pnts1.append(r[2])\\n v_y_pnts1.append(r[3])\\n\\n x_pnts2.append(r[4])\\n y_pnts2.append(r[5])\\n v_x_pnts2.append(r[6])\\n v_y_pnts2.append(r[7])\\n\\n x_pnts3.append(r[8])\\n y_pnts3.append(r[9])\\n v_x_pnts3.append(r[10])\\n v_y_pnts3.append(r[11])\\n\\n z_pnts1.append(r[12])\\n z_pnts2.append(r[13])\\n z_pnts3.append(r[14])\\n\\n v_z_pnts1.append(r[15])\\n v_z_pnts2.append(r[16])\\n v_z_pnts3.append(r[17])\\n\\n t_values.append(t)\\n\\n # We return all the trajectories\\n return x_pnts1, y_pnts1, x_pnts2, y_pnts2, x_pnts3, y_pnts3, z_pnts1, z_pnts2, z_pnts3\",\n \"def compute_eigvals(*params, **hyperparams):\\n phi = params[0]\\n d, t = hyperparams[\\\"dimension\\\"]\\n\\n if qml.math.get_interface(phi) == \\\"tensorflow\\\":\\n phase = qml.math.exp(1j * qml.math.cast_like(phi, 1j))\\n minus_phase = qml.math.exp(-1j * qml.math.cast_like(phi, 1j))\\n return stack_last([phase if index < d else minus_phase for index in range(t)])\\n\\n arg = 1j * phi\\n prefactors = qml.math.array([1 if index < d else -1 for index in range(t)], like=phi)\\n\\n if qml.math.ndim(phi) == 0:\\n product = arg * prefactors\\n else:\\n product = qml.math.outer(arg, prefactors)\\n return qml.math.exp(product)\",\n \"def test_loss_hamiltonian_incomplete(self):\\n g = nx.lollipop_graph(4, 1).to_directed()\\n edge_weight_data = {edge: (i + 1) * 0.5 for i, edge in enumerate(g.edges)}\\n for k, v in edge_weight_data.items():\\n g[k[0]][k[1]][\\\"weight\\\"] = v\\n h = loss_hamiltonian(g)\\n\\n expected_ops = [\\n qml.PauliZ(0),\\n qml.PauliZ(1),\\n qml.PauliZ(2),\\n qml.PauliZ(3),\\n qml.PauliZ(4),\\n qml.PauliZ(5),\\n qml.PauliZ(6),\\n qml.PauliZ(7),\\n qml.PauliZ(8),\\n qml.PauliZ(9),\\n qml.PauliZ(10),\\n qml.PauliZ(11),\\n qml.PauliZ(12),\\n qml.PauliZ(13),\\n ]\\n expected_coeffs = [\\n np.log(0.5),\\n np.log(1),\\n np.log(1.5),\\n np.log(2),\\n np.log(2.5),\\n np.log(3),\\n np.log(3.5),\\n np.log(4),\\n np.log(4.5),\\n np.log(5),\\n np.log(5.5),\\n np.log(6),\\n np.log(6.5),\\n np.log(7),\\n ]\\n\\n assert expected_coeffs == h.coeffs\\n assert all([op.wires == exp.wires for op, exp in zip(h.ops, expected_ops)])\\n assert all([type(op) is type(exp) for op, exp in zip(h.ops, expected_ops)])\",\n \"def test_tdsp_dijsktra_with_timesteps_real_data(self):\\n input_file = \\\"/home/andy/code/python/om_task/data/input_data1.txt\\\"\\n graph_data = process_input_file(input_file)\\n\\n graphs = {}\\n\\n today = datetime.today()\\n t = time(0, 0) # input time value\\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\\n\\n for timestep in graph_data:\\n # print(\\\"Timestep=\\\", timestep)\\n # Create a graph for each timestep\\n graphs[timestep] = Graph()\\n for edge in graph_data.get(timestep):\\n graphs[timestep].add_edge(*edge)\\n\\n for graph in graphs:\\n print(graphs[graph].edges)\\n print(graphs[graph].weights)\\n\\n print(\\\"Start Test 1\\\")\\n path = tdsp_dijsktra(graphs, start_time, 'B1', 'F4')\\n print(path)\\n self.assertEqual(['B1', 'C2', 'D3', 'E4', 'F4'], path)\",\n \"def hmm(pc, n1, n2, w, dt, rounding):\\n\\n t = 0 # start time\\n ts = 0 #start time of stimulus \\n \\n x = 'default' #start hidden state\\n obs = [] #observations\\n states = [] #hidden states\\n count = 0 #counter\\n transitionYes = 0 #keeps track of whether transition has happened\\n foreperiodSteps = int((6/dt)+1)\\n \\n \\n while round(ts,rounding) < w: #this ends when w is over, rounding to avoid\\n #floating point no. comaparison errors\\n states.append(x)\\n \\n \\n if transitionYes == 1:\\n ts = ts+dt\\n \\n #generating observations, 1 is cue, 0 is default\\n if x == 'cue':\\n k = np.random.binomial(1,n2)\\n if k == 1:\\n obs.append(1) \\n else:\\n obs.append(0)\\n \\n if x == 'default':\\n k = np.random.binomial(1,n1)\\n if k == 1:\\n obs.append(0) \\n else:\\n obs.append(1)\\n \\n if count < foreperiodSteps and transitionYes == 0:\\n #\\n r = 1/(foreperiodSteps-count)\\n #print(r)\\n i = np.random.binomial(1, r) #transition out of default if i == 1\\n if i == 1:\\n transitionYes = 1\\n #tLeft = round(t,rounding)\\n j = np.random.binomial(1, pc) #on transitioning out of default, prob of \\n if j == 1: #cue is pc, and going back to default is 1-pc\\n x = 'cue'\\n else:\\n x = 'default'\\n \\n #print(r, t, count, ts, sep=' ')\\n t = t+dt\\n count = count +1\\n \\n \\n return obs, states\",\n \"def run_agent(self):\\n '''\\n The child class is created in order to override the value method which will take into account\\n previous states of the agent. The reward function is made exponential rather than linear, which\\n decreases the probability of agent visiting the state which was already visited.\\n '''\\n\\n class GraphProblemSpecialised(GraphProblem):\\n def __init__(self, initial, goal, graph, reward_dict, already_visited_reward):\\n GraphProblem.__init__(self, initial, goal, graph)\\n self.rewards = reward_dict\\n self.already_visited_reward = already_visited_reward\\n\\n def value(self, state, history):\\n if state in history.keys():\\n return self.rewards[state] - (self.already_visited_reward ** history[state])\\n return self.rewards[state]\\n\\n # -- Load and init mission --#\\n print('Generate and load the ' + self.mission_type + ' mission with seed ' + str(\\n self.mission_seed) + ' allowing ' + self.AGENT_MOVEMENT_TYPE + ' movements')\\n mission_xml = init_mission(self.agent_host, self.agent_port, self.AGENT_NAME, self.mission_type,\\n self.mission_seed, self.AGENT_MOVEMENT_TYPE)\\n self.solution_report.setMissionXML(mission_xml)\\n self.solution_report.start()\\n\\n # -- Get the state of the world along with internal state... --#\\n state_t = self.agent_host.getWorldState()\\n\\n # -- Main loop: --#\\n while state_t.is_mission_running:\\n state_t = self.agent_host.getWorldState()\\n\\n # -- Check if anything went wrong along the way --#\\n for error in state_t.errors:\\n print(\\\"Error:\\\", error.text)\\n\\n # -- Oracle and Internal Sensors--#\\n if state_t.number_of_observations_since_last_state > 0: # Has any Oracle-like and/or internal sensor observations come in?\\n msg = state_t.observations[-1].text # Get the details for the last observed state\\n oracle_and_internal = json.loads(msg) # Parse the Oracle JSON\\n # print oracle_and_internal\\n # -- Oracle sensor --#\\n grid = oracle_and_internal.get(u'grid', 0) # Demo only, string with the\\n # -- GPS-like sensor --#\\n xpos = oracle_and_internal.get(u'XPos', 0) # Demo only, position in 2D plane, 1st axis\\n zpos = oracle_and_internal.get(u'ZPos', 0) # Demo only, position in 2D plane, 2nd axis (yes Z!)\\n ypos = oracle_and_internal.get(u'YPos', 0) # Demo only, height as measured from surface! (yes Y!)\\n\\n current_location_id = self._get_current_location_id((xpos, zpos))\\n\\n if self.history.get(current_location_id):\\n self.history[current_location_id] += 1\\n else:\\n self.history[current_location_id] = 1\\n\\n if self.first_time_flag:\\n start_location = current_location_id\\n\\n # Gets the possible actions and checks for goal block\\n state_space_actions, state_space_locations, reached_goal = self._get_local_state_space_actions(grid,\\n [xpos,\\n zpos])\\n\\n if reached_goal:\\n break\\n\\n self.rewards_by_location_id, self.previous_rewards_total = self._get_rewards(\\n self.rewards_by_location_id,\\n state_space_actions,\\n state_space_locations,\\n oracle_and_internal,\\n self.previous_rewards_total)\\n\\n # Creates a graph for local (neighbourhood) actions\\n local_map = UndirectedGraph(state_space_actions)\\n local_problem = GraphProblemSpecialised(initial=start_location, goal=None, graph=local_map,\\n reward_dict=self.rewards_by_location_id,\\n already_visited_reward=self.already_visited_reward)\\n # Looks for most optimal next step\\n next_step = self.hill_climbing(local_problem, self.history)\\n\\n # If the next step is already in history the reward will be exponentially increased (but is negated)\\n if next_step in self.history.keys():\\n print \\\"You already visited that so will be punished!\\\"\\n self.rewards_by_location_id[next_step] -= self.already_visited_reward ** self.history[next_step]\\n self.history[next_step] += 1\\n\\n next_x, next_z = state_space_locations[next_step]\\n self.agent_host.sendCommand(\\\"tp \\\" + str(next_x) + \\\" \\\" + str(217) + \\\" \\\" + str(next_z))\\n time.sleep(0.1)\\n\\n # -- Collect the number of rewards and add to reward_cumulative --#\\n # -- Note: Since we only observe the sensors and environment every a number of rewards may have accumulated in the buffer --#\\n for reward_t in state_t.rewards:\\n print(\\\"Reward_t:\\\", reward_t.getValue())\\n self.solution_report.addReward(reward_t.getValue(), datetime.datetime.now())\\n\\n # -- Check if anything went wrong along the way --#\\n for error in state_t.errors:\\n print(\\\"Error:\\\", error.text)\\n\\n print(\\\"Mission has ended.either because time has passed or you reached the goal.\\\")\\n return\",\n \"def test_floyd_warshall(self):\\n dag = retworkx.PyDAG()\\n # inputs\\n qr_0 = dag.add_node('qr[0]')\\n qr_1 = dag.add_node('qr[1]')\\n qr_2 = dag.add_node('qr[2]')\\n cr_0 = dag.add_node('cr[0]')\\n cr_1 = dag.add_node('cr[1]')\\n # wires\\n cx_1 = dag.add_node('cx_1')\\n dag.add_edge(qr_0, cx_1, 'qr[0]')\\n dag.add_edge(qr_1, cx_1, 'qr[1]')\\n h_1 = dag.add_node('h_1')\\n dag.add_edge(cx_1, h_1, 'qr[0]')\\n cx_2 = dag.add_node('cx_2')\\n dag.add_edge(cx_1, cx_2, 'qr[1]')\\n dag.add_edge(qr_2, cx_2, 'qr[2]')\\n cx_3 = dag.add_node('cx_3')\\n dag.add_edge(h_1, cx_3, 'qr[0]')\\n dag.add_edge(cx_2, cx_3, 'qr[2]')\\n h_2 = dag.add_node('h_2')\\n dag.add_edge(cx_3, h_2, 'qr[2]')\\n # # outputs\\n qr_0_out = dag.add_node('qr[0]_out')\\n dag.add_edge(cx_3, qr_0_out, 'qr[0]')\\n qr_1_out = dag.add_node('qr[1]_out')\\n dag.add_edge(cx_2, qr_1_out, 'qr[1]')\\n qr_2_out = dag.add_node('qr[2]_out')\\n dag.add_edge(h_2, qr_2_out, 'qr[2]')\\n cr_0_out = dag.add_node('cr[0]_out')\\n dag.add_edge(cr_0, cr_0_out, 'qr[2]')\\n cr_1_out = dag.add_node('cr[1]_out')\\n dag.add_edge(cr_1, cr_1_out, 'cr[1]')\\n\\n result = retworkx.floyd_warshall(dag)\\n expected = {\\n 0: {0: 0, 5: 1, 6: 2, 7: 2, 8: 3, 9: 4, 10: 4, 11: 3, 12: 5},\\n 1: {1: 0, 5: 1, 6: 2, 7: 2, 8: 3, 9: 4, 10: 4, 11: 3, 12: 5},\\n 2: {2: 0, 7: 1, 8: 2, 9: 3, 10: 3, 11: 2, 12: 4},\\n 3: {3: 0, 13: 1},\\n 4: {4: 0, 14: 1},\\n 5: {5: 0, 6: 1, 7: 1, 8: 2, 9: 3, 10: 3, 11: 2, 12: 4},\\n 6: {6: 0, 8: 1, 9: 2, 10: 2, 12: 3},\\n 7: {7: 0, 8: 1, 9: 2, 10: 2, 11: 1, 12: 3},\\n 8: {8: 0, 9: 1, 10: 1, 12: 2},\\n 9: {9: 0, 12: 1},\\n 10: {10: 0},\\n 11: {11: 0},\\n 12: {12: 0},\\n 13: {13: 0},\\n 14: {14: 0},\\n }\\n self.assertDictEqual(result, expected)\",\n \"def el_ph(om,eig,q,zs,mass,eps,rG,nmodes,nqpt,nat):\\n\\n # Initiate\\n g = np.zeros((nqpt,nmodes),dtype=complex)\\n\\n # Initiate q+G\\n qpG = np.zeros((nqpt,3))\\n\\n q_c = q[:,0:3] \\n q2 = np.zeros(nqpt)\\n N = 5 # Initial size of G-point grid used for sum\\n\\n alpha = 5.0 # Convergence parameter\\n\\n for nn in range(-N,N+1):\\n for mm in range(-N,N+1):\\n for ll in range(-N,N+1):\\n #\\n for ic in range(3):\\n qpG[:,ic] = q_c[:,ic] + nn*rG[0,ic] + mm*rG[1,ic] + ll*rG[2,ic]\\n # IMPORTANT : Put a check here that qpG is nonzero! (break the loop if so)\\n # Denominator\\n q2[:] = 0.0\\n for ia in range(3): \\n for ib in range(3):\\n q2[:] += qpG[:,ia]*eps[ia,ib]*qpG[:,ib]\\n # \\n inv_q2 = 1.0 / (q2 + 1e-10)\\n arg = np.exp(-0.25 * np.sum(qpG**2, axis=1) / alpha) * inv_q2 # exp((q+G)^2/4a)\\n \\n for imod in range(nmodes):\\n for ia in range(3):\\n for ib in range(3):\\n for iat in range(nat):\\n g[:,imod] += arg[:]*qpG[:,ia]*zs[iat,ia,ib]*eig[imod,:,iat,ib] \\\\\\n / np.sqrt(2.0*mass[iat]*np.abs(om[imod,:])+1e-10)\\n\\n return g\",\n \"def compute_global_error(g):\\n Fx = 0\\n for edge in g.edges:\\n\\n # pose-pose constraint\\n if edge.Type == 'P':\\n\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node state for the current edge\\n x1 = g.x[fromIdx:fromIdx + 3]\\n x2 = g.x[toIdx:toIdx + 3]\\n\\n # get measurement and information matrix for the edge\\n z12 = edge.measurement\\n info12 = edge.information\\n\\n # (TODO) compute the error due to this edge`\\n z12 = v2t(z12)\\n x1 = v2t(x1)\\n x2 = v2t(x2)\\n eij = t2v(np.linalg.inv(z12) @ np.linalg.inv(x1) @ x2)\\n Fx = Fx + eij.transpose() @ info12 @ eij\\n # pose-pose constraint\\n elif edge.Type == 'L':\\n print(\\\"You shouldn't be here.\\\")\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node states for the current edge\\n x = g.x[fromIdx:fromIdx + 3]\\n l = g.x[toIdx:toIdx + 2]\\n\\n # get measurement and information matrix for the edge\\n z = edge.measurement\\n info12 = edge.information\\n\\n # (TODO) compute the error due to this edge\\n # TODO2 : do on homo matrices\\n xtr = v2t(x)\\n R = xtr[0:2, 0:2]\\n eil = R.transpose() @ (l - x[0:2]) - z\\n Fx = Fx + eil.transpose() @ info12 @ eil\\n\\n return Fx\",\n \"def test_tdsp_dijsktra_with_timesteps_2(self):\\n input_file = \\\"/home/andy/code/python/om_task/data/test_data3.txt\\\"\\n graph_data = process_input_file(input_file)\\n\\n graphs = {}\\n\\n today = datetime.today()\\n t = time(0, 0) # input time value\\n start_time = datetime(today.year, today.month, today.day, t.hour, t.minute)\\n\\n for timestep in graph_data:\\n # print(\\\"Timestep=\\\", timestep)\\n # Create a graph for each timestep\\n graphs[timestep] = Graph()\\n for edge in graph_data.get(timestep):\\n graphs[timestep].add_edge(*edge)\\n\\n for graph in graphs:\\n print(graphs[graph].edges)\\n print(graphs[graph].weights)\\n\\n path = tdsp_dijsktra(graphs, start_time, 'A0', 'B1')\\n\\n print(path)\\n\\n self.assertEqual(['A0', 'B0', 'B1'], path)\",\n \"def main():\\n\\n global time\\n global MAX_ITER\\n global output_dt\\n\\n # ==========================================================================\\n # Initialize\\n # - Returns a dictionary of dictionaries, which are the parameters from the\\n # configuration file (by section) and from the command line (listed as\\n # section 'CommandLine')\\n params = init()\\n\\n # ==========================================================================\\n # Evolution loop\\n\\n prev_write = -1\\n\\n for n_iter in xrange(MAX_ITER):\\n\\n # Exceeded maximum time\\n if time >= tmax:\\n break\\n\\n # Unexpected exit? (e.g. like \\\"touch .dump_restart\\\")\\n # TODO\\n\\n # Write output\\n do_write = False\\n if output_dt > 0:\\n curr_write = int(math.floor(time / output_dt))\\n if curr_write > prev_write:\\n do_write = True\\n prev_write = curr_write\\n if do_write: # to allow for a condition based on step number\\n Grid.write_data(n_iter)\\n\\n # Boundary condition fill\\n Grid.fill_boundary_conditions()\\n\\n # Compute step size\\n dt = compute_time_step()\\n\\n # Evolve a single step\\n Hydro.one_step(dt)\\n\\n # Update time\\n time = time + dt\\n\\n # End evolution loop\\n\\n # ==========================================================================\\n # Finalize\\n\\n # Write final output\\n Grid.write_data(n_iter+1)\\n finalize()\",\n \"def solve_csp(nodes, arcs, max_steps):\\n\\n nodes = list(nodes)\\n print 'nodes:', nodes\\n\\n node_values_dict = dict(zip(nodes, '2'*len(set(nodes))))\\n print 'initial random assignment', node_values_dict\\n indexes = np.arange(len(nodes))\\n\\n graph = {}\\n for arc in arcs:\\n if not arc[0] in graph:\\n graph[arc[0]] = []\\n if not arc[1] in graph:\\n graph[arc[1]] = []\\n graph[arc[0]].append(arc[1])\\n graph[arc[1]].append(arc[0])\\n for i in indexes:\\n if i in graph:\\n continue\\n else:\\n graph[i] = []\\n graph = dict(sorted(graph.items()))\\n print 'graph:', graph\\n\\n domain = [i for i in np.arange(1, 10, 1)]\\n print 'initial domain for each node:', domain\\n\\n superAdjacency ={}\\n for i in np.arange(len(nodes)):\\n superAdjacency[i] = []\\n superAdjacency[i].append(nodes[i])\\n superAdjacency[i].append(node_values_dict[nodes[i]])\\n superAdjacency[i].append(graph[i])\\n superAdjacency[i].append(domain)\\n\\n print 'superAdjacency', superAdjacency\\n\\n def getNodeType(superAdjacency, index):\\n return list(superAdjacency[index])[0]\\n\\n def getCurrentAssignment(superAdjacency, index):\\n return list(superAdjacency[index])[1]\\n\\n def getCurrentAssignmentForList(superAdjacency, indexList):\\n return [int(list(superAdjacency[index])[1]) for index in indexList]\\n\\n def getSolution(superAdjacency):\\n return [int(list(superAdjacency[index])[1]) for index in superAdjacency]\\n\\n def getNeighbours(superAdjacency, index):\\n return list(superAdjacency[index])[2]\\n\\n def getDomain(superAdjacency, index):\\n return list(superAdjacency[index])[3]\\n\\n def updateSuperAdjacency(superAdjacency, nodeType, newValue):\\n updateList =[]\\n for i in superAdjacency:\\n if str(getNodeType(superAdjacency, i)) == nodeType:\\n updateList.append(i)\\n for i in updateList:\\n superAdjacency[i][1] = newValue\\n\\n def isSolution():\\n return graphConstraints(superAdjacency)\\n\\n def graphConstraints(superAdjacency):\\n graphEval = []\\n\\n for index in superAdjacency:\\n neighbours = getNeighbours(superAdjacency, index)\\n nodeType = getNodeType(superAdjacency, index)\\n\\n if nodeType == 'T':\\n graphEval.append(int(str(eval(str(\\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]))\\n elif nodeType == 'C':\\n return 'NA'\\n elif nodeType == 'S':\\n graphEval.append(int(str(eval(str(\\n getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]))\\n elif nodeType == 'H':\\n graphEval.append(int(str(np.sum(\\n getCurrentAssignmentForList(superAdjacency, neighbours)))[0]))\\n if nodeType == 'P':\\n graphEval.append(int(str(np.sum(\\n getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]))\\n\\n currentAssignment = [item[1] for item in superAdjacency.values()]\\n difference = map(sub, currentAssignment, graphEval)\\n\\n if sum(difference) == 0:\\n return True\\n else:\\n return difference\\n\\n def findConflictVariable(superAdjacency, lastUpdateNode):\\n node_conflict_count = {}\\n for node in node_values_dict:\\n node_conflict_count[node] = 0\\n for index in superAdjacency:\\n neighbours = getNeighbours(superAdjacency, index)\\n nodeType = getNodeType(superAdjacency, index)\\n if nodeType == 'T':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != \\\\\\n int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n elif nodeType == 'S':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n elif nodeType == 'H':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n if nodeType == 'P':\\n try:\\n if getCurrentAssignment(superAdjacency, index) != int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0]):\\n node_conflict_count[nodeType] = node_conflict_count[nodeType] + 1\\n except:\\n continue\\n choices = [k for k, v in node_conflict_count.items() if v > 0]\\n if len(choices) > 0:\\n updateNode = random.choice(choices)\\n\\n if updateNode == lastUpdateNode:\\n choices.pop(choices.index(updateNode))\\n try:\\n lastUpdateNode = random.choice(choices)\\n return lastUpdateNode, lastUpdateNode\\n except:\\n return lastUpdateNode, lastUpdateNode\\n else:\\n lastUpdateNode = updateNode\\n return updateNode, lastUpdateNode\\n else:\\n return 'NA', 'NA'\\n\\n\\n\\n def valueForConflictedVariable(superAdjacency, var):\\n for index in superAdjacency:\\n nodeType = getNodeType(superAdjacency, index)\\n neighbours = getNeighbours(superAdjacency, index)\\n if not neighbours:\\n continue\\n elif str(nodeType) == str(var):\\n domain = getDomain(superAdjacency, index)\\n\\n choice = random.choice(domain)\\n if nodeType == 'T':\\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[0])\\n elif nodeType == 'S':\\n choice = int(str(eval(str(getCurrentAssignmentForList(superAdjacency, neighbours)).replace(',', '*'))[0])[::-1][0])\\n elif nodeType == 'H':\\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[0])\\n if nodeType == 'P':\\n choice = int(str(np.sum(getCurrentAssignmentForList(superAdjacency, neighbours)))[::-1][0])\\n\\n choice = int(choice)\\n if choice % 2 == 0:\\n return choice\\n else:\\n return choice\\n\\n def min_conflicts(nodes, arcs, max_steps):\\n lastUpdateNode = ''\\n for i in range(max_steps):\\n if isSolution() == True:\\n return\\n var, lastUpdateNode = findConflictVariable(superAdjacency, lastUpdateNode)\\n if var != 'NA':\\n value = valueForConflictedVariable(superAdjacency, var)\\n updateSuperAdjacency(superAdjacency, var, value)\\n node_values_dict[var] = value\\n else:\\n pass\\n\\n return\\n\\n min_conflicts(nodes, arcs, max_steps)\\n node_values = getSolution(superAdjacency)\\n return node_values\",\n \"def rhs(states, t, parameters, values=None):\\n # Imports\\n import numpy as np\\n import math\\n\\n # Assign states\\n assert(len(states) == 6)\\n vlv, vrv, v1s, v2s, v1p, v2p = states\\n\\n # Assign parameters\\n assert(len(parameters) == 38)\\n restVlvd=parameters[0]; restVlvs=parameters[1]; restVrvd=parameters[2];\\\\\\n restVrvs=parameters[3]; Emaxlv=parameters[4]; Emaxrv=parameters[5];\\\\\\n Eminlv=parameters[6]; Eminrv=parameters[7]; R1_s=parameters[16];\\\\\\n Rao_s=parameters[18]; Rmit=parameters[19]; c1s=parameters[20];\\\\\\n c2s=parameters[21]; pext_s=parameters[22]; rest_v1s=parameters[23];\\\\\\n rest_v2s=parameters[24]; R1_p=parameters[25]; Rao_p=parameters[27];\\\\\\n Rtric=parameters[28]; c1p=parameters[29]; c2p=parameters[30];\\\\\\n p_epi=parameters[31]; pext_p=parameters[32]; rest_v1p=parameters[33];\\\\\\n rest_v2p=parameters[34]; bcl=parameters[35];\\\\\\n twitchperiod=parameters[37]\\n\\n # Init return args\\n if values is None:\\n values = np.zeros((6,), dtype=np.float_)\\n else:\\n assert isinstance(values, np.ndarray) and values.shape == (6,)\\n\\n # Expressions for the Time varying elastance component\\n t_lv = math.fmod(t, bcl)\\n yv = (0.5 - 0.5*math.cos(2.0*math.pi*t_lv/twitchperiod) if t_lv <\\\\\\n twitchperiod else 0)\\n Elv = Eminlv + (Emaxlv - Eminlv)*yv\\n restVlv = restVlvs + (1 - yv)*(restVlvd - restVlvs)\\n plv = p_epi + (-restVlv + vlv)*Elv\\n Erv = Eminrv + (Emaxrv - Eminrv)*yv\\n restVrv = restVrvs + (1 - yv)*(restVrvd - restVrvs)\\n prv = p_epi + (-restVrv + vrv)*Erv\\n\\n # Expressions for the Pressures and flows component\\n p1s = (-pext_s + (-rest_v1s + v1s)/c1s if v1s > 0 else -pext_s -\\\\\\n rest_v1s/c1s)\\n p2s = (-pext_s + (-rest_v2s + v2s)/c2s if v2s > 0 else -pext_s -\\\\\\n rest_v2s/c2s)\\n p1p = (-pext_p + (-rest_v1p + v1p)/c1p if v1p > 0 else -pext_p -\\\\\\n rest_v1p/c1p)\\n p2p = (-pext_p + (-rest_v2p + v2p)/c2p if v2p > 0 else -pext_p -\\\\\\n rest_v2p/c2p)\\n qart_s = ((-p1s + plv)/Rao_s if plv > p1s else 0)\\n q_mit = ((-plv + p2p)/Rmit if p2p > plv else 0)\\n q1_s = (-p2s + p1s)/R1_s\\n qart_p = ((-p1p + prv)/Rao_p if prv > p1p else 0)\\n q_tric = ((-prv + p2s)/Rtric if p2s > prv else 0)\\n q1_p = (-p2p + p1p)/R1_p\\n\\n # Expressions for the Ventricular volumes component\\n values[0] = -qart_s + q_mit\\n values[1] = -qart_p + q_tric\\n\\n # Expressions for the Systemic volumes component\\n values[2] = -q1_s + qart_s\\n values[3] = -q_tric + q1_s\\n\\n # Expressions for the Pulmonary volumes component\\n values[4] = -q1_p + qart_p\\n values[5] = -q_mit + q1_p\\n\\n # Return results\\n return values\",\n \"def forward_backward(observations):\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE GOES HERE\\n #\\n # observations = [(4, 3), (4, 2), (3, 2), (4, 0), (2, 0), (2, 0), (3, 2), \\n # (4, 2), (2, 3), (3, 5)]\\n num_time_steps = len(observations)\\n forward_messages = [None] * num_time_steps\\n forward_messages[0] = prior_matrix\\n # # # TODO: Compute the forward messages\\n for i,x_i in enumerate(observations):\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n pi_0 = forward_messages[i]\\n # print(len(B[:obs_index]))\\n weights = np.multiply(pi_0, B[:,obs_index])\\n # x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\\n else:\\n weights = forward_messages[i]\\n # print(weights)\\n x = sum([A[j,:]* w_i.T for j,w_i in enumerate(weights)])\\n if i+1 < len(forward_messages):\\n forward_messages[i+1] = x#normalize(x)\\n # break\\n\\n ## forward messages as dictionary\\n # for_dict = [None]*num_time_steps\\n # for j,f in enumerate(forward_messages):\\n # x = Distribution()\\n # for i,x_i in enumerate(f):\\n # if x_i == 0:\\n # continue\\n # # print(i,x_i)\\n # x[all_possible_hidden_states[i]] = x_i\\n # for_dict[j] = x.renormalize()\\n # print(for_dict[3])\\n\\n # print('--------------\\\\n-----------------\\\\n')\\n\\n\\n backward_messages = [None] * num_time_steps\\n # backward_messages[-1] = [1]*len(prior_matrix)\\n message = np.ones(len(all_possible_hidden_states), dtype=np.float64)\\n backward_messages[-1] = message/len(all_possible_hidden_states)\\n \\n# ****\\n ## Backwards messages\\n for i,x_i in enumerate(reversed(observations)):\\n # print(x_i)\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n pi = backward_messages[-1-i]\\n weights = np.multiply(pi, B[:,obs_index])\\n else:\\n weights = backward_messages[-1-i]\\n # print(i)\\n x = sum([A[:,j]*w_i for j,w_i in enumerate(weights)])\\n\\n if i+1 < len(backward_messages):\\n backward_messages[-2-i] = x#normalize(x)\\n\\n ## backward messages as dictionary\\n # back_dict = [None]*num_time_steps\\n # for j,b in enumerate(backward_messages):\\n # x = Distribution()\\n # if b == None:\\n # continue\\n # for i,x_i in enumerate(b):\\n # if x_i == 0 or x_i==None:\\n # continue\\n # # print(i,x_i)\\n # x[all_possible_hidden_states[i]] = x_i\\n # back_dict[j] = x.renormalize()\\n \\n # print(back_dict[0])\\n # print(A[:10,:10])\\n # print('\\\\n-----------------\\\\n', B[:10,:10])\\n\\n # print(backward_messages[2])\\n # backward_messages[0] = forward_messages[0]\\n # # ## marginals as matrix\\n marginals = [None] * num_time_steps \\n for i,x_i in enumerate(observations):\\n if x_i:\\n obs_index = obs_state_index_map[x_i]\\n marginals[i] = np.multiply(np.multiply(backward_messages[i],\\n forward_messages[i]),\\n B[:,obs_index])\\n else:\\n marginals[i] = np.multiply(backward_messages[i],forward_messages[i])\\n # if i == 0:\\n # marginals[i] = np.multiply(backward_messages[i], B[:,obs_index])\\n # elif i == len(observations)-1:\\n # marginals[i] = np.multiply(forward_messages[i], B[:,obs_index])\\n # else:\\n\\n ## marginals as dictionary\\n marg_dict = [None]*num_time_steps\\n for j,m in enumerate(marginals):\\n x = Distribution()\\n for i,x_i in enumerate(m):\\n if x_i == 0 or x_i==None:\\n continue\\n x[all_possible_hidden_states[i]] = x_i\\n marg_dict[j] = x.renormalize()\\n # print(marginals[i])\\n # print(A[:10, :10], '\\\\n')\\n # print(B[:10, :10], '\\\\n')\\n # print(marg_dict)\\n return marg_dict\",\n \"def solve(self,init=None,g_init=1e-3,g_step=5e-3,g_fin=None,evol=False,movingGrid=False):\\n if(g_fin==None): g_fin=self.g\\n #Check if all signs are correct\\n if(g_fin<0):\\n if(g_step>0): g_step*=-1.\\n if(g_init>0): g_init*=-1.\\n else:\\n if(g_step<0): g_step*=-1.\\n if(g_init<0): g_step*=-1.\\n\\n #If no initial distribution is given, start from the BCS ground state\\n if(init==None): init=[1 if i<self.N else 0 for i in range(self.n)]\\n var_init=np.array([-2.*init[i]-g_init/(1-2.*init[i])*np.sum([self.XXZ.Z(j,i)*(init[j]-init[i]) for j in range(self.n) if j!=i]) for i in range(self.n)])\\n n_step=int((g_fin-g_init)/g_step)\\n g=g_init\\n\\n #Define necessary variables if evol or movingGrid=True\\n if(evol or movingGrid):\\n var_evol=np.zeros([n_step,self.n])\\n g_evol=np.zeros(n_step)\\n if(movingGrid):\\n rap_evol = np.zeros([n_step,self.N],dtype=complex)\\n rap_evol[0] = [self.levels[i] for i in range(self.n) if init[i]!=0 ]\\n rap=np.array([self.levels[i]+0.5*np.abs(np.random.rand()) for i in range(self.n) if init[i]!=0])\\n grid=np.zeros(self.N+1,dtype=complex)\\n grid[0]=1e3\\n for k in range(self.N): grid[k+1]=rap[k]\\n n_grid=n_step/20 #Calculates rapidities at 20 intermediate steps\\n\\n #Gradually increase the coupling constant g and solve iteratively at each step starting from the Taylor approximation from the previous step\\n for i in range(n_step):\\n var_new=self.newtonraphson(g,var_init)\\n der=self.get_derivative(var_new,g)\\n #var_init=self.taylor_expansion(g,g_step,var_new)\\n var_init = var_new+g_step*der\\n g+=g_step\\n #print g\\n\\n #Save variables at current step if evol =True\\n if(evol or movingGrid):\\n var_evol[i]=var_init\\n g_evol[i]=g\\n if(movingGrid and i%n_grid==0 and i!=0):\\n #Method for obtaining the rapidities starting from the set of Lambda_i\\n rf=RootFinder(self.XXZ,var_evol[i]/g_evol[i],g_evol[i],self.N)\\n u=rf.solveForU(grid)\\n lm=LaguerreMethod(grid,u)\\n rap=lm.laguerre()\\n rap_evol[i]=np.sort(lm.laguerre())\\n for k in range(self.N): grid[k+1]=rap[k]\\n grid[0]=10*max(rap)\\n elif(movingGrid and i!=0):\\n rf=RootFinder(self.XXZ,var_evol[i]/g_evol[i],g_evol[i],self.N)\\n u=rf.solveForU(grid)\\n lm=LaguerreMethod(grid,u)\\n rap_evol[i]=np.sort(lm.laguerre())\\n \\n \\n #One final iterative solution at g=g_fin\\n self.solution=self.newtonraphson(g_fin,var_init)\\n #Calculate the occupation numbers\\n self.occupation=0.5*(-1.-self.solution+g_fin*self.get_derivative(self.solution,g_fin))\\n\\n #One final calculation of the rapidities\\n if(movingGrid):\\n rf=RootFinder(self.XXZ,self.solution/g_fin,g_fin,self.N)\\n u=rf.solveForU(grid)\\n lm=LaguerreMethod(grid,u)\\n rap=lm.laguerre()\\n self.rapidities=rap\\n\\n if movingGrid: return [g_evol,var_evol,rap_evol]\\n if evol: return [g_evol,var_evol]\\n return self.solution\",\n \"def one_forward_pass(t,states,init_vals,traces,delta,unit_cube,edges,P):\\n \\n next_vals = -1e100 * np.ones(init_vals.shape)\\n \\n S,T = states.shape\\n \\n for i in range(len(states)):\\n for j in range(len(unit_cube)):\\n# print('State, unitcube subtracted',s,c)\\n if (states[i] - unit_cube[j]).min() >= 0:\\n \\n state_idx = edges[i,j]\\n \\n tau = np.where(unit_cube[j] == 0)\\n \\n if len(tau[0]) == 0:\\n next_vals[i] = log_sum_exp([next_vals[i],\\\\\\n init_vals[state_idx]+T*np.log(delta)])\\n \\n else:\\n \\n flag = 0\\n temp = []\\n for k in tau[0]:\\n if (t-states[i,k] >=0 and t-states[i,k]< len(traces[k])):\\n temp.append(traces[k][t-states[i][k]])\\n else:\\n flag = 1\\n break\\n\\n if (len(set(temp)) == 1 and flag == 0):\\n bit = temp[0]\\n next_vals[i] = log_sum_exp([next_vals[i],init_vals[state_idx]\\\\\\n +(T-len(temp)) * np.log(delta)\\\\\\n + np.log(1-delta) * (len(temp))\\n + np.log(P[t,bit]+1e-100)])\\n \\n return next_vals\",\n \"def _generate_hourly_seasonality(\\n self,\\n time_range: np.ndarray,\\n hourly_seasonality_params: List[Tuple[float, float]],\\n ) -> np.ndarray:\\n\\n return sum(\\n [\\n alpha * np.cos(2 * np.pi * (i + 1) * time_range / 24)\\n + beta * np.sin(2 * np.pi * (i + 1) * time_range / 24)\\n for i, (alpha, beta) in enumerate(hourly_seasonality_params)\\n ]\\n )\",\n \"def communityGraph(graph):\\n\\n lapgr = nx.laplacian_matrix(graph)\\n\\n # Get the eigenvalues and eigenvectors of the Laplacian matrix\\n evals, evec = np.linalg.eigh(lapgr.todense())\\n\\n fiedler = evec[1]\\n results = []\\n ## \\\"Fiedler\\\", fiedler\\n median = np.median(fiedler, axis=1) # median of the second eigenvalue\\n for i in range(0, fiedler.size): # divide the graph nodes into two\\n if(fiedler[0, i] < median):\\n results.append(0)\\n else:\\n results.append(1)\\n return results, evals, evec\",\n \"def execute_algorithm_with_params(params):\\n\\n # unpack the algorithm and its parameters\\n algorithm, algorithm_name, problem, show_solution_plot, solution_plot_save_path, calculate_times, calculate_value_evolution = params\\n\\n start_time = time.time()\\n value_evolution = None\\n times_dict = None\\n if calculate_value_evolution:\\n if algorithm == evolutionary.solve_problem:\\n if calculate_times:\\n solution, times_dict, value_evolution = algorithm(problem, calculate_times=calculate_times, return_population_fitness_per_generation=calculate_value_evolution)\\n else:\\n solution, value_evolution = algorithm(problem, calculate_times=calculate_times, return_population_fitness_per_generation=calculate_value_evolution)\\n else:\\n if calculate_times:\\n solution, times_dict, value_evolution = algorithm(problem, calculate_times=calculate_times, return_value_evolution=calculate_value_evolution)\\n else:\\n solution, value_evolution = algorithm(problem, calculate_times=calculate_times, return_value_evolution=calculate_value_evolution)\\n elif calculate_times:\\n solution, times_dict = algorithm(problem, calculate_times=calculate_times)\\n else:\\n solution = algorithm(problem)\\n elapsed_time = get_time_since(start_time)\\n\\n if solution and (show_solution_plot or solution_plot_save_path):\\n solution.visualize(show_plot=show_solution_plot, save_path=solution_plot_save_path)\\n\\n return solution, solution.value, value_evolution, elapsed_time, times_dict\",\n \"def timeEvolve(state, Hamiltonian, t):\\n state_t = expm(1j * Hamiltonian * t).dot(state)\\n return state_t\",\n \"def generate_aima_grid():\\n\\n # https://stats.stackexchange.com/questions/339592/how-to-get-p-and-r-values-for-a-markov-decision-process-grid-world-problem\\n\\n actions_map = {0: '^', 1: 'V', 2: '<', 3: '>'}\\n\\n transitions = np.zeros((4, 12, 12)) # (A, S, S)\\n transitions[0] = [[0.9, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.8, 0., 0., 0., 0.2, 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.8, 0., 0., 0.1, 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.1, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.1],\\n [0., 0., 0., 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.1]]\\n\\n transitions[1] = [[0.1, 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0.8, 0.1, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.2, 0., 0., 0., 0.8, 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0.1, 0., 0., 0.8, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0.1, 0., 0., 0.8, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.9, 0.1, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.8, 0.1],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.1, 0.9]]\\n\\n transitions[2] = [[0.9, 0., 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\\n [0.8, 0.2, 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.8, 0.1, 0., 0., 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\\n [0., 0.1, 0., 0., 0.8, 0., 0., 0., 0., 0.1, 0., 0.],\\n [0., 0., 0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.9, 0., 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0.8, 0.2, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0.8, 0.1]]\\n\\n transitions[3] = [[0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0.2, 0.8, 0., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0., 0., 0.1, 0.8, 0., 0., 0.1, 0., 0., 0., 0., 0.],\\n [0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],\\n [0.1, 0., 0., 0., 0.8, 0., 0., 0., 0.1, 0., 0., 0.],\\n [0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0., 0.],\\n [0., 0., 0.1, 0., 0., 0., 0., 0.8, 0., 0., 0.1, 0.],\\n [0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.],\\n [0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8, 0., 0.],\\n [0., 0., 0., 0., 0., 0., 0., 0., 0., 0.2, 0.8, 0.],\\n [0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.1, 0.8],\\n [0., 0., 0., 0., 0., 0., 0., 0.1, 0., 0., 0., 0.9]]\\n\\n rewards = np.asarray((-0.02, -0.02, -0.02, 1, -0.02, -0.02, -0.02, -1, -0.02, -0.02, -0.02, -0.02))\\n\\n print('\\\\n***** aima grid world *****\\\\n')\\n print('Transition matrix:', transitions.shape)\\n print('Reward matrix:', rewards.shape)\\n\\n return transitions, rewards\",\n \"def jmt(start, end, time):\\n # the first 3 coefficients are from s(t=0) derivatives\\n c_1, c_2, c_3 = start[0], start[1], start[2] / 2\\n\\n matrix_a = np.array([\\n [time**3, time**4, time**5],\\n [3 * time**2, 4 * time**3, 5 * time**4],\\n [6 * time, 12 * time**2, 20 * time**3]\\n ])\\n\\n vector_b = np.array(\\n [end[0] - (start[0] + start[1] * time + 0.5 * start[2] * time**2),\\n end[1] - (start[1] + start[2] * time),\\n end[2] - start[2]])\\n\\n x_r = inv(matrix_a).dot(vector_b) # solve AX = B system\\n\\n c_4, c_5, c_6 = x_r[0], x_r[1], x_r[2]\\n\\n return [c_1, c_2, c_3, c_4, c_5, c_6]\",\n \"def calc_harmony_dynamics(self):\\n Hg = self.B + self.inpS + self.W.matmul(self.state)\\n #Hg += self.bowl.calc_bowl_gradient(self.state)\\n return Hg\",\n \"def calculate(self) :\\n #self.graph\\n self.val_i = 0\\n while (len(self.undefined_vertices) > 0) :\\n cond = True\\n while cond:\\n cond = False\\n for node in self.undefined_vertices:\\n if self.condition_satisfied(node, self.val_i) :\\n cond = True\\n self.undefined_vertices.remove(node)\\n self.val_l[node] = self.val_i\\n self.val_c[node] = self.val_m\\n self.val_m += 1\\n for node in self.undefined_vertices:\\n if self.val_i not in [self.val_l[n] for n in\\n self.graph.next_nodes(node)]:\\n self.undefined_vertices.remove(node)\\n self.val_l[node] = self.infinity\\n self.val_c[node] = 0\\n self.val_i += 1\\n self.graph.save_graph(\\\"check\\\")\\n self.save(\\\"this.value\\\")\\n return self.graph.to_dictionary(), self.val_l, self.val_c\",\n \"def return_list_of_states(graphs_list,\\n times, pulses, evol='xy', verbose=0):\\n all_states = []\\n for G in tqdm(graphs_list, disable=verbose==0):\\n all_states.append(return_evolution(G, times, pulses, evol))\\n return all_states\",\n \"def timlinucb_parallel_t(\\n df_edges,\\n df_feats,\\n times,\\n nodes,\\n num_seeds=5,\\n sigma=4,\\n c=0.1,\\n epsilon=0.4,\\n num_repeats_oim=10,\\n num_repeats_oim_reward=10,\\n style=\\\"additive\\\",\\n process_id=1,\\n persist=False,\\n):\\n if \\\"tim\\\" not in os.listdir():\\n logger_tlu.warning(\\\"Couldn't find TIM in the program directory\\\")\\n return False\\n\\n tim_name = f\\\"tim_tlu_{process_id}\\\"\\n dir_name = f\\\"{tim_name}_dir\\\"\\n logger_tlu.debug(f\\\"Name of the new TIM file: {tim_name}\\\")\\n shutil.copyfile(\\\"tim\\\", tim_name)\\n\\n # Making the new tim file executable\\n st = os.stat(tim_name)\\n os.chmod(tim_name, st.st_mode | stat.S_IEXEC)\\n\\n results = []\\n\\n # For persistent parameters - making the b and M matrices\\n if persist:\\n b = np.zeros((df_feats.shape[1], 1))\\n m_inv = np.eye(df_feats.shape[1], df_feats.shape[1])\\n else:\\n b = None\\n m_inv = None\\n\\n for t in times:\\n if style == \\\"additive\\\":\\n df_t = df_edges[df_edges[\\\"day\\\"] <= t].sort_values(\\\"source\\\").reset_index()\\n elif style == \\\"dynamic\\\":\\n df_t = df_edges[df_edges[\\\"day\\\"] == t].sort_values(\\\"source\\\").reset_index()\\n\\n df_feats_t = df_t[\\\"index\\\"].apply(lambda x: df_feats.loc[x])\\n\\n result_oim = oim_node2vec(\\n df_t,\\n df_feats_t,\\n nodes,\\n num_inf=num_seeds,\\n sigma=sigma,\\n c=c,\\n epsilon=epsilon,\\n num_repeats=num_repeats_oim,\\n num_repeats_reward=num_repeats_oim_reward,\\n oracle=partial(tim_parallel, tim_file=tim_name, temp_dir=dir_name),\\n hide_tqdm=True,\\n persist=persist,\\n m_inv=m_inv,\\n b=b,\\n )\\n\\n result_oim[\\\"time\\\"] = t\\n\\n if persist:\\n m_inv = result_oim.pop(\\\"m_inv\\\")\\n b = result_oim.pop(\\\"b\\\")\\n\\n results.append(result_oim)\\n\\n logger_tlu.debug(\\n f\\\"Removing the new TIM files {tim_name} and the temp directories {dir_name}\\\"\\n )\\n os.remove(tim_name)\\n shutil.rmtree(dir_name)\\n\\n return pd.DataFrame(results)\",\n \"def find_min_hamiltonian_path(G,weights,probs_instead_of_weights=False):\\n\\n # Create a new model\\n m = Model(\\\"hamiltonian_cycle\\\")\\n \\n # Create variables\\n x_vars = {}\\n u_vars = {}\\n for var1 in permute(G.vertices()):\\n for var2 in permute(G.vertices()):\\n if var1 != var2:\\n x_vars[(var1,var2)] = m.addVar(vtype='B', name=\\\"x_\\\"+str(var1)+'_'+str(var2))\\n u_vars[var1] = m.addVar(vtype=GRB.INTEGER, name=\\\"u_\\\"+str(var1))\\n m.update()\\n \\n for var in G.vertices():\\n if var != START_NODE:\\n cur_incoming = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[1] == var)])\\n #print(cur_incoming)\\n m.addConstr(cur_incoming,GRB.EQUAL,1.0)\\n \\n if var != END_NODE:\\n cur_outgoing = LinExpr([(1.0,v) for k,v in x_vars.items() if (k[0] == var)])\\n #print(cur_outgoing)\\n m.addConstr(cur_outgoing,GRB.EQUAL,1.0)\\n \\n for var1 in G.vertices():\\n for var2 in G.vertices():\\n if var1 != var2:\\n c = LinExpr([(1.0,u_vars[var1]),(-1.0,u_vars[var2]),(G.num_vertices(),x_vars[(var1,var2)])])\\n #print(c)\\n m.addConstr(c,GRB.LESS_EQUAL,G.num_vertices()-1)\\n \\n # Set objective\\n #try:\\n edge_weights = permute(G.get_edge_weights(weights))\\n if probs_instead_of_weights:\\n all_probs = []\\n for v in G.vertices():\\n if v != END_NODE:\\n batch_scores = [(e,w) for e,w in edge_weights if e[0] == v]\\n S = logsumexp([x[1] for x in batch_scores])\\n batch_scores = [(e,np.exp(w-S)) for e,w in batch_scores]\\n all_probs.extend(batch_scores)\\n edge_weights = all_probs\\n objective = LinExpr([(weight,x_vars[edge]) for edge,weight in edge_weights])\\n #except TypeError:\\n # return None\\n \\n m.setObjective(objective,GRB.MINIMIZE)\\n m.update()\\n code = m.optimize()\\n \\n try:\\n return [k for k,v in x_vars.items() if v.x > 0.98]\\n except GurobiError:\\n return None\",\n \"def _get_full_graph(self):\",\n \"def solver(u_init, eta_0, eta, eta_lin, T, H, L_lhs, L_rhs, alpha, gamma, B, D, C, ftol = 1e-3, max_iter = 5000, verbose = 0, nnls_max_iter=30):\\n\\n # Raise('NotImplementedError: only adjusted the arguments.')\\n #Need to incorporate L_lhs into stacked and appropriate w_lin updates, u_update and eta_lin increments\\n #precompute the expensive operation:\\n lin_penalties = 1/np.sqrt(2*eta_lin)\\n eta_T_H_L_stacked = scipy.sparse.vstack([T.multiply(1/np.sqrt(2*eta_0))] + [H[i].multiply(1/np.sqrt(2*eta[i])) for i in range(len(H))] + [L_lhs.multiply(lin_penalties[:,None])])\\n #!!!!\\n# premultiplied_lhs = eta_T_H_stacked.T.dot(eta_T_H_stacked).toarray()\\n #!!!!\\n u_prev = u_init + 1\\n u = u_init\\n count = 0\\n obj_history = []\\n relaxed_obj_history = [-1, 0.1] #just two initial values to enter the loop\\n while np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2]) > ftol and count < max_iter:#np.linalg.norm(u - u_prev, np.inf) > 1e-3 and count < max_iter: #Maybe all of them stop changing\\n start = time.time()\\n \\n u_prev = np.copy(u)\\n w_0 = w_0_update(eta_0, u, T, alpha, B) \\n w = w_update(u, H, gamma, D, C) \\n w_lin = w_lin_update(u, L_lhs, L_rhs)\\n# u = u_update(eta_0, eta, w_0, w, eta_T_H_stacked, nnls_max_iter=50)\\n #!!!!\\n # u = u_update(eta_0, eta, w_0, w, eta_T_H_L_stacked, nnls_max_iter=30)\\n u = u_update(eta_0, eta, eta_lin, w_0, w, w_lin, eta_T_H_L_stacked, premultiplied_lhs = None, nnls_max_iter=nnls_max_iter)\\n #!!!!\\n count += 1 \\n if count == 10:\\n u_inf = np.copy(u)\\n w_0_inf = w_0[:]\\n w_inf = w[:]\\n w_lin_inf = w_lin[:]\\n if count > 10 and np.abs(cur_obj) > 1e+15: #HANDLE THIS BETTER!!!\\n print('INFINITY! RETURNING u at the 10-th iteration to enter the feasibility loop')\\n return u_inf, w_0_inf, w_inf, w_lin_inf, obj_history, relaxed_obj_history\\n \\n cur_obj = obj_u_opt_N_fixed(u, T, alpha, B)\\n obj_history.append(cur_obj)\\n cur_relaxed_obj = relaxed_obj_u_opt_N_fixed(u, w_0, w, w_lin, eta_0, eta, eta_lin, T, H, L_lhs, alpha, B)\\n # relaxed_obj_u_opt_N_fixed(u, w_0, w, eta_0, eta, T, H, alpha, B)\\n relaxed_obj_history.append(cur_relaxed_obj) \\n \\n stop = time.time()\\n duration = stop-start\\n \\n if count%1 == 0 and verbose: \\n stopping_criterion = np.abs((relaxed_obj_history[-2] - relaxed_obj_history[-1])/relaxed_obj_history[-2])\\n print(' iter = {}, stopping criterion:{}, OBJ {}'.format(count, stopping_criterion, cur_obj))\\n print(' This iteration took: {}'.format(duration))\\n return u, w_0, w, w_lin, obj_history, relaxed_obj_history\",\n \"def theta_v_time():\\n pass\",\n \"def hessian_cost(self, joint_angles: dict, ee_goals) -> np.ndarray:\\n kinematic_map = self.kinematic_map[\\\"p0\\\"] # get map to all nodes from root\\n end_effector_nodes = ee_goals.keys()\\n H = np.zeros((self.n, self.n))\\n for (\\n ee\\n ) in end_effector_nodes: # iterate through end-effector nodes, assumes sorted\\n ee_path = kinematic_map[ee][\\n 1:\\n ] # [:-1] # no last node, only phys. joint locations\\n t_ee = self.get_pose(joint_angles, ee).trans\\n dg_ee_x = t_ee[0] - ee_goals[ee].trans[0]\\n dg_ee_y = t_ee[1] - ee_goals[ee].trans[1]\\n for (pdx, joint_p) in enumerate(ee_path): # algorithm fills Hess per column\\n p_idx = int(joint_p[1:]) - 1\\n sin_p_term = 0.0\\n cos_p_term = 0.0\\n for jdx in range(pdx, len(ee_path)):\\n node_jdx = ee_path[jdx]\\n theta_jdx = sum([joint_angles[key] for key in ee_path[0 : jdx + 1]])\\n sin_p_term += self.a[node_jdx] * np.sin(theta_jdx)\\n cos_p_term += self.a[node_jdx] * np.cos(theta_jdx)\\n\\n for (qdx, joint_q) in enumerate(\\n ee_path[pdx:]\\n ): # TODO: check if starting from pdx works\\n qdx = qdx + pdx\\n q_idx = int(joint_q[1:]) - 1\\n sin_q_term = 0.0\\n cos_q_term = 0.0\\n for kdx in range(qdx, len(ee_path)):\\n node_kdx = ee_path[kdx]\\n theta_kdx = sum(\\n [joint_angles[key] for key in ee_path[0 : kdx + 1]]\\n )\\n sin_q_term += self.a[node_kdx] * np.sin(theta_kdx)\\n cos_q_term += self.a[node_kdx] * np.cos(theta_kdx)\\n\\n # assert(q_idx >= p_idx)\\n H[p_idx, q_idx] += (\\n 2.0 * sin_q_term * sin_p_term\\n - 2.0 * dg_ee_x * cos_q_term\\n + 2.0 * cos_p_term * cos_q_term\\n - 2.0 * dg_ee_y * sin_q_term\\n )\\n\\n return H + H.T - np.diag(np.diag(H))\",\n \"def linearize_and_solve(g):\\n\\n # initialize the sparse H and the vector b\\n H = np.zeros((len(g.x), len(g.x)), dtype='float')\\n b = np.zeros(len(g.x), dtype='float')\\n\\n # set flag to fix gauge\\n needToAddPrior = True\\n Fx = 0\\n\\n # compute the addend term to H and b for each of our constraints\\n print('linearize and build system')\\n\\n for edge in g.edges:\\n\\n # pose-pose constraint\\n if edge.Type == 'P':\\n\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node state for the current edge\\n x_i = g.x[fromIdx:fromIdx + 3]\\n x_j = g.x[toIdx:toIdx + 3]\\n\\n # (TODO) compute the error and the Jacobians\\n e, A, B = linearize_pose_pose_constraint(\\n x_i, x_j, edge.measurement)\\n\\n # # (TODO) compute the terms\\n b_i = e.transpose() @ edge.information @ A\\n b_j = e.transpose() @ edge.information @ B\\n H_ii = A.transpose() @ edge.information @ A\\n H_ij = A.transpose() @ edge.information @ B\\n H_jj = B.transpose() @ edge.information @ B\\n\\n # (TODO) add the terms to H matrix and b\\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\\n H[toIdx:toIdx + 3, toIdx:toIdx + 3] += H_jj\\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 3] += H_ij\\n H[toIdx:toIdx + 3, fromIdx:fromIdx + 3, ] += H_ij.transpose()\\n b[fromIdx:fromIdx + 3] += b_i[0, :]\\n b[toIdx:toIdx + 3] += b_j[0, :]\\n\\n # Add the prior for one pose of this edge\\n # This fixes one node to remain at its current location\\n if needToAddPrior:\\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx +\\n 3] = H[fromIdx:fromIdx + 3,\\n fromIdx:fromIdx + 3] + 1000 * np.eye(3)\\n needToAddPrior = False\\n\\n # pose-pose constraint\\n elif edge.Type == 'L':\\n print(\\\"you shouldn't be here...\\\")\\n # compute idx for nodes using lookup table\\n fromIdx = g.lut[edge.fromNode]\\n toIdx = g.lut[edge.toNode]\\n\\n # get node states for the current edge\\n x = g.x[fromIdx:fromIdx + 3]\\n l = g.x[toIdx:toIdx + 2]\\n\\n # (TODO) compute the error and the Jacobians\\n e, A, B = linearize_pose_landmark_constraint(\\n x, l, edge.measurement)\\n\\n # (TODO) compute the terms\\n b_i = e.transpose() @ edge.information @ A\\n b_j = e.transpose() @ edge.information @ B\\n H_ii = A.transpose() @ edge.information @ A\\n H_ij = A.transpose() @ edge.information @ B\\n H_jj = B.transpose() @ edge.information @ B\\n\\n # (TODO )add the terms to H matrix and b\\n H[fromIdx:fromIdx + 3, fromIdx:fromIdx + 3] += H_ii\\n H[toIdx:toIdx + 2, toIdx:toIdx + 2] += H_jj\\n H[fromIdx:fromIdx + 3, toIdx:toIdx + 2] += H_ij\\n H[toIdx:toIdx + 2, fromIdx:fromIdx + 3, ] += H_ij.transpose()\\n b[fromIdx:fromIdx + 3] = b_i\\n b[toIdx:toIdx + 2] = b_j\\n # solve system\\n dx = np.linalg.solve(H, b)\\n\\n return dx\",\n \"def floydWarshall(graph):\\n \\\"\\\"\\\" initializing the solution matrix same as input graph matrix\\n OR we can say that the initial values of shortest distances\\n are based on shortest paths considerting no \\n intermedidate vertices \\\"\\\"\\\"\\n V = len(graph[0])\\n dist = [[elem for elem in line] for line in graph]\\n \\n \\\"\\\"\\\" Add all vertices one by one to the set of intermediate\\n vertices.\\n ---> Before start of a iteration, we have shortest distances\\n between all pairs of vertices such that the shortest\\n distances consider only the vertices in set \\n {0, 1, 2, .. k-1} as intermediate vertices.\\n ----> After the end of a iteration, vertex no. k is\\n added to the set of intermediate vertices and the \\n set becomes {0, 1, 2, .. k}\\n \\\"\\\"\\\"\\n for k in range(V):\\n \\n # pick all vertices as source one by one\\n for i in range(V):\\n \\n # Pick all vertices as destination for the\\n # above picked source\\n for j in range(V):\\n \\n # If vertex k is on the shortest path from \\n # i to j, then update the value of dist[i][j]\\n dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])\\n\\n for line in dist:\\n print line\\n\\n return dist\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6062276","0.6009414","0.5854938","0.55636716","0.5466281","0.54142034","0.54097426","0.53703797","0.5366806","0.5362178","0.53470725","0.5342757","0.5329308","0.52993786","0.5255946","0.52543396","0.5253646","0.5226769","0.5217197","0.5200583","0.51922","0.5166258","0.5165572","0.5165006","0.5151935","0.51509225","0.51451945","0.51360124","0.5131971","0.5127064","0.51263916","0.5123485","0.511295","0.5106237","0.50917697","0.5081962","0.50703937","0.50696886","0.5068241","0.5058643","0.50539947","0.5050564","0.50463825","0.50453347","0.50405943","0.50344425","0.5034295","0.5027275","0.5021011","0.50156724","0.50099474","0.50099474","0.50082874","0.5004102","0.50038236","0.5002994","0.5002356","0.5001764","0.49874848","0.49867412","0.49842262","0.49833456","0.49824417","0.4981385","0.49786404","0.49697188","0.49695018","0.49653378","0.49629033","0.49603048","0.4953875","0.49458507","0.4942957","0.4937107","0.49351886","0.49319273","0.4928265","0.49264494","0.49234152","0.49186525","0.49159372","0.49130857","0.48916635","0.48808736","0.48791167","0.4877266","0.48737115","0.4868798","0.48629344","0.48611668","0.48573092","0.48556453","0.48548833","0.48547414","0.48545647","0.48497182","0.48491165","0.48458922","0.48457038","0.484521"],"string":"[\n \"0.6062276\",\n \"0.6009414\",\n \"0.5854938\",\n \"0.55636716\",\n \"0.5466281\",\n \"0.54142034\",\n \"0.54097426\",\n \"0.53703797\",\n \"0.5366806\",\n \"0.5362178\",\n \"0.53470725\",\n \"0.5342757\",\n \"0.5329308\",\n \"0.52993786\",\n \"0.5255946\",\n \"0.52543396\",\n \"0.5253646\",\n \"0.5226769\",\n \"0.5217197\",\n \"0.5200583\",\n \"0.51922\",\n \"0.5166258\",\n \"0.5165572\",\n \"0.5165006\",\n \"0.5151935\",\n \"0.51509225\",\n \"0.51451945\",\n \"0.51360124\",\n \"0.5131971\",\n \"0.5127064\",\n \"0.51263916\",\n \"0.5123485\",\n \"0.511295\",\n \"0.5106237\",\n \"0.50917697\",\n \"0.5081962\",\n \"0.50703937\",\n \"0.50696886\",\n \"0.5068241\",\n \"0.5058643\",\n \"0.50539947\",\n \"0.5050564\",\n \"0.50463825\",\n \"0.50453347\",\n \"0.50405943\",\n \"0.50344425\",\n \"0.5034295\",\n \"0.5027275\",\n \"0.5021011\",\n \"0.50156724\",\n \"0.50099474\",\n \"0.50099474\",\n \"0.50082874\",\n \"0.5004102\",\n \"0.50038236\",\n \"0.5002994\",\n \"0.5002356\",\n \"0.5001764\",\n \"0.49874848\",\n \"0.49867412\",\n \"0.49842262\",\n \"0.49833456\",\n \"0.49824417\",\n \"0.4981385\",\n \"0.49786404\",\n \"0.49697188\",\n \"0.49695018\",\n \"0.49653378\",\n \"0.49629033\",\n \"0.49603048\",\n \"0.4953875\",\n \"0.49458507\",\n \"0.4942957\",\n \"0.4937107\",\n \"0.49351886\",\n \"0.49319273\",\n \"0.4928265\",\n \"0.49264494\",\n \"0.49234152\",\n \"0.49186525\",\n \"0.49159372\",\n \"0.49130857\",\n \"0.48916635\",\n \"0.48808736\",\n \"0.48791167\",\n \"0.4877266\",\n \"0.48737115\",\n \"0.4868798\",\n \"0.48629344\",\n \"0.48611668\",\n \"0.48573092\",\n \"0.48556453\",\n \"0.48548833\",\n \"0.48547414\",\n \"0.48545647\",\n \"0.48497182\",\n \"0.48491165\",\n \"0.48458922\",\n \"0.48457038\",\n \"0.484521\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6342304"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23595,"cells":{"query":{"kind":"string","value":"Constructor for the RestoreObjectState class"},"document":{"kind":"string","value":"def __init__(self,\n error=None,\n object_status=None,\n resource_pool_id=None,\n restored_object_id=None,\n source_object_id=None,\n ):\n\n # Initialize members of the class\n self.error = error\n self.object_status = object_status\n self.resource_pool_id = resource_pool_id\n self.restored_object_id = restored_object_id\n self.source_object_id = source_object_id"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __init__(self, state):\n self.state = state","def restore(self, obj):\n return obj","def __init__(self,\n alternate_restore_base_directory=None,\n continue_on_error=None,\n encryption_enabled=None,\n generate_ssh_keys=None,\n override_originals=None,\n preserve_acls=None,\n preserve_attributes=None,\n preserve_timestamps=None,\n restore_entities=None,\n restore_to_original_paths=None,\n save_success_files=None,\n skip_estimation=None,\n ):\n\n # Initialize members of the class\n self.alternate_restore_base_directory = alternate_restore_base_directory\n self.continue_on_error = continue_on_error\n self.encryption_enabled = encryption_enabled\n self.generate_ssh_keys = generate_ssh_keys\n self.override_originals = override_originals\n self.preserve_acls = preserve_acls\n self.preserve_attributes = preserve_attributes\n self.preserve_timestamps = preserve_timestamps\n self.restore_entities = restore_entities\n self.restore_to_original_paths = restore_to_original_paths\n self.save_success_files = save_success_files\n self.skip_estimation = skip_estimation","def __init__(self, state=State.NORMAL):\n self.state = state","def __init__(self):\n raise NotImplementedError('cannot create independent state')","def mos_object(self):\n return self._restore_fn(*self._restore_args)","def __init__(self, init_state):\n self._curr_state = init_state","def __setstate__(self, _state : dict):\n self.__init__(**_state)","def restore(self):\n self.abstract_obj.restore()","def __init__(self):\n self._state: CartState = None","def __init__(self, *args, **kwds):\n if args or kwds:\n super(StateInstantiation, self).__init__(*args, **kwds)\n # message fields cannot be None, assign default values for those that are\n if self.state_path is None:\n self.state_path = ''\n if self.state_class is None:\n self.state_class = ''\n if self.initial_state_name is None:\n self.initial_state_name = ''\n if self.input_keys is None:\n self.input_keys = []\n if self.output_keys is None:\n self.output_keys = []\n if self.cond_outcome is None:\n self.cond_outcome = []\n if self.cond_transition is None:\n self.cond_transition = []\n if self.behavior_class is None:\n self.behavior_class = ''\n if self.parameter_names is None:\n self.parameter_names = []\n if self.parameter_values is None:\n self.parameter_values = []\n if self.position is None:\n self.position = [0.] * 2\n if self.outcomes is None:\n self.outcomes = []\n if self.transitions is None:\n self.transitions = []\n if self.autonomy is None:\n self.autonomy = []\n if self.userdata_keys is None:\n self.userdata_keys = []\n if self.userdata_remapping is None:\n self.userdata_remapping = []\n else:\n self.state_path = ''\n self.state_class = ''\n self.initial_state_name = ''\n self.input_keys = []\n self.output_keys = []\n self.cond_outcome = []\n self.cond_transition = []\n self.behavior_class = ''\n self.parameter_names = []\n self.parameter_values = []\n self.position = [0.] * 2\n self.outcomes = []\n self.transitions = []\n self.autonomy = []\n self.userdata_keys = []\n self.userdata_remapping = []","def __init__(self,\n application_restore_objects=None,\n hosting_protection_source=None,\n ):\n\n # Initialize members of the class\n self.application_restore_objects = application_restore_objects\n self.hosting_protection_source = hosting_protection_source","def __init__(self):\n\t\tself.state = None\n\t\tself.info = None\n\t\tself.next = None","def __init__( self, state=None ):\n\n raise NotImplementedError(\"__init__\");","def __init__(self):\n self.__dict__ = self._shared_state","def __setstate__(self, state):\n # compatibility with data from previous versions\n self._name = \"\"\n self._user_data = dict()\n self.__loaded_from = None\n # Restore state. This overrides the above if contained in the data.\n self.__dict__.update(restore_dict(state))","def restore_object(Bucket=None, Key=None, VersionId=None, RestoreRequest=None, RequestPayer=None):\n pass","def __setstate__(self, s):\n self.__dict__ = s\n self.experiment_object = None","def initialize_state(self):\n super(InverseChain, self).initialize_state()","def restore_object(self):\n self.co_worker_list = self.original_co_worker_list","def __init__(self, rexarm, state_machine, parent=None):\n QThread.__init__(self, parent=parent)\n self.rexarm = rexarm\n self.sm=state_machine","def restore_state(self, state: ale_py.ALEState):\n self.ale.restoreState(state)","def __init__(self) -> None:\n\n self.reset()","def _save_state_as_orig(self):\n self._orig = None\n self._orig = deepcopy(self)","def __init__(self):\n self.update_state()","def __restoreBackup(self):\n pass #FIXME!!!","def __init__(self, state: str) -> None:\n super().__init__(\"memory\")\n self._fail_counter = 0\n self._opened_at: datetime | None = None\n self._state = state","def restore(self, serialized: bytes) -> None:\n loaded_state = pickle.loads(serialized)\n self.__dict__.update(loaded_state.__dict__)","def __init__(self):\n self.state_locations = None;\n self.state_actions = None;\n self.start_id = None; # The id assigned to the start state\n self.goal_id = None; # The id assigned to the goal state\n self.start_loc = None; # The real word coordinates of the start state\n self.goal_loc = None; # The real word coordinates of the goal state\n self.reward_states_n = None\n self.reward_states = None\n self.reward_sendcommand = None\n self.reward_timeout = None\n self.timeout = None","def restore(self):\n raise NotImplementedError","def restore(self, restore):\n self._restore = restore","def __init__(self, context):\n super(CollectingState, self).__init__(context)\n self._ops_list = []\n self._ops_list += State.trans_stores\n self._inner_state = \"init\"","def __setstate__(self, dict):\n\n\t\tself.__dict__ = dict\n\n\t\t# Set missing values to defaults.\n\t\tself._device = None\n\t\tself.resources = {}","def initialize_state(self):\n raise NotImplementedError()","def __init__(self,mdp):\n self._mdp = mdp\n self._prev_state = None # What was the previous state?\n self._cur_state = None # What was is the current state?\n self.reset()","def __init__(self):\n self.state_shape = None\n self.action_shape = None\n self.number_turns = 0\n self.td_loss_history = []\n self.moving_average_loss = []\n self.reward_history = []\n self.moving_average_rewards = []\n self._episode_reward = 0","def fromState(state):","def __init__(self, board: Board, state: RRState = None):\n if state == None:\n self.initial = RRState(board)\n else:\n self.initial = state","def restore_state(self, state):\n state_ref = self.ale.decodeState(state)\n self.ale.restoreState(state_ref)\n self.ale.deleteState(state_ref)","def __init__(self, obj):\n self._store = {}\n self.obj = weakref.proxy(obj)","def __setstate__(self, ob):\n import pickle\n\n self.fn = pickle.loads(ob)","def __init__(self, *args, **kwds):\n if args or kwds:\n super(States, self).__init__(*args, **kwds)\n #message fields cannot be None, assign default values for those that are\n if self.name is None:\n self.name = ''\n if self.visible is None:\n self.visible = False\n if self.x is None:\n self.x = 0.\n if self.y is None:\n self.y = 0.\n if self.z is None:\n self.z = 0.\n if self.u is None:\n self.u = 0.\n if self.v is None:\n self.v = 0.\n if self.w is None:\n self.w = 0.\n if self.phi is None:\n self.phi = 0.\n if self.theta is None:\n self.theta = 0.\n if self.psi is None:\n self.psi = 0.\n if self.p is None:\n self.p = 0.\n if self.q is None:\n self.q = 0.\n if self.r is None:\n self.r = 0.\n else:\n self.name = ''\n self.visible = False\n self.x = 0.\n self.y = 0.\n self.z = 0.\n self.u = 0.\n self.v = 0.\n self.w = 0.\n self.phi = 0.\n self.theta = 0.\n self.psi = 0.\n self.p = 0.\n self.q = 0.\n self.r = 0.","def __getstate__(self):\n state = self.__dict__.copy()\n self.__cleanState__(state)\n return state","def __setstate__(self, state: dict) -> None:\n self.__handle__ = HandleInfo(**state)\n self.__handle__.is_recorded = True\n self.__init__(state[\"name\"], *state[\"args\"], **state[\"kwargs\"]) # type: ignore","def __setstate__(self, state):\n self.__dict__ = state\n self.freshly_loaded = True","def __init__(self, py_dict=None):\n super(StateDetailsSchema, self).__init__()\n self.sub_system_address = None\n self.sub_system_id = None\n self.state = None\n self.failure_message = None\n\n if py_dict is not None:\n self.get_object_from_py_dict(py_dict)","def _restore(self):\n self._logger = LOGGER\n self._param_store = pyro.get_param_store()\n self.set_state(self.best_params)\n self._alpha_guide_prior_params = dict(\n self._param_store.named_parameters()\n )","def __init__(self, player1, player2, state_machine, restore = False):\r\n super().__init__()\r\n self.__players[0] = player1\r\n self.__players[1] = player2\r\n self.__player_names[player1] = 'Human'\r\n self.__player_names[player2] = 'Bot'\r\n self.__state_machine = state_machine","def __init__(self, *args, **kwargs):\n super(AbstractOdeModel, self).__init__(*args, **kwargs)\n self.saved_states = {}\n self.state = self.initial_state.copy()\n self.dirty = False # whether the solver will need to be reset due to a model change before the next solve\n self.set_solver(DefaultSolver())\n self.env = Env.ModelWrapperEnvironment(self)\n assert hasattr(self, 'output_names')","def __init__(self, obj, *args, **kwargs):\n self.obj_ = obj\n super(ArtificialRV, self).__init__(*args, **kwargs)","def restore_state(self, ckpt):\n raise NotImplemented()","def __init__(self,\n state,\n stateCallback = None,\n name = \"\",\n ):\n self._state = state\n self._reason = \"\"\n if stateCallback:\n self._stateCallbackList = [stateCallback]\n else:\n self._stateCallbackList = []\n self.name = name","def __init__(self, state: State):\n self._state = state\n self._parent = None\n self._untried_edges = self._state.possible_actions\n self.children = {} # {AbstractAction: AbstractState}\n self.tot_reward = 0\n self.num_samples = 0","def __init__(self):\n # Define class API\n self.api = API2()\n # Initialize a list of SAVED_OBJECTS (used in get_ancestors)\n self.SAVED_OBJECTS = []\n # Initialize the total number of objects\n self.total = 0\n # Load saved objects from file to continue the last execution\n self.load_saved_objects()","def __init__(self, *args, **kwds):\n if args or kwds:\n super(Reset, self).__init__(*args, **kwds)","def __setstate__(self, state) -> None:\n # TODO (sven): Validate that our config and the config in state are compatible.\n # For example, the model architectures may differ.\n # Also, what should the behavior be if e.g. some training parameter\n # (e.g. lr) changed?\n\n if hasattr(self, \"workers\") and \"worker\" in state:\n self.workers.local_worker().set_state(state[\"worker\"])\n remote_state = ray.put(state[\"worker\"])\n self.workers.foreach_worker(\n lambda w: w.set_state(ray.get(remote_state)),\n local_worker=False,\n healthy_only=False,\n )\n if self.evaluation_workers:\n # If evaluation workers are used, also restore the policies\n # there in case they are used for evaluation purpose.\n self.evaluation_workers.foreach_worker(\n lambda w: w.set_state(ray.get(remote_state)),\n healthy_only=False,\n )\n # If necessary, restore replay data as well.\n if self.local_replay_buffer is not None:\n # TODO: Experimental functionality: Restore contents of replay\n # buffer from checkpoint, only if user has configured this.\n if self.config.get(\"store_buffer_in_checkpoints\"):\n if \"local_replay_buffer\" in state:\n self.local_replay_buffer.set_state(state[\"local_replay_buffer\"])\n else:\n logger.warning(\n \"`store_buffer_in_checkpoints` is True, but no replay \"\n \"data found in state!\"\n )\n elif \"local_replay_buffer\" in state and log_once(\n \"no_store_buffer_in_checkpoints_but_data_found\"\n ):\n logger.warning(\n \"`store_buffer_in_checkpoints` is False, but some replay \"\n \"data found in state!\"\n )\n\n if self.train_exec_impl is not None:\n self.train_exec_impl.shared_metrics.get().restore(state[\"train_exec_impl\"])\n elif \"counters\" in state:\n self._counters = state[\"counters\"]\n\n if \"training_iteration\" in state:\n self._iteration = state[\"training_iteration\"]","def __init__(self, location, state = State.E):\n self.location = location\n self.state = state","def __init__(\n self,\n state: str,\n redis_object: Redis,\n namespace: str | None = None,\n fallback_circuit_state: str = STATE_CLOSED,\n cluster_mode: bool = False,\n ):\n\n # Module does not exist, so this feature is not available\n if not HAS_REDIS_SUPPORT:\n raise ImportError(\n \"CircuitRedisStorage can only be used if the required dependencies exist\"\n )\n\n super().__init__(\"redis\")\n\n self._redis = redis_object\n self._namespace_name = namespace\n self._fallback_circuit_state = fallback_circuit_state\n self._initial_state = str(state)\n self._cluster_mode = cluster_mode\n\n self._initialize_redis_state(self._initial_state)","def __init__(self):\n self.reset()","def __init__(self):\n # The current information for the environment\n self.state_space = ()\n self.action_space = ()\n self.state = None\n self.reward = 0\n self.terminal = False\n self.truncated = False\n self.info = None","def __init__(self):\r\n\r\n self.reset()","def __init__(self, orig):\n self.orig = orig","def initial_state(self):\n pass","def _Restore(self) -> None:\n self._SetNodes(self._nodes)","def __init__(self, fname):\n self.fname = os.path.abspath(fname)\n self.restore()","def __setstate__(self, state):\n # Restore instance attributes\n try: \n obj = Thing.ID_dict[state['id']] # is this obj already in dict?\n dbg.debug(\"Note: %s already in Thing.ID_dict, maps to %s\" % (state['id'], obj))\n except KeyError: # Not already in dict\n Thing.ID_dict[state['id']] = self\n if 'has_beat' in state:\n Thing.game.register_heartbeat(self)\n self.__dict__.update(state)","def _transit_state(self) -> None:\n pass","def __init__( self, prevState = None ): ###PLEASE NOTE THIS THAT THE __init__ method is here and this is where GameState() starts\n if prevState != None: # Initial state\n self.data = GameStateData(prevState.data) ##This statement imports the GameStateData object from the GameStateData class in game.py. This object contains a data packet documenting the state of the game.\n\n else:\n self.data = GameStateData()\n \"\"\"\n self._foodEaten = None\n self._capsuleEaten = None\n self._agentMoved = None\n self._lose = False\n self._win = False\n self.scoreChange = 0\n \"\"\"","def restore(self, checkpoint):\n raise NotImplementedError","def __init__(self, obj, attribs):\n self.obj = obj\n self.attribs = attribs\n if self.obj:\n self._save()","def __init__(self,startState,func,emitState):\n self.startState = startState\n self.func = func\n self.stateToSet = emitState","def load_state(self, state):\n for attr, cls in self._stateobject_attributes.iteritems():\n if state.get(attr, None) is None:\n setattr(self, attr, None)\n else:\n curr = getattr(self, attr)\n if hasattr(curr, \"load_state\"):\n curr.load_state(state[attr])\n elif hasattr(cls, \"from_state\"):\n setattr(self, attr, cls.from_state(state[attr]))\n else:\n setattr(self, attr, cls(state[attr]))","def __getstate__(self) -> Dict[str, Any]:\n s = self.__dict__.copy()\n # Kill the parent ref. It won't pickle well.\n s[\"_parent\"] = None\n return s","def __init__(self, instrument):\n self._unsub_dispatcher = None\n self._instrument = instrument\n self._state = instrument.state","def restore(self, arguments):\n puts_err(colored.red(\"Not implemented!\"))","def set_state(self, state_obj):\n if not isinstance(state_obj, dict):\n raise DatasetParserException(\"Invalid state structure\")\n if not (StateKey.FIRST_RECORD in state_obj) or \\\n not (StateKey.POSITION in state_obj) or \\\n not (StateKey.VELOCITY_END in state_obj):\n raise DatasetParserException(\"Invalid state keys\")\n\n #\n # Initialize parent data.\n #\n self._timestamp = 0.0\n self._record_buffer = []\n\n self._state = state_obj\n self._read_state = state_obj\n self.input_file.seek(self._read_state[StateKey.POSITION], 0)","def __setstate__(self, d):\n\t\tself.__dict__ = d","def __setstate__(self, state):\n return None","def __init__(self, subject):\n super().__init__(subject)\n self.state = 0","def restore(self):\n self.igate.restore()\n self.fgate.restore()\n self.ogate.restore()\n super(LSTM, self).restore()","def __setstate__(self, state):\n for i, j in state.items():\n setattr(self, i, j)\n self.describer_model = _load_model(self.name)","def __setstate__(self, state):\n for i, j in state.items():\n setattr(self, i, j)\n self.describer_model = _load_model(self.name)","def restore_model_state(self, model: Block):\n if model in self.initial_state:\n from_json(model, sd=self.initial_state[model], wts=StoreState)\n else:\n self._update_summary(model, \"status\", InitializationStatus.Error)\n raise ValueError(\"No initial state stored.\")","def __init__(self) -> None:\n # TODO: Provide the complete constructor for this object","def __init__(__self__, *,\n cross_subscription_restore_settings: Optional[pulumi.Input['CrossSubscriptionRestoreSettingsArgs']] = None):\n if cross_subscription_restore_settings is not None:\n pulumi.set(__self__, \"cross_subscription_restore_settings\", cross_subscription_restore_settings)","def restore(self):\n return self._restore","def __init__(self, **kwds):\n self._state = None\n\n super().__init__(\n discovery_update=self.discovery_update,\n **kwds,\n )","def restore(self):\n\t\treturn Job(SDK.PrlVm_Restore(self.handle)[0])","def __getstate__(self):\n\t\treturn self","def __setstate__(self, state):\n if state.get('_pickle_standard') == 2:\n self.__dict__.update(state)\n return\n\n # unpickle from state pickled with our previous custom __getstate__ code\n logging = get_task_logger(__name__) # logging is likely to happen within celery\n try:\n self.startdate = dateutil.parser.parse(state.get('startdate')) if state.get('startdate') else None\n self.enddate = dateutil.parser.parse(state.get('enddate')) if state.get('enddate') else None\n except Exception as e:\n logging.error(\"Could not unpack start and end dates for DateSpan. Error: %s\" % e)\n self.format = state.get('format', ISO_DATE_FORMAT)\n self.inclusive = state.get('inclusive', True)\n self.timezone = pytz.utc\n self.is_default = state.get('is_default', False)\n self.max_days = state.get('max_days')\n try:\n self.timezone = pytz.timezone(state.get('timezone'))\n except Exception as e:\n logging.error(\"Could not unpack timezone for DateSpan. Error: %s\" % e)","def initialize_state(self, state):\n print 'state initialized'\n return state","def restore_full_state(self, state):\n state_ref = self.ale.decodeState(state)\n self.ale.restoreSystemState(state_ref)\n self.ale.deleteState(state_ref)","def initialize(self):\n self.currState = self.startState","def restoreState(self, state):\n self.setVoltage(state['voltage'])\n if state['output'] == True:\n self.turnOn()\n else:\n self.turnOff()","def __init__(self, repository):\r\n self.__repository = repository\r\n self.__undo_operations = []\r\n self.__redo_operations = []\r\n self.__redo_count = 0\r\n self.__reserve_action = []","def __init__(self):\n super().__init__()\n self.reset()","def __init__(self, undo, redo, **kwargs):\n self._undo = undo\n self._redo = redo\n self._data = kwargs.get(\"data\", {})\n self.key = kwargs.get(\"key\", None)","def __setstate__(self, state):\n exclude_keys = ['_is_zero', '_is_positive', '_is_nonneg']\n for key,value in state.items():\n if key in exclude_keys:\n continue\n if key == '_field':\n self._init_field(value)\n continue\n self.__dict__[key] = value\n return state","def __init__(self, context, laststate=False):\n self.context = self.clone_context(context)\n self.global_filter = None\n self._rebalancetime = None\n\n self._swarm = None\n self._swarm_stats = None\n self._swarm_inposition = None\n\n self._picked_swarm = None\n self._picked_inposition = None\n self._picked_exposure = None\n\n self._last_date = None\n self._last_exoquote = None\n self._last_exposure = None\n self._last_members_list = None\n self._last_rebalance_date = None\n self._last_delta = None\n self._last_prev_exposure = None\n self._max_exposure = None\n\n self._swarm_series = None\n self._delta = None\n\n self._islast_state = laststate\n\n strategy_settings = self.context['strategy']\n # Initialize strategy class\n self.strategy = strategy_settings['class'](self.context)\n\n self._swarm_avg = None\n self._swarm = None\n self._swarm_exposure = None","def __init__(self, initial_state=True):\n self.ffmpeg = None\n self.initial_state = initial_state"],"string":"[\n \"def __init__(self, state):\\n self.state = state\",\n \"def restore(self, obj):\\n return obj\",\n \"def __init__(self,\\n alternate_restore_base_directory=None,\\n continue_on_error=None,\\n encryption_enabled=None,\\n generate_ssh_keys=None,\\n override_originals=None,\\n preserve_acls=None,\\n preserve_attributes=None,\\n preserve_timestamps=None,\\n restore_entities=None,\\n restore_to_original_paths=None,\\n save_success_files=None,\\n skip_estimation=None,\\n ):\\n\\n # Initialize members of the class\\n self.alternate_restore_base_directory = alternate_restore_base_directory\\n self.continue_on_error = continue_on_error\\n self.encryption_enabled = encryption_enabled\\n self.generate_ssh_keys = generate_ssh_keys\\n self.override_originals = override_originals\\n self.preserve_acls = preserve_acls\\n self.preserve_attributes = preserve_attributes\\n self.preserve_timestamps = preserve_timestamps\\n self.restore_entities = restore_entities\\n self.restore_to_original_paths = restore_to_original_paths\\n self.save_success_files = save_success_files\\n self.skip_estimation = skip_estimation\",\n \"def __init__(self, state=State.NORMAL):\\n self.state = state\",\n \"def __init__(self):\\n raise NotImplementedError('cannot create independent state')\",\n \"def mos_object(self):\\n return self._restore_fn(*self._restore_args)\",\n \"def __init__(self, init_state):\\n self._curr_state = init_state\",\n \"def __setstate__(self, _state : dict):\\n self.__init__(**_state)\",\n \"def restore(self):\\n self.abstract_obj.restore()\",\n \"def __init__(self):\\n self._state: CartState = None\",\n \"def __init__(self, *args, **kwds):\\n if args or kwds:\\n super(StateInstantiation, self).__init__(*args, **kwds)\\n # message fields cannot be None, assign default values for those that are\\n if self.state_path is None:\\n self.state_path = ''\\n if self.state_class is None:\\n self.state_class = ''\\n if self.initial_state_name is None:\\n self.initial_state_name = ''\\n if self.input_keys is None:\\n self.input_keys = []\\n if self.output_keys is None:\\n self.output_keys = []\\n if self.cond_outcome is None:\\n self.cond_outcome = []\\n if self.cond_transition is None:\\n self.cond_transition = []\\n if self.behavior_class is None:\\n self.behavior_class = ''\\n if self.parameter_names is None:\\n self.parameter_names = []\\n if self.parameter_values is None:\\n self.parameter_values = []\\n if self.position is None:\\n self.position = [0.] * 2\\n if self.outcomes is None:\\n self.outcomes = []\\n if self.transitions is None:\\n self.transitions = []\\n if self.autonomy is None:\\n self.autonomy = []\\n if self.userdata_keys is None:\\n self.userdata_keys = []\\n if self.userdata_remapping is None:\\n self.userdata_remapping = []\\n else:\\n self.state_path = ''\\n self.state_class = ''\\n self.initial_state_name = ''\\n self.input_keys = []\\n self.output_keys = []\\n self.cond_outcome = []\\n self.cond_transition = []\\n self.behavior_class = ''\\n self.parameter_names = []\\n self.parameter_values = []\\n self.position = [0.] * 2\\n self.outcomes = []\\n self.transitions = []\\n self.autonomy = []\\n self.userdata_keys = []\\n self.userdata_remapping = []\",\n \"def __init__(self,\\n application_restore_objects=None,\\n hosting_protection_source=None,\\n ):\\n\\n # Initialize members of the class\\n self.application_restore_objects = application_restore_objects\\n self.hosting_protection_source = hosting_protection_source\",\n \"def __init__(self):\\n\\t\\tself.state = None\\n\\t\\tself.info = None\\n\\t\\tself.next = None\",\n \"def __init__( self, state=None ):\\n\\n raise NotImplementedError(\\\"__init__\\\");\",\n \"def __init__(self):\\n self.__dict__ = self._shared_state\",\n \"def __setstate__(self, state):\\n # compatibility with data from previous versions\\n self._name = \\\"\\\"\\n self._user_data = dict()\\n self.__loaded_from = None\\n # Restore state. This overrides the above if contained in the data.\\n self.__dict__.update(restore_dict(state))\",\n \"def restore_object(Bucket=None, Key=None, VersionId=None, RestoreRequest=None, RequestPayer=None):\\n pass\",\n \"def __setstate__(self, s):\\n self.__dict__ = s\\n self.experiment_object = None\",\n \"def initialize_state(self):\\n super(InverseChain, self).initialize_state()\",\n \"def restore_object(self):\\n self.co_worker_list = self.original_co_worker_list\",\n \"def __init__(self, rexarm, state_machine, parent=None):\\n QThread.__init__(self, parent=parent)\\n self.rexarm = rexarm\\n self.sm=state_machine\",\n \"def restore_state(self, state: ale_py.ALEState):\\n self.ale.restoreState(state)\",\n \"def __init__(self) -> None:\\n\\n self.reset()\",\n \"def _save_state_as_orig(self):\\n self._orig = None\\n self._orig = deepcopy(self)\",\n \"def __init__(self):\\n self.update_state()\",\n \"def __restoreBackup(self):\\n pass #FIXME!!!\",\n \"def __init__(self, state: str) -> None:\\n super().__init__(\\\"memory\\\")\\n self._fail_counter = 0\\n self._opened_at: datetime | None = None\\n self._state = state\",\n \"def restore(self, serialized: bytes) -> None:\\n loaded_state = pickle.loads(serialized)\\n self.__dict__.update(loaded_state.__dict__)\",\n \"def __init__(self):\\n self.state_locations = None;\\n self.state_actions = None;\\n self.start_id = None; # The id assigned to the start state\\n self.goal_id = None; # The id assigned to the goal state\\n self.start_loc = None; # The real word coordinates of the start state\\n self.goal_loc = None; # The real word coordinates of the goal state\\n self.reward_states_n = None\\n self.reward_states = None\\n self.reward_sendcommand = None\\n self.reward_timeout = None\\n self.timeout = None\",\n \"def restore(self):\\n raise NotImplementedError\",\n \"def restore(self, restore):\\n self._restore = restore\",\n \"def __init__(self, context):\\n super(CollectingState, self).__init__(context)\\n self._ops_list = []\\n self._ops_list += State.trans_stores\\n self._inner_state = \\\"init\\\"\",\n \"def __setstate__(self, dict):\\n\\n\\t\\tself.__dict__ = dict\\n\\n\\t\\t# Set missing values to defaults.\\n\\t\\tself._device = None\\n\\t\\tself.resources = {}\",\n \"def initialize_state(self):\\n raise NotImplementedError()\",\n \"def __init__(self,mdp):\\n self._mdp = mdp\\n self._prev_state = None # What was the previous state?\\n self._cur_state = None # What was is the current state?\\n self.reset()\",\n \"def __init__(self):\\n self.state_shape = None\\n self.action_shape = None\\n self.number_turns = 0\\n self.td_loss_history = []\\n self.moving_average_loss = []\\n self.reward_history = []\\n self.moving_average_rewards = []\\n self._episode_reward = 0\",\n \"def fromState(state):\",\n \"def __init__(self, board: Board, state: RRState = None):\\n if state == None:\\n self.initial = RRState(board)\\n else:\\n self.initial = state\",\n \"def restore_state(self, state):\\n state_ref = self.ale.decodeState(state)\\n self.ale.restoreState(state_ref)\\n self.ale.deleteState(state_ref)\",\n \"def __init__(self, obj):\\n self._store = {}\\n self.obj = weakref.proxy(obj)\",\n \"def __setstate__(self, ob):\\n import pickle\\n\\n self.fn = pickle.loads(ob)\",\n \"def __init__(self, *args, **kwds):\\n if args or kwds:\\n super(States, self).__init__(*args, **kwds)\\n #message fields cannot be None, assign default values for those that are\\n if self.name is None:\\n self.name = ''\\n if self.visible is None:\\n self.visible = False\\n if self.x is None:\\n self.x = 0.\\n if self.y is None:\\n self.y = 0.\\n if self.z is None:\\n self.z = 0.\\n if self.u is None:\\n self.u = 0.\\n if self.v is None:\\n self.v = 0.\\n if self.w is None:\\n self.w = 0.\\n if self.phi is None:\\n self.phi = 0.\\n if self.theta is None:\\n self.theta = 0.\\n if self.psi is None:\\n self.psi = 0.\\n if self.p is None:\\n self.p = 0.\\n if self.q is None:\\n self.q = 0.\\n if self.r is None:\\n self.r = 0.\\n else:\\n self.name = ''\\n self.visible = False\\n self.x = 0.\\n self.y = 0.\\n self.z = 0.\\n self.u = 0.\\n self.v = 0.\\n self.w = 0.\\n self.phi = 0.\\n self.theta = 0.\\n self.psi = 0.\\n self.p = 0.\\n self.q = 0.\\n self.r = 0.\",\n \"def __getstate__(self):\\n state = self.__dict__.copy()\\n self.__cleanState__(state)\\n return state\",\n \"def __setstate__(self, state: dict) -> None:\\n self.__handle__ = HandleInfo(**state)\\n self.__handle__.is_recorded = True\\n self.__init__(state[\\\"name\\\"], *state[\\\"args\\\"], **state[\\\"kwargs\\\"]) # type: ignore\",\n \"def __setstate__(self, state):\\n self.__dict__ = state\\n self.freshly_loaded = True\",\n \"def __init__(self, py_dict=None):\\n super(StateDetailsSchema, self).__init__()\\n self.sub_system_address = None\\n self.sub_system_id = None\\n self.state = None\\n self.failure_message = None\\n\\n if py_dict is not None:\\n self.get_object_from_py_dict(py_dict)\",\n \"def _restore(self):\\n self._logger = LOGGER\\n self._param_store = pyro.get_param_store()\\n self.set_state(self.best_params)\\n self._alpha_guide_prior_params = dict(\\n self._param_store.named_parameters()\\n )\",\n \"def __init__(self, player1, player2, state_machine, restore = False):\\r\\n super().__init__()\\r\\n self.__players[0] = player1\\r\\n self.__players[1] = player2\\r\\n self.__player_names[player1] = 'Human'\\r\\n self.__player_names[player2] = 'Bot'\\r\\n self.__state_machine = state_machine\",\n \"def __init__(self, *args, **kwargs):\\n super(AbstractOdeModel, self).__init__(*args, **kwargs)\\n self.saved_states = {}\\n self.state = self.initial_state.copy()\\n self.dirty = False # whether the solver will need to be reset due to a model change before the next solve\\n self.set_solver(DefaultSolver())\\n self.env = Env.ModelWrapperEnvironment(self)\\n assert hasattr(self, 'output_names')\",\n \"def __init__(self, obj, *args, **kwargs):\\n self.obj_ = obj\\n super(ArtificialRV, self).__init__(*args, **kwargs)\",\n \"def restore_state(self, ckpt):\\n raise NotImplemented()\",\n \"def __init__(self,\\n state,\\n stateCallback = None,\\n name = \\\"\\\",\\n ):\\n self._state = state\\n self._reason = \\\"\\\"\\n if stateCallback:\\n self._stateCallbackList = [stateCallback]\\n else:\\n self._stateCallbackList = []\\n self.name = name\",\n \"def __init__(self, state: State):\\n self._state = state\\n self._parent = None\\n self._untried_edges = self._state.possible_actions\\n self.children = {} # {AbstractAction: AbstractState}\\n self.tot_reward = 0\\n self.num_samples = 0\",\n \"def __init__(self):\\n # Define class API\\n self.api = API2()\\n # Initialize a list of SAVED_OBJECTS (used in get_ancestors)\\n self.SAVED_OBJECTS = []\\n # Initialize the total number of objects\\n self.total = 0\\n # Load saved objects from file to continue the last execution\\n self.load_saved_objects()\",\n \"def __init__(self, *args, **kwds):\\n if args or kwds:\\n super(Reset, self).__init__(*args, **kwds)\",\n \"def __setstate__(self, state) -> None:\\n # TODO (sven): Validate that our config and the config in state are compatible.\\n # For example, the model architectures may differ.\\n # Also, what should the behavior be if e.g. some training parameter\\n # (e.g. lr) changed?\\n\\n if hasattr(self, \\\"workers\\\") and \\\"worker\\\" in state:\\n self.workers.local_worker().set_state(state[\\\"worker\\\"])\\n remote_state = ray.put(state[\\\"worker\\\"])\\n self.workers.foreach_worker(\\n lambda w: w.set_state(ray.get(remote_state)),\\n local_worker=False,\\n healthy_only=False,\\n )\\n if self.evaluation_workers:\\n # If evaluation workers are used, also restore the policies\\n # there in case they are used for evaluation purpose.\\n self.evaluation_workers.foreach_worker(\\n lambda w: w.set_state(ray.get(remote_state)),\\n healthy_only=False,\\n )\\n # If necessary, restore replay data as well.\\n if self.local_replay_buffer is not None:\\n # TODO: Experimental functionality: Restore contents of replay\\n # buffer from checkpoint, only if user has configured this.\\n if self.config.get(\\\"store_buffer_in_checkpoints\\\"):\\n if \\\"local_replay_buffer\\\" in state:\\n self.local_replay_buffer.set_state(state[\\\"local_replay_buffer\\\"])\\n else:\\n logger.warning(\\n \\\"`store_buffer_in_checkpoints` is True, but no replay \\\"\\n \\\"data found in state!\\\"\\n )\\n elif \\\"local_replay_buffer\\\" in state and log_once(\\n \\\"no_store_buffer_in_checkpoints_but_data_found\\\"\\n ):\\n logger.warning(\\n \\\"`store_buffer_in_checkpoints` is False, but some replay \\\"\\n \\\"data found in state!\\\"\\n )\\n\\n if self.train_exec_impl is not None:\\n self.train_exec_impl.shared_metrics.get().restore(state[\\\"train_exec_impl\\\"])\\n elif \\\"counters\\\" in state:\\n self._counters = state[\\\"counters\\\"]\\n\\n if \\\"training_iteration\\\" in state:\\n self._iteration = state[\\\"training_iteration\\\"]\",\n \"def __init__(self, location, state = State.E):\\n self.location = location\\n self.state = state\",\n \"def __init__(\\n self,\\n state: str,\\n redis_object: Redis,\\n namespace: str | None = None,\\n fallback_circuit_state: str = STATE_CLOSED,\\n cluster_mode: bool = False,\\n ):\\n\\n # Module does not exist, so this feature is not available\\n if not HAS_REDIS_SUPPORT:\\n raise ImportError(\\n \\\"CircuitRedisStorage can only be used if the required dependencies exist\\\"\\n )\\n\\n super().__init__(\\\"redis\\\")\\n\\n self._redis = redis_object\\n self._namespace_name = namespace\\n self._fallback_circuit_state = fallback_circuit_state\\n self._initial_state = str(state)\\n self._cluster_mode = cluster_mode\\n\\n self._initialize_redis_state(self._initial_state)\",\n \"def __init__(self):\\n self.reset()\",\n \"def __init__(self):\\n # The current information for the environment\\n self.state_space = ()\\n self.action_space = ()\\n self.state = None\\n self.reward = 0\\n self.terminal = False\\n self.truncated = False\\n self.info = None\",\n \"def __init__(self):\\r\\n\\r\\n self.reset()\",\n \"def __init__(self, orig):\\n self.orig = orig\",\n \"def initial_state(self):\\n pass\",\n \"def _Restore(self) -> None:\\n self._SetNodes(self._nodes)\",\n \"def __init__(self, fname):\\n self.fname = os.path.abspath(fname)\\n self.restore()\",\n \"def __setstate__(self, state):\\n # Restore instance attributes\\n try: \\n obj = Thing.ID_dict[state['id']] # is this obj already in dict?\\n dbg.debug(\\\"Note: %s already in Thing.ID_dict, maps to %s\\\" % (state['id'], obj))\\n except KeyError: # Not already in dict\\n Thing.ID_dict[state['id']] = self\\n if 'has_beat' in state:\\n Thing.game.register_heartbeat(self)\\n self.__dict__.update(state)\",\n \"def _transit_state(self) -> None:\\n pass\",\n \"def __init__( self, prevState = None ): ###PLEASE NOTE THIS THAT THE __init__ method is here and this is where GameState() starts\\n if prevState != None: # Initial state\\n self.data = GameStateData(prevState.data) ##This statement imports the GameStateData object from the GameStateData class in game.py. This object contains a data packet documenting the state of the game.\\n\\n else:\\n self.data = GameStateData()\\n \\\"\\\"\\\"\\n self._foodEaten = None\\n self._capsuleEaten = None\\n self._agentMoved = None\\n self._lose = False\\n self._win = False\\n self.scoreChange = 0\\n \\\"\\\"\\\"\",\n \"def restore(self, checkpoint):\\n raise NotImplementedError\",\n \"def __init__(self, obj, attribs):\\n self.obj = obj\\n self.attribs = attribs\\n if self.obj:\\n self._save()\",\n \"def __init__(self,startState,func,emitState):\\n self.startState = startState\\n self.func = func\\n self.stateToSet = emitState\",\n \"def load_state(self, state):\\n for attr, cls in self._stateobject_attributes.iteritems():\\n if state.get(attr, None) is None:\\n setattr(self, attr, None)\\n else:\\n curr = getattr(self, attr)\\n if hasattr(curr, \\\"load_state\\\"):\\n curr.load_state(state[attr])\\n elif hasattr(cls, \\\"from_state\\\"):\\n setattr(self, attr, cls.from_state(state[attr]))\\n else:\\n setattr(self, attr, cls(state[attr]))\",\n \"def __getstate__(self) -> Dict[str, Any]:\\n s = self.__dict__.copy()\\n # Kill the parent ref. It won't pickle well.\\n s[\\\"_parent\\\"] = None\\n return s\",\n \"def __init__(self, instrument):\\n self._unsub_dispatcher = None\\n self._instrument = instrument\\n self._state = instrument.state\",\n \"def restore(self, arguments):\\n puts_err(colored.red(\\\"Not implemented!\\\"))\",\n \"def set_state(self, state_obj):\\n if not isinstance(state_obj, dict):\\n raise DatasetParserException(\\\"Invalid state structure\\\")\\n if not (StateKey.FIRST_RECORD in state_obj) or \\\\\\n not (StateKey.POSITION in state_obj) or \\\\\\n not (StateKey.VELOCITY_END in state_obj):\\n raise DatasetParserException(\\\"Invalid state keys\\\")\\n\\n #\\n # Initialize parent data.\\n #\\n self._timestamp = 0.0\\n self._record_buffer = []\\n\\n self._state = state_obj\\n self._read_state = state_obj\\n self.input_file.seek(self._read_state[StateKey.POSITION], 0)\",\n \"def __setstate__(self, d):\\n\\t\\tself.__dict__ = d\",\n \"def __setstate__(self, state):\\n return None\",\n \"def __init__(self, subject):\\n super().__init__(subject)\\n self.state = 0\",\n \"def restore(self):\\n self.igate.restore()\\n self.fgate.restore()\\n self.ogate.restore()\\n super(LSTM, self).restore()\",\n \"def __setstate__(self, state):\\n for i, j in state.items():\\n setattr(self, i, j)\\n self.describer_model = _load_model(self.name)\",\n \"def __setstate__(self, state):\\n for i, j in state.items():\\n setattr(self, i, j)\\n self.describer_model = _load_model(self.name)\",\n \"def restore_model_state(self, model: Block):\\n if model in self.initial_state:\\n from_json(model, sd=self.initial_state[model], wts=StoreState)\\n else:\\n self._update_summary(model, \\\"status\\\", InitializationStatus.Error)\\n raise ValueError(\\\"No initial state stored.\\\")\",\n \"def __init__(self) -> None:\\n # TODO: Provide the complete constructor for this object\",\n \"def __init__(__self__, *,\\n cross_subscription_restore_settings: Optional[pulumi.Input['CrossSubscriptionRestoreSettingsArgs']] = None):\\n if cross_subscription_restore_settings is not None:\\n pulumi.set(__self__, \\\"cross_subscription_restore_settings\\\", cross_subscription_restore_settings)\",\n \"def restore(self):\\n return self._restore\",\n \"def __init__(self, **kwds):\\n self._state = None\\n\\n super().__init__(\\n discovery_update=self.discovery_update,\\n **kwds,\\n )\",\n \"def restore(self):\\n\\t\\treturn Job(SDK.PrlVm_Restore(self.handle)[0])\",\n \"def __getstate__(self):\\n\\t\\treturn self\",\n \"def __setstate__(self, state):\\n if state.get('_pickle_standard') == 2:\\n self.__dict__.update(state)\\n return\\n\\n # unpickle from state pickled with our previous custom __getstate__ code\\n logging = get_task_logger(__name__) # logging is likely to happen within celery\\n try:\\n self.startdate = dateutil.parser.parse(state.get('startdate')) if state.get('startdate') else None\\n self.enddate = dateutil.parser.parse(state.get('enddate')) if state.get('enddate') else None\\n except Exception as e:\\n logging.error(\\\"Could not unpack start and end dates for DateSpan. Error: %s\\\" % e)\\n self.format = state.get('format', ISO_DATE_FORMAT)\\n self.inclusive = state.get('inclusive', True)\\n self.timezone = pytz.utc\\n self.is_default = state.get('is_default', False)\\n self.max_days = state.get('max_days')\\n try:\\n self.timezone = pytz.timezone(state.get('timezone'))\\n except Exception as e:\\n logging.error(\\\"Could not unpack timezone for DateSpan. Error: %s\\\" % e)\",\n \"def initialize_state(self, state):\\n print 'state initialized'\\n return state\",\n \"def restore_full_state(self, state):\\n state_ref = self.ale.decodeState(state)\\n self.ale.restoreSystemState(state_ref)\\n self.ale.deleteState(state_ref)\",\n \"def initialize(self):\\n self.currState = self.startState\",\n \"def restoreState(self, state):\\n self.setVoltage(state['voltage'])\\n if state['output'] == True:\\n self.turnOn()\\n else:\\n self.turnOff()\",\n \"def __init__(self, repository):\\r\\n self.__repository = repository\\r\\n self.__undo_operations = []\\r\\n self.__redo_operations = []\\r\\n self.__redo_count = 0\\r\\n self.__reserve_action = []\",\n \"def __init__(self):\\n super().__init__()\\n self.reset()\",\n \"def __init__(self, undo, redo, **kwargs):\\n self._undo = undo\\n self._redo = redo\\n self._data = kwargs.get(\\\"data\\\", {})\\n self.key = kwargs.get(\\\"key\\\", None)\",\n \"def __setstate__(self, state):\\n exclude_keys = ['_is_zero', '_is_positive', '_is_nonneg']\\n for key,value in state.items():\\n if key in exclude_keys:\\n continue\\n if key == '_field':\\n self._init_field(value)\\n continue\\n self.__dict__[key] = value\\n return state\",\n \"def __init__(self, context, laststate=False):\\n self.context = self.clone_context(context)\\n self.global_filter = None\\n self._rebalancetime = None\\n\\n self._swarm = None\\n self._swarm_stats = None\\n self._swarm_inposition = None\\n\\n self._picked_swarm = None\\n self._picked_inposition = None\\n self._picked_exposure = None\\n\\n self._last_date = None\\n self._last_exoquote = None\\n self._last_exposure = None\\n self._last_members_list = None\\n self._last_rebalance_date = None\\n self._last_delta = None\\n self._last_prev_exposure = None\\n self._max_exposure = None\\n\\n self._swarm_series = None\\n self._delta = None\\n\\n self._islast_state = laststate\\n\\n strategy_settings = self.context['strategy']\\n # Initialize strategy class\\n self.strategy = strategy_settings['class'](self.context)\\n\\n self._swarm_avg = None\\n self._swarm = None\\n self._swarm_exposure = None\",\n \"def __init__(self, initial_state=True):\\n self.ffmpeg = None\\n self.initial_state = initial_state\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6527886","0.6478938","0.63768274","0.63061714","0.6259334","0.6208393","0.6155825","0.6133407","0.612051","0.6097409","0.5997136","0.5995691","0.59769154","0.5974528","0.5970553","0.59491473","0.59310687","0.592171","0.5913257","0.58927315","0.58747876","0.5869466","0.5866477","0.58582354","0.583775","0.58274937","0.5814694","0.5771102","0.5767165","0.57482713","0.5748073","0.5746735","0.5745257","0.5745239","0.5744092","0.57437015","0.57398176","0.57327116","0.56732076","0.5632026","0.56227523","0.56117445","0.56105113","0.56063133","0.5597252","0.5596614","0.55827343","0.55823267","0.55778164","0.55601394","0.5556521","0.5541821","0.5540896","0.55351734","0.55346495","0.55329907","0.55314255","0.55198437","0.55192757","0.5514219","0.5512981","0.5509899","0.5506663","0.5504258","0.5494997","0.54858303","0.54841155","0.54834634","0.54709053","0.5466372","0.5465158","0.5458094","0.5455452","0.54525054","0.54514176","0.54486305","0.5447317","0.5446073","0.5437143","0.54319125","0.5420777","0.5420777","0.5418064","0.5417436","0.54168683","0.5416661","0.54125714","0.5405753","0.5405502","0.53988606","0.5389588","0.5381037","0.5375909","0.5374552","0.53602725","0.5347593","0.5345742","0.5342531","0.5341428","0.5341241"],"string":"[\n \"0.6527886\",\n \"0.6478938\",\n \"0.63768274\",\n \"0.63061714\",\n \"0.6259334\",\n \"0.6208393\",\n \"0.6155825\",\n \"0.6133407\",\n \"0.612051\",\n \"0.6097409\",\n \"0.5997136\",\n \"0.5995691\",\n \"0.59769154\",\n \"0.5974528\",\n \"0.5970553\",\n \"0.59491473\",\n \"0.59310687\",\n \"0.592171\",\n \"0.5913257\",\n \"0.58927315\",\n \"0.58747876\",\n \"0.5869466\",\n \"0.5866477\",\n \"0.58582354\",\n \"0.583775\",\n \"0.58274937\",\n \"0.5814694\",\n \"0.5771102\",\n \"0.5767165\",\n \"0.57482713\",\n \"0.5748073\",\n \"0.5746735\",\n \"0.5745257\",\n \"0.5745239\",\n \"0.5744092\",\n \"0.57437015\",\n \"0.57398176\",\n \"0.57327116\",\n \"0.56732076\",\n \"0.5632026\",\n \"0.56227523\",\n \"0.56117445\",\n \"0.56105113\",\n \"0.56063133\",\n \"0.5597252\",\n \"0.5596614\",\n \"0.55827343\",\n \"0.55823267\",\n \"0.55778164\",\n \"0.55601394\",\n \"0.5556521\",\n \"0.5541821\",\n \"0.5540896\",\n \"0.55351734\",\n \"0.55346495\",\n \"0.55329907\",\n \"0.55314255\",\n \"0.55198437\",\n \"0.55192757\",\n \"0.5514219\",\n \"0.5512981\",\n \"0.5509899\",\n \"0.5506663\",\n \"0.5504258\",\n \"0.5494997\",\n \"0.54858303\",\n \"0.54841155\",\n \"0.54834634\",\n \"0.54709053\",\n \"0.5466372\",\n \"0.5465158\",\n \"0.5458094\",\n \"0.5455452\",\n \"0.54525054\",\n \"0.54514176\",\n \"0.54486305\",\n \"0.5447317\",\n \"0.5446073\",\n \"0.5437143\",\n \"0.54319125\",\n \"0.5420777\",\n \"0.5420777\",\n \"0.5418064\",\n \"0.5417436\",\n \"0.54168683\",\n \"0.5416661\",\n \"0.54125714\",\n \"0.5405753\",\n \"0.5405502\",\n \"0.53988606\",\n \"0.5389588\",\n \"0.5381037\",\n \"0.5375909\",\n \"0.5374552\",\n \"0.53602725\",\n \"0.5347593\",\n \"0.5345742\",\n \"0.5342531\",\n \"0.5341428\",\n \"0.5341241\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69528556"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23596,"cells":{"query":{"kind":"string","value":"Creates an instance of this model from a dictionary"},"document":{"kind":"string","value":"def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n error = cohesity_management_sdk.models.request_error.RequestError.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None\n object_status = dictionary.get('objectStatus')\n resource_pool_id = dictionary.get('resourcePoolId')\n restored_object_id = dictionary.get('restoredObjectId')\n source_object_id = dictionary.get('sourceObjectId')\n\n # Return an object of this model\n return cls(\n error,\n object_status,\n resource_pool_id,\n restored_object_id,\n source_object_id\n)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n name = dictionary.get('name')\n mtype = dictionary.get('type')\n usage_bytes = dictionary.get('usageBytes')\n\n # Return an object of this model\n return cls(\n id,\n name,\n mtype,\n usage_bytes\n)","def create(cls, dictionary):\n return cls(**dictionary)","def create(cls, dictionary):\n return cls(**dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n scheduling = meraki.models.scheduling_model.SchedulingModel.from_dictionary(dictionary.get('scheduling')) if dictionary.get('scheduling') else None\r\n bandwidth = meraki.models.bandwidth_model.BandwidthModel.from_dictionary(dictionary.get('bandwidth')) if dictionary.get('bandwidth') else None\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n scheduling,\r\n bandwidth,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n external_ids = dictionary.get('externalIds')\r\n harsh_accel_setting = dictionary.get('harsh_accel_setting')\r\n name = dictionary.get('name')\r\n\r\n # Return an object of this model\r\n return cls(external_ids,\r\n harsh_accel_setting,\r\n name)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n formatted_price = dictionary.get('FormattedPrice')\n amount = dictionary.get('Amount')\n currency_code = dictionary.get('CurrencyCode')\n\n # Return an object of this model\n return cls(formatted_price,\n amount,\n currency_code)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('Id')\r\n name = dictionary.get('Name')\r\n last_edited = APIHelper.RFC3339DateTime.from_value(dictionary.get(\"LastEdited\")).datetime if dictionary.get(\"LastEdited\") else None\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n name,\r\n last_edited,\r\n dictionary)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n mtype = dictionary.get(\"type\")\n filename = dictionary.get(\"filename\")\n payload = dictionary.get(\"payload\")\n\n # Return an object of this model\n return cls(mtype,\n filename,\n payload)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n protected_count = dictionary.get('protectedCount')\n protected_size = dictionary.get('protectedSize')\n unprotected_count = dictionary.get('unprotectedCount')\n unprotected_size = dictionary.get('unprotectedSize')\n\n # Return an object of this model\n return cls(\n protected_count,\n protected_size,\n unprotected_count,\n unprotected_size\n)","def from_dict(cls, dictionary: Dict[str, Any]):\n return cls(**dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n primary_language = dictionary.get('PrimaryLanguage')\r\n secondary_language = dictionary.get('SecondaryLanguage')\r\n xml_signature = dictionary.get('XmlSignature')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(primary_language,\r\n secondary_language,\r\n xml_signature,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n number = dictionary.get('number')\r\n name = dictionary.get('name')\r\n balance = dictionary.get('balance')\r\n mtype = dictionary.get('type')\r\n status = dictionary.get('status')\r\n customer_id = dictionary.get('customerId')\r\n institution_id = dictionary.get('institutionId')\r\n balance_date = dictionary.get('balanceDate')\r\n created_date = dictionary.get('createdDate')\r\n currency = dictionary.get('currency')\r\n institution_login_id = dictionary.get('institutionLoginId')\r\n display_position = dictionary.get('displayPosition')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n number,\r\n name,\r\n balance,\r\n mtype,\r\n status,\r\n customer_id,\r\n institution_id,\r\n balance_date,\r\n created_date,\r\n currency,\r\n institution_login_id,\r\n display_position,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n links = dictionary.get('links')\r\n email_config = dictionary.get('emailConfig')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(links,\r\n email_config,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n alias = dictionary.get(\"alias\")\r\n cnam_lookups_enabled = dictionary.get(\"cnam_lookups_enabled\")\r\n number_type = dictionary.get(\"number_type\")\r\n rate_center = dictionary.get(\"rate_center\")\r\n state = dictionary.get(\"state\")\r\n value = dictionary.get(\"value\")\r\n\r\n # Return an object of this model\r\n return cls(alias,\r\n cnam_lookups_enabled,\r\n number_type,\r\n rate_center,\r\n state,\r\n value)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n username = dictionary.get('username')\r\n first_name = dictionary.get('firstName')\r\n last_name = dictionary.get('lastName')\r\n application_id = dictionary.get('applicationId')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(username,\r\n first_name,\r\n last_name,\r\n application_id,\r\n dictionary)","def from_dict(cls, data):\n return cls(**data)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def _from_dict(cls, _dict):\n return cls.from_dict(_dict)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n height = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Height')) if dictionary.get('Height') else None\n length = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Length')) if dictionary.get('Length') else None\n weight = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Weight')) if dictionary.get('Weight') else None\n width = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Width')) if dictionary.get('Width') else None\n\n # Return an object of this model\n return cls(height,\n length,\n weight,\n width)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n setup = idfy_rest_client.models.setup.Setup.from_dictionary(dictionary.get('setup')) if dictionary.get('setup') else None\r\n merge_fields = dictionary.get('mergeFields')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(setup,\r\n merge_fields,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n to = dictionary.get('to')\r\n application_id = dictionary.get('applicationId')\r\n expiration_time_in_minutes = dictionary.get('expirationTimeInMinutes')\r\n code = dictionary.get('code')\r\n scope = dictionary.get('scope')\r\n\r\n # Return an object of this model\r\n return cls(to,\r\n application_id,\r\n expiration_time_in_minutes,\r\n code,\r\n scope)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n fqdn = dictionary.get('fqdn')\n guid = dictionary.get('guid')\n id = dictionary.get('id')\n name = dictionary.get('name')\n owner_id = dictionary.get('ownerId')\n status = dictionary.get('status')\n total_size_bytes = dictionary.get('totalSizeBytes')\n\n # Return an object of this model\n return cls(\n fqdn,\n guid,\n id,\n name,\n owner_id,\n status,\n total_size_bytes\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n force_delete = dictionary.get('forceDelete')\n id = dictionary.get('id')\n include_marked_for_removal = dictionary.get('includeMarkedForRemoval')\n retry = dictionary.get('retry')\n\n # Return an object of this model\n return cls(\n force_delete,\n id,\n include_marked_for_removal,\n retry\n)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n account_holder_name = dictionary.get('accountHolderName')\r\n routing_number = dictionary.get('routingNumber')\r\n\r\n # Return an object of this model\r\n return cls(account_holder_name,\r\n routing_number)","def from_dict(cls, d):\n return cls(**d)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n ephemeral_public_key = dictionary.get('ephemeral_public_key')\r\n public_key_hash = dictionary.get('public_key_hash')\r\n transaction_id = dictionary.get('transaction_id')\r\n\r\n # Return an object of this model\r\n return cls(ephemeral_public_key,\r\n public_key_hash,\r\n transaction_id)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n given_name = dictionary.get('givenName')\r\n middle_name = dictionary.get('middleName')\r\n family_name = dictionary.get('familyName')\r\n address = None\r\n if dictionary.get('address') != None:\r\n address = list()\r\n for structure in dictionary.get('address'):\r\n address.append(finicityapi.models.payroll_address.PayrollAddress.from_dictionary(structure))\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n given_name,\r\n middle_name,\r\n family_name,\r\n address,\r\n dictionary)","def from_dict(cls, dct):\n return cls(**dct)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n mor_item = dictionary.get('morItem')\n mor_type = dictionary.get('morType')\n uuid = dictionary.get('uuid')\n\n # Return an object of this model\n return cls(\n mor_item,\n mor_type,\n uuid\n)","def from_dict(cls, data: Dict[str, any]):\n return cls(**data)","def from_dict(cls, session: \"FigoSession\", data_dict: dict) -> \"ModelBase\":\n return cls(session, **data_dict)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n wind_speed = dictionary.get('windSpeed')\n power = dictionary.get('power')\n\n # Return an object of this model\n return cls(wind_speed,\n power)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n consumer_id = dictionary.get('consumerId')\r\n consumer_ssn = dictionary.get('consumerSsn')\r\n event_name = dictionary.get('eventName')\r\n id = dictionary.get('id')\r\n status = dictionary.get('status')\r\n mtype = dictionary.get('type')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(consumer_id,\r\n consumer_ssn,\r\n event_name,\r\n id,\r\n status,\r\n mtype,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n account_id = dictionary.get('AccountId')\r\n name = dictionary.get('Name')\r\n org_no = dictionary.get('OrgNo')\r\n uni_customer_no = dictionary.get('UniCustomerNo')\r\n created = APIHelper.RFC3339DateTime.from_value(dictionary.get(\"Created\")).datetime if dictionary.get(\"Created\") else None\r\n last_modified = APIHelper.RFC3339DateTime.from_value(dictionary.get(\"LastModified\")).datetime if dictionary.get(\"LastModified\") else None\r\n dealer_id = dictionary.get('DealerId')\r\n dealer_name = dictionary.get('DealerName')\r\n dealer_reference = dictionary.get('DealerReference')\r\n enabled = dictionary.get('Enabled')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(account_id,\r\n name,\r\n org_no,\r\n uni_customer_no,\r\n created,\r\n last_modified,\r\n dealer_id,\r\n dealer_name,\r\n dealer_reference,\r\n enabled,\r\n dictionary)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n title = dictionary.get('title')\r\n device_group = dictionary.get('deviceGroup')\r\n create_on = dictionary.get('createOn')\r\n update_on = dictionary.get('updateOn')\r\n created_by = dictionary.get('createdBy')\r\n create_on_persian_date = dictionary.get('createOnPersianDate')\r\n update_on_persian_date = dictionary.get('updateOnPersianDate')\r\n device_type_brand_model_title = dictionary.get('deviceTypeBrandModelTitle')\r\n device_brand_ids = dictionary.get('deviceBrandIds')\r\n device_type_id = dictionary.get('deviceTypeId')\r\n device_brand_id = dictionary.get('deviceBrandId')\r\n updated_by = dictionary.get('updatedBy')\r\n device_type_title = dictionary.get('deviceTypeTitle')\r\n device_brand_title = dictionary.get('deviceBrandTitle')\r\n device_brands_title = dictionary.get('deviceBrandsTitle')\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n title,\r\n device_group,\r\n create_on,\r\n update_on,\r\n created_by,\r\n create_on_persian_date,\r\n update_on_persian_date,\r\n device_type_brand_model_title,\r\n device_brand_ids,\r\n device_type_id,\r\n device_brand_id,\r\n updated_by,\r\n device_type_title,\r\n device_brand_title,\r\n device_brands_title)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n password = dictionary.get('password')\r\n name = dictionary.get('name')\r\n tag_ids = dictionary.get('tagIds')\r\n eld_adverse_weather_exemption_enabled = dictionary.get('eldAdverseWeatherExemptionEnabled')\r\n eld_big_day_exemption_enabled = dictionary.get('eldBigDayExemptionEnabled')\r\n eld_day_start_hour = dictionary.get('eldDayStartHour')\r\n eld_exempt = dictionary.get('eldExempt')\r\n eld_exempt_reason = dictionary.get('eldExemptReason')\r\n eld_pc_enabled = dictionary.get(\"eldPcEnabled\") if dictionary.get(\"eldPcEnabled\") else False\r\n eld_ym_enabled = dictionary.get(\"eldYmEnabled\") if dictionary.get(\"eldYmEnabled\") else False\r\n external_ids = dictionary.get('externalIds')\r\n group_id = dictionary.get('groupId')\r\n license_number = dictionary.get('licenseNumber')\r\n license_state = dictionary.get('licenseState')\r\n notes = dictionary.get('notes')\r\n phone = dictionary.get('phone')\r\n username = dictionary.get('username')\r\n vehicle_id = dictionary.get('vehicleId')\r\n\r\n # Return an object of this model\r\n return cls(password,\r\n name,\r\n tag_ids,\r\n eld_adverse_weather_exemption_enabled,\r\n eld_big_day_exemption_enabled,\r\n eld_day_start_hour,\r\n eld_exempt,\r\n eld_exempt_reason,\r\n eld_pc_enabled,\r\n eld_ym_enabled,\r\n external_ids,\r\n group_id,\r\n license_number,\r\n license_state,\r\n notes,\r\n phone,\r\n username,\r\n vehicle_id)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n env_type = dictionary.get('envType')\n protected_count = dictionary.get('protectedCount')\n protected_size_bytes = dictionary.get('protectedSizeBytes')\n unprotected_count = dictionary.get('unprotectedCount')\n unprotected_size_bytes = dictionary.get('unprotectedSizeBytes')\n\n # Return an object of this model\n return cls(\n env_type,\n protected_count,\n protected_size_bytes,\n unprotected_count,\n unprotected_size_bytes\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n is_mail_enabled = dictionary.get('isMailEnabled')\n is_security_enabled = dictionary.get('isSecurityEnabled')\n member_count = dictionary.get('memberCount')\n visibility = dictionary.get('visibility')\n\n # Return an object of this model\n return cls(\n is_mail_enabled,\n is_security_enabled,\n member_count,\n visibility\n)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n time_zone = dictionary.get('timeZone')\r\n tags = dictionary.get('tags')\r\n disable_my_meraki_com = dictionary.get('disableMyMerakiCom')\r\n disable_remote_status_page = dictionary.get('disableRemoteStatusPage')\r\n enrollment_string = dictionary.get('enrollmentString')\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n time_zone,\r\n tags,\r\n disable_my_meraki_com,\r\n disable_remote_status_page,\r\n enrollment_string)","def from_dict(cls, dictionary):\n normalised = cls.normalise_dict(dictionary)\n return cls.from_normalised_dict(normalised)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n name = dictionary.get('name')\r\n lan_ip = dictionary.get('lanIp')\r\n uplink = dictionary.get('uplink')\r\n public_port = dictionary.get('publicPort')\r\n local_port = dictionary.get('localPort')\r\n allowed_ips = dictionary.get('allowedIps')\r\n protocol = dictionary.get('protocol')\r\n\r\n # Return an object of this model\r\n return cls(name,\r\n lan_ip,\r\n uplink,\r\n public_port,\r\n local_port,\r\n allowed_ips,\r\n protocol)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n found = dictionary.get('found')\r\n displaying = dictionary.get('displaying')\r\n more_available = dictionary.get('moreAvailable')\r\n created_date = dictionary.get('createdDate')\r\n institutions = None\r\n if dictionary.get('institutions') != None:\r\n institutions = list()\r\n for structure in dictionary.get('institutions'):\r\n institutions.append(finicityapi.models.institution.Institution.from_dictionary(structure))\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(found,\r\n displaying,\r\n more_available,\r\n created_date,\r\n institutions,\r\n dictionary)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n backup_file_path = dictionary.get('backupFilePath')\n excluded_file_paths = dictionary.get(\"excludedFilePaths\")\n skip_nested_volumes = dictionary.get('skipNestedVolumes')\n\n # Return an object of this model\n return cls(\n backup_file_path,\n excluded_file_paths,\n skip_nested_volumes\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n lowest_new_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestNewPrice')) if dictionary.get('LowestNewPrice') else None\n lowest_used_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestUsedPrice')) if dictionary.get('LowestUsedPrice') else None\n lowest_collectible_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestCollectiblePrice')) if dictionary.get('LowestCollectiblePrice') else None\n lowest_refurbished_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestRefurbishedPrice')) if dictionary.get('LowestRefurbishedPrice') else None\n total_new = dictionary.get('TotalNew')\n total_used = dictionary.get('TotalUsed')\n total_collectible = dictionary.get('TotalCollectible')\n total_refurbished = dictionary.get('TotalRefurbished')\n\n # Return an object of this model\n return cls(lowest_new_price,\n lowest_used_price,\n lowest_collectible_price,\n lowest_refurbished_price,\n total_new,\n total_used,\n total_collectible,\n total_refurbished)","def from_dict(cls, data):\r\n instance = cls()\r\n for key, value in data.items():\r\n instance.__dict__[key] = value\r\n return instance","def from_dict(cls, dictionary):\n instance = cls()\n for key, value in dictionary.items():\n instance.__dict__[key] = value\n\n return instance","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n door_closed = dictionary.get('doorClosed')\r\n id = dictionary.get('id')\r\n name = dictionary.get('name')\r\n\r\n # Return an object of this model\r\n return cls(door_closed,\r\n id,\r\n name)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n provider_id = dictionary.get('providerId')\n server_time = dictionary.get('serverTime')\n username = dictionary.get('username')\n driver_license_number = dictionary.get('driverLicenseNumber')\n country = dictionary.get('country')\n region = dictionary.get('region')\n driver_home_terminal = dictionary.get('driverHomeTerminal')\n\n # Return an object of this model\n return cls(id,\n provider_id,\n server_time,\n username,\n driver_license_number,\n country,\n region,\n driver_home_terminal)","def from_dict(cls, data):\n instance = cls()\n instance._set_data(data)\n return instance","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n is_group_site = dictionary.get('isGroupSite')\n is_private_channel_site = dictionary.get('isPrivateChannelSite')\n is_team_site = dictionary.get('isTeamSite')\n\n # Return an object of this model\n return cls(\n is_group_site,\n is_private_channel_site,\n is_team_site\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n provider_id = dictionary.get('providerId')\n server_time = dictionary.get('serverTime')\n active_from = dictionary.get('activeFrom')\n active_to = dictionary.get('activeTo')\n rpm_over_value = dictionary.get('rpmOverValue')\n over_speed_value = dictionary.get('overSpeedValue')\n excess_speed_value = dictionary.get('excessSpeedValue')\n long_idle_value = dictionary.get('longIdleValue')\n hi_throttle_value = dictionary.get('hiThrottleValue')\n\n # Return an object of this model\n return cls(id,\n provider_id,\n server_time,\n active_from,\n active_to,\n rpm_over_value,\n over_speed_value,\n excess_speed_value,\n long_idle_value,\n hi_throttle_value)","def from_dict(cls, dikt) -> 'ModelClass':\n return util.deserialize_model(dikt, cls)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n action = dictionary.get('action')\n cluster_info = dictionary.get('clusterInfo')\n details = dictionary.get('details')\n domain = dictionary.get('domain')\n entity_id = dictionary.get('entityId')\n entity_name = dictionary.get('entityName')\n entity_type = dictionary.get('entityType')\n human_timestamp = dictionary.get('humanTimestamp')\n impersonation = dictionary.get('impersonation')\n ip = dictionary.get('ip')\n new_record = dictionary.get('newRecord')\n original_tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('originalTenant')) if dictionary.get('originalTenant') else None\n previous_record = dictionary.get('previousRecord')\n tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('tenant')) if dictionary.get('tenant') else None\n timestamp_usecs = dictionary.get('timestampUsecs')\n user_name = dictionary.get('userName')\n\n # Return an object of this model\n return cls(\n action,\n cluster_info,\n details,\n domain,\n entity_id,\n entity_name,\n entity_type,\n human_timestamp,\n impersonation,\n ip,\n new_record,\n original_tenant,\n previous_record,\n tenant,\n timestamp_usecs,\n user_name\n)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n api_group = dictionary.get('apiGroup')\n api_version = dictionary.get('apiVersion')\n kind = dictionary.get('kind')\n name = dictionary.get('name')\n namespace = dictionary.get('namespace')\n resource_version = dictionary.get('resourceVersion')\n uid = dictionary.get('uid')\n\n # Return an object of this model\n return cls(\n api_group,\n api_version,\n kind,\n name,\n namespace,\n resource_version,\n uid\n)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n id = dictionary.get('id')\r\n consumer_id = dictionary.get('consumerId')\r\n consumer_ssn = dictionary.get('consumerSsn')\r\n requester_name = dictionary.get('requesterName')\r\n request_id = dictionary.get('requestId')\r\n constraints = finicityapi.models.report_constraints.ReportConstraints.from_dictionary(dictionary.get('constraints')) if dictionary.get('constraints') else None\r\n mtype = dictionary.get('type')\r\n status = dictionary.get('status')\r\n created_date = dictionary.get('createdDate')\r\n\r\n # Clean out expected properties from dictionary\r\n for key in cls._names.values():\r\n if key in dictionary:\r\n del dictionary[key]\r\n\r\n # Return an object of this model\r\n return cls(id,\r\n consumer_id,\r\n consumer_ssn,\r\n requester_name,\r\n request_id,\r\n constraints,\r\n mtype,\r\n status,\r\n created_date,\r\n dictionary)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n address = dictionary.get('address')\n port = dictionary.get('port')\n protocol = dictionary.get('protocol')\n is_cluster_auditing_enabled = dictionary.get('isClusterAuditingEnabled')\n is_data_protection_enabled = dictionary.get('isDataProtectionEnabled')\n is_filer_auditing_enabled = dictionary.get('isFilerAuditingEnabled')\n is_ssh_log_enabled = dictionary.get('isSshLogEnabled')\n name = dictionary.get('name')\n\n # Return an object of this model\n return cls(address,\n port,\n protocol,\n is_cluster_auditing_enabled,\n is_data_protection_enabled,\n is_filer_auditing_enabled,\n is_ssh_log_enabled,\n name)","def from_dictionary(cls,\r\n dictionary):\r\n if dictionary is None:\r\n return None\r\n\r\n # Extract variables from the dictionary\r\n enabled = dictionary.get('enabled')\r\n spare_serial = dictionary.get('spareSerial')\r\n uplink_mode = dictionary.get('uplinkMode')\r\n virtual_ip_1 = dictionary.get('virtualIp1')\r\n virtual_ip_2 = dictionary.get('virtualIp2')\r\n\r\n # Return an object of this model\r\n return cls(enabled,\r\n spare_serial,\r\n uplink_mode,\r\n virtual_ip_1,\r\n virtual_ip_2)","def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n access_token = dictionary.get('accessToken')\n token_type = dictionary.get('tokenType')\n error = cohesity_app_sdk.models.error.Error.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None\n\n # Return an object of this model\n return cls(access_token,\n token_type,\n error)"],"string":"[\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n id = dictionary.get('id')\\n name = dictionary.get('name')\\n mtype = dictionary.get('type')\\n usage_bytes = dictionary.get('usageBytes')\\n\\n # Return an object of this model\\n return cls(\\n id,\\n name,\\n mtype,\\n usage_bytes\\n)\",\n \"def create(cls, dictionary):\\n return cls(**dictionary)\",\n \"def create(cls, dictionary):\\n return cls(**dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n scheduling = meraki.models.scheduling_model.SchedulingModel.from_dictionary(dictionary.get('scheduling')) if dictionary.get('scheduling') else None\\r\\n bandwidth = meraki.models.bandwidth_model.BandwidthModel.from_dictionary(dictionary.get('bandwidth')) if dictionary.get('bandwidth') else None\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n scheduling,\\r\\n bandwidth,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n external_ids = dictionary.get('externalIds')\\r\\n harsh_accel_setting = dictionary.get('harsh_accel_setting')\\r\\n name = dictionary.get('name')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(external_ids,\\r\\n harsh_accel_setting,\\r\\n name)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n formatted_price = dictionary.get('FormattedPrice')\\n amount = dictionary.get('Amount')\\n currency_code = dictionary.get('CurrencyCode')\\n\\n # Return an object of this model\\n return cls(formatted_price,\\n amount,\\n currency_code)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('Id')\\r\\n name = dictionary.get('Name')\\r\\n last_edited = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"LastEdited\\\")).datetime if dictionary.get(\\\"LastEdited\\\") else None\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n name,\\r\\n last_edited,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n mtype = dictionary.get(\\\"type\\\")\\n filename = dictionary.get(\\\"filename\\\")\\n payload = dictionary.get(\\\"payload\\\")\\n\\n # Return an object of this model\\n return cls(mtype,\\n filename,\\n payload)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n protected_count = dictionary.get('protectedCount')\\n protected_size = dictionary.get('protectedSize')\\n unprotected_count = dictionary.get('unprotectedCount')\\n unprotected_size = dictionary.get('unprotectedSize')\\n\\n # Return an object of this model\\n return cls(\\n protected_count,\\n protected_size,\\n unprotected_count,\\n unprotected_size\\n)\",\n \"def from_dict(cls, dictionary: Dict[str, Any]):\\n return cls(**dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n primary_language = dictionary.get('PrimaryLanguage')\\r\\n secondary_language = dictionary.get('SecondaryLanguage')\\r\\n xml_signature = dictionary.get('XmlSignature')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(primary_language,\\r\\n secondary_language,\\r\\n xml_signature,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n number = dictionary.get('number')\\r\\n name = dictionary.get('name')\\r\\n balance = dictionary.get('balance')\\r\\n mtype = dictionary.get('type')\\r\\n status = dictionary.get('status')\\r\\n customer_id = dictionary.get('customerId')\\r\\n institution_id = dictionary.get('institutionId')\\r\\n balance_date = dictionary.get('balanceDate')\\r\\n created_date = dictionary.get('createdDate')\\r\\n currency = dictionary.get('currency')\\r\\n institution_login_id = dictionary.get('institutionLoginId')\\r\\n display_position = dictionary.get('displayPosition')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n number,\\r\\n name,\\r\\n balance,\\r\\n mtype,\\r\\n status,\\r\\n customer_id,\\r\\n institution_id,\\r\\n balance_date,\\r\\n created_date,\\r\\n currency,\\r\\n institution_login_id,\\r\\n display_position,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n links = dictionary.get('links')\\r\\n email_config = dictionary.get('emailConfig')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(links,\\r\\n email_config,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n alias = dictionary.get(\\\"alias\\\")\\r\\n cnam_lookups_enabled = dictionary.get(\\\"cnam_lookups_enabled\\\")\\r\\n number_type = dictionary.get(\\\"number_type\\\")\\r\\n rate_center = dictionary.get(\\\"rate_center\\\")\\r\\n state = dictionary.get(\\\"state\\\")\\r\\n value = dictionary.get(\\\"value\\\")\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(alias,\\r\\n cnam_lookups_enabled,\\r\\n number_type,\\r\\n rate_center,\\r\\n state,\\r\\n value)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n username = dictionary.get('username')\\r\\n first_name = dictionary.get('firstName')\\r\\n last_name = dictionary.get('lastName')\\r\\n application_id = dictionary.get('applicationId')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(username,\\r\\n first_name,\\r\\n last_name,\\r\\n application_id,\\r\\n dictionary)\",\n \"def from_dict(cls, data):\\n return cls(**data)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def _from_dict(cls, _dict):\\n return cls.from_dict(_dict)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n height = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Height')) if dictionary.get('Height') else None\\n length = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Length')) if dictionary.get('Length') else None\\n weight = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Weight')) if dictionary.get('Weight') else None\\n width = awsecommerceservice.models.decimal_with_units.DecimalWithUnits.from_dictionary(dictionary.get('Width')) if dictionary.get('Width') else None\\n\\n # Return an object of this model\\n return cls(height,\\n length,\\n weight,\\n width)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n setup = idfy_rest_client.models.setup.Setup.from_dictionary(dictionary.get('setup')) if dictionary.get('setup') else None\\r\\n merge_fields = dictionary.get('mergeFields')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(setup,\\r\\n merge_fields,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n to = dictionary.get('to')\\r\\n application_id = dictionary.get('applicationId')\\r\\n expiration_time_in_minutes = dictionary.get('expirationTimeInMinutes')\\r\\n code = dictionary.get('code')\\r\\n scope = dictionary.get('scope')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(to,\\r\\n application_id,\\r\\n expiration_time_in_minutes,\\r\\n code,\\r\\n scope)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n fqdn = dictionary.get('fqdn')\\n guid = dictionary.get('guid')\\n id = dictionary.get('id')\\n name = dictionary.get('name')\\n owner_id = dictionary.get('ownerId')\\n status = dictionary.get('status')\\n total_size_bytes = dictionary.get('totalSizeBytes')\\n\\n # Return an object of this model\\n return cls(\\n fqdn,\\n guid,\\n id,\\n name,\\n owner_id,\\n status,\\n total_size_bytes\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n force_delete = dictionary.get('forceDelete')\\n id = dictionary.get('id')\\n include_marked_for_removal = dictionary.get('includeMarkedForRemoval')\\n retry = dictionary.get('retry')\\n\\n # Return an object of this model\\n return cls(\\n force_delete,\\n id,\\n include_marked_for_removal,\\n retry\\n)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n account_holder_name = dictionary.get('accountHolderName')\\r\\n routing_number = dictionary.get('routingNumber')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(account_holder_name,\\r\\n routing_number)\",\n \"def from_dict(cls, d):\\n return cls(**d)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n ephemeral_public_key = dictionary.get('ephemeral_public_key')\\r\\n public_key_hash = dictionary.get('public_key_hash')\\r\\n transaction_id = dictionary.get('transaction_id')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(ephemeral_public_key,\\r\\n public_key_hash,\\r\\n transaction_id)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n given_name = dictionary.get('givenName')\\r\\n middle_name = dictionary.get('middleName')\\r\\n family_name = dictionary.get('familyName')\\r\\n address = None\\r\\n if dictionary.get('address') != None:\\r\\n address = list()\\r\\n for structure in dictionary.get('address'):\\r\\n address.append(finicityapi.models.payroll_address.PayrollAddress.from_dictionary(structure))\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n given_name,\\r\\n middle_name,\\r\\n family_name,\\r\\n address,\\r\\n dictionary)\",\n \"def from_dict(cls, dct):\\n return cls(**dct)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n mor_item = dictionary.get('morItem')\\n mor_type = dictionary.get('morType')\\n uuid = dictionary.get('uuid')\\n\\n # Return an object of this model\\n return cls(\\n mor_item,\\n mor_type,\\n uuid\\n)\",\n \"def from_dict(cls, data: Dict[str, any]):\\n return cls(**data)\",\n \"def from_dict(cls, session: \\\"FigoSession\\\", data_dict: dict) -> \\\"ModelBase\\\":\\n return cls(session, **data_dict)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n wind_speed = dictionary.get('windSpeed')\\n power = dictionary.get('power')\\n\\n # Return an object of this model\\n return cls(wind_speed,\\n power)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n consumer_id = dictionary.get('consumerId')\\r\\n consumer_ssn = dictionary.get('consumerSsn')\\r\\n event_name = dictionary.get('eventName')\\r\\n id = dictionary.get('id')\\r\\n status = dictionary.get('status')\\r\\n mtype = dictionary.get('type')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(consumer_id,\\r\\n consumer_ssn,\\r\\n event_name,\\r\\n id,\\r\\n status,\\r\\n mtype,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n account_id = dictionary.get('AccountId')\\r\\n name = dictionary.get('Name')\\r\\n org_no = dictionary.get('OrgNo')\\r\\n uni_customer_no = dictionary.get('UniCustomerNo')\\r\\n created = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"Created\\\")).datetime if dictionary.get(\\\"Created\\\") else None\\r\\n last_modified = APIHelper.RFC3339DateTime.from_value(dictionary.get(\\\"LastModified\\\")).datetime if dictionary.get(\\\"LastModified\\\") else None\\r\\n dealer_id = dictionary.get('DealerId')\\r\\n dealer_name = dictionary.get('DealerName')\\r\\n dealer_reference = dictionary.get('DealerReference')\\r\\n enabled = dictionary.get('Enabled')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(account_id,\\r\\n name,\\r\\n org_no,\\r\\n uni_customer_no,\\r\\n created,\\r\\n last_modified,\\r\\n dealer_id,\\r\\n dealer_name,\\r\\n dealer_reference,\\r\\n enabled,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n title = dictionary.get('title')\\r\\n device_group = dictionary.get('deviceGroup')\\r\\n create_on = dictionary.get('createOn')\\r\\n update_on = dictionary.get('updateOn')\\r\\n created_by = dictionary.get('createdBy')\\r\\n create_on_persian_date = dictionary.get('createOnPersianDate')\\r\\n update_on_persian_date = dictionary.get('updateOnPersianDate')\\r\\n device_type_brand_model_title = dictionary.get('deviceTypeBrandModelTitle')\\r\\n device_brand_ids = dictionary.get('deviceBrandIds')\\r\\n device_type_id = dictionary.get('deviceTypeId')\\r\\n device_brand_id = dictionary.get('deviceBrandId')\\r\\n updated_by = dictionary.get('updatedBy')\\r\\n device_type_title = dictionary.get('deviceTypeTitle')\\r\\n device_brand_title = dictionary.get('deviceBrandTitle')\\r\\n device_brands_title = dictionary.get('deviceBrandsTitle')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n title,\\r\\n device_group,\\r\\n create_on,\\r\\n update_on,\\r\\n created_by,\\r\\n create_on_persian_date,\\r\\n update_on_persian_date,\\r\\n device_type_brand_model_title,\\r\\n device_brand_ids,\\r\\n device_type_id,\\r\\n device_brand_id,\\r\\n updated_by,\\r\\n device_type_title,\\r\\n device_brand_title,\\r\\n device_brands_title)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n password = dictionary.get('password')\\r\\n name = dictionary.get('name')\\r\\n tag_ids = dictionary.get('tagIds')\\r\\n eld_adverse_weather_exemption_enabled = dictionary.get('eldAdverseWeatherExemptionEnabled')\\r\\n eld_big_day_exemption_enabled = dictionary.get('eldBigDayExemptionEnabled')\\r\\n eld_day_start_hour = dictionary.get('eldDayStartHour')\\r\\n eld_exempt = dictionary.get('eldExempt')\\r\\n eld_exempt_reason = dictionary.get('eldExemptReason')\\r\\n eld_pc_enabled = dictionary.get(\\\"eldPcEnabled\\\") if dictionary.get(\\\"eldPcEnabled\\\") else False\\r\\n eld_ym_enabled = dictionary.get(\\\"eldYmEnabled\\\") if dictionary.get(\\\"eldYmEnabled\\\") else False\\r\\n external_ids = dictionary.get('externalIds')\\r\\n group_id = dictionary.get('groupId')\\r\\n license_number = dictionary.get('licenseNumber')\\r\\n license_state = dictionary.get('licenseState')\\r\\n notes = dictionary.get('notes')\\r\\n phone = dictionary.get('phone')\\r\\n username = dictionary.get('username')\\r\\n vehicle_id = dictionary.get('vehicleId')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(password,\\r\\n name,\\r\\n tag_ids,\\r\\n eld_adverse_weather_exemption_enabled,\\r\\n eld_big_day_exemption_enabled,\\r\\n eld_day_start_hour,\\r\\n eld_exempt,\\r\\n eld_exempt_reason,\\r\\n eld_pc_enabled,\\r\\n eld_ym_enabled,\\r\\n external_ids,\\r\\n group_id,\\r\\n license_number,\\r\\n license_state,\\r\\n notes,\\r\\n phone,\\r\\n username,\\r\\n vehicle_id)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n env_type = dictionary.get('envType')\\n protected_count = dictionary.get('protectedCount')\\n protected_size_bytes = dictionary.get('protectedSizeBytes')\\n unprotected_count = dictionary.get('unprotectedCount')\\n unprotected_size_bytes = dictionary.get('unprotectedSizeBytes')\\n\\n # Return an object of this model\\n return cls(\\n env_type,\\n protected_count,\\n protected_size_bytes,\\n unprotected_count,\\n unprotected_size_bytes\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n is_mail_enabled = dictionary.get('isMailEnabled')\\n is_security_enabled = dictionary.get('isSecurityEnabled')\\n member_count = dictionary.get('memberCount')\\n visibility = dictionary.get('visibility')\\n\\n # Return an object of this model\\n return cls(\\n is_mail_enabled,\\n is_security_enabled,\\n member_count,\\n visibility\\n)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n time_zone = dictionary.get('timeZone')\\r\\n tags = dictionary.get('tags')\\r\\n disable_my_meraki_com = dictionary.get('disableMyMerakiCom')\\r\\n disable_remote_status_page = dictionary.get('disableRemoteStatusPage')\\r\\n enrollment_string = dictionary.get('enrollmentString')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n time_zone,\\r\\n tags,\\r\\n disable_my_meraki_com,\\r\\n disable_remote_status_page,\\r\\n enrollment_string)\",\n \"def from_dict(cls, dictionary):\\n normalised = cls.normalise_dict(dictionary)\\n return cls.from_normalised_dict(normalised)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n name = dictionary.get('name')\\r\\n lan_ip = dictionary.get('lanIp')\\r\\n uplink = dictionary.get('uplink')\\r\\n public_port = dictionary.get('publicPort')\\r\\n local_port = dictionary.get('localPort')\\r\\n allowed_ips = dictionary.get('allowedIps')\\r\\n protocol = dictionary.get('protocol')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(name,\\r\\n lan_ip,\\r\\n uplink,\\r\\n public_port,\\r\\n local_port,\\r\\n allowed_ips,\\r\\n protocol)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n found = dictionary.get('found')\\r\\n displaying = dictionary.get('displaying')\\r\\n more_available = dictionary.get('moreAvailable')\\r\\n created_date = dictionary.get('createdDate')\\r\\n institutions = None\\r\\n if dictionary.get('institutions') != None:\\r\\n institutions = list()\\r\\n for structure in dictionary.get('institutions'):\\r\\n institutions.append(finicityapi.models.institution.Institution.from_dictionary(structure))\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(found,\\r\\n displaying,\\r\\n more_available,\\r\\n created_date,\\r\\n institutions,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n backup_file_path = dictionary.get('backupFilePath')\\n excluded_file_paths = dictionary.get(\\\"excludedFilePaths\\\")\\n skip_nested_volumes = dictionary.get('skipNestedVolumes')\\n\\n # Return an object of this model\\n return cls(\\n backup_file_path,\\n excluded_file_paths,\\n skip_nested_volumes\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n lowest_new_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestNewPrice')) if dictionary.get('LowestNewPrice') else None\\n lowest_used_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestUsedPrice')) if dictionary.get('LowestUsedPrice') else None\\n lowest_collectible_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestCollectiblePrice')) if dictionary.get('LowestCollectiblePrice') else None\\n lowest_refurbished_price = awsecommerceservice.models.price.Price.from_dictionary(dictionary.get('LowestRefurbishedPrice')) if dictionary.get('LowestRefurbishedPrice') else None\\n total_new = dictionary.get('TotalNew')\\n total_used = dictionary.get('TotalUsed')\\n total_collectible = dictionary.get('TotalCollectible')\\n total_refurbished = dictionary.get('TotalRefurbished')\\n\\n # Return an object of this model\\n return cls(lowest_new_price,\\n lowest_used_price,\\n lowest_collectible_price,\\n lowest_refurbished_price,\\n total_new,\\n total_used,\\n total_collectible,\\n total_refurbished)\",\n \"def from_dict(cls, data):\\r\\n instance = cls()\\r\\n for key, value in data.items():\\r\\n instance.__dict__[key] = value\\r\\n return instance\",\n \"def from_dict(cls, dictionary):\\n instance = cls()\\n for key, value in dictionary.items():\\n instance.__dict__[key] = value\\n\\n return instance\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n door_closed = dictionary.get('doorClosed')\\r\\n id = dictionary.get('id')\\r\\n name = dictionary.get('name')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(door_closed,\\r\\n id,\\r\\n name)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n id = dictionary.get('id')\\n provider_id = dictionary.get('providerId')\\n server_time = dictionary.get('serverTime')\\n username = dictionary.get('username')\\n driver_license_number = dictionary.get('driverLicenseNumber')\\n country = dictionary.get('country')\\n region = dictionary.get('region')\\n driver_home_terminal = dictionary.get('driverHomeTerminal')\\n\\n # Return an object of this model\\n return cls(id,\\n provider_id,\\n server_time,\\n username,\\n driver_license_number,\\n country,\\n region,\\n driver_home_terminal)\",\n \"def from_dict(cls, data):\\n instance = cls()\\n instance._set_data(data)\\n return instance\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n is_group_site = dictionary.get('isGroupSite')\\n is_private_channel_site = dictionary.get('isPrivateChannelSite')\\n is_team_site = dictionary.get('isTeamSite')\\n\\n # Return an object of this model\\n return cls(\\n is_group_site,\\n is_private_channel_site,\\n is_team_site\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n id = dictionary.get('id')\\n provider_id = dictionary.get('providerId')\\n server_time = dictionary.get('serverTime')\\n active_from = dictionary.get('activeFrom')\\n active_to = dictionary.get('activeTo')\\n rpm_over_value = dictionary.get('rpmOverValue')\\n over_speed_value = dictionary.get('overSpeedValue')\\n excess_speed_value = dictionary.get('excessSpeedValue')\\n long_idle_value = dictionary.get('longIdleValue')\\n hi_throttle_value = dictionary.get('hiThrottleValue')\\n\\n # Return an object of this model\\n return cls(id,\\n provider_id,\\n server_time,\\n active_from,\\n active_to,\\n rpm_over_value,\\n over_speed_value,\\n excess_speed_value,\\n long_idle_value,\\n hi_throttle_value)\",\n \"def from_dict(cls, dikt) -> 'ModelClass':\\n return util.deserialize_model(dikt, cls)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n action = dictionary.get('action')\\n cluster_info = dictionary.get('clusterInfo')\\n details = dictionary.get('details')\\n domain = dictionary.get('domain')\\n entity_id = dictionary.get('entityId')\\n entity_name = dictionary.get('entityName')\\n entity_type = dictionary.get('entityType')\\n human_timestamp = dictionary.get('humanTimestamp')\\n impersonation = dictionary.get('impersonation')\\n ip = dictionary.get('ip')\\n new_record = dictionary.get('newRecord')\\n original_tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('originalTenant')) if dictionary.get('originalTenant') else None\\n previous_record = dictionary.get('previousRecord')\\n tenant = cohesity_management_sdk.models.tenant.Tenant.from_dictionary(dictionary.get('tenant')) if dictionary.get('tenant') else None\\n timestamp_usecs = dictionary.get('timestampUsecs')\\n user_name = dictionary.get('userName')\\n\\n # Return an object of this model\\n return cls(\\n action,\\n cluster_info,\\n details,\\n domain,\\n entity_id,\\n entity_name,\\n entity_type,\\n human_timestamp,\\n impersonation,\\n ip,\\n new_record,\\n original_tenant,\\n previous_record,\\n tenant,\\n timestamp_usecs,\\n user_name\\n)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n api_group = dictionary.get('apiGroup')\\n api_version = dictionary.get('apiVersion')\\n kind = dictionary.get('kind')\\n name = dictionary.get('name')\\n namespace = dictionary.get('namespace')\\n resource_version = dictionary.get('resourceVersion')\\n uid = dictionary.get('uid')\\n\\n # Return an object of this model\\n return cls(\\n api_group,\\n api_version,\\n kind,\\n name,\\n namespace,\\n resource_version,\\n uid\\n)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n id = dictionary.get('id')\\r\\n consumer_id = dictionary.get('consumerId')\\r\\n consumer_ssn = dictionary.get('consumerSsn')\\r\\n requester_name = dictionary.get('requesterName')\\r\\n request_id = dictionary.get('requestId')\\r\\n constraints = finicityapi.models.report_constraints.ReportConstraints.from_dictionary(dictionary.get('constraints')) if dictionary.get('constraints') else None\\r\\n mtype = dictionary.get('type')\\r\\n status = dictionary.get('status')\\r\\n created_date = dictionary.get('createdDate')\\r\\n\\r\\n # Clean out expected properties from dictionary\\r\\n for key in cls._names.values():\\r\\n if key in dictionary:\\r\\n del dictionary[key]\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(id,\\r\\n consumer_id,\\r\\n consumer_ssn,\\r\\n requester_name,\\r\\n request_id,\\r\\n constraints,\\r\\n mtype,\\r\\n status,\\r\\n created_date,\\r\\n dictionary)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n address = dictionary.get('address')\\n port = dictionary.get('port')\\n protocol = dictionary.get('protocol')\\n is_cluster_auditing_enabled = dictionary.get('isClusterAuditingEnabled')\\n is_data_protection_enabled = dictionary.get('isDataProtectionEnabled')\\n is_filer_auditing_enabled = dictionary.get('isFilerAuditingEnabled')\\n is_ssh_log_enabled = dictionary.get('isSshLogEnabled')\\n name = dictionary.get('name')\\n\\n # Return an object of this model\\n return cls(address,\\n port,\\n protocol,\\n is_cluster_auditing_enabled,\\n is_data_protection_enabled,\\n is_filer_auditing_enabled,\\n is_ssh_log_enabled,\\n name)\",\n \"def from_dictionary(cls,\\r\\n dictionary):\\r\\n if dictionary is None:\\r\\n return None\\r\\n\\r\\n # Extract variables from the dictionary\\r\\n enabled = dictionary.get('enabled')\\r\\n spare_serial = dictionary.get('spareSerial')\\r\\n uplink_mode = dictionary.get('uplinkMode')\\r\\n virtual_ip_1 = dictionary.get('virtualIp1')\\r\\n virtual_ip_2 = dictionary.get('virtualIp2')\\r\\n\\r\\n # Return an object of this model\\r\\n return cls(enabled,\\r\\n spare_serial,\\r\\n uplink_mode,\\r\\n virtual_ip_1,\\r\\n virtual_ip_2)\",\n \"def from_dictionary(cls,\\n dictionary):\\n if dictionary is None:\\n return None\\n\\n # Extract variables from the dictionary\\n access_token = dictionary.get('accessToken')\\n token_type = dictionary.get('tokenType')\\n error = cohesity_app_sdk.models.error.Error.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None\\n\\n # Return an object of this model\\n return cls(access_token,\\n token_type,\\n error)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83181584","0.8168118","0.8168118","0.8118749","0.8089047","0.79787344","0.7949278","0.79231393","0.7898951","0.78923255","0.788838","0.7882321","0.7882212","0.7876749","0.78585315","0.7836853","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.7801407","0.778169","0.7777758","0.77596736","0.7742912","0.77341646","0.7705121","0.7696183","0.76809496","0.7670297","0.7663996","0.76603854","0.7657914","0.76517224","0.76302916","0.7602739","0.7593293","0.7592748","0.759","0.7589917","0.7579973","0.7566604","0.75653","0.7563392","0.74963725","0.7491968","0.74903727","0.74877626","0.74833405","0.746709","0.74645287","0.74627846","0.7456073","0.74542487","0.7447277","0.74081016","0.7400107","0.7390997","0.7387449","0.7384797","0.7370505"],"string":"[\n \"0.83181584\",\n \"0.8168118\",\n \"0.8168118\",\n \"0.8118749\",\n \"0.8089047\",\n \"0.79787344\",\n \"0.7949278\",\n \"0.79231393\",\n \"0.7898951\",\n \"0.78923255\",\n \"0.788838\",\n \"0.7882321\",\n \"0.7882212\",\n \"0.7876749\",\n \"0.78585315\",\n \"0.7836853\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.7801407\",\n \"0.778169\",\n \"0.7777758\",\n \"0.77596736\",\n \"0.7742912\",\n \"0.77341646\",\n \"0.7705121\",\n \"0.7696183\",\n \"0.76809496\",\n \"0.7670297\",\n \"0.7663996\",\n \"0.76603854\",\n \"0.7657914\",\n \"0.76517224\",\n \"0.76302916\",\n \"0.7602739\",\n \"0.7593293\",\n \"0.7592748\",\n \"0.759\",\n \"0.7589917\",\n \"0.7579973\",\n \"0.7566604\",\n \"0.75653\",\n \"0.7563392\",\n \"0.74963725\",\n \"0.7491968\",\n \"0.74903727\",\n \"0.74877626\",\n \"0.74833405\",\n \"0.746709\",\n \"0.74645287\",\n \"0.74627846\",\n \"0.7456073\",\n \"0.74542487\",\n \"0.7447277\",\n \"0.74081016\",\n \"0.7400107\",\n \"0.7390997\",\n \"0.7387449\",\n \"0.7384797\",\n \"0.7370505\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":23597,"cells":{"query":{"kind":"string","value":"Test login with 2SA."},"document":{"kind":"string","value":"def test_login_2sa(self):\n dsm_7 = SynologyDSMMock(\n VALID_HOST,\n VALID_PORT,\n VALID_USER_2SA,\n VALID_PASSWORD,\n VALID_HTTPS,\n VALID_VERIFY_SSL,\n )\n dsm_7.dsm_version = 7\n with pytest.raises(SynologyDSMLogin2SARequiredException) as error:\n dsm_7.login()\n error_value = error.value.args[0]\n assert error_value[\"api\"] == \"SYNO.API.Auth\"\n assert error_value[\"code\"] == 403\n assert error_value[\"reason\"] == \"One time password not specified\"\n assert (\n error_value[\"details\"]\n == \"Two-step authentication required for account: valid_user_2sa\"\n )\n\n assert dsm_7.login(VALID_OTP)\n\n assert dsm_7._session_id == SESSION_ID\n assert dsm_7._syno_token == SYNO_TOKEN\n assert dsm_7._device_token == DEVICE_TOKEN\n assert dsm_7.device_token == DEVICE_TOKEN"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_login_2sa_new_session(self):\n dsm_7 = SynologyDSMMock(\n VALID_HOST,\n VALID_PORT,\n VALID_USER_2SA,\n VALID_PASSWORD,\n VALID_HTTPS,\n VALID_VERIFY_SSL,\n device_token=DEVICE_TOKEN,\n )\n dsm_7.dsm_version = 7\n assert dsm_7.login()\n\n assert dsm_7._session_id == SESSION_ID\n assert dsm_7._syno_token == SYNO_TOKEN\n assert dsm_7._device_token == DEVICE_TOKEN\n assert dsm_7.device_token == DEVICE_TOKEN","def test_aio_can_login_to_web_portal(aio):","def login():","def login():","def test_successful_login(self):\n pass","def test_login(self):\n self._configure_testshib_provider()\n self._test_login()","def test_activate_login(self):\r\n pass","def test_basic_login(self):\n c = Client()\n c.login(username='a', password='123456')","def login(self):","async def test_login(self):\n params = {\n 'VCA_HOST': os.getenv('VCA_HOST', '127.0.0.1'),\n 'VCA_PORT': os.getenv('VCA_PORT', 17070),\n 'VCA_USER': os.getenv('VCA_USER', 'admin'),\n 'VCA_SECRET': os.getenv('VCA_SECRET', 'admin'),\n 'VCA_CHARMS': os.getenv('VCA_CHARMS', None),\n 'VCA_PUBLIC_KEY': os.getenv('VCA_PUBLIC_KEY', None),\n 'VCA_CACERT': os.getenv('VCA_CACERT', \"invalidcacert\"),\n }\n\n client = self.get_n2vc(params)\n\n await client.login()\n assert client.authenticated\n\n await client.logout()\n assert client.authenticated is False","def test_regular_user_login(self):\n self.login(\"user\", \"user\")\n self.should_see(\"This is your profile, user.\")","def test_login(self):\n\n print('\\n\\nEnter a valid LendingClub account information...')\n email = input('Email:')\n password = getpass.getpass()\n\n self.assertTrue(self.session.authenticate(email, password))\n print('Authentication successful')","def test_valid_login(self):\n self.assertTrue(self.session.authenticate('test@test.com', 'supersecret'))","def login():\n pass","def test_02_account_login(self):\n self.login(email='test@test2.com', password='Abcd@1234')\n self.assertEquals(\n self.selenium.current_url, self.get_absolute_url())\n print 'valid login test completed'","def test_login(self):\n\n client = Client('username', 'password')\n self.setSessionResponse(200)\n try:\n client.authenticate()\n except Exception as e:\n self.fail(\"Exception raised : \" + str(e))","def test_login():\n My.search_merchant_page(driver, My.Testing_Env_EN)\n validate_login()\n print('----------')\n My.search_merchant_page(driver, My.Testing_Env_FR)\n validate_login()\n driver.quit()","def test_login(self):\n self.driver.find_element_by_link_text(\"Sign in\").click()\n self.driver.find_element_by_id(\"email\").send_keys(\"devsoftbol@gmail.com\")\n self.driver.find_element_by_id(\"passwd\").send_keys(\"control123\")\n self.driver.find_element_by_id(\"SubmitLogin\").click()\n time.sleep(5)","def test_professor_can_login_to_web_portal(professor):","def test_login(self):\n self.user_api()\n self.base.metadata.create_all(self.engine)\n people = self.provision_users()\n p = {'__action': 'login', 'id': people[0].id, 'password': \"testing\"}\n self.post('user', 200, params=p)","def test_start_new_verification(self):\r\n user = UserFactory.create(username=\"rusty\", password=\"test\")\r\n self.client.login(username=\"rusty\", password=\"test\")","def test_login_OK(self):\n rv = self.login('super',\n '1b3231655cebb7a1f783eddf27d254ca')\n assert 'Bienvenido' in rv.data","def login(self):\n\t\treturn","def test_sucessful_login(self):\n self.user.list_of_accounts = [{'username': 'dalton',\n 'pwd': 'chromelegend',\n 'email': 'legionless@yahoo.com'}]\n msg = self.user.login(\"legionless@yahoo.com\", \"chromelegend\")\n self.assertEqual(msg, \"Success!\")","def test_030_login_as_user(self):\n\n testflow.step(LOG_USR_MSG, TEST_USER1)\n users.loginAsUser(\n TEST_USER1,\n config.INTERNAL_PROFILE,\n self.user_password,\n True,\n )\n\n testflow.step(TST_CON_MSG, TEST_USER1)\n assert connectionTest(), \"User '%s' can't login\" % TEST_USER1","def do_login(self, backend, user):","def test_admin_can_login_to_web_portal(admin):","def test_login(self):\n url_extend = 'user_auth/login/'\n self.browser.get(self.url + url_extend)\n\n # enter the username and password.\n username_field = self.browser.find_element_by_name('user_name')\n username_field.send_keys('user4')\n password_field = self.browser.find_element_by_name('password')\n password_field.send_keys('user')\n\n # click login button.\n # get the first input button under the first form in login page.\n login_button = self.browser.find_element_by_xpath(\"//form[1]/fieldset[1]/input[@type='submit']\")\n try:\n login_button.click()\n except:\n raise Exception(\"Login Error!\")","def test_031_login_as_exp_pwd_user(self):\n\n testflow.step(LOG_USR_MSG, TEST_USER2)\n users.loginAsUser(\n TEST_USER2,\n config.INTERNAL_PROFILE,\n self.user_password,\n True,\n )\n\n testflow.step(TST_CON_MSG, TEST_USER2)\n assert not connectionTest(), \"User '%s' can login\" % TEST_USER2","def testGaiaLogin(self):\n if self._is_guest:\n return\n try:\n username, password = next(self._GetCredentialsIter())\n except StopIteration:\n username = 'autotest.catapult'\n password = 'autotest'\n with self._CreateBrowser(gaia_login=True,\n username=oobe.Oobe.Canonicalize(username),\n password=password):\n self.assertTrue(py_utils.WaitFor(self._IsCryptohomeMounted, 10))","def test_successful_login(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n rv = self.login('Bo_theo5@example.com', 'Bo1995')\n self.assertIn(b'You are now logged in', rv.data)","def testLoginTwice(self):\n self.assertEquals(models.SUCCESS, self.users.add(\"userG2\", \"password\"))\n self.assertEquals(self.users.login(\"userG2\", \"password\"), 2)\n self.assertEquals(self.users.login(\"userG2\", \"password\"), 3)","def login_user():\n pass","def login(self):\n self.client.login(username=self.user.username, password='test')","def test_login(self):\n\n with self.client as c:\n result = c.post('/login',\n data={'email': 'cat@gmail.com', 'password': 'abc'},\n follow_redirects=True\n )\n self.assertEqual(session['user_id'], 1)\n self.assertIn(\"You are logged in\", result.data)\n\n print \"DONE WITH LOGIN CHECK\"","def test_login_post_with_2fa(self, *_):\n view = views.Login.as_view()\n form = forms.LoginForm()\n form.data[\"localname\"] = \"badger\"\n form.data[\"password\"] = \"password\"\n request = self.factory.post(\"\", form.data)\n request.user = self.anonymous_user\n middleware = SessionMiddleware(request)\n middleware.process_request(request)\n request.session.save()\n\n with patch(\"bookwyrm.views.landing.login.login\"):\n result = view(request)\n self.assertEqual(result.url, \"/2fa-check\")\n self.assertEqual(result.status_code, 302)","def test_m19bqj_236(setup):\n tiger_obj = Tiger(browser_name=browser_name)\n tiger_obj.login(username=username, password=password)","def test_admin_user_login(self):\n self.login(\"admin\", \"admin\")\n self.should_see(\"This is your profile, admin.\")","def test_ucs_log_in(self):\n api_data = request(\"get\", \"/login\")\n self.assertEqual(api_data['status'], 200,\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\n self.assertNotEqual(api_data[\"json\"], None,\n \"Expected a token to be returned on login and received None\")\n self.assertNotEqual(type(api_data[\"json\"]),\n \"unicode\", \"Unexpected Token was received on Login\")","def test_0000_initiate_users(self):\n self.login(email=common.test_user_1_email, username=common.test_user_1_name)\n self.login(email=common.admin_email, username=common.admin_username)\n self.galaxy_login(email=common.admin_email, username=common.admin_username)","def test_login_required():\n pass","def check_login(self):\n # read token first\n user_data = self.storage.get_user_data(self.user_id)\n if not \"token\" in user_data:\n sys.exit(\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\")\n\n # check token\n token = user_data[\"token\"]\n url = self.host_address + \"/assist/authentication\"\n payload = {\n 'action' : \"check\",\n 'client' : self.client_info,\n 'KEY' : (self.user_id + \";\" + token)\n }\n headers = {\n 'Content-Type': \"application/json\"\n }\n response = requests.request(\"POST\", url, json=payload, headers=headers)\n try:\n res = json.loads(response.text)\n except NameError:\n res = None\n\n if res[\"result\"] and res[\"result\"] == \"success\":\n name = res[\"user_name\"][\"nick\"] or res[\"user_name\"][\"first\"]\n print(\"SEPIA account: Success - Wb \" + name + \", your login token is still valid.\")\n else:\n print(\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\")","def test_logging_running(self):\n tester = app.test_client(self)\n response = tester.get('/login', content_type='html/text')\n self.assertTrue(b'PLEASE LOGIN' in response.data)","def login_bot(self):\n pass","def test_exception_shib_login(self):\r\n no_remote_user_request = self.request_factory.get('/shib-login')\r\n no_remote_user_request.META.update({'Shib-Identity-Provider': IDP})\r\n no_remote_user_response = shib_login(no_remote_user_request)\r\n self.assertEqual(no_remote_user_response.status_code, 403)\r\n self.assertIn(\"identity server did not return your ID information\", no_remote_user_response.content)\r\n\r\n no_idp_request = self.request_factory.get('/shib-login')\r\n no_idp_request.META.update({'REMOTE_USER': REMOTE_USER})\r\n no_idp_response = shib_login(no_idp_request)\r\n self.assertEqual(no_idp_response.status_code, 403)\r\n self.assertIn(\"identity server did not return your ID information\", no_idp_response.content)","def test_open_id_setup(self):\r\n self.attempt_login(200)","def test_agentpi_login(self):\n param = {\n 'username' : \"seth\", \n 'password' : \"testing\"\n }\n response = param\n\n self.assertEqual(response.text, \"User Exists\")","def test_01_authenticated(self):\r\n res = self.signin(email=self.email_addr, password=self.password)\r\n res = self.app.get(self.url, follow_redirects=True)\r\n dom = BeautifulSoup(res.data)\r\n err_msg = \"The CKAN exporter should be available for the owner of the app\"\r\n assert dom.find(id=\"ckan\") is not None, err_msg\r\n\r\n self.signout()\r\n\r\n self.signin(email=self.email_addr2, password=self.password)\r\n res = self.app.get(self.url, follow_redirects=True)\r\n dom = BeautifulSoup(res.data)\r\n err_msg = \"The CKAN exporter should be ONLY available for the owner of the app\"\r\n assert dom.find(id=\"ckan\") is None, err_msg","def test_login_successful():\n user_info = {\"password\": \"abc123\", \"username\": \"0450539776\",}\n response = requests.get(\"http://127.0.0.1:7700/login\", params=user_info)\n assert(response.status_code == 200)\n assert(\"token\" in response.json())","def login(self):\n driver = self.selenium_test.driver\n driver.get(self.selenium_test.get_server_url())\n self.selenium_test.wait_fn(self.preenche_username)\n driver.find_element_by_id('btnlogin').click()\n self.selenium_test.wait_to_be_logged_in()","def test_login_endpoint_not_verbose():\n url = f\"{DEXCOM_BASE_URL}/{DEXCOM_LOGIN_ENDPOINT}\"\n json = {\n \"accountName\": USERNAME,\n \"password\": \"a\",\n \"applicationId\": DEXCOM_APPLICATION_ID,\n }\n r = requests.request(\"post\", url, json=json,)\n assert r.json() == DEFAULT_SESSION_ID","def test_login(self, mock):\n _setup_responses(mock)\n api = LiveStreamApi(\"user\", \"pass\")\n\n api.login()\n\n with self.subTest(\"stores the token on the api object\"):\n self.assertEqual(api._token, \"ffffffffffffffffffffffffffffffffffffffff\")\n\n with self.subTest(\"stores ssesyranac cookie on the api object\"):\n self.assertEqual(api._ssesyranac, \"ssesyranac\")","def loginAsManager(self):\n self.browser.open('http://nohost/plone/')\n self.browser.getLink('Log in').click()\n self.browser.getControl('Login Name').value = 'root'\n self.browser.getControl('Password').value = 'secret'\n self.browser.getControl('Log in').click()","def test_login_post_no_2fa_set(self, *_):\n view = views.Login.as_view()\n form = forms.LoginForm()\n form.data[\"localname\"] = \"rat\"\n form.data[\"password\"] = \"password\"\n request = self.factory.post(\"\", form.data)\n request.user = self.anonymous_user\n\n with patch(\"bookwyrm.views.landing.login.login\"):\n result = view(request)\n self.assertEqual(result.url, \"/2fa-prompt\")\n self.assertEqual(result.status_code, 302)","def login(self, returnToURL):\r\n\t\tif not self.request().hasValue('userId') or \\\r\n\t\t\tnot self.request().hasValue('password'):\r\n\t\t\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\r\n\t\t\treturn 0\r\n\t\treturn 1","def test_login(self):\n res = self.client.get(\"/login\")\n data = res.data.decode(\"utf-8\")\n assert res.status == \"200 OK\"\n assert \"Already a member!\" in data","def test_short_password_login(self):\n with self.client:\n response = login_user(self, 'joe@gmail.com', 'aA111')\n data = json.loads(response.data.decode())\n self.assertTrue(data['status'] == 'fail')\n self.assertTrue(data['message'] == 'Validation errors.')\n self.assertTrue(response.content_type == 'application/json')\n self.assertEqual(response.status_code, 422)","def test_auth_code_positive(self, api):\n self.builder.add_user(api.get_user())\n resp = api.login_user(api.get_user().username, api.get_user().password)\n self.builder.del_user(api.get_user())\n assert resp.status_code == 200","def test_voluntary_login(self):\n # Going to the login form voluntarily:\n resp = self.app.get('/login', status=200)\n form = resp.form\n # Submitting the login form:\n form['login'] = 'manager'\n form['password'] = 'managepass'\n post_login = form.submit(status=302)\n # Being redirected to the home page:\n ok_(post_login.location.startswith('http://localhost/post_login'))\n home_page = post_login.follow(status=302)\n ok_('authtkt' in home_page.request.cookies,\n 'Session cookie was not defined: %s' % home_page.request.cookies)\n eq_(home_page.location, 'http://localhost/')","def test_profile_secure_login(self):\n response = self.client.get('/profile/')\n self.assertEqual(response.status_code, 302)","def test_non_user_login(self):\n self.user.list_of_accounts = [{'username': 'Parseen',\n 'pwd': 'mypassword',\n 'email': 'david.parseen@yahoo.com'}]\n msg = self.user.login(\"nonuser@yahoo.com\", \"idontevenhaveone\")\n self.assertEqual(msg, \"Account not registered, sign up\")","def test_student_login(self):\n # Test classic login\n post = {'username_or_email': 'student@test.com', 'password': '1234'}\n response = self.client.post(self.signin_url, post)\n self.assertRedirects(response, reverse('home'))\n # Test login with next page\n response = self.client.post(\n self.signin_url + '?next=' + self.student.get_homework_url(),\n post)\n self.assertRedirects(response, self.student.get_homework_url())\n # Logout View\n response = self.client.get(reverse('users:logout'))\n self.assertRedirects(response, reverse('home'))\n # Try access homework page not logged in\n response = self.client.get(self.student.get_homework_url())\n redirect_url = self.signin_url + '?next=' + self.student.get_homework_url()\n self.assertRedirects(response, redirect_url)","def test_login_twice(self):\n self.client.login(username=self.USERNAME, password=self.PASSWORD)\n username2 = \"two\"\n password2 = \"two\"\n user2 = User.objects.create_user(username=username2, password=password2)\n UserInfo.objects.create(user=user2)\n\n resp = self.client.post(\n reverse('login'),\n json.dumps({\n \"username\": username2,\n \"password\": username2,\n }),\n content_type=\"application/json\"\n )\n assert resp.status_code == 200, resp.content.decode('utf-8')\n assert self.is_authenticated(user2)","def test_auth_success(self):\n request = self.factory.get(resolve('/'))\n response = Login.as_view()(request)\n self.assertEqual(response.status_code, 200)\n data = {\n 'username': 'pravin.gordhan',\n 'password': 'pravin.gordhan'\n }\n request = self.factory.post(resolve('/'), data)\n request.session = self.client.session\n response = Login.as_view()(request)\n self.assertEqual(response.url, '/employee/dashboard/')","def test_login(self):\n\t\tdata = {'username' : 'testUser2', 'password' : 'passTestUser'}\n\t\tresponse = self.login(data)\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\ttry:\n\t\t\ttoken = response.data[\"token\"]\n\t\texcept AttributeError:\n\t\t\tself.fail(\"No token attribute\")","async def test_validate_login(hass: HomeAssistant, provider, capsys) -> None:\n data = provider.data\n data.add_auth(\"test-user\", \"test-pass\")\n\n await script_auth.validate_login(\n hass, provider, Mock(username=\"test-user\", password=\"test-pass\")\n )\n captured = capsys.readouterr()\n assert captured.out == \"Auth valid\\n\"\n\n await script_auth.validate_login(\n hass, provider, Mock(username=\"test-user\", password=\"invalid-pass\")\n )\n captured = capsys.readouterr()\n assert captured.out == \"Auth invalid\\n\"\n\n await script_auth.validate_login(\n hass, provider, Mock(username=\"invalid-user\", password=\"test-pass\")\n )\n captured = capsys.readouterr()\n assert captured.out == \"Auth invalid\\n\"","def test_login(self):\n response = self.client.get(reverse(\"myhome:login\"), follow=True)\n loginresponse = self.client.login(username='user', password='123456')\n self.assertEqual(response.status_code, 200)\n self.assertTrue(loginresponse)","def test_user_login(app):\n login_res = app.post('/auth', data={\n 'email': 'tracy.tim@cognizant.com',\n 'password': 'password'\n },content_type='application/json') \n assert login_res.status_code == 200","def test_ssl_login_without_signup_lms(self):\r\n\r\n external_auth.views.ssl_login(self._create_ssl_request('/'))\r\n\r\n # Assert our user exists in both eamap and Users, and that we are logged in\r\n try:\r\n ExternalAuthMap.objects.get(external_id=self.USER_EMAIL)\r\n except ExternalAuthMap.DoesNotExist, ex:\r\n self.fail('User did not get properly added to external auth map, exception was {0}'.format(str(ex)))\r\n try:\r\n User.objects.get(email=self.USER_EMAIL)\r\n except ExternalAuthMap.DoesNotExist, ex:\r\n self.fail('User did not get properly added to internal users, exception was {0}'.format(str(ex)))","def login(self):\n # the login url is just api, not api2\n url = 'https://simple-note.appspot.com/api/login'\n query = {'email': self.email, 'password': self.password}\n data = base64.b64encode(urllib.urlencode(query))\n try:\n fh = urllib2.urlopen(url, data)\n self.authtok = fh.read()\n except urllib2.HTTPError, e:\n # Received a non 2xx status code\n raise SimplenoteError('http error: {}'.format(e.code))\n except urllib2.URLError, e:\n # Non http error, like network issue\n raise SimplenoteError('url error: {}'.format(e.reason))\n fh.close()\n return True","def login_luis():\n browser.get(\"https://eu.luis.ai\")\n WebDriverWait(browser, 5).until(EC.element_to_be_clickable((By.LINK_TEXT, \"Sign in\")))\n browser.find_element_by_link_text('Sign in').click()\n WebDriverWait(browser, 5).until(EC.element_to_be_clickable((By.ID, \"idSIButton9\")))\n browser.find_element_by_id('i0116').send_keys(config.username)\n browser.find_element_by_id('idSIButton9').click()\n WebDriverWait(browser, 5).until(EC.element_to_be_clickable((By.ID, \"idSIButton9\")))\n browser.find_element_by_id('i0118').send_keys(config.password)\n browser.find_element_by_id('idSIButton9').click()","def login(self):\n self.open(base_url + '/login')\n self.type(\"#email\", test_user.email)\n self.type(\"#password\", test_user.password)\n self.click('input[type=\"submit\"]')","def login(self):\n return self.client.login(username='Georgie', password='12345678')","def test_login():\n headers = {}\n data = {\"role\": args.k8s_namespace, \"jwt\": args.k8s_sa_jwt}\n url = \"{0}/auth/{1}/login\".format(args.vault_url, args.k8s_cluster_name)\n print \"Testing login to confirm that the integration is working\"\n req = send_post(url=url, data=data, headers=headers, return_output=True)\n if str(req.status_code).startswith('2'):\n print 'SUCCESS! Login request returned {0} {1}'.format(req.status_code, req.reason)\n else:\n print 'FAIL! {0} {1} {2}'.format(req.status_code, req.reason, req.content)\n exit(77)","def test001_authenticate_user(self):\n self.lg('%s STARTED' % self._testID)\n\n self.lg('- Create user1 with admin access ')\n old_password = str(uuid.uuid4()).replace('-', '')[0:10]\n user1 = self.cloudbroker_user_create(group='admin', password=old_password)\n\n self.lg(\"- Authenticate U1 ,should return session key[user1_key] .\")\n user1_key = self.get_authenticated_user_api(username=user1, password=old_password)\n self.assertTrue(user1_key)\n\n self.lg(\"- Use U1's key to list the accounts for U1, should succeed.\")\n accounts_list = user1_key.cloudapi.accounts.list()\n self.assertEqual(accounts_list, [])","def login_test(self):\n\n log.info(\"Testing login server...\")\n status = \"\"\n note = \"\"\n\n try:\n response = self._login(acc_config['username'], acc_config['password'])\n status = \"Up\"\n note = \"Login server is OK.\"\n except MasterServerError, e:\n status = \"Down\"\n note = e.error\n \n db.execute(\"\"\"UPDATE servers SET status = %s, time = %s, note = %s WHERE id = 1 \"\"\", [1 if status == \"Up\" else 0, time.time(), note])\n return status, note","def logUserIn(self):\n self.browser.get(self.live_server_url)\n self.browser.get(self.live_server_url + reverse('registration:auth_login').rstrip())\n self.assertIn(\n 'login',\n self.browser.current_url\n )\n self.browser.find_element_by_name('username').send_keys(TEST_USER['username'])\n self.browser.find_element_by_id('id_password').send_keys(TEST_USER['password'])\n self.browser.find_element_by_id('submit-login').click()","def login(self):\n login_form = {\"kid\": \"\",\n \"uni\": self.server,\n \"login\": self.username,\n \"pass\": self.password}\n url = \"https://%s.ogame.gameforge.com/main/login\" % self.country_code\n result = self.session.post(url, data=login_form)","def test_adtls(self):\n for domain in config.ADW2K12_DOMAINS:\n principal = '%s@%s' % (config.ADW2k12_USER1, domain)\n\n testflow.step(\"Login as user %s\", config.ADW2k12_USER1)\n users.loginAsUser(\n principal,\n self.conf['authn_name'],\n config.ADW2k12_USER_PASSWORD,\n True,\n )\n\n testflow.step(\n \"Testing connection with user %s\", config.ADW2k12_USER1\n )\n assert common.connectionTest(), \"User %s can't login.\" % principal","def test_https(self):\n r = self.r.post('/users/login',\n {'next': 'https://su.mo.com/kb/new?f=b'})\n eq_('/kb/new?f=b', get_next_url(r))","def login(userID, robotID, password): #@NoSelf","def test_login_to_youtube(self):\n\n # Finding elements on the page and actions.\n self.wait_clickable_by_css(\n \"#buttons a > .style-scope.ytd-button-renderer\"\n \".style-suggestive.size-small[role='button']\"\n ).click()\n self.wait_clickable_by_id(\"identifierId\").send_keys(config.USER1[\"email\"])\n self.wait_clickable_by_id(\"identifierNext\").click()\n self.wait_invisibility_by_id(\"identifierId\")\n self.wait_clickable_by_css(\".whsOnd.zHQkBf\").send_keys(config.USER1[\"password\"])\n self.wait_clickable_by_id(\"passwordNext\").click()\n\n try:\n self.wait_clickable_by_css(\".ZFr60d.CeoRYc\").click()\n\n except:\n\n pass\n\n # Waiting for button to appear.\n self.wait_visibility_by_css(\"#avatar-btn\")\n self.make_screenshot()\n print(\"Test 1: User is successfully logged in.\")","def test_shred_login():\n assert_redirect_to_login('/shred/')\n assert_not_redirect_to_login('/shred/')","def _log_into_shib( self, driver ):\n driver.find_element_by_id(\"username\").clear()\n driver.find_element_by_id(\"username\").send_keys( self.USERNAME )\n driver.find_element_by_id(\"password\").clear()\n driver.find_element_by_id(\"password\").send_keys( self.PASSWORD )\n driver.find_element_by_css_selector(\"button[type=\\\"submit\\\"]\").click()\n return driver","def testSignOutAndSignBackIn(self):\n self.host.ContinueAuth()\n self.host.SignIn(self.account['username'], self.account['password'])\n self.host.AllowAccess()\n self.host.SignOut()\n self.host.ContinueAuth()\n self.host.AllowAccess()","def login_to_system(credentials):\n return True if credentials else False","def test_login_logout(self):\n\n rv = login(self.client, app.config['USERNAME'], app.config['PASSWORD'])\n self.assertTrue(b'Play' in rv.data)\n\n rv = logout(self.client)\n self.assertTrue(b'Sign In' in rv.data)\n\n rv = login(self.client, app.config['USERNAME'] + 'x', app.config['PASSWORD'])\n self.assertTrue(b'Invalid username or password' in rv.data)\n\n rv = login(self.client, app.config['USERNAME'], app.config['PASSWORD'] + 'x')\n self.assertTrue(b'Invalid username or password' in rv.data)","def _login(self,user,password=\"testpassword\"):\n self.client.logout()\n if user is None:\n return #just log out\n success = self.client.login(username=user.username,password=password)\n self.assertTrue(success, \"could not log in as user %s using password %s\"\n % (user.username,password)) \n return success","def test_login_POST_2(self):\r\n\r\n User.signup(username='testuser2',\r\n password=\"PASSWORD\", location=\"US-FL\")\r\n db.session.commit()\r\n with app.app_context():\r\n form = UserLoginForm(username='testuser2',\r\n password='WRONG_PASSWORD')\r\n with self.client:\r\n response = self.client.post(\r\n '/login', data=form.data, follow_redirects=True)\r\n self.assertIn(b'Invalid credentials.', response.data)","def test_can_login(self):\n user = authenticate(username='jack', password='secret')\n self.assertTrue(user is not None)\n self.assertTrue(user.is_authenticated)","def test_correct_login(self):\n self.app.post('/register', data=self.user_reg_details)\n res = self.app.post('/login', data=self.user_login_details)\n self.assertEqual(res.status_code, 200)\n self.assertIn(\"Successfully logged in\", str(res.data))","def login(self):\n url = 'https://ngb.to/login.php?do=login'\n\n params = {'do': 'login'}\n payload = {'vb_login_username': self.username,\n 'vb_login_password': self.password,\n 'url': \"index.php\",\n 'do': \"login\",\n 'vb_login_md5password': \"\",\n 'vb_login_md5password_utf': \"\",\n 's': \"\",\n 'securitytoken': \"guest\",\n 'cookieuser': \"1\"}\n\n self.session.post(url, data=payload, params=params)","def test_two_factor(app, client):\n data = dict(email=\"dude@lp.com\", password=\"password\", password_confirm=\"password\")\n response = client.post(\"/register\", data=data, follow_redirects=False)\n assert \"tf-setup\" in response.location\n\n # make sure not logged in\n response = client.get(\"/profile\")\n assert response.status_code == 302\n assert \"/login?next=%2Fprofile\" in response.location","def authenticate(self):\n\n # Choose a random user agent string from the most popular\n agent_strings = [\n 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36',\n 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36',\n 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36'\n ]\n headers = {'User-Agent': choice(agent_strings)}\n\n # Spin up a requests session\n with requests.Session() as s:\n s.headers.update(headers)\n\n login_page = s.get('https://alta.registries.gov.ab.ca/SpinII/').content\n soup = BeautifulSoup(login_page, 'html.parser')\n\n login_payload = {\n 'uctrlFullHeader:ShutdownAlert1:Hidden1':'',\n 'uctrlFullHeader:ShutdownAlert1:Hidden2':'',\n 'JavascriptEnabled':1,\n 'uctrlLogon:txtLogonName':'',\n 'uctrlLogon:txtPassword':'',\n 'uctrlLogon:cmdLogonGuest.x':59,\n 'uctrlLogon:cmdLogonGuest.y':26\n }\n login_payload['__EVENTTARGET'] = soup.select_one('#__EVENTTARGET')['value']\n login_payload['__EVENTARGUMENT'] = soup.select_one('#__EVENTARGUMENT')['value']\n login_payload['__VIEWSTATE'] = soup.select_one('#__VIEWSTATE')['value']\n\n sleep(2)\n legal_notice_page = s.post('https://alta.registries.gov.ab.ca/SpinII/logon.aspx', \\\n data=login_payload).content\n soup = BeautifulSoup(legal_notice_page, 'html.parser')\n\n login_payload['__VIEWSTATE'] = soup.select_one('#__VIEWSTATE')['value']\n login_payload['cmdYES.x'] = 55\n login_payload['cmdYES.y'] = 12\n del login_payload['__EVENTARGUMENT']\n del login_payload['__EVENTTARGET']\n\n sleep(2)\n confirm_guest_page = s.post('https://alta.registries.gov.ab.ca/SpinII/legalnotice.aspx', \\\n data=login_payload).content\n soup = BeautifulSoup(confirm_guest_page, 'html.parser')\n\n if len(soup.find_all(text='You are logged on as a Guest.')) > 0:\n return s","def test_signin_functionality(self):\n res = self.client.post('/signin',\n follow_redirects=True, data=dict(\n username='orange',\n password='123Orange',\n ))\n data = res.data.decode('utf-8')\n assert 'Profile' in data\n assert 'Username: orange' in data\n assert res.status == '200 OK'","def test_login_logout(self):\n rv = self.login(closet.app.config['USERNAME'],\n closet.app.config['PASSWORD'])\n assert b'You were logged in' in rv.data\n rv = self.logout()\n assert b'You were logged out' in rv.data\n rv = self.login(closet.app.config['USERNAME'] + 'x',\n closet.app.config['PASSWORD'])\n assert b'Invalid username' in rv.data\n rv = self.login(closet.app.config['USERNAME'],\n closet.app.config['PASSWORD'] + 'x')\n assert b'Invalid password' in rv.data","def test_login_to_shoplists(self):\n tester = app.test_client(self)\n response = tester.post('/login', follow_redirects=True)\n self.assertEqual(response.status_code, 200)","def test_correct_login(self):\n with self.client:\n response = self.client.post(\n '/users/login',\n data=dict(username=\"eschoppik\", password=\"secret\"),\n follow_redirects=True\n )\n self.assertIn(b'Welcome', response.data)\n self.assertTrue(current_user.username == \"eschoppik\")\n self.assertTrue(current_user.is_authenticated)","def test_login(self):\n # Signup a user\n response = self.client.post('/api/v1/auth/signup',\n data=json.dumps(self.new_user2),\n content_type='application/json')\n self.assertEqual(response.status_code, 201)\n\n # Test user login\n response = self.client.post('/api/v1/auth/login',\n data=json.dumps(self.login_details),\n content_type='application/json')\n self.assertEqual(response.status_code, 200)","def test_authentication_success():\n d = Dexcom(USERNAME, PASSWORD)\n d._validate_account()\n d._validate_session_id()"],"string":"[\n \"def test_login_2sa_new_session(self):\\n dsm_7 = SynologyDSMMock(\\n VALID_HOST,\\n VALID_PORT,\\n VALID_USER_2SA,\\n VALID_PASSWORD,\\n VALID_HTTPS,\\n VALID_VERIFY_SSL,\\n device_token=DEVICE_TOKEN,\\n )\\n dsm_7.dsm_version = 7\\n assert dsm_7.login()\\n\\n assert dsm_7._session_id == SESSION_ID\\n assert dsm_7._syno_token == SYNO_TOKEN\\n assert dsm_7._device_token == DEVICE_TOKEN\\n assert dsm_7.device_token == DEVICE_TOKEN\",\n \"def test_aio_can_login_to_web_portal(aio):\",\n \"def login():\",\n \"def login():\",\n \"def test_successful_login(self):\\n pass\",\n \"def test_login(self):\\n self._configure_testshib_provider()\\n self._test_login()\",\n \"def test_activate_login(self):\\r\\n pass\",\n \"def test_basic_login(self):\\n c = Client()\\n c.login(username='a', password='123456')\",\n \"def login(self):\",\n \"async def test_login(self):\\n params = {\\n 'VCA_HOST': os.getenv('VCA_HOST', '127.0.0.1'),\\n 'VCA_PORT': os.getenv('VCA_PORT', 17070),\\n 'VCA_USER': os.getenv('VCA_USER', 'admin'),\\n 'VCA_SECRET': os.getenv('VCA_SECRET', 'admin'),\\n 'VCA_CHARMS': os.getenv('VCA_CHARMS', None),\\n 'VCA_PUBLIC_KEY': os.getenv('VCA_PUBLIC_KEY', None),\\n 'VCA_CACERT': os.getenv('VCA_CACERT', \\\"invalidcacert\\\"),\\n }\\n\\n client = self.get_n2vc(params)\\n\\n await client.login()\\n assert client.authenticated\\n\\n await client.logout()\\n assert client.authenticated is False\",\n \"def test_regular_user_login(self):\\n self.login(\\\"user\\\", \\\"user\\\")\\n self.should_see(\\\"This is your profile, user.\\\")\",\n \"def test_login(self):\\n\\n print('\\\\n\\\\nEnter a valid LendingClub account information...')\\n email = input('Email:')\\n password = getpass.getpass()\\n\\n self.assertTrue(self.session.authenticate(email, password))\\n print('Authentication successful')\",\n \"def test_valid_login(self):\\n self.assertTrue(self.session.authenticate('test@test.com', 'supersecret'))\",\n \"def login():\\n pass\",\n \"def test_02_account_login(self):\\n self.login(email='test@test2.com', password='Abcd@1234')\\n self.assertEquals(\\n self.selenium.current_url, self.get_absolute_url())\\n print 'valid login test completed'\",\n \"def test_login(self):\\n\\n client = Client('username', 'password')\\n self.setSessionResponse(200)\\n try:\\n client.authenticate()\\n except Exception as e:\\n self.fail(\\\"Exception raised : \\\" + str(e))\",\n \"def test_login():\\n My.search_merchant_page(driver, My.Testing_Env_EN)\\n validate_login()\\n print('----------')\\n My.search_merchant_page(driver, My.Testing_Env_FR)\\n validate_login()\\n driver.quit()\",\n \"def test_login(self):\\n self.driver.find_element_by_link_text(\\\"Sign in\\\").click()\\n self.driver.find_element_by_id(\\\"email\\\").send_keys(\\\"devsoftbol@gmail.com\\\")\\n self.driver.find_element_by_id(\\\"passwd\\\").send_keys(\\\"control123\\\")\\n self.driver.find_element_by_id(\\\"SubmitLogin\\\").click()\\n time.sleep(5)\",\n \"def test_professor_can_login_to_web_portal(professor):\",\n \"def test_login(self):\\n self.user_api()\\n self.base.metadata.create_all(self.engine)\\n people = self.provision_users()\\n p = {'__action': 'login', 'id': people[0].id, 'password': \\\"testing\\\"}\\n self.post('user', 200, params=p)\",\n \"def test_start_new_verification(self):\\r\\n user = UserFactory.create(username=\\\"rusty\\\", password=\\\"test\\\")\\r\\n self.client.login(username=\\\"rusty\\\", password=\\\"test\\\")\",\n \"def test_login_OK(self):\\n rv = self.login('super',\\n '1b3231655cebb7a1f783eddf27d254ca')\\n assert 'Bienvenido' in rv.data\",\n \"def login(self):\\n\\t\\treturn\",\n \"def test_sucessful_login(self):\\n self.user.list_of_accounts = [{'username': 'dalton',\\n 'pwd': 'chromelegend',\\n 'email': 'legionless@yahoo.com'}]\\n msg = self.user.login(\\\"legionless@yahoo.com\\\", \\\"chromelegend\\\")\\n self.assertEqual(msg, \\\"Success!\\\")\",\n \"def test_030_login_as_user(self):\\n\\n testflow.step(LOG_USR_MSG, TEST_USER1)\\n users.loginAsUser(\\n TEST_USER1,\\n config.INTERNAL_PROFILE,\\n self.user_password,\\n True,\\n )\\n\\n testflow.step(TST_CON_MSG, TEST_USER1)\\n assert connectionTest(), \\\"User '%s' can't login\\\" % TEST_USER1\",\n \"def do_login(self, backend, user):\",\n \"def test_admin_can_login_to_web_portal(admin):\",\n \"def test_login(self):\\n url_extend = 'user_auth/login/'\\n self.browser.get(self.url + url_extend)\\n\\n # enter the username and password.\\n username_field = self.browser.find_element_by_name('user_name')\\n username_field.send_keys('user4')\\n password_field = self.browser.find_element_by_name('password')\\n password_field.send_keys('user')\\n\\n # click login button.\\n # get the first input button under the first form in login page.\\n login_button = self.browser.find_element_by_xpath(\\\"//form[1]/fieldset[1]/input[@type='submit']\\\")\\n try:\\n login_button.click()\\n except:\\n raise Exception(\\\"Login Error!\\\")\",\n \"def test_031_login_as_exp_pwd_user(self):\\n\\n testflow.step(LOG_USR_MSG, TEST_USER2)\\n users.loginAsUser(\\n TEST_USER2,\\n config.INTERNAL_PROFILE,\\n self.user_password,\\n True,\\n )\\n\\n testflow.step(TST_CON_MSG, TEST_USER2)\\n assert not connectionTest(), \\\"User '%s' can login\\\" % TEST_USER2\",\n \"def testGaiaLogin(self):\\n if self._is_guest:\\n return\\n try:\\n username, password = next(self._GetCredentialsIter())\\n except StopIteration:\\n username = 'autotest.catapult'\\n password = 'autotest'\\n with self._CreateBrowser(gaia_login=True,\\n username=oobe.Oobe.Canonicalize(username),\\n password=password):\\n self.assertTrue(py_utils.WaitFor(self._IsCryptohomeMounted, 10))\",\n \"def test_successful_login(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n rv = self.login('Bo_theo5@example.com', 'Bo1995')\\n self.assertIn(b'You are now logged in', rv.data)\",\n \"def testLoginTwice(self):\\n self.assertEquals(models.SUCCESS, self.users.add(\\\"userG2\\\", \\\"password\\\"))\\n self.assertEquals(self.users.login(\\\"userG2\\\", \\\"password\\\"), 2)\\n self.assertEquals(self.users.login(\\\"userG2\\\", \\\"password\\\"), 3)\",\n \"def login_user():\\n pass\",\n \"def login(self):\\n self.client.login(username=self.user.username, password='test')\",\n \"def test_login(self):\\n\\n with self.client as c:\\n result = c.post('/login',\\n data={'email': 'cat@gmail.com', 'password': 'abc'},\\n follow_redirects=True\\n )\\n self.assertEqual(session['user_id'], 1)\\n self.assertIn(\\\"You are logged in\\\", result.data)\\n\\n print \\\"DONE WITH LOGIN CHECK\\\"\",\n \"def test_login_post_with_2fa(self, *_):\\n view = views.Login.as_view()\\n form = forms.LoginForm()\\n form.data[\\\"localname\\\"] = \\\"badger\\\"\\n form.data[\\\"password\\\"] = \\\"password\\\"\\n request = self.factory.post(\\\"\\\", form.data)\\n request.user = self.anonymous_user\\n middleware = SessionMiddleware(request)\\n middleware.process_request(request)\\n request.session.save()\\n\\n with patch(\\\"bookwyrm.views.landing.login.login\\\"):\\n result = view(request)\\n self.assertEqual(result.url, \\\"/2fa-check\\\")\\n self.assertEqual(result.status_code, 302)\",\n \"def test_m19bqj_236(setup):\\n tiger_obj = Tiger(browser_name=browser_name)\\n tiger_obj.login(username=username, password=password)\",\n \"def test_admin_user_login(self):\\n self.login(\\\"admin\\\", \\\"admin\\\")\\n self.should_see(\\\"This is your profile, admin.\\\")\",\n \"def test_ucs_log_in(self):\\n api_data = request(\\\"get\\\", \\\"/login\\\")\\n self.assertEqual(api_data['status'], 200,\\n 'Incorrect HTTP return code, expected 200, got:' + str(api_data['status']))\\n self.assertNotEqual(api_data[\\\"json\\\"], None,\\n \\\"Expected a token to be returned on login and received None\\\")\\n self.assertNotEqual(type(api_data[\\\"json\\\"]),\\n \\\"unicode\\\", \\\"Unexpected Token was received on Login\\\")\",\n \"def test_0000_initiate_users(self):\\n self.login(email=common.test_user_1_email, username=common.test_user_1_name)\\n self.login(email=common.admin_email, username=common.admin_username)\\n self.galaxy_login(email=common.admin_email, username=common.admin_username)\",\n \"def test_login_required():\\n pass\",\n \"def check_login(self):\\n # read token first\\n user_data = self.storage.get_user_data(self.user_id)\\n if not \\\"token\\\" in user_data:\\n sys.exit(\\\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\\\")\\n\\n # check token\\n token = user_data[\\\"token\\\"]\\n url = self.host_address + \\\"/assist/authentication\\\"\\n payload = {\\n 'action' : \\\"check\\\",\\n 'client' : self.client_info,\\n 'KEY' : (self.user_id + \\\";\\\" + token)\\n }\\n headers = {\\n 'Content-Type': \\\"application/json\\\"\\n }\\n response = requests.request(\\\"POST\\\", url, json=payload, headers=headers)\\n try:\\n res = json.loads(response.text)\\n except NameError:\\n res = None\\n\\n if res[\\\"result\\\"] and res[\\\"result\\\"] == \\\"success\\\":\\n name = res[\\\"user_name\\\"][\\\"nick\\\"] or res[\\\"user_name\\\"][\\\"first\\\"]\\n print(\\\"SEPIA account: Success - Wb \\\" + name + \\\", your login token is still valid.\\\")\\n else:\\n print(\\\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\\\")\",\n \"def test_logging_running(self):\\n tester = app.test_client(self)\\n response = tester.get('/login', content_type='html/text')\\n self.assertTrue(b'PLEASE LOGIN' in response.data)\",\n \"def login_bot(self):\\n pass\",\n \"def test_exception_shib_login(self):\\r\\n no_remote_user_request = self.request_factory.get('/shib-login')\\r\\n no_remote_user_request.META.update({'Shib-Identity-Provider': IDP})\\r\\n no_remote_user_response = shib_login(no_remote_user_request)\\r\\n self.assertEqual(no_remote_user_response.status_code, 403)\\r\\n self.assertIn(\\\"identity server did not return your ID information\\\", no_remote_user_response.content)\\r\\n\\r\\n no_idp_request = self.request_factory.get('/shib-login')\\r\\n no_idp_request.META.update({'REMOTE_USER': REMOTE_USER})\\r\\n no_idp_response = shib_login(no_idp_request)\\r\\n self.assertEqual(no_idp_response.status_code, 403)\\r\\n self.assertIn(\\\"identity server did not return your ID information\\\", no_idp_response.content)\",\n \"def test_open_id_setup(self):\\r\\n self.attempt_login(200)\",\n \"def test_agentpi_login(self):\\n param = {\\n 'username' : \\\"seth\\\", \\n 'password' : \\\"testing\\\"\\n }\\n response = param\\n\\n self.assertEqual(response.text, \\\"User Exists\\\")\",\n \"def test_01_authenticated(self):\\r\\n res = self.signin(email=self.email_addr, password=self.password)\\r\\n res = self.app.get(self.url, follow_redirects=True)\\r\\n dom = BeautifulSoup(res.data)\\r\\n err_msg = \\\"The CKAN exporter should be available for the owner of the app\\\"\\r\\n assert dom.find(id=\\\"ckan\\\") is not None, err_msg\\r\\n\\r\\n self.signout()\\r\\n\\r\\n self.signin(email=self.email_addr2, password=self.password)\\r\\n res = self.app.get(self.url, follow_redirects=True)\\r\\n dom = BeautifulSoup(res.data)\\r\\n err_msg = \\\"The CKAN exporter should be ONLY available for the owner of the app\\\"\\r\\n assert dom.find(id=\\\"ckan\\\") is None, err_msg\",\n \"def test_login_successful():\\n user_info = {\\\"password\\\": \\\"abc123\\\", \\\"username\\\": \\\"0450539776\\\",}\\n response = requests.get(\\\"http://127.0.0.1:7700/login\\\", params=user_info)\\n assert(response.status_code == 200)\\n assert(\\\"token\\\" in response.json())\",\n \"def login(self):\\n driver = self.selenium_test.driver\\n driver.get(self.selenium_test.get_server_url())\\n self.selenium_test.wait_fn(self.preenche_username)\\n driver.find_element_by_id('btnlogin').click()\\n self.selenium_test.wait_to_be_logged_in()\",\n \"def test_login_endpoint_not_verbose():\\n url = f\\\"{DEXCOM_BASE_URL}/{DEXCOM_LOGIN_ENDPOINT}\\\"\\n json = {\\n \\\"accountName\\\": USERNAME,\\n \\\"password\\\": \\\"a\\\",\\n \\\"applicationId\\\": DEXCOM_APPLICATION_ID,\\n }\\n r = requests.request(\\\"post\\\", url, json=json,)\\n assert r.json() == DEFAULT_SESSION_ID\",\n \"def test_login(self, mock):\\n _setup_responses(mock)\\n api = LiveStreamApi(\\\"user\\\", \\\"pass\\\")\\n\\n api.login()\\n\\n with self.subTest(\\\"stores the token on the api object\\\"):\\n self.assertEqual(api._token, \\\"ffffffffffffffffffffffffffffffffffffffff\\\")\\n\\n with self.subTest(\\\"stores ssesyranac cookie on the api object\\\"):\\n self.assertEqual(api._ssesyranac, \\\"ssesyranac\\\")\",\n \"def loginAsManager(self):\\n self.browser.open('http://nohost/plone/')\\n self.browser.getLink('Log in').click()\\n self.browser.getControl('Login Name').value = 'root'\\n self.browser.getControl('Password').value = 'secret'\\n self.browser.getControl('Log in').click()\",\n \"def test_login_post_no_2fa_set(self, *_):\\n view = views.Login.as_view()\\n form = forms.LoginForm()\\n form.data[\\\"localname\\\"] = \\\"rat\\\"\\n form.data[\\\"password\\\"] = \\\"password\\\"\\n request = self.factory.post(\\\"\\\", form.data)\\n request.user = self.anonymous_user\\n\\n with patch(\\\"bookwyrm.views.landing.login.login\\\"):\\n result = view(request)\\n self.assertEqual(result.url, \\\"/2fa-prompt\\\")\\n self.assertEqual(result.status_code, 302)\",\n \"def login(self, returnToURL):\\r\\n\\t\\tif not self.request().hasValue('userId') or \\\\\\r\\n\\t\\t\\tnot self.request().hasValue('password'):\\r\\n\\t\\t\\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\\r\\n\\t\\t\\treturn 0\\r\\n\\t\\treturn 1\",\n \"def test_login(self):\\n res = self.client.get(\\\"/login\\\")\\n data = res.data.decode(\\\"utf-8\\\")\\n assert res.status == \\\"200 OK\\\"\\n assert \\\"Already a member!\\\" in data\",\n \"def test_short_password_login(self):\\n with self.client:\\n response = login_user(self, 'joe@gmail.com', 'aA111')\\n data = json.loads(response.data.decode())\\n self.assertTrue(data['status'] == 'fail')\\n self.assertTrue(data['message'] == 'Validation errors.')\\n self.assertTrue(response.content_type == 'application/json')\\n self.assertEqual(response.status_code, 422)\",\n \"def test_auth_code_positive(self, api):\\n self.builder.add_user(api.get_user())\\n resp = api.login_user(api.get_user().username, api.get_user().password)\\n self.builder.del_user(api.get_user())\\n assert resp.status_code == 200\",\n \"def test_voluntary_login(self):\\n # Going to the login form voluntarily:\\n resp = self.app.get('/login', status=200)\\n form = resp.form\\n # Submitting the login form:\\n form['login'] = 'manager'\\n form['password'] = 'managepass'\\n post_login = form.submit(status=302)\\n # Being redirected to the home page:\\n ok_(post_login.location.startswith('http://localhost/post_login'))\\n home_page = post_login.follow(status=302)\\n ok_('authtkt' in home_page.request.cookies,\\n 'Session cookie was not defined: %s' % home_page.request.cookies)\\n eq_(home_page.location, 'http://localhost/')\",\n \"def test_profile_secure_login(self):\\n response = self.client.get('/profile/')\\n self.assertEqual(response.status_code, 302)\",\n \"def test_non_user_login(self):\\n self.user.list_of_accounts = [{'username': 'Parseen',\\n 'pwd': 'mypassword',\\n 'email': 'david.parseen@yahoo.com'}]\\n msg = self.user.login(\\\"nonuser@yahoo.com\\\", \\\"idontevenhaveone\\\")\\n self.assertEqual(msg, \\\"Account not registered, sign up\\\")\",\n \"def test_student_login(self):\\n # Test classic login\\n post = {'username_or_email': 'student@test.com', 'password': '1234'}\\n response = self.client.post(self.signin_url, post)\\n self.assertRedirects(response, reverse('home'))\\n # Test login with next page\\n response = self.client.post(\\n self.signin_url + '?next=' + self.student.get_homework_url(),\\n post)\\n self.assertRedirects(response, self.student.get_homework_url())\\n # Logout View\\n response = self.client.get(reverse('users:logout'))\\n self.assertRedirects(response, reverse('home'))\\n # Try access homework page not logged in\\n response = self.client.get(self.student.get_homework_url())\\n redirect_url = self.signin_url + '?next=' + self.student.get_homework_url()\\n self.assertRedirects(response, redirect_url)\",\n \"def test_login_twice(self):\\n self.client.login(username=self.USERNAME, password=self.PASSWORD)\\n username2 = \\\"two\\\"\\n password2 = \\\"two\\\"\\n user2 = User.objects.create_user(username=username2, password=password2)\\n UserInfo.objects.create(user=user2)\\n\\n resp = self.client.post(\\n reverse('login'),\\n json.dumps({\\n \\\"username\\\": username2,\\n \\\"password\\\": username2,\\n }),\\n content_type=\\\"application/json\\\"\\n )\\n assert resp.status_code == 200, resp.content.decode('utf-8')\\n assert self.is_authenticated(user2)\",\n \"def test_auth_success(self):\\n request = self.factory.get(resolve('/'))\\n response = Login.as_view()(request)\\n self.assertEqual(response.status_code, 200)\\n data = {\\n 'username': 'pravin.gordhan',\\n 'password': 'pravin.gordhan'\\n }\\n request = self.factory.post(resolve('/'), data)\\n request.session = self.client.session\\n response = Login.as_view()(request)\\n self.assertEqual(response.url, '/employee/dashboard/')\",\n \"def test_login(self):\\n\\t\\tdata = {'username' : 'testUser2', 'password' : 'passTestUser'}\\n\\t\\tresponse = self.login(data)\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\ttry:\\n\\t\\t\\ttoken = response.data[\\\"token\\\"]\\n\\t\\texcept AttributeError:\\n\\t\\t\\tself.fail(\\\"No token attribute\\\")\",\n \"async def test_validate_login(hass: HomeAssistant, provider, capsys) -> None:\\n data = provider.data\\n data.add_auth(\\\"test-user\\\", \\\"test-pass\\\")\\n\\n await script_auth.validate_login(\\n hass, provider, Mock(username=\\\"test-user\\\", password=\\\"test-pass\\\")\\n )\\n captured = capsys.readouterr()\\n assert captured.out == \\\"Auth valid\\\\n\\\"\\n\\n await script_auth.validate_login(\\n hass, provider, Mock(username=\\\"test-user\\\", password=\\\"invalid-pass\\\")\\n )\\n captured = capsys.readouterr()\\n assert captured.out == \\\"Auth invalid\\\\n\\\"\\n\\n await script_auth.validate_login(\\n hass, provider, Mock(username=\\\"invalid-user\\\", password=\\\"test-pass\\\")\\n )\\n captured = capsys.readouterr()\\n assert captured.out == \\\"Auth invalid\\\\n\\\"\",\n \"def test_login(self):\\n response = self.client.get(reverse(\\\"myhome:login\\\"), follow=True)\\n loginresponse = self.client.login(username='user', password='123456')\\n self.assertEqual(response.status_code, 200)\\n self.assertTrue(loginresponse)\",\n \"def test_user_login(app):\\n login_res = app.post('/auth', data={\\n 'email': 'tracy.tim@cognizant.com',\\n 'password': 'password'\\n },content_type='application/json') \\n assert login_res.status_code == 200\",\n \"def test_ssl_login_without_signup_lms(self):\\r\\n\\r\\n external_auth.views.ssl_login(self._create_ssl_request('/'))\\r\\n\\r\\n # Assert our user exists in both eamap and Users, and that we are logged in\\r\\n try:\\r\\n ExternalAuthMap.objects.get(external_id=self.USER_EMAIL)\\r\\n except ExternalAuthMap.DoesNotExist, ex:\\r\\n self.fail('User did not get properly added to external auth map, exception was {0}'.format(str(ex)))\\r\\n try:\\r\\n User.objects.get(email=self.USER_EMAIL)\\r\\n except ExternalAuthMap.DoesNotExist, ex:\\r\\n self.fail('User did not get properly added to internal users, exception was {0}'.format(str(ex)))\",\n \"def login(self):\\n # the login url is just api, not api2\\n url = 'https://simple-note.appspot.com/api/login'\\n query = {'email': self.email, 'password': self.password}\\n data = base64.b64encode(urllib.urlencode(query))\\n try:\\n fh = urllib2.urlopen(url, data)\\n self.authtok = fh.read()\\n except urllib2.HTTPError, e:\\n # Received a non 2xx status code\\n raise SimplenoteError('http error: {}'.format(e.code))\\n except urllib2.URLError, e:\\n # Non http error, like network issue\\n raise SimplenoteError('url error: {}'.format(e.reason))\\n fh.close()\\n return True\",\n \"def login_luis():\\n browser.get(\\\"https://eu.luis.ai\\\")\\n WebDriverWait(browser, 5).until(EC.element_to_be_clickable((By.LINK_TEXT, \\\"Sign in\\\")))\\n browser.find_element_by_link_text('Sign in').click()\\n WebDriverWait(browser, 5).until(EC.element_to_be_clickable((By.ID, \\\"idSIButton9\\\")))\\n browser.find_element_by_id('i0116').send_keys(config.username)\\n browser.find_element_by_id('idSIButton9').click()\\n WebDriverWait(browser, 5).until(EC.element_to_be_clickable((By.ID, \\\"idSIButton9\\\")))\\n browser.find_element_by_id('i0118').send_keys(config.password)\\n browser.find_element_by_id('idSIButton9').click()\",\n \"def login(self):\\n self.open(base_url + '/login')\\n self.type(\\\"#email\\\", test_user.email)\\n self.type(\\\"#password\\\", test_user.password)\\n self.click('input[type=\\\"submit\\\"]')\",\n \"def login(self):\\n return self.client.login(username='Georgie', password='12345678')\",\n \"def test_login():\\n headers = {}\\n data = {\\\"role\\\": args.k8s_namespace, \\\"jwt\\\": args.k8s_sa_jwt}\\n url = \\\"{0}/auth/{1}/login\\\".format(args.vault_url, args.k8s_cluster_name)\\n print \\\"Testing login to confirm that the integration is working\\\"\\n req = send_post(url=url, data=data, headers=headers, return_output=True)\\n if str(req.status_code).startswith('2'):\\n print 'SUCCESS! Login request returned {0} {1}'.format(req.status_code, req.reason)\\n else:\\n print 'FAIL! {0} {1} {2}'.format(req.status_code, req.reason, req.content)\\n exit(77)\",\n \"def test001_authenticate_user(self):\\n self.lg('%s STARTED' % self._testID)\\n\\n self.lg('- Create user1 with admin access ')\\n old_password = str(uuid.uuid4()).replace('-', '')[0:10]\\n user1 = self.cloudbroker_user_create(group='admin', password=old_password)\\n\\n self.lg(\\\"- Authenticate U1 ,should return session key[user1_key] .\\\")\\n user1_key = self.get_authenticated_user_api(username=user1, password=old_password)\\n self.assertTrue(user1_key)\\n\\n self.lg(\\\"- Use U1's key to list the accounts for U1, should succeed.\\\")\\n accounts_list = user1_key.cloudapi.accounts.list()\\n self.assertEqual(accounts_list, [])\",\n \"def login_test(self):\\n\\n log.info(\\\"Testing login server...\\\")\\n status = \\\"\\\"\\n note = \\\"\\\"\\n\\n try:\\n response = self._login(acc_config['username'], acc_config['password'])\\n status = \\\"Up\\\"\\n note = \\\"Login server is OK.\\\"\\n except MasterServerError, e:\\n status = \\\"Down\\\"\\n note = e.error\\n \\n db.execute(\\\"\\\"\\\"UPDATE servers SET status = %s, time = %s, note = %s WHERE id = 1 \\\"\\\"\\\", [1 if status == \\\"Up\\\" else 0, time.time(), note])\\n return status, note\",\n \"def logUserIn(self):\\n self.browser.get(self.live_server_url)\\n self.browser.get(self.live_server_url + reverse('registration:auth_login').rstrip())\\n self.assertIn(\\n 'login',\\n self.browser.current_url\\n )\\n self.browser.find_element_by_name('username').send_keys(TEST_USER['username'])\\n self.browser.find_element_by_id('id_password').send_keys(TEST_USER['password'])\\n self.browser.find_element_by_id('submit-login').click()\",\n \"def login(self):\\n login_form = {\\\"kid\\\": \\\"\\\",\\n \\\"uni\\\": self.server,\\n \\\"login\\\": self.username,\\n \\\"pass\\\": self.password}\\n url = \\\"https://%s.ogame.gameforge.com/main/login\\\" % self.country_code\\n result = self.session.post(url, data=login_form)\",\n \"def test_adtls(self):\\n for domain in config.ADW2K12_DOMAINS:\\n principal = '%s@%s' % (config.ADW2k12_USER1, domain)\\n\\n testflow.step(\\\"Login as user %s\\\", config.ADW2k12_USER1)\\n users.loginAsUser(\\n principal,\\n self.conf['authn_name'],\\n config.ADW2k12_USER_PASSWORD,\\n True,\\n )\\n\\n testflow.step(\\n \\\"Testing connection with user %s\\\", config.ADW2k12_USER1\\n )\\n assert common.connectionTest(), \\\"User %s can't login.\\\" % principal\",\n \"def test_https(self):\\n r = self.r.post('/users/login',\\n {'next': 'https://su.mo.com/kb/new?f=b'})\\n eq_('/kb/new?f=b', get_next_url(r))\",\n \"def login(userID, robotID, password): #@NoSelf\",\n \"def test_login_to_youtube(self):\\n\\n # Finding elements on the page and actions.\\n self.wait_clickable_by_css(\\n \\\"#buttons a > .style-scope.ytd-button-renderer\\\"\\n \\\".style-suggestive.size-small[role='button']\\\"\\n ).click()\\n self.wait_clickable_by_id(\\\"identifierId\\\").send_keys(config.USER1[\\\"email\\\"])\\n self.wait_clickable_by_id(\\\"identifierNext\\\").click()\\n self.wait_invisibility_by_id(\\\"identifierId\\\")\\n self.wait_clickable_by_css(\\\".whsOnd.zHQkBf\\\").send_keys(config.USER1[\\\"password\\\"])\\n self.wait_clickable_by_id(\\\"passwordNext\\\").click()\\n\\n try:\\n self.wait_clickable_by_css(\\\".ZFr60d.CeoRYc\\\").click()\\n\\n except:\\n\\n pass\\n\\n # Waiting for button to appear.\\n self.wait_visibility_by_css(\\\"#avatar-btn\\\")\\n self.make_screenshot()\\n print(\\\"Test 1: User is successfully logged in.\\\")\",\n \"def test_shred_login():\\n assert_redirect_to_login('/shred/')\\n assert_not_redirect_to_login('/shred/')\",\n \"def _log_into_shib( self, driver ):\\n driver.find_element_by_id(\\\"username\\\").clear()\\n driver.find_element_by_id(\\\"username\\\").send_keys( self.USERNAME )\\n driver.find_element_by_id(\\\"password\\\").clear()\\n driver.find_element_by_id(\\\"password\\\").send_keys( self.PASSWORD )\\n driver.find_element_by_css_selector(\\\"button[type=\\\\\\\"submit\\\\\\\"]\\\").click()\\n return driver\",\n \"def testSignOutAndSignBackIn(self):\\n self.host.ContinueAuth()\\n self.host.SignIn(self.account['username'], self.account['password'])\\n self.host.AllowAccess()\\n self.host.SignOut()\\n self.host.ContinueAuth()\\n self.host.AllowAccess()\",\n \"def login_to_system(credentials):\\n return True if credentials else False\",\n \"def test_login_logout(self):\\n\\n rv = login(self.client, app.config['USERNAME'], app.config['PASSWORD'])\\n self.assertTrue(b'Play' in rv.data)\\n\\n rv = logout(self.client)\\n self.assertTrue(b'Sign In' in rv.data)\\n\\n rv = login(self.client, app.config['USERNAME'] + 'x', app.config['PASSWORD'])\\n self.assertTrue(b'Invalid username or password' in rv.data)\\n\\n rv = login(self.client, app.config['USERNAME'], app.config['PASSWORD'] + 'x')\\n self.assertTrue(b'Invalid username or password' in rv.data)\",\n \"def _login(self,user,password=\\\"testpassword\\\"):\\n self.client.logout()\\n if user is None:\\n return #just log out\\n success = self.client.login(username=user.username,password=password)\\n self.assertTrue(success, \\\"could not log in as user %s using password %s\\\"\\n % (user.username,password)) \\n return success\",\n \"def test_login_POST_2(self):\\r\\n\\r\\n User.signup(username='testuser2',\\r\\n password=\\\"PASSWORD\\\", location=\\\"US-FL\\\")\\r\\n db.session.commit()\\r\\n with app.app_context():\\r\\n form = UserLoginForm(username='testuser2',\\r\\n password='WRONG_PASSWORD')\\r\\n with self.client:\\r\\n response = self.client.post(\\r\\n '/login', data=form.data, follow_redirects=True)\\r\\n self.assertIn(b'Invalid credentials.', response.data)\",\n \"def test_can_login(self):\\n user = authenticate(username='jack', password='secret')\\n self.assertTrue(user is not None)\\n self.assertTrue(user.is_authenticated)\",\n \"def test_correct_login(self):\\n self.app.post('/register', data=self.user_reg_details)\\n res = self.app.post('/login', data=self.user_login_details)\\n self.assertEqual(res.status_code, 200)\\n self.assertIn(\\\"Successfully logged in\\\", str(res.data))\",\n \"def login(self):\\n url = 'https://ngb.to/login.php?do=login'\\n\\n params = {'do': 'login'}\\n payload = {'vb_login_username': self.username,\\n 'vb_login_password': self.password,\\n 'url': \\\"index.php\\\",\\n 'do': \\\"login\\\",\\n 'vb_login_md5password': \\\"\\\",\\n 'vb_login_md5password_utf': \\\"\\\",\\n 's': \\\"\\\",\\n 'securitytoken': \\\"guest\\\",\\n 'cookieuser': \\\"1\\\"}\\n\\n self.session.post(url, data=payload, params=params)\",\n \"def test_two_factor(app, client):\\n data = dict(email=\\\"dude@lp.com\\\", password=\\\"password\\\", password_confirm=\\\"password\\\")\\n response = client.post(\\\"/register\\\", data=data, follow_redirects=False)\\n assert \\\"tf-setup\\\" in response.location\\n\\n # make sure not logged in\\n response = client.get(\\\"/profile\\\")\\n assert response.status_code == 302\\n assert \\\"/login?next=%2Fprofile\\\" in response.location\",\n \"def authenticate(self):\\n\\n # Choose a random user agent string from the most popular\\n agent_strings = [\\n 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.113 Safari/537.36',\\n 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.157 Safari/537.36',\\n 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.90 Safari/537.36'\\n ]\\n headers = {'User-Agent': choice(agent_strings)}\\n\\n # Spin up a requests session\\n with requests.Session() as s:\\n s.headers.update(headers)\\n\\n login_page = s.get('https://alta.registries.gov.ab.ca/SpinII/').content\\n soup = BeautifulSoup(login_page, 'html.parser')\\n\\n login_payload = {\\n 'uctrlFullHeader:ShutdownAlert1:Hidden1':'',\\n 'uctrlFullHeader:ShutdownAlert1:Hidden2':'',\\n 'JavascriptEnabled':1,\\n 'uctrlLogon:txtLogonName':'',\\n 'uctrlLogon:txtPassword':'',\\n 'uctrlLogon:cmdLogonGuest.x':59,\\n 'uctrlLogon:cmdLogonGuest.y':26\\n }\\n login_payload['__EVENTTARGET'] = soup.select_one('#__EVENTTARGET')['value']\\n login_payload['__EVENTARGUMENT'] = soup.select_one('#__EVENTARGUMENT')['value']\\n login_payload['__VIEWSTATE'] = soup.select_one('#__VIEWSTATE')['value']\\n\\n sleep(2)\\n legal_notice_page = s.post('https://alta.registries.gov.ab.ca/SpinII/logon.aspx', \\\\\\n data=login_payload).content\\n soup = BeautifulSoup(legal_notice_page, 'html.parser')\\n\\n login_payload['__VIEWSTATE'] = soup.select_one('#__VIEWSTATE')['value']\\n login_payload['cmdYES.x'] = 55\\n login_payload['cmdYES.y'] = 12\\n del login_payload['__EVENTARGUMENT']\\n del login_payload['__EVENTTARGET']\\n\\n sleep(2)\\n confirm_guest_page = s.post('https://alta.registries.gov.ab.ca/SpinII/legalnotice.aspx', \\\\\\n data=login_payload).content\\n soup = BeautifulSoup(confirm_guest_page, 'html.parser')\\n\\n if len(soup.find_all(text='You are logged on as a Guest.')) > 0:\\n return s\",\n \"def test_signin_functionality(self):\\n res = self.client.post('/signin',\\n follow_redirects=True, data=dict(\\n username='orange',\\n password='123Orange',\\n ))\\n data = res.data.decode('utf-8')\\n assert 'Profile' in data\\n assert 'Username: orange' in data\\n assert res.status == '200 OK'\",\n \"def test_login_logout(self):\\n rv = self.login(closet.app.config['USERNAME'],\\n closet.app.config['PASSWORD'])\\n assert b'You were logged in' in rv.data\\n rv = self.logout()\\n assert b'You were logged out' in rv.data\\n rv = self.login(closet.app.config['USERNAME'] + 'x',\\n closet.app.config['PASSWORD'])\\n assert b'Invalid username' in rv.data\\n rv = self.login(closet.app.config['USERNAME'],\\n closet.app.config['PASSWORD'] + 'x')\\n assert b'Invalid password' in rv.data\",\n \"def test_login_to_shoplists(self):\\n tester = app.test_client(self)\\n response = tester.post('/login', follow_redirects=True)\\n self.assertEqual(response.status_code, 200)\",\n \"def test_correct_login(self):\\n with self.client:\\n response = self.client.post(\\n '/users/login',\\n data=dict(username=\\\"eschoppik\\\", password=\\\"secret\\\"),\\n follow_redirects=True\\n )\\n self.assertIn(b'Welcome', response.data)\\n self.assertTrue(current_user.username == \\\"eschoppik\\\")\\n self.assertTrue(current_user.is_authenticated)\",\n \"def test_login(self):\\n # Signup a user\\n response = self.client.post('/api/v1/auth/signup',\\n data=json.dumps(self.new_user2),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 201)\\n\\n # Test user login\\n response = self.client.post('/api/v1/auth/login',\\n data=json.dumps(self.login_details),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 200)\",\n \"def test_authentication_success():\\n d = Dexcom(USERNAME, PASSWORD)\\n d._validate_account()\\n d._validate_session_id()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7610409","0.7500811","0.74207056","0.74207056","0.7279427","0.72677475","0.7121446","0.7109126","0.707014","0.70642114","0.7060475","0.70395577","0.70346","0.69922304","0.69830513","0.6942732","0.6919252","0.6907737","0.6880657","0.6877048","0.6873271","0.6871723","0.68097985","0.67957515","0.67878354","0.6772828","0.67619437","0.6745331","0.67446417","0.6715374","0.6704573","0.6701049","0.6699676","0.66980076","0.66739243","0.6669591","0.6665172","0.66627663","0.6661833","0.66436905","0.664037","0.66378915","0.66337645","0.6628438","0.6619452","0.65801835","0.65719956","0.6565747","0.65472263","0.6539785","0.6521289","0.6504528","0.64937687","0.648995","0.64757574","0.645041","0.6446454","0.64435077","0.64428186","0.64396673","0.64341104","0.6429327","0.64163375","0.6414823","0.6411783","0.6411754","0.640672","0.6405876","0.64011294","0.63989365","0.63976866","0.6392061","0.63903797","0.63887614","0.63801414","0.6377579","0.63768274","0.6371468","0.6368486","0.6366454","0.6365787","0.63613486","0.63572055","0.6355949","0.6346627","0.63455635","0.6344758","0.634333","0.63429344","0.6339822","0.63366413","0.6332812","0.6330982","0.63299","0.63294303","0.63290244","0.6326064","0.6325111","0.631988","0.63091284"],"string":"[\n \"0.7610409\",\n \"0.7500811\",\n \"0.74207056\",\n \"0.74207056\",\n \"0.7279427\",\n \"0.72677475\",\n \"0.7121446\",\n \"0.7109126\",\n \"0.707014\",\n \"0.70642114\",\n \"0.7060475\",\n \"0.70395577\",\n \"0.70346\",\n \"0.69922304\",\n \"0.69830513\",\n \"0.6942732\",\n \"0.6919252\",\n \"0.6907737\",\n \"0.6880657\",\n \"0.6877048\",\n \"0.6873271\",\n \"0.6871723\",\n \"0.68097985\",\n \"0.67957515\",\n \"0.67878354\",\n \"0.6772828\",\n \"0.67619437\",\n \"0.6745331\",\n \"0.67446417\",\n \"0.6715374\",\n \"0.6704573\",\n \"0.6701049\",\n \"0.6699676\",\n \"0.66980076\",\n \"0.66739243\",\n \"0.6669591\",\n \"0.6665172\",\n \"0.66627663\",\n \"0.6661833\",\n \"0.66436905\",\n \"0.664037\",\n \"0.66378915\",\n \"0.66337645\",\n \"0.6628438\",\n \"0.6619452\",\n \"0.65801835\",\n \"0.65719956\",\n \"0.6565747\",\n \"0.65472263\",\n \"0.6539785\",\n \"0.6521289\",\n \"0.6504528\",\n \"0.64937687\",\n \"0.648995\",\n \"0.64757574\",\n \"0.645041\",\n \"0.6446454\",\n \"0.64435077\",\n \"0.64428186\",\n \"0.64396673\",\n \"0.64341104\",\n \"0.6429327\",\n \"0.64163375\",\n \"0.6414823\",\n \"0.6411783\",\n \"0.6411754\",\n \"0.640672\",\n \"0.6405876\",\n \"0.64011294\",\n \"0.63989365\",\n \"0.63976866\",\n \"0.6392061\",\n \"0.63903797\",\n \"0.63887614\",\n \"0.63801414\",\n \"0.6377579\",\n \"0.63768274\",\n \"0.6371468\",\n \"0.6368486\",\n \"0.6366454\",\n \"0.6365787\",\n \"0.63613486\",\n \"0.63572055\",\n \"0.6355949\",\n \"0.6346627\",\n \"0.63455635\",\n \"0.6344758\",\n \"0.634333\",\n \"0.63429344\",\n \"0.6339822\",\n \"0.63366413\",\n \"0.6332812\",\n \"0.6330982\",\n \"0.63299\",\n \"0.63294303\",\n \"0.63290244\",\n \"0.6326064\",\n \"0.6325111\",\n \"0.631988\",\n \"0.63091284\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.80582833"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23598,"cells":{"query":{"kind":"string","value":"Test login with 2SA and a new session with granted device."},"document":{"kind":"string","value":"def test_login_2sa_new_session(self):\n dsm_7 = SynologyDSMMock(\n VALID_HOST,\n VALID_PORT,\n VALID_USER_2SA,\n VALID_PASSWORD,\n VALID_HTTPS,\n VALID_VERIFY_SSL,\n device_token=DEVICE_TOKEN,\n )\n dsm_7.dsm_version = 7\n assert dsm_7.login()\n\n assert dsm_7._session_id == SESSION_ID\n assert dsm_7._syno_token == SYNO_TOKEN\n assert dsm_7._device_token == DEVICE_TOKEN\n assert dsm_7.device_token == DEVICE_TOKEN"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_login_2sa(self):\n dsm_7 = SynologyDSMMock(\n VALID_HOST,\n VALID_PORT,\n VALID_USER_2SA,\n VALID_PASSWORD,\n VALID_HTTPS,\n VALID_VERIFY_SSL,\n )\n dsm_7.dsm_version = 7\n with pytest.raises(SynologyDSMLogin2SARequiredException) as error:\n dsm_7.login()\n error_value = error.value.args[0]\n assert error_value[\"api\"] == \"SYNO.API.Auth\"\n assert error_value[\"code\"] == 403\n assert error_value[\"reason\"] == \"One time password not specified\"\n assert (\n error_value[\"details\"]\n == \"Two-step authentication required for account: valid_user_2sa\"\n )\n\n assert dsm_7.login(VALID_OTP)\n\n assert dsm_7._session_id == SESSION_ID\n assert dsm_7._syno_token == SYNO_TOKEN\n assert dsm_7._device_token == DEVICE_TOKEN\n assert dsm_7.device_token == DEVICE_TOKEN","async def test_login(self):\n params = {\n 'VCA_HOST': os.getenv('VCA_HOST', '127.0.0.1'),\n 'VCA_PORT': os.getenv('VCA_PORT', 17070),\n 'VCA_USER': os.getenv('VCA_USER', 'admin'),\n 'VCA_SECRET': os.getenv('VCA_SECRET', 'admin'),\n 'VCA_CHARMS': os.getenv('VCA_CHARMS', None),\n 'VCA_PUBLIC_KEY': os.getenv('VCA_PUBLIC_KEY', None),\n 'VCA_CACERT': os.getenv('VCA_CACERT', \"invalidcacert\"),\n }\n\n client = self.get_n2vc(params)\n\n await client.login()\n assert client.authenticated\n\n await client.logout()\n assert client.authenticated is False","def test_aio_can_login_to_web_portal(aio):","def test_login(self):\n self._configure_testshib_provider()\n self._test_login()","def test_open_id_setup(self):\r\n self.attempt_login(200)","def the_user_should_be_able_to_connect_to_another_device():\n assert web_app.connect_to_device2()","def test_successful_login(self):\n pass","def test_start_new_verification(self):\r\n user = UserFactory.create(username=\"rusty\", password=\"test\")\r\n self.client.login(username=\"rusty\", password=\"test\")","def test_access_token_in_session_after_login(self, client, valid_otp_data):\n\n resp = client.post(self.url, json=valid_otp_data)\n assert resp.status_code == 200\n\n session_resp = client.get(\"/view_session\")\n assert \"access_token\" in session_resp.json()","def test_login(self):\n self.user_api()\n self.base.metadata.create_all(self.engine)\n people = self.provision_users()\n p = {'__action': 'login', 'id': people[0].id, 'password': \"testing\"}\n self.post('user', 200, params=p)","def test_activate_login(self):\r\n pass","def test_031_login_as_exp_pwd_user(self):\n\n testflow.step(LOG_USR_MSG, TEST_USER2)\n users.loginAsUser(\n TEST_USER2,\n config.INTERNAL_PROFILE,\n self.user_password,\n True,\n )\n\n testflow.step(TST_CON_MSG, TEST_USER2)\n assert not connectionTest(), \"User '%s' can login\" % TEST_USER2","def test_login_post_with_2fa(self, *_):\n view = views.Login.as_view()\n form = forms.LoginForm()\n form.data[\"localname\"] = \"badger\"\n form.data[\"password\"] = \"password\"\n request = self.factory.post(\"\", form.data)\n request.user = self.anonymous_user\n middleware = SessionMiddleware(request)\n middleware.process_request(request)\n request.session.save()\n\n with patch(\"bookwyrm.views.landing.login.login\"):\n result = view(request)\n self.assertEqual(result.url, \"/2fa-check\")\n self.assertEqual(result.status_code, 302)","def testLoginTwice(self):\n self.assertEquals(models.SUCCESS, self.users.add(\"userG2\", \"password\"))\n self.assertEquals(self.users.login(\"userG2\", \"password\"), 2)\n self.assertEquals(self.users.login(\"userG2\", \"password\"), 3)","def test_030_login_as_user(self):\n\n testflow.step(LOG_USR_MSG, TEST_USER1)\n users.loginAsUser(\n TEST_USER1,\n config.INTERNAL_PROFILE,\n self.user_password,\n True,\n )\n\n testflow.step(TST_CON_MSG, TEST_USER1)\n assert connectionTest(), \"User '%s' can't login\" % TEST_USER1","def test_login(self):\n\n print('\\n\\nEnter a valid LendingClub account information...')\n email = input('Email:')\n password = getpass.getpass()\n\n self.assertTrue(self.session.authenticate(email, password))\n print('Authentication successful')","def testGaiaLogin(self):\n if self._is_guest:\n return\n try:\n username, password = next(self._GetCredentialsIter())\n except StopIteration:\n username = 'autotest.catapult'\n password = 'autotest'\n with self._CreateBrowser(gaia_login=True,\n username=oobe.Oobe.Canonicalize(username),\n password=password):\n self.assertTrue(py_utils.WaitFor(self._IsCryptohomeMounted, 10))","def test_valid_login(self):\n self.assertTrue(self.session.authenticate('test@test.com', 'supersecret'))","def test_login_user_second_time(client, new_user, registered_user):\n rv = client.post(\"/auth/login/\", json=new_user)\n token = rv.get_json()[\"access_token\"]\n rv = client.post(\n \"/auth/login/\",\n headers={\"Authorization\": \"Bearer {}\".format(token)},\n json=new_user\n )\n response = rv.get_json()\n assert rv.status_code == HTTPStatus.UNAUTHORIZED\n assert response[\"message\"] == \"User logged in already\"","def test_login_with_testshib_provider_short_session_length(self):\n # Configure the provider with a 10-second timeout\n self._configure_testshib_provider(max_session_length=10)\n\n now = datetime.datetime.utcnow()\n with freeze_time(now):\n # Test the login flow, adding the user in the process\n self._test_login()\n\n # Wait 30 seconds; longer than the manually-set 10-second timeout\n later = now + datetime.timedelta(seconds=30)\n with freeze_time(later):\n # Test returning as a logged in user; this method verifies that we're logged out first.\n self._test_return_login(previous_session_timed_out=True)","def test_twice_logging_in(test_client, test_session):\n tokens = []\n for _ in range(2):\n with patch(\"validators.authentication.session\", test_session):\n with patch(\"views.login.session\", test_session):\n payload = {\"username\": \"testuser1\", \"password\": \"Qwerty123_\"}\n response = test_client.post(\"api/v1/login\", data=payload)\n assert response.status_code == 200\n tokens.append(response.json()[\"access_token\"])\n time.sleep(1)\n assert tokens[0] != tokens[1]","def login():","def login():","def do_login(self, backend, user):","def test_0000_initiate_users(self):\n self.login(email=common.test_user_1_email, username=common.test_user_1_name)\n self.login(email=common.admin_email, username=common.admin_username)\n self.galaxy_login(email=common.admin_email, username=common.admin_username)","def test_basic_login(self):\n c = Client()\n c.login(username='a', password='123456')","def test_set_session():","def test_login_session_check(self):\r\n\t\tprint(\"\")\r\n\t\tprint(\"`login_session_check` method tests\")\r\n\t\tprint(\"---------------------\")\r\n\t\tprint(\"Test: `login_session_check: logged in`\")\r\n\t\tpath = 'login'\r\n\t\twith requests_mock.mock() as m:\r\n\t\t\tm.get(\r\n\t\t\t\tf'{host}/{basepath}/{path}',\r\n\t\t\t\tstatus_code = 200,\r\n\t\t\t\treason = 'OK',\r\n\t\t\t\ttext=\"\"\"{\r\n\t\t\t\t\t\"rows\":\r\n\t\t\t\t\t\t[\r\n\t\t\t\t\t\t\t{\"FORCE_PWD_CHANGE\":true,\r\n\t\t\t\t\t\t\t\"LAST_ACCT\":1,\r\n\t\t\t\t\t\t\t\"NEXT_PWNED\":null,\r\n\t\t\t\t\t\t\t\"PWD_EXPIRE\":\"2020-07-30\",\r\n\t\t\t\t\t\t\t\"ROOT\":true,\r\n\t\t\t\t\t\t\t\"USER\":\"restuser\",\r\n\t\t\t\t\t\t\t\"USER_ID\":2,\r\n\t\t\t\t\t\t\t\"expired_pwd\":false\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t],\r\n\t\t\t\t\t\"success\":true\r\n\t\t\t\t}\"\"\"\r\n\t\t\t)\r\n\t\t\tsession_check = sdk.login_session_check()\r\n\t\t\tassert session_check[0] == True\r\n\t\t\tassert session_check[1]['FORCE_PWD_CHANGE'] == True\r\n\t\t\tassert session_check[1]['LAST_ACCT'] == 1\r\n\t\t\tassert session_check[1]['NEXT_PWNED'] == None\r\n\t\t\tassert session_check[1]['ROOT'] == True\r\n\t\t\tassert session_check[1]['USER_ID'] == 2\r\n\t\t\tassert session_check[1]['USER'] == 'restuser'\r\n\t\t\tassert session_check[1]['expired_pwd'] == False\r\n\t\t\tprint(\"Passed!!!\")\r\n\t\t\tprint(\"Test: `login_session_check: not logged in`\")\r\n\t\t\tm.get(\r\n\t\t\t\tf'{host}/{basepath}/{path}',\r\n\t\t\t\tstatus_code = 200,\r\n\t\t\t\treason = 'OK',\r\n\t\t\t\ttext=\"\"\"{\r\n\t\t\t\t\t\"rows\":\t[],\r\n\t\t\t\t\t\"success\":false\r\n\t\t\t\t}\"\"\"\r\n\t\t\t)\r\n\t\t\tsession_check = sdk.login_session_check()\r\n\t\t\tassert session_check[0] == False\r\n\t\t\tassert not session_check[1] # dictionary should be empty\r\n\t\tprint(\"Passed!!!\")","def testing_create_login_session():\n set_logged_in_user(request.form['email'])\n app.logger.debug(\n \"logged in user set to {} for testing\".format(\n request.form['email']))\n return ''","def test_02_account_login(self):\n self.login(email='test@test2.com', password='Abcd@1234')\n self.assertEquals(\n self.selenium.current_url, self.get_absolute_url())\n print 'valid login test completed'","def test_sucessful_login(self):\n self.user.list_of_accounts = [{'username': 'dalton',\n 'pwd': 'chromelegend',\n 'email': 'legionless@yahoo.com'}]\n msg = self.user.login(\"legionless@yahoo.com\", \"chromelegend\")\n self.assertEqual(msg, \"Success!\")","def test_regular_user_login(self):\n self.login(\"user\", \"user\")\n self.should_see(\"This is your profile, user.\")","def test_login(self):\n self.driver.find_element_by_link_text(\"Sign in\").click()\n self.driver.find_element_by_id(\"email\").send_keys(\"devsoftbol@gmail.com\")\n self.driver.find_element_by_id(\"passwd\").send_keys(\"control123\")\n self.driver.find_element_by_id(\"SubmitLogin\").click()\n time.sleep(5)","def test_login_OK(self):\n rv = self.login('super',\n '1b3231655cebb7a1f783eddf27d254ca')\n assert 'Bienvenido' in rv.data","def test_releaseSession_success_and_failure(self):\n\t\tdm = DeviceManager()\n\t\tdm.sessionID=\"random session\"\n\t\tself.assertEqual(dm.releaseSession(\"random session\"), \"success\")\n\t\tself.assertEqual(dm.releaseSession(\"other session\"), \"failure\")","def test_login(self):\n\n with self.client as c:\n result = c.post('/login',\n data={'email': 'cat@gmail.com', 'password': 'abc'},\n follow_redirects=True\n )\n self.assertEqual(session['user_id'], 1)\n self.assertIn(\"You are logged in\", result.data)\n\n print \"DONE WITH LOGIN CHECK\"","def check_login(self):\n # read token first\n user_data = self.storage.get_user_data(self.user_id)\n if not \"token\" in user_data:\n sys.exit(\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\")\n\n # check token\n token = user_data[\"token\"]\n url = self.host_address + \"/assist/authentication\"\n payload = {\n 'action' : \"check\",\n 'client' : self.client_info,\n 'KEY' : (self.user_id + \";\" + token)\n }\n headers = {\n 'Content-Type': \"application/json\"\n }\n response = requests.request(\"POST\", url, json=payload, headers=headers)\n try:\n res = json.loads(response.text)\n except NameError:\n res = None\n\n if res[\"result\"] and res[\"result\"] == \"success\":\n name = res[\"user_name\"][\"nick\"] or res[\"user_name\"][\"first\"]\n print(\"SEPIA account: Success - Wb \" + name + \", your login token is still valid.\")\n else:\n print(\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\")","def test_two_factor(app, client):\n data = dict(email=\"dude@lp.com\", password=\"password\", password_confirm=\"password\")\n response = client.post(\"/register\", data=data, follow_redirects=False)\n assert \"tf-setup\" in response.location\n\n # make sure not logged in\n response = client.get(\"/profile\")\n assert response.status_code == 302\n assert \"/login?next=%2Fprofile\" in response.location","def login_permitted_user(self):\n self.grant_permission()\n self.client.login(username=\"john\", password=\"pass\")","def test_login_endpoint_not_verbose():\n url = f\"{DEXCOM_BASE_URL}/{DEXCOM_LOGIN_ENDPOINT}\"\n json = {\n \"accountName\": USERNAME,\n \"password\": \"a\",\n \"applicationId\": DEXCOM_APPLICATION_ID,\n }\n r = requests.request(\"post\", url, json=json,)\n assert r.json() == DEFAULT_SESSION_ID","def test_login(self):\n\n client = Client('username', 'password')\n self.setSessionResponse(200)\n try:\n client.authenticate()\n except Exception as e:\n self.fail(\"Exception raised : \" + str(e))","def test_successful_login(self):\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\n rv = self.login('Bo_theo5@example.com', 'Bo1995')\n self.assertIn(b'You are now logged in', rv.data)","def test_existing_session_auth_token(self):\n\n test_header = {'X-Auth-Token': 'pretend_token'}\n\n with self.app_sess1 as c:\n ret1 = c.get('/', headers=test_header)\n ret2 = c.get('/', headers=test_header)\n self.assertEqual(ret1.data, ret2.data)","def login(self):\n self.client.login(username=self.user.username, password='test')","def test_login(self, mock):\n _setup_responses(mock)\n api = LiveStreamApi(\"user\", \"pass\")\n\n api.login()\n\n with self.subTest(\"stores the token on the api object\"):\n self.assertEqual(api._token, \"ffffffffffffffffffffffffffffffffffffffff\")\n\n with self.subTest(\"stores ssesyranac cookie on the api object\"):\n self.assertEqual(api._ssesyranac, \"ssesyranac\")","def test_login_twice(self):\n self.client.login(username=self.USERNAME, password=self.PASSWORD)\n username2 = \"two\"\n password2 = \"two\"\n user2 = User.objects.create_user(username=username2, password=password2)\n UserInfo.objects.create(user=user2)\n\n resp = self.client.post(\n reverse('login'),\n json.dumps({\n \"username\": username2,\n \"password\": username2,\n }),\n content_type=\"application/json\"\n )\n assert resp.status_code == 200, resp.content.decode('utf-8')\n assert self.is_authenticated(user2)","def login_user_two(self):\n return self.client.post(self.login_url,\n self.valid_user_two_login_details, format='json')","def test_01_authenticated(self):\r\n res = self.signin(email=self.email_addr, password=self.password)\r\n res = self.app.get(self.url, follow_redirects=True)\r\n dom = BeautifulSoup(res.data)\r\n err_msg = \"The CKAN exporter should be available for the owner of the app\"\r\n assert dom.find(id=\"ckan\") is not None, err_msg\r\n\r\n self.signout()\r\n\r\n self.signin(email=self.email_addr2, password=self.password)\r\n res = self.app.get(self.url, follow_redirects=True)\r\n dom = BeautifulSoup(res.data)\r\n err_msg = \"The CKAN exporter should be ONLY available for the owner of the app\"\r\n assert dom.find(id=\"ckan\") is None, err_msg","def test_login_post_no_2fa_set(self, *_):\n view = views.Login.as_view()\n form = forms.LoginForm()\n form.data[\"localname\"] = \"rat\"\n form.data[\"password\"] = \"password\"\n request = self.factory.post(\"\", form.data)\n request.user = self.anonymous_user\n\n with patch(\"bookwyrm.views.landing.login.login\"):\n result = view(request)\n self.assertEqual(result.url, \"/2fa-prompt\")\n self.assertEqual(result.status_code, 302)","def login(test_app):\n from flask_monitoringdashboard import config\n\n with test_app.session_transaction() as sess:\n sess[config.link + '_logged_in'] = True\n sess[config.link + '_admin'] = True","def test_authentication_success():\n d = Dexcom(USERNAME, PASSWORD)\n d._validate_account()\n d._validate_session_id()","def login(self):","def test_new_session_promotion(self):\r\n cursor = self.db.cursor()\r\n incookie = Cookie()\r\n incookie['trac_session'] = '123456'\r\n outcookie = Cookie()\r\n req = Mock(authname='john', base_path='/', incookie=incookie,\r\n outcookie=outcookie)\r\n session = Session(self.env, req)\r\n self.assertEqual('john', session.sid)\r\n session.save()\r\n\r\n cursor.execute(\"SELECT sid,authenticated FROM session\")\r\n self.assertEqual(('john', 1), cursor.fetchone())\r\n self.assertEqual(None, cursor.fetchone())","def test_login():\n My.search_merchant_page(driver, My.Testing_Env_EN)\n validate_login()\n print('----------')\n My.search_merchant_page(driver, My.Testing_Env_FR)\n validate_login()\n driver.quit()","def testSignOutAndSignBackIn(self):\n self.host.ContinueAuth()\n self.host.SignIn(self.account['username'], self.account['password'])\n self.host.AllowAccess()\n self.host.SignOut()\n self.host.ContinueAuth()\n self.host.AllowAccess()","def test_ap_hs20_session_info(dev, apdev):\n bssid = apdev[0]['bssid']\n params = hs20_ap_params()\n params['nai_realm'] = [ \"0,example.com,21[2:4]\" ]\n hostapd.add_ap(apdev[0]['ifname'], params)\n\n dev[0].request(\"SET pmf 1\")\n dev[0].hs20_enable()\n dev[0].add_cred_values({ 'realm': \"example.com\",\n 'username': \"hs20-session-info-test\",\n 'password': \"password\" })\n interworking_select(dev[0], bssid, freq=\"2412\")\n interworking_connect(dev[0], bssid, \"TTLS\")\n ev = dev[0].wait_event([\"ESS-DISASSOC-IMMINENT\"], timeout=10)\n if ev is None:\n raise Exception(\"Timeout on ESS disassociation imminent notice\")\n if \" 1 59904 https://example.com/\" not in ev:\n raise Exception(\"Unexpected ESS disassociation imminent event contents\")\n ev = dev[0].wait_event([\"CTRL-EVENT-SCAN-STARTED\"])\n if ev is None:\n raise Exception(\"Scan not started\")\n ev = dev[0].wait_event([\"CTRL-EVENT-SCAN-RESULTS\"])\n if ev is None:\n raise Exception(\"Scan not completed\")","def test_login(self):\n user = UUIDUser.objects.create_user(username=\"uuid\", password=\"test\")\n self.assertTrue(self.client.login(username=\"uuid\", password=\"test\"))\n self.assertEqual(\n UUIDUser.objects.get(pk=self.client.session[SESSION_KEY]), user\n )","def __init__(self, user, password, device):\n self.user = user\n self.password = password\n self.device = device\n self.session = requests.session()\n\n # Hard-coded auth seed\n seed = \"oZ7QE6LcLJp6fiWzdqZc\"\n\n # Get auth tokens\n sha1p = sha.new(user.lower() + password + seed)\n sha1p = sha1p.hexdigest()\n\n auth_server = \"vera-us-oem-autha11.mios.com\"\n\n url = \"https://%s/autha/auth/username/%s?SHA1Password=%s&PK_Oem=1\" % \\\n (auth_server, user.lower(), sha1p)\n\n response = self.session.get(url).json()\n\n self.server_account = response[\"Server_Account\"]\n self.auth_token = response[\"Identity\"]\n self.auth_sig = response[\"IdentitySignature\"]\n\n # Get account number\n account_info = json.loads(base64.b64decode(self.auth_token))\n pk_account = account_info[\"PK_Account\"]\n sys.stderr.write(\"Account number: %s\\n\" % pk_account)\n\n # Get session token for server account\n session_token = self.get_session_token(self.server_account)\n\n # Get devices\n headers = { \"MMSSession\": session_token }\n url = \"https://%s/account/account/account/%s/devices\" % \\\n (self.server_account, str(pk_account))\n devices = self.session.get(url, headers=headers).json()\n\n # Work out server device\n server_device = None\n for i in devices[\"Devices\"]:\n if i[\"PK_Device\"] == device:\n server_device = i[\"Server_Device\"]\n if server_device == None:\n raise RuntimeError, \"Device %s not known.\\n\" % device\n \n sys.stderr.write(\"Server device: %s\\n\" % server_device)\n\n # Get session token on server_device\n session_token = self.get_session_token(server_device)\n\n # Get server_relay\n headers = { \"MMSSession\": session_token }\n\n url = \"https://\" + server_device + \"/device/device/device/\" + \\\n str(device)\n\n relay_info = self.session.get(url, headers=headers).json()\n\n self.relay = relay_info[\"Server_Relay\"]\n\n sys.stderr.write(\"Server relay: %s\\n\" % self.relay)\n\n # Get session token on server_relay\n self.session_token = self.get_session_token(self.relay)\n\n Vera.__init__(self)\n\n sys.stderr.write(\"Connected to remote device.\\n\")","def NavigateGuestLogin(self):\n self._ExecuteOobeApi('Oobe.guestLoginForTesting')","def test_session_auth_token(self):\n\n sess1 = None\n sess2 = None\n test_header = {'X-Auth-Token': 'pretend_token'}\n\n with self.app_sess1 as c:\n ret = c.get('/', headers=test_header)\n sess1 = ret.data\n\n with self.app_sess2 as c:\n ret = c.get('/', headers=test_header)\n sess2 = ret.data\n\n self.assertEqual(sess1, sess2)","def test_login_successful():\n user_info = {\"password\": \"abc123\", \"username\": \"0450539776\",}\n response = requests.get(\"http://127.0.0.1:7700/login\", params=user_info)\n assert(response.status_code == 200)\n assert(\"token\" in response.json())","def login(self, returnToURL):\r\n\t\tif not self.request().hasValue('userId') or \\\r\n\t\t\tnot self.request().hasValue('password'):\r\n\t\t\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\r\n\t\t\treturn 0\r\n\t\treturn 1","def test_shib_login_enrollment(self):\r\n student = UserFactory.create()\r\n extauth = ExternalAuthMap(external_id='testuser@stanford.edu',\r\n external_email='',\r\n external_domain='shib:https://idp.stanford.edu/',\r\n external_credentials=\"\",\r\n internal_password=\"password\",\r\n user=student)\r\n student.set_password(\"password\")\r\n student.save()\r\n extauth.save()\r\n\r\n course = CourseFactory.create(org='Stanford', number='123', display_name='Shib Only')\r\n course.enrollment_domain = 'shib:https://idp.stanford.edu/'\r\n self.store.update_item(course, '**replace_user**')\r\n\r\n # use django test client for sessions and url processing\r\n # no enrollment before trying\r\n self.assertFalse(CourseEnrollment.is_enrolled(student, course.id))\r\n self.client.logout()\r\n request_kwargs = {'path': '/shib-login/',\r\n 'data': {'enrollment_action': 'enroll', 'course_id': course.id.to_deprecated_string(), 'next': '/testredirect'},\r\n 'follow': False,\r\n 'REMOTE_USER': 'testuser@stanford.edu',\r\n 'Shib-Identity-Provider': 'https://idp.stanford.edu/'}\r\n response = self.client.get(**request_kwargs)\r\n # successful login is a redirect to \"/\"\r\n self.assertEqual(response.status_code, 302)\r\n self.assertEqual(response['location'], 'http://testserver/testredirect')\r\n # now there is enrollment\r\n self.assertTrue(CourseEnrollment.is_enrolled(student, course.id))\r\n\r\n # Clean up and try again with POST (doesn't happen with real production shib, doing this for test coverage)\r\n self.client.logout()\r\n CourseEnrollment.unenroll(student, course.id)\r\n self.assertFalse(CourseEnrollment.is_enrolled(student, course.id))\r\n\r\n response = self.client.post(**request_kwargs)\r\n # successful login is a redirect to \"/\"\r\n self.assertEqual(response.status_code, 302)\r\n self.assertEqual(response['location'], 'http://testserver/testredirect')\r\n # now there is enrollment\r\n self.assertTrue(CourseEnrollment.is_enrolled(student, course.id))","def test_adtls(self):\n for domain in config.ADW2K12_DOMAINS:\n principal = '%s@%s' % (config.ADW2k12_USER1, domain)\n\n testflow.step(\"Login as user %s\", config.ADW2k12_USER1)\n users.loginAsUser(\n principal,\n self.conf['authn_name'],\n config.ADW2k12_USER_PASSWORD,\n True,\n )\n\n testflow.step(\n \"Testing connection with user %s\", config.ADW2k12_USER1\n )\n assert common.connectionTest(), \"User %s can't login.\" % principal","def test_create_session(self):\n finder = FinderInsidePro(self.test_key)\n session_id = finder.create_session(2811)\n assert isinstance(session_id, str)\n assert session_id == finder.session_id\n assert len(session_id)","def test_auth_success(self):\n request = self.factory.get(resolve('/'))\n response = Login.as_view()(request)\n self.assertEqual(response.status_code, 200)\n data = {\n 'username': 'pravin.gordhan',\n 'password': 'pravin.gordhan'\n }\n request = self.factory.post(resolve('/'), data)\n request.session = self.client.session\n response = Login.as_view()(request)\n self.assertEqual(response.url, '/employee/dashboard/')","def connect(self):\n if time.time() < self._login_cooldown:\n raise FailedToConnect(\"login on cooldown\")\n\n session = yield from self.get_session()\n resp = yield from session.post(\"https://public-ubiservices.ubi.com/v3/profiles/sessions\", headers = {\n \"Content-Type\": \"application/json\",\n \"Ubi-AppId\": self.appid,\n \"Authorization\": \"Basic \" + self.token\n }, data=json.dumps({\"rememberMe\": True}))\n\n data = yield from resp.json()\n\n message = \"Unknown Error\"\n if \"message\" in data and \"httpCode\" in data:\n message = \"HTTP %s: %s\" % (data[\"httpCode\"], data[\"message\"])\n elif \"message\" in data:\n message = data[\"message\"]\n elif \"httpCode\" in data:\n message = str(data[\"httpCode\"])\n\n if \"ticket\" in data:\n self.key = data.get(\"ticket\")\n self.sessionid = data.get(\"sessionId\")\n self.uncertain_spaceid = data.get(\"spaceId\")\n else:\n raise FailedToConnect(message)","def loginAsManager(self):\n self.browser.open('http://nohost/plone/')\n self.browser.getLink('Log in').click()\n self.browser.getControl('Login Name').value = 'root'\n self.browser.getControl('Password').value = 'secret'\n self.browser.getControl('Log in').click()","def test_patient_login(self):\n\n data = {\"email\": \"jsmith@gmail.com\", \"password\": \"password\"}\n result = self.client.post(\"/patient-login\", data=data,\n follow_redirects=True)\n self.assertEqual(result.status_code, 200)\n self.assertIn(b\"Patient Dashboard\", result.data)\n\n data = {\"email\": \"jsmith@gmail.com\", \"password\": \"pass\"}\n result = self.client.post(\"/patient-login\", data=data,\n follow_redirects=True)\n self.assertEqual(result.status_code, 200)\n self.assertIn(b\"Incorrect password\", result.data)\n\n data = {\"email\": \"jsmith33@gmail.com\", \"password\": \"password\"}\n result = self.client.post(\"/patient-login\", data=data,\n follow_redirects=True)\n self.assertEqual(result.status_code, 200)\n self.assertIn(b\"No account with\", result.data)","def test_reopen_session(self):\n first_session_id = self._open_session()\n second_session_id = self._open_session(expect_termination=first_session_id, expect_initial=False)\n self.assertNotEqual(first_session_id, second_session_id)","def the_user_should_be_able_to_connect_to_one_of_the_devices():\n assert web_app.connect_to_device1()","def test_agentpi_login(self):\n param = {\n 'username' : \"seth\", \n 'password' : \"testing\"\n }\n response = param\n\n self.assertEqual(response.text, \"User Exists\")","def logIn2(self, token1, token2):\n self.driver = webdriver.Firefox()\n self.driver.get(\"https://twitter.com/login\")\n\n username_field = self.driver.find_element_by_class_name(\"js-username-field\")\n password_field = self.driver.find_element_by_class_name(\"js-password-field\")\n\n time.sleep(2)\n username_field.send_keys(token1)\n self.driver.implicitly_wait(1)\n\n time.sleep(2)\n password_field.send_keys(token2)\n self.driver.implicitly_wait(1)\n\n self.driver.find_element_by_class_name(\"EdgeButtom--medium\").click()","def test_login_with_correct_authentication_success(self):\n user = {\n \"Email\": \"fyi@g.com\",\n \"Type\": \"passenger\",\n \"Password\": \"pass234\",\n \"Confirm Password\": \"pass234\"\n }\n response = self.client().post('/api/v1/auth/register',\n data=user)\n self.assertEqual(response.status_code, 201)\n logins = {\"Email\": \"fyi@g.com\", \"Password\": \"pass234\"}\n res = self.client().post('/api/v1/auth/login', data=logins)\n self.assertTrue(res.status_code, 200)","def test_auth_code_positive(self, api):\n self.builder.add_user(api.get_user())\n resp = api.login_user(api.get_user().username, api.get_user().password)\n self.builder.del_user(api.get_user())\n assert resp.status_code == 200","def logUserIn(self):\n self.browser.get(self.live_server_url)\n self.browser.get(self.live_server_url + reverse('registration:auth_login').rstrip())\n self.assertIn(\n 'login',\n self.browser.current_url\n )\n self.browser.find_element_by_name('username').send_keys(TEST_USER['username'])\n self.browser.find_element_by_id('id_password').send_keys(TEST_USER['password'])\n self.browser.find_element_by_id('submit-login').click()","def test_professor_can_login_to_web_portal(professor):","def test_login():\n headers = {}\n data = {\"role\": args.k8s_namespace, \"jwt\": args.k8s_sa_jwt}\n url = \"{0}/auth/{1}/login\".format(args.vault_url, args.k8s_cluster_name)\n print \"Testing login to confirm that the integration is working\"\n req = send_post(url=url, data=data, headers=headers, return_output=True)\n if str(req.status_code).startswith('2'):\n print 'SUCCESS! Login request returned {0} {1}'.format(req.status_code, req.reason)\n else:\n print 'FAIL! {0} {1} {2}'.format(req.status_code, req.reason, req.content)\n exit(77)","def test_admin_can_login_to_web_portal(admin):","def test_login(self):\n url_extend = 'user_auth/login/'\n self.browser.get(self.url + url_extend)\n\n # enter the username and password.\n username_field = self.browser.find_element_by_name('user_name')\n username_field.send_keys('user4')\n password_field = self.browser.find_element_by_name('password')\n password_field.send_keys('user')\n\n # click login button.\n # get the first input button under the first form in login page.\n login_button = self.browser.find_element_by_xpath(\"//form[1]/fieldset[1]/input[@type='submit']\")\n try:\n login_button.click()\n except:\n raise Exception(\"Login Error!\")","def test_login(self):\n # Signup a user\n response = self.client.post('/api/v1/auth/signup',\n data=json.dumps(self.new_user2),\n content_type='application/json')\n self.assertEqual(response.status_code, 201)\n\n # Test user login\n response = self.client.post('/api/v1/auth/login',\n data=json.dumps(self.login_details),\n content_type='application/json')\n self.assertEqual(response.status_code, 200)","def test_login(self):\n\t\tdata = {'username' : 'testUser2', 'password' : 'passTestUser'}\n\t\tresponse = self.login(data)\n\t\tself.assertEqual(response.status_code, status.HTTP_200_OK)\n\t\ttry:\n\t\t\ttoken = response.data[\"token\"]\n\t\texcept AttributeError:\n\t\t\tself.fail(\"No token attribute\")","def login_to_apic(self):\n session = Session(URL, LOGIN, PASSWORD)\n resp = session.login()\n self.assertTrue(resp.ok)\n return session","def login(self):\n\t\treturn","def test_user_login():\n app = create_ctfd()\n with app.app_context():\n register_user(app)\n client = login_as_user(app)\n r = client.get('/profile')\n assert r.location != \"http://localhost/login\" # We didn't get redirected to login\n assert r.status_code == 200\n destroy_ctfd(app)","def test_m19bqj_236(setup):\n tiger_obj = Tiger(browser_name=browser_name)\n tiger_obj.login(username=username, password=password)","def test_logging_running(self):\n tester = app.test_client(self)\n response = tester.get('/login', content_type='html/text')\n self.assertTrue(b'PLEASE LOGIN' in response.data)","def test_client_session_with_argument():\n with c.session('com.apple.mobilesafari', ['-u', 'https://www.github.com']) as s:\n time.sleep(1.0)\n s(id='URL')\n assert s(name='Share', className=\"Button\").exists","def test001_authenticate_user(self):\n self.lg('%s STARTED' % self._testID)\n\n self.lg('- Create user1 with admin access ')\n old_password = str(uuid.uuid4()).replace('-', '')[0:10]\n user1 = self.cloudbroker_user_create(group='admin', password=old_password)\n\n self.lg(\"- Authenticate U1 ,should return session key[user1_key] .\")\n user1_key = self.get_authenticated_user_api(username=user1, password=old_password)\n self.assertTrue(user1_key)\n\n self.lg(\"- Use U1's key to list the accounts for U1, should succeed.\")\n accounts_list = user1_key.cloudapi.accounts.list()\n self.assertEqual(accounts_list, [])","def test_verify_connection_to_a_device():","def test_exception_shib_login(self):\r\n no_remote_user_request = self.request_factory.get('/shib-login')\r\n no_remote_user_request.META.update({'Shib-Identity-Provider': IDP})\r\n no_remote_user_response = shib_login(no_remote_user_request)\r\n self.assertEqual(no_remote_user_response.status_code, 403)\r\n self.assertIn(\"identity server did not return your ID information\", no_remote_user_response.content)\r\n\r\n no_idp_request = self.request_factory.get('/shib-login')\r\n no_idp_request.META.update({'REMOTE_USER': REMOTE_USER})\r\n no_idp_response = shib_login(no_idp_request)\r\n self.assertEqual(no_idp_response.status_code, 403)\r\n self.assertIn(\"identity server did not return your ID information\", no_idp_response.content)","def login(self):\n login_form = {\"kid\": \"\",\n \"uni\": self.server,\n \"login\": self.username,\n \"pass\": self.password}\n url = \"https://%s.ogame.gameforge.com/main/login\" % self.country_code\n result = self.session.post(url, data=login_form)","def test_admin_user_login(self):\n self.login(\"admin\", \"admin\")\n self.should_see(\"This is your profile, admin.\")","def login_bot(self):\n pass","def test_login_POST_2(self):\r\n\r\n User.signup(username='testuser2',\r\n password=\"PASSWORD\", location=\"US-FL\")\r\n db.session.commit()\r\n with app.app_context():\r\n form = UserLoginForm(username='testuser2',\r\n password='WRONG_PASSWORD')\r\n with self.client:\r\n response = self.client.post(\r\n '/login', data=form.data, follow_redirects=True)\r\n self.assertIn(b'Invalid credentials.', response.data)","def new_session(self):\n body = yield from self._fetch_json(URL_LOGIN, self._new_session_data)\n self.sma_sid = jmespath.search('result.sid', body)\n if self.sma_sid:\n return True\n\n msg = 'Could not start session, %s, got {}'.format(body)\n\n if body.get('err'):\n if body.get('err') == 503:\n _LOGGER.error(\"Max amount of sesions reached\")\n else:\n _LOGGER.error(msg, body.get('err'))\n else:\n _LOGGER.error(msg, \"Session ID expected [result.sid]\")\n return False","def login_client(self, client):\n test_login(client, self._email, self._user_pw)","def test_auth_positive(self, new_user):\n new = new_user\n response = self.api_client.login(new.username, new.password)\n assert new.username in response","def test_api_livesession_read_token_lti_admin_instruct_token_email_ok(self):\n # livesession with another email and lti_user_id\n livesession = LiveSessionFactory(\n is_registered=True,\n is_from_lti_connection=True,\n email=\"different@aol.com\", # explicit to be found in response\n video__playlist__lti_id=\"Maths\", # explicit to be found in response\n username=\"Sam\", # explicit to be found in response\n )\n jwt_token = InstructorOrAdminLtiTokenFactory(\n playlist=livesession.video.playlist,\n context_id=str(livesession.video.playlist.lti_id),\n consumer_site=str(livesession.consumer_site.id),\n )\n\n response = self.client.get(\n self._get_url(livesession.video, livesession),\n HTTP_AUTHORIZATION=f\"Bearer {jwt_token}\",\n )\n self.assertEqual(response.status_code, 200)\n self.assertEqual(\n response.json(),\n {\n \"anonymous_id\": None,\n \"consumer_site\": str(livesession.video.playlist.consumer_site_id),\n \"display_name\": None,\n \"email\": \"different@aol.com\",\n \"id\": str(livesession.id),\n \"is_registered\": True,\n \"language\": \"en\",\n \"live_attendance\": None,\n \"lti_user_id\": livesession.lti_user_id,\n \"lti_id\": \"Maths\",\n \"should_send_reminders\": True,\n \"username\": \"Sam\",\n \"video\": str(livesession.video.id),\n },\n )","def login():\n pass"],"string":"[\n \"def test_login_2sa(self):\\n dsm_7 = SynologyDSMMock(\\n VALID_HOST,\\n VALID_PORT,\\n VALID_USER_2SA,\\n VALID_PASSWORD,\\n VALID_HTTPS,\\n VALID_VERIFY_SSL,\\n )\\n dsm_7.dsm_version = 7\\n with pytest.raises(SynologyDSMLogin2SARequiredException) as error:\\n dsm_7.login()\\n error_value = error.value.args[0]\\n assert error_value[\\\"api\\\"] == \\\"SYNO.API.Auth\\\"\\n assert error_value[\\\"code\\\"] == 403\\n assert error_value[\\\"reason\\\"] == \\\"One time password not specified\\\"\\n assert (\\n error_value[\\\"details\\\"]\\n == \\\"Two-step authentication required for account: valid_user_2sa\\\"\\n )\\n\\n assert dsm_7.login(VALID_OTP)\\n\\n assert dsm_7._session_id == SESSION_ID\\n assert dsm_7._syno_token == SYNO_TOKEN\\n assert dsm_7._device_token == DEVICE_TOKEN\\n assert dsm_7.device_token == DEVICE_TOKEN\",\n \"async def test_login(self):\\n params = {\\n 'VCA_HOST': os.getenv('VCA_HOST', '127.0.0.1'),\\n 'VCA_PORT': os.getenv('VCA_PORT', 17070),\\n 'VCA_USER': os.getenv('VCA_USER', 'admin'),\\n 'VCA_SECRET': os.getenv('VCA_SECRET', 'admin'),\\n 'VCA_CHARMS': os.getenv('VCA_CHARMS', None),\\n 'VCA_PUBLIC_KEY': os.getenv('VCA_PUBLIC_KEY', None),\\n 'VCA_CACERT': os.getenv('VCA_CACERT', \\\"invalidcacert\\\"),\\n }\\n\\n client = self.get_n2vc(params)\\n\\n await client.login()\\n assert client.authenticated\\n\\n await client.logout()\\n assert client.authenticated is False\",\n \"def test_aio_can_login_to_web_portal(aio):\",\n \"def test_login(self):\\n self._configure_testshib_provider()\\n self._test_login()\",\n \"def test_open_id_setup(self):\\r\\n self.attempt_login(200)\",\n \"def the_user_should_be_able_to_connect_to_another_device():\\n assert web_app.connect_to_device2()\",\n \"def test_successful_login(self):\\n pass\",\n \"def test_start_new_verification(self):\\r\\n user = UserFactory.create(username=\\\"rusty\\\", password=\\\"test\\\")\\r\\n self.client.login(username=\\\"rusty\\\", password=\\\"test\\\")\",\n \"def test_access_token_in_session_after_login(self, client, valid_otp_data):\\n\\n resp = client.post(self.url, json=valid_otp_data)\\n assert resp.status_code == 200\\n\\n session_resp = client.get(\\\"/view_session\\\")\\n assert \\\"access_token\\\" in session_resp.json()\",\n \"def test_login(self):\\n self.user_api()\\n self.base.metadata.create_all(self.engine)\\n people = self.provision_users()\\n p = {'__action': 'login', 'id': people[0].id, 'password': \\\"testing\\\"}\\n self.post('user', 200, params=p)\",\n \"def test_activate_login(self):\\r\\n pass\",\n \"def test_031_login_as_exp_pwd_user(self):\\n\\n testflow.step(LOG_USR_MSG, TEST_USER2)\\n users.loginAsUser(\\n TEST_USER2,\\n config.INTERNAL_PROFILE,\\n self.user_password,\\n True,\\n )\\n\\n testflow.step(TST_CON_MSG, TEST_USER2)\\n assert not connectionTest(), \\\"User '%s' can login\\\" % TEST_USER2\",\n \"def test_login_post_with_2fa(self, *_):\\n view = views.Login.as_view()\\n form = forms.LoginForm()\\n form.data[\\\"localname\\\"] = \\\"badger\\\"\\n form.data[\\\"password\\\"] = \\\"password\\\"\\n request = self.factory.post(\\\"\\\", form.data)\\n request.user = self.anonymous_user\\n middleware = SessionMiddleware(request)\\n middleware.process_request(request)\\n request.session.save()\\n\\n with patch(\\\"bookwyrm.views.landing.login.login\\\"):\\n result = view(request)\\n self.assertEqual(result.url, \\\"/2fa-check\\\")\\n self.assertEqual(result.status_code, 302)\",\n \"def testLoginTwice(self):\\n self.assertEquals(models.SUCCESS, self.users.add(\\\"userG2\\\", \\\"password\\\"))\\n self.assertEquals(self.users.login(\\\"userG2\\\", \\\"password\\\"), 2)\\n self.assertEquals(self.users.login(\\\"userG2\\\", \\\"password\\\"), 3)\",\n \"def test_030_login_as_user(self):\\n\\n testflow.step(LOG_USR_MSG, TEST_USER1)\\n users.loginAsUser(\\n TEST_USER1,\\n config.INTERNAL_PROFILE,\\n self.user_password,\\n True,\\n )\\n\\n testflow.step(TST_CON_MSG, TEST_USER1)\\n assert connectionTest(), \\\"User '%s' can't login\\\" % TEST_USER1\",\n \"def test_login(self):\\n\\n print('\\\\n\\\\nEnter a valid LendingClub account information...')\\n email = input('Email:')\\n password = getpass.getpass()\\n\\n self.assertTrue(self.session.authenticate(email, password))\\n print('Authentication successful')\",\n \"def testGaiaLogin(self):\\n if self._is_guest:\\n return\\n try:\\n username, password = next(self._GetCredentialsIter())\\n except StopIteration:\\n username = 'autotest.catapult'\\n password = 'autotest'\\n with self._CreateBrowser(gaia_login=True,\\n username=oobe.Oobe.Canonicalize(username),\\n password=password):\\n self.assertTrue(py_utils.WaitFor(self._IsCryptohomeMounted, 10))\",\n \"def test_valid_login(self):\\n self.assertTrue(self.session.authenticate('test@test.com', 'supersecret'))\",\n \"def test_login_user_second_time(client, new_user, registered_user):\\n rv = client.post(\\\"/auth/login/\\\", json=new_user)\\n token = rv.get_json()[\\\"access_token\\\"]\\n rv = client.post(\\n \\\"/auth/login/\\\",\\n headers={\\\"Authorization\\\": \\\"Bearer {}\\\".format(token)},\\n json=new_user\\n )\\n response = rv.get_json()\\n assert rv.status_code == HTTPStatus.UNAUTHORIZED\\n assert response[\\\"message\\\"] == \\\"User logged in already\\\"\",\n \"def test_login_with_testshib_provider_short_session_length(self):\\n # Configure the provider with a 10-second timeout\\n self._configure_testshib_provider(max_session_length=10)\\n\\n now = datetime.datetime.utcnow()\\n with freeze_time(now):\\n # Test the login flow, adding the user in the process\\n self._test_login()\\n\\n # Wait 30 seconds; longer than the manually-set 10-second timeout\\n later = now + datetime.timedelta(seconds=30)\\n with freeze_time(later):\\n # Test returning as a logged in user; this method verifies that we're logged out first.\\n self._test_return_login(previous_session_timed_out=True)\",\n \"def test_twice_logging_in(test_client, test_session):\\n tokens = []\\n for _ in range(2):\\n with patch(\\\"validators.authentication.session\\\", test_session):\\n with patch(\\\"views.login.session\\\", test_session):\\n payload = {\\\"username\\\": \\\"testuser1\\\", \\\"password\\\": \\\"Qwerty123_\\\"}\\n response = test_client.post(\\\"api/v1/login\\\", data=payload)\\n assert response.status_code == 200\\n tokens.append(response.json()[\\\"access_token\\\"])\\n time.sleep(1)\\n assert tokens[0] != tokens[1]\",\n \"def login():\",\n \"def login():\",\n \"def do_login(self, backend, user):\",\n \"def test_0000_initiate_users(self):\\n self.login(email=common.test_user_1_email, username=common.test_user_1_name)\\n self.login(email=common.admin_email, username=common.admin_username)\\n self.galaxy_login(email=common.admin_email, username=common.admin_username)\",\n \"def test_basic_login(self):\\n c = Client()\\n c.login(username='a', password='123456')\",\n \"def test_set_session():\",\n \"def test_login_session_check(self):\\r\\n\\t\\tprint(\\\"\\\")\\r\\n\\t\\tprint(\\\"`login_session_check` method tests\\\")\\r\\n\\t\\tprint(\\\"---------------------\\\")\\r\\n\\t\\tprint(\\\"Test: `login_session_check: logged in`\\\")\\r\\n\\t\\tpath = 'login'\\r\\n\\t\\twith requests_mock.mock() as m:\\r\\n\\t\\t\\tm.get(\\r\\n\\t\\t\\t\\tf'{host}/{basepath}/{path}',\\r\\n\\t\\t\\t\\tstatus_code = 200,\\r\\n\\t\\t\\t\\treason = 'OK',\\r\\n\\t\\t\\t\\ttext=\\\"\\\"\\\"{\\r\\n\\t\\t\\t\\t\\t\\\"rows\\\":\\r\\n\\t\\t\\t\\t\\t\\t[\\r\\n\\t\\t\\t\\t\\t\\t\\t{\\\"FORCE_PWD_CHANGE\\\":true,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"LAST_ACCT\\\":1,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"NEXT_PWNED\\\":null,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"PWD_EXPIRE\\\":\\\"2020-07-30\\\",\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"ROOT\\\":true,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"USER\\\":\\\"restuser\\\",\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"USER_ID\\\":2,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\\"expired_pwd\\\":false\\r\\n\\t\\t\\t\\t\\t\\t\\t}\\r\\n\\t\\t\\t\\t\\t\\t],\\r\\n\\t\\t\\t\\t\\t\\\"success\\\":true\\r\\n\\t\\t\\t\\t}\\\"\\\"\\\"\\r\\n\\t\\t\\t)\\r\\n\\t\\t\\tsession_check = sdk.login_session_check()\\r\\n\\t\\t\\tassert session_check[0] == True\\r\\n\\t\\t\\tassert session_check[1]['FORCE_PWD_CHANGE'] == True\\r\\n\\t\\t\\tassert session_check[1]['LAST_ACCT'] == 1\\r\\n\\t\\t\\tassert session_check[1]['NEXT_PWNED'] == None\\r\\n\\t\\t\\tassert session_check[1]['ROOT'] == True\\r\\n\\t\\t\\tassert session_check[1]['USER_ID'] == 2\\r\\n\\t\\t\\tassert session_check[1]['USER'] == 'restuser'\\r\\n\\t\\t\\tassert session_check[1]['expired_pwd'] == False\\r\\n\\t\\t\\tprint(\\\"Passed!!!\\\")\\r\\n\\t\\t\\tprint(\\\"Test: `login_session_check: not logged in`\\\")\\r\\n\\t\\t\\tm.get(\\r\\n\\t\\t\\t\\tf'{host}/{basepath}/{path}',\\r\\n\\t\\t\\t\\tstatus_code = 200,\\r\\n\\t\\t\\t\\treason = 'OK',\\r\\n\\t\\t\\t\\ttext=\\\"\\\"\\\"{\\r\\n\\t\\t\\t\\t\\t\\\"rows\\\":\\t[],\\r\\n\\t\\t\\t\\t\\t\\\"success\\\":false\\r\\n\\t\\t\\t\\t}\\\"\\\"\\\"\\r\\n\\t\\t\\t)\\r\\n\\t\\t\\tsession_check = sdk.login_session_check()\\r\\n\\t\\t\\tassert session_check[0] == False\\r\\n\\t\\t\\tassert not session_check[1] # dictionary should be empty\\r\\n\\t\\tprint(\\\"Passed!!!\\\")\",\n \"def testing_create_login_session():\\n set_logged_in_user(request.form['email'])\\n app.logger.debug(\\n \\\"logged in user set to {} for testing\\\".format(\\n request.form['email']))\\n return ''\",\n \"def test_02_account_login(self):\\n self.login(email='test@test2.com', password='Abcd@1234')\\n self.assertEquals(\\n self.selenium.current_url, self.get_absolute_url())\\n print 'valid login test completed'\",\n \"def test_sucessful_login(self):\\n self.user.list_of_accounts = [{'username': 'dalton',\\n 'pwd': 'chromelegend',\\n 'email': 'legionless@yahoo.com'}]\\n msg = self.user.login(\\\"legionless@yahoo.com\\\", \\\"chromelegend\\\")\\n self.assertEqual(msg, \\\"Success!\\\")\",\n \"def test_regular_user_login(self):\\n self.login(\\\"user\\\", \\\"user\\\")\\n self.should_see(\\\"This is your profile, user.\\\")\",\n \"def test_login(self):\\n self.driver.find_element_by_link_text(\\\"Sign in\\\").click()\\n self.driver.find_element_by_id(\\\"email\\\").send_keys(\\\"devsoftbol@gmail.com\\\")\\n self.driver.find_element_by_id(\\\"passwd\\\").send_keys(\\\"control123\\\")\\n self.driver.find_element_by_id(\\\"SubmitLogin\\\").click()\\n time.sleep(5)\",\n \"def test_login_OK(self):\\n rv = self.login('super',\\n '1b3231655cebb7a1f783eddf27d254ca')\\n assert 'Bienvenido' in rv.data\",\n \"def test_releaseSession_success_and_failure(self):\\n\\t\\tdm = DeviceManager()\\n\\t\\tdm.sessionID=\\\"random session\\\"\\n\\t\\tself.assertEqual(dm.releaseSession(\\\"random session\\\"), \\\"success\\\")\\n\\t\\tself.assertEqual(dm.releaseSession(\\\"other session\\\"), \\\"failure\\\")\",\n \"def test_login(self):\\n\\n with self.client as c:\\n result = c.post('/login',\\n data={'email': 'cat@gmail.com', 'password': 'abc'},\\n follow_redirects=True\\n )\\n self.assertEqual(session['user_id'], 1)\\n self.assertIn(\\\"You are logged in\\\", result.data)\\n\\n print \\\"DONE WITH LOGIN CHECK\\\"\",\n \"def check_login(self):\\n # read token first\\n user_data = self.storage.get_user_data(self.user_id)\\n if not \\\"token\\\" in user_data:\\n sys.exit(\\\"SEPIA account: No user data found! Please generate a token first (python -m sepia.account --id=[sepia-user-id] --host=[sepia-server-url]).\\\")\\n\\n # check token\\n token = user_data[\\\"token\\\"]\\n url = self.host_address + \\\"/assist/authentication\\\"\\n payload = {\\n 'action' : \\\"check\\\",\\n 'client' : self.client_info,\\n 'KEY' : (self.user_id + \\\";\\\" + token)\\n }\\n headers = {\\n 'Content-Type': \\\"application/json\\\"\\n }\\n response = requests.request(\\\"POST\\\", url, json=payload, headers=headers)\\n try:\\n res = json.loads(response.text)\\n except NameError:\\n res = None\\n\\n if res[\\\"result\\\"] and res[\\\"result\\\"] == \\\"success\\\":\\n name = res[\\\"user_name\\\"][\\\"nick\\\"] or res[\\\"user_name\\\"][\\\"first\\\"]\\n print(\\\"SEPIA account: Success - Wb \\\" + name + \\\", your login token is still valid.\\\")\\n else:\\n print(\\\"SEPIA account: Failed - I think the token is invalid or we got connection problems.\\\")\",\n \"def test_two_factor(app, client):\\n data = dict(email=\\\"dude@lp.com\\\", password=\\\"password\\\", password_confirm=\\\"password\\\")\\n response = client.post(\\\"/register\\\", data=data, follow_redirects=False)\\n assert \\\"tf-setup\\\" in response.location\\n\\n # make sure not logged in\\n response = client.get(\\\"/profile\\\")\\n assert response.status_code == 302\\n assert \\\"/login?next=%2Fprofile\\\" in response.location\",\n \"def login_permitted_user(self):\\n self.grant_permission()\\n self.client.login(username=\\\"john\\\", password=\\\"pass\\\")\",\n \"def test_login_endpoint_not_verbose():\\n url = f\\\"{DEXCOM_BASE_URL}/{DEXCOM_LOGIN_ENDPOINT}\\\"\\n json = {\\n \\\"accountName\\\": USERNAME,\\n \\\"password\\\": \\\"a\\\",\\n \\\"applicationId\\\": DEXCOM_APPLICATION_ID,\\n }\\n r = requests.request(\\\"post\\\", url, json=json,)\\n assert r.json() == DEFAULT_SESSION_ID\",\n \"def test_login(self):\\n\\n client = Client('username', 'password')\\n self.setSessionResponse(200)\\n try:\\n client.authenticate()\\n except Exception as e:\\n self.fail(\\\"Exception raised : \\\" + str(e))\",\n \"def test_successful_login(self):\\n self.signup('Bo', 'Theo', 'Bo_theo5@example.com', 'Bo1995', 'Bo1995')\\n rv = self.login('Bo_theo5@example.com', 'Bo1995')\\n self.assertIn(b'You are now logged in', rv.data)\",\n \"def test_existing_session_auth_token(self):\\n\\n test_header = {'X-Auth-Token': 'pretend_token'}\\n\\n with self.app_sess1 as c:\\n ret1 = c.get('/', headers=test_header)\\n ret2 = c.get('/', headers=test_header)\\n self.assertEqual(ret1.data, ret2.data)\",\n \"def login(self):\\n self.client.login(username=self.user.username, password='test')\",\n \"def test_login(self, mock):\\n _setup_responses(mock)\\n api = LiveStreamApi(\\\"user\\\", \\\"pass\\\")\\n\\n api.login()\\n\\n with self.subTest(\\\"stores the token on the api object\\\"):\\n self.assertEqual(api._token, \\\"ffffffffffffffffffffffffffffffffffffffff\\\")\\n\\n with self.subTest(\\\"stores ssesyranac cookie on the api object\\\"):\\n self.assertEqual(api._ssesyranac, \\\"ssesyranac\\\")\",\n \"def test_login_twice(self):\\n self.client.login(username=self.USERNAME, password=self.PASSWORD)\\n username2 = \\\"two\\\"\\n password2 = \\\"two\\\"\\n user2 = User.objects.create_user(username=username2, password=password2)\\n UserInfo.objects.create(user=user2)\\n\\n resp = self.client.post(\\n reverse('login'),\\n json.dumps({\\n \\\"username\\\": username2,\\n \\\"password\\\": username2,\\n }),\\n content_type=\\\"application/json\\\"\\n )\\n assert resp.status_code == 200, resp.content.decode('utf-8')\\n assert self.is_authenticated(user2)\",\n \"def login_user_two(self):\\n return self.client.post(self.login_url,\\n self.valid_user_two_login_details, format='json')\",\n \"def test_01_authenticated(self):\\r\\n res = self.signin(email=self.email_addr, password=self.password)\\r\\n res = self.app.get(self.url, follow_redirects=True)\\r\\n dom = BeautifulSoup(res.data)\\r\\n err_msg = \\\"The CKAN exporter should be available for the owner of the app\\\"\\r\\n assert dom.find(id=\\\"ckan\\\") is not None, err_msg\\r\\n\\r\\n self.signout()\\r\\n\\r\\n self.signin(email=self.email_addr2, password=self.password)\\r\\n res = self.app.get(self.url, follow_redirects=True)\\r\\n dom = BeautifulSoup(res.data)\\r\\n err_msg = \\\"The CKAN exporter should be ONLY available for the owner of the app\\\"\\r\\n assert dom.find(id=\\\"ckan\\\") is None, err_msg\",\n \"def test_login_post_no_2fa_set(self, *_):\\n view = views.Login.as_view()\\n form = forms.LoginForm()\\n form.data[\\\"localname\\\"] = \\\"rat\\\"\\n form.data[\\\"password\\\"] = \\\"password\\\"\\n request = self.factory.post(\\\"\\\", form.data)\\n request.user = self.anonymous_user\\n\\n with patch(\\\"bookwyrm.views.landing.login.login\\\"):\\n result = view(request)\\n self.assertEqual(result.url, \\\"/2fa-prompt\\\")\\n self.assertEqual(result.status_code, 302)\",\n \"def login(test_app):\\n from flask_monitoringdashboard import config\\n\\n with test_app.session_transaction() as sess:\\n sess[config.link + '_logged_in'] = True\\n sess[config.link + '_admin'] = True\",\n \"def test_authentication_success():\\n d = Dexcom(USERNAME, PASSWORD)\\n d._validate_account()\\n d._validate_session_id()\",\n \"def login(self):\",\n \"def test_new_session_promotion(self):\\r\\n cursor = self.db.cursor()\\r\\n incookie = Cookie()\\r\\n incookie['trac_session'] = '123456'\\r\\n outcookie = Cookie()\\r\\n req = Mock(authname='john', base_path='/', incookie=incookie,\\r\\n outcookie=outcookie)\\r\\n session = Session(self.env, req)\\r\\n self.assertEqual('john', session.sid)\\r\\n session.save()\\r\\n\\r\\n cursor.execute(\\\"SELECT sid,authenticated FROM session\\\")\\r\\n self.assertEqual(('john', 1), cursor.fetchone())\\r\\n self.assertEqual(None, cursor.fetchone())\",\n \"def test_login():\\n My.search_merchant_page(driver, My.Testing_Env_EN)\\n validate_login()\\n print('----------')\\n My.search_merchant_page(driver, My.Testing_Env_FR)\\n validate_login()\\n driver.quit()\",\n \"def testSignOutAndSignBackIn(self):\\n self.host.ContinueAuth()\\n self.host.SignIn(self.account['username'], self.account['password'])\\n self.host.AllowAccess()\\n self.host.SignOut()\\n self.host.ContinueAuth()\\n self.host.AllowAccess()\",\n \"def test_ap_hs20_session_info(dev, apdev):\\n bssid = apdev[0]['bssid']\\n params = hs20_ap_params()\\n params['nai_realm'] = [ \\\"0,example.com,21[2:4]\\\" ]\\n hostapd.add_ap(apdev[0]['ifname'], params)\\n\\n dev[0].request(\\\"SET pmf 1\\\")\\n dev[0].hs20_enable()\\n dev[0].add_cred_values({ 'realm': \\\"example.com\\\",\\n 'username': \\\"hs20-session-info-test\\\",\\n 'password': \\\"password\\\" })\\n interworking_select(dev[0], bssid, freq=\\\"2412\\\")\\n interworking_connect(dev[0], bssid, \\\"TTLS\\\")\\n ev = dev[0].wait_event([\\\"ESS-DISASSOC-IMMINENT\\\"], timeout=10)\\n if ev is None:\\n raise Exception(\\\"Timeout on ESS disassociation imminent notice\\\")\\n if \\\" 1 59904 https://example.com/\\\" not in ev:\\n raise Exception(\\\"Unexpected ESS disassociation imminent event contents\\\")\\n ev = dev[0].wait_event([\\\"CTRL-EVENT-SCAN-STARTED\\\"])\\n if ev is None:\\n raise Exception(\\\"Scan not started\\\")\\n ev = dev[0].wait_event([\\\"CTRL-EVENT-SCAN-RESULTS\\\"])\\n if ev is None:\\n raise Exception(\\\"Scan not completed\\\")\",\n \"def test_login(self):\\n user = UUIDUser.objects.create_user(username=\\\"uuid\\\", password=\\\"test\\\")\\n self.assertTrue(self.client.login(username=\\\"uuid\\\", password=\\\"test\\\"))\\n self.assertEqual(\\n UUIDUser.objects.get(pk=self.client.session[SESSION_KEY]), user\\n )\",\n \"def __init__(self, user, password, device):\\n self.user = user\\n self.password = password\\n self.device = device\\n self.session = requests.session()\\n\\n # Hard-coded auth seed\\n seed = \\\"oZ7QE6LcLJp6fiWzdqZc\\\"\\n\\n # Get auth tokens\\n sha1p = sha.new(user.lower() + password + seed)\\n sha1p = sha1p.hexdigest()\\n\\n auth_server = \\\"vera-us-oem-autha11.mios.com\\\"\\n\\n url = \\\"https://%s/autha/auth/username/%s?SHA1Password=%s&PK_Oem=1\\\" % \\\\\\n (auth_server, user.lower(), sha1p)\\n\\n response = self.session.get(url).json()\\n\\n self.server_account = response[\\\"Server_Account\\\"]\\n self.auth_token = response[\\\"Identity\\\"]\\n self.auth_sig = response[\\\"IdentitySignature\\\"]\\n\\n # Get account number\\n account_info = json.loads(base64.b64decode(self.auth_token))\\n pk_account = account_info[\\\"PK_Account\\\"]\\n sys.stderr.write(\\\"Account number: %s\\\\n\\\" % pk_account)\\n\\n # Get session token for server account\\n session_token = self.get_session_token(self.server_account)\\n\\n # Get devices\\n headers = { \\\"MMSSession\\\": session_token }\\n url = \\\"https://%s/account/account/account/%s/devices\\\" % \\\\\\n (self.server_account, str(pk_account))\\n devices = self.session.get(url, headers=headers).json()\\n\\n # Work out server device\\n server_device = None\\n for i in devices[\\\"Devices\\\"]:\\n if i[\\\"PK_Device\\\"] == device:\\n server_device = i[\\\"Server_Device\\\"]\\n if server_device == None:\\n raise RuntimeError, \\\"Device %s not known.\\\\n\\\" % device\\n \\n sys.stderr.write(\\\"Server device: %s\\\\n\\\" % server_device)\\n\\n # Get session token on server_device\\n session_token = self.get_session_token(server_device)\\n\\n # Get server_relay\\n headers = { \\\"MMSSession\\\": session_token }\\n\\n url = \\\"https://\\\" + server_device + \\\"/device/device/device/\\\" + \\\\\\n str(device)\\n\\n relay_info = self.session.get(url, headers=headers).json()\\n\\n self.relay = relay_info[\\\"Server_Relay\\\"]\\n\\n sys.stderr.write(\\\"Server relay: %s\\\\n\\\" % self.relay)\\n\\n # Get session token on server_relay\\n self.session_token = self.get_session_token(self.relay)\\n\\n Vera.__init__(self)\\n\\n sys.stderr.write(\\\"Connected to remote device.\\\\n\\\")\",\n \"def NavigateGuestLogin(self):\\n self._ExecuteOobeApi('Oobe.guestLoginForTesting')\",\n \"def test_session_auth_token(self):\\n\\n sess1 = None\\n sess2 = None\\n test_header = {'X-Auth-Token': 'pretend_token'}\\n\\n with self.app_sess1 as c:\\n ret = c.get('/', headers=test_header)\\n sess1 = ret.data\\n\\n with self.app_sess2 as c:\\n ret = c.get('/', headers=test_header)\\n sess2 = ret.data\\n\\n self.assertEqual(sess1, sess2)\",\n \"def test_login_successful():\\n user_info = {\\\"password\\\": \\\"abc123\\\", \\\"username\\\": \\\"0450539776\\\",}\\n response = requests.get(\\\"http://127.0.0.1:7700/login\\\", params=user_info)\\n assert(response.status_code == 200)\\n assert(\\\"token\\\" in response.json())\",\n \"def login(self, returnToURL):\\r\\n\\t\\tif not self.request().hasValue('userId') or \\\\\\r\\n\\t\\t\\tnot self.request().hasValue('password'):\\r\\n\\t\\t\\tself.response().sendRedirect('/nova/login.psp?returnToURL=%s' % returnToURL)\\r\\n\\t\\t\\treturn 0\\r\\n\\t\\treturn 1\",\n \"def test_shib_login_enrollment(self):\\r\\n student = UserFactory.create()\\r\\n extauth = ExternalAuthMap(external_id='testuser@stanford.edu',\\r\\n external_email='',\\r\\n external_domain='shib:https://idp.stanford.edu/',\\r\\n external_credentials=\\\"\\\",\\r\\n internal_password=\\\"password\\\",\\r\\n user=student)\\r\\n student.set_password(\\\"password\\\")\\r\\n student.save()\\r\\n extauth.save()\\r\\n\\r\\n course = CourseFactory.create(org='Stanford', number='123', display_name='Shib Only')\\r\\n course.enrollment_domain = 'shib:https://idp.stanford.edu/'\\r\\n self.store.update_item(course, '**replace_user**')\\r\\n\\r\\n # use django test client for sessions and url processing\\r\\n # no enrollment before trying\\r\\n self.assertFalse(CourseEnrollment.is_enrolled(student, course.id))\\r\\n self.client.logout()\\r\\n request_kwargs = {'path': '/shib-login/',\\r\\n 'data': {'enrollment_action': 'enroll', 'course_id': course.id.to_deprecated_string(), 'next': '/testredirect'},\\r\\n 'follow': False,\\r\\n 'REMOTE_USER': 'testuser@stanford.edu',\\r\\n 'Shib-Identity-Provider': 'https://idp.stanford.edu/'}\\r\\n response = self.client.get(**request_kwargs)\\r\\n # successful login is a redirect to \\\"/\\\"\\r\\n self.assertEqual(response.status_code, 302)\\r\\n self.assertEqual(response['location'], 'http://testserver/testredirect')\\r\\n # now there is enrollment\\r\\n self.assertTrue(CourseEnrollment.is_enrolled(student, course.id))\\r\\n\\r\\n # Clean up and try again with POST (doesn't happen with real production shib, doing this for test coverage)\\r\\n self.client.logout()\\r\\n CourseEnrollment.unenroll(student, course.id)\\r\\n self.assertFalse(CourseEnrollment.is_enrolled(student, course.id))\\r\\n\\r\\n response = self.client.post(**request_kwargs)\\r\\n # successful login is a redirect to \\\"/\\\"\\r\\n self.assertEqual(response.status_code, 302)\\r\\n self.assertEqual(response['location'], 'http://testserver/testredirect')\\r\\n # now there is enrollment\\r\\n self.assertTrue(CourseEnrollment.is_enrolled(student, course.id))\",\n \"def test_adtls(self):\\n for domain in config.ADW2K12_DOMAINS:\\n principal = '%s@%s' % (config.ADW2k12_USER1, domain)\\n\\n testflow.step(\\\"Login as user %s\\\", config.ADW2k12_USER1)\\n users.loginAsUser(\\n principal,\\n self.conf['authn_name'],\\n config.ADW2k12_USER_PASSWORD,\\n True,\\n )\\n\\n testflow.step(\\n \\\"Testing connection with user %s\\\", config.ADW2k12_USER1\\n )\\n assert common.connectionTest(), \\\"User %s can't login.\\\" % principal\",\n \"def test_create_session(self):\\n finder = FinderInsidePro(self.test_key)\\n session_id = finder.create_session(2811)\\n assert isinstance(session_id, str)\\n assert session_id == finder.session_id\\n assert len(session_id)\",\n \"def test_auth_success(self):\\n request = self.factory.get(resolve('/'))\\n response = Login.as_view()(request)\\n self.assertEqual(response.status_code, 200)\\n data = {\\n 'username': 'pravin.gordhan',\\n 'password': 'pravin.gordhan'\\n }\\n request = self.factory.post(resolve('/'), data)\\n request.session = self.client.session\\n response = Login.as_view()(request)\\n self.assertEqual(response.url, '/employee/dashboard/')\",\n \"def connect(self):\\n if time.time() < self._login_cooldown:\\n raise FailedToConnect(\\\"login on cooldown\\\")\\n\\n session = yield from self.get_session()\\n resp = yield from session.post(\\\"https://public-ubiservices.ubi.com/v3/profiles/sessions\\\", headers = {\\n \\\"Content-Type\\\": \\\"application/json\\\",\\n \\\"Ubi-AppId\\\": self.appid,\\n \\\"Authorization\\\": \\\"Basic \\\" + self.token\\n }, data=json.dumps({\\\"rememberMe\\\": True}))\\n\\n data = yield from resp.json()\\n\\n message = \\\"Unknown Error\\\"\\n if \\\"message\\\" in data and \\\"httpCode\\\" in data:\\n message = \\\"HTTP %s: %s\\\" % (data[\\\"httpCode\\\"], data[\\\"message\\\"])\\n elif \\\"message\\\" in data:\\n message = data[\\\"message\\\"]\\n elif \\\"httpCode\\\" in data:\\n message = str(data[\\\"httpCode\\\"])\\n\\n if \\\"ticket\\\" in data:\\n self.key = data.get(\\\"ticket\\\")\\n self.sessionid = data.get(\\\"sessionId\\\")\\n self.uncertain_spaceid = data.get(\\\"spaceId\\\")\\n else:\\n raise FailedToConnect(message)\",\n \"def loginAsManager(self):\\n self.browser.open('http://nohost/plone/')\\n self.browser.getLink('Log in').click()\\n self.browser.getControl('Login Name').value = 'root'\\n self.browser.getControl('Password').value = 'secret'\\n self.browser.getControl('Log in').click()\",\n \"def test_patient_login(self):\\n\\n data = {\\\"email\\\": \\\"jsmith@gmail.com\\\", \\\"password\\\": \\\"password\\\"}\\n result = self.client.post(\\\"/patient-login\\\", data=data,\\n follow_redirects=True)\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b\\\"Patient Dashboard\\\", result.data)\\n\\n data = {\\\"email\\\": \\\"jsmith@gmail.com\\\", \\\"password\\\": \\\"pass\\\"}\\n result = self.client.post(\\\"/patient-login\\\", data=data,\\n follow_redirects=True)\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b\\\"Incorrect password\\\", result.data)\\n\\n data = {\\\"email\\\": \\\"jsmith33@gmail.com\\\", \\\"password\\\": \\\"password\\\"}\\n result = self.client.post(\\\"/patient-login\\\", data=data,\\n follow_redirects=True)\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b\\\"No account with\\\", result.data)\",\n \"def test_reopen_session(self):\\n first_session_id = self._open_session()\\n second_session_id = self._open_session(expect_termination=first_session_id, expect_initial=False)\\n self.assertNotEqual(first_session_id, second_session_id)\",\n \"def the_user_should_be_able_to_connect_to_one_of_the_devices():\\n assert web_app.connect_to_device1()\",\n \"def test_agentpi_login(self):\\n param = {\\n 'username' : \\\"seth\\\", \\n 'password' : \\\"testing\\\"\\n }\\n response = param\\n\\n self.assertEqual(response.text, \\\"User Exists\\\")\",\n \"def logIn2(self, token1, token2):\\n self.driver = webdriver.Firefox()\\n self.driver.get(\\\"https://twitter.com/login\\\")\\n\\n username_field = self.driver.find_element_by_class_name(\\\"js-username-field\\\")\\n password_field = self.driver.find_element_by_class_name(\\\"js-password-field\\\")\\n\\n time.sleep(2)\\n username_field.send_keys(token1)\\n self.driver.implicitly_wait(1)\\n\\n time.sleep(2)\\n password_field.send_keys(token2)\\n self.driver.implicitly_wait(1)\\n\\n self.driver.find_element_by_class_name(\\\"EdgeButtom--medium\\\").click()\",\n \"def test_login_with_correct_authentication_success(self):\\n user = {\\n \\\"Email\\\": \\\"fyi@g.com\\\",\\n \\\"Type\\\": \\\"passenger\\\",\\n \\\"Password\\\": \\\"pass234\\\",\\n \\\"Confirm Password\\\": \\\"pass234\\\"\\n }\\n response = self.client().post('/api/v1/auth/register',\\n data=user)\\n self.assertEqual(response.status_code, 201)\\n logins = {\\\"Email\\\": \\\"fyi@g.com\\\", \\\"Password\\\": \\\"pass234\\\"}\\n res = self.client().post('/api/v1/auth/login', data=logins)\\n self.assertTrue(res.status_code, 200)\",\n \"def test_auth_code_positive(self, api):\\n self.builder.add_user(api.get_user())\\n resp = api.login_user(api.get_user().username, api.get_user().password)\\n self.builder.del_user(api.get_user())\\n assert resp.status_code == 200\",\n \"def logUserIn(self):\\n self.browser.get(self.live_server_url)\\n self.browser.get(self.live_server_url + reverse('registration:auth_login').rstrip())\\n self.assertIn(\\n 'login',\\n self.browser.current_url\\n )\\n self.browser.find_element_by_name('username').send_keys(TEST_USER['username'])\\n self.browser.find_element_by_id('id_password').send_keys(TEST_USER['password'])\\n self.browser.find_element_by_id('submit-login').click()\",\n \"def test_professor_can_login_to_web_portal(professor):\",\n \"def test_login():\\n headers = {}\\n data = {\\\"role\\\": args.k8s_namespace, \\\"jwt\\\": args.k8s_sa_jwt}\\n url = \\\"{0}/auth/{1}/login\\\".format(args.vault_url, args.k8s_cluster_name)\\n print \\\"Testing login to confirm that the integration is working\\\"\\n req = send_post(url=url, data=data, headers=headers, return_output=True)\\n if str(req.status_code).startswith('2'):\\n print 'SUCCESS! Login request returned {0} {1}'.format(req.status_code, req.reason)\\n else:\\n print 'FAIL! {0} {1} {2}'.format(req.status_code, req.reason, req.content)\\n exit(77)\",\n \"def test_admin_can_login_to_web_portal(admin):\",\n \"def test_login(self):\\n url_extend = 'user_auth/login/'\\n self.browser.get(self.url + url_extend)\\n\\n # enter the username and password.\\n username_field = self.browser.find_element_by_name('user_name')\\n username_field.send_keys('user4')\\n password_field = self.browser.find_element_by_name('password')\\n password_field.send_keys('user')\\n\\n # click login button.\\n # get the first input button under the first form in login page.\\n login_button = self.browser.find_element_by_xpath(\\\"//form[1]/fieldset[1]/input[@type='submit']\\\")\\n try:\\n login_button.click()\\n except:\\n raise Exception(\\\"Login Error!\\\")\",\n \"def test_login(self):\\n # Signup a user\\n response = self.client.post('/api/v1/auth/signup',\\n data=json.dumps(self.new_user2),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 201)\\n\\n # Test user login\\n response = self.client.post('/api/v1/auth/login',\\n data=json.dumps(self.login_details),\\n content_type='application/json')\\n self.assertEqual(response.status_code, 200)\",\n \"def test_login(self):\\n\\t\\tdata = {'username' : 'testUser2', 'password' : 'passTestUser'}\\n\\t\\tresponse = self.login(data)\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_200_OK)\\n\\t\\ttry:\\n\\t\\t\\ttoken = response.data[\\\"token\\\"]\\n\\t\\texcept AttributeError:\\n\\t\\t\\tself.fail(\\\"No token attribute\\\")\",\n \"def login_to_apic(self):\\n session = Session(URL, LOGIN, PASSWORD)\\n resp = session.login()\\n self.assertTrue(resp.ok)\\n return session\",\n \"def login(self):\\n\\t\\treturn\",\n \"def test_user_login():\\n app = create_ctfd()\\n with app.app_context():\\n register_user(app)\\n client = login_as_user(app)\\n r = client.get('/profile')\\n assert r.location != \\\"http://localhost/login\\\" # We didn't get redirected to login\\n assert r.status_code == 200\\n destroy_ctfd(app)\",\n \"def test_m19bqj_236(setup):\\n tiger_obj = Tiger(browser_name=browser_name)\\n tiger_obj.login(username=username, password=password)\",\n \"def test_logging_running(self):\\n tester = app.test_client(self)\\n response = tester.get('/login', content_type='html/text')\\n self.assertTrue(b'PLEASE LOGIN' in response.data)\",\n \"def test_client_session_with_argument():\\n with c.session('com.apple.mobilesafari', ['-u', 'https://www.github.com']) as s:\\n time.sleep(1.0)\\n s(id='URL')\\n assert s(name='Share', className=\\\"Button\\\").exists\",\n \"def test001_authenticate_user(self):\\n self.lg('%s STARTED' % self._testID)\\n\\n self.lg('- Create user1 with admin access ')\\n old_password = str(uuid.uuid4()).replace('-', '')[0:10]\\n user1 = self.cloudbroker_user_create(group='admin', password=old_password)\\n\\n self.lg(\\\"- Authenticate U1 ,should return session key[user1_key] .\\\")\\n user1_key = self.get_authenticated_user_api(username=user1, password=old_password)\\n self.assertTrue(user1_key)\\n\\n self.lg(\\\"- Use U1's key to list the accounts for U1, should succeed.\\\")\\n accounts_list = user1_key.cloudapi.accounts.list()\\n self.assertEqual(accounts_list, [])\",\n \"def test_verify_connection_to_a_device():\",\n \"def test_exception_shib_login(self):\\r\\n no_remote_user_request = self.request_factory.get('/shib-login')\\r\\n no_remote_user_request.META.update({'Shib-Identity-Provider': IDP})\\r\\n no_remote_user_response = shib_login(no_remote_user_request)\\r\\n self.assertEqual(no_remote_user_response.status_code, 403)\\r\\n self.assertIn(\\\"identity server did not return your ID information\\\", no_remote_user_response.content)\\r\\n\\r\\n no_idp_request = self.request_factory.get('/shib-login')\\r\\n no_idp_request.META.update({'REMOTE_USER': REMOTE_USER})\\r\\n no_idp_response = shib_login(no_idp_request)\\r\\n self.assertEqual(no_idp_response.status_code, 403)\\r\\n self.assertIn(\\\"identity server did not return your ID information\\\", no_idp_response.content)\",\n \"def login(self):\\n login_form = {\\\"kid\\\": \\\"\\\",\\n \\\"uni\\\": self.server,\\n \\\"login\\\": self.username,\\n \\\"pass\\\": self.password}\\n url = \\\"https://%s.ogame.gameforge.com/main/login\\\" % self.country_code\\n result = self.session.post(url, data=login_form)\",\n \"def test_admin_user_login(self):\\n self.login(\\\"admin\\\", \\\"admin\\\")\\n self.should_see(\\\"This is your profile, admin.\\\")\",\n \"def login_bot(self):\\n pass\",\n \"def test_login_POST_2(self):\\r\\n\\r\\n User.signup(username='testuser2',\\r\\n password=\\\"PASSWORD\\\", location=\\\"US-FL\\\")\\r\\n db.session.commit()\\r\\n with app.app_context():\\r\\n form = UserLoginForm(username='testuser2',\\r\\n password='WRONG_PASSWORD')\\r\\n with self.client:\\r\\n response = self.client.post(\\r\\n '/login', data=form.data, follow_redirects=True)\\r\\n self.assertIn(b'Invalid credentials.', response.data)\",\n \"def new_session(self):\\n body = yield from self._fetch_json(URL_LOGIN, self._new_session_data)\\n self.sma_sid = jmespath.search('result.sid', body)\\n if self.sma_sid:\\n return True\\n\\n msg = 'Could not start session, %s, got {}'.format(body)\\n\\n if body.get('err'):\\n if body.get('err') == 503:\\n _LOGGER.error(\\\"Max amount of sesions reached\\\")\\n else:\\n _LOGGER.error(msg, body.get('err'))\\n else:\\n _LOGGER.error(msg, \\\"Session ID expected [result.sid]\\\")\\n return False\",\n \"def login_client(self, client):\\n test_login(client, self._email, self._user_pw)\",\n \"def test_auth_positive(self, new_user):\\n new = new_user\\n response = self.api_client.login(new.username, new.password)\\n assert new.username in response\",\n \"def test_api_livesession_read_token_lti_admin_instruct_token_email_ok(self):\\n # livesession with another email and lti_user_id\\n livesession = LiveSessionFactory(\\n is_registered=True,\\n is_from_lti_connection=True,\\n email=\\\"different@aol.com\\\", # explicit to be found in response\\n video__playlist__lti_id=\\\"Maths\\\", # explicit to be found in response\\n username=\\\"Sam\\\", # explicit to be found in response\\n )\\n jwt_token = InstructorOrAdminLtiTokenFactory(\\n playlist=livesession.video.playlist,\\n context_id=str(livesession.video.playlist.lti_id),\\n consumer_site=str(livesession.consumer_site.id),\\n )\\n\\n response = self.client.get(\\n self._get_url(livesession.video, livesession),\\n HTTP_AUTHORIZATION=f\\\"Bearer {jwt_token}\\\",\\n )\\n self.assertEqual(response.status_code, 200)\\n self.assertEqual(\\n response.json(),\\n {\\n \\\"anonymous_id\\\": None,\\n \\\"consumer_site\\\": str(livesession.video.playlist.consumer_site_id),\\n \\\"display_name\\\": None,\\n \\\"email\\\": \\\"different@aol.com\\\",\\n \\\"id\\\": str(livesession.id),\\n \\\"is_registered\\\": True,\\n \\\"language\\\": \\\"en\\\",\\n \\\"live_attendance\\\": None,\\n \\\"lti_user_id\\\": livesession.lti_user_id,\\n \\\"lti_id\\\": \\\"Maths\\\",\\n \\\"should_send_reminders\\\": True,\\n \\\"username\\\": \\\"Sam\\\",\\n \\\"video\\\": str(livesession.video.id),\\n },\\n )\",\n \"def login():\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79027075","0.6791165","0.6721474","0.6619786","0.65200156","0.649458","0.64693856","0.64288","0.6404014","0.64035445","0.63950443","0.63943654","0.6369294","0.6346183","0.6331206","0.6299405","0.6282982","0.6256549","0.6255143","0.6224549","0.62157404","0.61894566","0.61894566","0.6181815","0.61738956","0.6173311","0.6163155","0.6156066","0.6153292","0.6142292","0.6130478","0.61284816","0.6099908","0.6089325","0.6083194","0.6066931","0.6047024","0.6043349","0.6039505","0.60380214","0.60330987","0.60234267","0.6013669","0.60097337","0.6004352","0.6002598","0.59888","0.59874964","0.59809446","0.5969401","0.59601563","0.5950834","0.5948093","0.59408295","0.5940635","0.5938504","0.593316","0.5925709","0.5921006","0.5896199","0.5892841","0.5891341","0.589123","0.5881812","0.5881591","0.5879211","0.5876336","0.58760357","0.5855335","0.58512276","0.5849567","0.5845822","0.5835531","0.5832502","0.5831396","0.58168817","0.58118814","0.58081526","0.58073074","0.58069736","0.5804965","0.58040935","0.580302","0.5800942","0.5794123","0.57917565","0.57903117","0.5776569","0.5775232","0.5771579","0.5769491","0.576748","0.57607186","0.5759392","0.5756558","0.5755044","0.57530993","0.574913","0.57486284","0.5747646"],"string":"[\n \"0.79027075\",\n \"0.6791165\",\n \"0.6721474\",\n \"0.6619786\",\n \"0.65200156\",\n \"0.649458\",\n \"0.64693856\",\n \"0.64288\",\n \"0.6404014\",\n \"0.64035445\",\n \"0.63950443\",\n \"0.63943654\",\n \"0.6369294\",\n \"0.6346183\",\n \"0.6331206\",\n \"0.6299405\",\n \"0.6282982\",\n \"0.6256549\",\n \"0.6255143\",\n \"0.6224549\",\n \"0.62157404\",\n \"0.61894566\",\n \"0.61894566\",\n \"0.6181815\",\n \"0.61738956\",\n \"0.6173311\",\n \"0.6163155\",\n \"0.6156066\",\n \"0.6153292\",\n \"0.6142292\",\n \"0.6130478\",\n \"0.61284816\",\n \"0.6099908\",\n \"0.6089325\",\n \"0.6083194\",\n \"0.6066931\",\n \"0.6047024\",\n \"0.6043349\",\n \"0.6039505\",\n \"0.60380214\",\n \"0.60330987\",\n \"0.60234267\",\n \"0.6013669\",\n \"0.60097337\",\n \"0.6004352\",\n \"0.6002598\",\n \"0.59888\",\n \"0.59874964\",\n \"0.59809446\",\n \"0.5969401\",\n \"0.59601563\",\n \"0.5950834\",\n \"0.5948093\",\n \"0.59408295\",\n \"0.5940635\",\n \"0.5938504\",\n \"0.593316\",\n \"0.5925709\",\n \"0.5921006\",\n \"0.5896199\",\n \"0.5892841\",\n \"0.5891341\",\n \"0.589123\",\n \"0.5881812\",\n \"0.5881591\",\n \"0.5879211\",\n \"0.5876336\",\n \"0.58760357\",\n \"0.5855335\",\n \"0.58512276\",\n \"0.5849567\",\n \"0.5845822\",\n \"0.5835531\",\n \"0.5832502\",\n \"0.5831396\",\n \"0.58168817\",\n \"0.58118814\",\n \"0.58081526\",\n \"0.58073074\",\n \"0.58069736\",\n \"0.5804965\",\n \"0.58040935\",\n \"0.580302\",\n \"0.5800942\",\n \"0.5794123\",\n \"0.57917565\",\n \"0.57903117\",\n \"0.5776569\",\n \"0.5775232\",\n \"0.5771579\",\n \"0.5769491\",\n \"0.576748\",\n \"0.57607186\",\n \"0.5759392\",\n \"0.5756558\",\n \"0.5755044\",\n \"0.57530993\",\n \"0.574913\",\n \"0.57486284\",\n \"0.5747646\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.82061094"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":23599,"cells":{"query":{"kind":"string","value":"Load and return the malicious scripts dataset (classification). Returns"},"document":{"kind":"string","value":"def load_crawl():\n\n\tmodule_path = dirname(__file__)\n\twith open(join(module_path, 'data', 'train2.csv')) as csv_file:\n\t\tdata_file = csv.reader(csv_file)\n\t\ttemp = next(data_file)\n\t\tglobal n_samples\n\t\tn_samples = int(temp[0])\n\t\tglobal n_features\n\t\tn_features = int(temp[1])\n\t\tprint \"n samples \" + str((n_samples))\n\t\tprint \"n_features\" + str((n_features))\n\t\ttarget_names = np.array(temp[2:4])\n\t\tdata = np.empty((n_samples, n_features))\n\t\ttarget = np.empty((n_samples,), dtype=np.int)\n\n\t\tfor count, value in enumerate(data_file):\n\t\t\tdata[count] = np.asarray(value[:-1], dtype=np.float)\n\t\t\ttarget[count] = np.asarray(value[-1], dtype=np.int)\n\t\t\t#print \"data is \" + str(data[count])\n\t\t\t#print \"target is \" + str(target[count])\n\t\tprint \"Number of target records is \" + str(len(target))\n\t#with open(join(module_path, 'descr', 'train.rst')) as rst_file:\n\t#\tfdescr = rst_file.read()\n\n\treturn Bunch(data=data, target=target,\n\t\t\t target_names=target_names,\n\t\t\t DESCR=None,\n\t\t\t feature_names = ['evalCount', 'setInterval', 'setTimeout', 'link', \n\t\t\t\t\t\t\t 'search', 'exec','escape', 'unescape', 'ratio', \n\t\t\t\t\t\t\t 'emtropyAvg', 'entropyScript', 'longStrings', \n\t\t\t\t\t\t\t 'maxEntropy', 'stringAvg', 'maxLength', 'longVarFunc', \n\t\t\t\t\t\t\t 'stringAssignments', 'stringModFuncsCount', 'eventFuncsCount', \n\t\t\t\t\t\t\t 'domModFuncsCounter', 'suspStrings', 'whiteSpaceRatio', \n\t\t\t\t\t\t\t 'hexaStrings', 'maxNonPrintableCharactersinString', 'lineAvg', \n\t\t\t\t\t\t\t 'iframeCount', 'malTagCount', 'jsLength'])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _load_original_dataset(data_directory, setname):\n\n Sign = collections.namedtuple(\"Sign\", [\"visibility\", \"type\", \"name\"])\n data_directory = pathlib.Path(data_directory)\n filename = data_directory / setname / \"annotations.txt\"\n with tf.io.gfile.GFile(filename) as f:\n files, annotations = zip(*(l.strip().split(\":\", 1) for l in f))\n\n all_signs = []\n for annotation in annotations:\n signs = []\n for sign in annotation.split(\";\"):\n if sign == [\"\"] or not sign: continue\n parts = [s.strip() for s in sign.split(\",\")]\n if parts[0] == \"MISC_SIGNS\": continue\n signs.append(Sign(parts[0], parts[5], parts[6]))\n all_signs.append(signs)\n\n filepaths = (data_directory / setname / f for f in files)\n return zip(filepaths, all_signs)","def load_all_script(train_rating_path,test_negative_path, test_num=100):\n\ttrain_data = pd.read_csv(\n\t\ttrain_rating_path, \n\t\tsep='\\t', header=None, names=['user', 'item'], \n\t\tusecols=[0, 1], dtype={0: np.int32, 1: np.int32})\n\n\tuser_num = train_data['user'].max() + 1\n\titem_num = train_data['item'].max() + 1\n\n\ttrain_data = train_data.values.tolist()\n\n\t# load ratings as a dok matrix\n\ttrain_mat = sp.dok_matrix((user_num, item_num), dtype=np.float32)\n\tfor x in train_data:\n\t\ttrain_mat[x[0], x[1]] = 1.0\n\n\ttest_data = []\n\twith open(test_negative_path, 'r') as fd:\n\t\tline = fd.readline()\n\t\twhile line != None and line != '':\n\t\t\tarr = line.split('\\t')\n\t\t\tu = eval(arr[0])[0]\n\t\t\ttest_data.append([u, eval(arr[0])[1]])\n\t\t\tfor i in arr[1:]:\n\t\t\t\ttest_data.append([u, int(i)])\n\t\t\tline = fd.readline()\n\treturn train_data, test_data, user_num, item_num, train_mat","def load_classification_dataset(step, do_lower_case,data_type,data_subtype,use_syntetic_data):\n assert step in ['train', 'test']\n binary = False \n undersample_majority = False\n\n paths = ['~/Github/Data/Patient/NIRADS/PET_CT_NIRADS.xlsx', '~/Github/Data/Patient/NIRADS/MR_NIRADS_2018.xlsx','~/Github/Data/Patient/NIRADS/MR_NIRADS.xlsx']\n if data_type == 'ct':\n data_r = pd.read_excel(paths[0])\n else:\n data_r = pd.read_excel(paths[1])\n data_r.append(pd.read_excel(paths[2]), ignore_index = True, sort=False)\n\n data_p,data_n, y_p, y_n = tc.text_cleaning(data_r, None, data_target='section') \n\n if data_subtype == 'primary':\n data = data_p\n y = y_p -1\n else:\n data = data_n\n y = y_n -1\n\n if binary:\n y[y<2]=0\n y[y>0]=1\n\n y_dist = [np.sum(y==x) for x in np.unique(y)]\n print(\"Distribution of all labels: \", y_dist, \"\\n\\n\")\n\n train_text, test_text, y_train, y_test = train_test_split(data, y, test_size=0.2, random_state=1)\n\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\n print(\"Distribution of training labels: \", y_dist, \"\\n\\n\")\n\n if step =='train':\n if use_syntetic_data:\n data_syntetic = pd.read_csv('~/Github/Data/Patient/NIRADS/PET_CT_NIRADS_syntetic.csv')\n train_text = np.concatenate((train_text,data_syntetic['syntetic_data'].values))\n y_train = np.concatenate((y_train,data_syntetic['syntetic_label'].values-1))\n\n train_text, test_text, y_train, y_test = train_test_split(train_text, y_train, test_size=0.5, random_state=1)\n train_text = np.concatenate((train_text,test_text))\n y_train = np.concatenate((y_train,y_test))\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\n print(\"Distribution of training labels after inserting syntetic data: \", y_dist, \"\\n\\n\")\n\n if not undersample_majority:\n data_to_use = train_text.copy()\n y_to_use = y_train.copy()\n else:\n max_label1 = 1000\n data_to_use = []\n y_to_use = []\n y1=0\n for x in range(len(y_train)):\n if y_train[x] !=1:\n data_to_use.append(train_text[x])\n y_to_use.append(y_train[x])\n else:\n if y1 <max_label1:\n data_to_use.append(train_text[x])\n y_to_use.append(y_train[x])\n y1+=1\n\n else:\n data_to_use = test_text.copy()\n y_to_use = y_test.copy()\n\n basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)\n examples = []\n\n for i, tokens in tqdm(enumerate(data_to_use)):\n label = y_to_use[i]\n examples.append(\n ClassificationExample(\n id=i,\n tokens_a=basic_tokenizer.tokenize(tokens),\n tokens_b=None,\n label=label,\n )\n )\n logging.info('Number of `%s` examples: %d', step, len(examples))\n \n return examples","def load_data(self):\n return self._load_data(\"--codemeta-file\")","def import_datasets(snli_path):\n print('extract data from snli directory..')\n train = dict(); dev = dict(); test = dict()\n gold_labels = {'entailment': 0, 'neutral': 1, 'contradiction': 2}\n\n for file_type in ['train', 'dev', 'test']:\n path = os.path.join(snli_path, 'snli_1.0_{}.jsonl'.format(file_type))\n with open(path) as file:\n data = [json.loads(line) for line in file]\n eval(file_type)['premise'] = [entry['sentence1'] for entry in data if entry['gold_label'] != '-']\n eval(file_type)['hypothesis'] = [entry['sentence2'] for entry in data if entry['gold_label'] != '-']\n g_labels = np.array([gold_labels[entry['gold_label']] for entry in data if entry['gold_label'] != '-'])\n eval(file_type)['label'] = g_labels\n print('extraction process was finished successfully!')\n return train, dev, test","def load_cleaned_data(self):\n try:\n self.train = pd.read_pickle('../input/train_clean.pkl')\n self.test = pd.read_pickle('../input/test_clean.pkl')\n except FileNotFoundError:\n self.load_raw_data()","def load_raw_dataset(name):\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\n\n os.makedirs('downloads', exist_ok=True)\n path = os.path.join('downloads', name)\n path_raw = os.path.join(path, 'raw')\n\n if name == 'iris':\n prep_path(path)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', path_raw)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names', path_raw)\n return pd.read_csv(os.path.join(path_raw, 'iris.data'), names=['sepal_len', 'sepal_wid', 'petal_len', 'petal_wid', 'species'])\n\n elif name == 'wine':\n prep_path(path)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', path_raw)\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.names', path_raw)\n return pd.read_csv(os.path.join(path_raw, 'wine.data'), names=['class',\n 'alcohol',\n 'malic_acid',\n 'ash',\n 'alkalinity',\n 'magnesium',\n 'phenols',\n 'flavanoids',\n 'nonflavanoid_phenols',\n 'proanthocyanins',\n 'color_intensity',\n 'hue',\n 'dilution',\n 'proline'])\n\n elif name == 'titanic':\n import kaggle; kaggle.api.authenticate()\n prep_path(path)\n if len(os.listdir(path_raw)) == 0:\n kaggle.api.competition_download_files('titanic', path_raw)\n titanic = pd.read_csv(os.path.join(path_raw, 'train.csv'))\n titanic_test = pd.read_csv(os.path.join(path_raw, 'test.csv'))\n return titanic, titanic_test\n\n elif name == 'lanl':\n import kaggle; kaggle.api.authenticate()\n prep_path(path)\n if len(os.listdir(path)) == 0:\n kaggle.api.competition_download_files('LANL-Earthquake-Prediction', path_raw)\n if not os.path.exists(os.path.join(path_raw, 'test')):\n zip_ref = zipfile.ZipFile(os.path.join(path_raw, 'test.zip'), 'r')\n zip_ref.extractall(os.path.join(path_raw, 'test'))\n zip_ref.close()\n return pd.read_csv(os.path.join(path_raw, 'train.csv.zip'))\n\n elif name == 'MNIST':\n mnist = torchvision.datasets.MNIST('downloads', train=True, download=True)\n mnist_test = torchvision.datasets.MNIST('downloads', train=False, download=True)\n return mnist, mnist_test\n\n elif name == 'FashionMNIST':\n fmnist = torchvision.datasets.FashionMNIST('downloads', train=True, download=True)\n fmnist_test = torchvision.datasets.FashionMNIST('downloads', train=False, download=True)\n return fmnist, fmnist_test","def load_examples_data(dataset_name):\n dataset_name = dataset_name.strip().lower()\n if dataset_name.lower() not in ['pokemon', 'hanzi', 'animals', 'nsfw', 'simpsons', 'horse2zebra', 'people',\n 'autodrive', 'superresolution', 'anpr', 'beauty','antisproofing','facelandmarks','dogs-vs-cats','chinese']:\n raise ValueError('Not a valid dataset_name.')\n dataset_name = 'examples_' + dataset_name\n dirname = os.path.join(_trident_dir, dataset_name)\n if not os.path.exists(dirname):\n try:\n os.makedirs(dirname)\n except OSError:\n # Except permission denied and potential race conditions\n # in multi-threaded environments.\n pass\n is_internet_ok = is_connected()\n if dataset_name == 'examples_pokemon':\n is_download=download_file_from_google_drive('1U-xc54fX9j9BcidvRa0ow6qjssMlSF2A', dirname, 'pokemon.tar')\n tar_file_path = os.path.join(dirname, 'pokemon.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n extract_path = os.path.join(dirname, 'pokemon')\n dataset = load_folder_images(dataset_name, extract_path, folder_as_label=False)\n print('get pokemon images :{0}'.format(len(dataset)))\n return dataset\n\n\n elif dataset_name == 'examples_hanzi':\n download_file_from_google_drive('13UEzSG0az113gpRPKPyKrIE2HDaA2P4H', dirname, 'hanzi.tar')\n tar_file_path = os.path.join(dirname, 'hanzi.tar')\n extract_path = os.path.join(dirname, 'hanzi')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n dataset = load_folder_images(dataset_name, os.path.join(dirname, 'train'), folder_as_label=True,\n object_type=ObjectType.gray)\n\n dataset_test = load_folder_images(dataset_name, os.path.join(dirname, 'test'), folder_as_label=True,\n object_type=ObjectType.gray)\n\n dataset.testdata = dataset_test.traindata\n dataset.class_names['zh-cn'] = dataset.class_names['en-us']\n return dataset\n\n elif dataset_name == 'examples_animals':\n download_file_from_google_drive('19Cjq8OO6qd9k9TMZxlPjDpejDOdiHJoW', dirname, 'animals.tar')\n tar_file_path = os.path.join(dirname, 'animals.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n dataset = load_folder_images(dataset_name, dirname, folder_as_label=True)\n return dataset\n elif dataset_name == 'examples_nsfw':\n tar_file_path = os.path.join(dirname, 'nsfw.tar')\n if os.path.exists(tar_file_path) and get_file_create_time(tar_file_path)<datetime.datetime(2021, 2, 20, 0, 0, 0).timestamp():\n os.remove(tar_file_path)\n if os.path.exists(os.path.join(dirname,'porn_detection_data.pkl')):\n os.remove(os.path.join(dirname,'porn_detection_data.pkl'))\n _delete_h(dirname)\n download_file_from_google_drive('1EXpV2QUrSFJ7zJn8NqtqFl1k6HvXsUzp', dirname, 'nsfw.tar')\n\n extract_path = os.path.join(dirname, 'nsfw')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n folders = ['drawings', 'hentai', 'neutral', 'porn', 'sexy']\n data=unpickle(os.path.join(dirname,'porn_detection_data.pkl'))\n\n trainData = []\n testData = []\n trainLabel = []\n testLabel = []\n for n in range(5):\n folder=folders[n]\n trainData.extend(data[folder]['train'])\n trainLabel.extend([n]*len(data[folder]['train']))\n testData.extend(data[folder]['test'])\n testLabel.extend([n] * len(data[folder]['test']))\n\n trainarray = ImageDataset(trainData,object_type=ObjectType.rgb)\n trainlabel = LabelDataset(trainLabel,object_type=ObjectType.classification_label)\n train_iter = Iterator(data=trainarray, label=trainlabel)\n\n testarray = ImageDataset(testData,object_type=ObjectType.rgb)\n testlabel = LabelDataset(testLabel,object_type=ObjectType.classification_label)\n test_iter = Iterator(data=testarray, label=testlabel)\n print('training images: {0} test images:{1}'.format(len(trainarray), len(testarray)))\n\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\n dataset.binding_class_names(['drawing', 'hentai', 'neutral', 'porn', 'sexy'], 'en-us')\n dataset.binding_class_names(['绘画', '色情漫画', '中性', '色情', '性感'], 'zh-cn')\n dataset.binding_class_names(['繪畫', '色情漫畫', '中性', '色情', '性感'], 'zh-tw')\n dataset.scenario = 'train'\n return dataset\n elif dataset_name == 'examples_simpsons':\n download_file_from_google_drive('1hGNFbfBv3EZ4nx4Qod6PtSYzO8H4QIxC', dirname, 'simpsons.tar')\n tar_file_path = os.path.join(dirname, 'simpsons.tar')\n extract_path = os.path.join(dirname, 'simpsons')\n extract_archive(tar_file_path, extract_path, archive_format='tar')\n data_provider = load_folder_images(dataset_name, extract_path, folder_as_label=False)\n data_provider.traindata.unpair = RandomNoiseDataset(shape=(100), random_mode='normal')\n print('get simpsons images :{0}'.format(len(data_provider.traindata.data.items)))\n return data_provider\n elif dataset_name == 'examples_horse2zebra':\n download_file_from_google_drive('1pqj-T90Vh4wVNBV09kYZWgVPsZUA2f7U', dirname, 'horse2zebra.tar')\n tar_file_path = os.path.join(dirname, 'horse2zebra.tar')\n extract_path = os.path.join(dirname, 'horse2zebra')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n trainA = ImageDataset(list_images(os.path.join(dirname, 'trainA')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n trainB = ImageDataset(list_images(os.path.join(dirname, 'trainB')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n testA = ImageDataset(list_images(os.path.join(dirname, 'testA')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n testB = ImageDataset(list_images(os.path.join(dirname, 'testB')), object_type=ObjectType.rgb,\n get_image_mode=GetImageMode.processed)\n train_iter = Iterator(data=trainA, unpair=trainB)\n test_iter = Iterator(data=testA, unpair=testB)\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\n print('get horse2zebra images :{0}'.format(len(dataset)))\n return dataset\n elif dataset_name == 'examples_people':\n download_file_from_google_drive('1H7mJJfWpmXpRxurMZQqY4N_UXWLbQ2pT', dirname, 'people.tar')\n tar_file_path = os.path.join(dirname, 'people.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, 'imgs', '*.*g'))\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\n imgs=list(sorted(imgs))\n masks = list(sorted(masks))\n # make_dir_if_need(os.path.join(dirname, 'trimap'))\n # for i in range(len(masks)):\n # mask=mask2array(masks[i])\n # trimap=mask2trimap(mask)\n # save_mask(trimap,masks[i].replace('masks','trimap'))\n # print('trimap',len(masks))\n\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb)\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.binary_mask)\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\n print('get people images :{0}'.format(len(dataset)))\n return dataset\n elif dataset_name == 'examples_autodrive':\n download_file_from_google_drive('1JqPPeHqhWLqnI6bD8nuHcVx-Y56oIZMK', dirname, 'autodrive.tar')\n tar_file_path = os.path.join(dirname, 'autodrive.tar')\n extract_path = os.path.join(dirname, 'autodrive')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, 'images', '*.*g'))\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\n imgs = list(sorted(imgs))\n masks = list(sorted(masks))\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb,symbol='image')\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.color_mask,symbol='mask')\n\n def parse_code(l):\n if len(l.strip().split(\"\\t\")) == 2:\n a, b = l.replace('\\t\\t', '\\t').strip().split(\"\\t\")\n return tuple(int(i) for i in b.split(' ')), a\n\n label_codes, label_names = zip(\n *[parse_code(l) for l in open(os.path.join(dirname, \"label_colors.txt\")).readlines()])\n for i in range(len(label_codes)):\n mskdata.palette[label_names[i]] = label_codes[i]\n\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\n print('get autodrive images :{0}'.format(len(dataset)))\n return dataset\n elif dataset_name == 'examples_superresolution':\n download_file_from_google_drive('1v1uoymrWI_MLSiGvSGW7tWJYSnzzXpEQ', dirname, 'superresolution.tar')\n tar_file_path = os.path.join(dirname, 'superresolution.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\n imgs.extend(glob.glob(os.path.join(dirname, '*.bmp')))\n imgs = list(sorted(imgs))\n\n print('get super resolution images :{0}'.format(len(imgs)))\n\n imgdata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='lr')\n labeldata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='hr')\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=labeldata))\n return dataset\n elif dataset_name == 'examples_beauty':\n download_file_from_google_drive('1aJhxN9IqsxuayhRTm-gmxk6PiLe5wm9X', dirname, 'beauty.tar')\n tar_file_path = os.path.join(dirname, 'beauty.tar')\n\n extract_archive(tar_file_path, dirname, archive_format='tar')\n # 讀取圖片數據\n images_dict = {}\n with open(os.path.join(dirname, 'images_dict.pkl'), 'rb') as fp:\n images_dict = pickle.load(fp)\n\n f = open(os.path.join(dirname, 'All_Ratings.txt'), encoding='utf-8-sig').readlines()\n imgs = []\n landmarks = []\n ratings = []\n for row in f:\n data = row.strip().split('\\t')\n if 'images\\\\' + data[0] in images_dict:\n img = images_dict['images\\\\' + data[0]][0]\n img = img.transpose([2, 0, 1])[::-1].transpose([1, 2, 0])\n imgs.append(img)\n landmark = images_dict['images\\\\' + data[0]][1].astype(np.float32)\n landmarks.append(landmark)\n rating = (float(data[1])) / 5.00\n ratings.append(rating)\n print('{0} faces loaded...'.format(len(imgs)))\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb, symbol='faces')\n landmarkdata = LandmarkDataset(landmarks=landmarks, object_type=ObjectType.landmarks, symbol='target_landmarks')\n labeldata = LabelDataset(data=ratings,object_type=ObjectType.classification_label, symbol='target_beauty')\n data_provider = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=Dataset.zip(landmarkdata,labeldata)))\n return data_provider\n\n elif dataset_name == 'examples_facelandmarks':\n download_file_from_google_drive('1GtswQBAHPa_bXaB4tW2uOOQ8Lxfz2L5B', dirname, 'ibug_300W.tar')\n tar_file_path = os.path.join(dirname, 'ibug_300W.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n root_dir=os.path.join(dirname, 'ibug_300W_large_face_landmark_dataset')\n image_paths = {}\n landmarks = {}\n crops = {}\n\n for mode in ['train','test']:\n make_dir_if_need(os.path.join(dirname, 'crops',mode))\n tree = ElementTree.parse(os.path.join(root_dir, 'labels_ibug_300W_{0}.xml'.format(mode)))\n root = tree.getroot()\n image_paths[mode]=[]\n landmarks[mode] = []\n crops[mode] = []\n\n offset=5\n for j in tqdm(range(len(root[2]))):\n try:\n filename=root[2][j]\n landmark = []\n for num in range(68):\n x_coordinate = int(filename[0][num].attrib['x'])\n y_coordinate = int(filename[0][num].attrib['y'])\n landmark.append([x_coordinate, y_coordinate])\n landmark=np.asarray(landmark)\n\n crop = filename[0].attrib\n for k in crop.keys():\n crop[k] = int(crop[k]) if isinstance(crop[k], str) else crop[k]\n for k in crop.keys():\n if k=='top' and int(landmark[:,1].min())<int(crop[k]):\n crop[k] = int( landmark[:,1].min())\n crop[ 'height']+=crop[k]-int(landmark[:,1].min())\n elif k=='left' and int(landmark[:,0].min())<int(crop[k]):\n crop[k] = int( landmark[:,0].min())\n crop['width']+= crop[k] - int(landmark[:, 0].min())\n elif k == 'width' and int(landmark[:, 0].max()-landmark[:, 0].min()) > int(crop[k]):\n crop[k] = int(landmark[:, 0].max()-landmark[:, 0].min())\n elif k == 'height' and int(landmark[:, 1].max()-landmark[:, 1].min()) > int(crop[k]):\n crop[k] = int(landmark[:, 1].max()-landmark[:, 1].min())\n\n crop['left']-=offset\n crop['top'] -= offset\n crop['width'] += 2*offset\n crop['height'] += 2*offset\n\n\n landmark[:,0]-=crop['left']\n landmark[:, 1] -= crop['top']\n\n\n if not os.path.exists(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j))):\n im=image2array(os.path.join(root_dir, filename.attrib['file']))\n if im.ndim==2:\n im=cv2.cvtColor(im,cv2.COLOR_GRAY2RGB)\n im=im[crop['top']:min(crop['top']+crop['height'],im.shape[0]),crop['left']:min(crop['left']+crop['width'],im.shape[1]),:]\n\n if max(im.shape[:2])/max(min(im.shape[:2]),0)<=5:\n\n array2image(im).save(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\n image_paths[mode].append(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j)))\n crops[mode].append(crop)\n landmarks[mode].append(landmark)\n del im\n else:\n #im = image2array(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\n image_paths[mode].append(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\n crops[mode].append(crop)\n landmarks[mode].append(landmark)\n\n if j%100==0:\n gc.collect()\n except Exception as e:\n pass\n\n print('ibug 300w train dataset: images: {0} landmarks:{1} \\n'.format(len(image_paths['train']),len(landmarks['train'])))\n print('ibug 300w test dataset: images: {0} landmarks:{1} \\n'.format(len(image_paths['test']), len(landmarks['test'])))\n imdata=ImageDataset(images=image_paths['train'],symbol='faces',object_type=ObjectType.rgb)\n landmarkdata = LandmarkDataset(landmarks=landmarks['train'], symbol='landmarks',object_type=ObjectType.landmarks)\n imtestdata = ImageDataset(images=image_paths['test'], symbol='faces',object_type=ObjectType.rgb)\n landmarktestdata = LandmarkDataset(landmarks=landmarks['test'], symbol='landmarks',object_type=ObjectType.landmarks)\n data_provider=DataProvider(traindata=Iterator(data=imdata,label=landmarkdata),testdata=Iterator(data=imtestdata,label=landmarktestdata))\n return data_provider\n\n elif dataset_name == 'examples_antisproofing':\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\n extract_archive(tar_file_path, dirname, archive_format='tar')\n data_provider = load_folder_images(dataset_name,os.path.join(dirname, 'antisproofing'))\n return data_provider\n elif dataset_name == 'examples_anpr':\n download_file_from_google_drive('1uGBd8tXlP0TZAXNgrR6H0jl5MXj7VPbN', dirname, 'anpr.tar')\n tar_file_path = os.path.join(dirname, 'anpr.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\n imgs = list(sorted(imgs))\n\n # CCPD (Chinese City Parking Dataset, ECCV) and PDRC (license Plate Detection and Recognition Challenge)\n # https://github.com/detectRecog/CCPD\n provinces = [\"皖\", \"沪\", \"津\", \"渝\", \"冀\", \"晋\", \"蒙\", \"辽\", \"吉\", \"黑\", \"苏\", \"浙\", \"京\", \"闽\", \"赣\", \"鲁\", \"豫\", \"鄂\", \"湘\", \"粤\",\n \"桂\", \"琼\", \"川\", \"贵\", \"云\", \"藏\", \"陕\", \"甘\", \"青\", \"宁\", \"新\", \"警\", \"学\", \"O\"]\n alphabets = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',\n 'W', 'X', 'Y', 'Z', 'O']\n ads = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',\n 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'O']\n\n def lp2char(lp):\n cols = lp.split('_')\n charstring = ''\n for i in range(len(cols)):\n if i == 0:\n charstring += provinces[int(cols[i])]\n elif i == 1:\n charstring += alphabets[int(cols[i])]\n else:\n charstring += ads[int(cols[i])]\n return charstring\n\n width = 720\n height = 1160\n for im_path in imgs:\n lbl = im_path.split('/')[-1].rsplit('.', 1)[0].split('-')[-3]\n charstring = lp2char(lbl)\n iname = im_path.rsplit('/', 1)[-1].rsplit('.', 1)[0].split('-')\n [leftUp, rightDown] = [[int(eel) for eel in el.split('&')] for el in iname[2].split('_')]\n box = [leftUp[0], leftUp[1], rightDown[0], rightDown[1]]\n ori_w, ori_h = [float(int(el)) for el in [width, height]]\n new_labels = [(leftUp[0] + rightDown[0]) / (2 * ori_w), (leftUp[1] + rightDown[1]) / (2 * ori_h),\n (rightDown[0] - leftUp[0]) / ori_w, (rightDown[1] - leftUp[1]) / ori_h]\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\n extract_archive(tar_file_path, dirname, archive_format='tar')\n data_provider = load_folder_images(dataset_name, os.path.join(dirname, 'antisproofing'))\n return data_provider\n\n\n\n elif dataset_name == 'examples_dogs-vs-cats':\n download_file_from_google_drive('10czW0On7eIXkPP-MuQ-IRxMWdTizWjNC', dirname, 'dogs-vs-cats.tar')\n tar_file_path = os.path.join(dirname, 'dogs-vs-cats.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n data_provider = load_folder_images(dataset_name, dirname)\n return data_provider\n elif dataset_name == 'examples_chinese':\n to_half=ToHalfWidth()\n to_sc=ChineseConvert(convert_to='simplified')\n download_file_from_google_drive('1yzRzXpLuhSUxnixqCgpbdTk16ajnTEWF', dirname, 'chinese.tar')\n tar_file_path = os.path.join(dirname, 'chinese.tar')\n extract_archive(tar_file_path, dirname, archive_format='tar')\n\n as_train = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_training.utf8'), encoding='utf-8-sig').read().strip().replace('\\u3000' ,'|'))).splitlines()\n cityu_train =remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_training.utf8'), encoding='utf-8-sig').read().strip().replace(' ','|'))).splitlines()\n\n as_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_testing_gold.utf8'), encoding='utf-8-sig').read().strip().replace('\\u3000', '|'))).splitlines()\n cityu_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_test_gold.utf8'), encoding='utf-8-sig').read().strip().replace(' ', '|'))).splitlines()\n\n\n data = as_train + cityu_train # 把兩個語料合併\n test_data=as_test + cityu_test # 把兩個語料合併\n\n\n raw_data_train = [row.strip('\\n').strip('\\r') for row in data] # 移除分行字元\n raw_data_test = [row.strip('\\n').strip('\\r') for row in test_data] # 移除分行字元\n\n process_data_train=[]\n process_seg_label_train = []\n process_simplifided_label_train = []\n process_traditional_label_train = []\n\n tmp_data_train = []\n tmp_seg_label_train = []\n tmp_simplifided_label_train = []\n tmp_pronunce_label_train = []\n for k in tqdm(range(len(raw_data_train))):\n row=raw_data_train[k]\n if row.startswith('∥'):\n row=row[1:]\n words=row.replace('||','|').split('|')\n for k in range(len(words)):\n\n word = words[k]\n\n for i in range(len(word)):\n tmp_data_train.append(word[i])\n #tmp_simplifided_label_train.append(to_half(to_sc(word[i])))\n #轉換為BMES\n\n if i==0 and len(word)>1: #B 是一個詞的開始\n tmp_seg_label_train.append('B')\n elif i==len(word)-1 and len(word)>=2 and tmp_seg_label_train[-1] in ['B','M']: #E 是一個詞的結束\n tmp_seg_label_train.append('E')\n elif len(word)==1 and i==0: #S 自己就是一個單詞\n tmp_seg_label_train.append('S')\n elif len(word)>=3 and tmp_seg_label_train[-1] in ['B','M']: #M 是一個詞的中間\n tmp_seg_label_train.append('M')\n\n if len(tmp_seg_label_train)>0 and tmp_seg_label_train[-1] in ['E','S']:\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)) and k+1<len(words):\n if word in [ '。','﹖']:\n pass\n\n elif random.random() < 0.6 or is_alphabet(word):\n tmp_data_train.append(' ')\n tmp_seg_label_train.append('S')\n\n if (k+1<len(raw_data_train) and not raw_data_train[k+1].startswith( '」')) and words[-1] in [ '。','﹖']:\n #process_traditional_label_train.append(tmp_data_train)\n\n tmp_data_train=to_half(''.join(tmp_data_train))\n tmp_seg_label_train = ''.join(tmp_seg_label_train)\n # if len(tmp_data_train)!=len(tmp_seg_label_train):\n # print('')\n tmp_simplifided_label_train =to_sc(tmp_data_train)\n\n process_data_train.append(tmp_data_train)\n process_seg_label_train.append(tmp_seg_label_train)\n process_simplifided_label_train.append(tmp_simplifided_label_train)\n tmp_data_train = []\n tmp_seg_label_train = []\n tmp_simplifided_label_train = []\n tmp_pronunce_label_train = []\n # else:\n # tmp_data_train.append('\\n')\n # tmp_simplifided_label_train.append('\\n')\n # tmp_seg_label_train.append('\\n')\n corpus=process_data_train\n seg_corpus=process_seg_label_train\n simplifided_corpus =process_simplifided_label_train\n\n process_data_test = []\n process_seg_label_test = []\n process_simplifided_label_test = []\n process_traditional_label_test = []\n print('generate test labels')\n tmp_data_test = []\n tmp_seg_label_test = []\n tmp_simplifided_label_test = []\n tmp_pronunce_label_test = []\n for k in tqdm(range(len(raw_data_test))):\n row=raw_data_test[k]\n if row.startswith('∥'):\n row=row[1:]\n words = row.replace('||', '|').split('|')\n for k in range(len(words)):\n\n word = words[k]\n\n for i in range(len(word)):\n tmp_data_test.append(word[i])\n # tmp_simplifided_label_test.append(to_half(to_sc(word[i])))\n # 轉換為BMES\n\n if i == 0 and len(word) > 1: # B 是一個詞的開始\n tmp_seg_label_test.append('B')\n elif i == len(word) - 1 and len(word) >= 2 and tmp_seg_label_test[-1] in ['B', 'M']: # E 是一個詞的結束\n tmp_seg_label_test.append('E')\n elif len(word) == 1 and i == 0: # S 自己就是一個單詞\n tmp_seg_label_test.append('S')\n elif len(word) >= 3 and tmp_seg_label_test[-1] in ['B', 'M']: # M 是一個詞的中間\n tmp_seg_label_test.append('M')\n\n if len(tmp_seg_label_test) > 0 and tmp_seg_label_test[-1] in ['E', 'S'] and k+1<len(words):\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)):\n if word in ['。', '﹖']:\n pass\n elif random.random() < 0.6 or is_alphabet(word):\n tmp_data_test.append(' ')\n tmp_seg_label_test.append('S')\n\n if (k + 1 < len(raw_data_test) and not raw_data_test[k + 1].startswith('」')) and words[-1] in ['。', '﹖']:\n # process_traditional_label_test.append(tmp_data_test)\n\n tmp_data_test = to_half(''.join(tmp_data_test))\n tmp_seg_label_test = ''.join(tmp_seg_label_test)\n # if len(tmp_data_test)!=len(tmp_seg_label_test):\n # print('')\n tmp_simplifided_label_test = to_sc(tmp_data_test)\n\n process_data_test.append(tmp_data_test)\n process_seg_label_test.append(tmp_seg_label_test)\n process_simplifided_label_test.append(tmp_simplifided_label_test)\n tmp_data_test = []\n tmp_seg_label_test = []\n tmp_simplifided_label_test = []\n tmp_pronunce_label_test = []\n # else:\n # tmp_data_test.append('\\n')\n # tmp_simplifided_label_test.append('\\n')\n # tmp_seg_label_test.append('\\n')\n test_corpus = process_data_test\n test_seg_corpus = process_seg_label_test\n test_simplifided_corpus = process_simplifided_label_test\n\n\n data=TextSequenceDataset(corpus=corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\n seg_label = TextSequenceDataset(corpus=seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\n simplifided_label = TextSequenceDataset(corpus=simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\n traditional_label = TextSequenceDataset(corpus= copy.deepcopy(corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\n\n data_test=TextSequenceDataset(corpus=test_corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\n seg_test_label = TextSequenceDataset(corpus=test_seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\n simplifided_test_label = TextSequenceDataset(corpus=test_simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\n traditional_test_label = TextSequenceDataset(corpus= copy.deepcopy(test_corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\n\n\n chars = list(sorted(set(list( ''.join(corpus) +bpmf_phonetic+'\\n\\r\\t∥'+ ''.join(simplifided_corpus)+''.join(test_data)))))\n chars.insert(0, '[CLS]')\n chars.insert(1, '[SEP]')\n chars.insert(2, '[UNK]')\n chars.insert(3, '[PAD]')\n chars.insert(4, '[MASK]')\n\n data.vocabs =data_test.vocabs=simplifided_label.vocabs=simplifided_test_label.vocabs = chars\n data.text2index=data_test.text2index =simplifided_label.text2index=simplifided_test_label.text2index = dict((c, i) for i, c in enumerate(chars))\n data.index2text =data_test.index2text =simplifided_label.index2text=simplifided_test_label.index2text= dict((i, c) for i, c in enumerate(chars))\n traditional_label = copy.deepcopy(data)\n traditional_test_label = copy.deepcopy(data_test)\n traditional_label.object_type =traditional_test_label.object_type = ObjectType.sequence_label\n traditional_label.symbol =traditional_test_label.symbol = 'traditional_label'\n\n mask_label = copy.deepcopy(data)\n mask_test_label = copy.deepcopy(data_test)\n #mask_label.object_type =mask_test_label.object_type= ObjectType.corpus\n mask_label.symbol = mask_test_label.symbol = 'mask_label'\n\n\n\n nextword=copy.deepcopy(data)\n nextword_test = copy.deepcopy(data_test)\n nextword.object_type=nextword_test.object_type=ObjectType.sequence_label\n nextword.symbol=nextword_test.symbol='nextword_label'\n nextword.sequence_offset=nextword_test.sequence_offset=1\n\n label=ZipDataset(seg_label,nextword,simplifided_label,traditional_label,mask_label)\n label_test = ZipDataset(seg_test_label, nextword_test, simplifided_test_label, traditional_test_label, mask_test_label)\n provider=TextSequenceDataProvider(\n traindata=Iterator(data=data,label=label),\n testdata=Iterator(data=data_test,label=label_test))\n return provider\n #,sample_filter=lambda x:x[0][-1]==3\n else:\n return None","def load_matt_mahoney_text8_dataset():\n import zipfile\n from six.moves import urllib\n\n url = 'http://mattmahoney.net/dc/'\n\n def download_matt_mahoney_text8(filename, expected_bytes):\n \"\"\"Download a text file from Matt Mahoney's website\n if not present, and make sure it's the right size.\"\"\"\n if not os.path.exists(filename):\n print('Downloading ...')\n filename, _ = urllib.request.urlretrieve(url + filename, filename)\n statinfo = os.stat(filename)\n if statinfo.st_size == expected_bytes:\n print('Found and verified', filename)\n else:\n print(statinfo.st_size)\n raise Exception(\n 'Failed to verify ' + filename + '. Can you get to it with a browser?')\n return filename\n\n filename = download_matt_mahoney_text8('text8.zip', 31344016)\n\n with zipfile.ZipFile(filename) as f:\n word_list = f.read(f.namelist()[0]).split()\n return word_list","def load_data(nlp, cue_verbs, poly):\n train_dicts, _ = load_quote_authors(nlp)\n author_prediction_dataset = AuthorPredictionDataset(train_dicts, cue_verbs, poly)\n return np.array(train_dicts), author_prediction_dataset","def load_for_sklearn(self):\n\n labels = [] # string labels\n examples = [] # examples as strings\n\n # document number -> label mapping\n doc2label = n2b2.map_patients_to_labels(\n self.xml_dir,\n self.category)\n\n for f in os.listdir(self.cui_dir):\n doc_id = f.split('.')[0]\n file_path = os.path.join(self.cui_dir, f)\n file_as_string = open(file_path).read()\n\n string_label = doc2label[doc_id]\n int_label = LABEL2INT[string_label]\n labels.append(int_label)\n examples.append(file_as_string)\n\n return examples, labels","def load_data(self) -> None:","def load_caps(batch_size = 128):\r\n def relabel_classes(class_idx):\r\n if 10 <= class_idx <= 35:\r\n return class_idx - 10\r\n return None\r\n\r\n\r\n\r\n train_ds = torchvision.datasets.EMNIST(root='./data',\r\n train=True,\r\n download=True,\r\n split = 'byclass',\r\n transform = emnist_img_transform,\r\n target_transform = relabel_classes)\r\n\r\n\r\n\r\n test_ds = torchvision.datasets.EMNIST(root='./data',\r\n train=False,\r\n download=True,\r\n split = 'byclass',\r\n transform = emnist_img_transform,\r\n target_transform = relabel_classes)\r\n\r\n # Discard unwanted characters from the background data\r\n train_ds = discard_none_targets(train_ds)\r\n test_ds = discard_none_targets(test_ds)\r\n\r\n\r\n # create data loaders and shuffle everything...\r\n train_dl = torch.utils.data.DataLoader(train_ds,\r\n batch_size=batch_size,\r\n shuffle=True)\r\n\r\n test_dl = torch.utils.data.DataLoader(test_ds,\r\n batch_size=batch_size,\r\n shuffle=True)\r\n\r\n return train_dl,test_dl","def load_data(path_dataset):\n data = read_txt(path_dataset)[1:]\n return preprocess_data(data)","def load_dataset(fname, nb_lines):\n import os.path\n if os.path.isfile('safe/Amazon-'+str(nb_lines)+'.p'):\n return util.load('safe/Amazon-'+str(nb_lines)+'.p')\n count = 1\n X = []\n y = []\n with open(fname) as f:\n for line in f:\n text, label = read_line(line)\n #print((label, text))\n X.append(text)\n y.append(label)\n if count >= nb_lines:\n break\n count+=1\n\n #load pretrained dictonary\n dico = util.load('safe/vocab_gensim.p')\n preprocessor = text_preprocessing.Preprocessor(dico=dico)\n X = preprocessor.preprocess(X)\n #save the loaded dataset in a pickle for speeding up next run\n util.save((X,y), 'safe/Amazon-'+str(nb_lines)+'.p')\n return (X, y)","def load_data(self):\n sets = ['train', 'val']\n images = []\n labels = []\n self.labels_dic = {}\n file = open(self.path + 'wnids.txt')\n train_labels = file.read().split()\n if self.train:\n for fn in range(self.num_classes):\n f = train_labels[fn]\n for i in os.listdir(self.path + 'train/' + f + '/images/'):\n images.append(Image.open(self.path + 'train/' + f + '/images/' + i))\n labels.append(f)\n #image label n link to folder names of TinyImageNet\n self.labels_dic[f] = fn\n\n else:\n for fn in range(self.num_classes):\n f = train_labels[fn]\n self.labels_dic[f] = fn\n file_val = open(self.path + 'val/val_annotations.txt')\n val_labels = file_val.read().split('\\n')\n for im in val_labels:\n im_data = im.split(\"\t\")[:2]\n if len(im_data) < 2:\n continue\n if im_data[1] in self.labels_dic:\n images.append(Image.open(self.path + 'val/images/' + im_data[0]))\n labels.append(im_data[1])\n\n self.images = images\n self.labels = labels","def load_dataset(self):\n\n train_path = os.path.join(self.dataset_path, 'images_background')\n validation_path = os.path.join(self.dataset_path, 'images_evaluation')\n\n # First let's take care of the train alphabets\n for alphabet in os.listdir(train_path):\n if alphabet[0] == '.':\n continue\n alphabet_path = os.path.join(train_path, alphabet)\n\n current_alphabet_dictionary = {}\n\n for character in os.listdir(alphabet_path):\n if character[0] == '.':\n continue\n character_path = os.path.join(alphabet_path, character)\n\n current_alphabet_dictionary[character] = os.listdir(\n character_path)\n\n self.train_dictionary[alphabet] = current_alphabet_dictionary\n\n # Now it's time for the validation alphabets\n for alphabet in os.listdir(validation_path):\n alphabet_path = os.path.join(validation_path, alphabet)\n if alphabet[0] == '.':\n continue\n\n current_alphabet_dictionary = {}\n\n for character in os.listdir(alphabet_path):\n if character[0] == '.':\n continue\n character_path = os.path.join(alphabet_path, character)\n\n current_alphabet_dictionary[character] = os.listdir(\n character_path)\n\n self.evaluation_dictionary[alphabet] = current_alphabet_dictionary","def load_data_and_labels():\n # Load data from files\n positive_examples = []\n for file in os.listdir('with_datarace'):\n filename = os.fsdecode(file)\n ast_file = open('with_datarace\\\\' + filename, 'r')\n token_vector = ast_file.read()\n positive_examples.append(token_vector)\n file_names.append(filename)\n\n negative_examples = []\n for file in os.listdir('without_datarace\\\\'):\n filename = os.fsdecode(file)\n ast_file = open('without_datarace\\\\' + filename, 'r')\n token_vector = ast_file.read()\n negative_examples.append(token_vector) # List of lists\n file_names.append(filename)\n\n positive_examples = [s.strip() for s in positive_examples]\n negative_examples = [s.strip() for s in negative_examples]\n\n # Split by words\n x_text = positive_examples + negative_examples # why we didn't cobine it from the beginning?\n x_text = [clean_str(sent) for sent in x_text]\n x_text = [s.split(\" \") for s in x_text]\n\n # Generate labels\n positive_labels = [[0, 1] for _ in positive_examples]\n negative_labels = [[1, 0] for _ in negative_examples]\n y = np.concatenate([positive_labels, negative_labels], 0)\n\n return [x_text, y]","def load_data_raw(source='local'):\n import os\n\n if source == 'kaggle':\n # Download the Ames Housing Dataset\n # Set the enviroment variables\n import zipfile\n os.environ['KAGGLE_USERNAME'] = \"lubomrstraka\"\n os.environ['KAGGLE_KEY'] = \"c7347462ef834e6645ce238c2f2fa561\"\n \n # Import dependencies\n os.system(\"pip install kaggle --upgrade --quiet\")\n\n # Download datasets\n os.system(\"kaggle competitions download -c house-prices-advanced-regression-techniques --quiet\")\n \n # Extract data\n with zipfile.ZipFile('house-prices-advanced-regression-techniques.zip', 'r') as archive:\n archive.extractall()\n\n # Read Train & Test Baseline Data\n train_bl = pd.read_csv('train.csv', index_col='Id')\n test_bl = pd.read_csv('test.csv', index_col='Id')\n \n # Using local data used while registering dataset\n # prevents \"Too many requests\" response from Kaggle\n elif source == 'local': \n train_bl = pd.read_csv('train.csv', index_col='Id')\n test_bl = pd.read_csv('test.csv', index_col='Id')\n \n else:\n print('Missing data!')\n train_bl = pd.DataFrame()\n test_bl = pd.DataFrame()\n\n\n return train_bl, test_bl","def loadData(self, dataType): \n if dataType == \"train\":\n f = self.urls[0]\n elif dataType == \"valid\":\n f = self.urls[1]\n elif dataType == \"test\":\n f = self.urls[2] \n\n \"\"\" Load text file \"\"\"\n corpus = list()\n with io.open(f, encoding='UTF-8') as f:\n for line in f: \n if len(line) > self.minSeq and len(line) < self.maxLen:\n corpus.append(line.lstrip().rstrip().split(' '))\n return corpus","def load():\n filepath = dirname(abspath(__file__))\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\n data = recfromtxt(open(filepath + '/spector.csv',\"rb\"), delimiter=\" \",\n names=True, dtype=float, usecols=(1,2,3,4))\n names = list(data.dtype.names)\n endog = array(data[names[3]], dtype=float)\n endog_name = names[3]\n exog = column_stack(data[i] for i in names[:3]).astype(float)\n exog_name = names[:3]\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\n endog_name = endog_name, exog_name=exog_name)\n return dataset","def load_blacklist(experiment):\n blacklist = np.loadtxt('../Slip_Property_Data/%s_blacklist.txt'%experiment)\n return blacklist","def load_blacklist(experiment):\n blacklist = np.loadtxt('../Slip_Property_Data/%s_blacklist.txt'%experiment)\n return blacklist","def load_datapair(self, ds):\n raise NotImplementedError(\"Define this in your derived checker class\")","def load_data():\n # Dictionary mapping image names to labels\n image_name_to_label = dict()\n\n # Store labels associated with image names\n notifier.send(\" Reading metadata...\")\n with open(\"data/metadata.csv\") as file: # Original dataset\n # Use images for normal, virus (unknown type), COVID-19, SARS\n metadata_contents = csv.DictReader(file)\n for row in metadata_contents:\n if row[\"Label\"].lower() == \"normal\":\n label = 2\n elif row[\"Label_2_Virus_category\"].lower() == \"covid-19\":\n label = 0\n elif row[\"Label_1_Virus_category\"].lower() == \"virus\":\n label = 1\n else:\n continue\n image_name_to_label[row[\"X_ray_image_name\"]] = label\n with open(\"data/metadata2.csv\") as file: # GitHub dataset\n # Use COVID-19, SARS\n metadata_contents = csv.DictReader(file)\n for row in metadata_contents:\n if row[\"filename\"] in image_name_to_label: # Image already added\n continue\n if \"covid-19\" in row[\"finding\"].lower():\n label = 0\n elif row[\"finding\"].lower() == \"sars\":\n label = 1\n else:\n continue\n image_name_to_label[row[\"filename\"]] = label\n with open(\"data/metadata_COVID-19.csv\") as file: # Additional COVID-19 images\n metadata_contents = csv.DictReader(file)\n for row in metadata_contents:\n name = \"COVID-19/\" + row[\"FILE NAME\"] + \".\" + row[\"FORMAT\"]\n image_name_to_label[name.lower().replace(\" \", \"\")] = 0\n with open(\"data/metadata_ViralPneumonia.csv\") as file: # Additional virus images\n metadata_contents = csv.DictReader(file)\n for row in metadata_contents:\n name = \"ViralPneumonia/\" + row[\"FILE NAME\"].replace(\"-\", \"(\") + \").\" + row[\"FORMAT\"]\n image_name_to_label[name.lower().replace(\" \", \"\")] = 1\n with open(\"data/metadata_Normal.csv\") as file: # Additional normal images\n metadata_contents = csv.DictReader(file)\n for row in metadata_contents:\n name = \"Normal/\" + row[\"FILE NAME\"].replace(\"-\", \"(\") + \").\" + row[\"FORMAT\"]\n image_name_to_label[name.lower().replace(\" \", \"\")] = 2\n\n notifier.send(\" Loading images...\")\n images, labels = load_images(image_name_to_label)\n\n notifier.send(\" Splitting data...\")\n return split_data(images, labels)","def load_data():\n # Load and preprocess data\n sentences, labels = load_data_and_labels()\n sentences_padded = pad_sentences(sentences)\n vocabulary, vocabulary_inv = build_vocab(sentences_padded)\n x, y = build_input_data(sentences_padded, labels, vocabulary)\n return [x, y, vocabulary, vocabulary_inv]","def load_data(self):\n params = self.params\n catg = params.data_category\n langs = ['en', params.target_lang]\n data = {lang: {splt: {} for splt in (['train', 'valid'] if lang == 'en' else ['test'])} for lang in langs}\n clf_dataset_path = {\n lang: {\n splt: {\n 'x': os.path.join(params.data_path, '%s_%s_%s_x.bpe.pth' % (splt, lang, catg)),\n 'y': os.path.join(params.data_path, '%s_%s_%s_y.txt' % (splt, lang, catg)),\n } for splt in (['train', 'valid'] if lang == 'en' else ['test'])\n } for lang in langs\n }\n for splt in ['train', 'valid', 'test']:\n for lang in langs:\n if lang == 'en' and splt in ['train', 'valid'] or lang != 'en' and splt == 'test':\n # load data and dictionary\n data1 = load_binarized(clf_dataset_path[lang][splt]['x'], params)\n data['dico'] = data.get('dico', data1['dico'])\n # set dictionary parameters\n set_dico_parameters(params, data, data1['dico'])\n # create dataset\n data[lang][splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\n # load labels\n with open(clf_dataset_path[lang][splt]['y'], 'r') as f:\n labels = [int(l) for l in f]\n data[lang][splt]['y'] = torch.LongTensor(labels)\n assert len(data[lang][splt]['x']) == len(data[lang][splt]['y'])\n\n return data","def load_muscle(preprocess=True, mean_cut=None):\n\n url = f'https://raw.githubusercontent.com/PengTao-HUST/GDNB/master/data/muscle.txt'\n cache_dir = sys.modules['gdnb'].__path__[0] + '/data/'\n\n if not os.path.exists(cache_dir):\n os.makedirs(cache_dir)\n\n data_file = os.path.basename(url)\n full_path = cache_dir + data_file\n\n if not os.path.exists(full_path):\n urlretrieve(url, cache_dir + data_file)\n\n if preprocess:\n probes = []\n names = []\n exprs = []\n with open(full_path, 'r') as f:\n f.readline()\n f.readline()\n for line in f.readlines():\n data = line.split('\\t')\n probe = data[0]\n name = data[1]\n expr = np.array([np.log2(float(x)) for x in data[2:]])\n probes.append(probe)\n names.append(name)\n exprs.append(expr)\n probes = np.asarray(probes)\n names = np.asarray(names)\n exprs = np.asarray(exprs)\n\n use_index = []\n for name in names:\n if re.match('.*///.*', name) or not re.match('^[A-Z].*', name):\n use_index.append(False)\n else:\n use_index.append(True)\n\n probes, names, exprs = [obj[use_index] for obj in [probes, names, exprs]]\n\n means = np.mean(exprs, axis=1)\n if mean_cut is None:\n mean_cut = 7\n\n cut_index = np.where(means > mean_cut)\n probes_c, names_c, exprs_c = [obj[cut_index] for obj in [probes, names, exprs]]\n exprs_c = np.apply_along_axis(normalize_by_mean, 1, exprs_c)\n\n exprs_split = np.array([exprs_c[:, 2 * i: 2 * i + 6] for i in range(25)])\n return probes_c, names_c, exprs_split\n else:\n return full_path","def load_dataset():\n\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \"r\")\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\n\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \"r\")\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\n\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\n \n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\n \n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes","def load(self, source):\n try:\n inputdata = self.__inputmanager.read(source)\n self.__suitables = self.__inputmanager.map(inputdata)\n self.__data = inputdata\n except ValueError as e:\n print (\"Failed to load the dataset: %s\" % e)\n raise\n\n self.__modules = self.import_suitable_visualizations(self.__suitables)\n self.__has_datefields = self.__inputmanager.has_date_points()\n # Converting the datakeys into strings.\n self.__datakeys = [str(i) for i in list(self.__data[0].keys())]\n return self.__suitables","def load_dataset(\n dataset: str\n) -> Union[lmp.dataset.AnalogyDataset, lmp.dataset.LanguageModelDataset]:\n # Type check.\n if not isinstance(dataset, str):\n raise TypeError('`dataset` must be an instance of `str`.')\n\n if dataset == 'news_collection_desc':\n return _preprocess_news_collection(column='desc')\n\n if dataset == 'news_collection_title':\n return _preprocess_news_collection(column='title')\n\n if dataset == 'wiki_train_tokens':\n return _preprocess_wiki_tokens(split='train')\n\n if dataset == 'wiki_valid_tokens':\n return _preprocess_wiki_tokens(split='valid')\n\n if dataset == 'wiki_test_tokens':\n return _preprocess_wiki_tokens(split='test')\n\n if dataset == 'word_test_v1':\n return _preprocess_word_test_v1()\n\n raise ValueError(\n f'dataset `{dataset}` does not support.\\nSupported options:' +\n ''.join(list(map(\n lambda option: f'\\n\\t--dataset {option}',\n [\n 'news_collection_desc',\n 'news_collection_title',\n 'wiki_test_tokens',\n 'wiki_train_tokens',\n 'wiki_valid_tokens',\n 'word_test_v1'\n ]\n )))\n )","def get_dataset(args):\n\n if args['experiment']['dataset'] == Dataset.mindsets:\n xs, ys, cs = make_mindsets(mindset_sizes=args['dataset']['mindset_sizes'],\n nb_questions=args['dataset']['nb_questions'],\n nb_useless=args['dataset']['nb_useless'],\n noise=args['dataset']['noise'],\n seed=args['experiment']['seed'])\n\n return Data(xs=xs, ys=ys, cs=cs)\n\n if args['experiment']['dataset'] == Dataset.questionnaire_likert:\n xs, ys, cs = make_likert_questionnaire(nb_samples=args['dataset']['nb_samples'],\n nb_features=args['dataset']['nb_features'],\n nb_mindsets=args['dataset']['nb_mindsets'],\n centers=args['dataset']['centers'],\n range_answers=args['dataset']['range_answers'],\n seed=args['experiment']['seed'])\n\n return Data(xs=xs, ys=ys, cs=cs)\n\n if args['experiment']['dataset'] == Dataset.retinal:\n xs, ys = load_RETINAL(root_path=args['root_dir'],\n nb_bins=args['dataset']['nb_bins'],\n max_idx=args['dataset']['max_idx'])\n\n return Data(xs=xs, ys=ys)\n\n if args['experiment']['dataset'] == Dataset.moons:\n xs, ys = make_moons(n_samples=args['dataset']['n_samples'],\n noise=args['dataset']['noise'],\n random_state=args['experiment']['seed'])\n\n return Data(xs=xs, ys=ys)\n\n if args['experiment']['dataset'] == Dataset.breast_cancer_wisconsin:\n xs, ys = load_CANCER(args['dataset']['nb_bins'])\n\n return Data(xs=xs, ys=ys)\n\n if args['experiment']['dataset'] == Dataset.SBM:\n A, ys, G = load_SBM(block_sizes=args['dataset']['block_sizes'],\n p_in=args['dataset']['p'],\n p_out=args['dataset']['q'],\n seed=args['experiment']['seed'])\n\n return Data(ys=ys, A=A, G=G)\n\n if args['experiment']['dataset'] == Dataset.gaussian_mixture:\n xs, ys = make_blobs(n_samples=args['dataset']['blob_sizes'],\n centers=args['dataset']['blob_centers'],\n n_features=args['dataset']['blob_centers'],\n cluster_std=args['dataset']['blob_variances'],\n random_state=args['experiment']['seed'])\n\n return Data(xs=xs, ys=ys)\n\n if args['experiment']['dataset'] == Dataset.LFR:\n A, ys, G = load_LFR(nb_nodes=args['dataset']['nb_nodes'],\n tau1=args['dataset']['tau1'],\n tau2=args['dataset']['tau2'],\n mu=args['dataset']['mu'],\n average_degree=args['dataset']['average_degree'],\n min_community=args['dataset']['min_community'],\n seed=args['experiment']['seed'])\n\n return Data(ys=ys, A=A, G=G)\n\n if args['experiment']['dataset'] == Dataset.wave:\n df = pd.read_csv('datasets/waveform.csv')\n xs = df[df.columns[:-1]].to_numpy()\n ys = df[df.columns[-1]].to_numpy()\n\n return Data(xs=xs, ys=ys)\n\n raise ValueError('Wrong name for a dataset')","def load_data(self):","def load_data(data_fn,variables_fn,URL,VariableSet,Drop_extra=True):\r\n \r\n #If the data file exists locally, load it using pandas\r\n breakhere=1\r\n try: df = pd.read_csv(data_fn)\r\n except: \r\n #If the data file does not exist locally, download and save locally, then open\r\n print('Downloading data file (~430mb)')\r\n urllib.request.urlretrieve(URL,data_fn)\r\n print('Download Complete')\r\n df = pd.read_csv(data_fn)\r\n \r\n print('\\n************\\nNOTE RE: MIXED TYPE WARNING - These variables contain:')\r\n print(' 294 - HQ ID of person providing most of the information for this form')\r\n print(' 295 - HQ ID of 1st Other providing information for this form')\r\n print(' 701 - HF2 Cross wave ID (xwaveid) - 0001')\r\n print(' 702 - HF2 Cross wave ID (xwaveid) - 0002')\r\n print('These variables are not used in this project so the mixed type warning can be ignored\\n************')\r\n \r\n #Read the variables descriptor file\r\n variables = pd.read_csv(variables_fn)\r\n \r\n #extract the name of the response variable\r\n responseVar = variables['Variable'][variables['Response']=='y'].values[0]\r\n \r\n if Drop_extra:\r\n #Store the current number of recores\r\n NumRecords = df.shape[0]\r\n #remove entries with negative response variables (non-responding person, N/A, not asked, etc)\r\n DataSubset = pd.DataFrame(df[df[responseVar]>-1])\r\n #Notify the user how of how many records were dropped\r\n print('\\n{} records dropped due to lack of response variable (non-responding person, N/A, etc)'.format(NumRecords-DataSubset.shape[0]))\r\n \r\n #Extract the variable names for the variable set being analyzed\r\n KeepVars = variables['Variable'][variables[VariableSet]=='y']\r\n \r\n #Keep only the variables in the variable set\r\n DataSubset = DataSubset[KeepVars]\r\n \r\n else:\r\n #Return all variables and records\r\n DataSubset = df\r\n \r\n return DataSubset,variables,responseVar","def LoadTroikaDataset():\n data_dir = \"./datasets/troika/training_data\"\n data_fls = sorted(glob.glob(data_dir + \"/DATA_*.mat\"))\n ref_fls = sorted(glob.glob(data_dir + \"/REF_*.mat\"))\n return data_fls, ref_fls","def load(name):\n if name in datasets:\n\n return pd.read_csv(os.path.join(datasets_path, \"%s.csv\" % name))\n else:\n raise ValueError(\"Dataset not found!\")","def load_data():\n with open('../data/dataset.txt', 'r') as data_file:\n return data_file.read().split('\\n')","def get_data_loaders():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_2sentences_finalgenerated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"][-(2*2+5):]\n \n #history_complete.append(history)\n if len(persona) == 4:\n if len(history) > (len(persona)+3):\n history_chatbot = history[1::2]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss_2(persona, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def prepare(self):\n\n # step 0: load only when not loaded yet\n if TRAINING in self.data \\\n and VALIDATION in self.data:\n return\n\n # step 1: load the file names\n file_list = sorted(glob.glob(self.location+\"*.mhd\"))\n # count the number of data points\n\n # make a stratified validation set\n # note, the seed decides the validation set, but it is deterministic in the names\n random.seed(317070)\n patient_names = [self.patient_name_from_file_name(f) for f in file_list]\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\n\n # make the static data empty\n for s in self.datasets:\n self.data[s] = []\n self.labels[s] = []\n self.names[s] = []\n\n # load the filenames and put into the right dataset\n labels_as_dict = defaultdict(list)\n\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\n next(reader) # skip the header\n for row in reader:\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\n labels_as_dict[str(row[0])].append(label)\n\n for patient_file in file_list:\n patient_name = self.patient_name_from_file_name(patient_file)\n\n if patient_name in validation_patients:\n s = VALIDATION\n else:\n s = TRAINING\n label = labels_as_dict[str(patient_name)]\n if self.only_positive and not label:\n continue\n self.data[s].append(patient_file)\n \n if self.pick_nodule:\n self.labels[s].append([random.choice(label)]) \n else:\n self.labels[s].append(label)\n \n \n self.names[s].append(patient_name)\n\n # give every patient a unique number\n last_index = -1\n for s in self.datasets:\n self.indices[s] = range(last_index+1,last_index+1+len(self.data[s]))\n if len(self.indices[s]) > 0:\n last_index = self.indices[s][-1]\n print s, len(self.indices[s]), \"samples\"","def load_tamper(self, dataset_dir, subset):\n # Add classes. We have one class.\n # Naming the dataset nucleus, and the class nucleus\n self.add_class(\"tampers\", 1, \"tampers\")\n\n # Which subset?\n # \"val\": use hard-coded list above\n # \"train\": use data from stage1_train minus the hard-coded list above\n # else: use the data from the specified sub-directory\n # assert subset in [\"train\", \"val\", \"stage1_train\", \"stage1_test\", \"stage2_test\"]\n # subset_dir = \"stage1_train\" if subset in [\"train\", \"val\"] else subset\n dataset_dir = os.path.join(dataset_dir, subset, 'images')\n if subset == \"val\" or subset == \"test\":\n image_ids = next(os.walk(dataset_dir))[2]\n else:\n # Get image ids from directory names\n image_ids = next(os.walk(dataset_dir))[2]\n \n\n # dircopy_move = '/data/twj/copy-move/data_zoo/dataset/images/train'\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\n\n # dirnew_splicing = '/data/tamper'\n # image_ids_new_splicing = next(os.walk(os.path.join(dirnew_splicing, 'images')))[2]\n\n # dircopy_move = '/home/as/deeplab/wpmrcnn/ca2new/test'\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\n\n \n # dircopy_move = '/data/gy/ca2att/train3'\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\n\n # # # dirtxt_sp = '/data/gy/tamperpre/train'\n # # # image_ids_txt_sp = next(os.walk(os.path.join(dirtxt_sp, 'images')))[2]\n\n # dirnew_sp = '/data/gy/c2newsp/train'\n # image_ids_new_sp = next(os.walk(os.path.join(dirnew_sp, 'images')))[2]\n\n # Add images\n for image_id in image_ids:\n self.add_image(\n \"tampers\",\n image_id=image_id[:-4],\n path=os.path.join(dataset_dir, image_id))\n\n # for image_id in image_ids_copy_move:\n # self.add_image(\n # \"tampers\",\n # image_id=image_id[:-4],\n # path=os.path.join(dircopy_move, 'images', image_id))\n\n # for image_id in image_ids_new_splicing:\n # self.add_image(\n # \"tampers\",\n # image_id=image_id[:-4],\n # path=os.path.join(dirnew_splicing, 'images', image_id))\n\n # # for image_id in image_ids_txt_sp:\n # # self.add_image(\n # # \"tampers\",\n # # image_id=image_id[:-4],\n # # path=os.path.join(dirtxt_sp, 'images', image_id))\n\n # for image_id in image_ids_new_sp:\n # self.add_image(\n # \"tampers\",\n # image_id=image_id[:-4],\n # path=os.path.join(dirnew_sp, 'images', image_id))","def load_data():\r\n train_dataset = h5py.File('train_catvnoncat.h5', \"r\") # Change the directory as per your system\r\n train_set_x_orig = np.array(train_dataset[\"train_set_x\"][:]) # your train set features\r\n train_set_y_orig = np.array(train_dataset[\"train_set_y\"][:]) # your train set labels\r\n\r\n test_dataset = h5py.File('test_catvnoncat.h5', \"r\") # Change the directory as per your system\r\n test_set_x_orig = np.array(test_dataset[\"test_set_x\"][:]) # your test set features\r\n test_set_y_orig = np.array(test_dataset[\"test_set_y\"][:]) # your test set labels\r\n\r\n classes = np.array(test_dataset[\"list_classes\"][:]) # the list of classes\r\n \r\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\r\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\r\n \r\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes","def load_ICA_data(subject, data_dir, file='post_ICA', preload=True):\n\tDS_dir = 'downsampled_128'\n\t#datadir='/Users/md42732/Desktop/data/EEG/MovieTrailers/Participants/%s/%s'%(subject, DS_dir)\n\tif file == 'post_ICA':\n\t\tds = io.read_raw_fif('%s/%s/%s/%s_postICA_rejected.fif'%(data_dir, subject, DS_dir, subject), preload=True)\n\telse:\n\t\tprint('No other file previously saved to load')\n\n\treturn ds","def load_data_realistic_ssl(dataset_name, data_path, label_map_path):\n logging.info('Loading data from pickle at %s.', data_path)\n train_set, validation_set, test_set = pickle.load(open(data_path, 'rb'))\n train_inputs = train_set['images']\n train_labels = train_set['labels']\n val_inputs = validation_set['images']\n val_labels = validation_set['labels']\n test_inputs = test_set['images']\n test_labels = test_set['labels']\n # Load label map that specifies which trainining labeles are available.\n train_indices = json.load(open(label_map_path, 'r'))\n train_indices = [\n int(key.encode('ascii', 'ignore')) for key in train_indices['values']\n ]\n train_indices = np.asarray(train_indices)\n\n # Select the loaded train indices, and make the rest unlabeled.\n unlabeled_mask = np.ones((train_inputs.shape[0],), dtype=np.bool)\n unlabeled_mask[train_indices] = False\n unlabeled_inputs = train_inputs[unlabeled_mask]\n unlabeled_labels = train_labels[unlabeled_mask]\n train_inputs = train_inputs[train_indices]\n train_labels = train_labels[train_indices]\n\n # Select a feature preprocessing function, depending on the dataset.\n feature_preproc_fn = ((lambda image: image)\n if dataset_name == 'cifar10' else convert_image)\n\n data = Dataset.build_from_splits(\n name=dataset_name,\n inputs_train=train_inputs,\n labels_train=train_labels,\n inputs_val=val_inputs,\n labels_val=val_labels,\n inputs_test=test_inputs,\n labels_test=test_labels,\n inputs_unlabeled=unlabeled_inputs,\n labels_unlabeled=unlabeled_labels,\n feature_preproc_fn=feature_preproc_fn)\n return data","def load_data():\n\n # Load data from categories\n comp = fetch_20newsgroups(subset='all', categories=['comp.graphics', 'comp.sys.mac.hardware', 'comp.windows.x'], \\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\n science = fetch_20newsgroups(subset='all', categories=['sci.crypt', 'sci.electronics', 'sci.space'], \\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\n politics = fetch_20newsgroups(subset='all', categories=['talk.politics.guns', 'talk.politics.mideast'], \\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\n religion = fetch_20newsgroups(subset='all', categories=['alt.atheism', 'soc.religion.christian'], \\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\n recreation = fetch_20newsgroups(subset='all', categories=['rec.autos', 'rec.sport.baseball', 'rec.sport.hockey'], \\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\n\n # Print total number of documents\n data_len = [len(comp.data), len(science.data), len(politics.data), len(recreation.data), len(religion.data)]\n\n # Subsample classes to create a balanced dataset\n sub_k = min(data_len)\n comp.data, comp.target = [list(t) for t in zip(*random.sample(list(zip(comp.data, comp.target)), sub_k))]\n science.data, science.target = [list(t) for t in zip(*random.sample(list(zip(science.data, science.target)), sub_k))]\n politics.data, politics.target = [list(t) for t in zip(*random.sample(list(zip(politics.data, politics.target)), sub_k))]\n religion.data, religion.target = [list(t) for t in zip(*random.sample(list(zip(religion.data, religion.target)), sub_k))]\n recreation.data, recreation.target = [list(t) for t in zip(*random.sample(list(zip(recreation.data, recreation.target)), sub_k))]\n\n # Subcategories labels\n subcat_comp = np.array(comp.target)\n subcat_scien = np.array(science.target) + len(comp.target_names)\n subcat_polit = np.array(politics.target) + len(comp.target_names) + len(science.target_names)\n subcat_rel = np.array(religion.target) + len(comp.target_names) + len(science.target_names) + len(politics.target_names)\n subcat_rec = np.array(recreation.target) + len(comp.target_names) + len(science.target_names) + len(politics.target_names) + len(religion.target_names)\n\n # Assign labels to train data based on categories\n y_comp = np.ones(len(comp.data))\n y_scien = 2*np.ones(len(science.data))\n y_polit = 3*np.ones(len(politics.data))\n y_rel = 4*np.ones(len(religion.data))\n y_rec = 5*np.ones(len(recreation.data))\n labels = np.concatenate((y_comp,y_scien,y_polit,y_rel,y_rec), axis=None)\n\n # Computers\n train_comp, test_comp, y_train_comp, y_test_comp, subcat_comp_train, subcat_comp_test = train_test_split(comp.data, y_comp, subcat_comp, test_size=0.2, random_state=42)\n train_comp, val_comp, y_train_comp, y_val_comp, subcat_comp_train, subcat_comp_val = train_test_split(train_comp, y_train_comp, subcat_comp_train, test_size=0.25, random_state=42)\n\n # Sciences\n train_scien, test_scien, y_train_scien, y_test_scien, subcat_scien_train, subcat_scien_test = train_test_split(science.data, y_scien, subcat_scien, test_size=0.2, random_state=42)\n train_scien, val_scien, y_train_scien, y_val_scien, subcat_scien_train, subcat_scien_val = train_test_split(train_scien, y_train_scien, subcat_scien_train, test_size=0.25, random_state=42)\n\n # Politics\n train_polit, test_polit, y_train_polit, y_test_polit, subcat_polit_train, subcat_polit_test = train_test_split(politics.data, y_polit, subcat_polit, test_size=0.2, random_state=42)\n train_polit, val_polit, y_train_polit, y_val_polit, subcat_polit_train, subcat_polit_val = train_test_split(train_polit, y_train_polit, subcat_polit_train, test_size=0.25, random_state=42)\n\n # Religion\n train_rel, test_rel, y_train_rel, y_test_rel, subcat_rel_train, subcat_rel_test = train_test_split(religion.data, y_rel, subcat_rel, test_size=0.2, random_state=42)\n train_rel, val_rel, y_train_rel, y_val_rel, subcat_rel_train, subcat_rel_val = train_test_split(train_rel, y_train_rel, subcat_rel_train, test_size=0.25, random_state=42)\n\n # Recreation\n train_rec, test_rec, y_train_rec, y_test_rec, subcat_rec_train, subcat_rec_test = train_test_split(recreation.data, y_rec, subcat_rec, test_size=0.2, random_state=42)\n train_rec, val_rec, y_train_rec, y_val_rec, subcat_rec_train, subcat_rec_val = train_test_split(train_rec, y_train_rec, subcat_rec_train, test_size=0.25, random_state=42)\n\n # Corpus from all categories in train set\n newsgroups_train = train_comp + train_scien + train_polit + train_rel + train_rec\n #print(f\"Total number of documents in all categories in the train set is {len(newsgroups_train)}.\")\n train_labels = np.concatenate((y_train_comp,y_train_scien,y_train_polit,y_train_rel,y_train_rec), axis=None)\n #print(train_labels.shape)\n train_subcat = np.concatenate((subcat_comp_train,subcat_scien_train,subcat_polit_train,subcat_rel_train,subcat_rec_train), axis=None)\n #print(train_subcat.shape)\n\n # Corpus from all categories in test set\n newsgroups_test = test_comp + test_scien + test_polit + test_rel + test_rec\n test_labels = np.concatenate((y_test_comp,y_test_scien,y_test_polit,y_test_rel,y_test_rec), axis=None)\n test_subcat = np.concatenate((subcat_comp_test,subcat_scien_test,subcat_polit_test,subcat_rel_test,subcat_rec_test), axis=None)\n\n # Corpus from all categories in validation set\n newsgroups_val = val_comp + val_scien + val_polit + val_rel + val_rec\n val_labels = np.concatenate((y_val_comp,y_val_scien,y_val_polit,y_val_rel,y_val_rec), axis=None)\n val_subcat = np.concatenate((subcat_comp_val,subcat_scien_val,subcat_polit_val,subcat_rel_val,subcat_rec_val), axis=None)\n\n # Data Split\n total = len(test_labels) + len(val_labels) + len(train_labels)\n\n return newsgroups_train, train_labels, newsgroups_test, test_labels, newsgroups_val, val_labels, train_subcat, test_subcat, val_subcat","def preprocess(self, question_dir, unlabeled_set, training_set, vocab_size, max_example=100,\n use_chars=True, only_test_run=False):\n # Define files to be used\n dataset_files = {\"training\": \"train-p\" + training_set,\n \"validation\": \"dev-v1.1\",\n \"test\": \"test-p0.1\"}\n # Define vocabulary source file\n vocab_filename = \"vocab_training\" + training_set + \"+\" + \\\n \"unlabeled_\" + unlabeled_set + \".bin\"\n vocab_f = os.path.join(question_dir, vocab_filename)\n\n # Generate or load dictionaries\n raw_file_dir = '/scratch/s161027/ga_reader_data/ssqa'\n word_dictionary, char_dictionary, num_entities = \\\n self.make_dictionary(dataset_files, raw_file_dir, vocab_size,\n vocab_file=vocab_f)\n dictionary = (word_dictionary, char_dictionary)\n\n # Check for the existence of parsed data in binary files\n # Load them if they exist. Otherwise generate and save new ones.\n print(\"Preparing data...\")\n\n start_time = time.time()\n loaded_dataset = []\n for data_role in dataset_files.keys():\n if data_role == \"training\":\n path = os.path.join(question_dir, dataset_files[data_role])+\".bin\"\n else:\n path = os.path.join(question_dir, dataset_files[data_role]) + \\\n \"_train\" + training_set + \".bin\"\n\n # Parse original json file and save results in binary, then load with pickle\n if not os.path.exists(path):\n print(\"Can't find binary data for {} set. Parsing raw data...\".format(data_role))\n self.json_parser(raw_file_dir, dataset_files[data_role],\n dictionary, training_set, use_chars)\n\n print(\"Loading binary data for {} set\".format(data_role))\n infile = open(path, \"rb\")\n # loaded_data = pickle.load(infile)\n loaded_data = msgpack.unpack(infile)\n\n loaded_dataset.append(loaded_data)\n\n training, validation, test = loaded_dataset\n unpack_time = time.time() - start_time\n print(\"Unpacking took {}\".format(unpack_time))\n\n if only_test_run:\n training = random.sample(training, max_example)\n validation = random.sample(validation, max_example)\n test = random.sample(test, max_example)\n # training = training[0:max_example]\n # validation = validation[0:max_example]\n # test = test[0:max_example]\n\n data = Data(dictionary, num_entities, training, validation, test)\n\n # Message about bad samples being removed.\n print(\"{} questions were removed due to bad formatting.\"\n .format(self.num_removed_questions))\n\n return data","def load_davis_dataset():\n trainn_fold = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'folds', 'train_fold_setting1.txt')))\n train_fold = []\n for e in zip(*trainn_fold):\n for ee in e:\n train_fold.append(ee)\n #train_fold = [ee for e in trainn_fold for ee in e]\n test_fold = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'folds', 'test_fold_setting1.txt')))\n ligands = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'ligands_can.txt')),\n object_pairs_hook=OrderedDict)\n proteins = json.load(\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'proteins.txt')),\n object_pairs_hook=OrderedDict)\n \n affinity = pickle.load(open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'Y'), \n 'rb'), encoding='latin1')\n smiles_lst, protein_lst = [], []\n\n for k in ligands.keys():\n smiles = ligands[k]\n smiles_lst.append(smiles)\n for k in proteins.keys():\n protein_lst.append(proteins[k])\n\n affinity = [-np.log10(y / 1e9) for y in affinity]\n affinity = np.asarray(affinity)\n \n os.makedirs(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'processed'), exist_ok=True)\n train_test_dataset = []\n for split in ['train', 'test']:\n split_dir = os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'processed', split)\n os.makedirs(split_dir, exist_ok=True)\n fold = train_fold if split == 'train' else test_fold\n rows, cols = np.where(np.isnan(affinity) == False)\n rows, cols = rows[fold], cols[fold]\n \n data_lst = [[] for _ in range(1)]\n for idx in range(len(rows)):\n data = {}\n data['smiles'] = smiles_lst[rows[idx]]\n data['protein'] = protein_lst[cols[idx]]\n af = affinity[rows[idx], cols[idx]]\n data['aff'] = af\n\n data_lst[idx % 1].append(data)\n random.shuffle(data_lst)\n train_test_dataset.append(data_lst[0])\n return train_test_dataset","def load_synthetic_data():\n\n pickle_object = FM().data_file \n\n with pickle_object.open('rb') as data_file: \n return pickle.load(data_file)","def do_load(self):\n global g_state\n global g_list_of_classifier\n\n id_client = json.loads(request.data.decode('UTF-8'))['id']\n self._reset()\n if os.path.exists(CLASSIFIER_PATH + str(id_client) + '.cls'):\n g_list_of_classifier.load_from_file(CLASSIFIER_PATH + \n str(id_client) + '.cls')\n else:\n g_list_of_classifier = init_classifier()\n return ''","def datasets(self):\n return [Dataset.ENSEMBL]","def load_data():\n dictionary = corpora.Dictionary.load(app.config['DICTIONARY'])\n matrix = similarities.MatrixSimilarity.load(app.config['MATRIX'])\n model = models.LsiModel.load(app.config['MODEL'])\n df = pd.read_pickle(app.config['DATA_FRAME'])\n return Data(matrix=matrix, model=model, dictionary=dictionary, data_frame=df)","def GetDataset():\n x_train = []\n x_test = []\n y_train = []\n y_test = []\n\n classes1 = set()\n classes2 = set()\n for f in GetInputFiles():\n class1, class2, fold, fname = f.split('\\\\')[-4:]\n classes1.add(class1)\n classes2.add(class2)\n class1 = class1.split('_')[0]\n class2 = class2.split('_')[0]\n\n x = ReadAndTokenize(f)\n y = [int(class1 == 'positive'), int(class2 == 'truthful')]\n if fold == 'fold4':\n x_test.append(x)\n y_test.append(y)\n else:\n x_train.append(x)\n y_train.append(y)\n\n ### Make numpy arrays.\n x_test = MakeDesignMatrix(x_test)\n x_train = MakeDesignMatrix(x_train)\n y_test = numpy.array(y_test, dtype='float32')\n y_train = numpy.array(y_train, dtype='float32')\n\n dataset = (x_train, y_train, x_test, y_test)\n with open('dataset.pkl', 'wb') as fout:\n pickle.dump(dataset, fout)\n return dataset","def gen_data(force=False):\n if force or (not os.path.isfile(DATA_FILE)):\n domains, labels = gen_malicious(10000)\n\n # Get equal number of benign/malicious\n domains += get_alexa(len(domains))\n labels += ['benign']*len(domains)\n\n pickle.dump(zip(labels, domains), open(DATA_FILE, 'w'))","def learnDataset(self, data_loader):\n\n print(\"learning dataset\")\n # we have 127940 sentences in total\n count = 0\n for sample in data_loader:\n input_sentence = sample[\"input\"][0]\n target_sentence = sample[\"target\"][0]\n\n # NOTE: target_word & input_word are actually indecies of words, instead of word strings\n # NOTE: the first word has index 1\n first_target = int(target_sentence[1])\n first_input = int(input_sentence[1])\n\n self.emiss_factors[0][(first_input, first_target)] += 1\n\n prev_target = first_target\n for word_idx in range(2, 16):\n # note that word_idx is 0 is always <BOS>\n target_word = int(target_sentence[word_idx])\n input_word = int(input_sentence[word_idx])\n\n self.emiss_factors[word_idx - 1][(input_word, target_word)] += 1\n self.trans_factors[word_idx - 2][(prev_target, target_word)] += 1\n prev_target = target_word\n\n print(\"{}/127940\".format(count), end = \"\\r\")\n count += 1\n print(\"127940/127940\")\n\n # all data updated, no need to do any insertion\n for i in range(15):\n self.emiss_factors[i].fixed()\n for i in range(14):\n self.trans_factors[i].fixed()","def LoadBatch(filename):","def load_nuclei(self, dataset_dir, subset):\n # Add classes. We have one class.\n # Naming the dataset nucleus, and the class nucleus\n self.add_class(self.dataset_name, 1, 'nucleus')\n\n # Which subset?\n # \"val\": use hard-coded list above\n # \"train\": use data from stage1_train minus the hard-coded list above\n # else: use the data from the specified sub-directory\n assert subset in [\"train\", \"val\", \"stage1_train\",\n \"stage1_test\", \"stage2_test\"]\n subset_dir = \"stage1_train\" if subset in [\"train\", \"val\"] else subset\n dataset_dir = os.path.join(dataset_dir, subset_dir)\n if subset == \"val\":\n image_ids = NucleusDatasetHandler.VAL_IMAGE_IDS\n else:\n # Get image ids from directory names\n image_ids = next(os.walk(dataset_dir))[1]\n if subset == \"train\":\n image_ids = list(set(image_ids) -\n set(NucleusDatasetHandler.VAL_IMAGE_IDS))\n\n # Add images\n for image_id in image_ids:\n image_name = f\"images/{image_id}.png\"\n self.add_image(\n self.dataset_name,\n image_id=image_id,\n path=os.path.join(dataset_dir, image_id, image_name)\n )","def _load(self, dataset):\n raise NotImplementedError('Loader {} does not support loading datasets.'.format(self.type()))","def load_label_data(label_data_file):\n pos_site_script_list = []\n with open(label_data_file, 'r') as f:\n for eachline in f:\n one_site = json.loads(eachline.rstrip())\n site_url = list(one_site.keys())[0]\n script_list = list(one_site.values())[0]\n if len(script_list) > 0:\n for eachscript_dict in script_list:\n script_url = list(eachscript_dict.keys())[0]\n fp_prop_list = list(eachscript_dict.values())[0]\n if len(fp_prop_list) > 0:\n pos_site_script_list.append((site_url, script_url))\n\n return pos_site_script_list","def get_data_loaders_4sentence():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_1generated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"]\n #history_complete.append(history)\n if len(history_splitted) > (len(persona)-1):\n history_chatbot = history[1::2]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss(persona_selected, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def __call__(self):\n\n dataset = TextOnlyCocoAnnotation()\n\n with open(self.path) as read_file:\n\n json_loaded = json.load(read_file)\n\n for i, value in tqdm(json_loaded['imgs'].items()):\n image_path = os.path.join(os.path.dirname(self.path), 'train2014',\n value['file_name'])\n dataset_type = value['set']\n\n if dataset_type not in self.sets:\n print(dataset_type)\n continue\n\n for annotation_id in json_loaded['imgToAnns'][i]:\n annotation_value = json_loaded['anns'][str(annotation_id)]\n word_annotation = self.parse_annotation_instance(annotation_value)\n dataset.add_bbox(image_path, imagesize.get(image_path), word_annotation)\n\n return dataset","def load_and_sanitize (data_file):\n data = pd.read_csv(data_file, encoding=\"latin-1\")\n data = data.drop(columns=['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'])\n data = data.rename(columns={\"v1\": \"class\", \"v2\": \"text\"})\n return data","def load_dataset(self, problem_name=\"\", split=\"train\"):\n\n orm = self.__orm\n username = \"admin\" # should be unused (unless submit new feature to db)\n\n with orm.session_scope() as session:\n if not problem_name:\n problem_name = session.query(Problem.name)\\\n .filter(Problem.name != \"demo\").scalar()\n problem_id = session.query(Problem.id)\\\n .filter(Problem.name == problem_name).scalar()\n\n data_dir = os.path.join(\"/data\", split)\n dataset, entities_featurized, target = load_dataset_from_dir(\n session, data_dir, problem_name)\n\n suffix = \"_\" + split\n\n return problem_name, dataset, entities_featurized, target","def get_data_loaders_3sentences():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_3generated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"][-(2*2+3):]\n #history_complete.append(history)\n if len(history) > 6:\n history_chatbot = history[1::2]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss_2(persona_selected, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def importScript():\n crosswalkFile = 'mayaToNuke.info'\n if os.path.exists(crosswalkFile):\n fileInfo = open(crosswalkFile, 'r')\n text = fileInfo.readlines()\n dic = eval(text[-1])\n nkFile = dic.get('file')\n if os.path.exists(nkFile):\n print 'importing: '+nkFile\n nuke.nodePaste(nkFile)\n else:\n print 'nuke script not found...'","def load_data():\r\n train = convert_corpus_to_lists(ConllCorpusReader('CoNLL-2003', 'train.txt', ['words', 'pos', 'ignore', 'chunk']))\r\n val = convert_corpus_to_lists(ConllCorpusReader('CoNLL-2003', 'valid.txt', ['words', 'pos', 'ignore', 'chunk'])) # testa will be our val set\r\n test = convert_corpus_to_lists(ConllCorpusReader('CoNLL-2003', 'test.txt', ['words', 'pos', 'ignore', 'chunk']))\r\n\r\n return train, val, test","def mnist_load_data(filename):\n if os.path.isfile(filename):\n mnist_file = open(filename, 'rb')\n train_set, valid_set, test_set = pickle.load(mnist_file)\n return train_set, valid_set, test_set\n else:\n print('Failed to find data file %s' % (filename))\n return None","def load_preprocessed_dataset(dest = \"./Datasets/preprocessed_IsophonicsDataset.ds\") -> tuple:\n with lzma.open(dest, \"rb\") as dataset_file:\n dataset = pickle.load(dataset_file)\n\n print(\"[INFO] The Preprocessed Isophonics Dataset was loaded successfully.\")\n return dataset","def load_training_data(s3: str = \"s3://epam-hack4med-dataset\") -> pd.DataFrame:\n # Load labels\n df_labels = pd.read_csv(f\"{s3}/CRACoV-ETYKIETY.csv\")\n df_labels[id_cols] = df_labels[id_cols].astype(int)\n df_labels = df_labels.set_index(id_cols)\n labels = df_labels[[basic_target]]\n idx = labels.index\n\n # Load hospital admission file (PRZYJECIE)\n df_admission = pd.read_csv(f\"{s3}/CRACoV-PRZYJECIE.csv\")\n binary_adm_vars = [x for x in basic_adm_vars if df_admission[x].isin([\"Tak\", \"Nie\"]).any()]\n other_adm_vars = [x for x in basic_adm_vars if x not in binary_adm_vars]\n adm = df_admission.copy()\n adm = adm[id_cols + binary_adm_vars + other_adm_vars]\n adm = adm.set_index(id_cols).reindex(idx)\n \n # Load biochem analyses\n biochem_raw = pd.read_csv(f\"{s3}/CRACoV-BIOCHEMIA.csv\", parse_dates=['DATA_WYK']).sort_values('DATA_WYK')\n biochem = (\n biochem_raw.loc[biochem_raw.KOD.isin(basic_bio_codes)]\n .pivot_table(index=['LP.', 'ID_LAB'], columns='KOD', values='WYNIK', aggfunc='first')\n .reindex(idx)\n )\n # Merge it all together\n Xy_raw = pd.concat([labels, adm, biochem], axis='columns')\n return Xy_raw","def load_raw_text():\n if not os.path.exists( os.path.join( DATA_HOME, RAW_TEXT_FILE ) ) or \\\n not os.path.exists( os.path.join( DATA_HOME, LABELS_FILE ) ):\n print( 'no prior files found. staring from scratch' )\n rev, rat = parse_json( os.path.join( DATA_HOME, JSON_FILE ) )\n y = np.array( rat )\n print( 'saving data to files' )\n pickle.dump( rev , open( os.path.join( DATA_HOME, RAW_TEXT_FILE ), 'wb' ) )\n pickle.dump( y , open( os.path.join( DATA_HOME, LABELS_FILE ), 'wb' ) )\n else:\n print( 'found raw text and labes. loading...' )\n rev = pickle.load( open( os.path.join( DATA_HOME, RAW_TEXT_FILE ), 'rb' ) )\n y = pickle.load( open( os.path.join( DATA_HOME, LABELS_FILE ), 'rb' ) )\n print( 'done' )\n \n return rev, y","def load_domain_split_dataset(self, data_dir, logger=None):\n current_dir = Path()\n dir_path = current_dir / \"data\" / \"break_data\" / \"preprocessed\"\n file_name = \"dataset_preprocessed_domain_split.pkl\"\n if not (dir_path / file_name).is_file():\n if logger:\n logger.info('Creating domain split dataset...')\n text_domain_dataset_prefixes = ('COMQA', 'CWQ', 'DROP', 'HOTP')\n image_domain_dataset_prefixes = ('CLEVR', 'NLVR2')\n DB_domain_dataset_prefixes = ('ACADEMIC', 'ATIS', 'GEO', 'SPIDER')\n image_plus_DB = image_domain_dataset_prefixes + DB_domain_dataset_prefixes\n train_filtererd = pd.DataFrame()\n validation_filtererd = pd.DataFrame()\n test_filtererd = pd.DataFrame()\n\n for i, example in enumerate(self.dataset_logical['train']):\n if example['question_id'].startswith(text_domain_dataset_prefixes):\n train_filtererd = train_filtererd.append(example, ignore_index=True)\n for i, example in enumerate(self.dataset_logical['validation']):\n if example['question_id'].startswith(image_plus_DB):\n validation_filtererd = validation_filtererd.append(example, ignore_index=True)\n for i, example in enumerate(self.dataset_logical['test']):\n if example['question_id'].startswith(image_plus_DB):\n test_filtererd = test_filtererd.append(example, ignore_index=True)\n\n # TODO delete this?\n # train_dataset = self.dataset_logical['train'].filter(\n # lambda example: example['question_id'].startswith(text_domain_dataset_prefixes))\n # validation_dataset = self.dataset_logical['validation'].filter(\n # lambda example: example['question_id'].startswith(image_plus_DB))\n # test_dataset = self.dataset_logical['test'].filter(\n # lambda example: example['question_id'].startswith(image_plus_DB))\n # train_filtererd_ds = Dataset.from_pandas(train_filtererd)\n to_save = {'train': Dataset.from_pandas(train_filtererd),\n 'validation': Dataset.from_pandas(validation_filtererd),\n 'test': Dataset.from_pandas(test_filtererd)}\n save_obj(dir_path, to_save, file_name)\n\n dataset = load_obj(dir_path, file_name)\n return dataset","def _load_passes():\n filepath = os.path.join(os.getcwd(), os.path.dirname(__file__), PASSES_TXT)\n f = open(filepath, 'r')\n passes = f.read()\n f.close()\n return passes.strip().split('\\n')","def load_dataset(file_path):\n return Dataset.load(file_path)","def load_data(data_path=DATA_PATH):\n with open (os.path.join(DATA_PATH, \"imdb_extrait.pkl\"),\"rb\") as file:\n \n [data , id2titles , fields ]= pk.load(file)\n \n \n datax = data [: ,:33]\n datay = np.array([1 if x [33] >6.5 else -1 for x in data ])\n \n return datax, datay, id2titles, fields","def load_dataset(train_path, test_path, tokenizer):\n train_dataset = TextDataset(\n tokenizer=tokenizer,\n file_path=train_path,\n block_size=128)\n\n test_dataset = TextDataset(\n tokenizer=tokenizer,\n file_path=test_path,\n block_size=128)\n\n data_collator = DataCollatorForLanguageModeling(\n tokenizer=tokenizer, mlm=False,\n )\n return train_dataset, test_dataset, data_collator","def get_data_loaders_1sentence():\n dataset_path = \"\"\n dataset_cache = None\n personachat = get_dataset(dataset_path, dataset_cache)\n\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\n logger.info(\"Build inputs and labels\")\n datasets = {\"train\": defaultdict(list), \"valid\": defaultdict(list)}\n personality = []\n history_complete = []\n count_persona = 0\n with open('data_faiss_pegasus_1_sentence_final_generated.pkl', 'rb') as f:\n persona_selected_list = pickle.load(f)\n for dataset_name, dataset in personachat.items():\n num_candidates = len(dataset[0][\"utterances\"][0][\"candidates\"])\n if num_candidates > 0 and dataset_name == 'train':\n num_candidates = min(1, num_candidates)\n for dialog in dataset:\n persona = dialog[\"persona_info\"].copy()\n #datasets[personality].append(persona)\n count_history = 0\n for utterance in dialog[\"utterances\"]:\n count_history = count_history + 1\n history = utterance[\"history\"][-(2*2+1):]\n #history_complete.append(history)\n if len(history) > 3:\n history_chatbot = history[1]\n persona_selected = persona_selected_list[count_persona]\n instance = build_input_from_segments_faiss(persona_selected, history_chatbot) \n for input_name, input_array in instance.items():\n datasets[dataset_name][input_name].append(input_array)\n count_persona = count_persona + 1\n return datasets","def load_data_clean(source='local'):\n\n train_bl, test_bl = load_data_raw(source)\n\n train = train_bl.copy()\n train = encode_dtypes(train)\n train = impute_missing(train)\n train = clean_data(train)\n\n test = test_bl.copy()\n test = encode_dtypes(test)\n test = impute_missing(test)\n test = clean_data(test)\n\n return train, test","def load_blogpan(path, subset=\"all\", shuffle=True, rnd=2356, vct=CountVectorizer(), fix_k=None, min_size=None, raw=False, percent=.5):\n PAN13_HOME = \"C:/Users/mramire8/Documents/Datasets/textclassification/raw data/author-profiling-gender/gender-profiling/blogs/blogs\"\n\n data = bunch.Bunch()\n\n if subset in ('train', 'test'):\n # data[subset] = load_files(\"{0}/{1}\".format(AVI_HOME, subset), encoding=\"latin1\", load_content=True,\n # random_state=rnd)\n raise Exception(\"We are not ready for train test aviation data yet\")\n elif subset == \"all\":\n data = load_files(PAN13_HOME, encoding=\"latin1\", load_content=True,\n random_state=rnd)\n # parser = XMLParser(encoding=\"latin-1\", recover=True)\n parser = etree.XMLParser(recover=True)\n data.data = [clean_xml_pan(text, parser=parser) for text in data.data]\n # data[\"test\"] = load_files(\"{0}/{1}\".format(AVI_HOME, \"test\"), encoding=\"latin1\", load_content=True,\n # random_state=rnd)\n else:\n raise ValueError(\n \"subset can only be 'train', 'test' or 'all', got '%s'\" % subset)\n\n # train_x, test_x, train_y, test_y = train_test_split(data.data, data.target, test_size=0.25,\n # random_state=rnd)\n\n indices = ShuffleSplit(len(data.data), n_iter=1, test_size=percent, random_state=rnd)\n for train_ind, test_ind in indices:\n\n data = bunch.Bunch(train=bunch.Bunch(data=[data.data[i] for i in train_ind], target=data.target[train_ind]),\n test=bunch.Bunch(data=[data.data[i] for i in test_ind], target=data.target[test_ind]))\n # if shuffle:\n # random_state = np.random.RandomState(rnd)\n # indices = np.arange(data.train.target.shape[0])\n # random_state.shuffle(indices)\n # data.train.filenames = data.train.filenames[indices]\n # data.train.target = data.train.target[indices]\n # # Use an object array to shuffle: avoids memory copy\n # data_lst = np.array(data.train.data, dtype=object)\n # data_lst = data_lst[indices]\n # data.train.data = data_lst.tolist()\n\n if not raw:\n data = process_data(data, fix_k, min_size, vct)\n\n return data","def process_mlm_dataset(self, set_type):\n if not os.path.exists(os.path.join(self.dataset_dir, f'{self.dataset_name}train_examples.pkl')):\n self.train = open(os.path.join(self.dataset_dir, f'{self.dataset_name}train.txt'), 'r').read().lower().split(' \\n ')\n if not os.path.exists(os.path.join(self.dataset_dir, f'{self.dataset_name}test_examples.pkl')):\n self.test = open(os.path.join(self.dataset_dir, f'{self.dataset_name}test.txt'), 'r').read().lower().split(' \\n ')\n if not os.path.exists(os.path.join(self.dataset_dir, f'{self.dataset_name}dev_examples.pkl')):\n self.dev = open(os.path.join(self.dataset_dir, f'{self.dataset_name}dev.txt'), 'r').read().lower().split(' \\n ')","def load_data(path='./data/train'):\n print(\"Loading IMDB Data...\")\n data = []\n\n dir = os.path.dirname(__file__)\n file_list = glob.glob(os.path.join(dir, path + '/pos/*'))\n file_list.extend(glob.glob(os.path.join(dir, path + '/neg/*')))\n print(\"Parsing %s files\" % len(file_list))\n for i, f in enumerate(file_list):\n with open(f, \"r\", encoding=\"utf8\") as openf:\n s = openf.read()\n data.append(imp.preprocess(s)) # NOTE: Preprocessing code called here on all reviews\n return data","def load_data(self):\n with open('data/fordTrain.csv') as f:\n data = csv.reader(f, delimiter=',')\n train = [x for i, x in enumerate(data) if i > 0] \n # Extract features and target variable separately\n trainx = [x[3:] for x in train]\n trainy = [x[2] for x in train]\n\n with open('data/fordTest.csv') as f:\n data = csv.reader(f, delimiter=',')\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \n\n with open('data/Solution.csv') as f:\n data = csv.reader(f, delimiter=',')\n testy = [x[2] for i, x in enumerate(data) if i > 0] \n\n # Extract features and target variable, convert to numpy array\n trainx = np.asarray(trainx, dtype=np.float32)\n trainy = np.asarray(trainy, dtype=np.int8)\n testx = np.asarray(testx, dtype=np.float32)\n testy = np.asarray(testy, dtype=np.int8)\n\n # Return training and test sets\n trainSet = Dataset(trainx, trainy)\n testSet = Dataset(testx, testy)\n return trainSet, testSet","def test_loadData():\n \n sys = LVsystem.Ecosystem()\n \n sys.loadSetup('2Prey1Predator')\n \n \n data = sys.create_data()\n \n assert data[0] == 3\n assert data[1] == ['rabbit', 'hen', 'fox']\n assert data[2] == [30,10,20]\n assert data[3] == [0.09,0.07,-0.06] \n assert data[4] == [10000,10000,1]\n assert data[5] == [400,500,250]\n assert data[6][1][2] == -data[6][2][1]\n assert data[6][2][2] == 0\n\n sys.removeSpecies('rabbit')\n sys.removeSpecies('fox')\n sys.removeSpecies('hen')","def load_dataset(self, split='train'):\n path = self.args.data\n if not os.path.exists(path):\n raise FileNotFoundError(\n \"Dataset not found: ({})\".format(path)\n )\n\n files = os.listdir(path) if os.path.isdir(path) else [path]\n files = [f for f in files if split in f]\n assert len(files) > 0\n\n self.datasets[split] = CombineBertData(files)\n\n\n \"\"\"\n dataset = data_utils.load_indexed_dataset(\n split_path, self.dictionary, self.args.dataset_impl, combine=combine\n )\n if dataset is None:\n raise FileNotFoundError(\n \"Dataset not found: {} ({})\".format(split, split_path)\n )\n\n dataset = TokenBlockDataset(\n dataset,\n dataset.sizes,\n self.args.tokens_per_sample,\n pad=self.dictionary.pad(),\n eos=self.dictionary.eos(),\n break_mode=self.args.sample_break_mode,\n include_targets=True,\n )\n\n add_eos_for_other_targets = (\n self.args.sample_break_mode is not None\n and self.args.sample_break_mode != \"none\"\n )\n\n self.datasets[split] = MonolingualDataset(\n dataset,\n dataset.sizes,\n self.dictionary,\n self.output_dictionary,\n add_eos_for_other_targets=add_eos_for_other_targets,\n shuffle=True,\n targets=self.targets,\n add_bos_token=self.args.add_bos_token,\n )\n \"\"\"","def load_data(self):\n raise NotImplementedError()","def loadSets(self, indir=\"\"):\n\n if indir==\"\":\n print(\"specify folder\")\n return -1\n\n self.train = pd.read_pickle(\"{}/train.pkl\".format(indir))\n self.valid = pd.read_pickle(\"{}/valid.pkl\".format(indir))\n self.test = pd.read_pickle(\"{}/test.pkl\".format(indir))\n\n print(\"sets loaded\")","def load_processed_dataset(name):\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\n path = os.path.join('downloads', name)\n path_processed = os.path.join(path, 'processed')\n\n if name == 'iris':\n return pd.read_csv(os.path.join(path_processed, 'iris.csv'))\n\n elif name == 'wine':\n return pd.read_csv(os.path.join(path_processed, 'wine.csv'))\n\n elif name == 'titanic':\n return pd.read_csv(os.path.join(path_processed, 'titanic.csv'))\n\n elif name == 'lanl':\n with open(os.path.join(path_processed, 'train_data.pkl'), 'rb') as f:\n x = pkl.load(f)\n with open(os.path.join(path_processed, 'train_targets.pkl'), 'rb') as f:\n y = pkl.load(f)\n return x, y\n\n elif name == 'MNIST' or name == 'FashionMNIST':\n training = torch.load(os.path.join(path_processed, 'training.pt'))\n test = torch.load(os.path.join(path_processed, 'test.pt'))\n return training, test","def load_data(limit=None, load_test=False):\n data_snli_dev, data_snli_train = None, None\n data_multinli_train, data_multinli_dev = None, None\n data_mli_train, data_mli_dev = None, None\n data_mli_test = None\n\n if SNLI_TRAIN_FILENAME.exists():\n data_snli_train = read_nli_data(SNLI_TRAIN_FILENAME, set_genre='snli', limit=limit)\n data_snli_dev = read_nli_data(SNLI_DEV_FILENAME, set_genre='snli', limit=limit)\n logging.info('SNLI: train - %s, dev - %s', data_snli_train.shape, data_snli_dev.shape)\n\n if MULTINLI_TRAIN_FILENAME.exists():\n data_multinli_train = read_nli_data(MULTINLI_TRAIN_FILENAME, limit=limit)\n data_multinli_dev = read_nli_data(MULTINLI_DEV_FILENAME, limit=limit)\n logging.info('MultiNLI: train - %s, dev - %s', data_multinli_train.shape, data_multinli_dev.shape)\n\n if MLI_TRAIN_FILENAME.exists():\n data_mli_train = read_nli_data(MLI_TRAIN_FILENAME, set_genre='clinical', limit=limit)\n data_mli_dev = read_nli_data(MLI_DEV_FILENAME, set_genre='clinical', limit=limit)\n logging.info('MLI: train - %s, dev - %s', data_mli_train.shape, data_mli_dev.shape)\n\n if load_test:\n data_mli_test = read_nli_data(MLI_TEST_FILENAME, set_genre='clinical', limit=limit)\n\n # Drop columns that are presented not in all datasets\n columns_to_drop = ['captionID', 'promptID', 'annotator_labels']\n for d in [data_snli_dev, data_snli_train, data_multinli_train, data_multinli_dev, data_mli_train, data_mli_dev,\n data_mli_test]:\n if d is not None:\n d.drop(columns_to_drop, axis=1, inplace=True, errors='ignore')\n\n # concatenate all data together\n data_train = pd.concat([data_snli_train, data_multinli_train, data_mli_train], axis=0)\n data_dev = pd.concat([data_snli_dev, data_multinli_dev, data_mli_dev], axis=0)\n\n data_train.set_index('genre', inplace=True)\n data_dev.set_index('genre', inplace=True)\n\n if data_mli_test is not None:\n data_mli_test.set_index('genre', inplace=True)\n\n if not load_test:\n return data_dev, data_train\n else:\n return data_dev, data_train, data_mli_test","def load_dataset():\n\n\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\n collate_fn=PadCollate())\n\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\n collate_fn=PadCollate())\n\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\n\n return train_dd_loader, train_dataloader, test_dataloader","def load_dataset(self):\n # Get all the files in the directory\n file_list = self.get_file_list()\n\n # Concatenate the data corresponding to a list of files\n data = self.concatenate_file_data(file_list)\n\n # Shuffle the data and create the training and the validation datasets\n data = self.shuffle_data_dictionary(data)\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)","def learnDataset(self, data_loader):\n print(\"learning dataset\")\n\n count = 0\n for sample in data_loader:\n input_sentence = sample[\"input\"][0]\n target_sentence = sample[\"target\"][0]\n\n prev_word = None\n for word_idx in range(1, 16):\n target_word = int(target_sentence[word_idx])\n self.model_parts[word_idx - 1].populateFactors(\n input_sentence, target_word, prev_word\n )\n prev_word = target_word\n\n print(\"{}/127940\".format(count), end = \"\\r\")\n count += 1\n print(\"127940/127940\")\n\n print(\"before fixed\", list(self.model_parts[0].factors[0].d.keys())[:10])\n for i in range(15):\n self.model_parts[i].fixed()\n print(\"after fixed\", self.model_parts[0].factors[0].keys[:10])","def _get_dataset(\n self,\n dataset_path: str,\n data_folder: str = \"data/\",\n ):\n if not os.path.isdir(dataset_path):\n click.secho(f\"{dataset_path} not found!\", fg=\"red\")\n\n dataset_hash = (\n int(hashlib.sha256(dataset_path.encode(\"utf-8\")).hexdigest(), 16) % 10 ** 8\n )\n\n # To avoid using cache for different models\n # split(/) for google/electra-base-discriminator\n pretrained_model = (\n self.hparams.pretrained_model.split(\"/\")[1]\n if \"/\" in self.hparams.pretrained_model\n else self.hparams.pretrained_model\n )\n dataset_cache = data_folder + \".dataset_\" + str(dataset_hash) + pretrained_model\n\n if os.path.isfile(dataset_cache):\n click.secho(f\"Loading tokenized dataset from cache: {dataset_cache}.\")\n return torch.load(dataset_cache)\n\n dataset_path += \"\" if dataset_path.endswith(\"/\") else \"/\"\n dataset = {\n \"train\": pd.read_csv(dataset_path + \"train.tsv\", sep=\"\\t\").to_dict(\n \"records\"\n ),\n \"valid\": pd.read_csv(dataset_path + \"valid.tsv\", sep=\"\\t\").to_dict(\n \"records\"\n ),\n \"test\": pd.read_csv(dataset_path + \"test.tsv\", sep=\"\\t\").to_dict(\"records\"),\n }\n # Read Labels\n with open(dataset_path + \"labels.txt\", \"r\") as fp:\n labels = [line.strip() for line in fp.readlines()]\n label_encoder = {labels[i]: i for i in range(len(labels))}\n\n dataset[\"label_encoder\"] = label_encoder\n # Tokenize\n dataset[\"train\"] = self._tokenize(dataset[\"train\"])\n dataset[\"valid\"] = self._tokenize(dataset[\"valid\"])\n dataset[\"test\"] = self._tokenize(dataset[\"test\"])\n torch.save(dataset, dataset_cache)\n return dataset","def main(self, data):\n\t\ttokenizer = BertTokenizer.from_pretrained(\"bert-base-uncased\", do_lower_case=True)\n\t\teval_features = self.get_features(data, self.labels, tokenizer, self.max_seq_length)\n\t\tlabel, prob = self.predict(eval_features)\n\t\treturn label, prob","def load_data():\n f = gzip.open('../data/mnist.pkl.gz', mode='rb')\n\n # NOTE: I get errors when I don't use encoding='latin1' because of Python 2 vs Python 3 compatibility issues\n # training_data, validation_data, test_data = pickle.load(f, encoding='latin1')\n training_data, validation_data, test_data = pickle.load(f)\n\n f.close()\n\n return training_data, validation_data, test_data","def load_eval_dataset(self):\n dict_path = get_eval_data(self.eval_path, self.src_lang, self.tgt_lang)\n\n pairs = []\n not_found_all = 0\n not_found_L1 = 0\n not_found_L2 = 0\n\n # Open the file and check if src and tgt word exists in the vocab\n with open(dict_path, \"r\") as f:\n for _, line in enumerate(f):\n word1, word2 = line.rstrip().split()\n if word1 in self.src_dico and word2 in self.tgt_dico:\n pairs.append((self.src_dico.index(word1), self.tgt_dico.index(word2)))\n else:\n not_found_all += 1\n not_found_L1 += int(word1 not in self.src_dico)\n not_found_L2 += int(word2 not in self.tgt_dico)\n print(\n \"Found %i pairs of words in the dictionary (%i unique). \"\n \" %i other pairs contained at least one unknown word \"\n \" (%i in src_lang, %i in tgt_lang)\"\n % (\n len(pairs),\n len(set([x for x, _ in pairs])),\n not_found_all,\n not_found_L1,\n not_found_L2,\n )\n )\n src_ind = [pairs[x][0] for x in range(len(pairs))]\n tgt_ind = [pairs[x][1] for x in range(len(pairs))]\n self.src_ind = np.asarray(src_ind)\n self.tgt_ind = np.asarray(tgt_ind)","def load_raw_data(prot, shuffle=True):\n dna_seq = []\n binding = []\n data_file = os.path.join(DATA_DIR, prot, 'train')\n with open(data_file, 'r') as f:\n datas = f.readlines()\n if shuffle:\n random.shuffle(datas)\n dna_seq.extend(data.split()[0] for data in datas)\n binding.extend(eval(data.split()[1]) for data in datas)\n return dna_seq, binding","def __loadDataset(self, parameters):\n # self.localConfigured = Settings.instance().readValue( key = 'Common/local-repo' )\n for pr in parameters:\n if pr['type'] == 'dataset':\n if pr['value'].startswith('undefined:/'):\n fileName = pr['value'].split('undefined:/')[1]\n if not os.path.exists( fileName ):\n raise Exception(\"the following test data file is missing: %s \" % fileName)\n\n doc = FileModelTestData.DataModel()\n res = doc.load( absPath = fileName )\n pr['value'] = \"undefined:/%s\" % doc.getRaw()\n elif pr['value'].startswith('local-tests:/'):\n fileName = pr['value'].split('local-tests:/')[1]\n\n if not os.path.exists( fileName ):\n raise Exception(\"the following test data file is missing: %s \" % fileName)\n \n doc = FileModelTestData.DataModel()\n res = doc.load( absPath = fileName )\n pr['value'] = \"local-tests:/%s\" % doc.getRaw()\n else:\n pass","def load_data(filename):\n assert os.path.exists(filename)==True\n dat = scipy.io.loadmat(filename)\n inputs = dat['inputs']\n #print len(inputs)\n targets = dat['targets']\n #print len(targets)\n assert len(inputs)==len(targets)\n\n global alldata\n global indim \n global outdim\n\n indim = len(inputs[0])\n outdim = 1\n #print indim\n alldata = ClassificationDataSet(indim, outdim, nb_classes = 8)\n alldata.setField('input',inputs)\n alldata.setField('target',targets)\n\n assert len(alldata['input'])==len(alldata['target'])\n print type(alldata)","def load_data(self):\n with open(self.file_name) as f:\n lines = f.readlines()\n\n labels = list()\n all_dat = list()\n for i, l in enumerate(lines):\n\n labels.append(int(l[0]))\n\n l = gensim.utils.any2unicode(l)\n all_dat.append(LabeledSentence(l.split(\"\\t\")[-1], [i]))\n\n return all_dat, np.asarray(labels)","def load_predicted_results(self):\n print(\"\\n\\nLoad prediction answers : \")\n with open(\"predicted_results\", \"rb\") as predicted_results:\n self.predicted_results = pickle.load(predicted_results)","def load_data(self):\n print(\"Loading dataset...\")\n # Load the dataset\n subIDs, data, labels = dl.load_processed_data_N_subjects_allchans(\n '../data_5sec_100Hz_bipolar/', Nsub=14)\n\n if len(data) > 1:\n\n # If more than one patient loaded, append data to single array\n data_arr = np.array(data[0])\n label_arr = labels[0]\n\n for sub in range(1, len(data)):\n data_arr = np.append(data_arr, data[sub], axis=1)\n label_arr = np.append(label_arr, labels[sub], axis=0)\n\n else:\n # Remove the extra dimension at axis=0\n data_array = np.squeeze(data)\n labels = np.squeeze(labels)\n\n # Move trials to the end so data array is 'nchan x timeseries x trials'\n self.data = np.moveaxis(data_arr, 1, -1)\n self.labels = np.array(label_arr)\n\n self.label_strings = dl.available_stringlabels\n\n valid_indices = np.sum(self.labels, axis=0)\n names = [[self.label_strings[i], i, valid_indices[i]] for i in range(len(valid_indices)) if valid_indices[i] > 0]\n print(\"A summary of valid labels is below: \\nFormat: [Label name, label index, Label count]\")\n for i in range(len(names)):\n print(names[i])\n return","def load_training_data(file_path):\n return load_data(file_path)","def load_data_from_files(self):\n # separated method to allow mock easier\n logger.info(\"Loading data...\")\n parent = Path(__file__).parent\n path = parent / \"resources\" / \"scores.txt\"\n self.scorer.load_from_file(path)\n path = parent / \"resources\" / \"american-english-large.txt\"\n self.trie.load_from_file(path)\n path = parent / \"resources\" / \"reels.txt\"\n self.reels = Reel.get_from_file(path)\n logger.info(\"Data loaded!\")","def load_dataset(self, split, epoch=0, combine=False, **kwargs):\n paths = self.args.data.split(':')\n assert len(paths) > 0\n data_path = paths[epoch % len(paths)]\n\n # infer langcode\n src, tgt = self.args.source_lang, self.args.target_lang\n if not hasattr(self.args, \"source_tau\"): self.args.source_tau = -1\n if not hasattr(self.args, \"target_tau\"): self.args.target_tau = -1\n\n if not hasattr(self.args, 'source_tau'): self.args.source_tau = -1\n if not hasattr(self.args, 'target_tau'): self.args.target_tau = -1\n\n if self.args.main_src_wordfreq is not None and self.args.dialect_src_wordfreq is not None:\n def word_idx_from_file(filename):\n idx = []\n with open(filename, 'r') as myfile:\n for line in myfile:\n idx.append(self.src_dict.index(line.split()[0]))\n return idx\n self.main_src_word_idx = word_idx_from_file(self.args.main_src_wordfreq) \n self.dialect_src_word_idx = word_idx_from_file(self.args.dialect_src_wordfreq)\n idx_to_sample_prob = []\n for i, src_word in enumerate(self.main_src_word_idx):\n if self.args.dialect_tau == -1:\n dialect_word_probs = np.array([1. for k in range(len(self.dialect_src_word_idx))])\n else:\n dialect_word_probs = np.array([-np.absolute(k-i) for k in range(len(self.dialect_src_word_idx))])\n idx_to_sample_prob.append(dialect_word_probs)\n #self.idx_to_sample_prob = scipy.special.softmax(np.array(self.idx_to_sample_prob)*0.01, axis=1)\n idx_to_sample_prob = scipy.special.softmax(np.array(idx_to_sample_prob)*self.args.dialect_tau, axis=1)\n print(idx_to_sample_prob)\n self.idx_to_sample_prob = {}\n for i, src_word in enumerate(self.main_src_word_idx):\n self.idx_to_sample_prob[src_word] = idx_to_sample_prob[i]\n pass_item = (self.idx_to_sample_prob, self.dialect_src_word_idx)\n else:\n pass_item = None\n if split != 'train':\n src_tau = -1 \n tgt_tau = -1\n mlm = None\n idx_to_src_gradnorm = None\n else: \n src_tau = self.args.source_tau \n tgt_tau = self.args.target_tau \n mlm = self.mlm\n idx_to_src_gradnorm = self.idx_to_src_gradnorm\n\n self.datasets[split] = load_langpair_dataset(\n data_path, split, src, self.src_dict, tgt, self.tgt_dict,\n combine=combine, dataset_impl=self.args.dataset_impl,\n upsample_primary=self.args.upsample_primary,\n left_pad_source=self.args.left_pad_source,\n left_pad_target=self.args.left_pad_target,\n max_source_positions=self.args.max_source_positions,\n max_target_positions=self.args.max_target_positions,\n src_tag=self.args.src_tag, tgt_tag=self.args.tgt_tag,\n src_tau=src_tau, tgt_tau=tgt_tau,\n epoch=epoch,\n id_to_sample_probabilities=pass_item,\n lm=mlm,\n idx_to_src_gradnorm=idx_to_src_gradnorm,\n )"],"string":"[\n \"def _load_original_dataset(data_directory, setname):\\n\\n Sign = collections.namedtuple(\\\"Sign\\\", [\\\"visibility\\\", \\\"type\\\", \\\"name\\\"])\\n data_directory = pathlib.Path(data_directory)\\n filename = data_directory / setname / \\\"annotations.txt\\\"\\n with tf.io.gfile.GFile(filename) as f:\\n files, annotations = zip(*(l.strip().split(\\\":\\\", 1) for l in f))\\n\\n all_signs = []\\n for annotation in annotations:\\n signs = []\\n for sign in annotation.split(\\\";\\\"):\\n if sign == [\\\"\\\"] or not sign: continue\\n parts = [s.strip() for s in sign.split(\\\",\\\")]\\n if parts[0] == \\\"MISC_SIGNS\\\": continue\\n signs.append(Sign(parts[0], parts[5], parts[6]))\\n all_signs.append(signs)\\n\\n filepaths = (data_directory / setname / f for f in files)\\n return zip(filepaths, all_signs)\",\n \"def load_all_script(train_rating_path,test_negative_path, test_num=100):\\n\\ttrain_data = pd.read_csv(\\n\\t\\ttrain_rating_path, \\n\\t\\tsep='\\\\t', header=None, names=['user', 'item'], \\n\\t\\tusecols=[0, 1], dtype={0: np.int32, 1: np.int32})\\n\\n\\tuser_num = train_data['user'].max() + 1\\n\\titem_num = train_data['item'].max() + 1\\n\\n\\ttrain_data = train_data.values.tolist()\\n\\n\\t# load ratings as a dok matrix\\n\\ttrain_mat = sp.dok_matrix((user_num, item_num), dtype=np.float32)\\n\\tfor x in train_data:\\n\\t\\ttrain_mat[x[0], x[1]] = 1.0\\n\\n\\ttest_data = []\\n\\twith open(test_negative_path, 'r') as fd:\\n\\t\\tline = fd.readline()\\n\\t\\twhile line != None and line != '':\\n\\t\\t\\tarr = line.split('\\\\t')\\n\\t\\t\\tu = eval(arr[0])[0]\\n\\t\\t\\ttest_data.append([u, eval(arr[0])[1]])\\n\\t\\t\\tfor i in arr[1:]:\\n\\t\\t\\t\\ttest_data.append([u, int(i)])\\n\\t\\t\\tline = fd.readline()\\n\\treturn train_data, test_data, user_num, item_num, train_mat\",\n \"def load_classification_dataset(step, do_lower_case,data_type,data_subtype,use_syntetic_data):\\n assert step in ['train', 'test']\\n binary = False \\n undersample_majority = False\\n\\n paths = ['~/Github/Data/Patient/NIRADS/PET_CT_NIRADS.xlsx', '~/Github/Data/Patient/NIRADS/MR_NIRADS_2018.xlsx','~/Github/Data/Patient/NIRADS/MR_NIRADS.xlsx']\\n if data_type == 'ct':\\n data_r = pd.read_excel(paths[0])\\n else:\\n data_r = pd.read_excel(paths[1])\\n data_r.append(pd.read_excel(paths[2]), ignore_index = True, sort=False)\\n\\n data_p,data_n, y_p, y_n = tc.text_cleaning(data_r, None, data_target='section') \\n\\n if data_subtype == 'primary':\\n data = data_p\\n y = y_p -1\\n else:\\n data = data_n\\n y = y_n -1\\n\\n if binary:\\n y[y<2]=0\\n y[y>0]=1\\n\\n y_dist = [np.sum(y==x) for x in np.unique(y)]\\n print(\\\"Distribution of all labels: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n train_text, test_text, y_train, y_test = train_test_split(data, y, test_size=0.2, random_state=1)\\n\\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\\n print(\\\"Distribution of training labels: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n if step =='train':\\n if use_syntetic_data:\\n data_syntetic = pd.read_csv('~/Github/Data/Patient/NIRADS/PET_CT_NIRADS_syntetic.csv')\\n train_text = np.concatenate((train_text,data_syntetic['syntetic_data'].values))\\n y_train = np.concatenate((y_train,data_syntetic['syntetic_label'].values-1))\\n\\n train_text, test_text, y_train, y_test = train_test_split(train_text, y_train, test_size=0.5, random_state=1)\\n train_text = np.concatenate((train_text,test_text))\\n y_train = np.concatenate((y_train,y_test))\\n y_dist = [np.sum(y_train==x) for x in np.unique(y_train)]\\n print(\\\"Distribution of training labels after inserting syntetic data: \\\", y_dist, \\\"\\\\n\\\\n\\\")\\n\\n if not undersample_majority:\\n data_to_use = train_text.copy()\\n y_to_use = y_train.copy()\\n else:\\n max_label1 = 1000\\n data_to_use = []\\n y_to_use = []\\n y1=0\\n for x in range(len(y_train)):\\n if y_train[x] !=1:\\n data_to_use.append(train_text[x])\\n y_to_use.append(y_train[x])\\n else:\\n if y1 <max_label1:\\n data_to_use.append(train_text[x])\\n y_to_use.append(y_train[x])\\n y1+=1\\n\\n else:\\n data_to_use = test_text.copy()\\n y_to_use = y_test.copy()\\n\\n basic_tokenizer = BasicTokenizer(do_lower_case=do_lower_case)\\n examples = []\\n\\n for i, tokens in tqdm(enumerate(data_to_use)):\\n label = y_to_use[i]\\n examples.append(\\n ClassificationExample(\\n id=i,\\n tokens_a=basic_tokenizer.tokenize(tokens),\\n tokens_b=None,\\n label=label,\\n )\\n )\\n logging.info('Number of `%s` examples: %d', step, len(examples))\\n \\n return examples\",\n \"def load_data(self):\\n return self._load_data(\\\"--codemeta-file\\\")\",\n \"def import_datasets(snli_path):\\n print('extract data from snli directory..')\\n train = dict(); dev = dict(); test = dict()\\n gold_labels = {'entailment': 0, 'neutral': 1, 'contradiction': 2}\\n\\n for file_type in ['train', 'dev', 'test']:\\n path = os.path.join(snli_path, 'snli_1.0_{}.jsonl'.format(file_type))\\n with open(path) as file:\\n data = [json.loads(line) for line in file]\\n eval(file_type)['premise'] = [entry['sentence1'] for entry in data if entry['gold_label'] != '-']\\n eval(file_type)['hypothesis'] = [entry['sentence2'] for entry in data if entry['gold_label'] != '-']\\n g_labels = np.array([gold_labels[entry['gold_label']] for entry in data if entry['gold_label'] != '-'])\\n eval(file_type)['label'] = g_labels\\n print('extraction process was finished successfully!')\\n return train, dev, test\",\n \"def load_cleaned_data(self):\\n try:\\n self.train = pd.read_pickle('../input/train_clean.pkl')\\n self.test = pd.read_pickle('../input/test_clean.pkl')\\n except FileNotFoundError:\\n self.load_raw_data()\",\n \"def load_raw_dataset(name):\\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\\n\\n os.makedirs('downloads', exist_ok=True)\\n path = os.path.join('downloads', name)\\n path_raw = os.path.join(path, 'raw')\\n\\n if name == 'iris':\\n prep_path(path)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data', path_raw)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names', path_raw)\\n return pd.read_csv(os.path.join(path_raw, 'iris.data'), names=['sepal_len', 'sepal_wid', 'petal_len', 'petal_wid', 'species'])\\n\\n elif name == 'wine':\\n prep_path(path)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data', path_raw)\\n safe_dl('https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.names', path_raw)\\n return pd.read_csv(os.path.join(path_raw, 'wine.data'), names=['class',\\n 'alcohol',\\n 'malic_acid',\\n 'ash',\\n 'alkalinity',\\n 'magnesium',\\n 'phenols',\\n 'flavanoids',\\n 'nonflavanoid_phenols',\\n 'proanthocyanins',\\n 'color_intensity',\\n 'hue',\\n 'dilution',\\n 'proline'])\\n\\n elif name == 'titanic':\\n import kaggle; kaggle.api.authenticate()\\n prep_path(path)\\n if len(os.listdir(path_raw)) == 0:\\n kaggle.api.competition_download_files('titanic', path_raw)\\n titanic = pd.read_csv(os.path.join(path_raw, 'train.csv'))\\n titanic_test = pd.read_csv(os.path.join(path_raw, 'test.csv'))\\n return titanic, titanic_test\\n\\n elif name == 'lanl':\\n import kaggle; kaggle.api.authenticate()\\n prep_path(path)\\n if len(os.listdir(path)) == 0:\\n kaggle.api.competition_download_files('LANL-Earthquake-Prediction', path_raw)\\n if not os.path.exists(os.path.join(path_raw, 'test')):\\n zip_ref = zipfile.ZipFile(os.path.join(path_raw, 'test.zip'), 'r')\\n zip_ref.extractall(os.path.join(path_raw, 'test'))\\n zip_ref.close()\\n return pd.read_csv(os.path.join(path_raw, 'train.csv.zip'))\\n\\n elif name == 'MNIST':\\n mnist = torchvision.datasets.MNIST('downloads', train=True, download=True)\\n mnist_test = torchvision.datasets.MNIST('downloads', train=False, download=True)\\n return mnist, mnist_test\\n\\n elif name == 'FashionMNIST':\\n fmnist = torchvision.datasets.FashionMNIST('downloads', train=True, download=True)\\n fmnist_test = torchvision.datasets.FashionMNIST('downloads', train=False, download=True)\\n return fmnist, fmnist_test\",\n \"def load_examples_data(dataset_name):\\n dataset_name = dataset_name.strip().lower()\\n if dataset_name.lower() not in ['pokemon', 'hanzi', 'animals', 'nsfw', 'simpsons', 'horse2zebra', 'people',\\n 'autodrive', 'superresolution', 'anpr', 'beauty','antisproofing','facelandmarks','dogs-vs-cats','chinese']:\\n raise ValueError('Not a valid dataset_name.')\\n dataset_name = 'examples_' + dataset_name\\n dirname = os.path.join(_trident_dir, dataset_name)\\n if not os.path.exists(dirname):\\n try:\\n os.makedirs(dirname)\\n except OSError:\\n # Except permission denied and potential race conditions\\n # in multi-threaded environments.\\n pass\\n is_internet_ok = is_connected()\\n if dataset_name == 'examples_pokemon':\\n is_download=download_file_from_google_drive('1U-xc54fX9j9BcidvRa0ow6qjssMlSF2A', dirname, 'pokemon.tar')\\n tar_file_path = os.path.join(dirname, 'pokemon.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n extract_path = os.path.join(dirname, 'pokemon')\\n dataset = load_folder_images(dataset_name, extract_path, folder_as_label=False)\\n print('get pokemon images :{0}'.format(len(dataset)))\\n return dataset\\n\\n\\n elif dataset_name == 'examples_hanzi':\\n download_file_from_google_drive('13UEzSG0az113gpRPKPyKrIE2HDaA2P4H', dirname, 'hanzi.tar')\\n tar_file_path = os.path.join(dirname, 'hanzi.tar')\\n extract_path = os.path.join(dirname, 'hanzi')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n dataset = load_folder_images(dataset_name, os.path.join(dirname, 'train'), folder_as_label=True,\\n object_type=ObjectType.gray)\\n\\n dataset_test = load_folder_images(dataset_name, os.path.join(dirname, 'test'), folder_as_label=True,\\n object_type=ObjectType.gray)\\n\\n dataset.testdata = dataset_test.traindata\\n dataset.class_names['zh-cn'] = dataset.class_names['en-us']\\n return dataset\\n\\n elif dataset_name == 'examples_animals':\\n download_file_from_google_drive('19Cjq8OO6qd9k9TMZxlPjDpejDOdiHJoW', dirname, 'animals.tar')\\n tar_file_path = os.path.join(dirname, 'animals.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n dataset = load_folder_images(dataset_name, dirname, folder_as_label=True)\\n return dataset\\n elif dataset_name == 'examples_nsfw':\\n tar_file_path = os.path.join(dirname, 'nsfw.tar')\\n if os.path.exists(tar_file_path) and get_file_create_time(tar_file_path)<datetime.datetime(2021, 2, 20, 0, 0, 0).timestamp():\\n os.remove(tar_file_path)\\n if os.path.exists(os.path.join(dirname,'porn_detection_data.pkl')):\\n os.remove(os.path.join(dirname,'porn_detection_data.pkl'))\\n _delete_h(dirname)\\n download_file_from_google_drive('1EXpV2QUrSFJ7zJn8NqtqFl1k6HvXsUzp', dirname, 'nsfw.tar')\\n\\n extract_path = os.path.join(dirname, 'nsfw')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n folders = ['drawings', 'hentai', 'neutral', 'porn', 'sexy']\\n data=unpickle(os.path.join(dirname,'porn_detection_data.pkl'))\\n\\n trainData = []\\n testData = []\\n trainLabel = []\\n testLabel = []\\n for n in range(5):\\n folder=folders[n]\\n trainData.extend(data[folder]['train'])\\n trainLabel.extend([n]*len(data[folder]['train']))\\n testData.extend(data[folder]['test'])\\n testLabel.extend([n] * len(data[folder]['test']))\\n\\n trainarray = ImageDataset(trainData,object_type=ObjectType.rgb)\\n trainlabel = LabelDataset(trainLabel,object_type=ObjectType.classification_label)\\n train_iter = Iterator(data=trainarray, label=trainlabel)\\n\\n testarray = ImageDataset(testData,object_type=ObjectType.rgb)\\n testlabel = LabelDataset(testLabel,object_type=ObjectType.classification_label)\\n test_iter = Iterator(data=testarray, label=testlabel)\\n print('training images: {0} test images:{1}'.format(len(trainarray), len(testarray)))\\n\\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\\n dataset.binding_class_names(['drawing', 'hentai', 'neutral', 'porn', 'sexy'], 'en-us')\\n dataset.binding_class_names(['绘画', '色情漫画', '中性', '色情', '性感'], 'zh-cn')\\n dataset.binding_class_names(['繪畫', '色情漫畫', '中性', '色情', '性感'], 'zh-tw')\\n dataset.scenario = 'train'\\n return dataset\\n elif dataset_name == 'examples_simpsons':\\n download_file_from_google_drive('1hGNFbfBv3EZ4nx4Qod6PtSYzO8H4QIxC', dirname, 'simpsons.tar')\\n tar_file_path = os.path.join(dirname, 'simpsons.tar')\\n extract_path = os.path.join(dirname, 'simpsons')\\n extract_archive(tar_file_path, extract_path, archive_format='tar')\\n data_provider = load_folder_images(dataset_name, extract_path, folder_as_label=False)\\n data_provider.traindata.unpair = RandomNoiseDataset(shape=(100), random_mode='normal')\\n print('get simpsons images :{0}'.format(len(data_provider.traindata.data.items)))\\n return data_provider\\n elif dataset_name == 'examples_horse2zebra':\\n download_file_from_google_drive('1pqj-T90Vh4wVNBV09kYZWgVPsZUA2f7U', dirname, 'horse2zebra.tar')\\n tar_file_path = os.path.join(dirname, 'horse2zebra.tar')\\n extract_path = os.path.join(dirname, 'horse2zebra')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n trainA = ImageDataset(list_images(os.path.join(dirname, 'trainA')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n trainB = ImageDataset(list_images(os.path.join(dirname, 'trainB')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n testA = ImageDataset(list_images(os.path.join(dirname, 'testA')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n testB = ImageDataset(list_images(os.path.join(dirname, 'testB')), object_type=ObjectType.rgb,\\n get_image_mode=GetImageMode.processed)\\n train_iter = Iterator(data=trainA, unpair=trainB)\\n test_iter = Iterator(data=testA, unpair=testB)\\n dataset = DataProvider(dataset_name, traindata=train_iter, testdata=test_iter)\\n print('get horse2zebra images :{0}'.format(len(dataset)))\\n return dataset\\n elif dataset_name == 'examples_people':\\n download_file_from_google_drive('1H7mJJfWpmXpRxurMZQqY4N_UXWLbQ2pT', dirname, 'people.tar')\\n tar_file_path = os.path.join(dirname, 'people.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, 'imgs', '*.*g'))\\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\\n imgs=list(sorted(imgs))\\n masks = list(sorted(masks))\\n # make_dir_if_need(os.path.join(dirname, 'trimap'))\\n # for i in range(len(masks)):\\n # mask=mask2array(masks[i])\\n # trimap=mask2trimap(mask)\\n # save_mask(trimap,masks[i].replace('masks','trimap'))\\n # print('trimap',len(masks))\\n\\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb)\\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.binary_mask)\\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\\n print('get people images :{0}'.format(len(dataset)))\\n return dataset\\n elif dataset_name == 'examples_autodrive':\\n download_file_from_google_drive('1JqPPeHqhWLqnI6bD8nuHcVx-Y56oIZMK', dirname, 'autodrive.tar')\\n tar_file_path = os.path.join(dirname, 'autodrive.tar')\\n extract_path = os.path.join(dirname, 'autodrive')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, 'images', '*.*g'))\\n masks = glob.glob(os.path.join(dirname, 'masks', '*.png'))\\n imgs = list(sorted(imgs))\\n masks = list(sorted(masks))\\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb,symbol='image')\\n mskdata = MaskDataset(masks=masks, object_type=ObjectType.color_mask,symbol='mask')\\n\\n def parse_code(l):\\n if len(l.strip().split(\\\"\\\\t\\\")) == 2:\\n a, b = l.replace('\\\\t\\\\t', '\\\\t').strip().split(\\\"\\\\t\\\")\\n return tuple(int(i) for i in b.split(' ')), a\\n\\n label_codes, label_names = zip(\\n *[parse_code(l) for l in open(os.path.join(dirname, \\\"label_colors.txt\\\")).readlines()])\\n for i in range(len(label_codes)):\\n mskdata.palette[label_names[i]] = label_codes[i]\\n\\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=mskdata))\\n print('get autodrive images :{0}'.format(len(dataset)))\\n return dataset\\n elif dataset_name == 'examples_superresolution':\\n download_file_from_google_drive('1v1uoymrWI_MLSiGvSGW7tWJYSnzzXpEQ', dirname, 'superresolution.tar')\\n tar_file_path = os.path.join(dirname, 'superresolution.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\\n imgs.extend(glob.glob(os.path.join(dirname, '*.bmp')))\\n imgs = list(sorted(imgs))\\n\\n print('get super resolution images :{0}'.format(len(imgs)))\\n\\n imgdata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='lr')\\n labeldata = ImageDataset(images=imgs * 2, object_type=ObjectType.rgb, symbol='hr')\\n dataset = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=labeldata))\\n return dataset\\n elif dataset_name == 'examples_beauty':\\n download_file_from_google_drive('1aJhxN9IqsxuayhRTm-gmxk6PiLe5wm9X', dirname, 'beauty.tar')\\n tar_file_path = os.path.join(dirname, 'beauty.tar')\\n\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n # 讀取圖片數據\\n images_dict = {}\\n with open(os.path.join(dirname, 'images_dict.pkl'), 'rb') as fp:\\n images_dict = pickle.load(fp)\\n\\n f = open(os.path.join(dirname, 'All_Ratings.txt'), encoding='utf-8-sig').readlines()\\n imgs = []\\n landmarks = []\\n ratings = []\\n for row in f:\\n data = row.strip().split('\\\\t')\\n if 'images\\\\\\\\' + data[0] in images_dict:\\n img = images_dict['images\\\\\\\\' + data[0]][0]\\n img = img.transpose([2, 0, 1])[::-1].transpose([1, 2, 0])\\n imgs.append(img)\\n landmark = images_dict['images\\\\\\\\' + data[0]][1].astype(np.float32)\\n landmarks.append(landmark)\\n rating = (float(data[1])) / 5.00\\n ratings.append(rating)\\n print('{0} faces loaded...'.format(len(imgs)))\\n imgdata = ImageDataset(images=imgs, object_type=ObjectType.rgb, symbol='faces')\\n landmarkdata = LandmarkDataset(landmarks=landmarks, object_type=ObjectType.landmarks, symbol='target_landmarks')\\n labeldata = LabelDataset(data=ratings,object_type=ObjectType.classification_label, symbol='target_beauty')\\n data_provider = DataProvider(dataset_name=dataset_name, traindata=Iterator(data=imgdata, label=Dataset.zip(landmarkdata,labeldata)))\\n return data_provider\\n\\n elif dataset_name == 'examples_facelandmarks':\\n download_file_from_google_drive('1GtswQBAHPa_bXaB4tW2uOOQ8Lxfz2L5B', dirname, 'ibug_300W.tar')\\n tar_file_path = os.path.join(dirname, 'ibug_300W.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n root_dir=os.path.join(dirname, 'ibug_300W_large_face_landmark_dataset')\\n image_paths = {}\\n landmarks = {}\\n crops = {}\\n\\n for mode in ['train','test']:\\n make_dir_if_need(os.path.join(dirname, 'crops',mode))\\n tree = ElementTree.parse(os.path.join(root_dir, 'labels_ibug_300W_{0}.xml'.format(mode)))\\n root = tree.getroot()\\n image_paths[mode]=[]\\n landmarks[mode] = []\\n crops[mode] = []\\n\\n offset=5\\n for j in tqdm(range(len(root[2]))):\\n try:\\n filename=root[2][j]\\n landmark = []\\n for num in range(68):\\n x_coordinate = int(filename[0][num].attrib['x'])\\n y_coordinate = int(filename[0][num].attrib['y'])\\n landmark.append([x_coordinate, y_coordinate])\\n landmark=np.asarray(landmark)\\n\\n crop = filename[0].attrib\\n for k in crop.keys():\\n crop[k] = int(crop[k]) if isinstance(crop[k], str) else crop[k]\\n for k in crop.keys():\\n if k=='top' and int(landmark[:,1].min())<int(crop[k]):\\n crop[k] = int( landmark[:,1].min())\\n crop[ 'height']+=crop[k]-int(landmark[:,1].min())\\n elif k=='left' and int(landmark[:,0].min())<int(crop[k]):\\n crop[k] = int( landmark[:,0].min())\\n crop['width']+= crop[k] - int(landmark[:, 0].min())\\n elif k == 'width' and int(landmark[:, 0].max()-landmark[:, 0].min()) > int(crop[k]):\\n crop[k] = int(landmark[:, 0].max()-landmark[:, 0].min())\\n elif k == 'height' and int(landmark[:, 1].max()-landmark[:, 1].min()) > int(crop[k]):\\n crop[k] = int(landmark[:, 1].max()-landmark[:, 1].min())\\n\\n crop['left']-=offset\\n crop['top'] -= offset\\n crop['width'] += 2*offset\\n crop['height'] += 2*offset\\n\\n\\n landmark[:,0]-=crop['left']\\n landmark[:, 1] -= crop['top']\\n\\n\\n if not os.path.exists(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j))):\\n im=image2array(os.path.join(root_dir, filename.attrib['file']))\\n if im.ndim==2:\\n im=cv2.cvtColor(im,cv2.COLOR_GRAY2RGB)\\n im=im[crop['top']:min(crop['top']+crop['height'],im.shape[0]),crop['left']:min(crop['left']+crop['width'],im.shape[1]),:]\\n\\n if max(im.shape[:2])/max(min(im.shape[:2]),0)<=5:\\n\\n array2image(im).save(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\\n image_paths[mode].append(os.path.join(dirname, 'crops', mode, '{0}.png'.format(j)))\\n crops[mode].append(crop)\\n landmarks[mode].append(landmark)\\n del im\\n else:\\n #im = image2array(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\\n image_paths[mode].append(os.path.join(dirname, 'crops',mode,'{0}.png'.format(j)))\\n crops[mode].append(crop)\\n landmarks[mode].append(landmark)\\n\\n if j%100==0:\\n gc.collect()\\n except Exception as e:\\n pass\\n\\n print('ibug 300w train dataset: images: {0} landmarks:{1} \\\\n'.format(len(image_paths['train']),len(landmarks['train'])))\\n print('ibug 300w test dataset: images: {0} landmarks:{1} \\\\n'.format(len(image_paths['test']), len(landmarks['test'])))\\n imdata=ImageDataset(images=image_paths['train'],symbol='faces',object_type=ObjectType.rgb)\\n landmarkdata = LandmarkDataset(landmarks=landmarks['train'], symbol='landmarks',object_type=ObjectType.landmarks)\\n imtestdata = ImageDataset(images=image_paths['test'], symbol='faces',object_type=ObjectType.rgb)\\n landmarktestdata = LandmarkDataset(landmarks=landmarks['test'], symbol='landmarks',object_type=ObjectType.landmarks)\\n data_provider=DataProvider(traindata=Iterator(data=imdata,label=landmarkdata),testdata=Iterator(data=imtestdata,label=landmarktestdata))\\n return data_provider\\n\\n elif dataset_name == 'examples_antisproofing':\\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n data_provider = load_folder_images(dataset_name,os.path.join(dirname, 'antisproofing'))\\n return data_provider\\n elif dataset_name == 'examples_anpr':\\n download_file_from_google_drive('1uGBd8tXlP0TZAXNgrR6H0jl5MXj7VPbN', dirname, 'anpr.tar')\\n tar_file_path = os.path.join(dirname, 'anpr.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n imgs = glob.glob(os.path.join(dirname, '*.*g'))\\n imgs = list(sorted(imgs))\\n\\n # CCPD (Chinese City Parking Dataset, ECCV) and PDRC (license Plate Detection and Recognition Challenge)\\n # https://github.com/detectRecog/CCPD\\n provinces = [\\\"皖\\\", \\\"沪\\\", \\\"津\\\", \\\"渝\\\", \\\"冀\\\", \\\"晋\\\", \\\"蒙\\\", \\\"辽\\\", \\\"吉\\\", \\\"黑\\\", \\\"苏\\\", \\\"浙\\\", \\\"京\\\", \\\"闽\\\", \\\"赣\\\", \\\"鲁\\\", \\\"豫\\\", \\\"鄂\\\", \\\"湘\\\", \\\"粤\\\",\\n \\\"桂\\\", \\\"琼\\\", \\\"川\\\", \\\"贵\\\", \\\"云\\\", \\\"藏\\\", \\\"陕\\\", \\\"甘\\\", \\\"青\\\", \\\"宁\\\", \\\"新\\\", \\\"警\\\", \\\"学\\\", \\\"O\\\"]\\n alphabets = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',\\n 'W', 'X', 'Y', 'Z', 'O']\\n ads = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',\\n 'X', 'Y', 'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'O']\\n\\n def lp2char(lp):\\n cols = lp.split('_')\\n charstring = ''\\n for i in range(len(cols)):\\n if i == 0:\\n charstring += provinces[int(cols[i])]\\n elif i == 1:\\n charstring += alphabets[int(cols[i])]\\n else:\\n charstring += ads[int(cols[i])]\\n return charstring\\n\\n width = 720\\n height = 1160\\n for im_path in imgs:\\n lbl = im_path.split('/')[-1].rsplit('.', 1)[0].split('-')[-3]\\n charstring = lp2char(lbl)\\n iname = im_path.rsplit('/', 1)[-1].rsplit('.', 1)[0].split('-')\\n [leftUp, rightDown] = [[int(eel) for eel in el.split('&')] for el in iname[2].split('_')]\\n box = [leftUp[0], leftUp[1], rightDown[0], rightDown[1]]\\n ori_w, ori_h = [float(int(el)) for el in [width, height]]\\n new_labels = [(leftUp[0] + rightDown[0]) / (2 * ori_w), (leftUp[1] + rightDown[1]) / (2 * ori_h),\\n (rightDown[0] - leftUp[0]) / ori_w, (rightDown[1] - leftUp[1]) / ori_h]\\n download_file_from_google_drive('1e7Zjn2MHNCvA5gXdJUECzY8NjK4KVpa7', dirname, 'antisproofing.tar')\\n tar_file_path = os.path.join(dirname, 'antisproofing.tar')\\n make_dir_if_need(os.path.join(dirname, 'antisproofing'))\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n data_provider = load_folder_images(dataset_name, os.path.join(dirname, 'antisproofing'))\\n return data_provider\\n\\n\\n\\n elif dataset_name == 'examples_dogs-vs-cats':\\n download_file_from_google_drive('10czW0On7eIXkPP-MuQ-IRxMWdTizWjNC', dirname, 'dogs-vs-cats.tar')\\n tar_file_path = os.path.join(dirname, 'dogs-vs-cats.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n data_provider = load_folder_images(dataset_name, dirname)\\n return data_provider\\n elif dataset_name == 'examples_chinese':\\n to_half=ToHalfWidth()\\n to_sc=ChineseConvert(convert_to='simplified')\\n download_file_from_google_drive('1yzRzXpLuhSUxnixqCgpbdTk16ajnTEWF', dirname, 'chinese.tar')\\n tar_file_path = os.path.join(dirname, 'chinese.tar')\\n extract_archive(tar_file_path, dirname, archive_format='tar')\\n\\n as_train = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_training.utf8'), encoding='utf-8-sig').read().strip().replace('\\\\u3000' ,'|'))).splitlines()\\n cityu_train =remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_training.utf8'), encoding='utf-8-sig').read().strip().replace(' ','|'))).splitlines()\\n\\n as_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'as_testing_gold.utf8'), encoding='utf-8-sig').read().strip().replace('\\\\u3000', '|'))).splitlines()\\n cityu_test = remove_nonprintable(to_half(codecs.open(os.path.join(dirname, 'cityu_test_gold.utf8'), encoding='utf-8-sig').read().strip().replace(' ', '|'))).splitlines()\\n\\n\\n data = as_train + cityu_train # 把兩個語料合併\\n test_data=as_test + cityu_test # 把兩個語料合併\\n\\n\\n raw_data_train = [row.strip('\\\\n').strip('\\\\r') for row in data] # 移除分行字元\\n raw_data_test = [row.strip('\\\\n').strip('\\\\r') for row in test_data] # 移除分行字元\\n\\n process_data_train=[]\\n process_seg_label_train = []\\n process_simplifided_label_train = []\\n process_traditional_label_train = []\\n\\n tmp_data_train = []\\n tmp_seg_label_train = []\\n tmp_simplifided_label_train = []\\n tmp_pronunce_label_train = []\\n for k in tqdm(range(len(raw_data_train))):\\n row=raw_data_train[k]\\n if row.startswith('∥'):\\n row=row[1:]\\n words=row.replace('||','|').split('|')\\n for k in range(len(words)):\\n\\n word = words[k]\\n\\n for i in range(len(word)):\\n tmp_data_train.append(word[i])\\n #tmp_simplifided_label_train.append(to_half(to_sc(word[i])))\\n #轉換為BMES\\n\\n if i==0 and len(word)>1: #B 是一個詞的開始\\n tmp_seg_label_train.append('B')\\n elif i==len(word)-1 and len(word)>=2 and tmp_seg_label_train[-1] in ['B','M']: #E 是一個詞的結束\\n tmp_seg_label_train.append('E')\\n elif len(word)==1 and i==0: #S 自己就是一個單詞\\n tmp_seg_label_train.append('S')\\n elif len(word)>=3 and tmp_seg_label_train[-1] in ['B','M']: #M 是一個詞的中間\\n tmp_seg_label_train.append('M')\\n\\n if len(tmp_seg_label_train)>0 and tmp_seg_label_train[-1] in ['E','S']:\\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)) and k+1<len(words):\\n if word in [ '。','﹖']:\\n pass\\n\\n elif random.random() < 0.6 or is_alphabet(word):\\n tmp_data_train.append(' ')\\n tmp_seg_label_train.append('S')\\n\\n if (k+1<len(raw_data_train) and not raw_data_train[k+1].startswith( '」')) and words[-1] in [ '。','﹖']:\\n #process_traditional_label_train.append(tmp_data_train)\\n\\n tmp_data_train=to_half(''.join(tmp_data_train))\\n tmp_seg_label_train = ''.join(tmp_seg_label_train)\\n # if len(tmp_data_train)!=len(tmp_seg_label_train):\\n # print('')\\n tmp_simplifided_label_train =to_sc(tmp_data_train)\\n\\n process_data_train.append(tmp_data_train)\\n process_seg_label_train.append(tmp_seg_label_train)\\n process_simplifided_label_train.append(tmp_simplifided_label_train)\\n tmp_data_train = []\\n tmp_seg_label_train = []\\n tmp_simplifided_label_train = []\\n tmp_pronunce_label_train = []\\n # else:\\n # tmp_data_train.append('\\\\n')\\n # tmp_simplifided_label_train.append('\\\\n')\\n # tmp_seg_label_train.append('\\\\n')\\n corpus=process_data_train\\n seg_corpus=process_seg_label_train\\n simplifided_corpus =process_simplifided_label_train\\n\\n process_data_test = []\\n process_seg_label_test = []\\n process_simplifided_label_test = []\\n process_traditional_label_test = []\\n print('generate test labels')\\n tmp_data_test = []\\n tmp_seg_label_test = []\\n tmp_simplifided_label_test = []\\n tmp_pronunce_label_test = []\\n for k in tqdm(range(len(raw_data_test))):\\n row=raw_data_test[k]\\n if row.startswith('∥'):\\n row=row[1:]\\n words = row.replace('||', '|').split('|')\\n for k in range(len(words)):\\n\\n word = words[k]\\n\\n for i in range(len(word)):\\n tmp_data_test.append(word[i])\\n # tmp_simplifided_label_test.append(to_half(to_sc(word[i])))\\n # 轉換為BMES\\n\\n if i == 0 and len(word) > 1: # B 是一個詞的開始\\n tmp_seg_label_test.append('B')\\n elif i == len(word) - 1 and len(word) >= 2 and tmp_seg_label_test[-1] in ['B', 'M']: # E 是一個詞的結束\\n tmp_seg_label_test.append('E')\\n elif len(word) == 1 and i == 0: # S 自己就是一個單詞\\n tmp_seg_label_test.append('S')\\n elif len(word) >= 3 and tmp_seg_label_test[-1] in ['B', 'M']: # M 是一個詞的中間\\n tmp_seg_label_test.append('M')\\n\\n if len(tmp_seg_label_test) > 0 and tmp_seg_label_test[-1] in ['E', 'S'] and k+1<len(words):\\n if len(word) > 1 and (is_alphabet(word) or is_punctuation(word)):\\n if word in ['。', '﹖']:\\n pass\\n elif random.random() < 0.6 or is_alphabet(word):\\n tmp_data_test.append(' ')\\n tmp_seg_label_test.append('S')\\n\\n if (k + 1 < len(raw_data_test) and not raw_data_test[k + 1].startswith('」')) and words[-1] in ['。', '﹖']:\\n # process_traditional_label_test.append(tmp_data_test)\\n\\n tmp_data_test = to_half(''.join(tmp_data_test))\\n tmp_seg_label_test = ''.join(tmp_seg_label_test)\\n # if len(tmp_data_test)!=len(tmp_seg_label_test):\\n # print('')\\n tmp_simplifided_label_test = to_sc(tmp_data_test)\\n\\n process_data_test.append(tmp_data_test)\\n process_seg_label_test.append(tmp_seg_label_test)\\n process_simplifided_label_test.append(tmp_simplifided_label_test)\\n tmp_data_test = []\\n tmp_seg_label_test = []\\n tmp_simplifided_label_test = []\\n tmp_pronunce_label_test = []\\n # else:\\n # tmp_data_test.append('\\\\n')\\n # tmp_simplifided_label_test.append('\\\\n')\\n # tmp_seg_label_test.append('\\\\n')\\n test_corpus = process_data_test\\n test_seg_corpus = process_seg_label_test\\n test_simplifided_corpus = process_simplifided_label_test\\n\\n\\n data=TextSequenceDataset(corpus=corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\\n seg_label = TextSequenceDataset(corpus=seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\\n simplifided_label = TextSequenceDataset(corpus=simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\\n traditional_label = TextSequenceDataset(corpus= copy.deepcopy(corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\\n\\n data_test=TextSequenceDataset(corpus=test_corpus,sequence_length=64,sequence_start_at='section_start',object_type=ObjectType.corpus,symbol='input')\\n seg_test_label = TextSequenceDataset(corpus=test_seg_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='seg_label')\\n simplifided_test_label = TextSequenceDataset(corpus=test_simplifided_corpus,sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='simplified_label')\\n traditional_test_label = TextSequenceDataset(corpus= copy.deepcopy(test_corpus), sequence_length=64, sequence_start_at='section_start', object_type=ObjectType.sequence_label,symbol='traditional_label')\\n\\n\\n chars = list(sorted(set(list( ''.join(corpus) +bpmf_phonetic+'\\\\n\\\\r\\\\t∥'+ ''.join(simplifided_corpus)+''.join(test_data)))))\\n chars.insert(0, '[CLS]')\\n chars.insert(1, '[SEP]')\\n chars.insert(2, '[UNK]')\\n chars.insert(3, '[PAD]')\\n chars.insert(4, '[MASK]')\\n\\n data.vocabs =data_test.vocabs=simplifided_label.vocabs=simplifided_test_label.vocabs = chars\\n data.text2index=data_test.text2index =simplifided_label.text2index=simplifided_test_label.text2index = dict((c, i) for i, c in enumerate(chars))\\n data.index2text =data_test.index2text =simplifided_label.index2text=simplifided_test_label.index2text= dict((i, c) for i, c in enumerate(chars))\\n traditional_label = copy.deepcopy(data)\\n traditional_test_label = copy.deepcopy(data_test)\\n traditional_label.object_type =traditional_test_label.object_type = ObjectType.sequence_label\\n traditional_label.symbol =traditional_test_label.symbol = 'traditional_label'\\n\\n mask_label = copy.deepcopy(data)\\n mask_test_label = copy.deepcopy(data_test)\\n #mask_label.object_type =mask_test_label.object_type= ObjectType.corpus\\n mask_label.symbol = mask_test_label.symbol = 'mask_label'\\n\\n\\n\\n nextword=copy.deepcopy(data)\\n nextword_test = copy.deepcopy(data_test)\\n nextword.object_type=nextword_test.object_type=ObjectType.sequence_label\\n nextword.symbol=nextword_test.symbol='nextword_label'\\n nextword.sequence_offset=nextword_test.sequence_offset=1\\n\\n label=ZipDataset(seg_label,nextword,simplifided_label,traditional_label,mask_label)\\n label_test = ZipDataset(seg_test_label, nextword_test, simplifided_test_label, traditional_test_label, mask_test_label)\\n provider=TextSequenceDataProvider(\\n traindata=Iterator(data=data,label=label),\\n testdata=Iterator(data=data_test,label=label_test))\\n return provider\\n #,sample_filter=lambda x:x[0][-1]==3\\n else:\\n return None\",\n \"def load_matt_mahoney_text8_dataset():\\n import zipfile\\n from six.moves import urllib\\n\\n url = 'http://mattmahoney.net/dc/'\\n\\n def download_matt_mahoney_text8(filename, expected_bytes):\\n \\\"\\\"\\\"Download a text file from Matt Mahoney's website\\n if not present, and make sure it's the right size.\\\"\\\"\\\"\\n if not os.path.exists(filename):\\n print('Downloading ...')\\n filename, _ = urllib.request.urlretrieve(url + filename, filename)\\n statinfo = os.stat(filename)\\n if statinfo.st_size == expected_bytes:\\n print('Found and verified', filename)\\n else:\\n print(statinfo.st_size)\\n raise Exception(\\n 'Failed to verify ' + filename + '. Can you get to it with a browser?')\\n return filename\\n\\n filename = download_matt_mahoney_text8('text8.zip', 31344016)\\n\\n with zipfile.ZipFile(filename) as f:\\n word_list = f.read(f.namelist()[0]).split()\\n return word_list\",\n \"def load_data(nlp, cue_verbs, poly):\\n train_dicts, _ = load_quote_authors(nlp)\\n author_prediction_dataset = AuthorPredictionDataset(train_dicts, cue_verbs, poly)\\n return np.array(train_dicts), author_prediction_dataset\",\n \"def load_for_sklearn(self):\\n\\n labels = [] # string labels\\n examples = [] # examples as strings\\n\\n # document number -> label mapping\\n doc2label = n2b2.map_patients_to_labels(\\n self.xml_dir,\\n self.category)\\n\\n for f in os.listdir(self.cui_dir):\\n doc_id = f.split('.')[0]\\n file_path = os.path.join(self.cui_dir, f)\\n file_as_string = open(file_path).read()\\n\\n string_label = doc2label[doc_id]\\n int_label = LABEL2INT[string_label]\\n labels.append(int_label)\\n examples.append(file_as_string)\\n\\n return examples, labels\",\n \"def load_data(self) -> None:\",\n \"def load_caps(batch_size = 128):\\r\\n def relabel_classes(class_idx):\\r\\n if 10 <= class_idx <= 35:\\r\\n return class_idx - 10\\r\\n return None\\r\\n\\r\\n\\r\\n\\r\\n train_ds = torchvision.datasets.EMNIST(root='./data',\\r\\n train=True,\\r\\n download=True,\\r\\n split = 'byclass',\\r\\n transform = emnist_img_transform,\\r\\n target_transform = relabel_classes)\\r\\n\\r\\n\\r\\n\\r\\n test_ds = torchvision.datasets.EMNIST(root='./data',\\r\\n train=False,\\r\\n download=True,\\r\\n split = 'byclass',\\r\\n transform = emnist_img_transform,\\r\\n target_transform = relabel_classes)\\r\\n\\r\\n # Discard unwanted characters from the background data\\r\\n train_ds = discard_none_targets(train_ds)\\r\\n test_ds = discard_none_targets(test_ds)\\r\\n\\r\\n\\r\\n # create data loaders and shuffle everything...\\r\\n train_dl = torch.utils.data.DataLoader(train_ds,\\r\\n batch_size=batch_size,\\r\\n shuffle=True)\\r\\n\\r\\n test_dl = torch.utils.data.DataLoader(test_ds,\\r\\n batch_size=batch_size,\\r\\n shuffle=True)\\r\\n\\r\\n return train_dl,test_dl\",\n \"def load_data(path_dataset):\\n data = read_txt(path_dataset)[1:]\\n return preprocess_data(data)\",\n \"def load_dataset(fname, nb_lines):\\n import os.path\\n if os.path.isfile('safe/Amazon-'+str(nb_lines)+'.p'):\\n return util.load('safe/Amazon-'+str(nb_lines)+'.p')\\n count = 1\\n X = []\\n y = []\\n with open(fname) as f:\\n for line in f:\\n text, label = read_line(line)\\n #print((label, text))\\n X.append(text)\\n y.append(label)\\n if count >= nb_lines:\\n break\\n count+=1\\n\\n #load pretrained dictonary\\n dico = util.load('safe/vocab_gensim.p')\\n preprocessor = text_preprocessing.Preprocessor(dico=dico)\\n X = preprocessor.preprocess(X)\\n #save the loaded dataset in a pickle for speeding up next run\\n util.save((X,y), 'safe/Amazon-'+str(nb_lines)+'.p')\\n return (X, y)\",\n \"def load_data(self):\\n sets = ['train', 'val']\\n images = []\\n labels = []\\n self.labels_dic = {}\\n file = open(self.path + 'wnids.txt')\\n train_labels = file.read().split()\\n if self.train:\\n for fn in range(self.num_classes):\\n f = train_labels[fn]\\n for i in os.listdir(self.path + 'train/' + f + '/images/'):\\n images.append(Image.open(self.path + 'train/' + f + '/images/' + i))\\n labels.append(f)\\n #image label n link to folder names of TinyImageNet\\n self.labels_dic[f] = fn\\n\\n else:\\n for fn in range(self.num_classes):\\n f = train_labels[fn]\\n self.labels_dic[f] = fn\\n file_val = open(self.path + 'val/val_annotations.txt')\\n val_labels = file_val.read().split('\\\\n')\\n for im in val_labels:\\n im_data = im.split(\\\"\\t\\\")[:2]\\n if len(im_data) < 2:\\n continue\\n if im_data[1] in self.labels_dic:\\n images.append(Image.open(self.path + 'val/images/' + im_data[0]))\\n labels.append(im_data[1])\\n\\n self.images = images\\n self.labels = labels\",\n \"def load_dataset(self):\\n\\n train_path = os.path.join(self.dataset_path, 'images_background')\\n validation_path = os.path.join(self.dataset_path, 'images_evaluation')\\n\\n # First let's take care of the train alphabets\\n for alphabet in os.listdir(train_path):\\n if alphabet[0] == '.':\\n continue\\n alphabet_path = os.path.join(train_path, alphabet)\\n\\n current_alphabet_dictionary = {}\\n\\n for character in os.listdir(alphabet_path):\\n if character[0] == '.':\\n continue\\n character_path = os.path.join(alphabet_path, character)\\n\\n current_alphabet_dictionary[character] = os.listdir(\\n character_path)\\n\\n self.train_dictionary[alphabet] = current_alphabet_dictionary\\n\\n # Now it's time for the validation alphabets\\n for alphabet in os.listdir(validation_path):\\n alphabet_path = os.path.join(validation_path, alphabet)\\n if alphabet[0] == '.':\\n continue\\n\\n current_alphabet_dictionary = {}\\n\\n for character in os.listdir(alphabet_path):\\n if character[0] == '.':\\n continue\\n character_path = os.path.join(alphabet_path, character)\\n\\n current_alphabet_dictionary[character] = os.listdir(\\n character_path)\\n\\n self.evaluation_dictionary[alphabet] = current_alphabet_dictionary\",\n \"def load_data_and_labels():\\n # Load data from files\\n positive_examples = []\\n for file in os.listdir('with_datarace'):\\n filename = os.fsdecode(file)\\n ast_file = open('with_datarace\\\\\\\\' + filename, 'r')\\n token_vector = ast_file.read()\\n positive_examples.append(token_vector)\\n file_names.append(filename)\\n\\n negative_examples = []\\n for file in os.listdir('without_datarace\\\\\\\\'):\\n filename = os.fsdecode(file)\\n ast_file = open('without_datarace\\\\\\\\' + filename, 'r')\\n token_vector = ast_file.read()\\n negative_examples.append(token_vector) # List of lists\\n file_names.append(filename)\\n\\n positive_examples = [s.strip() for s in positive_examples]\\n negative_examples = [s.strip() for s in negative_examples]\\n\\n # Split by words\\n x_text = positive_examples + negative_examples # why we didn't cobine it from the beginning?\\n x_text = [clean_str(sent) for sent in x_text]\\n x_text = [s.split(\\\" \\\") for s in x_text]\\n\\n # Generate labels\\n positive_labels = [[0, 1] for _ in positive_examples]\\n negative_labels = [[1, 0] for _ in negative_examples]\\n y = np.concatenate([positive_labels, negative_labels], 0)\\n\\n return [x_text, y]\",\n \"def load_data_raw(source='local'):\\n import os\\n\\n if source == 'kaggle':\\n # Download the Ames Housing Dataset\\n # Set the enviroment variables\\n import zipfile\\n os.environ['KAGGLE_USERNAME'] = \\\"lubomrstraka\\\"\\n os.environ['KAGGLE_KEY'] = \\\"c7347462ef834e6645ce238c2f2fa561\\\"\\n \\n # Import dependencies\\n os.system(\\\"pip install kaggle --upgrade --quiet\\\")\\n\\n # Download datasets\\n os.system(\\\"kaggle competitions download -c house-prices-advanced-regression-techniques --quiet\\\")\\n \\n # Extract data\\n with zipfile.ZipFile('house-prices-advanced-regression-techniques.zip', 'r') as archive:\\n archive.extractall()\\n\\n # Read Train & Test Baseline Data\\n train_bl = pd.read_csv('train.csv', index_col='Id')\\n test_bl = pd.read_csv('test.csv', index_col='Id')\\n \\n # Using local data used while registering dataset\\n # prevents \\\"Too many requests\\\" response from Kaggle\\n elif source == 'local': \\n train_bl = pd.read_csv('train.csv', index_col='Id')\\n test_bl = pd.read_csv('test.csv', index_col='Id')\\n \\n else:\\n print('Missing data!')\\n train_bl = pd.DataFrame()\\n test_bl = pd.DataFrame()\\n\\n\\n return train_bl, test_bl\",\n \"def loadData(self, dataType): \\n if dataType == \\\"train\\\":\\n f = self.urls[0]\\n elif dataType == \\\"valid\\\":\\n f = self.urls[1]\\n elif dataType == \\\"test\\\":\\n f = self.urls[2] \\n\\n \\\"\\\"\\\" Load text file \\\"\\\"\\\"\\n corpus = list()\\n with io.open(f, encoding='UTF-8') as f:\\n for line in f: \\n if len(line) > self.minSeq and len(line) < self.maxLen:\\n corpus.append(line.lstrip().rstrip().split(' '))\\n return corpus\",\n \"def load():\\n filepath = dirname(abspath(__file__))\\n##### EDIT THE FOLLOWING TO POINT TO DatasetName.csv #####\\n data = recfromtxt(open(filepath + '/spector.csv',\\\"rb\\\"), delimiter=\\\" \\\",\\n names=True, dtype=float, usecols=(1,2,3,4))\\n names = list(data.dtype.names)\\n endog = array(data[names[3]], dtype=float)\\n endog_name = names[3]\\n exog = column_stack(data[i] for i in names[:3]).astype(float)\\n exog_name = names[:3]\\n dataset = Dataset(data=data, names=names, endog=endog, exog=exog,\\n endog_name = endog_name, exog_name=exog_name)\\n return dataset\",\n \"def load_blacklist(experiment):\\n blacklist = np.loadtxt('../Slip_Property_Data/%s_blacklist.txt'%experiment)\\n return blacklist\",\n \"def load_blacklist(experiment):\\n blacklist = np.loadtxt('../Slip_Property_Data/%s_blacklist.txt'%experiment)\\n return blacklist\",\n \"def load_datapair(self, ds):\\n raise NotImplementedError(\\\"Define this in your derived checker class\\\")\",\n \"def load_data():\\n # Dictionary mapping image names to labels\\n image_name_to_label = dict()\\n\\n # Store labels associated with image names\\n notifier.send(\\\" Reading metadata...\\\")\\n with open(\\\"data/metadata.csv\\\") as file: # Original dataset\\n # Use images for normal, virus (unknown type), COVID-19, SARS\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n if row[\\\"Label\\\"].lower() == \\\"normal\\\":\\n label = 2\\n elif row[\\\"Label_2_Virus_category\\\"].lower() == \\\"covid-19\\\":\\n label = 0\\n elif row[\\\"Label_1_Virus_category\\\"].lower() == \\\"virus\\\":\\n label = 1\\n else:\\n continue\\n image_name_to_label[row[\\\"X_ray_image_name\\\"]] = label\\n with open(\\\"data/metadata2.csv\\\") as file: # GitHub dataset\\n # Use COVID-19, SARS\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n if row[\\\"filename\\\"] in image_name_to_label: # Image already added\\n continue\\n if \\\"covid-19\\\" in row[\\\"finding\\\"].lower():\\n label = 0\\n elif row[\\\"finding\\\"].lower() == \\\"sars\\\":\\n label = 1\\n else:\\n continue\\n image_name_to_label[row[\\\"filename\\\"]] = label\\n with open(\\\"data/metadata_COVID-19.csv\\\") as file: # Additional COVID-19 images\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n name = \\\"COVID-19/\\\" + row[\\\"FILE NAME\\\"] + \\\".\\\" + row[\\\"FORMAT\\\"]\\n image_name_to_label[name.lower().replace(\\\" \\\", \\\"\\\")] = 0\\n with open(\\\"data/metadata_ViralPneumonia.csv\\\") as file: # Additional virus images\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n name = \\\"ViralPneumonia/\\\" + row[\\\"FILE NAME\\\"].replace(\\\"-\\\", \\\"(\\\") + \\\").\\\" + row[\\\"FORMAT\\\"]\\n image_name_to_label[name.lower().replace(\\\" \\\", \\\"\\\")] = 1\\n with open(\\\"data/metadata_Normal.csv\\\") as file: # Additional normal images\\n metadata_contents = csv.DictReader(file)\\n for row in metadata_contents:\\n name = \\\"Normal/\\\" + row[\\\"FILE NAME\\\"].replace(\\\"-\\\", \\\"(\\\") + \\\").\\\" + row[\\\"FORMAT\\\"]\\n image_name_to_label[name.lower().replace(\\\" \\\", \\\"\\\")] = 2\\n\\n notifier.send(\\\" Loading images...\\\")\\n images, labels = load_images(image_name_to_label)\\n\\n notifier.send(\\\" Splitting data...\\\")\\n return split_data(images, labels)\",\n \"def load_data():\\n # Load and preprocess data\\n sentences, labels = load_data_and_labels()\\n sentences_padded = pad_sentences(sentences)\\n vocabulary, vocabulary_inv = build_vocab(sentences_padded)\\n x, y = build_input_data(sentences_padded, labels, vocabulary)\\n return [x, y, vocabulary, vocabulary_inv]\",\n \"def load_data(self):\\n params = self.params\\n catg = params.data_category\\n langs = ['en', params.target_lang]\\n data = {lang: {splt: {} for splt in (['train', 'valid'] if lang == 'en' else ['test'])} for lang in langs}\\n clf_dataset_path = {\\n lang: {\\n splt: {\\n 'x': os.path.join(params.data_path, '%s_%s_%s_x.bpe.pth' % (splt, lang, catg)),\\n 'y': os.path.join(params.data_path, '%s_%s_%s_y.txt' % (splt, lang, catg)),\\n } for splt in (['train', 'valid'] if lang == 'en' else ['test'])\\n } for lang in langs\\n }\\n for splt in ['train', 'valid', 'test']:\\n for lang in langs:\\n if lang == 'en' and splt in ['train', 'valid'] or lang != 'en' and splt == 'test':\\n # load data and dictionary\\n data1 = load_binarized(clf_dataset_path[lang][splt]['x'], params)\\n data['dico'] = data.get('dico', data1['dico'])\\n # set dictionary parameters\\n set_dico_parameters(params, data, data1['dico'])\\n # create dataset\\n data[lang][splt]['x'] = Dataset(data1['sentences'], data1['positions'], params)\\n # load labels\\n with open(clf_dataset_path[lang][splt]['y'], 'r') as f:\\n labels = [int(l) for l in f]\\n data[lang][splt]['y'] = torch.LongTensor(labels)\\n assert len(data[lang][splt]['x']) == len(data[lang][splt]['y'])\\n\\n return data\",\n \"def load_muscle(preprocess=True, mean_cut=None):\\n\\n url = f'https://raw.githubusercontent.com/PengTao-HUST/GDNB/master/data/muscle.txt'\\n cache_dir = sys.modules['gdnb'].__path__[0] + '/data/'\\n\\n if not os.path.exists(cache_dir):\\n os.makedirs(cache_dir)\\n\\n data_file = os.path.basename(url)\\n full_path = cache_dir + data_file\\n\\n if not os.path.exists(full_path):\\n urlretrieve(url, cache_dir + data_file)\\n\\n if preprocess:\\n probes = []\\n names = []\\n exprs = []\\n with open(full_path, 'r') as f:\\n f.readline()\\n f.readline()\\n for line in f.readlines():\\n data = line.split('\\\\t')\\n probe = data[0]\\n name = data[1]\\n expr = np.array([np.log2(float(x)) for x in data[2:]])\\n probes.append(probe)\\n names.append(name)\\n exprs.append(expr)\\n probes = np.asarray(probes)\\n names = np.asarray(names)\\n exprs = np.asarray(exprs)\\n\\n use_index = []\\n for name in names:\\n if re.match('.*///.*', name) or not re.match('^[A-Z].*', name):\\n use_index.append(False)\\n else:\\n use_index.append(True)\\n\\n probes, names, exprs = [obj[use_index] for obj in [probes, names, exprs]]\\n\\n means = np.mean(exprs, axis=1)\\n if mean_cut is None:\\n mean_cut = 7\\n\\n cut_index = np.where(means > mean_cut)\\n probes_c, names_c, exprs_c = [obj[cut_index] for obj in [probes, names, exprs]]\\n exprs_c = np.apply_along_axis(normalize_by_mean, 1, exprs_c)\\n\\n exprs_split = np.array([exprs_c[:, 2 * i: 2 * i + 6] for i in range(25)])\\n return probes_c, names_c, exprs_split\\n else:\\n return full_path\",\n \"def load_dataset():\\n\\n train_dataset = h5py.File('datasets/train_catvnoncat.h5', \\\"r\\\")\\n train_set_x_orig = np.array(train_dataset[\\\"train_set_x\\\"][:]) # your train set features\\n train_set_y_orig = np.array(train_dataset[\\\"train_set_y\\\"][:]) # your train set labels\\n\\n test_dataset = h5py.File('datasets/test_catvnoncat.h5', \\\"r\\\")\\n test_set_x_orig = np.array(test_dataset[\\\"test_set_x\\\"][:]) # your test set features\\n test_set_y_orig = np.array(test_dataset[\\\"test_set_y\\\"][:]) # your test set labels\\n\\n classes = np.array(test_dataset[\\\"list_classes\\\"][:]) # the list of classes\\n \\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\\n \\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\",\n \"def load(self, source):\\n try:\\n inputdata = self.__inputmanager.read(source)\\n self.__suitables = self.__inputmanager.map(inputdata)\\n self.__data = inputdata\\n except ValueError as e:\\n print (\\\"Failed to load the dataset: %s\\\" % e)\\n raise\\n\\n self.__modules = self.import_suitable_visualizations(self.__suitables)\\n self.__has_datefields = self.__inputmanager.has_date_points()\\n # Converting the datakeys into strings.\\n self.__datakeys = [str(i) for i in list(self.__data[0].keys())]\\n return self.__suitables\",\n \"def load_dataset(\\n dataset: str\\n) -> Union[lmp.dataset.AnalogyDataset, lmp.dataset.LanguageModelDataset]:\\n # Type check.\\n if not isinstance(dataset, str):\\n raise TypeError('`dataset` must be an instance of `str`.')\\n\\n if dataset == 'news_collection_desc':\\n return _preprocess_news_collection(column='desc')\\n\\n if dataset == 'news_collection_title':\\n return _preprocess_news_collection(column='title')\\n\\n if dataset == 'wiki_train_tokens':\\n return _preprocess_wiki_tokens(split='train')\\n\\n if dataset == 'wiki_valid_tokens':\\n return _preprocess_wiki_tokens(split='valid')\\n\\n if dataset == 'wiki_test_tokens':\\n return _preprocess_wiki_tokens(split='test')\\n\\n if dataset == 'word_test_v1':\\n return _preprocess_word_test_v1()\\n\\n raise ValueError(\\n f'dataset `{dataset}` does not support.\\\\nSupported options:' +\\n ''.join(list(map(\\n lambda option: f'\\\\n\\\\t--dataset {option}',\\n [\\n 'news_collection_desc',\\n 'news_collection_title',\\n 'wiki_test_tokens',\\n 'wiki_train_tokens',\\n 'wiki_valid_tokens',\\n 'word_test_v1'\\n ]\\n )))\\n )\",\n \"def get_dataset(args):\\n\\n if args['experiment']['dataset'] == Dataset.mindsets:\\n xs, ys, cs = make_mindsets(mindset_sizes=args['dataset']['mindset_sizes'],\\n nb_questions=args['dataset']['nb_questions'],\\n nb_useless=args['dataset']['nb_useless'],\\n noise=args['dataset']['noise'],\\n seed=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys, cs=cs)\\n\\n if args['experiment']['dataset'] == Dataset.questionnaire_likert:\\n xs, ys, cs = make_likert_questionnaire(nb_samples=args['dataset']['nb_samples'],\\n nb_features=args['dataset']['nb_features'],\\n nb_mindsets=args['dataset']['nb_mindsets'],\\n centers=args['dataset']['centers'],\\n range_answers=args['dataset']['range_answers'],\\n seed=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys, cs=cs)\\n\\n if args['experiment']['dataset'] == Dataset.retinal:\\n xs, ys = load_RETINAL(root_path=args['root_dir'],\\n nb_bins=args['dataset']['nb_bins'],\\n max_idx=args['dataset']['max_idx'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.moons:\\n xs, ys = make_moons(n_samples=args['dataset']['n_samples'],\\n noise=args['dataset']['noise'],\\n random_state=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.breast_cancer_wisconsin:\\n xs, ys = load_CANCER(args['dataset']['nb_bins'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.SBM:\\n A, ys, G = load_SBM(block_sizes=args['dataset']['block_sizes'],\\n p_in=args['dataset']['p'],\\n p_out=args['dataset']['q'],\\n seed=args['experiment']['seed'])\\n\\n return Data(ys=ys, A=A, G=G)\\n\\n if args['experiment']['dataset'] == Dataset.gaussian_mixture:\\n xs, ys = make_blobs(n_samples=args['dataset']['blob_sizes'],\\n centers=args['dataset']['blob_centers'],\\n n_features=args['dataset']['blob_centers'],\\n cluster_std=args['dataset']['blob_variances'],\\n random_state=args['experiment']['seed'])\\n\\n return Data(xs=xs, ys=ys)\\n\\n if args['experiment']['dataset'] == Dataset.LFR:\\n A, ys, G = load_LFR(nb_nodes=args['dataset']['nb_nodes'],\\n tau1=args['dataset']['tau1'],\\n tau2=args['dataset']['tau2'],\\n mu=args['dataset']['mu'],\\n average_degree=args['dataset']['average_degree'],\\n min_community=args['dataset']['min_community'],\\n seed=args['experiment']['seed'])\\n\\n return Data(ys=ys, A=A, G=G)\\n\\n if args['experiment']['dataset'] == Dataset.wave:\\n df = pd.read_csv('datasets/waveform.csv')\\n xs = df[df.columns[:-1]].to_numpy()\\n ys = df[df.columns[-1]].to_numpy()\\n\\n return Data(xs=xs, ys=ys)\\n\\n raise ValueError('Wrong name for a dataset')\",\n \"def load_data(self):\",\n \"def load_data(data_fn,variables_fn,URL,VariableSet,Drop_extra=True):\\r\\n \\r\\n #If the data file exists locally, load it using pandas\\r\\n breakhere=1\\r\\n try: df = pd.read_csv(data_fn)\\r\\n except: \\r\\n #If the data file does not exist locally, download and save locally, then open\\r\\n print('Downloading data file (~430mb)')\\r\\n urllib.request.urlretrieve(URL,data_fn)\\r\\n print('Download Complete')\\r\\n df = pd.read_csv(data_fn)\\r\\n \\r\\n print('\\\\n************\\\\nNOTE RE: MIXED TYPE WARNING - These variables contain:')\\r\\n print(' 294 - HQ ID of person providing most of the information for this form')\\r\\n print(' 295 - HQ ID of 1st Other providing information for this form')\\r\\n print(' 701 - HF2 Cross wave ID (xwaveid) - 0001')\\r\\n print(' 702 - HF2 Cross wave ID (xwaveid) - 0002')\\r\\n print('These variables are not used in this project so the mixed type warning can be ignored\\\\n************')\\r\\n \\r\\n #Read the variables descriptor file\\r\\n variables = pd.read_csv(variables_fn)\\r\\n \\r\\n #extract the name of the response variable\\r\\n responseVar = variables['Variable'][variables['Response']=='y'].values[0]\\r\\n \\r\\n if Drop_extra:\\r\\n #Store the current number of recores\\r\\n NumRecords = df.shape[0]\\r\\n #remove entries with negative response variables (non-responding person, N/A, not asked, etc)\\r\\n DataSubset = pd.DataFrame(df[df[responseVar]>-1])\\r\\n #Notify the user how of how many records were dropped\\r\\n print('\\\\n{} records dropped due to lack of response variable (non-responding person, N/A, etc)'.format(NumRecords-DataSubset.shape[0]))\\r\\n \\r\\n #Extract the variable names for the variable set being analyzed\\r\\n KeepVars = variables['Variable'][variables[VariableSet]=='y']\\r\\n \\r\\n #Keep only the variables in the variable set\\r\\n DataSubset = DataSubset[KeepVars]\\r\\n \\r\\n else:\\r\\n #Return all variables and records\\r\\n DataSubset = df\\r\\n \\r\\n return DataSubset,variables,responseVar\",\n \"def LoadTroikaDataset():\\n data_dir = \\\"./datasets/troika/training_data\\\"\\n data_fls = sorted(glob.glob(data_dir + \\\"/DATA_*.mat\\\"))\\n ref_fls = sorted(glob.glob(data_dir + \\\"/REF_*.mat\\\"))\\n return data_fls, ref_fls\",\n \"def load(name):\\n if name in datasets:\\n\\n return pd.read_csv(os.path.join(datasets_path, \\\"%s.csv\\\" % name))\\n else:\\n raise ValueError(\\\"Dataset not found!\\\")\",\n \"def load_data():\\n with open('../data/dataset.txt', 'r') as data_file:\\n return data_file.read().split('\\\\n')\",\n \"def get_data_loaders():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_2sentences_finalgenerated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"][-(2*2+5):]\\n \\n #history_complete.append(history)\\n if len(persona) == 4:\\n if len(history) > (len(persona)+3):\\n history_chatbot = history[1::2]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss_2(persona, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def prepare(self):\\n\\n # step 0: load only when not loaded yet\\n if TRAINING in self.data \\\\\\n and VALIDATION in self.data:\\n return\\n\\n # step 1: load the file names\\n file_list = sorted(glob.glob(self.location+\\\"*.mhd\\\"))\\n # count the number of data points\\n\\n # make a stratified validation set\\n # note, the seed decides the validation set, but it is deterministic in the names\\n random.seed(317070)\\n patient_names = [self.patient_name_from_file_name(f) for f in file_list]\\n validation_patients = random.sample(patient_names, int(VALIDATION_SET_SIZE*len(patient_names)))\\n\\n # make the static data empty\\n for s in self.datasets:\\n self.data[s] = []\\n self.labels[s] = []\\n self.names[s] = []\\n\\n # load the filenames and put into the right dataset\\n labels_as_dict = defaultdict(list)\\n\\n with open(paths.LUNA_LABELS_PATH, 'rb') as csvfile:\\n reader = csv.reader(csvfile, delimiter=',', quotechar='|')\\n next(reader) # skip the header\\n for row in reader:\\n label = (float(row[1]), float(row[2]), float(row[3]), float(row[4]))\\n labels_as_dict[str(row[0])].append(label)\\n\\n for patient_file in file_list:\\n patient_name = self.patient_name_from_file_name(patient_file)\\n\\n if patient_name in validation_patients:\\n s = VALIDATION\\n else:\\n s = TRAINING\\n label = labels_as_dict[str(patient_name)]\\n if self.only_positive and not label:\\n continue\\n self.data[s].append(patient_file)\\n \\n if self.pick_nodule:\\n self.labels[s].append([random.choice(label)]) \\n else:\\n self.labels[s].append(label)\\n \\n \\n self.names[s].append(patient_name)\\n\\n # give every patient a unique number\\n last_index = -1\\n for s in self.datasets:\\n self.indices[s] = range(last_index+1,last_index+1+len(self.data[s]))\\n if len(self.indices[s]) > 0:\\n last_index = self.indices[s][-1]\\n print s, len(self.indices[s]), \\\"samples\\\"\",\n \"def load_tamper(self, dataset_dir, subset):\\n # Add classes. We have one class.\\n # Naming the dataset nucleus, and the class nucleus\\n self.add_class(\\\"tampers\\\", 1, \\\"tampers\\\")\\n\\n # Which subset?\\n # \\\"val\\\": use hard-coded list above\\n # \\\"train\\\": use data from stage1_train minus the hard-coded list above\\n # else: use the data from the specified sub-directory\\n # assert subset in [\\\"train\\\", \\\"val\\\", \\\"stage1_train\\\", \\\"stage1_test\\\", \\\"stage2_test\\\"]\\n # subset_dir = \\\"stage1_train\\\" if subset in [\\\"train\\\", \\\"val\\\"] else subset\\n dataset_dir = os.path.join(dataset_dir, subset, 'images')\\n if subset == \\\"val\\\" or subset == \\\"test\\\":\\n image_ids = next(os.walk(dataset_dir))[2]\\n else:\\n # Get image ids from directory names\\n image_ids = next(os.walk(dataset_dir))[2]\\n \\n\\n # dircopy_move = '/data/twj/copy-move/data_zoo/dataset/images/train'\\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\\n\\n # dirnew_splicing = '/data/tamper'\\n # image_ids_new_splicing = next(os.walk(os.path.join(dirnew_splicing, 'images')))[2]\\n\\n # dircopy_move = '/home/as/deeplab/wpmrcnn/ca2new/test'\\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\\n\\n \\n # dircopy_move = '/data/gy/ca2att/train3'\\n # image_ids_copy_move = next(os.walk(os.path.join(dircopy_move, 'images')))[2]\\n\\n # # # dirtxt_sp = '/data/gy/tamperpre/train'\\n # # # image_ids_txt_sp = next(os.walk(os.path.join(dirtxt_sp, 'images')))[2]\\n\\n # dirnew_sp = '/data/gy/c2newsp/train'\\n # image_ids_new_sp = next(os.walk(os.path.join(dirnew_sp, 'images')))[2]\\n\\n # Add images\\n for image_id in image_ids:\\n self.add_image(\\n \\\"tampers\\\",\\n image_id=image_id[:-4],\\n path=os.path.join(dataset_dir, image_id))\\n\\n # for image_id in image_ids_copy_move:\\n # self.add_image(\\n # \\\"tampers\\\",\\n # image_id=image_id[:-4],\\n # path=os.path.join(dircopy_move, 'images', image_id))\\n\\n # for image_id in image_ids_new_splicing:\\n # self.add_image(\\n # \\\"tampers\\\",\\n # image_id=image_id[:-4],\\n # path=os.path.join(dirnew_splicing, 'images', image_id))\\n\\n # # for image_id in image_ids_txt_sp:\\n # # self.add_image(\\n # # \\\"tampers\\\",\\n # # image_id=image_id[:-4],\\n # # path=os.path.join(dirtxt_sp, 'images', image_id))\\n\\n # for image_id in image_ids_new_sp:\\n # self.add_image(\\n # \\\"tampers\\\",\\n # image_id=image_id[:-4],\\n # path=os.path.join(dirnew_sp, 'images', image_id))\",\n \"def load_data():\\r\\n train_dataset = h5py.File('train_catvnoncat.h5', \\\"r\\\") # Change the directory as per your system\\r\\n train_set_x_orig = np.array(train_dataset[\\\"train_set_x\\\"][:]) # your train set features\\r\\n train_set_y_orig = np.array(train_dataset[\\\"train_set_y\\\"][:]) # your train set labels\\r\\n\\r\\n test_dataset = h5py.File('test_catvnoncat.h5', \\\"r\\\") # Change the directory as per your system\\r\\n test_set_x_orig = np.array(test_dataset[\\\"test_set_x\\\"][:]) # your test set features\\r\\n test_set_y_orig = np.array(test_dataset[\\\"test_set_y\\\"][:]) # your test set labels\\r\\n\\r\\n classes = np.array(test_dataset[\\\"list_classes\\\"][:]) # the list of classes\\r\\n \\r\\n train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))\\r\\n test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))\\r\\n \\r\\n return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes\",\n \"def load_ICA_data(subject, data_dir, file='post_ICA', preload=True):\\n\\tDS_dir = 'downsampled_128'\\n\\t#datadir='/Users/md42732/Desktop/data/EEG/MovieTrailers/Participants/%s/%s'%(subject, DS_dir)\\n\\tif file == 'post_ICA':\\n\\t\\tds = io.read_raw_fif('%s/%s/%s/%s_postICA_rejected.fif'%(data_dir, subject, DS_dir, subject), preload=True)\\n\\telse:\\n\\t\\tprint('No other file previously saved to load')\\n\\n\\treturn ds\",\n \"def load_data_realistic_ssl(dataset_name, data_path, label_map_path):\\n logging.info('Loading data from pickle at %s.', data_path)\\n train_set, validation_set, test_set = pickle.load(open(data_path, 'rb'))\\n train_inputs = train_set['images']\\n train_labels = train_set['labels']\\n val_inputs = validation_set['images']\\n val_labels = validation_set['labels']\\n test_inputs = test_set['images']\\n test_labels = test_set['labels']\\n # Load label map that specifies which trainining labeles are available.\\n train_indices = json.load(open(label_map_path, 'r'))\\n train_indices = [\\n int(key.encode('ascii', 'ignore')) for key in train_indices['values']\\n ]\\n train_indices = np.asarray(train_indices)\\n\\n # Select the loaded train indices, and make the rest unlabeled.\\n unlabeled_mask = np.ones((train_inputs.shape[0],), dtype=np.bool)\\n unlabeled_mask[train_indices] = False\\n unlabeled_inputs = train_inputs[unlabeled_mask]\\n unlabeled_labels = train_labels[unlabeled_mask]\\n train_inputs = train_inputs[train_indices]\\n train_labels = train_labels[train_indices]\\n\\n # Select a feature preprocessing function, depending on the dataset.\\n feature_preproc_fn = ((lambda image: image)\\n if dataset_name == 'cifar10' else convert_image)\\n\\n data = Dataset.build_from_splits(\\n name=dataset_name,\\n inputs_train=train_inputs,\\n labels_train=train_labels,\\n inputs_val=val_inputs,\\n labels_val=val_labels,\\n inputs_test=test_inputs,\\n labels_test=test_labels,\\n inputs_unlabeled=unlabeled_inputs,\\n labels_unlabeled=unlabeled_labels,\\n feature_preproc_fn=feature_preproc_fn)\\n return data\",\n \"def load_data():\\n\\n # Load data from categories\\n comp = fetch_20newsgroups(subset='all', categories=['comp.graphics', 'comp.sys.mac.hardware', 'comp.windows.x'], \\\\\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\\n science = fetch_20newsgroups(subset='all', categories=['sci.crypt', 'sci.electronics', 'sci.space'], \\\\\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\\n politics = fetch_20newsgroups(subset='all', categories=['talk.politics.guns', 'talk.politics.mideast'], \\\\\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\\n religion = fetch_20newsgroups(subset='all', categories=['alt.atheism', 'soc.religion.christian'], \\\\\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\\n recreation = fetch_20newsgroups(subset='all', categories=['rec.autos', 'rec.sport.baseball', 'rec.sport.hockey'], \\\\\\n shuffle=True, random_state=1, remove=('headers', 'footers', 'quotes'))\\n\\n # Print total number of documents\\n data_len = [len(comp.data), len(science.data), len(politics.data), len(recreation.data), len(religion.data)]\\n\\n # Subsample classes to create a balanced dataset\\n sub_k = min(data_len)\\n comp.data, comp.target = [list(t) for t in zip(*random.sample(list(zip(comp.data, comp.target)), sub_k))]\\n science.data, science.target = [list(t) for t in zip(*random.sample(list(zip(science.data, science.target)), sub_k))]\\n politics.data, politics.target = [list(t) for t in zip(*random.sample(list(zip(politics.data, politics.target)), sub_k))]\\n religion.data, religion.target = [list(t) for t in zip(*random.sample(list(zip(religion.data, religion.target)), sub_k))]\\n recreation.data, recreation.target = [list(t) for t in zip(*random.sample(list(zip(recreation.data, recreation.target)), sub_k))]\\n\\n # Subcategories labels\\n subcat_comp = np.array(comp.target)\\n subcat_scien = np.array(science.target) + len(comp.target_names)\\n subcat_polit = np.array(politics.target) + len(comp.target_names) + len(science.target_names)\\n subcat_rel = np.array(religion.target) + len(comp.target_names) + len(science.target_names) + len(politics.target_names)\\n subcat_rec = np.array(recreation.target) + len(comp.target_names) + len(science.target_names) + len(politics.target_names) + len(religion.target_names)\\n\\n # Assign labels to train data based on categories\\n y_comp = np.ones(len(comp.data))\\n y_scien = 2*np.ones(len(science.data))\\n y_polit = 3*np.ones(len(politics.data))\\n y_rel = 4*np.ones(len(religion.data))\\n y_rec = 5*np.ones(len(recreation.data))\\n labels = np.concatenate((y_comp,y_scien,y_polit,y_rel,y_rec), axis=None)\\n\\n # Computers\\n train_comp, test_comp, y_train_comp, y_test_comp, subcat_comp_train, subcat_comp_test = train_test_split(comp.data, y_comp, subcat_comp, test_size=0.2, random_state=42)\\n train_comp, val_comp, y_train_comp, y_val_comp, subcat_comp_train, subcat_comp_val = train_test_split(train_comp, y_train_comp, subcat_comp_train, test_size=0.25, random_state=42)\\n\\n # Sciences\\n train_scien, test_scien, y_train_scien, y_test_scien, subcat_scien_train, subcat_scien_test = train_test_split(science.data, y_scien, subcat_scien, test_size=0.2, random_state=42)\\n train_scien, val_scien, y_train_scien, y_val_scien, subcat_scien_train, subcat_scien_val = train_test_split(train_scien, y_train_scien, subcat_scien_train, test_size=0.25, random_state=42)\\n\\n # Politics\\n train_polit, test_polit, y_train_polit, y_test_polit, subcat_polit_train, subcat_polit_test = train_test_split(politics.data, y_polit, subcat_polit, test_size=0.2, random_state=42)\\n train_polit, val_polit, y_train_polit, y_val_polit, subcat_polit_train, subcat_polit_val = train_test_split(train_polit, y_train_polit, subcat_polit_train, test_size=0.25, random_state=42)\\n\\n # Religion\\n train_rel, test_rel, y_train_rel, y_test_rel, subcat_rel_train, subcat_rel_test = train_test_split(religion.data, y_rel, subcat_rel, test_size=0.2, random_state=42)\\n train_rel, val_rel, y_train_rel, y_val_rel, subcat_rel_train, subcat_rel_val = train_test_split(train_rel, y_train_rel, subcat_rel_train, test_size=0.25, random_state=42)\\n\\n # Recreation\\n train_rec, test_rec, y_train_rec, y_test_rec, subcat_rec_train, subcat_rec_test = train_test_split(recreation.data, y_rec, subcat_rec, test_size=0.2, random_state=42)\\n train_rec, val_rec, y_train_rec, y_val_rec, subcat_rec_train, subcat_rec_val = train_test_split(train_rec, y_train_rec, subcat_rec_train, test_size=0.25, random_state=42)\\n\\n # Corpus from all categories in train set\\n newsgroups_train = train_comp + train_scien + train_polit + train_rel + train_rec\\n #print(f\\\"Total number of documents in all categories in the train set is {len(newsgroups_train)}.\\\")\\n train_labels = np.concatenate((y_train_comp,y_train_scien,y_train_polit,y_train_rel,y_train_rec), axis=None)\\n #print(train_labels.shape)\\n train_subcat = np.concatenate((subcat_comp_train,subcat_scien_train,subcat_polit_train,subcat_rel_train,subcat_rec_train), axis=None)\\n #print(train_subcat.shape)\\n\\n # Corpus from all categories in test set\\n newsgroups_test = test_comp + test_scien + test_polit + test_rel + test_rec\\n test_labels = np.concatenate((y_test_comp,y_test_scien,y_test_polit,y_test_rel,y_test_rec), axis=None)\\n test_subcat = np.concatenate((subcat_comp_test,subcat_scien_test,subcat_polit_test,subcat_rel_test,subcat_rec_test), axis=None)\\n\\n # Corpus from all categories in validation set\\n newsgroups_val = val_comp + val_scien + val_polit + val_rel + val_rec\\n val_labels = np.concatenate((y_val_comp,y_val_scien,y_val_polit,y_val_rel,y_val_rec), axis=None)\\n val_subcat = np.concatenate((subcat_comp_val,subcat_scien_val,subcat_polit_val,subcat_rel_val,subcat_rec_val), axis=None)\\n\\n # Data Split\\n total = len(test_labels) + len(val_labels) + len(train_labels)\\n\\n return newsgroups_train, train_labels, newsgroups_test, test_labels, newsgroups_val, val_labels, train_subcat, test_subcat, val_subcat\",\n \"def preprocess(self, question_dir, unlabeled_set, training_set, vocab_size, max_example=100,\\n use_chars=True, only_test_run=False):\\n # Define files to be used\\n dataset_files = {\\\"training\\\": \\\"train-p\\\" + training_set,\\n \\\"validation\\\": \\\"dev-v1.1\\\",\\n \\\"test\\\": \\\"test-p0.1\\\"}\\n # Define vocabulary source file\\n vocab_filename = \\\"vocab_training\\\" + training_set + \\\"+\\\" + \\\\\\n \\\"unlabeled_\\\" + unlabeled_set + \\\".bin\\\"\\n vocab_f = os.path.join(question_dir, vocab_filename)\\n\\n # Generate or load dictionaries\\n raw_file_dir = '/scratch/s161027/ga_reader_data/ssqa'\\n word_dictionary, char_dictionary, num_entities = \\\\\\n self.make_dictionary(dataset_files, raw_file_dir, vocab_size,\\n vocab_file=vocab_f)\\n dictionary = (word_dictionary, char_dictionary)\\n\\n # Check for the existence of parsed data in binary files\\n # Load them if they exist. Otherwise generate and save new ones.\\n print(\\\"Preparing data...\\\")\\n\\n start_time = time.time()\\n loaded_dataset = []\\n for data_role in dataset_files.keys():\\n if data_role == \\\"training\\\":\\n path = os.path.join(question_dir, dataset_files[data_role])+\\\".bin\\\"\\n else:\\n path = os.path.join(question_dir, dataset_files[data_role]) + \\\\\\n \\\"_train\\\" + training_set + \\\".bin\\\"\\n\\n # Parse original json file and save results in binary, then load with pickle\\n if not os.path.exists(path):\\n print(\\\"Can't find binary data for {} set. Parsing raw data...\\\".format(data_role))\\n self.json_parser(raw_file_dir, dataset_files[data_role],\\n dictionary, training_set, use_chars)\\n\\n print(\\\"Loading binary data for {} set\\\".format(data_role))\\n infile = open(path, \\\"rb\\\")\\n # loaded_data = pickle.load(infile)\\n loaded_data = msgpack.unpack(infile)\\n\\n loaded_dataset.append(loaded_data)\\n\\n training, validation, test = loaded_dataset\\n unpack_time = time.time() - start_time\\n print(\\\"Unpacking took {}\\\".format(unpack_time))\\n\\n if only_test_run:\\n training = random.sample(training, max_example)\\n validation = random.sample(validation, max_example)\\n test = random.sample(test, max_example)\\n # training = training[0:max_example]\\n # validation = validation[0:max_example]\\n # test = test[0:max_example]\\n\\n data = Data(dictionary, num_entities, training, validation, test)\\n\\n # Message about bad samples being removed.\\n print(\\\"{} questions were removed due to bad formatting.\\\"\\n .format(self.num_removed_questions))\\n\\n return data\",\n \"def load_davis_dataset():\\n trainn_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'folds', 'train_fold_setting1.txt')))\\n train_fold = []\\n for e in zip(*trainn_fold):\\n for ee in e:\\n train_fold.append(ee)\\n #train_fold = [ee for e in trainn_fold for ee in e]\\n test_fold = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'folds', 'test_fold_setting1.txt')))\\n ligands = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'ligands_can.txt')),\\n object_pairs_hook=OrderedDict)\\n proteins = json.load(\\n open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'proteins.txt')),\\n object_pairs_hook=OrderedDict)\\n \\n affinity = pickle.load(open(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'Y'), \\n 'rb'), encoding='latin1')\\n smiles_lst, protein_lst = [], []\\n\\n for k in ligands.keys():\\n smiles = ligands[k]\\n smiles_lst.append(smiles)\\n for k in proteins.keys():\\n protein_lst.append(proteins[k])\\n\\n affinity = [-np.log10(y / 1e9) for y in affinity]\\n affinity = np.asarray(affinity)\\n \\n os.makedirs(os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'processed'), exist_ok=True)\\n train_test_dataset = []\\n for split in ['train', 'test']:\\n split_dir = os.path.join('dataset', 'regression', 'benchmark', 'DAVIStest', 'processed', split)\\n os.makedirs(split_dir, exist_ok=True)\\n fold = train_fold if split == 'train' else test_fold\\n rows, cols = np.where(np.isnan(affinity) == False)\\n rows, cols = rows[fold], cols[fold]\\n \\n data_lst = [[] for _ in range(1)]\\n for idx in range(len(rows)):\\n data = {}\\n data['smiles'] = smiles_lst[rows[idx]]\\n data['protein'] = protein_lst[cols[idx]]\\n af = affinity[rows[idx], cols[idx]]\\n data['aff'] = af\\n\\n data_lst[idx % 1].append(data)\\n random.shuffle(data_lst)\\n train_test_dataset.append(data_lst[0])\\n return train_test_dataset\",\n \"def load_synthetic_data():\\n\\n pickle_object = FM().data_file \\n\\n with pickle_object.open('rb') as data_file: \\n return pickle.load(data_file)\",\n \"def do_load(self):\\n global g_state\\n global g_list_of_classifier\\n\\n id_client = json.loads(request.data.decode('UTF-8'))['id']\\n self._reset()\\n if os.path.exists(CLASSIFIER_PATH + str(id_client) + '.cls'):\\n g_list_of_classifier.load_from_file(CLASSIFIER_PATH + \\n str(id_client) + '.cls')\\n else:\\n g_list_of_classifier = init_classifier()\\n return ''\",\n \"def datasets(self):\\n return [Dataset.ENSEMBL]\",\n \"def load_data():\\n dictionary = corpora.Dictionary.load(app.config['DICTIONARY'])\\n matrix = similarities.MatrixSimilarity.load(app.config['MATRIX'])\\n model = models.LsiModel.load(app.config['MODEL'])\\n df = pd.read_pickle(app.config['DATA_FRAME'])\\n return Data(matrix=matrix, model=model, dictionary=dictionary, data_frame=df)\",\n \"def GetDataset():\\n x_train = []\\n x_test = []\\n y_train = []\\n y_test = []\\n\\n classes1 = set()\\n classes2 = set()\\n for f in GetInputFiles():\\n class1, class2, fold, fname = f.split('\\\\\\\\')[-4:]\\n classes1.add(class1)\\n classes2.add(class2)\\n class1 = class1.split('_')[0]\\n class2 = class2.split('_')[0]\\n\\n x = ReadAndTokenize(f)\\n y = [int(class1 == 'positive'), int(class2 == 'truthful')]\\n if fold == 'fold4':\\n x_test.append(x)\\n y_test.append(y)\\n else:\\n x_train.append(x)\\n y_train.append(y)\\n\\n ### Make numpy arrays.\\n x_test = MakeDesignMatrix(x_test)\\n x_train = MakeDesignMatrix(x_train)\\n y_test = numpy.array(y_test, dtype='float32')\\n y_train = numpy.array(y_train, dtype='float32')\\n\\n dataset = (x_train, y_train, x_test, y_test)\\n with open('dataset.pkl', 'wb') as fout:\\n pickle.dump(dataset, fout)\\n return dataset\",\n \"def gen_data(force=False):\\n if force or (not os.path.isfile(DATA_FILE)):\\n domains, labels = gen_malicious(10000)\\n\\n # Get equal number of benign/malicious\\n domains += get_alexa(len(domains))\\n labels += ['benign']*len(domains)\\n\\n pickle.dump(zip(labels, domains), open(DATA_FILE, 'w'))\",\n \"def learnDataset(self, data_loader):\\n\\n print(\\\"learning dataset\\\")\\n # we have 127940 sentences in total\\n count = 0\\n for sample in data_loader:\\n input_sentence = sample[\\\"input\\\"][0]\\n target_sentence = sample[\\\"target\\\"][0]\\n\\n # NOTE: target_word & input_word are actually indecies of words, instead of word strings\\n # NOTE: the first word has index 1\\n first_target = int(target_sentence[1])\\n first_input = int(input_sentence[1])\\n\\n self.emiss_factors[0][(first_input, first_target)] += 1\\n\\n prev_target = first_target\\n for word_idx in range(2, 16):\\n # note that word_idx is 0 is always <BOS>\\n target_word = int(target_sentence[word_idx])\\n input_word = int(input_sentence[word_idx])\\n\\n self.emiss_factors[word_idx - 1][(input_word, target_word)] += 1\\n self.trans_factors[word_idx - 2][(prev_target, target_word)] += 1\\n prev_target = target_word\\n\\n print(\\\"{}/127940\\\".format(count), end = \\\"\\\\r\\\")\\n count += 1\\n print(\\\"127940/127940\\\")\\n\\n # all data updated, no need to do any insertion\\n for i in range(15):\\n self.emiss_factors[i].fixed()\\n for i in range(14):\\n self.trans_factors[i].fixed()\",\n \"def LoadBatch(filename):\",\n \"def load_nuclei(self, dataset_dir, subset):\\n # Add classes. We have one class.\\n # Naming the dataset nucleus, and the class nucleus\\n self.add_class(self.dataset_name, 1, 'nucleus')\\n\\n # Which subset?\\n # \\\"val\\\": use hard-coded list above\\n # \\\"train\\\": use data from stage1_train minus the hard-coded list above\\n # else: use the data from the specified sub-directory\\n assert subset in [\\\"train\\\", \\\"val\\\", \\\"stage1_train\\\",\\n \\\"stage1_test\\\", \\\"stage2_test\\\"]\\n subset_dir = \\\"stage1_train\\\" if subset in [\\\"train\\\", \\\"val\\\"] else subset\\n dataset_dir = os.path.join(dataset_dir, subset_dir)\\n if subset == \\\"val\\\":\\n image_ids = NucleusDatasetHandler.VAL_IMAGE_IDS\\n else:\\n # Get image ids from directory names\\n image_ids = next(os.walk(dataset_dir))[1]\\n if subset == \\\"train\\\":\\n image_ids = list(set(image_ids) -\\n set(NucleusDatasetHandler.VAL_IMAGE_IDS))\\n\\n # Add images\\n for image_id in image_ids:\\n image_name = f\\\"images/{image_id}.png\\\"\\n self.add_image(\\n self.dataset_name,\\n image_id=image_id,\\n path=os.path.join(dataset_dir, image_id, image_name)\\n )\",\n \"def _load(self, dataset):\\n raise NotImplementedError('Loader {} does not support loading datasets.'.format(self.type()))\",\n \"def load_label_data(label_data_file):\\n pos_site_script_list = []\\n with open(label_data_file, 'r') as f:\\n for eachline in f:\\n one_site = json.loads(eachline.rstrip())\\n site_url = list(one_site.keys())[0]\\n script_list = list(one_site.values())[0]\\n if len(script_list) > 0:\\n for eachscript_dict in script_list:\\n script_url = list(eachscript_dict.keys())[0]\\n fp_prop_list = list(eachscript_dict.values())[0]\\n if len(fp_prop_list) > 0:\\n pos_site_script_list.append((site_url, script_url))\\n\\n return pos_site_script_list\",\n \"def get_data_loaders_4sentence():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_1generated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"]\\n #history_complete.append(history)\\n if len(history_splitted) > (len(persona)-1):\\n history_chatbot = history[1::2]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss(persona_selected, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def __call__(self):\\n\\n dataset = TextOnlyCocoAnnotation()\\n\\n with open(self.path) as read_file:\\n\\n json_loaded = json.load(read_file)\\n\\n for i, value in tqdm(json_loaded['imgs'].items()):\\n image_path = os.path.join(os.path.dirname(self.path), 'train2014',\\n value['file_name'])\\n dataset_type = value['set']\\n\\n if dataset_type not in self.sets:\\n print(dataset_type)\\n continue\\n\\n for annotation_id in json_loaded['imgToAnns'][i]:\\n annotation_value = json_loaded['anns'][str(annotation_id)]\\n word_annotation = self.parse_annotation_instance(annotation_value)\\n dataset.add_bbox(image_path, imagesize.get(image_path), word_annotation)\\n\\n return dataset\",\n \"def load_and_sanitize (data_file):\\n data = pd.read_csv(data_file, encoding=\\\"latin-1\\\")\\n data = data.drop(columns=['Unnamed: 2', 'Unnamed: 3', 'Unnamed: 4'])\\n data = data.rename(columns={\\\"v1\\\": \\\"class\\\", \\\"v2\\\": \\\"text\\\"})\\n return data\",\n \"def load_dataset(self, problem_name=\\\"\\\", split=\\\"train\\\"):\\n\\n orm = self.__orm\\n username = \\\"admin\\\" # should be unused (unless submit new feature to db)\\n\\n with orm.session_scope() as session:\\n if not problem_name:\\n problem_name = session.query(Problem.name)\\\\\\n .filter(Problem.name != \\\"demo\\\").scalar()\\n problem_id = session.query(Problem.id)\\\\\\n .filter(Problem.name == problem_name).scalar()\\n\\n data_dir = os.path.join(\\\"/data\\\", split)\\n dataset, entities_featurized, target = load_dataset_from_dir(\\n session, data_dir, problem_name)\\n\\n suffix = \\\"_\\\" + split\\n\\n return problem_name, dataset, entities_featurized, target\",\n \"def get_data_loaders_3sentences():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_3generated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"][-(2*2+3):]\\n #history_complete.append(history)\\n if len(history) > 6:\\n history_chatbot = history[1::2]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss_2(persona_selected, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def importScript():\\n crosswalkFile = 'mayaToNuke.info'\\n if os.path.exists(crosswalkFile):\\n fileInfo = open(crosswalkFile, 'r')\\n text = fileInfo.readlines()\\n dic = eval(text[-1])\\n nkFile = dic.get('file')\\n if os.path.exists(nkFile):\\n print 'importing: '+nkFile\\n nuke.nodePaste(nkFile)\\n else:\\n print 'nuke script not found...'\",\n \"def load_data():\\r\\n train = convert_corpus_to_lists(ConllCorpusReader('CoNLL-2003', 'train.txt', ['words', 'pos', 'ignore', 'chunk']))\\r\\n val = convert_corpus_to_lists(ConllCorpusReader('CoNLL-2003', 'valid.txt', ['words', 'pos', 'ignore', 'chunk'])) # testa will be our val set\\r\\n test = convert_corpus_to_lists(ConllCorpusReader('CoNLL-2003', 'test.txt', ['words', 'pos', 'ignore', 'chunk']))\\r\\n\\r\\n return train, val, test\",\n \"def mnist_load_data(filename):\\n if os.path.isfile(filename):\\n mnist_file = open(filename, 'rb')\\n train_set, valid_set, test_set = pickle.load(mnist_file)\\n return train_set, valid_set, test_set\\n else:\\n print('Failed to find data file %s' % (filename))\\n return None\",\n \"def load_preprocessed_dataset(dest = \\\"./Datasets/preprocessed_IsophonicsDataset.ds\\\") -> tuple:\\n with lzma.open(dest, \\\"rb\\\") as dataset_file:\\n dataset = pickle.load(dataset_file)\\n\\n print(\\\"[INFO] The Preprocessed Isophonics Dataset was loaded successfully.\\\")\\n return dataset\",\n \"def load_training_data(s3: str = \\\"s3://epam-hack4med-dataset\\\") -> pd.DataFrame:\\n # Load labels\\n df_labels = pd.read_csv(f\\\"{s3}/CRACoV-ETYKIETY.csv\\\")\\n df_labels[id_cols] = df_labels[id_cols].astype(int)\\n df_labels = df_labels.set_index(id_cols)\\n labels = df_labels[[basic_target]]\\n idx = labels.index\\n\\n # Load hospital admission file (PRZYJECIE)\\n df_admission = pd.read_csv(f\\\"{s3}/CRACoV-PRZYJECIE.csv\\\")\\n binary_adm_vars = [x for x in basic_adm_vars if df_admission[x].isin([\\\"Tak\\\", \\\"Nie\\\"]).any()]\\n other_adm_vars = [x for x in basic_adm_vars if x not in binary_adm_vars]\\n adm = df_admission.copy()\\n adm = adm[id_cols + binary_adm_vars + other_adm_vars]\\n adm = adm.set_index(id_cols).reindex(idx)\\n \\n # Load biochem analyses\\n biochem_raw = pd.read_csv(f\\\"{s3}/CRACoV-BIOCHEMIA.csv\\\", parse_dates=['DATA_WYK']).sort_values('DATA_WYK')\\n biochem = (\\n biochem_raw.loc[biochem_raw.KOD.isin(basic_bio_codes)]\\n .pivot_table(index=['LP.', 'ID_LAB'], columns='KOD', values='WYNIK', aggfunc='first')\\n .reindex(idx)\\n )\\n # Merge it all together\\n Xy_raw = pd.concat([labels, adm, biochem], axis='columns')\\n return Xy_raw\",\n \"def load_raw_text():\\n if not os.path.exists( os.path.join( DATA_HOME, RAW_TEXT_FILE ) ) or \\\\\\n not os.path.exists( os.path.join( DATA_HOME, LABELS_FILE ) ):\\n print( 'no prior files found. staring from scratch' )\\n rev, rat = parse_json( os.path.join( DATA_HOME, JSON_FILE ) )\\n y = np.array( rat )\\n print( 'saving data to files' )\\n pickle.dump( rev , open( os.path.join( DATA_HOME, RAW_TEXT_FILE ), 'wb' ) )\\n pickle.dump( y , open( os.path.join( DATA_HOME, LABELS_FILE ), 'wb' ) )\\n else:\\n print( 'found raw text and labes. loading...' )\\n rev = pickle.load( open( os.path.join( DATA_HOME, RAW_TEXT_FILE ), 'rb' ) )\\n y = pickle.load( open( os.path.join( DATA_HOME, LABELS_FILE ), 'rb' ) )\\n print( 'done' )\\n \\n return rev, y\",\n \"def load_domain_split_dataset(self, data_dir, logger=None):\\n current_dir = Path()\\n dir_path = current_dir / \\\"data\\\" / \\\"break_data\\\" / \\\"preprocessed\\\"\\n file_name = \\\"dataset_preprocessed_domain_split.pkl\\\"\\n if not (dir_path / file_name).is_file():\\n if logger:\\n logger.info('Creating domain split dataset...')\\n text_domain_dataset_prefixes = ('COMQA', 'CWQ', 'DROP', 'HOTP')\\n image_domain_dataset_prefixes = ('CLEVR', 'NLVR2')\\n DB_domain_dataset_prefixes = ('ACADEMIC', 'ATIS', 'GEO', 'SPIDER')\\n image_plus_DB = image_domain_dataset_prefixes + DB_domain_dataset_prefixes\\n train_filtererd = pd.DataFrame()\\n validation_filtererd = pd.DataFrame()\\n test_filtererd = pd.DataFrame()\\n\\n for i, example in enumerate(self.dataset_logical['train']):\\n if example['question_id'].startswith(text_domain_dataset_prefixes):\\n train_filtererd = train_filtererd.append(example, ignore_index=True)\\n for i, example in enumerate(self.dataset_logical['validation']):\\n if example['question_id'].startswith(image_plus_DB):\\n validation_filtererd = validation_filtererd.append(example, ignore_index=True)\\n for i, example in enumerate(self.dataset_logical['test']):\\n if example['question_id'].startswith(image_plus_DB):\\n test_filtererd = test_filtererd.append(example, ignore_index=True)\\n\\n # TODO delete this?\\n # train_dataset = self.dataset_logical['train'].filter(\\n # lambda example: example['question_id'].startswith(text_domain_dataset_prefixes))\\n # validation_dataset = self.dataset_logical['validation'].filter(\\n # lambda example: example['question_id'].startswith(image_plus_DB))\\n # test_dataset = self.dataset_logical['test'].filter(\\n # lambda example: example['question_id'].startswith(image_plus_DB))\\n # train_filtererd_ds = Dataset.from_pandas(train_filtererd)\\n to_save = {'train': Dataset.from_pandas(train_filtererd),\\n 'validation': Dataset.from_pandas(validation_filtererd),\\n 'test': Dataset.from_pandas(test_filtererd)}\\n save_obj(dir_path, to_save, file_name)\\n\\n dataset = load_obj(dir_path, file_name)\\n return dataset\",\n \"def _load_passes():\\n filepath = os.path.join(os.getcwd(), os.path.dirname(__file__), PASSES_TXT)\\n f = open(filepath, 'r')\\n passes = f.read()\\n f.close()\\n return passes.strip().split('\\\\n')\",\n \"def load_dataset(file_path):\\n return Dataset.load(file_path)\",\n \"def load_data(data_path=DATA_PATH):\\n with open (os.path.join(DATA_PATH, \\\"imdb_extrait.pkl\\\"),\\\"rb\\\") as file:\\n \\n [data , id2titles , fields ]= pk.load(file)\\n \\n \\n datax = data [: ,:33]\\n datay = np.array([1 if x [33] >6.5 else -1 for x in data ])\\n \\n return datax, datay, id2titles, fields\",\n \"def load_dataset(train_path, test_path, tokenizer):\\n train_dataset = TextDataset(\\n tokenizer=tokenizer,\\n file_path=train_path,\\n block_size=128)\\n\\n test_dataset = TextDataset(\\n tokenizer=tokenizer,\\n file_path=test_path,\\n block_size=128)\\n\\n data_collator = DataCollatorForLanguageModeling(\\n tokenizer=tokenizer, mlm=False,\\n )\\n return train_dataset, test_dataset, data_collator\",\n \"def get_data_loaders_1sentence():\\n dataset_path = \\\"\\\"\\n dataset_cache = None\\n personachat = get_dataset(dataset_path, dataset_cache)\\n\\n tokenizer_selected = OpenAIGPTTokenizer.from_pretrained('openai-gpt')\\n logger.info(\\\"Build inputs and labels\\\")\\n datasets = {\\\"train\\\": defaultdict(list), \\\"valid\\\": defaultdict(list)}\\n personality = []\\n history_complete = []\\n count_persona = 0\\n with open('data_faiss_pegasus_1_sentence_final_generated.pkl', 'rb') as f:\\n persona_selected_list = pickle.load(f)\\n for dataset_name, dataset in personachat.items():\\n num_candidates = len(dataset[0][\\\"utterances\\\"][0][\\\"candidates\\\"])\\n if num_candidates > 0 and dataset_name == 'train':\\n num_candidates = min(1, num_candidates)\\n for dialog in dataset:\\n persona = dialog[\\\"persona_info\\\"].copy()\\n #datasets[personality].append(persona)\\n count_history = 0\\n for utterance in dialog[\\\"utterances\\\"]:\\n count_history = count_history + 1\\n history = utterance[\\\"history\\\"][-(2*2+1):]\\n #history_complete.append(history)\\n if len(history) > 3:\\n history_chatbot = history[1]\\n persona_selected = persona_selected_list[count_persona]\\n instance = build_input_from_segments_faiss(persona_selected, history_chatbot) \\n for input_name, input_array in instance.items():\\n datasets[dataset_name][input_name].append(input_array)\\n count_persona = count_persona + 1\\n return datasets\",\n \"def load_data_clean(source='local'):\\n\\n train_bl, test_bl = load_data_raw(source)\\n\\n train = train_bl.copy()\\n train = encode_dtypes(train)\\n train = impute_missing(train)\\n train = clean_data(train)\\n\\n test = test_bl.copy()\\n test = encode_dtypes(test)\\n test = impute_missing(test)\\n test = clean_data(test)\\n\\n return train, test\",\n \"def load_blogpan(path, subset=\\\"all\\\", shuffle=True, rnd=2356, vct=CountVectorizer(), fix_k=None, min_size=None, raw=False, percent=.5):\\n PAN13_HOME = \\\"C:/Users/mramire8/Documents/Datasets/textclassification/raw data/author-profiling-gender/gender-profiling/blogs/blogs\\\"\\n\\n data = bunch.Bunch()\\n\\n if subset in ('train', 'test'):\\n # data[subset] = load_files(\\\"{0}/{1}\\\".format(AVI_HOME, subset), encoding=\\\"latin1\\\", load_content=True,\\n # random_state=rnd)\\n raise Exception(\\\"We are not ready for train test aviation data yet\\\")\\n elif subset == \\\"all\\\":\\n data = load_files(PAN13_HOME, encoding=\\\"latin1\\\", load_content=True,\\n random_state=rnd)\\n # parser = XMLParser(encoding=\\\"latin-1\\\", recover=True)\\n parser = etree.XMLParser(recover=True)\\n data.data = [clean_xml_pan(text, parser=parser) for text in data.data]\\n # data[\\\"test\\\"] = load_files(\\\"{0}/{1}\\\".format(AVI_HOME, \\\"test\\\"), encoding=\\\"latin1\\\", load_content=True,\\n # random_state=rnd)\\n else:\\n raise ValueError(\\n \\\"subset can only be 'train', 'test' or 'all', got '%s'\\\" % subset)\\n\\n # train_x, test_x, train_y, test_y = train_test_split(data.data, data.target, test_size=0.25,\\n # random_state=rnd)\\n\\n indices = ShuffleSplit(len(data.data), n_iter=1, test_size=percent, random_state=rnd)\\n for train_ind, test_ind in indices:\\n\\n data = bunch.Bunch(train=bunch.Bunch(data=[data.data[i] for i in train_ind], target=data.target[train_ind]),\\n test=bunch.Bunch(data=[data.data[i] for i in test_ind], target=data.target[test_ind]))\\n # if shuffle:\\n # random_state = np.random.RandomState(rnd)\\n # indices = np.arange(data.train.target.shape[0])\\n # random_state.shuffle(indices)\\n # data.train.filenames = data.train.filenames[indices]\\n # data.train.target = data.train.target[indices]\\n # # Use an object array to shuffle: avoids memory copy\\n # data_lst = np.array(data.train.data, dtype=object)\\n # data_lst = data_lst[indices]\\n # data.train.data = data_lst.tolist()\\n\\n if not raw:\\n data = process_data(data, fix_k, min_size, vct)\\n\\n return data\",\n \"def process_mlm_dataset(self, set_type):\\n if not os.path.exists(os.path.join(self.dataset_dir, f'{self.dataset_name}train_examples.pkl')):\\n self.train = open(os.path.join(self.dataset_dir, f'{self.dataset_name}train.txt'), 'r').read().lower().split(' \\\\n ')\\n if not os.path.exists(os.path.join(self.dataset_dir, f'{self.dataset_name}test_examples.pkl')):\\n self.test = open(os.path.join(self.dataset_dir, f'{self.dataset_name}test.txt'), 'r').read().lower().split(' \\\\n ')\\n if not os.path.exists(os.path.join(self.dataset_dir, f'{self.dataset_name}dev_examples.pkl')):\\n self.dev = open(os.path.join(self.dataset_dir, f'{self.dataset_name}dev.txt'), 'r').read().lower().split(' \\\\n ')\",\n \"def load_data(path='./data/train'):\\n print(\\\"Loading IMDB Data...\\\")\\n data = []\\n\\n dir = os.path.dirname(__file__)\\n file_list = glob.glob(os.path.join(dir, path + '/pos/*'))\\n file_list.extend(glob.glob(os.path.join(dir, path + '/neg/*')))\\n print(\\\"Parsing %s files\\\" % len(file_list))\\n for i, f in enumerate(file_list):\\n with open(f, \\\"r\\\", encoding=\\\"utf8\\\") as openf:\\n s = openf.read()\\n data.append(imp.preprocess(s)) # NOTE: Preprocessing code called here on all reviews\\n return data\",\n \"def load_data(self):\\n with open('data/fordTrain.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n train = [x for i, x in enumerate(data) if i > 0] \\n # Extract features and target variable separately\\n trainx = [x[3:] for x in train]\\n trainy = [x[2] for x in train]\\n\\n with open('data/fordTest.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testx = [x[3:] for i, x in enumerate(data) if i > 0] \\n\\n with open('data/Solution.csv') as f:\\n data = csv.reader(f, delimiter=',')\\n testy = [x[2] for i, x in enumerate(data) if i > 0] \\n\\n # Extract features and target variable, convert to numpy array\\n trainx = np.asarray(trainx, dtype=np.float32)\\n trainy = np.asarray(trainy, dtype=np.int8)\\n testx = np.asarray(testx, dtype=np.float32)\\n testy = np.asarray(testy, dtype=np.int8)\\n\\n # Return training and test sets\\n trainSet = Dataset(trainx, trainy)\\n testSet = Dataset(testx, testy)\\n return trainSet, testSet\",\n \"def test_loadData():\\n \\n sys = LVsystem.Ecosystem()\\n \\n sys.loadSetup('2Prey1Predator')\\n \\n \\n data = sys.create_data()\\n \\n assert data[0] == 3\\n assert data[1] == ['rabbit', 'hen', 'fox']\\n assert data[2] == [30,10,20]\\n assert data[3] == [0.09,0.07,-0.06] \\n assert data[4] == [10000,10000,1]\\n assert data[5] == [400,500,250]\\n assert data[6][1][2] == -data[6][2][1]\\n assert data[6][2][2] == 0\\n\\n sys.removeSpecies('rabbit')\\n sys.removeSpecies('fox')\\n sys.removeSpecies('hen')\",\n \"def load_dataset(self, split='train'):\\n path = self.args.data\\n if not os.path.exists(path):\\n raise FileNotFoundError(\\n \\\"Dataset not found: ({})\\\".format(path)\\n )\\n\\n files = os.listdir(path) if os.path.isdir(path) else [path]\\n files = [f for f in files if split in f]\\n assert len(files) > 0\\n\\n self.datasets[split] = CombineBertData(files)\\n\\n\\n \\\"\\\"\\\"\\n dataset = data_utils.load_indexed_dataset(\\n split_path, self.dictionary, self.args.dataset_impl, combine=combine\\n )\\n if dataset is None:\\n raise FileNotFoundError(\\n \\\"Dataset not found: {} ({})\\\".format(split, split_path)\\n )\\n\\n dataset = TokenBlockDataset(\\n dataset,\\n dataset.sizes,\\n self.args.tokens_per_sample,\\n pad=self.dictionary.pad(),\\n eos=self.dictionary.eos(),\\n break_mode=self.args.sample_break_mode,\\n include_targets=True,\\n )\\n\\n add_eos_for_other_targets = (\\n self.args.sample_break_mode is not None\\n and self.args.sample_break_mode != \\\"none\\\"\\n )\\n\\n self.datasets[split] = MonolingualDataset(\\n dataset,\\n dataset.sizes,\\n self.dictionary,\\n self.output_dictionary,\\n add_eos_for_other_targets=add_eos_for_other_targets,\\n shuffle=True,\\n targets=self.targets,\\n add_bos_token=self.args.add_bos_token,\\n )\\n \\\"\\\"\\\"\",\n \"def load_data(self):\\n raise NotImplementedError()\",\n \"def loadSets(self, indir=\\\"\\\"):\\n\\n if indir==\\\"\\\":\\n print(\\\"specify folder\\\")\\n return -1\\n\\n self.train = pd.read_pickle(\\\"{}/train.pkl\\\".format(indir))\\n self.valid = pd.read_pickle(\\\"{}/valid.pkl\\\".format(indir))\\n self.test = pd.read_pickle(\\\"{}/test.pkl\\\".format(indir))\\n\\n print(\\\"sets loaded\\\")\",\n \"def load_processed_dataset(name):\\n assert name in VALID_NAMES, 'Invalid data set requested. Please make sure name is one of ' + ', '.join(VALID_NAMES) + '.'\\n path = os.path.join('downloads', name)\\n path_processed = os.path.join(path, 'processed')\\n\\n if name == 'iris':\\n return pd.read_csv(os.path.join(path_processed, 'iris.csv'))\\n\\n elif name == 'wine':\\n return pd.read_csv(os.path.join(path_processed, 'wine.csv'))\\n\\n elif name == 'titanic':\\n return pd.read_csv(os.path.join(path_processed, 'titanic.csv'))\\n\\n elif name == 'lanl':\\n with open(os.path.join(path_processed, 'train_data.pkl'), 'rb') as f:\\n x = pkl.load(f)\\n with open(os.path.join(path_processed, 'train_targets.pkl'), 'rb') as f:\\n y = pkl.load(f)\\n return x, y\\n\\n elif name == 'MNIST' or name == 'FashionMNIST':\\n training = torch.load(os.path.join(path_processed, 'training.pt'))\\n test = torch.load(os.path.join(path_processed, 'test.pt'))\\n return training, test\",\n \"def load_data(limit=None, load_test=False):\\n data_snli_dev, data_snli_train = None, None\\n data_multinli_train, data_multinli_dev = None, None\\n data_mli_train, data_mli_dev = None, None\\n data_mli_test = None\\n\\n if SNLI_TRAIN_FILENAME.exists():\\n data_snli_train = read_nli_data(SNLI_TRAIN_FILENAME, set_genre='snli', limit=limit)\\n data_snli_dev = read_nli_data(SNLI_DEV_FILENAME, set_genre='snli', limit=limit)\\n logging.info('SNLI: train - %s, dev - %s', data_snli_train.shape, data_snli_dev.shape)\\n\\n if MULTINLI_TRAIN_FILENAME.exists():\\n data_multinli_train = read_nli_data(MULTINLI_TRAIN_FILENAME, limit=limit)\\n data_multinli_dev = read_nli_data(MULTINLI_DEV_FILENAME, limit=limit)\\n logging.info('MultiNLI: train - %s, dev - %s', data_multinli_train.shape, data_multinli_dev.shape)\\n\\n if MLI_TRAIN_FILENAME.exists():\\n data_mli_train = read_nli_data(MLI_TRAIN_FILENAME, set_genre='clinical', limit=limit)\\n data_mli_dev = read_nli_data(MLI_DEV_FILENAME, set_genre='clinical', limit=limit)\\n logging.info('MLI: train - %s, dev - %s', data_mli_train.shape, data_mli_dev.shape)\\n\\n if load_test:\\n data_mli_test = read_nli_data(MLI_TEST_FILENAME, set_genre='clinical', limit=limit)\\n\\n # Drop columns that are presented not in all datasets\\n columns_to_drop = ['captionID', 'promptID', 'annotator_labels']\\n for d in [data_snli_dev, data_snli_train, data_multinli_train, data_multinli_dev, data_mli_train, data_mli_dev,\\n data_mli_test]:\\n if d is not None:\\n d.drop(columns_to_drop, axis=1, inplace=True, errors='ignore')\\n\\n # concatenate all data together\\n data_train = pd.concat([data_snli_train, data_multinli_train, data_mli_train], axis=0)\\n data_dev = pd.concat([data_snli_dev, data_multinli_dev, data_mli_dev], axis=0)\\n\\n data_train.set_index('genre', inplace=True)\\n data_dev.set_index('genre', inplace=True)\\n\\n if data_mli_test is not None:\\n data_mli_test.set_index('genre', inplace=True)\\n\\n if not load_test:\\n return data_dev, data_train\\n else:\\n return data_dev, data_train, data_mli_test\",\n \"def load_dataset():\\n\\n\\n train_dd_loader = DailyDialogLoader(PATH_TO_TRAIN_DATA, load=False)\\n train_dataloader = DataLoader(train_dd_loader, batch_size=16, shuffle=True, num_workers=0,\\n collate_fn=PadCollate())\\n\\n test_dd_loader = DailyDialogLoader(PATH_TO_TEST_DATA, load=True)\\n test_dataloader = DataLoader(test_dd_loader, batch_size=1, shuffle=False, num_workers=0,\\n collate_fn=PadCollate())\\n\\n assert train_dd_loader.vocabulary.n_words == test_dd_loader.vocabulary.n_words\\n\\n return train_dd_loader, train_dataloader, test_dataloader\",\n \"def load_dataset(self):\\n # Get all the files in the directory\\n file_list = self.get_file_list()\\n\\n # Concatenate the data corresponding to a list of files\\n data = self.concatenate_file_data(file_list)\\n\\n # Shuffle the data and create the training and the validation datasets\\n data = self.shuffle_data_dictionary(data)\\n self.training_dataset, self.validation_dataset = self.split_data_into_training_and_validation(data)\",\n \"def learnDataset(self, data_loader):\\n print(\\\"learning dataset\\\")\\n\\n count = 0\\n for sample in data_loader:\\n input_sentence = sample[\\\"input\\\"][0]\\n target_sentence = sample[\\\"target\\\"][0]\\n\\n prev_word = None\\n for word_idx in range(1, 16):\\n target_word = int(target_sentence[word_idx])\\n self.model_parts[word_idx - 1].populateFactors(\\n input_sentence, target_word, prev_word\\n )\\n prev_word = target_word\\n\\n print(\\\"{}/127940\\\".format(count), end = \\\"\\\\r\\\")\\n count += 1\\n print(\\\"127940/127940\\\")\\n\\n print(\\\"before fixed\\\", list(self.model_parts[0].factors[0].d.keys())[:10])\\n for i in range(15):\\n self.model_parts[i].fixed()\\n print(\\\"after fixed\\\", self.model_parts[0].factors[0].keys[:10])\",\n \"def _get_dataset(\\n self,\\n dataset_path: str,\\n data_folder: str = \\\"data/\\\",\\n ):\\n if not os.path.isdir(dataset_path):\\n click.secho(f\\\"{dataset_path} not found!\\\", fg=\\\"red\\\")\\n\\n dataset_hash = (\\n int(hashlib.sha256(dataset_path.encode(\\\"utf-8\\\")).hexdigest(), 16) % 10 ** 8\\n )\\n\\n # To avoid using cache for different models\\n # split(/) for google/electra-base-discriminator\\n pretrained_model = (\\n self.hparams.pretrained_model.split(\\\"/\\\")[1]\\n if \\\"/\\\" in self.hparams.pretrained_model\\n else self.hparams.pretrained_model\\n )\\n dataset_cache = data_folder + \\\".dataset_\\\" + str(dataset_hash) + pretrained_model\\n\\n if os.path.isfile(dataset_cache):\\n click.secho(f\\\"Loading tokenized dataset from cache: {dataset_cache}.\\\")\\n return torch.load(dataset_cache)\\n\\n dataset_path += \\\"\\\" if dataset_path.endswith(\\\"/\\\") else \\\"/\\\"\\n dataset = {\\n \\\"train\\\": pd.read_csv(dataset_path + \\\"train.tsv\\\", sep=\\\"\\\\t\\\").to_dict(\\n \\\"records\\\"\\n ),\\n \\\"valid\\\": pd.read_csv(dataset_path + \\\"valid.tsv\\\", sep=\\\"\\\\t\\\").to_dict(\\n \\\"records\\\"\\n ),\\n \\\"test\\\": pd.read_csv(dataset_path + \\\"test.tsv\\\", sep=\\\"\\\\t\\\").to_dict(\\\"records\\\"),\\n }\\n # Read Labels\\n with open(dataset_path + \\\"labels.txt\\\", \\\"r\\\") as fp:\\n labels = [line.strip() for line in fp.readlines()]\\n label_encoder = {labels[i]: i for i in range(len(labels))}\\n\\n dataset[\\\"label_encoder\\\"] = label_encoder\\n # Tokenize\\n dataset[\\\"train\\\"] = self._tokenize(dataset[\\\"train\\\"])\\n dataset[\\\"valid\\\"] = self._tokenize(dataset[\\\"valid\\\"])\\n dataset[\\\"test\\\"] = self._tokenize(dataset[\\\"test\\\"])\\n torch.save(dataset, dataset_cache)\\n return dataset\",\n \"def main(self, data):\\n\\t\\ttokenizer = BertTokenizer.from_pretrained(\\\"bert-base-uncased\\\", do_lower_case=True)\\n\\t\\teval_features = self.get_features(data, self.labels, tokenizer, self.max_seq_length)\\n\\t\\tlabel, prob = self.predict(eval_features)\\n\\t\\treturn label, prob\",\n \"def load_data():\\n f = gzip.open('../data/mnist.pkl.gz', mode='rb')\\n\\n # NOTE: I get errors when I don't use encoding='latin1' because of Python 2 vs Python 3 compatibility issues\\n # training_data, validation_data, test_data = pickle.load(f, encoding='latin1')\\n training_data, validation_data, test_data = pickle.load(f)\\n\\n f.close()\\n\\n return training_data, validation_data, test_data\",\n \"def load_eval_dataset(self):\\n dict_path = get_eval_data(self.eval_path, self.src_lang, self.tgt_lang)\\n\\n pairs = []\\n not_found_all = 0\\n not_found_L1 = 0\\n not_found_L2 = 0\\n\\n # Open the file and check if src and tgt word exists in the vocab\\n with open(dict_path, \\\"r\\\") as f:\\n for _, line in enumerate(f):\\n word1, word2 = line.rstrip().split()\\n if word1 in self.src_dico and word2 in self.tgt_dico:\\n pairs.append((self.src_dico.index(word1), self.tgt_dico.index(word2)))\\n else:\\n not_found_all += 1\\n not_found_L1 += int(word1 not in self.src_dico)\\n not_found_L2 += int(word2 not in self.tgt_dico)\\n print(\\n \\\"Found %i pairs of words in the dictionary (%i unique). \\\"\\n \\\" %i other pairs contained at least one unknown word \\\"\\n \\\" (%i in src_lang, %i in tgt_lang)\\\"\\n % (\\n len(pairs),\\n len(set([x for x, _ in pairs])),\\n not_found_all,\\n not_found_L1,\\n not_found_L2,\\n )\\n )\\n src_ind = [pairs[x][0] for x in range(len(pairs))]\\n tgt_ind = [pairs[x][1] for x in range(len(pairs))]\\n self.src_ind = np.asarray(src_ind)\\n self.tgt_ind = np.asarray(tgt_ind)\",\n \"def load_raw_data(prot, shuffle=True):\\n dna_seq = []\\n binding = []\\n data_file = os.path.join(DATA_DIR, prot, 'train')\\n with open(data_file, 'r') as f:\\n datas = f.readlines()\\n if shuffle:\\n random.shuffle(datas)\\n dna_seq.extend(data.split()[0] for data in datas)\\n binding.extend(eval(data.split()[1]) for data in datas)\\n return dna_seq, binding\",\n \"def __loadDataset(self, parameters):\\n # self.localConfigured = Settings.instance().readValue( key = 'Common/local-repo' )\\n for pr in parameters:\\n if pr['type'] == 'dataset':\\n if pr['value'].startswith('undefined:/'):\\n fileName = pr['value'].split('undefined:/')[1]\\n if not os.path.exists( fileName ):\\n raise Exception(\\\"the following test data file is missing: %s \\\" % fileName)\\n\\n doc = FileModelTestData.DataModel()\\n res = doc.load( absPath = fileName )\\n pr['value'] = \\\"undefined:/%s\\\" % doc.getRaw()\\n elif pr['value'].startswith('local-tests:/'):\\n fileName = pr['value'].split('local-tests:/')[1]\\n\\n if not os.path.exists( fileName ):\\n raise Exception(\\\"the following test data file is missing: %s \\\" % fileName)\\n \\n doc = FileModelTestData.DataModel()\\n res = doc.load( absPath = fileName )\\n pr['value'] = \\\"local-tests:/%s\\\" % doc.getRaw()\\n else:\\n pass\",\n \"def load_data(filename):\\n assert os.path.exists(filename)==True\\n dat = scipy.io.loadmat(filename)\\n inputs = dat['inputs']\\n #print len(inputs)\\n targets = dat['targets']\\n #print len(targets)\\n assert len(inputs)==len(targets)\\n\\n global alldata\\n global indim \\n global outdim\\n\\n indim = len(inputs[0])\\n outdim = 1\\n #print indim\\n alldata = ClassificationDataSet(indim, outdim, nb_classes = 8)\\n alldata.setField('input',inputs)\\n alldata.setField('target',targets)\\n\\n assert len(alldata['input'])==len(alldata['target'])\\n print type(alldata)\",\n \"def load_data(self):\\n with open(self.file_name) as f:\\n lines = f.readlines()\\n\\n labels = list()\\n all_dat = list()\\n for i, l in enumerate(lines):\\n\\n labels.append(int(l[0]))\\n\\n l = gensim.utils.any2unicode(l)\\n all_dat.append(LabeledSentence(l.split(\\\"\\\\t\\\")[-1], [i]))\\n\\n return all_dat, np.asarray(labels)\",\n \"def load_predicted_results(self):\\n print(\\\"\\\\n\\\\nLoad prediction answers : \\\")\\n with open(\\\"predicted_results\\\", \\\"rb\\\") as predicted_results:\\n self.predicted_results = pickle.load(predicted_results)\",\n \"def load_data(self):\\n print(\\\"Loading dataset...\\\")\\n # Load the dataset\\n subIDs, data, labels = dl.load_processed_data_N_subjects_allchans(\\n '../data_5sec_100Hz_bipolar/', Nsub=14)\\n\\n if len(data) > 1:\\n\\n # If more than one patient loaded, append data to single array\\n data_arr = np.array(data[0])\\n label_arr = labels[0]\\n\\n for sub in range(1, len(data)):\\n data_arr = np.append(data_arr, data[sub], axis=1)\\n label_arr = np.append(label_arr, labels[sub], axis=0)\\n\\n else:\\n # Remove the extra dimension at axis=0\\n data_array = np.squeeze(data)\\n labels = np.squeeze(labels)\\n\\n # Move trials to the end so data array is 'nchan x timeseries x trials'\\n self.data = np.moveaxis(data_arr, 1, -1)\\n self.labels = np.array(label_arr)\\n\\n self.label_strings = dl.available_stringlabels\\n\\n valid_indices = np.sum(self.labels, axis=0)\\n names = [[self.label_strings[i], i, valid_indices[i]] for i in range(len(valid_indices)) if valid_indices[i] > 0]\\n print(\\\"A summary of valid labels is below: \\\\nFormat: [Label name, label index, Label count]\\\")\\n for i in range(len(names)):\\n print(names[i])\\n return\",\n \"def load_training_data(file_path):\\n return load_data(file_path)\",\n \"def load_data_from_files(self):\\n # separated method to allow mock easier\\n logger.info(\\\"Loading data...\\\")\\n parent = Path(__file__).parent\\n path = parent / \\\"resources\\\" / \\\"scores.txt\\\"\\n self.scorer.load_from_file(path)\\n path = parent / \\\"resources\\\" / \\\"american-english-large.txt\\\"\\n self.trie.load_from_file(path)\\n path = parent / \\\"resources\\\" / \\\"reels.txt\\\"\\n self.reels = Reel.get_from_file(path)\\n logger.info(\\\"Data loaded!\\\")\",\n \"def load_dataset(self, split, epoch=0, combine=False, **kwargs):\\n paths = self.args.data.split(':')\\n assert len(paths) > 0\\n data_path = paths[epoch % len(paths)]\\n\\n # infer langcode\\n src, tgt = self.args.source_lang, self.args.target_lang\\n if not hasattr(self.args, \\\"source_tau\\\"): self.args.source_tau = -1\\n if not hasattr(self.args, \\\"target_tau\\\"): self.args.target_tau = -1\\n\\n if not hasattr(self.args, 'source_tau'): self.args.source_tau = -1\\n if not hasattr(self.args, 'target_tau'): self.args.target_tau = -1\\n\\n if self.args.main_src_wordfreq is not None and self.args.dialect_src_wordfreq is not None:\\n def word_idx_from_file(filename):\\n idx = []\\n with open(filename, 'r') as myfile:\\n for line in myfile:\\n idx.append(self.src_dict.index(line.split()[0]))\\n return idx\\n self.main_src_word_idx = word_idx_from_file(self.args.main_src_wordfreq) \\n self.dialect_src_word_idx = word_idx_from_file(self.args.dialect_src_wordfreq)\\n idx_to_sample_prob = []\\n for i, src_word in enumerate(self.main_src_word_idx):\\n if self.args.dialect_tau == -1:\\n dialect_word_probs = np.array([1. for k in range(len(self.dialect_src_word_idx))])\\n else:\\n dialect_word_probs = np.array([-np.absolute(k-i) for k in range(len(self.dialect_src_word_idx))])\\n idx_to_sample_prob.append(dialect_word_probs)\\n #self.idx_to_sample_prob = scipy.special.softmax(np.array(self.idx_to_sample_prob)*0.01, axis=1)\\n idx_to_sample_prob = scipy.special.softmax(np.array(idx_to_sample_prob)*self.args.dialect_tau, axis=1)\\n print(idx_to_sample_prob)\\n self.idx_to_sample_prob = {}\\n for i, src_word in enumerate(self.main_src_word_idx):\\n self.idx_to_sample_prob[src_word] = idx_to_sample_prob[i]\\n pass_item = (self.idx_to_sample_prob, self.dialect_src_word_idx)\\n else:\\n pass_item = None\\n if split != 'train':\\n src_tau = -1 \\n tgt_tau = -1\\n mlm = None\\n idx_to_src_gradnorm = None\\n else: \\n src_tau = self.args.source_tau \\n tgt_tau = self.args.target_tau \\n mlm = self.mlm\\n idx_to_src_gradnorm = self.idx_to_src_gradnorm\\n\\n self.datasets[split] = load_langpair_dataset(\\n data_path, split, src, self.src_dict, tgt, self.tgt_dict,\\n combine=combine, dataset_impl=self.args.dataset_impl,\\n upsample_primary=self.args.upsample_primary,\\n left_pad_source=self.args.left_pad_source,\\n left_pad_target=self.args.left_pad_target,\\n max_source_positions=self.args.max_source_positions,\\n max_target_positions=self.args.max_target_positions,\\n src_tag=self.args.src_tag, tgt_tag=self.args.tgt_tag,\\n src_tau=src_tau, tgt_tau=tgt_tau,\\n epoch=epoch,\\n id_to_sample_probabilities=pass_item,\\n lm=mlm,\\n idx_to_src_gradnorm=idx_to_src_gradnorm,\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5732409","0.56973225","0.5590737","0.549615","0.54825884","0.54152006","0.5368154","0.5350428","0.5322323","0.53070223","0.5303706","0.52806413","0.5271645","0.5271418","0.5266955","0.5249725","0.5239241","0.52312857","0.52145183","0.52016944","0.5196183","0.5195152","0.5195152","0.5185736","0.5174593","0.51566744","0.51543516","0.5152642","0.51432645","0.51336014","0.5124375","0.51160854","0.51127744","0.51103395","0.5097312","0.50923187","0.50871295","0.5078368","0.507377","0.50553536","0.5052059","0.5039693","0.5035536","0.5029031","0.500745","0.50023204","0.49997213","0.49934807","0.4992623","0.49856266","0.49852893","0.4964709","0.49621782","0.49578115","0.495106","0.49501988","0.4949823","0.4949263","0.49489555","0.4948637","0.4945492","0.49435973","0.49434307","0.4943041","0.49427098","0.49293438","0.4927829","0.49224725","0.49181268","0.49172688","0.49066514","0.49064258","0.48987818","0.4897894","0.48955807","0.48954663","0.48934603","0.48916963","0.48735905","0.48731977","0.48711443","0.48685998","0.4860352","0.4853212","0.48485437","0.4848494","0.48474705","0.48451197","0.4842352","0.4841666","0.4826554","0.4825546","0.48242265","0.4823385","0.48228884","0.4815731","0.48114875","0.48088357","0.48044243","0.4797773","0.47942644"],"string":"[\n \"0.5732409\",\n \"0.56973225\",\n \"0.5590737\",\n \"0.549615\",\n \"0.54825884\",\n \"0.54152006\",\n \"0.5368154\",\n \"0.5350428\",\n \"0.5322323\",\n \"0.53070223\",\n \"0.5303706\",\n \"0.52806413\",\n \"0.5271645\",\n \"0.5271418\",\n \"0.5266955\",\n \"0.5249725\",\n \"0.5239241\",\n \"0.52312857\",\n \"0.52145183\",\n \"0.52016944\",\n \"0.5196183\",\n \"0.5195152\",\n \"0.5195152\",\n \"0.5185736\",\n \"0.5174593\",\n \"0.51566744\",\n \"0.51543516\",\n \"0.5152642\",\n \"0.51432645\",\n \"0.51336014\",\n \"0.5124375\",\n \"0.51160854\",\n \"0.51127744\",\n \"0.51103395\",\n \"0.5097312\",\n \"0.50923187\",\n \"0.50871295\",\n \"0.5078368\",\n \"0.507377\",\n \"0.50553536\",\n \"0.5052059\",\n \"0.5039693\",\n \"0.5035536\",\n \"0.5029031\",\n \"0.500745\",\n \"0.50023204\",\n \"0.49997213\",\n \"0.49934807\",\n \"0.4992623\",\n \"0.49856266\",\n \"0.49852893\",\n \"0.4964709\",\n \"0.49621782\",\n \"0.49578115\",\n \"0.495106\",\n \"0.49501988\",\n \"0.4949823\",\n \"0.4949263\",\n \"0.49489555\",\n \"0.4948637\",\n \"0.4945492\",\n \"0.49435973\",\n \"0.49434307\",\n \"0.4943041\",\n \"0.49427098\",\n \"0.49293438\",\n \"0.4927829\",\n \"0.49224725\",\n \"0.49181268\",\n \"0.49172688\",\n \"0.49066514\",\n \"0.49064258\",\n \"0.48987818\",\n \"0.4897894\",\n \"0.48955807\",\n \"0.48954663\",\n \"0.48934603\",\n \"0.48916963\",\n \"0.48735905\",\n \"0.48731977\",\n \"0.48711443\",\n \"0.48685998\",\n \"0.4860352\",\n \"0.4853212\",\n \"0.48485437\",\n \"0.4848494\",\n \"0.48474705\",\n \"0.48451197\",\n \"0.4842352\",\n \"0.4841666\",\n \"0.4826554\",\n \"0.4825546\",\n \"0.48242265\",\n \"0.4823385\",\n \"0.48228884\",\n \"0.4815731\",\n \"0.48114875\",\n \"0.48088357\",\n \"0.48044243\",\n \"0.4797773\",\n \"0.47942644\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":235,"numItemsPerPage":100,"numTotalItems":95772,"offset":23500,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjcxMjA5MSwianRpIjoiN2IzMGM0MWYtOTc3MC00ZGM0LThmZTUtNjJlMDVhZjg4M2U0Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY3MTU2OTEsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Z3Vdk-JT_N5_YexWPs7uCpwfhOQj4KnN65Igcy80Sws_z9kgu0ihGl4AJEKrDVxnoODnn2-QzG34apvZCWClCw","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Converts an image into a networks input. | def get_detect_image_blob(self, im):
im_orig = im.astype(np.float32, copy=True)
im_orig -= cfg.SIAMSE.PIXEL_MEANS
im_shape = im_orig.shape
im_size_min = np.min(im_shape[0:2])
im_size_max = np.max(im_shape[0:2])
processed_ims = []
im_scale_factors = []
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def imagenet_preprocess(image, label):\n i = image\n i = tf.cast(i, tf.float32)\n i = tf.image.resize_with_crop_or_pad(i, 224, 224)\n if model_name == 'ResNet50' or model_name == 'ResNet152':\n i = tf.keras.applications.resnet.preprocess_input(i)\n else:\n i... | [
"0.63952285",
"0.63228744",
"0.63136196",
"0.62095743",
"0.62074095",
"0.61970663",
"0.6180743",
"0.6180006",
"0.6155081",
"0.6112606",
"0.6109308",
"0.6098736",
"0.604532",
"0.603232",
"0.6016995",
"0.6010818",
"0.6000536",
"0.59828776",
"0.59793276",
"0.5928676",
"0.5842607... | 0.0 | -1 |
Convert a list of images into a networks input. Assumes images are already prepared (means subtracted, BGR order, ...). | def im_list_to_blob(self, ims):
max_shape = np.array([im.shape for im in ims]).max(axis=0)
num_images = len(ims)
blob = np.zeros((num_images, max_shape[0], max_shape[1], 3),
dtype=np.float32)
for i in range(num_images):
im = ims[i]
blob[i, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def class_imgs(list_img):\n numberimg = len(list_img)\n resize(net, numberimg, cursize)\n i = 0\n for img in list_img:\n image = caffe.io.load_image(img)\n transformed_image = transformer.preprocess('data', image)\n net.blobs['data'].data[i] = transformed_image\n i = i + 1\n... | [
"0.6794266",
"0.65664166",
"0.6506291",
"0.6428332",
"0.64100635",
"0.6392384",
"0.6322385",
"0.63118637",
"0.62800974",
"0.6256072",
"0.6243301",
"0.6233787",
"0.62281585",
"0.6213896",
"0.61919415",
"0.6191805",
"0.61836946",
"0.61509347",
"0.6144131",
"0.6138562",
"0.61356... | 0.0 | -1 |
Generates a csv file with the resulting assignment while it updates the status of the process using Celery | def calculate_result(self, reviewer_data, article_data, people_data,
coi_data,
min_rev_art, max_rev_art, min_art_rev, max_art_rev):
cur_progress = 0
max_progress = 100
article_data = pd.DataFrame(article_data)
people_data = pd.DataFrame... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def export_to(short_name):\r\n (app, owner, n_tasks, n_task_runs,\r\n overall_progress, last_activity) = app_by_shortname(short_name)\r\n title = app_title(app, gettext(\"Export\"))\r\n loading_text = gettext(\"Exporting data..., this may take a while\")\r\n\r\n try:\r\n require.app.read(app... | [
"0.6271365",
"0.606226",
"0.6017278",
"0.5945065",
"0.5934954",
"0.58989936",
"0.5891281",
"0.5823478",
"0.581835",
"0.58153915",
"0.5762086",
"0.5739158",
"0.5739158",
"0.5732645",
"0.57053995",
"0.5689611",
"0.56734747",
"0.5639372",
"0.56097394",
"0.56026286",
"0.5598239",... | 0.0 | -1 |
Test case for delete_opening_balance_journals_key | def test_delete_opening_balance_journals_key(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_opening_balance_journals_key(self):\n pass",
"def test_get_opening_balance_journals(self):\n pass",
"def test_post_opening_balance_journals(self):\n pass",
"def test_client_risk_assessment_delete(self):\n pass",
"def test_deleteItinerary(self):\n event = dict... | [
"0.7443269",
"0.6647047",
"0.6586451",
"0.6173807",
"0.59971863",
"0.5906599",
"0.5883001",
"0.58747035",
"0.58452064",
"0.5810683",
"0.5803397",
"0.5792871",
"0.57869107",
"0.57812667",
"0.5751271",
"0.5725391",
"0.5719262",
"0.57173496",
"0.56513774",
"0.5649916",
"0.564739... | 0.954454 | 0 |
Test case for get_opening_balance_journals | def test_get_opening_balance_journals(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_opening_balance_journals_key(self):\n pass",
"def test_post_opening_balance_journals(self):\n pass",
"def test_delete_opening_balance_journals_key(self):\n pass",
"def test_open_ru_ballance(self, ):\n if self.report_type == 'open.ru':\n (mid, aid) = self.ma... | [
"0.7997928",
"0.7800163",
"0.6249587",
"0.5947075",
"0.5603603",
"0.5390032",
"0.53497434",
"0.5313137",
"0.52879274",
"0.52468204",
"0.52310777",
"0.5218465",
"0.5213669",
"0.5169804",
"0.5147557",
"0.5146794",
"0.5145016",
"0.5138725",
"0.51375633",
"0.50891036",
"0.5077854... | 0.93086916 | 0 |
Test case for get_opening_balance_journals_key | def test_get_opening_balance_journals_key(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_opening_balance_journals(self):\n pass",
"def test_delete_opening_balance_journals_key(self):\n pass",
"def test_post_opening_balance_journals(self):\n pass",
"def test_journals_paged_fields(self, api_client):\n rv = api_client.get(\"/journals-paged\")\n json_d... | [
"0.814138",
"0.7337289",
"0.66358453",
"0.5097487",
"0.5004364",
"0.49763408",
"0.49549302",
"0.49017188",
"0.48923275",
"0.48898348",
"0.48454645",
"0.4810751",
"0.47996962",
"0.47848547",
"0.47577968",
"0.4739",
"0.47346452",
"0.47301468",
"0.4718948",
"0.471765",
"0.470826... | 0.9500056 | 0 |
Test case for post_opening_balance_journals | def test_post_opening_balance_journals(self):
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_opening_balance_journals(self):\n pass",
"def test_get_opening_balance_journals_key(self):\n pass",
"def test_delete_opening_balance_journals_key(self):\n pass",
"def test_finalize_and_open_period(self):\n employee_payments_qty = EmployeePayment.objects.filter(employe... | [
"0.84121585",
"0.69012296",
"0.649312",
"0.6370543",
"0.5991055",
"0.5923325",
"0.5892853",
"0.5802448",
"0.5717177",
"0.56970596",
"0.5671049",
"0.56420887",
"0.5641799",
"0.56363505",
"0.5616931",
"0.56020135",
"0.5594999",
"0.55920017",
"0.55864936",
"0.5533124",
"0.551042... | 0.9369089 | 0 |
Go to the page 'url', find the next link to got, then extract the JSON query result, find the wanted train, and display the results. | def main(url, MY_OUTWARD_TIME_MINI, MY_OUTWARD_TIME_MAXI="23:59"):
MY_OUTWARD_TIME_MINI = MY_OUTWARD_TIME_MINI.replace("h", ":")
MY_OUTWARD_TIME_MAXI = MY_OUTWARD_TIME_MAXI.replace("h", ":")
# Create the web browser object
b = RB(history=True, allow_redirects=True)
# Open the page
b.open(url)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_details_json(self, url):\n response = self.get_response(url)\n if response:\n html_soup = BeautifulSoup(response.text, 'html.parser')\n listings_json = html_soup.find('script', id='__NEXT_DATA__')\n if listings_json:\n listings_json = str(listi... | [
"0.640374",
"0.6311036",
"0.6293636",
"0.62394124",
"0.61887467",
"0.6168092",
"0.6126903",
"0.60940063",
"0.60837823",
"0.6080943",
"0.60407084",
"0.60225344",
"0.60035765",
"0.5994992",
"0.5961852",
"0.5961246",
"0.59560084",
"0.5912258",
"0.59046686",
"0.5901058",
"0.58722... | 0.7052188 | 0 |
generate the hashes for the passwords | def gen_hash(self, data):
password_gen = crypt.encrypt(data)
return password_gen | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_password(args):\n for password in args:\n heashed=hash_password(password)\n print(heashed)\n # checked=check_password(heashed)",
"def generate_hash(password, salt):\n # encode the password/salt in utf-8\n bytes_string = password.encode(encoding='utf-8')\n salt = salt.enco... | [
"0.69298804",
"0.68461454",
"0.6780465",
"0.67700803",
"0.6745123",
"0.6678128",
"0.66269416",
"0.6591104",
"0.65296036",
"0.6519999",
"0.65092117",
"0.65037704",
"0.6464029",
"0.646137",
"0.6457473",
"0.6453947",
"0.64536256",
"0.64312357",
"0.64078385",
"0.63722223",
"0.636... | 0.6938553 | 0 |
Given two dicts, merge them into a new dict as a shallow copy. | def merge_two_dicts(self, x, y):
z = x.copy()
z.update(y)
return z | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mergedict(x, y):\n z = x.copy()\n z.update(y)\n return z",
"def merge_dicts(dict_a, dict_b):\n dict_c = dict_a.copy()\n dict_c.update(dict_b)\n return dict_c",
"def merge_two_dicts(x, y):\n\tz = x.copy()\n\tz.update(y)\n\treturn z",
"def merge_two_dicts(x, y):\r\... | [
"0.8501846",
"0.84466875",
"0.84402865",
"0.84311867",
"0.8383174",
"0.8383174",
"0.8383174",
"0.8383174",
"0.8383174",
"0.8383174",
"0.8383174",
"0.8383174",
"0.83499664",
"0.83499664",
"0.83499664",
"0.82086074",
"0.81884646",
"0.81880224",
"0.81880224",
"0.8082591",
"0.799... | 0.8428829 | 4 |
Check a valid alpha space, and Update the space of project layers | def _update_layer_input_spaces(self):
layers = self.layers
context, state = self.input_space.components
layers[0].set_input_space(context)
for i in range(1, len(layers)):
layers[i].set_input_space(layers[i-1].get_output_space())
if not layers[-1].get_output_space()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_compute_alphas(self):\n\t\tdetails = self.watcher.analyze(layers=[self.second_layer], pool=False, randomize=False, plot=False, mp_fit=False, pl_package=WW_POWERLAW)\n\t\t#d = self.watcher.get_details(results=results)\n\t\ta = details.alpha.to_numpy()\n\t\tself.assertAlmostEqual(a[0],1.74859, places=3)\n\t... | [
"0.5934487",
"0.5925016",
"0.59177595",
"0.5883185",
"0.53154767",
"0.5309143",
"0.53014594",
"0.5276205",
"0.524059",
"0.5209953",
"0.51917106",
"0.50878495",
"0.5069914",
"0.50581545",
"0.5009805",
"0.4991279",
"0.49881154",
"0.49847874",
"0.49658477",
"0.4958915",
"0.49475... | 0.57453865 | 4 |
Compute the Alpha Distribution Do something about | def alpha(self, state, pctx):
raise NotImplementedError | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def optimal_alpha():\n\n # When I checked all of alphas, -0.01 was the best\n alpha = -0.01\n # np.random.choice([-0.06, -0.01, 0.04, 0.1])\n return alpha",
"def alpha(self):\n if self._alpha is None:\n df = self.fdist\n alpha_ = -self._powerlaw(df.index, df.freq)\n ... | [
"0.67765987",
"0.6742169",
"0.6655793",
"0.6544725",
"0.6529802",
"0.6469974",
"0.6445292",
"0.6410639",
"0.6391583",
"0.6390676",
"0.6371379",
"0.6346702",
"0.6341216",
"0.6341216",
"0.6341216",
"0.6337032",
"0.6275701",
"0.62751776",
"0.6227204",
"0.62154394",
"0.62064844",... | 0.6381885 | 10 |
Actor Network for Policy function Approximation, using a tanh activation for continuous control. We add parameter noise to encourage exploration, and balance it with Layer Normalization. | def network(self):
inp = Input((self.env_dim))
# #
# x = Dense(256, activation='relu')(inp)
# x = GaussianNoise(1.0)(x)
# #
# x = Flatten()(x)
# x = Dense(128, activation='relu')(x)
# x = GaussianNoise(1.0)(x)
# #
# out = Dense(self.act_dim... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(\n\t\t\tself, xi_dim, u_dim, noise_dim, n_hidden=[50, 50,],\n\t\t\tact_fct=tf.nn.tanh, noise_scale=1.):\n\n\t\tPolicy.__init__(self, xi_dim, u_dim)\n\n\t\tself._nn = MLP(\n\t\t\tn_input=xi_dim + noise_dim,\n\t\t\tn_output=u_dim,\n\t\t\tn_hidden=n_hidden,\n\t\t\tbatch_size_svi=1,\n\t\t\tact_fct=act_fct... | [
"0.6396525",
"0.63267297",
"0.63142556",
"0.62548804",
"0.6153631",
"0.6122751",
"0.6095379",
"0.6042239",
"0.6022594",
"0.60222757",
"0.6021168",
"0.60164464",
"0.59947276",
"0.59813875",
"0.5972728",
"0.59699893",
"0.5963782",
"0.5926341",
"0.59177935",
"0.59131825",
"0.588... | 0.0 | -1 |
Action prediction (target network) | def target_predict(self, inp):
return self.target_model.predict(inp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(self, state, action):\n assert np.shape(state) == (self._state_dim,)\n assert np.shape(action) == (self._action_dim,)\n\n ### PROBLEM 1\n ### YOUR CODE HERE\n # raise NotImplementedError\n next_state_pred = self._sess.run(self._next_state_pred,\n ... | [
"0.74663013",
"0.7177816",
"0.70986164",
"0.6922276",
"0.69212276",
"0.68662626",
"0.6827339",
"0.6794997",
"0.6789111",
"0.6774284",
"0.6735736",
"0.66649896",
"0.6650672",
"0.66315424",
"0.6606041",
"0.6605678",
"0.65936124",
"0.6592807",
"0.657133",
"0.6562334",
"0.6552538... | 0.6688052 | 11 |
Transfer model weights to target model with a factor of Tau | def transfer_weights(self):
W, target_W = self.model.get_weights(), self.target_model.get_weights()
for i in range(len(W)):
target_W[i] = self.tau * W[i] + (1 - self.tau)* target_W[i]
self.target_model.set_weights(target_W) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())",
"def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())",
"def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())",
"def _update_... | [
"0.73884064",
"0.73884064",
"0.73884064",
"0.7025803",
"0.6765796",
"0.67450416",
"0.6741832",
"0.67204714",
"0.6674984",
"0.6514898",
"0.65123016",
"0.6492347",
"0.6492347",
"0.6467089",
"0.6460493",
"0.64421093",
"0.64420146",
"0.6416018",
"0.6381238",
"0.6341845",
"0.63382... | 0.7874975 | 0 |
Draws a hex grid, based on the map object, onto this Surface | def draw_grid(self, surface):
# put platform to the left
(top, left) = get_surface_pos(self.flower_spawn_pos[0])
surface.blit(self.platform, ((top-RADIUS, left-RADIUS), (0, 0)))
unit_cell = [(.5 * RADIUS, 0),
(1.5 * RADIUS, 0),
(2 * RADIUS, SQRT3... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _draw_map(screen):\n my_map = HexMap(80, 80, _hex_size=10)\n my_map.generate_with_random_walk(150, iterations=25)\n for tile in my_map:\n # print(tile)\n color = COLORS[tile.type]\n\n tile_color = _modify_color(color)\n pygame.draw.polygon(screen, tile_color, tile.corners)\... | [
"0.75499904",
"0.74049234",
"0.7057696",
"0.7036038",
"0.67157614",
"0.6702647",
"0.6663625",
"0.666057",
"0.6598581",
"0.65752",
"0.6569185",
"0.6499745",
"0.6489359",
"0.64855045",
"0.64463276",
"0.641363",
"0.63803756",
"0.63674766",
"0.6222767",
"0.61868495",
"0.6152065",... | 0.69068396 | 4 |
Output the company CIK listed (applicable only for stocks issues in the SEC, so no exchange name is required) | def get_company_cik(stock_ticker: str):
company_cik = sec_finance_functions.get_company_data_by_ticker(stock_ticker).company_cik
return company_cik | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def company(self):\n\n x = 0\n my_company = self.data[\"Company Name\"]\n my_account = self.data[\"Account\"]\n result = []\n for i in my_company:\n my_string = i + \" -- \" + my_account[x]\n x += 1\n result.append(my_string)\n\n return res... | [
"0.62574416",
"0.6169119",
"0.6011516",
"0.5925151",
"0.56726855",
"0.5637131",
"0.5628796",
"0.56104475",
"0.5564428",
"0.54830617",
"0.5324723",
"0.5307937",
"0.5264544",
"0.52378327",
"0.5234159",
"0.52317774",
"0.51992476",
"0.5190561",
"0.5165406",
"0.5164627",
"0.514469... | 0.6787039 | 0 |
Get the number of fillings of a stock for the given year (or all fillings since the company listing) | def get_last_filling(stock_ticker: str,
filling_year: Optional[int] = None):
company_cik = sec_finance_functions.get_company_data_by_ticker(stock_ticker).company_cik
all_company_fillings = sec_finance_functions.get_all_company_filings_by_cik(company_cik)
all_company_fillings_by_year = s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def numPostings(years):\n\tcount = []\n\tfor year in years:\n\t\tfilename = \"SmartEnergy\" +str(year) +\".xlsx\"\n\t\tDB = pd.read_excel(filename, sheet_name = 'Filters')\n\t\tcount.append(DB.iloc[10][1])\n\treturn count",
"def _bands_competed_last_year():\n lLastYear = datetime.datetime.now().year - 1\n ... | [
"0.60557085",
"0.5479599",
"0.5406363",
"0.53464955",
"0.53220004",
"0.5278154",
"0.517318",
"0.51207525",
"0.51200336",
"0.4972167",
"0.49510524",
"0.49407512",
"0.49316242",
"0.49237838",
"0.49139115",
"0.49106917",
"0.49084038",
"0.48991558",
"0.48983836",
"0.48923317",
"0... | 0.6672505 | 0 |
Returns true if there is a new filling for this company. | def is_there_new_filling(stock_ticker: str):
return {f"Function is not implemented yet"} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_filled(self):\n return(self.order_master.amount==self.order_master.filled)",
"def is_new_financial_charge_created(self):\n current_number_of_records = self.get_number_of_financial_charges_in_the_grid()\n if int(current_number_of_records) > int(self.number_of_financial_charges_before_c... | [
"0.6681442",
"0.6435274",
"0.61737776",
"0.6131102",
"0.6128357",
"0.6062047",
"0.59511334",
"0.588346",
"0.58620167",
"0.57702446",
"0.5748563",
"0.57421947",
"0.5722985",
"0.57050693",
"0.5675417",
"0.5594404",
"0.5583435",
"0.556458",
"0.55533123",
"0.555196",
"0.5529778",... | 0.54475653 | 25 |
Call to inform that the any concurrent ripping process is finished. | def rip_finished(self):
if self.is_ripping:
self.is_ripping.clear() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def syncDone (self) :\r\n self.ongoing_sync_count -= 1",
"def _notify_end(self):\n to_scan = len(self._files_to_scan)\n event.notify(ScanProgressEvent(to_scan, to_scan, True))",
"def finished(self):",
"def finished(self):\n pass",
"def finish(self) -> None:",
"def finish(self)... | [
"0.6337645",
"0.62002885",
"0.6101757",
"0.60869145",
"0.60562354",
"0.60562354",
"0.6047451",
"0.6047451",
"0.6047451",
"0.6047451",
"0.6016429",
"0.59790313",
"0.59760773",
"0.5959373",
"0.5959373",
"0.5951485",
"0.5951485",
"0.5918788",
"0.59124225",
"0.5900939",
"0.589903... | 0.67650646 | 0 |
Helper method for populating data into packet P. | def _read_data_into_packet(self, p):
length = p.length * self.disc.audio_format.bytes_per_frame
if p.file_pos is None:
# Silence, so send on null bytes to player
p.data = '\0' * length
else:
file_pos = p.file_pos * self.disc.audio_format.bytes_per_frame
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fill_data(self, data):\n self._data = data\n\n self._data_length = data[1:3]\n self._frame_id = data[4]\n self._address = XbeeAddress(data[5:9], data[9:13], data[13:15])\n self._at_command = data[15:17]\n self._command_status = data[17]\n try:\n self.... | [
"0.68859315",
"0.6309926",
"0.6203171",
"0.59932953",
"0.5979013",
"0.5979013",
"0.59707654",
"0.59640336",
"0.5962908",
"0.59237236",
"0.5911169",
"0.59105027",
"0.58891994",
"0.5878796",
"0.5788424",
"0.5725738",
"0.57154256",
"0.57137066",
"0.5694419",
"0.5611748",
"0.5601... | 0.56601655 | 19 |
Iterate over DISC, splitting it into packets starting at TRACK_NUMBER index 1. This call will ensure that no packets cross a track or pregap boundary, and will also obey any edits to the disc. It will not, however, read any samples from disc, just tell the calling code what to read. | def iterate(cls, disc, track_number):
assert track_number >= 0 and track_number < len(disc.tracks)
track = disc.tracks[track_number]
packet_frame_size = (
disc.audio_format.rate / cls.PACKETS_PER_SECOND)
# Mock up a packet that ends at the start of index 1, so the
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _read_packets(self, reader: Par2FileReader):\n start_count = len(self)\n pointers = reader.get_pointers()\n # Create RecoverySets if needed\n for set_id, pointer_set in packets.by_set_id(pointers).items():\n print(set_id.hex(), pointer_set)\n if set_id not in s... | [
"0.5243465",
"0.50652975",
"0.503824",
"0.49788526",
"0.49385667",
"0.48881853",
"0.48847038",
"0.4879093",
"0.48679477",
"0.4829947",
"0.48023844",
"0.4800166",
"0.47898296",
"0.47791988",
"0.47784358",
"0.47733098",
"0.4772302",
"0.4743291",
"0.4735822",
"0.4723006",
"0.469... | 0.73285556 | 0 |
Initialize the installer's root path. | def __init__(self, specs, resources, properties=None):
if not properties:
properties = {}
self.init_collections()
self.properties = properties
self.set_paths(specs, resources)
self.parse_paths()
self.find_resources() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init():\n\n # Run the Installer's `init` function.\n Installer.init()",
"def __init__(self, rootPath=None):\n self.rootPath = rootPath or '.'",
"def __init__(self, root_path):\r\n self.root_path = root_path\r\n if not os.path.exists(root_path):\r\n os.makedirs(... | [
"0.6967015",
"0.6809016",
"0.67659163",
"0.6641332",
"0.6592395",
"0.656968",
"0.65626764",
"0.6486784",
"0.63000315",
"0.62842697",
"0.6153095",
"0.6122613",
"0.61168647",
"0.61159515",
"0.60651994",
"0.59922624",
"0.598174",
"0.59735596",
"0.594777",
"0.59465355",
"0.592946... | 0.0 | -1 |
Initialize collections to their default values. | def init_collections(self):
# Default paths to spec files relative to specs folder.
self.specs = {
'BASE': '',
'variables': 'variables.xml',
'conditions': 'conditions.xml',
'dynamicvariables': 'dynamic_variables.xml',
'dynamic_variables': 'dyna... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def init_defaults(self, defaults):\r\n for (sect, opt, default) in defaults:\r\n self._default(sect, opt, default)",
"def set_initial_values(self):\n\n pass",
"def initDefaults(self):\n return _libsbml.Compartment_initDefaults(self)",
"def initialize_default(self):\n se... | [
"0.64917606",
"0.6362083",
"0.6237232",
"0.6192766",
"0.6160568",
"0.61294746",
"0.6128681",
"0.6098633",
"0.5996917",
"0.5996615",
"0.59810257",
"0.598072",
"0.594288",
"0.5935369",
"0.5935369",
"0.5899538",
"0.5893436",
"0.58926535",
"0.5881706",
"0.5862227",
"0.58338207",
... | 0.59458727 | 12 |
Takes base paths to specs and resources. | def set_paths(self, specs, resources):
self.install = 'install.xml'
self.specs_path = path_format(specs)
self.root = path_format(dirname(dirname(self.specs_path)) + '/')
self.res_path = path_format(resources)
self.resources['BASE'] = self.res_path
self.specs['BASE'] = sel... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_resource_path(self):\n\n # Without arguments\n resources_root_path = os.path.abspath(os.path.join(\n MY_DIRECTORY, '..', '..', 'resources'\n ))\n self.assertEqual(resources_root_path, paths.resource())",
"def __init__(self, specs, resources, properties=None):\n ... | [
"0.6165541",
"0.6127959",
"0.611318",
"0.6023412",
"0.59037876",
"0.576045",
"0.575814",
"0.5617551",
"0.56028676",
"0.55873394",
"0.5575436",
"0.5532464",
"0.5520052",
"0.54906976",
"0.54781777",
"0.5471999",
"0.54613155",
"0.54188824",
"0.53953713",
"0.539372",
"0.5368863",... | 0.7049754 | 0 |
Extracts paths to available izpack resources and spec files from the installer's install.xml spec. | def parse_paths(self):
self.soup = BeautifulSoup(open(self.get_path('install')))
for spec in list(self.specs.keys()):
spec_file = self.find_specs_path(spec)
if spec_file:
# If spec file exists
self.specs[spec] = path_format(spec_file)
e... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_paths(self, specs, resources):\n self.install = 'install.xml'\n self.specs_path = path_format(specs)\n self.root = path_format(dirname(dirname(self.specs_path)) + '/')\n self.res_path = path_format(resources)\n self.resources['BASE'] = self.res_path\n self.specs['B... | [
"0.5985074",
"0.5818984",
"0.55800974",
"0.5558382",
"0.5510714",
"0.5509265",
"0.54902023",
"0.5484745",
"0.54695016",
"0.543011",
"0.5405252",
"0.53903776",
"0.5373021",
"0.5365647",
"0.5341147",
"0.5305645",
"0.53018004",
"0.52990454",
"0.52964294",
"0.52779734",
"0.527142... | 0.6754402 | 0 |
Find the path for the spec in the install.xml file. | def find_specs_path(self, spec):
element = self.soup.find(spec)
if element:
child = element.find('xi:include')
if child: # if xi:include exists, specs are external.
path = self.properties.substitute(child['href'])
else:
# Internal spec... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_paths(self):\n self.soup = BeautifulSoup(open(self.get_path('install')))\n for spec in list(self.specs.keys()):\n spec_file = self.find_specs_path(spec)\n if spec_file:\n # If spec file exists\n self.specs[spec] = path_format(spec_file)\n ... | [
"0.66329956",
"0.6390044",
"0.6344499",
"0.62348706",
"0.61632514",
"0.6048204",
"0.5858314",
"0.5840221",
"0.580385",
"0.5725794",
"0.5686409",
"0.5641364",
"0.56244683",
"0.5608649",
"0.55820984",
"0.5533073",
"0.5533073",
"0.5516132",
"0.5502403",
"0.5439248",
"0.54391897"... | 0.7470482 | 0 |
Returns a path to the spec or resources file, or None if there isn't any. | def get_path(self, name):
for col in [self.specs, self.resources]:
if name in col:
return force_absolute(col['BASE'], col[name])
raise MissingFileException(name) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_resource(filename: str, path: str | None = None) -> str:\n root = Path(__file__).parent\n full_path = root if path is None else root / Path(path)\n return str(full_path / filename)",
"def source_resource_path(self) -> Optional[str]:\n return pulumi.get(self, \"source_resource_path\")",
... | [
"0.68443334",
"0.68380535",
"0.6713034",
"0.66187924",
"0.65891606",
"0.6541039",
"0.6467703",
"0.64296913",
"0.6378949",
"0.63331485",
"0.63191414",
"0.63191414",
"0.63191414",
"0.6309162",
"0.63026977",
"0.6249998",
"0.6202229",
"0.6180328",
"0.6180328",
"0.6180328",
"0.618... | 0.607958 | 32 |
Parse the install.xml resources and extract paths to available resource files. | def find_resources(self):
path = self.get_path('resources')
if not path:
rsoup = self.soup
else:
rsoup = BeautifulSoup(open(path))
self.parse_resources(rsoup) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_resources(self, soup):\n for res in soup.find_all('res'):\n if 'customlangpack' in res['id'].lower():\n self.find_langpack_path(res)\n else:\n rid = remove_xml(res['id'])\n self.resources[rid] = path_format(self.properties.substitu... | [
"0.6525635",
"0.6458453",
"0.6247702",
"0.6149706",
"0.5675304",
"0.5485798",
"0.54253304",
"0.5365386",
"0.53127724",
"0.5307869",
"0.5268524",
"0.52580196",
"0.5257995",
"0.524883",
"0.51688087",
"0.51635474",
"0.5150724",
"0.5131621",
"0.5084626",
"0.50781643",
"0.50696945... | 0.61680824 | 3 |
Parse the install.xml (or resources.xml) soup to find all available resources. | def parse_resources(self, soup):
for res in soup.find_all('res'):
if 'customlangpack' in res['id'].lower():
self.find_langpack_path(res)
else:
rid = remove_xml(res['id'])
self.resources[rid] = path_format(self.properties.substitute(res['src... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_resources(self):\n path = self.get_path('resources')\n\n if not path:\n rsoup = self.soup\n else:\n rsoup = BeautifulSoup(open(path))\n\n self.parse_resources(rsoup)",
"def parse_paths(self):\n self.soup = BeautifulSoup(open(self.get_path('install... | [
"0.7189946",
"0.59733474",
"0.5380635",
"0.53306276",
"0.52788985",
"0.5263637",
"0.5235712",
"0.5170429",
"0.5113374",
"0.50949967",
"0.5075004",
"0.50734943",
"0.5058489",
"0.5009926",
"0.4998898",
"0.4996702",
"0.4971879",
"0.49711636",
"0.49570197",
"0.49357328",
"0.49281... | 0.66038096 | 1 |
Finds a langpack path from the given xml langpack element | def find_langpack_path(self, langpack):
lid = langpack['id']
src = path_format(self.properties.substitute(langpack['src']))
if '.xml_' in lid:
self.langpacks[lid[-3:]] = src
if not 'default' in self.langpacks:
self.langpacks['default'] = src
self.reso... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_langpack_path(self, lid='default'):\n path = self.langpacks[lid]\n return force_absolute(self.res_path, path)",
"def _safe_get_element(path, root):\n elements = path.split('.')\n parent = root\n for element in elements[:-1]:\n parent = getattr(parent, element, None)\n ... | [
"0.60459447",
"0.542366",
"0.54062265",
"0.53140926",
"0.5283099",
"0.5267232",
"0.52111304",
"0.52110153",
"0.5112656",
"0.5109639",
"0.50798786",
"0.503845",
"0.5029484",
"0.5024299",
"0.50155646",
"0.50155646",
"0.5005777",
"0.49973974",
"0.49784917",
"0.49735188",
"0.4969... | 0.71990365 | 0 |
Returns the path to the langpack with the given localization id. | def get_langpack_path(self, lid='default'):
path = self.langpacks[lid]
return force_absolute(self.res_path, path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_langpack_path(self, langpack):\n lid = langpack['id']\n src = path_format(self.properties.substitute(langpack['src']))\n if '.xml_' in lid:\n self.langpacks[lid[-3:]] = src\n\n if not 'default' in self.langpacks:\n self.langpacks['default'] = src\n ... | [
"0.73198885",
"0.6105887",
"0.5961551",
"0.58504504",
"0.58083636",
"0.5787844",
"0.5782545",
"0.5768041",
"0.55205953",
"0.5518579",
"0.5518284",
"0.54572797",
"0.54148406",
"0.540771",
"0.539632",
"0.539049",
"0.5386805",
"0.5383221",
"0.5375136",
"0.5335914",
"0.53032947",... | 0.79494125 | 0 |
Removes the .xml from a resource or spec id. | def remove_xml(rid):
if '.xml' in rid[-4:]:
return rid[:-4]
else:
return rid | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self): \n self.doRoot(self.removeDir)\n settings.getChanged('mosh.resourceReplacer.applied').remove(self.file)",
"def removeID(self, doc):\n if doc is None: doc__o = None\n else: doc__o = doc._o\n ret = libxml2mod.xmlRemoveID(doc__o, self._o)\n return ret",
... | [
"0.6571621",
"0.59867907",
"0.59495574",
"0.5810718",
"0.58104086",
"0.57775265",
"0.5769766",
"0.5720916",
"0.56980383",
"0.5681628",
"0.5668962",
"0.56642413",
"0.5655876",
"0.5647954",
"0.56197345",
"0.5602799",
"0.550016",
"0.5495898",
"0.5472836",
"0.5450075",
"0.5386508... | 0.6564904 | 1 |
Ensures that the base path is not appended to an absolute path. | def force_absolute(base, path):
if os.path.abspath(path) and os.path.exists(path):
return path
else:
return path_format(base + path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _is_bad_path(path, base):\r\n return not resolved(joinpath(base, path)).startswith(base)",
"def relative_base(base):\n return as_base(base).lstrip('/')",
"def _graceful_relative_url(base_url, url):\n if url == base_url:\n return ''\n base_prefix = '%s://%s' % urlparse.urlparse(base_url o... | [
"0.6916786",
"0.67421585",
"0.66749847",
"0.64415956",
"0.64331144",
"0.6391375",
"0.634446",
"0.63375163",
"0.63358223",
"0.63287544",
"0.63265294",
"0.6256979",
"0.6243405",
"0.6241263",
"0.62288374",
"0.61725926",
"0.6163012",
"0.61393946",
"0.61246914",
"0.610019",
"0.608... | 0.8096843 | 0 |
Append a child SHETNode object to this parent. | def append_child(self, child):
self._children.append(child) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def appendChild(self, child):\n self.__initChild()\n self.__child.append(child)",
"def add_child(self, child):\r\n self.children.append(child)",
"def add_child(self, child):\n assert isinstance(child, (Node, str))\n self.children.append(child)\n return child",
"def a... | [
"0.75263894",
"0.71979386",
"0.71660924",
"0.70930797",
"0.7083536",
"0.7083536",
"0.70750386",
"0.70191234",
"0.70174617",
"0.69852936",
"0.6984658",
"0.6984658",
"0.6984658",
"0.6974553",
"0.6964133",
"0.691352",
"0.6870681",
"0.68534565",
"0.683959",
"0.6832848",
"0.682881... | 0.743963 | 1 |
Return the child object for this row. | def child(self, row):
return self._children[row] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fm_get_child(self, idx):\n return self._relation_lst[self.CHILD][idx]",
"def parent_row(self):\n dict_cur.execute('SELECT * FROM \"{}\" WHERE {} = {}'.format(\n self.parent_table(), self.id_col_of_parent(), self.parent_id\n ))\n return dict_cur.fetchone()",
"def child... | [
"0.69378644",
"0.6922745",
"0.67441875",
"0.67046505",
"0.64928705",
"0.6490793",
"0.64874583",
"0.636516",
"0.6325162",
"0.63212925",
"0.6312723",
"0.62407464",
"0.6223152",
"0.6199766",
"0.61490715",
"0.6089433",
"0.6058238",
"0.6028954",
"0.6019511",
"0.60055214",
"0.60042... | 0.7951686 | 0 |
Return the parent for this object. | def parent(self):
return self._parent | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_parent(self):\n return self.__parent",
"def get_parent(self):\n return self.__parent",
"def get_parent(self):\n return self._parent",
"def get_parent(self):\n return self.parent",
"def get_parent(self):\n return self.parent",
"def get_parent(self):\n retu... | [
"0.9200622",
"0.9200622",
"0.9199283",
"0.916468",
"0.916468",
"0.916468",
"0.91454464",
"0.91169167",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.91072214",
"0.904735",
"0.9025... | 0.9021966 | 21 |
Return the number of children for this object. | def child_count(self):
return len(self._children) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def children_count(self):\n return len(self._children_ids)",
"def get_num_children(self):\n return len(self.children)",
"def num_children(self):\r\n return len(self.children)",
"def n_children(self):\n ch = self.children\n return 0 if not ch else len(ch) + sum([c.n_children... | [
"0.90056854",
"0.89945096",
"0.8814528",
"0.84932816",
"0.8328836",
"0.820382",
"0.81602144",
"0.8130981",
"0.8113122",
"0.8032147",
"0.8006279",
"0.7992068",
"0.7951158",
"0.79241395",
"0.7880368",
"0.7846781",
"0.7826892",
"0.7825752",
"0.7825752",
"0.7813822",
"0.78123784"... | 0.90249795 | 0 |
Return the row number of this object in its parents child object list. | def row(self):
if self._parent != None:
return self._parent._children.index(self)
else:
return 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def position(self):\n # (this to be able to let the model know my 'row')\n if self.parent and self in self.parent.children:\n return self.parent.children.index(self)\n return 0",
"def get_row_count(self):\n\t\treturn self.iter_n_children(None)",
"def get_parent_index(self):\n ... | [
"0.7749123",
"0.7150035",
"0.7133484",
"0.7002957",
"0.6893562",
"0.68775827",
"0.68358344",
"0.68228674",
"0.6657135",
"0.65858424",
"0.6512793",
"0.65048885",
"0.6504525",
"0.6482687",
"0.64728826",
"0.6462298",
"0.6381234",
"0.6368826",
"0.6327531",
"0.63188356",
"0.630715... | 0.8057412 | 0 |
Return either the name of the node or the type of the node. column = 0 Node name column = 1 Node type | def data(self, column):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_node_type_name(self):\n pass",
"def _getNodeType(node): # {{{\n if node.nodeType == node.ELEMENT_NODE : return \"ELEMENT_NODE\"\n elif node.nodeType == node.ATTRIBUTE_NODE : return \"ATTRIBUTE_NODE\"\n elif node.nodeType == node.TEXT_NODE ... | [
"0.74844366",
"0.7219065",
"0.6962392",
"0.6915872",
"0.69109935",
"0.68993855",
"0.68213034",
"0.67636293",
"0.67303824",
"0.6608851",
"0.65244263",
"0.6468702",
"0.64218444",
"0.6386568",
"0.6383737",
"0.631373",
"0.6278558",
"0.625848",
"0.6188647",
"0.61741495",
"0.604731... | 0.0 | -1 |
Return the icon for this node type. | def get_icon(self):
return QIcon() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def icon(self):\n if \"icon\" in self._typeconf:\n return self._typeconf[\"icon\"]",
"def icon(self) -> str:\n return self._icon",
"def icon(self) -> str:\n return self._icon",
"def icon(self) -> str:\n return self._icon",
"def icon(self) -> str | None:\n retur... | [
"0.85799116",
"0.839415",
"0.839415",
"0.839415",
"0.83772486",
"0.833063",
"0.83136874",
"0.83136874",
"0.83030766",
"0.82950103",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.82862633",
"0.8... | 0.72396433 | 81 |
List all registered users | def get(self):
return get_all_users() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_all_users():",
"def all_users():\n\n users = crud.get_users()\n\n return render_template('all_users.html', users=users)",
"def user_list(ctx):\n data = ctx.obj.get_all_users()\n output_json_data(data)",
"def list_users(self):\n raise NotImplementedError",
"def list_users():\n ... | [
"0.81718403",
"0.8096765",
"0.80531436",
"0.80079234",
"0.79894656",
"0.79580796",
"0.78869665",
"0.78769445",
"0.7870435",
"0.7852773",
"0.7852773",
"0.7852773",
"0.7852773",
"0.7852773",
"0.7852773",
"0.78296953",
"0.78264874",
"0.77799135",
"0.7775502",
"0.77415365",
"0.77... | 0.74711365 | 43 |
Creates a new User | def post(self):
data = request.json
return save_new_user(data=data) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_user(self, **kwargs):\n\n user = self.user_model(**self._prepare_create_user_args(**kwargs))\n return self.put(user)",
"def create_user():\n record = request.get_json()\n if record is None:\n return {\"Error\": \"No data Supplied.\"}, 400\n\n schema = user_schema.load(rec... | [
"0.8356902",
"0.82334316",
"0.818709",
"0.81866163",
"0.81820846",
"0.8136355",
"0.81212246",
"0.8107862",
"0.810485",
"0.81023943",
"0.8095305",
"0.8065845",
"0.806039",
"0.801286",
"0.79925007",
"0.7991061",
"0.7983073",
"0.79765683",
"0.7966382",
"0.79606205",
"0.795309",
... | 0.0 | -1 |
get a user given its identifier | def get(self, no):
user = get_a_user(no)
if not user:
api.abort(404)
else:
return user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_user(id):\n pass",
"def get_user_from_id(user_id):\n return Users.query.filter_by(id=user_id).first()",
"def get_user_by_id(self, id):\n\t\treturn self.users.get(id)",
"def get_user_by_id(user_id):\n return User.query.get(user_id)",
"def get_user():\n try:\n userId = request.... | [
"0.86616516",
"0.81289124",
"0.7963865",
"0.7956894",
"0.7897557",
"0.78906107",
"0.7883696",
"0.786984",
"0.78655744",
"0.78536576",
"0.78536576",
"0.78536576",
"0.78536576",
"0.77602255",
"0.77237105",
"0.77002823",
"0.7681181",
"0.7670162",
"0.7650683",
"0.7638847",
"0.763... | 0.75004166 | 43 |
Parse command line arguments | def parseArguments():
parser = argparse.ArgumentParser(description='Tool run benchmarks and query database')
parser.add_argument('--version', action="store_true", dest="version", default=False, help="Print version")
parser.add_argument("--query", "-q", action="store_true", dest="queryDataBase", default=Fals... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_args():\n parser = argparse.ArgumentParser(\n description=\"Reads datapacket pcds, interpolates quaternions and generates scans from dataset in config file\")\n parser.add_argument(\"--visualization\", \"-v\", action=\"store_true\", help=\"if generated clouds ... | [
"0.84956664",
"0.77526116",
"0.7492404",
"0.74425805",
"0.74166906",
"0.7415034",
"0.7406717",
"0.7405937",
"0.7394592",
"0.739314",
"0.7353777",
"0.73531276",
"0.73295814",
"0.7326098",
"0.73121136",
"0.7297962",
"0.72947985",
"0.7294619",
"0.7293887",
"0.7288054",
"0.727713... | 0.0 | -1 |
Send an API request to the URI and return the response as JSON | def get(self, api):
response = requests.get("{}/{}".format(self.NHL_URL, api),
params={'format': 'json'})
jresp = response.json()
if "error" in jresp:
raise RuntimeError(json.dumps(jresp))
return jresp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def api_call(endpoint, params, headers):\n\n api_response = get(BASE_URL.format(endpoint=endpoint), params=params,\n headers=headers)\n\n api_response.raise_for_status()\n json_resp = api_response.json()\n\n api_response.close()\n return json_resp",
"def _api_call(self, **kwa... | [
"0.7422599",
"0.7417137",
"0.7387633",
"0.72940725",
"0.72173136",
"0.71671855",
"0.7158895",
"0.7139885",
"0.7135085",
"0.7044011",
"0.6986337",
"0.6938263",
"0.6930868",
"0.6928152",
"0.6916814",
"0.6900717",
"0.6863039",
"0.6863039",
"0.68534124",
"0.6803363",
"0.6768796",... | 0.0 | -1 |
Returns a count of games for each team between a range of dates. The range of dates is inclusive. The result is a dictionary, where the key is a team ID and the values is the number of games played within the date range. | def games_count(self, start_date, end_date): # noqa
if start_date > end_date:
raise RuntimeError("End date must be beyond start")
cur_date = start_date
tot_gc = defaultdict(int)
while cur_date <= end_date:
teams_playing = self._teams_playing_one_day(cur_date)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def collect_stats(games: List[BaseGame], date_min = None, date_max = None):\n if not games: games = self.games\n\n under2_5 = len(list(filter(lambda g: g.is_total_under(), games)))\n under3_5 = len(list(filter(lambda g: g.is_total_under(3.5), games)))\n under1_5 = len(list(filter(lambda... | [
"0.66655016",
"0.6575532",
"0.6239661",
"0.60753345",
"0.5819676",
"0.56853807",
"0.56271034",
"0.5605924",
"0.552719",
"0.5430894",
"0.5406802",
"0.5393699",
"0.53550273",
"0.5331798",
"0.52389354",
"0.5208741",
"0.5198225",
"0.51977944",
"0.5194764",
"0.51899004",
"0.51551"... | 0.77764916 | 0 |
Returns the full list of all players in the NHL. Each player is returned with their teamID and playerID. | def players(self):
if self.players_cache is None:
team_df = self.teams()
self.players_cache = self.ea.players_endpoint(
team_df["id"].tolist())
columns = ["teamId", "playerId", "name", "position"]
all_players = []
for team in self.players_cache["t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_players(team_id: int) -> list[Player]:\n\n players = Player.query.filter_by(team_id=team_id).order_by(Player.position.asc()).all()\n\n return players",
"async def get_players(self):\r\n if os.environ.get(\"WoW_Token\") is None:\r\n return\r\n else:\r\n async with... | [
"0.73543996",
"0.7350862",
"0.7326979",
"0.7267568",
"0.7178544",
"0.71210647",
"0.7101303",
"0.7095917",
"0.70638573",
"0.70361084",
"0.70209825",
"0.695598",
"0.69269913",
"0.68729657",
"0.6858013",
"0.68501425",
"0.6834751",
"0.6827907",
"0.68150014",
"0.68046874",
"0.6801... | 0.77101475 | 0 |
Returns URL to redirect to from the ``next`` param in the request. | def next_url(request):
next = request.REQUEST.get("next", "")
host = request.get_host()
return next if next and is_safe_url(next, host=host) else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_redirect_url(self, *args, **kwargs):\n return get_login_url(self.request, self.request.GET.get('next'))",
"def get_redirect_url(request):\n next = request.POST.get('next', request.GET.get('next'))\n if not is_safe_url(url=next, host=request.get_host()):\n next = request.META.get('HTTP... | [
"0.83204603",
"0.83197",
"0.7689727",
"0.7661551",
"0.7638349",
"0.76374096",
"0.7544939",
"0.75045264",
"0.73248774",
"0.7298591",
"0.72670794",
"0.7144886",
"0.68980455",
"0.67974",
"0.66958416",
"0.6675485",
"0.66591203",
"0.6639384",
"0.6530356",
"0.6400732",
"0.6353697",... | 0.82515216 | 2 |
Returns a dict of all exporters available in this module. | def exporters():
return dict(_exporters) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_exported_services(self):\n with self.__export_lock:\n return [reg.get_export_reference() for reg in self.__exported_regs]",
"def modules(self):\n return self._modules.keys()",
"def export(self) -> Dict[str, Any]:\n return {\n \"name\": self.name,\n \"ch... | [
"0.67320096",
"0.671589",
"0.6693358",
"0.65067416",
"0.65005225",
"0.6418204",
"0.6391994",
"0.61761796",
"0.61683196",
"0.6134161",
"0.6020214",
"0.60188884",
"0.60087794",
"0.6007217",
"0.59965616",
"0.5981217",
"0.5973341",
"0.5953239",
"0.59515285",
"0.59218055",
"0.5913... | 0.8974469 | 0 |
Returns a dict of all expression writers available in this module. | def ewriters():
return dict(_ewriters) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exporters():\n return dict(_exporters)",
"def loggers() -> Dict[str, logging.Logger]:\n return dict(logging.root.manager.loggerDict) # type: ignore",
"def _getWriters(reactor):\n if IReactorFDSet.providedBy(reactor):\n return reactor.getWriters()\n elif \"IOCP\" in reactor.__class__.__n... | [
"0.60313106",
"0.5901297",
"0.5880711",
"0.58622074",
"0.58196956",
"0.5742172",
"0.56615275",
"0.5657879",
"0.5596137",
"0.55732113",
"0.5545482",
"0.5508399",
"0.5503588",
"0.5474215",
"0.5455626",
"0.54393846",
"0.54258674",
"0.5408531",
"0.53520226",
"0.53115875",
"0.5309... | 0.5967789 | 1 |
Helper method that implements the logic to look up an application. | def get_app(self, reference_app=None):
if reference_app is not None:
return reference_app
if current_app:
return current_app
if self.app is not None:
return self.app
raise RuntimeError('CacheDB: Application not registered on db instance and no applicat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_app(app, symbol_by_name=..., imp=...):\n ...",
"def get_application(handle):\n\n if handle in applications:\n return applications.get(handle)\n raise KeyError(\"Application with handle '%s' not registered\" % handle)",
"def test_get_application(self):\n from supvisors.rpcinterfa... | [
"0.76504076",
"0.7343031",
"0.7199703",
"0.6993979",
"0.6919488",
"0.6867285",
"0.6855719",
"0.68179643",
"0.6812087",
"0.6794836",
"0.678283",
"0.6750141",
"0.67416745",
"0.66992825",
"0.6693951",
"0.66593003",
"0.6654224",
"0.66125464",
"0.66099894",
"0.65840536",
"0.655603... | 0.6288743 | 35 |
generates all prime numbers smaller than _n_ using the Sieve of Eratosthenes | def primes(n):
sieve = [True]*n
for p in range(2, n):
if sieve[p]:
yield p
for i in range(p*p, n, p):
sieve[i] = False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def primes(n):\n\tsieve = [True] * n\n\tyield 2\n\tfor i in xrange(3,int(n**0.5)+1,2):\n\t\tif sieve[i]:\n\t\t\tyield i\n\t\t\tsieve[i*i::2*i] = [False]*((n-i*i-1)/(2*i)+1)\n\tfor i in xrange(i+2,n,2):\n\t\tif sieve[i]: yield i",
"def eratosthenes_sieve(n):\r\n\tnumbers = [True for i in range(n + 1)]\r\n\t\r\n\t... | [
"0.84180295",
"0.8417532",
"0.82622313",
"0.82567656",
"0.82486343",
"0.82486343",
"0.8190478",
"0.818247",
"0.8172363",
"0.81599665",
"0.81357145",
"0.8119539",
"0.8106137",
"0.8075972",
"0.8052299",
"0.8046388",
"0.80405337",
"0.8021724",
"0.8011649",
"0.8010728",
"0.800634... | 0.8424956 | 0 |
Check if the given sequence is a Fibonacci sequence. Fibonacci sequence is assumed to have length > 2. | def check_fibonacci(data: Sequence[int]) -> bool:
if len(data) < 3:
return False
if data[0] != 0 or data[1] != 1:
return False
for n in range(2, len(data)):
if data[n] != data[n - 1] + data[n - 2]:
return False
return True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_fibonacci(data: Sequence[int]) -> bool:\n def fib_gen(n: int) -> Iterable:\n a, b = 0, 1\n while a <= n:\n yield a\n a, b = b, a + b\n\n last_el = data[-1]\n perfect_fib = list(el for el in fib_gen(last_el))\n\n if len(data) < 3:\n return False\n ... | [
"0.7771214",
"0.7764462",
"0.7430969",
"0.7402631",
"0.70261985",
"0.68094856",
"0.67896724",
"0.65808904",
"0.6365835",
"0.63628143",
"0.632067",
"0.62956697",
"0.6284243",
"0.62702245",
"0.625835",
"0.6245525",
"0.61474824",
"0.6098934",
"0.6074185",
"0.60714906",
"0.602317... | 0.81119895 | 0 |
return the first n bits of fractional part of float f | def frac_bin(f, n=32):
f -= math.floor(f) # get only the fractional part
f *= 2**n # shift left
f = int(f) # truncate the rest of the fractional content
return f | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_mask_i_float(i, n):\n range_n = arange(cast(array(n), int32))\n i_float = cast(array(i), int32)\n mask_i = equal(range_n, i_float)\n mask_i_float = cast(mask_i, float32)\n return mask_i_float",
"def fpart(x):\n return x - np.floor(x)",
"def fpart(x):\n return x - math.floor(x)"... | [
"0.6895186",
"0.6649497",
"0.66047823",
"0.627372",
"0.6265717",
"0.61318606",
"0.6037289",
"0.6027234",
"0.60202575",
"0.60193044",
"0.59969354",
"0.5991846",
"0.59733486",
"0.59640974",
"0.5958672",
"0.59521466",
"0.5927512",
"0.5888159",
"0.58834416",
"0.58711225",
"0.5788... | 0.7696176 | 0 |
Processes options from the command line. | def command_line (args: Iterable [str], program: str = 'toystrip') -> Options:
parser = argparse.ArgumentParser (prog=program, description='Strip fragment bodies from a Toy program repository.')
parser.add_argument ('-i', '--input', nargs='?', default='repo.yaml',
help='the path of the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_options(self):\n\n argv = sys.argv\n\n # process any optlist_ options\n self.valid_opts.check_special_opts(argv)\n\n # process terminal options without the option_list interface\n # (so that errors are not reported)\n\n # if no arguments are given, do default processing\n ... | [
"0.7470507",
"0.73331",
"0.7307183",
"0.7284981",
"0.7284207",
"0.7283357",
"0.727826",
"0.7129506",
"0.7059957",
"0.702482",
"0.7008134",
"0.6971482",
"0.6954829",
"0.694842",
"0.69375587",
"0.69160885",
"0.6883534",
"0.68250364",
"0.6820386",
"0.6808777",
"0.6788847",
"0.... | 0.0 | -1 |
A helper function for 2D rotations. | def rotate(points, angle):
ca = np.cos(angle*pi/180)
sa = np.sin(angle*pi/180)
R = np.array([[ca, -sa], [sa, ca]]) # positive is CCW
R.shape += (1,) # add dim for broadcasting over n points
points = points.T
points.shape = (1,) + points.shape # 1x2xn
points = (R*points).sum(axis=1).T # d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getEllipsYZRotMatrix(a1, a2):\n adir = a2 - a1\n amid = a1 + 0.5 * adir\n kath = np.sqrt((adir[0] * adir[0] + adir[1] * adir[1]) / 4.0)\n octantA2 = octant(a2)\n theta = np.arctan( abs( (adir[2]/2) / kath) )\n #[1, 4, 6, 7 ] => left rotation\n #[2, 3, 5, 8 ] => right rotation\n if oct... | [
"0.67545587",
"0.67527825",
"0.667054",
"0.6549296",
"0.6538852",
"0.65088505",
"0.6380749",
"0.6361178",
"0.635002",
"0.63448316",
"0.63114065",
"0.629315",
"0.6288181",
"0.6284019",
"0.62703216",
"0.6244028",
"0.61983275",
"0.6178014",
"0.61679846",
"0.61626464",
"0.6139964... | 0.0 | -1 |
construct positive tgt sample and negative tgt sample which is a random version of the positive one | def tgt_samples(self, params):
def save_json(save_path, file_id, samples):
init_logger()
for i, sample in enumerate(samples):
save_ = os.path.join(save_path, "{:s}_{:d}.json".format(file_id, i))
with open(save_, 'w') as file:
json... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _sample_neg(self, assign_result, num_expected, **kwargs):\n neg_inds = torch.nonzero(assign_result.gt_inds == 0)\n if neg_inds.numel() != 0:\n neg_inds = neg_inds.squeeze(1)\n if len(neg_inds) <= num_expected:\n repeat_ = num_expected // neg_inds.numel()\n ... | [
"0.6897532",
"0.664779",
"0.65409416",
"0.6332981",
"0.63276327",
"0.62545764",
"0.62370294",
"0.62344706",
"0.6191355",
"0.61533237",
"0.61114484",
"0.6094475",
"0.6094475",
"0.6068479",
"0.6061773",
"0.6030603",
"0.6010253",
"0.6003246",
"0.6001415",
"0.5956334",
"0.5956334... | 0.0 | -1 |
Preprocesses the given bitext by removing empty lines, sentence pairs in incorrect languages, sentences above a the specified length threshold, and sentence pair exceeding the specified length ratio. | def preprocess_bitext(src_path, tgt_path, src_lang, tgt_lang, max_len, max_len_ratio):
# Generate output paths
src_out_path = '.'.join(src_path.split('.')[:-1]) + '.clean.{:s}'.format(src_lang)
tgt_out_path = '.'.join(tgt_path.split('.')[:-1]) + '.clean.{:s}'.format(tgt_lang)
# Open aligned corpora
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(text):\n text = remove_space(text)\n text = clean_special_punctuations(text)\n text = handle_emojis(text)\n text = clean_number(text)\n text = spacing_punctuation(text)\n text = clean_repeat_words(text)\n text = remove_space(text)\n #text = stop(text)# if changing this, then ... | [
"0.5930999",
"0.56018895",
"0.54720354",
"0.54013246",
"0.5385498",
"0.53538865",
"0.5309747",
"0.5302773",
"0.530155",
"0.5279971",
"0.5275908",
"0.52461535",
"0.5241778",
"0.523378",
"0.5210483",
"0.5210375",
"0.52024615",
"0.51972234",
"0.51928794",
"0.51886725",
"0.518412... | 0.6658864 | 0 |
Generate QSO templates for DESI Rebins to input wavelength array (or log10 in wvmnx) | def desi_qso_templates(z_wind=0.2, zmnx=(0.4,4.), outfil=None, N_perz=500,
boss_pca_fil=None, wvmnx=(3500., 10000.),
rebin_wave=None, rstate=None,
sdss_pca_fil=None, no_write=False, redshift=None,
seed=None, old_read=False, ipad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n std_template_file = os.path.join(os.environ['HOME'], 'prospect/py/prospect/data/std_templates.fits')\n if os.path.isfile(std_template_file):\n print('Error std template file already exists')\n\n #- Templates produced from 1st component of old (pre-Aug 2022) Redrock templates:\n tem... | [
"0.63988525",
"0.61624724",
"0.6049136",
"0.6009026",
"0.5754354",
"0.5714916",
"0.5675985",
"0.5639088",
"0.5584253",
"0.5570435",
"0.55066645",
"0.5493375",
"0.54839",
"0.5475753",
"0.54349035",
"0.53918606",
"0.5388889",
"0.53888744",
"0.537513",
"0.5362154",
"0.5355699",
... | 0.5666829 | 7 |
Repackage the coefficients and redshifts into a single FITS file | def repackage_coeff(boss_pca_fil=None, sdss_pca_fil=None,
outfil='qso_templates_v2.0.fits'):
# PCA values
if boss_pca_fil is None:
boss_pca_fil = 'BOSS_DR10Lya_PCA_values_nocut.fits.gz'
hdu = fits.open(boss_pca_fil)
boss_pca_coeff = hdu[1].data
if sdss_pca_fil is None:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_as_fits(self, filename):",
"def reassemble(file, save=False):\n # Open the FITS file\n hdulist = fits.open(file, mode='update')\n filename = os.path.basename(file).replace('.fits', '')\n directory = os.path.join(os.path.dirname(file), filename + '_data')\n\n # Large file\n if os.path.i... | [
"0.59937274",
"0.58742166",
"0.5733586",
"0.5678403",
"0.5589093",
"0.5542352",
"0.55127305",
"0.547598",
"0.53778374",
"0.5374953",
"0.53529",
"0.535201",
"0.53475887",
"0.5272805",
"0.5256761",
"0.5191057",
"0.5183628",
"0.5168582",
"0.5159844",
"0.5153219",
"0.5136804",
... | 0.5787115 | 2 |
Generate a small set of random templates for testing | def tst_random_set():
final_wave, final_spec, final_z = desi_qso_templates(
outfil='test_random_set.fits', N_perz=100, seed=12345) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_multi_template():\n data = []\n data.extend([\"{}_data.json\".format(i) for i in range(50)])\n data.extend([\"{}_log.csv\".format(i) for i in range(50)])\n data.extend([\"filename_{}.py\".format(i) for i in range(50)])\n data.extend([\"stuff_{}.py\".format(i) for i in range(50)])\n temp ... | [
"0.72083974",
"0.63701993",
"0.6368686",
"0.6321199",
"0.62644243",
"0.6257337",
"0.6201381",
"0.617634",
"0.6142078",
"0.6015824",
"0.6010889",
"0.59950966",
"0.5977103",
"0.597154",
"0.5879443",
"0.5858846",
"0.5847928",
"0.583918",
"0.5821612",
"0.58189946",
"0.58071667",
... | 0.6923423 | 1 |
initialize restaurant name and cuisine type attributes and sets number served attribute to a default value 0 | def __init__(self, restaurant_name, cuisine_type):
self.restaurant_name = restaurant_name
self.cuisine_type = cuisine_type
self.number_served = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, restaurant_name, cuisine_type):\n self.restaurant_name = restaurant_name\n self.cuisine_type = cuisine_type\n self.number_served = 0",
"def __init__(self, restaurant_name, cuisine_type):\n self.restaurant_name = restaurant_name\n self.cuisine_ty... | [
"0.8314235",
"0.8282508",
"0.8282508",
"0.82709175",
"0.82709175",
"0.8264752",
"0.8071585",
"0.7439493",
"0.7387792",
"0.7319224",
"0.7265492",
"0.7265492",
"0.7265492",
"0.71875435",
"0.71698016",
"0.71122634",
"0.6878828",
"0.684674",
"0.68462706",
"0.6834815",
"0.676543",... | 0.83117634 | 2 |
describes a restaurant by its name and cuisine type | def describe_restaurant(self):
print(f"{self.restaurant_name.title()} serves {self.cuisine_type}.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def describe_restaurant(self):\n\t\tprint(\"name of the restaurant is \" + self.restaurant_name)\n\t\tprint(\"cuisine type is \" + self.cuisine_type)",
"def describeRestaurant(self):\n print (f\"{self.name} has the best {self.cuisineType}\")",
"def describe_restaurant(self):\n\t\tdetails = f\"{self.rest... | [
"0.82693654",
"0.82492495",
"0.82483953",
"0.8167286",
"0.8106043",
"0.8073259",
"0.8036618",
"0.78226703",
"0.78043205",
"0.78036106",
"0.752929",
"0.7442119",
"0.74197125",
"0.7419168",
"0.74157757",
"0.73562765",
"0.7146399",
"0.70746666",
"0.70746666",
"0.7027343",
"0.702... | 0.823461 | 3 |
Prints a message that the restaurant is open. | def open_restaurant(self):
print(f"The restaurant is open.") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def open_restaurant(self):\n msg = f\"{self.name} is open. Come on in!\"\n print(f\"\\n{msg}\")",
"def open_restaurant(self):\n\t\topen = f\"{self.restaurant_name} is now open.\"\n\t\tprint(f\"\\n{open}\")",
"def open_restaurant(self):\r\n\t\tprint(self.restaurant_name.title() + \" is open\")",
... | [
"0.84129494",
"0.83964026",
"0.83871007",
"0.8371406",
"0.8318077",
"0.8231593",
"0.8231593",
"0.8231593",
"0.8207684",
"0.8207684",
"0.8207684",
"0.8207684",
"0.81987953",
"0.81586903",
"0.8079485",
"0.80655825",
"0.7935586",
"0.7746546",
"0.7586863",
"0.7568593",
"0.6807336... | 0.8771324 | 0 |
Remove duplicates in a 2D list. | def remove_dupl_2d(arr):
arr_len = len(arr)
idx = 0
unique = set()
while idx < arr_len:
if tuple(arr[idx]) in unique:
del arr[idx]
arr_len -= 1
continue
unique.add(tuple(arr[idx]))
idx += 1
return arr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unique_elements_from_2D_list(list_2d):\n return list(set(flatten_2D_list(list_2d)))",
"def remove_duplicates(list):\n x = 0\n while x < len(list):\n y = x + 1\n while y < len(list):\n if list[x] == list[y]:\n del list[y]\n else:\n y +... | [
"0.77904236",
"0.7317339",
"0.7272788",
"0.70233446",
"0.6959906",
"0.6949109",
"0.69180614",
"0.6898379",
"0.6891898",
"0.6872626",
"0.686393",
"0.68368906",
"0.6829106",
"0.6820149",
"0.6818071",
"0.6759585",
"0.6757643",
"0.66838396",
"0.66789544",
"0.66774946",
"0.6656065... | 0.75136393 | 1 |
Return comparison operators from strings. | def ops(rule):
ops_dict = {'>' : operator.gt,
'<' : operator.lt,
'>=': operator.ge,
'<=': operator.le,
'=' : operator.eq,
'==' : operator.eq}
return ops_dict[rule] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def str_to_operator(s):\n return {\n # https://docs.python.org/3/library/operator.html#mapping-operators-to-functions\n \"<\": operator.lt,\n \"<=\": operator.le,\n \"==\": operator.eq,\n \"!=\": operator.ne,\n \">=\": operator.ge,\n \">\": operator.gt,\n }[s]... | [
"0.78497833",
"0.6872431",
"0.6471799",
"0.6461164",
"0.6423107",
"0.6388608",
"0.62490875",
"0.62442315",
"0.621637",
"0.6206094",
"0.6175508",
"0.61468226",
"0.613907",
"0.6055677",
"0.6053246",
"0.6050973",
"0.59804946",
"0.594457",
"0.5933758",
"0.59236586",
"0.5913188",
... | 0.6017789 | 16 |
Initialise verboseprint() if verbose to a specific nvfunc or print, else to no printing. | def init_verbose_print(verbose=True, vfunc=print, nvfunc=None):
global verboseprint
if verbose:
verboseprint = vfunc
else:
if not nvfunc:
verboseprint = lambda *a, **k: None
else:
verboseprint = nvfunc
return verboseprint | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verbose_print(verbose, print_function=None):\n\n if verbose:\n return print_function or print\n else:\n def vprint(*args, **kwars):\n pass\n return vprint",
"def set_verboseprint(func=misc.init_verbose_print(verbose=True, vfunc=print, nvfunc=misc.log)):\n global verbo... | [
"0.7538737",
"0.7518328",
"0.6643926",
"0.66073173",
"0.6594862",
"0.65729207",
"0.65286297",
"0.63692355",
"0.6299959",
"0.629843",
"0.6282386",
"0.6246638",
"0.612347",
"0.6121666",
"0.6113824",
"0.6102391",
"0.6084847",
"0.598136",
"0.59381145",
"0.5932641",
"0.5875921",
... | 0.8172151 | 0 |
Create directory dir_path if it does not exist. | def create_dir(dir_path):
validate.check_python_ver(ver=3.5)
from pathlib import Path
Path(dir_path).mkdir(parents=True, exist_ok=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dir_if_doesnt_exist(dir_path):\n if not os.path.exists(dir_path):\n os.makedirs(dir_path)\n return",
"def create_directory(dir_path):\r\n if not os.path.exists(dir_path):\r\n os.makedirs(dir_path, exist_ok=True)",
"def create_dir(dir_path):\n if not os.path.exists(d... | [
"0.86574495",
"0.84062487",
"0.8376306",
"0.83313924",
"0.8270023",
"0.82542133",
"0.8220174",
"0.81615025",
"0.814925",
"0.80941194",
"0.8093426",
"0.8077159",
"0.8055836",
"0.8017316",
"0.8007193",
"0.7989146",
"0.796331",
"0.7937054",
"0.790511",
"0.78983074",
"0.7885585",... | 0.7973728 | 16 |
returns the sum of the proper divisors of a number n. | def d(n):
rt = math.sqrt(n)
i = 2
result = 1
while i < rt:
if n % i == 0:
result += i
result += n // i
i += 1
# i == rt implies that n is a square number
if i == rt and n % i == 0:
result += i
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sum_of_proper_divisors(n):\n\n\tpd = find_divisors(n)\n\n\treturn sum(pd)",
"def sum_proper_divisors(n):\r\n return sum(proper_divisors(n))",
"def sum_divisors(n):\r\n return sum(proper_divisors(n)) + n",
"def d(n):\n divisors = []\n for i in range(1, n):\n if n % i == 0:\n divisors.appen... | [
"0.9230572",
"0.9063063",
"0.8890579",
"0.8401838",
"0.8237709",
"0.81488013",
"0.80824167",
"0.7931736",
"0.7893",
"0.7875711",
"0.7867992",
"0.78603905",
"0.7837132",
"0.77953523",
"0.7753415",
"0.7628213",
"0.7583701",
"0.75809145",
"0.75312734",
"0.7483885",
"0.74810076",... | 0.7149193 | 39 |
Returns a list of all abundant numbers less than an upper limit | def getAbundantNumbers(upperLimit):
result = []
for i in range(1, upperLimit):
if d(i) > i:
result.append(i)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def solution(limit=28123):\n sum_divs = [1] * (limit + 1)\n\n for i in range(2, int(limit**0.5) + 1):\n sum_divs[i * i] += i\n for k in range(i + 1, limit // i + 1):\n sum_divs[k * i] += k + i\n\n abundants = set()\n res = 0\n\n for n in range(1, limit + 1):\n if sum_... | [
"0.6772986",
"0.65578127",
"0.6472297",
"0.6274483",
"0.61667085",
"0.6099296",
"0.6032808",
"0.6027965",
"0.5983113",
"0.59658635",
"0.59558725",
"0.5935221",
"0.5906062",
"0.58387524",
"0.5832162",
"0.5813864",
"0.58016706",
"0.579645",
"0.57799524",
"0.57706046",
"0.576062... | 0.8741688 | 0 |
Returns true iff the number n can be written as the sum of two abundant numbers. | def canBeWritten(n):
for a in abundantNumbersList:
if a >= n: break
if (n - a) in abundantNumbersSet:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_abundant(n):\r\n if sum_proper_divisors(n) > n:\r\n return True\r\n else:\r\n return False",
"def isAbundant(n):\n\treturn sumProperDivisors(n, PRIMES) > n",
"def is_abundant(num: int) -> bool:\n return sum(divisors(num)) - num > num",
"def is_abundant(n: int, print_div: bool = ... | [
"0.7858181",
"0.76310307",
"0.7264005",
"0.7210944",
"0.68021965",
"0.6637436",
"0.6592846",
"0.6582656",
"0.6508782",
"0.64454526",
"0.63586575",
"0.63261133",
"0.6279456",
"0.623999",
"0.62178534",
"0.616031",
"0.61566705",
"0.61406416",
"0.61299574",
"0.6128495",
"0.611129... | 0.7694291 | 1 |
Get information on existing groups | def get_all(isamAppliance, check_mode=False, force=False):
return isamAppliance.invoke_get("Retrieving groups", "/sysaccount/groups/v1") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_groups_details(self, groups):\n assert isinstance(groups, list)\n # It may be require we request the API by splitting the names list\n # If the list is too long to be handled by the Gerrit server (URI)\n query_args = \"?%s\" % \"&\".join([\"q=%s\" % g for g in groups])\n ... | [
"0.77337617",
"0.7699671",
"0.7469322",
"0.73761415",
"0.73761415",
"0.7320174",
"0.7300221",
"0.7300221",
"0.72716445",
"0.72584856",
"0.71400124",
"0.7080925",
"0.705979",
"0.7046742",
"0.7038761",
"0.7034169",
"0.7026396",
"0.7013527",
"0.69954467",
"0.69342196",
"0.690011... | 0.0 | -1 |
Get information on particular group by id | def get(isamAppliance, id, check_mode=False, force=False):
return isamAppliance.invoke_get("Retrieving group", "/sysaccount/groups/{0}/v1".format(id)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_group_details(self, group_id):\n url = self.groups_url + \"/\" + group_id\n return requests.get(url, headers=self.headers)",
"def test_groups_group_id_get(self):\n pass",
"def groups_by_id(request, gid):\r\n group = Group()\r\n filtered_groups = group.query({\"gid\":str(gid)}... | [
"0.7361329",
"0.7319719",
"0.72981286",
"0.72602093",
"0.7082582",
"0.69680196",
"0.6961489",
"0.69496065",
"0.6938957",
"0.69266856",
"0.68284786",
"0.67854506",
"0.675372",
"0.6691113",
"0.6670034",
"0.6615766",
"0.6612242",
"0.6554502",
"0.6540729",
"0.64619184",
"0.645098... | 0.6288713 | 31 |
Create a new group | def create(isamAppliance, id, check_mode=False, force=False):
if force is True or _check(isamAppliance, id=id) is False:
if check_mode is True:
return isamAppliance.create_return_object(changed=True)
else:
return isamAppliance.invoke_post("Creating group", "/sysaccount/groups... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_create_group(self):\n pass",
"def test_create_group(self):\n pass",
"def test_create_group(self):\n groupid = 'villains'\n\n # create the group\n resp = self.app.post('/groups', data=json.dumps({'name':groupid}))\n assert resp.status_code == 200\n\n # F... | [
"0.815556",
"0.815556",
"0.80986136",
"0.8067711",
"0.8020423",
"0.7923718",
"0.78320086",
"0.77860224",
"0.77714515",
"0.77649784",
"0.7745107",
"0.77115846",
"0.77047557",
"0.76685154",
"0.7644153",
"0.7617915",
"0.7598676",
"0.7593983",
"0.75932276",
"0.7545795",
"0.753286... | 0.6656752 | 95 |
Check if the last created group has the exact same id or id exists | def _check(isamAppliance, id=None):
ret_obj = get_all(isamAppliance)
if id != None:
for groups in ret_obj['data']:
if groups['id'] == id:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_uuid(self, obj, groupid):\n if self.get_uuid(obj) == groupid:\n return True",
"def check_insert_group_user(self, id_user:int, id_group:int) -> bool:\n try:\n value_list = self.cursor.execute(f\"SELECT * FROM {table_user_group_connect} WHERE id_user={id_user} AND id_g... | [
"0.6570774",
"0.6442853",
"0.6362174",
"0.6342777",
"0.63284546",
"0.62991196",
"0.6206621",
"0.6137091",
"0.6101102",
"0.6100525",
"0.60978",
"0.60718405",
"0.6065793",
"0.60605556",
"0.60003704",
"0.59999543",
"0.59341437",
"0.5921304",
"0.5915208",
"0.59089285",
"0.5907399... | 0.0 | -1 |
Compare the list of groups between two appliances | def compare(isamAppliance1, isamAppliance2):
ret_obj1 = get_all(isamAppliance1)
ret_obj2 = get_all(isamAppliance2)
return ibmsecurity.utilities.tools.json_compare(ret_obj1, ret_obj2) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_groups(self):\n group0 = self.test_save('TestGroup0')\n group1 = self.test_save('TestGroup1')\n \n group0.grant('Perm1', object0)\n group0.grant('Perm3', object1)\n group1.grant('Perm2', object1)\n \n self.assert_(group0 in get_groups(object0))\n... | [
"0.64160657",
"0.63160855",
"0.628175",
"0.62237453",
"0.61753273",
"0.61753273",
"0.61045057",
"0.60945976",
"0.5951745",
"0.5942494",
"0.5942494",
"0.5940178",
"0.59220314",
"0.5886079",
"0.5881222",
"0.5855865",
"0.58520585",
"0.58456254",
"0.5836837",
"0.58087313",
"0.573... | 0.6151799 | 6 |
Serves starting point for the customer app. | def home():
return render_template('customer.html') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def startapp():",
"def startUp(self):\n pass",
"def start_deployment(self):\n return",
"def start():\r\n\r\n userName = userLogin.login()\r\n runApp(userName)",
"def startup(self):\n pass",
"def start():\n # Import any local level utilities that may be used\n # be... | [
"0.6639027",
"0.6373469",
"0.6251696",
"0.62194455",
"0.62177706",
"0.6122557",
"0.6084569",
"0.6079541",
"0.60736877",
"0.60678446",
"0.60678446",
"0.60678446",
"0.60678446",
"0.60678446",
"0.60678446",
"0.60678446",
"0.60678446",
"0.60596323",
"0.60596323",
"0.6020635",
"0.... | 0.5785409 | 37 |
For making a new request for ride. | def ride():
from services import taxi_service
customer_id = request.form['customer_id']
res = taxi_service.ride(customer_id)
return json_response(res) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_request(self, **kwargs):\n if kwargs['ride_id'] in app.database['Rides']:\n request_ids = [x for x in app.database['Requests']]\n if request_ids:\n request_id = max(request_ids) + 1\n else:\n request_id = 1\n self.new_reque... | [
"0.75216687",
"0.65378934",
"0.64955944",
"0.6391881",
"0.6327837",
"0.6260179",
"0.6085085",
"0.6083617",
"0.6060242",
"0.5994067",
"0.5968204",
"0.58465064",
"0.58400995",
"0.5741157",
"0.5677039",
"0.5617212",
"0.55390745",
"0.55201983",
"0.5494111",
"0.5423132",
"0.541637... | 0.6671646 | 1 |
Buy shares of stock | def buy():
# User reached route via GET
if request.method == "GET":
# Display quote
return render_template("buy.html")
# User reached route via POST
else:
buy_symbol = request.form.get("buy_symbol").upper()
buy_amount = float(request.form.get("buy_amount"))
q... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def buy(self, ctx, name, shares: int):\n\t\tplural = 's' if shares != 1 else ''\n\t\tcurrency = await bank.get_currency_name(ctx.guild)\n\t\tif shares < 1:\n\t\t\tawait ctx.send('You cannot buy less than one share.')\n\t\t\treturn\n\t\tname = name.upper()\n\t\ttry:\n\t\t\tstock_data = await self._get_stock_d... | [
"0.75090504",
"0.73669976",
"0.719782",
"0.7076133",
"0.702035",
"0.70142156",
"0.69631433",
"0.6943623",
"0.6915625",
"0.691014",
"0.6897359",
"0.68731195",
"0.6865242",
"0.68647367",
"0.6850216",
"0.6848369",
"0.6818854",
"0.67891747",
"0.6722476",
"0.6719868",
"0.67188966"... | 0.0 | -1 |
Show history of transactions | def history():
user_id = session["user_id"]
history_list = db.execute("SELECT symbol, price, amount, timestamp FROM stocks WHERE user_id = :user_id", user_id = user_id)
rows = len(history_list)
history = []
for row in range(rows-1, -1, -1):
history.append([history_list[row]["symbol"], hi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def history():\n transactions = db.execute(\"SELECT Symbol, Shares, Transacted FROM cash WHERE id=:id\", id=session[\"user_id\"])\n return render_template(\"history.html\", transactions=transactions)",
"def history():\n\n #Query transactions by user id\n trans = Transactions.query.filter_by(owner=ses... | [
"0.82002884",
"0.8140903",
"0.8114919",
"0.8042388",
"0.8033679",
"0.80168986",
"0.79338187",
"0.7822898",
"0.77456313",
"0.77341163",
"0.7718728",
"0.7716838",
"0.7708978",
"0.7628142",
"0.7624304",
"0.7530955",
"0.74965966",
"0.7481556",
"0.74478734",
"0.7423578",
"0.738227... | 0.7147903 | 30 |
Sell shares of stock | def sell():
# User reached route via GET
if request.method == "GET":
# Display quote
return render_template("sell.html")
# User reached route via POST
else:
sell_symbol = request.form.get("sell_symbol").upper()
sell_amount = float(request.form.get("sell_amount"))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sell_stock(self, symbol):\n amount_to_sell = self.get_equity(symbol)\n chirp.order_sell_fractional_by_price(symbol, amount_to_sell)\n self.L.add_line('', symbol, 'SOLD', amount_to_sell)",
"async def sell(self, ctx, name, shares: int):\n\t\tplural = 's' if shares != 1 else ''\n\t\tif shar... | [
"0.76451164",
"0.748746",
"0.7260813",
"0.71164954",
"0.7057435",
"0.70490545",
"0.70268077",
"0.69872165",
"0.6972749",
"0.6966809",
"0.6915586",
"0.68977857",
"0.68829334",
"0.6849716",
"0.68191767",
"0.68124473",
"0.68022114",
"0.6801836",
"0.67799073",
"0.67698354",
"0.67... | 0.60202867 | 87 |
Description of variables used | def main():
"""
Initialize Parameters
"""
src_path_map = '../data/map/wean.dat'
src_path_log = '../data/log/robotdata1.log'
map_obj = MapReader(src_path_map)
occupancy_map = map_obj.get_map()
logfile = open(src_path_log, 'r')
motion_model = MotionModel()
params = {
'z_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def variables_used (self) :\r\n\t\t## These names possibly contain dimension specification!\r\n\t\treturn self.variable_names",
"def variables_used (self) :\r\n\t\treturn []",
"def variables(self):\n return ()",
"def info(self):\n\t\timport inspect\n\t\n\t\tmessage = \"All variables available for star... | [
"0.7597981",
"0.7461102",
"0.742432",
"0.7258713",
"0.69928813",
"0.6981387",
"0.69313735",
"0.69255525",
"0.69189847",
"0.69012296",
"0.6899917",
"0.6858732",
"0.6843246",
"0.68283254",
"0.67520756",
"0.6725148",
"0.66848177",
"0.66221344",
"0.6604822",
"0.65710163",
"0.6563... | 0.0 | -1 |
Test the function 'save_screenshot' | def test_save_screenshot():
surface_flow_file = Path(TEST_RESULTS_FILES_PATH, "surface_flow.vtu")
screenshot_file = save_screenshot(surface_flow_file, "Mach")
assert screenshot_file.exists()
if screenshot_file.exists():
screenshot_file.unlink() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __take_screenshot(web_driver: webdriver, test_name: str):\n root_dir = os.path.dirname(os.path.abspath(__file__)).replace(\"tests\", \"reports\")\n file_name = f\"{str(datetime.datetime.now().timestamp())}_{test_name}.jpg\"\n screenshot_file_path = os.path.join(root_dir, file_name)\n web_driver.sav... | [
"0.7212455",
"0.7189058",
"0.70866424",
"0.7077667",
"0.70456177",
"0.6968092",
"0.69598687",
"0.6943727",
"0.6886083",
"0.6874362",
"0.6820328",
"0.6815366",
"0.68121475",
"0.6712085",
"0.6625147",
"0.6597559",
"0.6579359",
"0.6511203",
"0.65101516",
"0.6504467",
"0.65036196... | 0.81533283 | 0 |
get the date as a string only shows month/day [bias] as days want to add on today(could be minus) defaut is zero stands for today | def get_date_str(bias=0):
today = datetime.datetime.today() # 獲得今天的日期
date = (today + datetime.timedelta(days=bias)).strftime("%m/%d") # 格式化日期
return ' ' + date[1:] if date[0] == '0' else date # 把0換成空白 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def todaystr():\n today = datetime.datetime.today()\n return f\"{today.year}{today.month:02}{today.day:02}\"",
"def getDate():\n current_time = datetime.datetime.now()\n day = current_time.day\n month = current_time.month\n year = current_time.year\n date = \"{dd}-{mm}-{yyyy}\".format(dd=day... | [
"0.77219003",
"0.7503358",
"0.7500843",
"0.7455331",
"0.7453163",
"0.7407494",
"0.73675853",
"0.73555744",
"0.7328088",
"0.7196816",
"0.7162487",
"0.70597667",
"0.7008564",
"0.6929033",
"0.6923107",
"0.6921202",
"0.68978816",
"0.6877118",
"0.6834021",
"0.68301964",
"0.6810871... | 0.8040248 | 0 |
Calculates the demand along each edge for a particular routing and flow | def calc_demand(self, routing: np.ndarray, demand: float,
commodity_idx: int) -> np.ndarray:
commodity = self.commodities[commodity_idx]
node_flow = np.zeros(self.num_nodes)
node_flow[commodity[0]] = demand
split_matrix = np.zeros((self.num_nodes, self.num_nodes), dt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],\n demand: float,\n routing: np.ndarray) -> np.ndarray:\n edge_mapping = {edge: i for i, edge in\n enumerate(sorted(self.graph.edges))}\n\n ... | [
"0.7155596",
"0.6779073",
"0.6652812",
"0.6349164",
"0.63395905",
"0.6288503",
"0.62845767",
"0.6226773",
"0.62261355",
"0.61473256",
"0.61391884",
"0.6069398",
"0.6058541",
"0.6003596",
"0.5980734",
"0.5970249",
"0.59189695",
"0.59046817",
"0.58885455",
"0.58686656",
"0.5754... | 0.7746539 | 0 |
Returns the maxlinkutilisation for the graph, given the demands and routing. Uses np matrix operations for speed | def calc(self, demands: Demand, routing: Routing) -> np.ndarray:
total_utilisation = np.zeros((self.num_nodes, self.num_nodes),
dtype=float)
for commodity_idx in range(len(self.commodities)):
utilisation = self.calc_demand(routing,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edge... | [
"0.6417331",
"0.6131723",
"0.5959363",
"0.5949413",
"0.5865138",
"0.5848731",
"0.56908566",
"0.56839055",
"0.5609217",
"0.55568206",
"0.5556245",
"0.5482216",
"0.54756725",
"0.5473974",
"0.54683226",
"0.54410064",
"0.53907794",
"0.5382068",
"0.5376598",
"0.53537947",
"0.53520... | 0.5892291 | 4 |
Returns the optimal minimum of maxlinkutilisation for the graph, given the demands | def opt(self, demands: Demand) -> float:
# Create the linear solver with the GLOP backend.
solver = pywraplp.Solver('multicommodity_flow_lp',
pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
## VARIABLES
# Flow variables, the splitting ratios for each edge
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compare_greedy_dist_to_sync_dist(max_demand=8, show_graph=False):\n pass",
"def max_flow_min_cut(vertices, start, end):\n\n max_flow = 0 # There is no flow initially\n\n while True:\n bfs(vertices, start)\n\n if not end.bfs_visited:\n # There is no path between start and en... | [
"0.6206008",
"0.61956775",
"0.61796796",
"0.6167126",
"0.6034246",
"0.58196956",
"0.5767577",
"0.57007045",
"0.5692291",
"0.5689462",
"0.5678431",
"0.56615597",
"0.5658582",
"0.5644581",
"0.5641445",
"0.564055",
"0.5603883",
"0.5592757",
"0.5569047",
"0.5535338",
"0.5527755",... | 0.59470457 | 5 |
Calculates the link utilisation over a graph for a particular flow and its demand. (NB utilisation in bandwidth, not relative to capacity) | def calc_per_flow_link_utilisation(self, flow: Tuple[int, int],
demand: float,
routing: np.ndarray) -> np.ndarray:
edge_mapping = {edge: i for i, edge in
enumerate(sorted(self.graph.edges))}
link_utili... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_overall_link_utilisation(self, demands: Demand,\n routing: Routing) -> np.ndarray:\n flows = [(i, j) for i in range(self.num_nodes)\n for j in range(self.num_nodes)\n if i != j]\n\n link_utilisation = np.zeros(self.num_edge... | [
"0.71253026",
"0.67660636",
"0.66454524",
"0.6522981",
"0.6514812",
"0.647129",
"0.6460042",
"0.6392503",
"0.6243768",
"0.62313336",
"0.6146924",
"0.61348885",
"0.6108246",
"0.5984085",
"0.5855024",
"0.58338815",
"0.5774301",
"0.57635266",
"0.5752603",
"0.57300353",
"0.570590... | 0.77368706 | 0 |
Calculates the overall utilisation of each link in a network given a routing choice and a set of demands. (NB utilisation in bandwidth, not relative to capacity) | def calc_overall_link_utilisation(self, demands: Demand,
routing: Routing) -> np.ndarray:
flows = [(i, j) for i in range(self.num_nodes)
for j in range(self.num_nodes)
if i != j]
link_utilisation = np.zeros(self.num_edges)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_slow(self, demands: Demand, routing: Routing) -> float:\n edge_capacities = [e[2]['weight'] for e in\n sorted(self.graph.edges(data=True))]\n link_utilisation = self.calc_overall_link_utilisation(demands, routing)\n # Because utilisation compared to link widt... | [
"0.69715726",
"0.6957851",
"0.6760472",
"0.6361233",
"0.6345169",
"0.61192685",
"0.61020505",
"0.6086766",
"0.60547054",
"0.5906217",
"0.5893766",
"0.58539325",
"0.58028054",
"0.56963044",
"0.5695608",
"0.5679503",
"0.56758183",
"0.56425416",
"0.5628271",
"0.5583995",
"0.5572... | 0.75995314 | 0 |
Returns the maxlinkutilisation for the graph, given the demands and routing | def calc_slow(self, demands: Demand, routing: Routing) -> float:
edge_capacities = [e[2]['weight'] for e in
sorted(self.graph.edges(data=True))]
link_utilisation = self.calc_overall_link_utilisation(demands, routing)
# Because utilisation compared to link width is what... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_max_flow(graph, start, end):\n try:\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\"weight\")\n return flow_value\n except Exception as e:\n print(\"Error in Max flow computation \", e)\n return \"NaN\"",
"def get_max_usage(topology, path):\n ma... | [
"0.6513394",
"0.644975",
"0.62100786",
"0.61312515",
"0.610921",
"0.6011917",
"0.60004693",
"0.59970826",
"0.5994218",
"0.5972986",
"0.5926666",
"0.5894119",
"0.5879665",
"0.5859379",
"0.5828642",
"0.5822828",
"0.58168876",
"0.5812462",
"0.5796409",
"0.579364",
"0.5784096",
... | 0.5926042 | 11 |
Returns the maxlinkutilisation for the graph, given the demands and routing This method is hopefully much faster (by using LP rather than naive flow pushing). | def calc_lp(self, demands: Demand, routing: Routing) -> float:
epsilon = self.epsilon
# Create the linear solver with the GLOP backend.
solver = pywraplp.Solver('flow_utilisation_lp',
pywraplp.Solver.GLOP_LINEAR_PROGRAMMING)
## VARIABLES
# Flow ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_max_flow(graph, start, end):\n try:\n flow_value, _ = nx.maximum_flow(graph.graph, start, end, capacity=\"weight\")\n return flow_value\n except Exception as e:\n print(\"Error in Max flow computation \", e)\n return \"NaN\"",
"def get_max_usage(topology, path):\n ma... | [
"0.65920657",
"0.6395454",
"0.6269792",
"0.62530327",
"0.61595035",
"0.60755104",
"0.6060538",
"0.6029283",
"0.5978314",
"0.594786",
"0.59212416",
"0.5899884",
"0.5854466",
"0.584627",
"0.5839982",
"0.5837012",
"0.58368164",
"0.5815957",
"0.5805583",
"0.57703376",
"0.57671905... | 0.5938287 | 10 |
SET theme accroding to configration theme path in advance | def set_device_theme(dname, theme_type, number=0):
# log in theme app like i theme
activity_name = theme_config.getValue(dname,'set_theme_pkg')
#DEVICE = device.Device(dname)
#DEVICE.app_operation(action='LAUNCH', pkg=activity_name)
DEVICE = adbtools.AdbTools(dname)
#DEVICE.start_application(ac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_theme(self):\r\n template_conf = self._config.template\r\n if isinstance(template_conf, str):\r\n # Either a local path or the name of built-in themes\r\n if os.path.exists(template_conf):\r\n template_conf = {\r\n 'name': os.path.split(template_conf)[-1],\r\n ... | [
"0.7291386",
"0.72200936",
"0.72200936",
"0.7041518",
"0.70217",
"0.6841499",
"0.68290067",
"0.67453665",
"0.6707492",
"0.6679242",
"0.65246654",
"0.6497607",
"0.6458891",
"0.6432759",
"0.64274865",
"0.6375833",
"0.63486564",
"0.63367087",
"0.63211995",
"0.63092625",
"0.62976... | 0.5805374 | 42 |
Takes the adjacency matrix, payment matrix (or matrices), relationship matrix and initial state of all vertices to return the increments in each strategy for each vertex | def hr_egn(A, B, R, x0):
# A - Adjacency matrix, np.ndarray (N,N)
# B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)
# R - Relationship or preference matrix, np.ndarray (N,N)
# x0 - Initial state of our system, np.ndarray (N,S), must be double
# Number of players
N = A[:, 0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_matrix(self):\n matrix = np.zeros([len(self.states), len(self.states)])\n starting_states = []\n transitions = []\n\n for chords in self.training_data:\n states = []\n is_starting_state = True\n chunks = [chords[x:x+self.order] for x in range(0,\... | [
"0.58972126",
"0.5740013",
"0.5628643",
"0.5628604",
"0.56055963",
"0.56013095",
"0.55628353",
"0.55471677",
"0.5523483",
"0.5455894",
"0.5450417",
"0.5443276",
"0.54323477",
"0.5426158",
"0.54141635",
"0.54007095",
"0.53644186",
"0.53399026",
"0.5322008",
"0.5318355",
"0.530... | 0.0 | -1 |
Takes a time interval, number of steps, adjacency matrix, payment matrix (or matrices), relationship matrix and initial state of all vertices to return the result of the hyperrational evolutionary game played on the given graph in that time interval | def hr_game(t0, tf, n, A, B, R, x0):
# t0 - Initial time
# tf - Final time
# n - Number of steps
# A - Adjacency matrix, np.ndarray (N,N)
# B - A 2D or 3D matrix with all payoff matrices, np.ndarray (S,S,N)
# R - Relationship or preference matrix, np.ndarray (N,N)
# x0 - Initial state of o... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def params(timeseries_input):\n # Settings for Nelder Mead Algorithm\n global timeseries\n timeseries=timeseries_input\n\n NumIters = 1 # First Iteration\n MaxIters = 1e3 # Maximum number of iterations\n Tolerance = 1e-5 # Tolerance on best and worst function values\n N = 5 # Number of Hes... | [
"0.6062276",
"0.6009414",
"0.5854938",
"0.55636716",
"0.5466281",
"0.54142034",
"0.54097426",
"0.53703797",
"0.5366806",
"0.5362178",
"0.53470725",
"0.5342757",
"0.5329308",
"0.52993786",
"0.5255946",
"0.52543396",
"0.5253646",
"0.5226769",
"0.5217197",
"0.5200583",
"0.51922"... | 0.6342304 | 0 |
Constructor for the RestoreObjectState class | def __init__(self,
error=None,
object_status=None,
resource_pool_id=None,
restored_object_id=None,
source_object_id=None,
):
# Initialize members of the class
self.error = error
self.object_status =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, state):\n self.state = state",
"def restore(self, obj):\n return obj",
"def __init__(self,\n alternate_restore_base_directory=None,\n continue_on_error=None,\n encryption_enabled=None,\n generate_ssh_keys=None,\n ... | [
"0.6527886",
"0.6478938",
"0.63768274",
"0.63061714",
"0.6259334",
"0.6208393",
"0.6155825",
"0.6133407",
"0.612051",
"0.6097409",
"0.5997136",
"0.5995691",
"0.59769154",
"0.5974528",
"0.5970553",
"0.59491473",
"0.59310687",
"0.592171",
"0.5913257",
"0.58927315",
"0.58747876"... | 0.69528556 | 0 |
Creates an instance of this model from a dictionary | def from_dictionary(cls,
dictionary):
if dictionary is None:
return None
# Extract variables from the dictionary
error = cohesity_management_sdk.models.request_error.RequestError.from_dictionary(dictionary.get('error')) if dictionary.get('error') else None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_dictionary(cls,\n dictionary):\n if dictionary is None:\n return None\n\n # Extract variables from the dictionary\n id = dictionary.get('id')\n name = dictionary.get('name')\n mtype = dictionary.get('type')\n usage_bytes = diction... | [
"0.83181584",
"0.8168118",
"0.8168118",
"0.8118749",
"0.8089047",
"0.79787344",
"0.7949278",
"0.79231393",
"0.7898951",
"0.78923255",
"0.788838",
"0.7882321",
"0.7882212",
"0.7876749",
"0.78585315",
"0.7836853",
"0.7801407",
"0.7801407",
"0.7801407",
"0.7801407",
"0.7801407",... | 0.0 | -1 |
Test login with 2SA. | def test_login_2sa(self):
dsm_7 = SynologyDSMMock(
VALID_HOST,
VALID_PORT,
VALID_USER_2SA,
VALID_PASSWORD,
VALID_HTTPS,
VALID_VERIFY_SSL,
)
dsm_7.dsm_version = 7
with pytest.raises(SynologyDSMLogin2SARequiredExceptio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_login_2sa_new_session(self):\n dsm_7 = SynologyDSMMock(\n VALID_HOST,\n VALID_PORT,\n VALID_USER_2SA,\n VALID_PASSWORD,\n VALID_HTTPS,\n VALID_VERIFY_SSL,\n device_token=DEVICE_TOKEN,\n )\n dsm_7.dsm_version ... | [
"0.7610409",
"0.7500811",
"0.74207056",
"0.74207056",
"0.7279427",
"0.72677475",
"0.7121446",
"0.7109126",
"0.707014",
"0.70642114",
"0.7060475",
"0.70395577",
"0.70346",
"0.69922304",
"0.69830513",
"0.6942732",
"0.6919252",
"0.6907737",
"0.6880657",
"0.6877048",
"0.6873271",... | 0.80582833 | 0 |
Test login with 2SA and a new session with granted device. | def test_login_2sa_new_session(self):
dsm_7 = SynologyDSMMock(
VALID_HOST,
VALID_PORT,
VALID_USER_2SA,
VALID_PASSWORD,
VALID_HTTPS,
VALID_VERIFY_SSL,
device_token=DEVICE_TOKEN,
)
dsm_7.dsm_version = 7
ass... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_login_2sa(self):\n dsm_7 = SynologyDSMMock(\n VALID_HOST,\n VALID_PORT,\n VALID_USER_2SA,\n VALID_PASSWORD,\n VALID_HTTPS,\n VALID_VERIFY_SSL,\n )\n dsm_7.dsm_version = 7\n with pytest.raises(SynologyDSMLogin2SAR... | [
"0.79027075",
"0.6791165",
"0.6721474",
"0.6619786",
"0.65200156",
"0.649458",
"0.64693856",
"0.64288",
"0.6404014",
"0.64035445",
"0.63950443",
"0.63943654",
"0.6369294",
"0.6346183",
"0.6331206",
"0.6299405",
"0.6282982",
"0.6256549",
"0.6255143",
"0.6224549",
"0.62157404",... | 0.82061094 | 0 |
Load and return the malicious scripts dataset (classification). Returns | def load_crawl():
module_path = dirname(__file__)
with open(join(module_path, 'data', 'train2.csv')) as csv_file:
data_file = csv.reader(csv_file)
temp = next(data_file)
global n_samples
n_samples = int(temp[0])
global n_features
n_features = int(temp[1])
print "n samples " + str((n_samples))
print "... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_original_dataset(data_directory, setname):\n\n Sign = collections.namedtuple(\"Sign\", [\"visibility\", \"type\", \"name\"])\n data_directory = pathlib.Path(data_directory)\n filename = data_directory / setname / \"annotations.txt\"\n with tf.io.gfile.GFile(filename) as f:\n files, annotations = z... | [
"0.5732409",
"0.56973225",
"0.5590737",
"0.549615",
"0.54825884",
"0.54152006",
"0.5368154",
"0.5350428",
"0.5322323",
"0.53070223",
"0.5303706",
"0.52806413",
"0.5271645",
"0.5271418",
"0.5266955",
"0.5249725",
"0.5239241",
"0.52312857",
"0.52145183",
"0.52016944",
"0.519618... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.