Consistent Variable Naming (aimacode#220)

* Change variable names from s_prime to s1, current_state to s1

* Sane default for update_state

Author: reachtarunhere

rl.py

@@ -39,18 +39,18 @@ def __init__(self, pi, mdp, alpha=None):
             self.alpha = lambda n: 1./(1+n)  # udacity video
 
     def __call__(self, percept):
-        s_prime, r_prime = self.update_state(percept)
+        s1, r1 = self.update_state(percept)
         pi, U, Ns, s, a, r = self.pi, self.U, self.Ns, self.s, self.a, self.r
         alpha, gamma, terminals = self.alpha, self.gamma, self.terminals
-        if not Ns[s_prime]:
-            U[s_prime] = r_prime
+        if not Ns[s1]:
+            U[s1] = r1
         if s is not None:
             Ns[s] += 1
-            U[s] += alpha(Ns[s]) * (r + gamma * U[s_prime] - U[s])
-        if s_prime in terminals:
+            U[s] += alpha(Ns[s]) * (r + gamma * U[s1] - U[s])
+        if s1 in terminals:
             self.s = self.a = self.r = None
         else:
-            self.s, self.a, self.r = s_prime, pi[s_prime], r_prime
+            self.s, self.a, self.r = s1, pi[s1], r1
         return self.a
 
     def update_state(self, percept):

search.py

@@ -437,34 +437,35 @@ def __init__(self, problem):
         self.result = {}
 
     def __call__(self, percept):
-        current_state = self.update_state(percept)
-        if self.problem.goal_test(current_state):
+        s1 = self.update_state(percept)
+        if self.problem.goal_test(s1):
             self.a = None
         else:
-            if current_state not in self.untried.keys():
-                self.untried[current_state] = self.problem.actions(
-                                                current_state)
+            if s1 not in self.untried.keys():
+                self.untried[s1] = self.problem.actions(s1)
             if self.s is not None:
-                if current_state != self.result[(self.s, self.a)]:
-                    self.result[(self.s, self.a)] = current_state
-                    unbacktracked[current_state].insert(0, self.s)
-            if len(self.untried[current_state]) == 0:
-                if len(self.unbacktracked[current_state]) == 0:
+                if s1 != self.result[(self.s, self.a)]:
+                    self.result[(self.s, self.a)] = s1
+                    unbacktracked[s1].insert(0, self.s)
+            if len(self.untried[s1]) == 0:
+                if len(self.unbacktracked[s1]) == 0:
                     self.a = None
                 else:
                     # else a <- an action b such that result[s', b] = POP(unbacktracked[s'])  # noqa
-                    unbacktracked_pop = self.unbacktracked[current_state].pop(0)  # noqa
+                    unbacktracked_pop = self.unbacktracked[s1].pop(0)  # noqa
                     for (s, b) in self.result.keys():
                         if self.result[(s, b)] == unbacktracked_pop:
                             self.a = b
                             break
             else:
-                self.a = self.untried[current_state].pop(0)
-        self.s = current_state
+                self.a = self.untried[s1].pop(0)
+        self.s = s1
         return self.a
 
     def update_state(self, percept):
-        raise NotImplementedError
+        ''' To be overriden in most cases. The default case
+        assumes th percept to be of type state'''
+        raise percept
 
 # ______________________________________________________________________________