class PRLinkIntegration(Integration): def _process(self): self._prlinks = OrderedSet() for match in itertools.chain( re.finditer(REGEX_TEMPLATE.format(PATH_REGEX), self._message), re.finditer(SHORT_REGEX_TEMPLATE.format(PATH_REGEX), self._message), ): self._prlinks.add(PrLink(match.group("path"))) @property def message(self): out = self._message for prlink in self._prlinks: out = re.sub( REGEX_TEMPLATE.format(prlink.path), "pr/{}".format(prlink.path), out, ) out = re.sub( SHORT_REGEX_TEMPLATE.format(prlink.path), r"<https://github.com/Cal-CS-61A-Staff/berkeley-cs61a/pull/{}|pr/{}>" .format(prlink.path, prlink.path), out, ) return out
def __init__(self, idx, tasks, task_duration, wall_time, np_random, cpu, mem): self.idx = idx self.tasks = tasks self.wall_time = wall_time self.np_random = np_random self.task_duration = task_duration self.cpu = cpu self.mem = mem self.num_tasks = len(tasks) self.num_finished_tasks = 0 # self.next_task_idx = 0 self.remain_tasks = set(list(range(len(tasks)))) self.no_more_tasks = False self.tasks_all_done = False self.node_finish_time = np.inf self.executors = OrderedSet() # uninitialized self.parent_nodes = [] self.child_nodes = [] self.descendant_nodes = [] self.job_dag = None self.assign_node_to_tasks()
def _process(self): self._issues = OrderedSet() for match in itertools.chain( re.finditer(REGEX_TEMPLATE.format(PATH_REGEX), self._message), re.finditer(SHORT_REGEX_TEMPLATE.format(PATH_REGEX), self._message), ): self._issues.add(Issue(match.group("path")))
def mark_hubs_after_initial_secants(builder, original_schemas, schemas, new_schemas, classes, named_lookups, add_rule): lookup = Lookup( 'dist', 'dupl', 'dflt', mark_filtering_set='all', reversed=True, ) hubs = OrderedSet() for schema in new_schemas: if isinstance(schema.path, Hub) and not schema.path.initial_secant: hubs.add(schema) classes['all'].append(schema) elif isinstance( schema.path, Line ) and schema.path.secant and schema.glyph_class == GlyphClass.JOINER: classes['secant'].append(schema) for hub in hubs: initial_secant_hub = hub.clone(path=hub.path.clone( initial_secant=True)) classes[phases.HUB_CLASS].append(initial_secant_hub) classes[phases.CONTINUING_OVERLAP_OR_HUB_CLASS].append( initial_secant_hub) add_rule(lookup, Rule( ['secant'], [hub], [], [initial_secant_hub], )) return [lookup]
class GoLinkIntegration(Integration): def _process(self): self._golinks = OrderedSet() for match in itertools.chain( re.finditer(REGEX_TEMPLATE.format(PATH_REGEX), self._message), re.finditer(SHORT_REGEX_TEMPLATE.format(PATH_REGEX), self._message), ): self._golinks.add(GoLink(match.group("path"))) @property def message(self): out = self._message for golink in self._golinks: out = re.sub( REGEX_TEMPLATE.format(golink.path), "go/{}".format(golink.path), out, ) out = re.sub( SHORT_REGEX_TEMPLATE.format(golink.path), r"<https://go.cs61a.org/{}|go/{}>".format( golink.path, golink.path), out, ) return out
def __tablename__(cls): global exclude_modules, inflect_engine modules = cls.__module__.split('.') modules[-1] = inflect_engine.plural( camel_case_to_lower_case_underscore(cls.__name__)) return '_'.join( list(OrderedSet(modules) - OrderedSet(exclude_modules)))
def compute_path(grid,start,goal,cost,heuristic): # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) # Keep track of the parent of each node. Since the car can take 4 distinct orientations, # for each orientation we can store a 2D array indicating the grid cells. # E.g. parent[0][2][3] will denote the parent when the car is at (2,3) facing up parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path =[['-' for row in range(len(grid[0]))] for col in range(len(grid))] x = start[0] y = start[1] theta = start[2] h = heuristic[x][y] g = 0 f = g+h open_set.put(start, Value(f=f,g=g)) # your code: implement A* # Initially you may want to ignore theta, that is, plan in 2D. # To do so, set actions=forward, cost = [1, 1, 1, 1], and action_name = ['U', 'L', 'R', 'D'] # Similarly, set parent=[[' ' for row in range(len(grid[0]))] for col in range(len(grid))] while open_set: node = open_set.pop() closed_set.add(node[0]) if node[0] == goal: break #finding child of node #write function for finding child node #setting the cost values for neighboring nodes neighbors = get_neighbors(node[0]) print(neighbors) for i in neighbors: x = i[0] y = i[1] theta = i[2] h = heuristic[x][y] g = node[1].g + costfunction(node[0],i) f = g+h if i not in open_set or i not in closed_set: open_set.put(i,Value(f,g)) elif i in open_set and f < open_set.get(i).f: open_set.put(i,Value(f,g)) return path, closed_set
def get_neighbors(grid, current_cell): neighbors = OrderedSet() x, y = current_cell for move in delta: x_new = x + move[0] y_new = y + move[1] if len(grid) > x_new >= 0 and len(grid[0]) > y_new >= 0: if not grid[x_new][y_new]: neighbors.add((x_new, y_new)) return neighbors
def reset(self): for node in self.nodes: node.reset() self.num_nodes_done = 0 self.executors = OrderedSet() self.frontier_nodes = OrderedSet() for node in self.nodes: if node.is_schedulable(): self.frontier_nodes.add(node) self.arrived = False self.completed = False self.completion_time = np.inf
def compute_value(grid, goal, cost): value = get_init_value_grid(grid, goal, MAX_COST) policy = get_init_policy(grid, goal) change = OrderedSet() change |= (get_neighbors(grid, goal)) while change: current_cell = change.pop() stochastic_cost, optimal_direction = get_min_cost( grid, value, current_cell) if stochastic_cost + cost < value[current_cell[0]][current_cell[1]]: value[current_cell[0]][current_cell[1]] = stochastic_cost + cost policy[current_cell[0]][current_cell[1]] = optimal_direction neighbors = get_neighbors(grid, current_cell) change |= (neighbors) return value, policy
def compute_path(grid,start,goal,cost,heuristic): # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) # Keep track of the parent of each node. Since the car can take 4 distinct orientations, # for each orientation we can store a 2D array indicating the grid cells. # E.g. parent[0][2][3] will denote the parent when the car is at (2,3) facing up parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path =[['-' for row in range(len(grid[0]))] for col in range(len(grid))] x = start[0] y = start[1] theta = start[2] h = heuristic[x][y] g = 0 f = g+h open_set.put(start, Value(f=f,g=g)) # your code: implement A* # Initially you may want to ignore theta, that is, plan in 2D. # To do so, set actions=forward, cost = [1, 1, 1, 1], and action_name = ['U', 'L', 'R', 'D'] # Similarly, set parent=[[' ' for row in range(len(grid[0]))] for col in range(len(grid))] return path, closed_set
def __init__(self, content='', callback=None, css=''): self.content = tools.load_content(content) or content self.template = system.default_template self.callback = callback self.css = css self.theme = None self.js = '' self.head = '' self.tail = '' self.title = '' self.subtitle = '' self.search = None self.actions = None self.libs = OrderedSet() self.styles = OrderedSet()
def compute_value(grid, goal, cost): value = get_init_value_grid(grid, goal, 99) policy = get_init_policy(grid, goal) change = OrderedSet() change |= (get_neighbors(grid, goal)) while change: current_cell = change.pop(last=False) min_cost, min_direction = get_min_cost(grid, value, current_cell) if min_cost + cost < value[current_cell[0]][current_cell[1]]: value[current_cell[0]][current_cell[1]] = min_cost + cost policy[current_cell[0]][current_cell[1]] = min_direction neighbors = get_neighbors(grid, current_cell) change |= (neighbors) for row in policy: print(row) for row in value: print(row) return value
def __init__(self, nodes, adj_mat, name): # nodes: list of N nodes # adj_mat: N by N 0-1 adjacency matrix, e_ij = 1 -> edge from i to j assert len(nodes) == adj_mat.shape[0] assert adj_mat.shape[0] == adj_mat.shape[1] self.name = name self.nodes = nodes self.adj_mat = adj_mat self.num_nodes = len(self.nodes) self.num_nodes_done = 0 # set of executors currently running on the job self.executors = OrderedSet() # the computation graph needs to be a DAG assert is_dag(self.num_nodes, self.adj_mat) # get the set of schedule nodes self.frontier_nodes = OrderedSet() for node in self.nodes: if node.is_schedulable(): self.frontier_nodes.add(node) # assign job dag to node self.assign_job_dag_to_node() # dag is arrived self.arrived = False # dag is completed self.completed = False # dag start ime self.start_time = None # dag completion time self.completion_time = np.inf # map a executor number to an interval self.executor_interval_map = \ self.get_executor_interval_map()
def compute_path(grid, start, goal, cost, heuristic): # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path = [['-' for row in range(len(grid[0]))] for col in range(len(grid))] x = start[0] y = start[1] theta = start[2] g_value = 0 h_value = heuristic[x][y] f = g_value + h_value parent_cost = [[[1000000000 for row in range(len(grid[0]))] for col in range(len(grid))], [[1000000000 for row in range(len(grid[0]))] for col in range(len(grid))], [[1000000000 for row in range(len(grid[0]))] for col in range(len(grid))], [[1000000000 for row in range(len(grid[0]))] for col in range(len(grid))]] open_set.put(start, Value(f=f, g=g_value)) ########################### IMPLEMENTATION OF DIJKSTRA ALGORITHM ################################### #################################################################################################### #################################################################################################### def dijkstra(grid, source): length = len(grid) Q_value = [(0, source)] value0 = [inf for i in range(length)] value0[source] = 0 while len(Q) != 0: (cost, u) = hq.heappop(Q_value) for v in range(n): if value0[v] > value0[u] + grid[u][v]: value0[v] = value0[u] + grid[u][v] hq.heappush(Q, (value0[v], v)) return value0 print('The dijkstra value is:', value0) return path, closed_set
def _process(self): course_id = piazza_course_id(course=self._course) self._posts = OrderedSet() for match in itertools.chain( re.finditer(SHORT_REGEX, self._message), re.finditer(LONG_REGEX.format(course_id), self._message), ): cid = int(match.group("cid")) fid_str = match.group("fid") full_cid = match.group("cid") + ("_f{}".format(fid_str) if fid_str else "") post = perform_piazza_action( action="get_post", course=self._course, as_staff=True, kwargs=dict(cid=cid), ) subject = post["history"][0]["subject"] content = post["history"][0]["content"] if fid_str: fid = int(fid_str) # 1 indexed curr_id = 0 for child in post["children"]: if child["type"] != "followup": continue curr_id += 1 if fid == curr_id: break else: return content = child["subject"] subject = unescape(subject) content = unescape(re.sub("<[^<]+?>", "", content)) url = "https://piazza.com/class/{}?cid={}".format( course_id, full_cid) self._posts.add(Post(subject, content, url, full_cid))
def _process(self): course_id = ed_course_id(course=self._course) ed_posts = perform_ed_action( action="get_feed", course=self._course, as_staff=True, kwargs=dict(limit=999999), )["threads"] self._posts = OrderedSet() for match in itertools.chain( re.finditer(SHORT_REGEX, self._message), re.finditer(LONG_REGEX.format(course_id), self._message), ): num = int(match.group("num")) pid = int(match.group("pid")) post = None if pid: for p in ed_posts: if p.get("id", 0) == pid: post = p break elif num: for p in ed_posts: if p.get("number", 0) == num: post = p break if not post: continue subject = post["title"] content = post["document"] subject = unescape(subject) content = unescape(re.sub("<[^<]+?>", "", content)) url = "https://edstem.org/us/courses/{}/discussion/{}".format( course_id, post["id"] ) self._posts.add(Post(subject, content, url, post["number"], post["id"]))
class IssueIntegration(Integration): def _process(self): self._issues = OrderedSet() for match in itertools.chain( re.finditer(REGEX_TEMPLATE.format(PATH_REGEX), self._message), re.finditer(SHORT_REGEX_TEMPLATE.format(PATH_REGEX), self._message), ): self._issues.add(Issue(match.group("path"))) @property def message(self): out = self._message for issue in self._issues: out = re.sub( REGEX_TEMPLATE.format(issue.path), "is/{}".format(issue.path), out ) out = re.sub( SHORT_REGEX_TEMPLATE.format(issue.path), r"<https://github.com/Cal-CS-61A-Staff/berkeley-cs61a/issues/{}|is/{}>".format( issue.path, issue.path ), out, ) return out
def get_msg_path(self, job_dags): if len(self.job_dags) != len(job_dags): job_dags_changed = True else: job_dags_changed = not(all(i is j for \ (i, j) in zip(self.job_dags, job_dags))) if job_dags_changed: self.msg_mats, self.msg_masks = get_msg_path(job_dags) self.dag_summ_backward_map = get_dag_summ_backward_map(job_dags) self.running_dag_mat = get_running_dag_mat(job_dags) self.job_dags = OrderedSet(job_dags) return self.msg_mats, self.msg_masks, \ self.dag_summ_backward_map, self.running_dag_mat, \ job_dags_changed
def canon(word): """Given a word, returns a list of synonyms in order of relevance""" url = URI.format(word=word) r = get(url) try: # get the word lists from the response word_lists = [ lst['list']['synonyms'].split('|') for lst in r.json()['response'] ] # concatenate the word lists and eliminate duplicates return list( OrderedSet([ item for sublist in word_lists for item in sublist if '(antonym)' not in item ])) except: return []
def compute_path(grid,start,goal,cost,heuristic): # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) # Keep track of the parent of each node. Since the car can take 4 distinct orientations, # for each orientation we can store a 2D array indicating the grid cells. # E.g. parent[0][2][3] will denote the parent when the car is at (2,3) facing up parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path =[['-' for row in range(len(grid[0]))] for col in range(len(grid))] dist =[] P =[] x = start[0] y = start[1] theta = start[2] h = heuristic[x][y] g = 0 f = g+h open_set.put(start, Value(f=f,g=g)) for i in range(0,6): for j in range(0,5): if grid[i][j] == 0: dist = 10000000 x = P(i) y = P(j c dfd #cIm just) open_set.put([i][j], dist) open_set.insert(goal,0) while not open_set.empty(): x,y = open_set.pop() # your code: implement A* # Initially you may want to ignore theta, that is, plan in 2D. # To do so, set actions=forward, cost = [1, 1, 1, 1], and action_name = ['U', 'L', 'R', 'D'] # Similarly, set parent=[[' ' for row in range(len(grid[0]))] for col in range(len(grid))] return path, closed_set if __name__ == "__main__": path,closed=compute_path(grid, init, goal, cost, heuristic) for i in range(len(path)): print(path[i]) print("\nExpanded Nodes") for node in closed: print(node) """
def canon(word): """Given a word, returns a list of synonyms in order of relevance""" # this is kind of fragile, maybe do something better about this return OrderedSet([syn.unicode_repr().split("'")[1].split('.')[0] for syn in wn.synsets(word)])
def compute_path(grid,start,goal,cost,heuristic): global forward # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) # Keep track of the parent of each node. Since the car can take 4 distinct orientations, # for each orientation we can store a 2D array indicating the grid cells. # E.g. parent[0][2][3] will denote the parent when the car is at (2,3) facing up parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path =[['-' for row in range(len(grid[0]))] for col in range(len(grid))] x = start[0] y = start[1] theta = start[2] h = heuristic[x][y] g = 0 f = g+h open_set.put(start, Value(f=f,g=g)) # your code: implement A* # Create start and end node while len(open_set)!=0: current_node,current_node_add=open_set.pop() if current_node==goal: path[current_node[0]][current_node[1]]='*' closed_set.add(current_node) print("Goal reached") while current_node!=start: parent_node = parent[current_node[2]][current_node[0]][current_node[1]] or_diff = parent_node[2] - current_node[2] #print(or_diff,"\t",current_node,"\n") if or_diff== -3: or_diff = -1 elif or_diff>0: or_diff = -1 elif or_diff<0: or_diff = 1 action_value = action.index(or_diff) act = action_name[action_value] path[parent_node[0]][parent_node[1]] = act current_node = parent_node break closed_set.add(current_node) # Generate children for index,_ in enumerate(action): # Adjacent squares theta = current_node[2] + action[index] if theta==4: theta=0 if theta==-1: theta=3 # Get node position child_node = ( current_node[0]+forward[theta][0], current_node[1]+forward[theta][1],theta) # Make sure within range if child_node[0] <= (len(grid)-1) and child_node[0] >= 0 and child_node[1] <= (len(grid[len(grid)-1])-1) and child_node[1] >= 0: #Make sure walkable terrain if (grid[child_node[0]][child_node[1]]) == 0: if child_node in closed_set: continue else: g = current_node_add.g + cost[index] h = heuristic[child_node[0]][child_node[1]] g = current_node_add.g + cost[index] f = g+h open_set.put(child_node, Value(f=f,g=g)) parent[theta][child_node[0]][child_node[1]] = current_node[0],current_node[1],current_node[2] """if child_node not in open_set: #print(False) h = heuristic[child_node[0]][child_node[1]] g = current_node_add.g + cost[index] f = g+h open_set.put(child_node, Value(f=f,g=g)) parent[theta][child_node[0]][child_node[1]] = current_node[0],current_node[1],current_node[2] elif child_node in open_set and g>current_node_add.g: #print(True) h = heuristic[child_node[0]][child_node[1]] g = current_node_add.g + cost[index] f = g+h open_set.put(child_node, Value(f=f,g=g)) parent[theta][child_node[0]][child_node[1]] = current_node[0],current_node[1],current_node[2]""" # Initially you may want to ignore theta, that is, plan in 2D. # To do so, set actions=forward, cost = [1, 1, 1, 1], and action_name = ['U', 'L', 'R', 'D'] # Similarly, set parent=[[' ' for row in range(len(grid[0]))] for col in range(len(grid))] return path, closed_set
class Node(object): def __init__(self, idx, tasks, task_duration, wall_time, np_random): self.idx = idx self.tasks = tasks self.wall_time = wall_time self.np_random = np_random self.task_duration = task_duration self.num_tasks = len(tasks) self.num_finished_tasks = 0 self.next_task_idx = 0 self.no_more_tasks = False self.tasks_all_done = False self.node_finish_time = np.inf self.executors = OrderedSet() # uninitialized self.parent_nodes = [] self.child_nodes = [] self.descendant_nodes = [] self.job_dag = None self.assign_node_to_tasks() def assign_node_to_tasks(self): for task in self.tasks: task.node = self def get_node_duration(self): # Warning: this is slow O(num_tasks) # get the total duration over all tasks duration = 0 for task in self.tasks: duration += task.get_duration() return duration def is_schedulable(self): if self.no_more_tasks: # no more tasks return False if self.tasks_all_done: # node done return False for node in self.parent_nodes: if not node.tasks_all_done: # a parent node not done return False return True def reset(self): for task in self.tasks: task.reset() self.executors.clear() self.num_finished_tasks = 0 self.next_task_idx = 0 self.no_more_tasks = False self.tasks_all_done = False self.node_finish_time = np.inf def sample_executor_key(self, num_executors): (left_exec, right_exec) = \ self.job_dag.executor_interval_map[num_executors] executor_key = None if left_exec == right_exec: executor_key = left_exec else: rand_pt = self.np_random.randint(1, right_exec - left_exec + 1) if rand_pt <= num_executors - left_exec: executor_key = left_exec else: executor_key = right_exec if executor_key not in self.task_duration['first_wave']: # more executors than number of tasks in the job largest_key = 0 for e in self.task_duration['first_wave']: if e > largest_key: largest_key = e executor_key = largest_key return executor_key def schedule(self, executor): assert self.next_task_idx < self.num_tasks task = self.tasks[self.next_task_idx] # task duration is determined by wave num_executors = len(self.job_dag.executors) assert num_executors > 0 # sample an executor point in the data executor_key = self.sample_executor_key(num_executors) if executor.task is None or \ executor.task.node.job_dag != task.node.job_dag: # the executor never runs a task in this job # fresh executor incurrs a warmup delay if len(self.task_duration['fresh_durations'][executor_key]) > 0: # (1) try to directly retrieve the warmup delay from data fresh_durations = \ self.task_duration['fresh_durations'][executor_key] i = np.random.randint(len(fresh_durations)) duration = fresh_durations[i] else: # (2) use first wave but deliberately add in a warmup delay first_wave = \ self.task_duration['first_wave'][executor_key] i = np.random.randint(len(first_wave)) duration = first_wave[i] + args.warmup_delay elif executor.task is not None and \ executor.task.node == task.node and \ len(self.task_duration['rest_wave'][executor_key]) > 0: # executor was working on this node # the task duration should be retrieved from rest wave rest_wave = self.task_duration['rest_wave'][executor_key] i = np.random.randint(len(rest_wave)) duration = rest_wave[i] else: # executor is fresh to this node, use first wave if len(self.task_duration['first_wave'][executor_key]) > 0: # (1) try to retrieve first wave from data first_wave = \ self.task_duration['first_wave'][executor_key] i = np.random.randint(len(first_wave)) duration = first_wave[i] else: # (2) first wave doesn't exist, use fresh durations instead # (should happen very rarely) fresh_durations = \ self.task_duration['fresh_durations'][executor_key] i = np.random.randint(len(fresh_durations)) duration = fresh_durations[i] # detach the executor from old node # the executor can run task means it is local # to the job at this point executor.detach_node() # schedule the task task.schedule(self.wall_time.curr_time, duration, executor) # mark executor as running in the node self.executors.add(executor) executor.node = self self.next_task_idx += 1 self.no_more_tasks = (self.next_task_idx >= self.num_tasks) if self.no_more_tasks: if self in self.job_dag.frontier_nodes: self.job_dag.frontier_nodes.remove(self) return task
def build_sql(self, data): ''' start with assigning data items to the underlying tables it seems sqlite really doesn't give a hoot about data types, and I don't see a difference in execution time between "like" and "=" - I guess sqlite is smart enough to optimize if there is no wild card. actually there IS a difference, so we will use 'like' only if there is a '%' in the search value. So that will make things a lot more straightforward. ''' from_tables = OrderedSet(["refs"]) restraints = OrderedSet() alias_counter = 0 for field, value in list(data.items()): if not value: continue if field in ("bibtexkey", "title", "year"): key = "refs.%s" % field restraints.add(self.translate_restraints(key, value)) continue if field == 'reftype': from_tables.add('reftypes') restraints.add('(reftypes.reftype_id = refs.reftype_id)') restraints.add(self.translate_restraints('reftypes.name', value)) continue table = 'uniqid' if field in ("doi", "pmid") else 'optional' alias_counter += 1 alias = "%s%s" % (table[:3], alias_counter) from_tables.add('%s as %s' % (table, alias)) restraints.add('(%s.ref_id = refs.ref_id)' % alias) restraints.add('(%s.field_id = %s)' % (alias, self.field_types[field])) restraints.add(self.translate_restraints('%s.content' % alias, value)) # format the sql start_clause = """ select refs.ref_id from """ line = ' %s\n' sql = textwrap.dedent(start_clause) + '\n' for i, clause in enumerate(from_tables): if i+1 < len(from_tables): clause += ',' sql += line % clause sql += 'where\n' for i, r in enumerate(restraints): if i > 0: r = 'and ' + r sql += line % r # open('/home/mpalmer/sql.log','w').write(sql) return sql.lstrip()
def compute_path(grid, start, goal, cost, heuristic): # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) # Keep track of the parent of each node. Since the car can take 4 distinct orientations, # for each orientation we can store a 2D array indicating the grid cells. # E.g. parent[0][2][3] will denote the parent when the car is at (2,3) facing up parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path = [['-' for row in range(len(grid[0]))] for col in range(len(grid))] x = start[0] y = start[1] theta = start[2] h = heuristic[x][y] g = 0 f = g + h # your code: implement A* open_set.put(start, Value(f=f, g=g)) while open_set.__len__() != 0: node = open_set.pop() g = node[1].g x = node[0][0] y = node[0][1] theta = node[0][2] #if reach the goal, break if (node[0] == goal): closed_set.add(node[0]) break closed_set.add(node[0]) for idx, act in enumerate(action): new_theta = (theta + act) % 4 #use orientation to determine the position new_x = x + forward[new_theta][0] new_y = y + forward[new_theta][1] #to make sure it won't break the node is naviable if (new_x < 0 or new_x > 4 or new_y < 0 or new_y > 5 or grid[new_x][new_y] == 1): continue new_g = g + cost[idx] new_h = heuristic[new_x][new_y] new_f = new_g + new_h child = [(new_x, new_y, new_theta), Value(f=new_f, g=new_g)] if (child[0] not in closed_set and child[0] not in open_set): open_set.put(child[0], child[1]) parent[new_theta][new_x][new_y] = (action_name[idx], node[0]) #if the cost decreased, add it to the openlist elif (open_set.has(child[0]) and open_set.get(child[0]).g > new_g): open_set.put(child[0], child[1]) parent[new_theta][new_x][new_y] = (action_name[idx], node[0]) #recording the path in parent #reach the goal path[x][y] = '*' #find out the path by recalling step by step while (x, y, theta) != start: pre_step = parent[theta][x][y] x = pre_step[1][0] y = pre_step[1][1] theta = pre_step[1][2] path[x][y] = pre_step[0] # Initially you may want to ignore theta, that is, plan in 2D. # To do so, set actions=forward, cost = [1, 1, 1, 1], and action_name = ['U', 'L', 'R', 'D'] # Similarly, set parent=[[' ' for row in range(len(grid[0]))] for col in range(len(grid))] return path, closed_set
def compute_path(grid, start, goal, cost, heuristic): # Use the OrderedSet for your closed list closed_set = OrderedSet() # Use thePriorityQueue for the open list open_set = PriorityQueue(order=min, f=lambda v: v.f) # Keep track of the parent of each node. Since the car can take 4 distinct orientations, # for each orientation we can store a 2D array indicating the grid cells. # E.g. parent[0][2][3] will denote the parent when the car is at (2,3) facing up parent = [[[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))], [[' ' for row in range(len(grid[0]))] for col in range(len(grid))]] # The path of the car path = [['-' for row in range(len(grid[0]))] for col in range(len(grid))] x = start[0] y = start[1] theta = start[2] h = heuristic[x][y] g = 0 f = g + h children = [] # print(start) open_set.put(start, Value(f=f, g=g)) while open_set: node, new_cost = open_set.pop() print('The current node is:', node) print('==============================') if node == goal: return path, closed_set closed_set.add(node) row_grid = len(grid) - 1 #4 Boundry of the grids column_grid = (len(grid[0])) - 1 #5 x1 = node[0] #Parrent x co-ordinate y1 = node[1] # Parrent y co-ordinate theta1 = node[2] # Parrent orientation f1 = new_cost.f #Parent total cost h = heuristic[x1][y1] #Heuristic of parrent g1 = new_cost.g #Path cost of parrent neighbor = [] f12 = [] h12 = [] g12 = [] for i in range(len(action)): temp_dir = collections.deque( direction ) # creating a deque tuple # 0 N :::: 1 west 2 south :::: east 3 index = theta1 # orientation of the Parent child_index = action[i] # possible index of the child n = -1 * child_index temp_dir.rotate(n) child_theta = temp_dir[ theta1] # using the index of the parent to find out the current orientation of the child """ calculating the distances of children""" x_pos = node[0] + forward[child_theta][ 0] # this gives the position of x,y of the child y_pos = node[1] + forward[child_theta][1] pos = (x_pos, y_pos, child_theta) g1 = [] if (pos[0] > row_grid or pos[1] > (column_grid) or pos[1] < 0 or pos[0] < 0): continue elif (grid[pos[0]][pos[1]] == 1): continue else: neighbor.append(pos) h1 = heuristic[x_pos][ y_pos] # heuristic of neighbor that is dist from the goal g1 = new_cost.g + cost[i] # path function print(new_cost.g) print("---------------------") print(cost[i]) f1 = g1 + h1 # total cost f12 = np.append(f12, f1) g12 = np.append(g12, g1) h12 = np.append(h12, h1) gmin = min(g12) posi = np.argmin(g12) c = 0 for neigh in neighbor: #Condition for child which is closest to the goal if neigh not in open_set or neigh not in closed_set: open_set.put(neigh, Value(f=f12[c], g=g12[c])) # print(open_set.get(neigh).g) print(neigh) print(open_set.get(neigh).g) elif neigh in open_set and gmin < open_set.get(neigh).g: open_set.put(neigh, Value(f=f12[c], g=g12[c])) # print("ggggggggg") c = c + 1 c = 0 return path, closed_set
def reset(self, executors): self.free_executors = {} self.free_executors[None] = OrderedSet() for executor in executors: self.free_executors[None].add(executor)
def add_job(self, job): self.free_executors[job] = OrderedSet()
def reset(self): self.job_dags = OrderedSet() self.msg_mats = [] self.msg_masks = [] self.dag_summ_backward_map = None self.running_dag_mat = None