util.py Mon Jul 12 21:42: : # util.py 2: # : # Licensing Information: Please do not distribute or publish solutions to this 4: #

Size: px

Start display at page:

Download "util.py Mon Jul 12 21:42: : # util.py 2: # : # Licensing Information: Please do not distribute or publish solutions to this 4: #"

Anastasia Washington
5 years ago
Views:

1 util.py Mon Jul 12 21:42: : # util.py 2: # : # Licensing Information: Please do not distribute or publish solutions to this 4: # project. You are free to use and extend these projects for educational 5: # purposes. The Pacman AI projects were developed at UC Berkeley, primarily by 6: # John DeNero (denero@cs.berkeley.edu) and Dan Klein (klein@cs.berkeley.edu). 7: # For more info, see cs188/sp09/pacman.html 8: 9: import sys 10: import inspect 11: import heapq, random 12: 13: 14: """ 15: Data structures useful for implementing SearchAgents 16: """ 17: 18: class Stack: 19: "A container with a last-in-first-out (LIFO) queuing policy." 20: def init (self): 21: self.list = [] 22: 23: def push(self,item): 24: "Push item onto the stack" 25: self.list.append(item) 26: 27: def pop(self): 28: "Pop the most recently pushed item from the stack" 29: return self.list.pop() 30: 31: def isempty(self): 32: "Returns true if the stack is empty" 33: return len(self.list) == 0 34: 35: class Queue: 36: "A container with a first-in-first-out (FIFO) queuing policy." 37: def init (self): 38: self.list = [] 39: 40: def push(self,item): 41: "Enqueue the item into the queue" 42: self.list.insert(0,item) 43: 44: def pop(self): 45: """ 46: Dequeue the earliest enqueued item still in the queue. This 47: operation removes the item from the queue. 48: """ 49: return self.list.pop() 50: 51: def isempty(self): 52: "Returns true if the queue is empty" 53: return len(self.list) == 0 54: 55: class PriorityQueue: 56: """ 57: Implements a priority queue data structure. Each inserted item 58: has a priority associated with it and the client is usually interested 59: in quick retrieval of the lowest-priority item in the queue. This 60: data structure allows O(1) access to the lowest-priority item. 61: 62: Note that this PriorityQueue does not allow you to change the priority 63: of an item. However, you may insert the same item multiple times with 64: different priorities. 65: """

2 util.py Mon Jul 12 21:42: : def init (self): 67: self.heap = [] 68: 69: def push(self, item, priority): 70: pair = (priority,item) 71: heapq.heappush(self.heap,pair) 72: 73: def pop(self): 74: (priority,item) = heapq.heappop(self.heap) 75: return item 76: 77: def isempty(self): 78: return len(self.heap) == 0 79: 80: class PriorityQueueWithFunction(PriorityQueue): 81: """ 82: Implements a priority queue with the same push/pop signature of the 83: Queue and the Stack classes. This is designed for drop-in replacement for 84: those two classes. The caller has to provide a priority function, which 85: extracts each item s priority. 86: """ 87: def init (self, priorityfunction): 88: "priorityfunction (item) -> priority" 89: self.priorityfunction = priorityfunction # store the priority function 90: PriorityQueue. init (self) # super-class initializer 91: 92: def push(self, item): 93: "Adds an item to the queue with priority from the priority function" 94: PriorityQueue.push(self, item, self.priorityfunction(item)) 95: 96: 97: def manhattandistance( xy1, xy2 ): 98: "Returns the Manhattan distance between points xy1 and xy2" 99: return abs( xy1[0] - xy2[0] ) + abs( xy1[1] - xy2[1] ) 100: 101: """ 102: Data structures and functions useful for various course projects 103: 104: The search project should not need anything below this line. 105: """ 106: 107: class Counter(dict): 108: """ 109: A counter keeps track of counts for a set of keys. 110: 111: The counter class is an extension of the standard python 112: dictionary type. It is specialized to have number values 113: (integers or floats), and includes a handful of additional 114: functions to ease the task of counting data. In particular, 115: all keys are defaulted to have value 0. Using a dictionary: 116: 117: a = {} 118: print a[ test ] 119: 120: would give an error, while the Counter class analogue: 121: 122: >>> a = Counter() 123: >>> print a[ test ] 124: 0 125: 126: returns the default 0 value. Note that to reference a key 127: that you know is contained in the counter, 128: you can still use the dictionary syntax: 129: 130: >>> a = Counter()

3 util.py Mon Jul 12 21:42: : >>> a[ test ] = 2 132: >>> print a[ test ] 133: 2 134: 135: This is very useful for counting things without initializing their counts, 136: see for example: 137: 138: >>> a[ blah ] += 1 139: >>> print a[ blah ] 140: 1 141: 142: The counter also includes additional functionality useful in implementing 143: the classifiers for this assignment. Two counters can be added, 144: subtracted or multiplied together. See below for details. They can 145: also be normalized and their total count and arg max can be extracted. 146: """ 147: def getitem (self, idx): 148: self.setdefault(idx, 0) 149: return dict. getitem (self, idx) 150: 151: def incrementall(self, keys, count): 152: """ 153: Increments all elements of keys by the same count. 154: 155: >>> a = Counter() 156: >>> a.incrementall([ one, two, three ], 1) 157: >>> a[ one ] 158: 1 159: >>> a[ two ] 160: 1 161: """ 162: for key in keys: 163: self[key] += count 164: 165: def argmax(self): 166: """ 167: Returns the key with the highest value. 168: """ 169: if len(self.keys()) == 0: return None 170: all = self.items() 171: values = [x[1] for x in all] 172: maxindex = values.index(max(values)) 173: return all[maxindex][0] 174: 175: def sortedkeys(self): 176: """ 177: Returns a list of keys sorted by their values. Keys 178: with the highest values will appear first. 179: 180: >>> a = Counter() 181: >>> a[ first ] = : >>> a[ second ] = 4 183: >>> a[ third ] = 1 184: >>> a.sortedkeys() 185: [ second, third, first ] 186: """ 187: sorteditems = self.items() 188: compare = lambda x, y: sign(y[1] - x[1]) 189: sorteditems.sort(cmp=compare) 190: return [x[0] for x in sorteditems] 191: 192: def totalcount(self): 193: """ 194: Returns the sum of counts for all keys. 195: """

4 util.py Mon Jul 12 21:42: : return sum(self.values()) 197: 198: def normalize(self): 199: """ 200: Edits the counter such that the total count of all 201: keys sums to 1. The ratio of counts for all keys 202: will remain the same. Note that normalizing an empty 203: Counter will result in an error. 204: """ 205: total = float(self.totalcount()) 206: if total == 0: return 207: for key in self.keys(): 208: self[key] = self[key] / total 209: 210: def divideall(self, divisor): 211: """ 212: Divides all counts by divisor 213: """ 214: divisor = float(divisor) 215: for key in self: 216: self[key] /= divisor 217: 218: def copy(self): 219: """ 220: Returns a copy of the counter 221: """ 222: return Counter(dict.copy(self)) 223: 224: def mul (self, y ): 225: """ 226: Multiplying two counters gives the dot product of their vectors where 227: each unique label is a vector element. 228: 229: >>> a = Counter() 230: >>> b = Counter() 231: >>> a[ first ] = : >>> a[ second ] = 4 233: >>> b[ first ] = 3 234: >>> b[ second ] = 5 235: >>> a[ third ] = : >>> a[ fourth ] = : >>> a * b 238: : """ 240: sum = 0 241: x = self 242: if len(x) > len(y): 243: x,y = y,x 244: for key in x: 245: if key not in y: 246: continue 247: sum += x[key] * y[key] 248: return sum 249: 250: def radd (self, y): 251: """ 252: Adding another counter to a counter increments the current counter 253: by the values stored in the second counter. 254: 255: >>> a = Counter() 256: >>> b = Counter() 257: >>> a[ first ] = : >>> a[ second ] = 4 259: >>> b[ first ] = 3 260: >>> b[ third ] = 1

5 util.py Mon Jul 12 21:42: d 261: >>> a += b 262: >>> a[ first ] 263: 1 264: """ 265: for key, value in y.items(): 266: self[key] += value 267: 268: def add ( self, y ): 269: """ 270: Adding two counters gives a counter with the union of all keys and 271: counts of the second added to counts of the first. 272: 273: >>> a = Counter() 274: >>> b = Counter() 275: >>> a[ first ] = : >>> a[ second ] = 4 277: >>> b[ first ] = 3 278: >>> b[ third ] = 1 279: >>> (a + b)[ first ] 280: 1 281: """ 282: addend = Counter() 283: for key in self: 284: if key in y: 285: addend[key] = self[key] + y[key] 286: else: 287: addend[key] = self[key] 288: for key in y: 289: if key in self: 290: continue 291: addend[key] = y[key] 292: return addend 293: 294: def sub ( self, y ): 295: """ 296: Subtracting a counter from another gives a counter with the union of all keys an 297: counts of the second subtracted from counts of the first. 298: 299: >>> a = Counter() 300: >>> b = Counter() 301: >>> a[ first ] = : >>> a[ second ] = 4 303: >>> b[ first ] = 3 304: >>> b[ third ] = 1 305: >>> (a - b)[ first ] 306: : """ 308: addend = Counter() 309: for key in self: 310: if key in y: 311: addend[key] = self[key] - y[key] 312: else: 313: addend[key] = self[key] 314: for key in y: 315: if key in self: 316: continue 317: addend[key] = -1 * y[key] 318: return addend 319: 320: def raisenotdefined(): 321: print "Method not implemented: %s" % inspect.stack()[1][3] 322: sys.exit(1) 323: 324: def normalize(vectororcounter):

6 util.py Mon Jul 12 21:42: : """ 326: normalize a vector or counter by dividing each value by the sum of all values 327: """ 328: normalizedcounter = Counter() 329: if type(vectororcounter) == type(normalizedcounter): 330: counter = vectororcounter 331: total = float(counter.totalcount()) 332: if total == 0: return counter 333: for key in counter.keys(): 334: value = counter[key] 335: normalizedcounter[key] = value / total 336: return normalizedcounter 337: else: 338: vector = vectororcounter 339: s = float(sum(vector)) 340: if s == 0: return vector 341: return [el / s for el in vector] 342: 343: def nsample(distribution, values, n): 344: if sum(distribution)!= 1: 345: distribution = normalize(distribution) 346: rand = [random.random() for i in range(n)] 347: rand.sort() 348: samples = [] 349: samplepos, distpos, cdf = 0,0, distribution[0] 350: while samplepos < n: 351: if rand[samplepos] < cdf: 352: samplepos += 1 353: samples.append(values[distpos]) 354: else: 355: distpos += 1 356: cdf += distribution[distpos] 357: return samples 358: 359: def sample(distribution, values = None): 360: if type(distribution) == Counter: 361: items = distribution.items() 362: distribution = [i[1] for i in items] 363: values = [i[0] for i in items] 364: if sum(distribution)!= 1: 365: distribution = normalize(distribution) 366: choice = random.random() 367: i, total= 0, distribution[0] 368: while choice > total: 369: i += 1 370: total += distribution[i] 371: return values[i] 372: 373: def samplefromcounter(ctr): 374: items = ctr.items() 375: return sample([v for k,v in items], [k for k,v in items]) 376: 377: def getprobability(value, distribution, values): 378: """ 379: Gives the probability of a value under a discrete distribution 380: defined by (distributions, values). 381: """ 382: total = : for prob, val in zip(distribution, values): 384: if val == value: 385: total += prob 386: return total 387: 388: def flipcoin( p ): 389: r = random.random()

7 util.py Mon Jul 12 21:42: : return r < p 391: 392: def choosefromdistribution( distribution ): 393: "Takes either a counter or a list of (prob, key) pairs and samples" 394: if type(distribution) == dict or type(distribution) == Counter: 395: return sample(distribution) 396: r = random.random() 397: base = : for prob, element in distribution: 399: base += prob 400: if r <= base: return element 401: 402: def nearestpoint( pos ): 403: """ 404: Finds the nearest grid point to a position (discretizes). 405: """ 406: ( current_row, current_col ) = pos 407: 408: grid_row = int( current_row ) 409: grid_col = int( current_col ) 410: return ( grid_row, grid_col ) 411: 412: def sign( x ): 413: """ 414: Returns 1 or -1 depending on the sign of x 415: """ 416: if( x >= 0 ): 417: return 1 418: else: 419: return : 421: def arrayinvert(array): 422: """ 423: Inverts a matrix stored as a list of lists. 424: """ 425: result = [[] for i in array] 426: for outer in array: 427: for inner in range(len(outer)): 428: result[inner].append(outer[inner]) 429: return result 430: 431: def matrixaslist( matrix, value = True ): 432: """ 433: Turns a matrix into a list of coordinates matching the specified value 434: """ 435: rows, cols = len( matrix ), len( matrix[0] ) 436: cells = [] 437: for row in range( rows ): 438: for col in range( cols ): 439: if matrix[row][col] == value: 440: cells.append( ( row, col ) ) 441: return cells 442: 443: def lookup(name, namespace): 444: """ 445: Get a method or class from any imported module from its name. 446: Usage: lookup(functionname, globals()) 447: """ 448: dots = name.count(. ) 449: if dots > 0: 450: modulename, objname =..join(name.split(. )[:-1]), name.split(. )[-1] 451: module = import (modulename) 452: return getattr(module, objname) 453: else: 454: modules = [obj for obj in namespace.values() if str(type(obj)) == "<type module

8 util.py Mon Jul 12 21:42: >"] 455: options = [getattr(module, name) for module in modules if name in dir(module)] 456: options += [obj[1] for obj in namespace.items() if obj[0] == name ] 457: if len(options) == 1: return options[0] 458: if len(options) > 1: raise Exception, Name conflict for %s 459: raise Exception, %s not found as a method or class % name 460: 461: def pause(): 462: """ 463: Pauses the output stream awaiting user feedback. 464: """ 465: print "<Press enter/return to continue>" 466: raw_input() 467: 468: 469: ## code to handle timeouts 470: import signal 471: class TimeoutFunctionException(Exception): 472: """Exception to raise on a timeout""" 473: pass 474: 475: class TimeoutFunction: 476: 477: def init (self, function, timeout): 478: "timeout must be at least 1 second. WHY??" 479: self.timeout = timeout 480: self.function = function 481: 482: def handle_timeout(self, signum, frame): 483: raise TimeoutFunctionException() 484: 485: def call (self, *args): 486: if not SIGALRM in dir(signal): 487: return self.function(*args) 488: old = signal.signal(signal.sigalrm, self.handle_timeout) 489: signal.alarm(self.timeout) 490: try: 491: result = self.function(*args) 492: finally: 493: signal.signal(signal.sigalrm, old) 494: signal.alarm(0) 495: return result

What is an algorithm?

What is an algorithm? Announcements CS 142 Stacks & Queues Program 3 has been assigned due 10/6 by 11:55pm Program details on website 2 Creating new Data Structures We ve used objects to create new data types such as Point,