updated point placement tests

Author: christianbean

tests/strategies/equivalence_strategies/test_point_placements.py

@@ -1,8 +1,6 @@
 from permuta import Perm
 from permuta.misc import DIR_EAST, DIR_NORTH, DIR_SOUTH, DIR_WEST, DIRS
 from tilescopethree.strategies import point_placement, requirement_placement
-from tilescopethree.strategies.equivalence_strategies.point_placements import \
-    place_point_of_requirement
 from tilings import Obstruction, Requirement, Tiling
 
 pytest_plugins = [
@@ -14,17 +12,19 @@
 
 
 def test_point_placement(diverse_tiling, no_point_tiling):
+    print(no_point_tiling)
+    print(no_point_tiling.positive_cells)
     strats = list(point_placement(diverse_tiling))
-    assert len(strats) == 3 * len(DIRS)
-
+    assert len(strats) == 5 * len(DIRS)
     strats = list(requirement_placement(no_point_tiling))
-    assert len(strats) == 3 * len(DIRS)
+    assert len(strats) == 9 * len(DIRS)
     strats = list(point_placement(no_point_tiling))
-    assert len(strats) == 0
+    assert len(strats) == 3 * len(DIRS)
 
 
 def test_place_point_of_requirement_point_only(diverse_tiling):
-    tiling = place_point_of_requirement(diverse_tiling, 0, 0, DIR_WEST)
+    tiling = diverse_tiling.place_point_of_gridded_permutation(
+                                diverse_tiling.requirements[0][0], 0, DIR_WEST)
     assert tiling == Tiling(
         obstructions=[
             Obstruction(Perm((0,)), [(1, 0)]),
@@ -53,13 +53,43 @@ def test_place_point_of_requirement_point_only(diverse_tiling):
              Requirement(Perm((0, 2, 1)), [(0, 3), (0, 4), (1, 4)]),
              Requirement(Perm((0, 2, 1)), [(0, 3), (0, 4), (3, 4)])]])
 
-    assert tiling == place_point_of_requirement(diverse_tiling, 0, 0, DIR_EAST)
-    assert tiling == place_point_of_requirement(
-        diverse_tiling, 0, 0, DIR_NORTH)
-    assert tiling == place_point_of_requirement(
-        diverse_tiling, 0, 0, DIR_SOUTH)
+    assert tiling == diverse_tiling.place_point_of_gridded_permutation(
+                            diverse_tiling.requirements[0][0], 0, DIR_EAST)
+    assert tiling == diverse_tiling.place_point_of_gridded_permutation(
+                            diverse_tiling.requirements[0][0], 0, DIR_NORTH)
+    assert tiling == diverse_tiling.place_point_of_gridded_permutation(
+                            diverse_tiling.requirements[0][0], 0, DIR_SOUTH)
 
-    tiling = place_point_of_requirement(diverse_tiling, 1, 0, DIR_WEST)
+    print(Tiling(
+        obstructions=[
+            Obstruction(Perm((0,)), [(2, 0)]),
+            Obstruction(Perm((0,)), [(2, 2)]),
+            Obstruction(Perm((0, 1)), [(1, 0), (1, 0)]),
+            Obstruction(Perm((0, 1)), [(1, 0), (1, 2)]),
+            Obstruction(Perm((0, 1)), [(1, 2), (1, 2)]),
+            Obstruction(Perm((0, 1)), [(3, 1), (3, 1)]),
+            Obstruction(Perm((0, 1)), [(2, 3), (2, 3)]),
+            Obstruction(Perm((0, 1)), [(2, 3), (4, 3)]),
+            Obstruction(Perm((0, 1)), [(4, 3), (4, 3)]),
+            Obstruction(Perm((1, 0)), [(1, 0), (1, 0)]),
+            Obstruction(Perm((1, 0)), [(1, 2), (1, 0)]),
+            Obstruction(Perm((1, 0)), [(1, 2), (1, 2)]),
+            Obstruction(Perm((1, 0)), [(3, 1), (3, 1)]),
+            Obstruction(Perm((1, 0)), [(2, 3), (2, 3)]),
+            Obstruction(Perm((1, 0)), [(2, 3), (4, 3)]),
+            Obstruction(Perm((1, 0)), [(4, 3), (4, 3)]),
+            Obstruction(Perm((0, 1, 2)), [(0, 0), (1, 3), (1, 3)]),
+            Obstruction(Perm((0, 2, 3, 1)), [(0, 2), (1, 3), (1, 3), (4, 2)])],
+        requirements=[
+            [Requirement(Perm((0,)), [(3, 1)])],
+            [Requirement(Perm((0,)), [(1, 0)]),
+             Requirement(Perm((0,)), [(1, 2)])],
+            [Requirement(Perm((0,)), [(2, 3)]),
+             Requirement(Perm((0,)), [(4, 3)])],
+            [Requirement(Perm((1, 0)), [(0, 4), (0, 3)]),
+             Requirement(Perm((0, 2, 1)), [(0, 3), (0, 4), (1, 4)])]]))
+    tiling = diverse_tiling.place_point_of_gridded_permutation(
+                                diverse_tiling.requirements[1][0], 0, DIR_WEST)
     assert tiling == Tiling(
         obstructions=[
             Obstruction(Perm((0,)), [(2, 0)]),
@@ -90,14 +120,16 @@ def test_place_point_of_requirement_point_only(diverse_tiling):
              Requirement(Perm((0, 2, 1)), [(0, 3), (0, 4), (1, 4)])]])
 
     tiling = Tiling(requirements=[[Requirement(Perm((0,)), [(0, 0)])]])
-    assert place_point_of_requirement(tiling, 0, 0, DIR_SOUTH) == Tiling(
+    assert tiling.place_point_of_gridded_permutation(tiling.requirements[0][0],
+                                                     0, DIR_SOUTH) == Tiling(
         obstructions=[Obstruction(Perm((0, 1)), [(0, 0), (0, 0)]),
                       Obstruction(Perm((1, 0)), [(0, 0), (0, 0)])],
         requirements=[[Requirement(Perm((0,)), [(0, 0)])]])
 
 
 def test_place_point_of_requirement(no_point_tiling):
-    tiling = place_point_of_requirement(no_point_tiling, 2, 1, DIR_WEST)
+    tiling = no_point_tiling.place_point_of_gridded_permutation(
+                            no_point_tiling.requirements[2][0], 1, DIR_WEST)
     tiling2 = Tiling(
         obstructions=[
             Obstruction(Perm((0, 1)), [(0, 1), (1, 3)]),

tilescopethree/strategies/batch_strategies/__init__.py

@@ -8,7 +8,7 @@
                                           partial_row_and_col_placements,
                                           partial_row_placements,
                                           requirement_list_placement,
-                                          row_placements,
-                                          row_and_col_placements)
+                                          row_and_col_placements,
+                                          row_placements)
 from .requirement_corroboration import requirement_corroboration
 from .targeted_cell_insertion import targeted_cell_insertion

tilescopethree/strategies/batch_strategies/list_requirement_placements.py

@@ -15,33 +15,38 @@ def requirement_list_placement(tiling, **kwargs):
                             req_placement._direction_string(direction),
                             ", ".join(str(r) for r in req)))
 
+
 def row_placements(tiling, **kwargs):
     yield from RequirementPlacement(tiling).all_row_placement_rules()
 
+
 def col_placements(tiling, **kwargs):
     yield from RequirementPlacement(tiling).all_col_placement_rules()
 
+
 def row_and_col_placements(tiling, **kwargs):
     req_placements = RequirementPlacement(tiling)
     yield from req_placements.all_row_placement_rules()
     yield from req_placements.all_col_placement_rules()
 
+
 def partial_row_placements(tiling, **kwargs):
     req_placements = (RequirementPlacement(tiling, own_row=False),
                       RequirementPlacement(tiling, own_col=False))
     for req_placement in req_placements:
         yield from req_placement.all_row_placement_rules()
 
+
 def partial_col_placements(tiling, **kwargs):
     req_placements = (RequirementPlacement(tiling, own_row=False),
                       RequirementPlacement(tiling, own_col=False))
     for req_placement in req_placements:
         yield from req_placement.all_col_placement_rules()
 
+
 def partial_row_and_col_placements(tiling, **kwargs):
     req_placements = (RequirementPlacement(tiling, own_row=False),
                       RequirementPlacement(tiling, own_col=False))
     for req_placement in req_placements:
         yield from req_placement.all_row_placement_rules()
         yield from req_placement.all_col_placement_rules()
-

tilescopethree/strategies/equivalence_strategies/isolate_points.py

@@ -9,4 +9,4 @@ def point_isolations(tiling, **kwargs):
         if not tiling.only_cell_in_row_and_col():
             isolated_tiling = req_placement.place_point_in_cell(cell, DIR_WEST)
             yield EquivalenceRule("Isolate point at cell {}.".format(cell),
-                                isolated_tiling)
+                                  isolated_tiling)

tilescopethree/strategies/equivalence_strategies/point_placements.py

@@ -23,6 +23,7 @@ def point_placement(tiling, **kwargs):
     """
     yield from RequirementPlacement(tiling).all_point_placement_rules()
 
+
 def all_placements(tiling, **kwargs):
     req_placements = (RequirementPlacement(tiling),
                       RequirementPlacement(tiling, own_row=False),

tilescopethree/strategy_packs_v2.py

@@ -4,11 +4,12 @@
 from comb_spec_searcher import StrategyPack
 from comb_spec_searcher.utils import get_func_name
 from tilescopethree.strategies import (all_cell_insertions, all_col_insertions,
+                                       all_placements,
                                        all_requirement_insertions,
                                        all_row_insertions)
 from tilescopethree.strategies import col_placements as col_placements_strat
-from tilescopethree.strategies import (all_placements, database_verified, 
-                                       elementary_verified, factor, fusion,
+from tilescopethree.strategies import (database_verified, elementary_verified,
+                                       factor, fusion,
                                        fusion_with_interleaving,
                                        globally_verified,
                                        obstruction_transitivity,