def test_132_genf(): searcher = TileScope([Perm((0, 2, 1))], point_placements) spec = searcher.auto_search(smallest=True) spec = spec.expand_verified() av = Av([Perm((0, 2, 1))]) for i in range(10): assert set(av.of_length(i)) == set( gp.patt for gp in spec.generate_objects_of_size(i)) assert spec.random_sample_object_of_size(i).patt in av gf = spec.get_genf() gf = sympy.series(spec.get_genf(), n=15) x = sympy.Symbol("x") assert [gf.coeff(x, n) for n in range(13)] == [ 1, 1, 2, 5, 14, 42, 132, 429, 1430, 4862, 16796, 58786, 208012, ]
def gps_indices_direction_owncol_ownrow_ignoreparent_includeempty(strategy): return [ strategy( gps=gps, indices=indices, direction=direction, own_col=own_col, own_row=own_row, ignore_parent=ignore_parent, include_empty=include_empty, ) for ( gps, indices, ), direction, own_col, own_row, ignore_parent, include_empty in product( ( ((GriddedPerm(Perm((0, )), ((0, 0), )), ), (0, )), ((GriddedPerm.single_cell(Perm((0, 1, 2)), (2, 1)), ), (1, )), ( ( GriddedPerm(Perm((0, 1)), ((0, 1), (1, 1))), GriddedPerm(Perm((1, 0)), ((2, 2), (3, 1))), ), (1, 0), ), ), (DIR_EAST, DIR_WEST, DIR_NORTH, DIR_SOUTH), (True, False), (True, False), (True, False), (True, False), ) ]
def test_splitting_gf(): parent = Tiling( obstructions=( GriddedPerm.single_cell(Perm((0, 1)), (0, 1)), GriddedPerm.single_cell(Perm((0, 1)), (1, 0)), ), assumptions=( TrackingAssumption([ GriddedPerm.point_perm((0, 1)), GriddedPerm.point_perm((1, 0)) ]), TrackingAssumption([GriddedPerm.point_perm((1, 0))]), ), ) child = Tiling( obstructions=( GriddedPerm.single_cell(Perm((0, 1)), (0, 1)), GriddedPerm.single_cell(Perm((0, 1)), (1, 0)), ), assumptions=( TrackingAssumption([GriddedPerm.point_perm((0, 1))]), TrackingAssumption([GriddedPerm.point_perm((1, 0))]), ), ) strat = SplittingStrategy() rule = strat(parent) x, k0, k1 = var("x k_0 k_1") parent_func = Function("F_0")(x, k0, k1) child_func = Function("F_1")(x, k0, k1) expected_eq = Eq(parent_func, child_func.subs({k1: k0 * k1})) assert len(rule.children) == 1 assert rule.children[0] == child assert rule.constructor.get_equation(parent_func, (child_func, )) == expected_eq
def _cell_insertion_custom( self, x: int, y: int, button: int, _modifiers: int ) -> None: """Add a custom obstruction or requirement to a single cell. Args: x (int): The x coordinate of the mouse click. y (int): The y coordinate of the mouse click. button (int): The mouse button clicked. _modifiers (int): If combinded with modifiers (e.g. ctrl). Unused. """ tplot = self._current() if button == pyglet.window.mouse.LEFT: self._add_tiling( tplot.tiling.add_single_cell_requirement( Perm.to_standard(self._custom_data), tplot.get_cell(Point(x, y)), ) ) elif button == pyglet.window.mouse.RIGHT: self._add_tiling( tplot.tiling.add_single_cell_obstruction( Perm.to_standard(self._custom_data), tplot.get_cell(Point(x, y)), ) )
def test_pack(self, strategy, enum_verified): assert strategy.pack( enum_verified[0]) == TileScopePack.point_placements( ).add_verification(BasicVerificationStrategy(), replace=True) assert strategy.pack(enum_verified[1]) in ( TileScopePack.regular_insertion_encoding(2), TileScopePack.regular_insertion_encoding(3), ) assert strategy.pack( enum_verified[2]) == TileScopePack.regular_insertion_encoding(3) assert strategy.pack( enum_verified[3]) == TileScopePack.regular_insertion_encoding(2) assert strategy.pack( enum_verified[4]) == TileScopePack.row_and_col_placements( ).fix_one_by_one([Perm((0, 1, 2)), Perm((2, 3, 0, 1))]) assert strategy.pack( enum_verified[5]) == TileScopePack.row_and_col_placements( row_only=True).make_fusion(tracked=True).fix_one_by_one( [Perm((0, 1, 2))]) with pytest.raises(InvalidOperationError): strategy.pack(enum_verified[6])
def test_321_1324(): searcher = TileScope("321_1324", reginsenc) spec = searcher.auto_search() assert isinstance(spec, CombinatorialSpecification) for i in range(20): gp = spec.random_sample_object_of_size(i) assert all(cell == (0, 0) for cell in gp.pos) assert gp.patt.avoids(Perm((2, 1, 0)), Perm((0, 2, 1, 3))) assert [spec.count_objects_of_size(i) for i in range(50)] == [ 1, 1, 2, 5, 13, 32, 72, 148, 281, 499, 838, 1343, 2069, 3082, 4460, 6294, 8689, 11765, 15658, 20521, 26525, 33860, 42736, 53384, 66057, 81031, 98606, 119107, 142885, 170318, 201812, 237802, 278753, 325161, 377554, 436493, 502573, 576424, 658712, 750140, 851449, 963419, 1086870, 1222663, 1371701, 1534930, 1713340, 1907966, 2119889, 2350237, ]
def not_fact_tiling(): not_fact_tiling = Tiling(obstructions=[ GriddedPerm(Perm((0, 1)), ((0, 0), (0, 0))), GriddedPerm(Perm((0, 1)), ((0, 0), (0, 1))), GriddedPerm(Perm((0, 1)), ((0, 1), (0, 1))), ]) return not_fact_tiling
def obs_inf1(self, tiling1): obs_trans = ObstructionInferral(tiling1) obs_trans.potential_new_obs = MagicMock(return_value=[ GriddedPerm(Perm((0, 1)), [(0, 0), (0, 0)]), GriddedPerm(Perm((1, 0)), [(0, 0), (1, 0)]), ]) return obs_trans
def test_new_obs(self, obs_inf1, obs_inf2): assert set(obs_inf1.potential_new_obs()) == set( [GriddedPerm(Perm((0, )), ((1, 0), ))]) assert set(obs_inf2.potential_new_obs()) == set([ GriddedPerm(Perm((0, )), ((0, 0), )), GriddedPerm(Perm((0, )), ((2, 0), )) ])
def test_remove_cells(simpleob): assert simpleob.remove_cells([ (0, 0) ]) == GriddedPerm(Perm((1, 0)), ((2, 2), (2, 1))) assert simpleob.remove_cells([(0, 0), (2, 2) ]) == GriddedPerm(Perm((0, )), ((2, 1), )) assert simpleob.remove_cells([(0, 1), (1, 2)]) == simpleob
def col_tiling(): t = Tiling(obstructions=[ GriddedPerm(Perm((0, 2, 1)), ((0, 0), ) * 3), GriddedPerm(Perm((0, 2, 1)), ((1, 0), ) * 3), GriddedPerm(Perm((0, 1)), ((0, 0), (1, 0))), ]) return t
def enum_not_verified(self, onebyone_enum): t = Tiling(obstructions=[ GriddedPerm(Perm((0, 1)), ((0, 0), (0, 1))), GriddedPerm(Perm((0, 1)), ((0, 0), (0, 0))), GriddedPerm(Perm((0, 1)), ((0, 1), (0, 1))), ]) return [t, onebyone_enum]
def tiling_no_trans_col(): return Tiling( obstructions=[ GriddedPerm(Perm((0, 1)), [(0, 0), (0, 1)]), GriddedPerm(Perm((0, 1)), [(0, 1), (0, 2)]), ] )
def tiling_no_trans_row(): return Tiling( obstructions=[ GriddedPerm(Perm((0, 1)), [(0, 0), (1, 0)]), GriddedPerm(Perm((0, 1)), [(1, 0), (2, 0)]), ] )
def test_new_obs(self, obs_not_inf, obs_inf1, obs_inf2): assert obs_inf1.new_obs() == [ GriddedPerm(Perm((0, 1)), ((0, 0), (0, 0))), ] assert obs_not_inf.new_obs() == [] assert obs_inf2.new_obs() == [ GriddedPerm(Perm((0, 1)), ((0, 0), (2, 0))), ]
def test_apply_map(typicalob, simpleob): def cell_mapping(x): return (x[0] + 1, x[1] + 2) assert typicalob.apply_map(cell_mapping) == GriddedPerm( Perm((1, 0, 2, 4, 3)), ((1, 2), (1, 2), (2, 2), (2, 3), (2, 3))) assert simpleob.apply_map(cell_mapping) == GriddedPerm( Perm((1, 0, 3, 2)), ((1, 2), (1, 2), (3, 4), (3, 3)))
def deflated_tiling(tiling, cell, sum_decomp=True): """Return tiling where cell is deflated.""" if sum_decomp: extra = Obstruction.single_cell(Perm((1, 0)), cell) else: extra = Obstruction.single_cell(Perm((0, 1)), cell) return Tiling(requirements=tiling.requirements, obstructions=tiling.obstructions + (extra, ))
def tiling_simple_trans_row(): return Tiling( obstructions=[ GriddedPerm(Perm((0, 1)), [(0, 0), (1, 0)]), GriddedPerm(Perm((0, 1)), [(1, 0), (2, 0)]), ], requirements=[[GriddedPerm(Perm((0,)), [(1, 0)])]], )
def test_length_one_meshpatts_emptyness(self): for equivalent_shading in ([], [(0, 0)], [(1, 0)], [(0, 1), (1, 1)]): mp = MeshPatt(Perm((0,)), equivalent_shading) assert Cell(frozenset({mp}), frozenset()).is_empty() for nonequivalent_shading in ([(0, 0), (1, 1)], [(0, 1), (1, 0)]): mp = MeshPatt(Perm((0,)), nonequivalent_shading) assert not Cell(frozenset({mp}), frozenset()).is_empty()
def test_mixed_sorting(self): p1 = Perm((0, 2, 1)) mp1 = MeshPatt(p1, [(i, i) for i in range(4)]) p2 = Perm((1, 0)) mp2 = MeshPatt(p2, [(2 - i, 2 - i) for i in range(3)]) assert list(Utils.sorted({p1, mp1, p2, mp2})) == [p2, p1, mp2, mp1]
def __init__( self, pattern: Iterable[int] = (), positions: Iterable[Cell] = ()) -> None: self._patt = Perm(pattern) self._pos = tuple(positions) if len(self._patt) != len(self._pos): raise ValueError("Pattern and position list have unequal lengths.") self._cells: FrozenSet[Cell] = frozenset(self._pos)
def simple_tiling(): return Tiling( obstructions=[GriddedPerm(Perm((1, 0)), [(0, 1), (1, 0)])], requirements=[[ GriddedPerm(Perm((0, 1)), [(0, 0), (1, 0)]), GriddedPerm(Perm((0, 1)), [(0, 0), (1, 1)]), ]], )
def test_contradictory(simpleob, singlecellob, everycellob): assert not simpleob.contradictory() assert not singlecellob.contradictory() assert not everycellob.contradictory() gp = GriddedPerm(Perm((0, 1)), [(0, 1), (1, 0)]) assert gp.contradictory() gp = GriddedPerm(Perm((0, 1)), [(1, 0), (0, 0)]) assert gp.contradictory()
def enum_not_verified(self, enum_onebyone, enum_with_interleaving): t = Tiling(obstructions=[ GriddedPerm(Perm((0, 1, 2)), ((0, 1), ) * 3), GriddedPerm(Perm((0, 1, 2)), ((1, 2), ) * 3), GriddedPerm(Perm((0, 1, 2)), ((1, 0), ) * 3), GriddedPerm(Perm((1, 2, 0)), ((0, 1), (1, 2), (1, 0))), ]) return [t, enum_onebyone, enum_with_interleaving]
def enum_verified(self, enum_with_req): t = Tiling(obstructions=[ GriddedPerm(Perm((0, 2, 1)), ((0, 1), ) * 3), GriddedPerm(Perm((0, 2, 1)), ((1, 2), ) * 3), GriddedPerm(Perm((0, 2, 1)), ((2, 0), ) * 3), GriddedPerm(Perm((1, 2, 0)), ((0, 1), (1, 2), (2, 0))), ]) return [t, enum_with_req]
def test_single_cell(): gp = GriddedPerm.single_cell((0, 1, 2), (2, 3)) assert gp.patt == Perm((0, 1, 2)) assert gp.pos == ((2, 3), (2, 3), (2, 3)) gp = GriddedPerm.single_cell((0, ), (45, 64)) assert gp.patt == Perm((0, )) assert gp.pos == ((45, 64), )
def test_stretch_gridded_perms(placement1, placement1owncol, placement1ownrow): gps = [ GriddedPerm(Perm((0, 1)), [(0, 0), (1, 1)]), GriddedPerm(Perm((0, 1)), [(1, 1), (2, 2)]), ] for p in (placement1, placement1ownrow, placement1owncol): assert set(p._stretch_gridded_perms(gps, (1, 1))) == set( chain.from_iterable(p._stretch_gridded_perm(gp, (1, 1)) for gp in gps) )
def deflation_type(gp): patt = gp._patt poss = gp._pos if patt == Perm((0, 2, 1)) or patt == Perm((1, 2, 0)): if poss[0][1] == poss[2][1] and poss[1][1] > poss[0][1]: return True if patt == Perm((1, 0, 2)) or patt == Perm((2, 0, 1)): if poss[0][1] == poss[2][1] and poss[1][1] < poss[0][1]: return True
def __init__(self, avoids=tuple(), contains=tuple(), tiling=None): if tiling is not None and isinstance(tiling, Tiling): self.tiling = tiling else: obs, reqs = stretch_av_and_co(avoids, contains, [(0, 1), (1, 0)]) reqs.extend([[Requirement.single_cell(Perm((0,)), (0, 1))], [Requirement.single_cell(Perm((0,)), (1, 0))]]) self.tiling = Tiling(obs, reqs)
def test_potential_new_obs(self, obs_inf1, obs_not_inf): assert set(obs_inf1.potential_new_obs()) == set([ GriddedPerm(Perm((0, )), ((0, 0), )), GriddedPerm(Perm((0, 1)), ((0, 0), (0, 0))), GriddedPerm(Perm((0, 1)), ((0, 0), (1, 0))), GriddedPerm(Perm((1, 0)), ((0, 0), (1, 0))), ]) print(obs_not_inf._tiling) assert set(obs_not_inf.potential_new_obs()) == set([])