rebesed to resolve comflicts in utils.py

Author: SnShine

README.md

@@ -1,25 +1,29 @@
-# `aima-python`: Structure of the Project
+# ![](https://github.com/aimacode/aima-java/blob/gh-pages/aima3e/images/aima3e.jpg)`aima-python` (Python 3.5)
 
-Python code for the book *Artificial Intelligence: A Modern Approach.*
-When complete, this project will cover all the major topics in the book, for each topic, such as `logic`, we will have the following [Python 3.5](https://www.python.org/downloads/release/python-350/) files in the main branch:
 
-- `logic.py`: Implementations of all the pseudocode algorithms in the book.
-- `logic_test.py`: A lightweight test suite, using `assert` statements, designed for use with `py.test`.
+Python code for the book *Artificial Intelligence: A Modern Approach.* We're loooking for one student sponsored by Google Summer of Code (GSoC) to work on this project; if you want to be that student, make some good contributions here (by looking throush the "Issues" and resolving some), and submit an application. (And we're always looking for solid contributors who are not affiliated with GSoC.)
+
+## Structure of the Project
+
+When complete, this project will have [Python 3.5](https://www.python.org/downloads/release/python-350/) code for all the pseudocode algorithms in the book. For each major topic, such as `logic`, we will have the following  files in the main branch:
+
+- `logic.py`: Implementations of all the pseudocode algorithms, and necessary support functions/classes/data.
+- `logic_test.py`: A lightweight test suite, using `assert` statements, designed for use with [`py.test`](http://pytest.org/latest/).
 - `logic.ipynb`: A Jupyter notebook, with examples of usage. Does a `from logic import *` to get the code.
 
-Until we get there, we will support a legacy branch, `aima3python2` (for the third edition of the textbook and for Python 2 code). To prepare code for the new master branch, the following two steps should be taken
+Until we get there, we will support a legacy branch, `aima3python2` (for the third edition of the textbook and for Python 2 code). To prepare code for the new master branch, the following two steps should be taken:
 
 ## Port to Python 3; Pythonic Idioms; py.test
 
 - Check for common problems in [porting to Python 3](http://python3porting.com/problems.html), such as: `print` is now a function; `range` and `map` and other functions no longer produce `list`s; objects of different types can no longer be compared with `<`; strings are now Unicode; it would be nice to move `%` string formating to `.format`; there is a new `next` function for generators; integer division now returns a float; we can now use set literals.
-- Replace poor idioms with proper Python. For example, we have many functions that were taken directly from Common Lisp, such as the `every` function: `every(callable, items)` returns true if every element of `items` is callable. This is good Lisp style, but good Python style would be to use `all` and a generator expression: `all(callable(f) for f in items)`. Eventually, fix all calls to these legacy Lisp functions and then remove the functions.
+- Replace old Lisp-based idioms with proper Python idioms. For example, we have many functions that were taken directly from Common Lisp, such as the `every` function: `every(callable, items)` returns true if every element of `items` is callable. This is good Lisp style, but good Python style would be to use `all` and a generator expression: `all(callable(f) for f in items)`. Eventually, fix all calls to these legacy Lisp functions and then remove the functions.
 - Create a `_test.py` file, and define functions that use `assert` to make tests. Remove any old `doctest` tests.
-In other words, replace the ">>> 2 + 2"  in a docstring with "assert 2 + 2 == 4" in `filename_test.py`.
+In other words, replace the ">>> 2 + 2 \n 4"  in a docstring with "assert 2 + 2 == 4" in `filename_test.py`.
 
 ## New and Improved Algorithms
 
-- Implement functions that were in the third edition of the book but were not yet implemented in the code.
-- As we finish chapters for the new fourth edition, we will share the pseudocode, and describe what changes are necessary.
+- Implement functions that were in the third edition of the book but were not yet implemented in the code. Check the [list of pseudocode algorithms (pdf)](http://aima.cs.berkeley.edu/algorithms.pdf) to see what's missing.
+- As we finish chapters for the new fourth edition, we will share the new pseudocode, and describe what changes are necessary.
 
 - Create a `.ipynb` notebook, and give examples of how to use the code.
 
@@ -47,7 +51,7 @@ Beyond the above rules, we use [Pep 8](https://www.python.org/dev/peps/pep-0008)
 # Choice of Programming Languages
 
 Are we right to concentrate on Java and Python versions of the code? I think so; both languages are popular; Java is
-fast enough for our purposes, and has reasonable type declarations (but can be verbose); Python is popular and has a very direct mapping to the pseudocode in the book (ut lacks type declarations and can be solw). The [TIOBE Index](http://www.tiobe.com/tiobe_index) says the top five most popular languages are:
+fast enough for our purposes, and has reasonable type declarations (but can be verbose); Python is popular and has a very direct mapping to the pseudocode in the book (but lacks type declarations and can be slow). The [TIOBE Index](http://www.tiobe.com/tiobe_index) says the top five most popular languages are:
 
         Java, C, C++, C#, Python
 

csp.py

@@ -530,7 +530,7 @@ def __init__(self, grid):
         the digits 1-9 denote a filled cell, '.' or '0' an empty one;
         other characters are ignored."""
         squares = iter(re.findall(r'\d|\.', grid))
-        domains = dict((var, if_(ch in '123456789', [ch], '123456789'))
+        domains = dict((var, ([ch] if ch in '123456789' else '123456789'))
                        for var, ch in zip(flatten(self.rows), squares))
         for _ in squares:
             raise ValueError("Not a Sudoku grid", grid) # Too many squares

games.py

@@ -41,6 +41,7 @@ def alphabeta_full_search(state, game):
 
     player = game.to_move(state)
 
+    #Functions used by alphabeta
     def max_value(state, alpha, beta):
         if game.terminal_test(state):
             return game.utility(state, player)
@@ -64,16 +65,15 @@ def min_value(state, alpha, beta):
         return v
 
     # Body of alphabeta_search:
-    return argmax(game.actions(state),
-                  lambda a: min_value(game.result(state, a),
-                                      -infinity, infinity))
+    return max_value(state, -infinity, infinity)
 
 def alphabeta_search(state, game, d=4, cutoff_test=None, eval_fn=None):
     """Search game to determine best action; use alpha-beta pruning.
     This version cuts off search and uses an evaluation function."""
 
     player = game.to_move(state)
 
+    #Functions used by alphabeta
     def max_value(state, alpha, beta, depth):
         if cutoff_test(state, depth):
             return eval_fn(state)
@@ -103,9 +103,7 @@ def min_value(state, alpha, beta, depth):
     cutoff_test = (cutoff_test or
                    (lambda state,depth: depth>d or game.terminal_test(state)))
     eval_fn = eval_fn or (lambda state: game.utility(state, player))
-    return argmax(game.actions(state),
-                  lambda a: min_value(game.result(state, a),
-                                      -infinity, infinity, 0))
+    return max_value(state, -infinity, infinity, 0)
 
 #______________________________________________________________________________
 # Players for Games
@@ -207,7 +205,7 @@ def terminal_test(self, state):
         return state not in ('A', 'B', 'C', 'D')
 
     def to_move(self, state):
-        return if_(state in 'BCD', 'MIN', 'MAX')
+        return ('MIN' if state in 'BCD' else 'MAX')
 
 class TicTacToe(Game):
     """Play TicTacToe on an h x v board, with Max (first player) playing 'X'.
@@ -229,13 +227,13 @@ def result(self, state, move):
             return state # Illegal move has no effect
         board = state.board.copy(); board[move] = state.to_move
         moves = list(state.moves); moves.remove(move)
-        return Struct(to_move=if_(state.to_move == 'X', 'O', 'X'),
+        return Struct(to_move=('O' if state.to_move == 'X' else 'X'),
                       utility=self.compute_utility(board, move, state.to_move),
                       board=board, moves=moves)
 
     def utility(self, state, player):
         "Return the value to player; 1 for win, -1 for loss, 0 otherwise."
-        return if_(player == 'X', state.utility, -state.utility)
+        return (state.utility if player == 'X' else -state.utility)
 
     def terminal_test(self, state):
         "A state is terminal if it is won or there are no empty squares."
@@ -254,7 +252,7 @@ def compute_utility(self, board, move, player):
             self.k_in_row(board, move, player, (1, 0)) or
             self.k_in_row(board, move, player, (1, -1)) or
             self.k_in_row(board, move, player, (1, 1))):
-            return if_(player == 'X', +1, -1)
+            return (+1 if player == 'X' else -1)
         else:
             return 0
 

grid.py

@@ -0,0 +1,52 @@
+## OK, the following are not as widely useful utilities as some of the other
+## functions here, but they do show up wherever we have 2D grids: Wumpus and
+## Vacuum worlds, TicTacToe and Checkers, and markov decision Processes.
+##__________________________________________________________________________
+import math
+
+
+orientations = [(1, 0), (0, 1), (-1, 0), (0, -1)]
+
+def turn_heading(heading, inc, headings=orientations):
+    return headings[(headings.index(heading) + inc) % len(headings)]
+
+def turn_right(heading):
+    return turn_heading(heading, -1)
+
+def turn_left(heading):
+    return turn_heading(heading, +1)
+
+def distance(a, b):
+    """The distance between two (x, y) points.
+        >>> distance((1,2),(5,5))
+            5.0 
+      """
+    return math.hypot((a[0] - b[0]), (a[1] - b[1]))
+
+def distance_squared(a, b):
+    """The square of the distance between two (x, y) points.
+       >>> distance_squared((1,2),(5,5))
+           25.0
+    """
+    return (a[0]- b[0])**2 + (a[1] - b[1])**2
+
+def distance2(a, b):
+    "The square of the distance between two (x, y) points."
+    return distance_squared(a, b)
+    
+def clip(x, lowest, highest):
+    """Return x clipped to the range [lowest..highest].
+    >>> [clip(x, 0, 1) for x in [-1, 0.5, 10]]
+    [0, 0.5, 1]
+    """
+    return max(lowest, min(x, highest))
+
+
+def vector_clip(vector, lowest, highest):
+    """Return vector, except if any element is less than the corresponding
+    value of lowest or more than the corresponding value of highest, clip to
+    those values.
+    >>> vector_clip((-1, 10), (0, 0), (9, 9))
+    (0, 9)
+    """
+    return type(vector)(map(clip, vector, lowest, highest))

logic.py

@@ -743,7 +743,7 @@ def WalkSAT(clauses, p=0.5, max_flips=10000):
     for i in range(max_flips):
         satisfied, unsatisfied = [], []
         for clause in clauses:
-            if_(pl_true(clause, model), satisfied, unsatisfied).append(clause)
+            (satisfied if pl_true(clause, model) else unsatisfied).append(clause)
         if not unsatisfied: ## if model satisfies all the clauses
             return model
         clause = random.choice(unsatisfied)

mdp.py

@@ -21,6 +21,8 @@ def __init__(self, init, actlist, terminals, gamma=.9):
         self.init=init
         self.actlist=actlist
         self.terminals=terminals
+        if not (0 <= gamma < 1):
+            raise ValueError("An MDP must have 0 <= gamma < 1")
         self.gamma=gamma
         self.states=set()
         self.reward={}
@@ -72,7 +74,7 @@ def T(self, state, action):
     def go(self, state, direction):
         "Return the state that results from going in this direction."
         state1 = vector_add(state, direction)
-        return if_(state1 in self.states, state1, state)
+        return (state1 if state1 in self.states else state)
 
     def to_grid(self, mapping):
         """Convert a mapping from (x, y) to v into a [[..., v, ...]] grid."""

probability.py

@@ -236,7 +236,7 @@ def p(self, value, event):
         0.375"""
         assert isinstance(value, bool)
         ptrue = self.cpt[event_values(event, self.parents)]
-        return if_(value, ptrue, 1 - ptrue)
+        return (ptrue if value else 1 - ptrue)
 
     def sample(self, event):
         """Sample from the distribution for this variable conditioned

search.py

@@ -246,7 +246,7 @@ def recursive_dls(node, problem, limit):
                     cutoff_occurred = True
                 elif result is not None:
                     return result
-            return if_(cutoff_occurred, 'cutoff', None)
+            return ('cutoff' if cutoff_occurred else None)
 
     # Body of depth_limited_search:
     return recursive_dls(Node(problem.initial), problem, limit)
@@ -321,7 +321,7 @@ def hill_climbing(problem):
 
 def exp_schedule(k=20, lam=0.005, limit=100):
     "One possible schedule function for simulated annealing"
-    return lambda t: if_(t < limit, k * math.exp(-lam * t), 0)
+    return lambda t: (k * math.exp(-lam * t) if t < limit else 0)
 
 def simulated_annealing(problem, schedule=exp_schedule()):
     "[Fig. 4.5]"

utils.py

@@ -2,7 +2,6 @@
 
 TODO[COMPLETED]: Let's take the >>> doctest examples out of the docstrings, and put them in utils_test.py
 TODO: count_if and the like are leftovers from COmmon Lisp; let's make replace thenm with Pythonic alternatives.
-TODO: if_ is a terrible idea; replace all uses with (x if test else y) and remove if_
 TODO: Create a separate grid.py file for 2D grid environments; move headings, etc there.
 TODO: Priority queues may not belong here -- see treatment in search.py
 """
@@ -63,7 +62,10 @@ def unique(seq):
 
 def product(numbers):
     """Return the product of the numbers."""
-    return reduce(operator.mul, numbers, 1)
+    result=1
+    for i in numbers:
+        result=result*i
+    return result
 
 def count_if(predicate, seq):
     """Count the number of elements of seq for which the predicate is true."""
@@ -233,17 +235,26 @@ def turn_right(heading):
 def turn_left(heading):
     return turn_heading(heading, +1)
 
-def distance(a, b):
-    "The distance between two (x, y) points."
-    return math.hypot((a.x - b.x), (a.y - b.y))
+def Point(x, y):
+    return (x, y)
+
+def point_x(point):
+    return point[0]
 
-def distance_squared(a, b):
+def point_y(point):
+    return point[1]
+
+def distance(a, b):
     "The distance between two (x, y) points."
-    return (a.x - b.x)**2 + (a.y - b.y)**2
+    ax, ay = a
+    bx, by = b
+    return math.hypot((ax - bx), (ay - by))
 
 def distance2(a, b):
     "The square of the distance between two (x, y) points."
-    return distance_squared(a, b)
+    ax, ay = a
+    bx, by = b
+    return (ax - bx)**2 + (ay - by)**2
 
 def vector_clip(vector, lowest, highest):
     """Return vector, except if any element is less than the corresponding
@@ -291,22 +302,6 @@ def memoized_fn(*args):
 
     return memoized_fn
 
-def if_(test, result, alternative):
-    """Like C++ and Java's (test ? result : alternative), except
-    both result and alternative are always evaluated. However, if
-    either evaluates to a function, it is applied to the empty arglist,
-    so you can delay execution by putting it in a lambda.
-    """
-    if test:
-        if callable(result):
-            return result()
-
-        return result
-    else:
-        if callable(alternative):
-            return alternative()
-
-        return alternative
 
 def name(obj):
     "Try to find some reasonable name for the object."