NolanBecker
diff --git a/‎agents.py‎
Lines changed: 23 additions & 23 deletions b/‎agents.py‎
Lines changed: 23 additions & 23 deletions
diff --git a/‎csp.py‎
Lines changed: 12 additions & 12 deletions b/‎csp.py‎
Lines changed: 12 additions & 12 deletions
diff --git a/‎doctests.py‎
Lines changed: 2 additions & 2 deletions b/‎doctests.py‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎games.py‎
Lines changed: 6 additions & 6 deletions b/‎games.py‎
Lines changed: 6 additions & 6 deletions
@@ -65,7 +65,7 @@ class Agent(Thing):
     """An Agent is a subclass of Thing with one required slot,
     .program, which should hold a function that takes one argument, the
     percept, and returns an action. (What counts as a percept or action
-    will depend on the specific environment in which the agent exists.) 
+    will depend on the specific environment in which the agent exists.)
     Note that 'program' is a slot, not a method.  If it were a method,
     then the program could 'cheat' and look at aspects of the agent.
     It's not supposed to do that: the program can only look at the
@@ -87,7 +87,7 @@ def can_grab(self, thing):
         """Returns True if this agent can grab this thing.
         Override for appropriate subclasses of Agent and Thing."""
         return False
-    
+
 def TraceAgent(agent):
     """Wrap the agent's program to print its input and output. This will let
     you see what the agent is doing in the environment."""
@@ -253,7 +253,7 @@ def list_things_at(self, location, tclass=Thing):
         "Return all things exactly at a given location."
         return [thing for thing in self.things
                 if thing.location == location and isinstance(thing, tclass)]
-    
+
     def some_things_at(self, location, tclass=Thing):
         """Return true if at least one of the things at location
         is an instance of class tclass (or a subclass)."""
@@ -297,7 +297,7 @@ class XYEnvironment(Environment):
     def __init__(self, width=10, height=10):
         super(XYEnvironment, self).__init__()
         update(self, width=width, height=height, observers=[])
-        
+
     def things_near(self, location, radius=None):
         "Return all things within radius of location."
         if radius is None: radius = self.perceptible_distance
@@ -343,7 +343,7 @@ def move_to(self, thing, destination):
             thing.location = destination
             for o in self.observers:
                 o.thing_moved(thing)
-        
+
     def add_thing(self, thing, location=(1, 1)):
         super(XYEnvironment, self).add_thing(thing, location)
         thing.holding = []
@@ -356,7 +356,7 @@ def delete_thing(self, thing):
         # Any more to do?  Thing holding anything or being held?
         for obs in self.observers:
             obs.thing_deleted(thing)
-    
+
     def add_walls(self):
         "Put walls around the entire perimeter of the grid."
         for x in range(self.width):
@@ -367,14 +367,14 @@ def add_walls(self):
             self.add_thing(Wall(), (self.width-1, y))
 
     def add_observer(self, observer):
-        """Adds an observer to the list of observers.  
+        """Adds an observer to the list of observers.
         An observer is typically an EnvGUI.
-        
+
         Each observer is notified of changes in move_to and add_thing,
         by calling the observer's methods thing_moved(thing)
         and thing_added(thing, loc)."""
         self.observers.append(observer)
-        
+
     def turn_heading(self, heading, inc):
         "Return the heading to the left (inc=+1) or right (inc=-1) of heading."
         return turn_heading(heading, inc)
@@ -388,11 +388,11 @@ class Wall(Obstacle):
     pass
 
 #______________________________________________________________________________
-## Vacuum environment 
+## Vacuum environment
 
 class Dirt(Thing):
     pass
-    
+
 class VacuumEnvironment(XYEnvironment):
     """The environment of [Ex. 2.12]. Agent perceives dirty or clean,
     and bump (into obstacle) or not; 2D discrete world of unknown size;
@@ -440,9 +440,9 @@ def __init__(self):
                        loc_B: random.choice(['Clean', 'Dirty'])}
 
     def thing_classes(self):
-        return [Wall, Dirt, ReflexVacuumAgent, RandomVacuumAgent, 
+        return [Wall, Dirt, ReflexVacuumAgent, RandomVacuumAgent,
                 TableDrivenVacuumAgent, ModelBasedVacuumAgent]
-    
+
     def percept(self, agent):
         "Returns the agent's location, and the location status (Dirty/Clean)."
         return (agent.location, self.status[agent.location])
@@ -485,16 +485,16 @@ def thing_classes(self):
 
     ## Needs a lot of work ...
 
-    
+
 #______________________________________________________________________________
 
 def compare_agents(EnvFactory, AgentFactories, n=10, steps=1000):
     """See how well each of several agents do in n instances of an environment.
     Pass in a factory (constructor) for environments, and several for agents.
-    Create n instances of the environment, and run each agent in copies of 
+    Create n instances of the environment, and run each agent in copies of
     each one for steps. Return a list of (agent, average-score) tuples."""
     envs = [EnvFactory() for i in range(n)]
-    return [(A, test_agent(A, steps, copy.deepcopy(envs))) 
+    return [(A, test_agent(A, steps, copy.deepcopy(envs)))
             for A in AgentFactories]
 
 def test_agent(AgentFactory, steps, envs):
@@ -527,7 +527,7 @@ def score(env):
 ## give is a range of expected scores.  If this test fails, it does
 ## not necessarily mean something is wrong.
 >>> envs = [TrivialVacuumEnvironment() for i in range(100)]
->>> def testv(A): return test_agent(A, 4, copy.deepcopy(envs)) 
+>>> def testv(A): return test_agent(A, 4, copy.deepcopy(envs))
 >>> 7 < testv(ModelBasedVacuumAgent) < 11
 True
 >>> 5 < testv(ReflexVacuumAgent) < 9
@@ -551,12 +551,12 @@ class EnvGUI(tk.Tk, object):
     def __init__(self, env, title = 'AIMA GUI', cellwidth=50, n=10):
 
         # Initialize window
-        
+
         super(EnvGUI, self).__init__()
         self.title(title)
 
         # Create components
-        
+
         canvas = EnvCanvas(self, env, cellwidth, n)
         toolbar = EnvToolbar(self, env, canvas)
         for w in [canvas, toolbar]:
@@ -569,14 +569,14 @@ def __init__(self, parent, env, canvas):
         super(EnvToolbar, self).__init__(parent, relief='raised', bd=2)
 
         # Initialize instance variables
-        
+
         self.env = env
         self.canvas = canvas
         self.running = False
         self.speed = 1.0
 
         # Create buttons and other controls
-        
+
         for txt, cmd in [('Step >', self.env.step),
                          ('Run >>', self.run),
                          ('Stop [ ]', self.stop),
@@ -608,7 +608,7 @@ def background_run(self):
             delay_sec = 1.0 / max(self.speed, 1.0) # avoid division by zero
             ms = int(1000.0 * delay_sec)  # seconds to milliseconds
             self.after(ms, self.background_run)
-        
+
     def list_things(self):
         print "Things in the environment:"
         for thing in self.env.things:
@@ -621,4 +621,4 @@ def list_agents(self):
 
     def set_speed(self, speed):
         self.speed = float(speed)
-    
+
@@ -53,7 +53,7 @@ def __init__(self, vars, domains, neighbors, constraints):
         update(self, vars=vars, domains=domains,
                neighbors=neighbors, constraints=constraints,
                initial=(), curr_domains=None, nassigns=0)
-        
+
     def assign(self, var, val, assignment):
         "Add {var: val} to assignment; Discard the old value if any."
         assignment[var] = val
@@ -91,7 +91,7 @@ def actions(self, state):
             var = find_if(lambda v: v not in assignment, self.vars)
             return [(var, val) for val in self.domains[var]
                     if self.nconflicts(var, val, assignment) == 0]
-    
+
     def result(self, state, (var, val)):
         "Perform an action and return the new state."
         return state + ((var, val),)
@@ -137,7 +137,7 @@ def restore(self, removals):
     def infer_assignment(self):
         "Return the partial assignment implied by the current inferences."
         self.support_pruning()
-        return dict((v, self.curr_domains[v][0]) 
+        return dict((v, self.curr_domains[v][0])
                     for v in self.vars if 1 == len(self.curr_domains[v]))
 
     ## This is for min_conflicts search
@@ -242,7 +242,7 @@ def backtrack(assignment):
     result = backtrack({})
     assert result is None or csp.goal_test(result)
     return result
-                
+
 #______________________________________________________________________________
 # Constraint Propagation with AC-3
 
@@ -292,7 +292,7 @@ def min_conflicts_value(csp, var, current):
     """Return the value that will give var the least number of conflicts.
     If there is a tie, choose at random."""
     return argmin_random_tie(csp.domains[var],
-                             lambda val: csp.nconflicts(var, val, current)) 
+                             lambda val: csp.nconflicts(var, val, current))
 
 #______________________________________________________________________________
 # Map-Coloring Problems
@@ -319,7 +319,7 @@ def MapColoringCSP(colors, neighbors):
     specified as a string of the form defined by parse_neighbors"""
 
     if isinstance(neighbors, str):
-        neighbors = parse_neighbors(neighbors)     
+        neighbors = parse_neighbors(neighbors)
     return CSP(neighbors.keys(), UniversalDict(colors), neighbors,
                different_values_constraint)
 
@@ -345,7 +345,7 @@ def parse_neighbors(neighbors, vars=[]):
 
 australia = MapColoringCSP(list('RGB'),
                            'SA: WA NT Q NSW V; NT: WA Q; NSW: Q V; T: ')
-    
+
 usa = MapColoringCSP(list('RGBY'),
         """WA: OR ID; OR: ID NV CA; CA: NV AZ; NV: ID UT AZ; ID: MT WY UT;
         UT: WY CO AZ; MT: ND SD WY; WY: SD NE CO; CO: NE KA OK NM; NM: OK TX;
@@ -398,7 +398,7 @@ def __init__(self, n):
                      UniversalDict(range(n)), queen_constraint)
         update(self, rows=[0]*n, ups=[0]*(2*n - 1), downs=[0]*(2*n - 1))
 
-    def nconflicts(self, var, val, assignment): 
+    def nconflicts(self, var, val, assignment):
         """The number of conflicts, as recorded with each assignment.
         Count conflicts in row and in up, down diagonals. If there
         is a queen there, it can't conflict with itself, so subtract 3."""
@@ -422,7 +422,7 @@ def unassign(self, var, assignment):
         if var in assignment:
             self.record_conflict(assignment, var, assignment[var], -1)
         CSP.unassign(self, var, assignment)
-        
+
     def record_conflict(self, assignment, var, val, delta):
         "Record conflicts caused by addition or deletion of a Queen."
         n = len(self.vars)
@@ -443,8 +443,8 @@ def display(self, assignment):
             for var in range(n):
                 if assignment.get(var,'') == val: ch = '*'
                 else: ch = ' '
-                print str(self.nconflicts(var, val, assignment))+ch, 
-            print        
+                print str(self.nconflicts(var, val, assignment))+ch,
+            print
 
 #______________________________________________________________________________
 # Sudoku
@@ -568,7 +568,7 @@ def zebra_constraint(A, a, B, b, recurse=0):
             (A in Pets and B in Pets) or
             (A in Drinks and B in Drinks) or
             (A in Countries and B in Countries) or
-            (A in Smokes and B in Smokes)): return not same        
+            (A in Smokes and B in Smokes)): return not same
         raise 'error'
     return CSP(vars, domains, neighbors, zebra_constraint)
 
 
@@ -5,9 +5,9 @@
     python doctests.py *.py
     python doctests.py -v *.py
 
-You can add more module-level tests with 
+You can add more module-level tests with
     __doc__ += "..."
-You can add stochastic tests with 
+You can add stochastic tests with
     __doc__ += random_tests("...")
 """
 
 
@@ -5,7 +5,7 @@
 # from the third edition until this gets reviewed.)
 
 from utils import *
-import random 
+import random
 
 #______________________________________________________________________________
 # Minimax Search
@@ -39,7 +39,7 @@ def min_value(state):
 
 
 #______________________________________________________________________________
-    
+
 def alphabeta_full_search(state, game):
     """Search game to determine best action; use alpha-beta pruning.
     As in [Fig. 6.7], this version searches all the way to the leaves."""
@@ -157,7 +157,7 @@ def legal_moves(self, state):
     def make_move(self, move, state):
         "Return the state that results from making a move from a state."
         abstract
-            
+
     def utility(self, state, player):
         "Return the value of this final state to player."
         abstract
@@ -198,7 +198,7 @@ class Fig62Game(Game):
                  D=dict(d1='D1', d2='D2', d3='D3'))
     utils = Dict(B1=3, B2=12, B3=8, C1=2, C2=4, C3=6, D1=14, D2=5, D3=2)
     initial = 'A'
-    
+
     def legal_moves(self, state):
         return [move for (move, next) in self.successors(state)]
 
@@ -213,7 +213,7 @@ def utility(self, state, player):
             return self.utils[state]
         else:
             return -self.utils[state]
-    
+
     def terminal_test(self, state):
         return state not in ('A', 'B', 'C', 'D')
 
@@ -287,7 +287,7 @@ class ConnectFour(TicTacToe):
     """A TicTacToe-like game in which you can only make a move on the bottom
     row, or in a square directly above an occupied square.  Traditionally
     played on a 7x6 board and requiring 4 in a row."""
-    
+
     def __init__(self, h=7, v=6, k=4):
         TicTacToe.__init__(self, h, v, k)