added doctest in Sudoku for AC4 and and the possibility of choosing the constant propagation algorithm in mac inference

dmeoli · dmeoli · commit 6986247481a0 · 2019-04-11T22:01:42.000+02:00
diff --git a/csp.py b/csp.py
@@ -290,9 +290,9 @@ def forward_checking(csp, var, value, assignment, removals):
     return True
 
 
-def mac(csp, var, value, assignment, removals):
+def mac(csp, var, value, assignment, removals, constraint_propagation=AC3):
     """Maintain arc consistency."""
-    return AC3(csp, {(X, var) for X in csp.neighbors[var]}, removals)
+    return constraint_propagation(csp, {(X, var) for X in csp.neighbors[var]}, removals)
 
 
 # The search, proper
@@ -326,11 +326,11 @@ def backtrack(assignment):
 
 
 # ______________________________________________________________________________
-# Min-conflicts hillclimbing search for CSPs
+# Min-conflicts Hill Climbing search for CSPs
 
 
 def min_conflicts(csp, max_steps=100000):
-    """Solve a CSP by stochastic hillclimbing on the number of conflicts."""
+    """Solve a CSP by stochastic Hill Climbing on the number of conflicts."""
     # Generate a complete assignment for all variables (probably with conflicts)
     csp.current = current = {}
     for var in csp.variables:
@@ -532,7 +532,7 @@ def queen_constraint(A, a, B, b):
     return A == B or (a != b and A + a != B + b and A - a != B - b)
 
 
-class NQueensCSP(CSP):
+class NQueens(CSP):
     """Make a CSP for the nQueens problem for search with min_conflicts.
     Suitable for large n, it uses only data structures of size O(n).
     Think of placing queens one per column, from left to right.
@@ -548,7 +548,7 @@ class NQueensCSP(CSP):
     a variable, and a best value for the variable, are each O(n).
     If you want, you can keep track of conflicted variables, then variable
     selection will also be O(1).
-    >>> len(backtracking_search(NQueensCSP(8)))
+    >>> len(backtracking_search(NQueens(8)))
     8
     """
 
@@ -673,7 +673,37 @@ class Sudoku(CSP):
     >>> h = Sudoku(harder1)
     >>> backtracking_search(h, select_unassigned_variable=mrv, inference=forward_checking) is not None
     True
-    """  # noqa
+
+    >>> e = Sudoku(easy1)
+    >>> e.display(e.infer_assignment())
+    . . 3 | . 2 . | 6 . .
+    9 . . | 3 . 5 | . . 1
+    . . 1 | 8 . 6 | 4 . .
+    ------+-------+------
+    . . 8 | 1 . 2 | 9 . .
+    7 . . | . . . | . . 8
+    . . 6 | 7 . 8 | 2 . .
+    ------+-------+------
+    . . 2 | 6 . 9 | 5 . .
+    8 . . | 2 . 3 | . . 9
+    . . 5 | . 1 . | 3 . .
+    >>> AC4(e); e.display(e.infer_assignment())
+    True
+    4 8 3 | 9 2 1 | 6 5 7
+    9 6 7 | 3 4 5 | 8 2 1
+    2 5 1 | 8 7 6 | 4 9 3
+    ------+-------+------
+    5 4 8 | 1 3 2 | 9 7 6
+    7 2 9 | 5 6 4 | 1 3 8
+    1 3 6 | 7 9 8 | 2 4 5
+    ------+-------+------
+    3 7 2 | 6 8 9 | 5 1 4
+    8 1 4 | 2 5 3 | 7 6 9
+    6 9 5 | 4 1 7 | 3 8 2
+    >>> h = Sudoku(harder1)
+    >>> backtracking_search(h, select_unassigned_variable=mrv, inference=forward_checking) is not None
+    True
+    """
 
     R3 = _R3
     Cell = _CELL
diff --git a/tests/test_csp.py b/tests/test_csp.py
@@ -376,12 +376,12 @@ def test_min_conflicts():
 
     australia_impossible = MapColoringCSP(list('RG'), 'SA: WA NT Q NSW V; NT: WA Q; NSW: Q V; T: ')
     assert min_conflicts(australia_impossible, 1000) is None
-    assert min_conflicts(NQueensCSP(2), 1000) is None
-    assert min_conflicts(NQueensCSP(3), 1000) is None
+    assert min_conflicts(NQueens(2), 1000) is None
+    assert min_conflicts(NQueens(3), 1000) is None
 
 
 def test_nqueens_csp():
-    csp = NQueensCSP(8)
+    csp = NQueens(8)
 
     assignment = {0: 0, 1: 1, 2: 2, 3: 3, 4: 4}
     csp.assign(5, 5, assignment)
@@ -428,7 +428,7 @@ def test_nqueens_csp():
     assert 6 not in assignment
 
     for n in range(5, 9):
-        csp = NQueensCSP(n)
+        csp = NQueens(n)
         solution = min_conflicts(csp)
         assert not solution or sorted(solution.values()) == list(range(n))
 
