Math::PlanePath::LTiling(3) 2x2 self-similar of four pattern parts

SYNOPSIS


use Math::PlanePath::LTiling;
my $path = Math::PlanePath::LTiling->new;
my ($x, $y) = $path->n_to_xy (123);

DESCRIPTION

This is a self-similar tiling by ``L'' shapes. A base ``L'' is replicated four times with end parts turned +90 and -90 degrees to make a larger L,

                                        +-----+-----+
                                        |12   |   15|
                                        |  +--+--+  |
                                        |  |14   |  |
                                        +--+  +--+--+
                                        |  |  |11   |
                                        |  +--+  +--+
                                        |13   |  |  |
                   +-----+              +-----+--+  +--+--+-----+
                   | 3   |              | 3   |  |10   |  |    5|
                   |  +--+        -->   |  +--+  +--+--+  +--+  |
                   |  |  |              |  |  | 8   |   9 |  |  |
    +--+           +--+  +--+--+        +--+  +--+--+--+--+  +--+
    |  |     -->   |  | 2   |  |        |  | 2   |  |  |   6 |  |
    |  +--+        |  +--+--+  |        |  +--+--+  |  +--+--+  |
    | 0   |        | 0   |   1 |        | 0   |   1 | 7   |   4 |
    +-----+        +-----+-----+        +-----+-----+-----+-----+

The parts are numbered to the left then middle then upper. This relative numbering is maintained when rotated at the next replication level, as for example N=4 to N=7.

The result is to visit 1 of every 3 points in the first quadrant with a subtle layout of points and spaces making diagonal lines and little 2x2 blocks.

    15  |  48          51  61          60 140         143 163
    14  |      50                  62         142                 168
    13  |          56          59                 139         162
    12  |  49          58              63 141             160
    11  |  55              44          47 131         138
    10  |          57          46                 136         137
     9  |      54                  43         130                 134
     8  |  52          53  45             128         129 135
     7  |  12          15  35          42              37  21
     6  |      14                  40          41                  22
     5  |          11          34                  38          25
     4  |  13              32          33  39          36
     3  |   3          10               5  31              26
     2  |           8           9                  27          24
     1  |       2                   6          30                  18
    Y=0 |   0           1   7           4  28          29  19
        +------------------------------------------------------------
          X=0   1   2   3   4   5   6   7   8   9  10  11  12  13  14

On the X=Y leading diagonal N=0,2,8,10,32,etc is the integers made from only digits 0 and 2 in base 4. Or equivalently integers which have zero bits at all even numbered positions, binary c0d0e0f0.

Left or Upper

Option "L_fill => "left"" or "L_fill => "upper"" numbers the tiles instead at their left end or upper end respectively.

    L_fill => 'left'           8  |      52              45  43        
                               7  |          15                      42
    +-----+                    6  |  12              35          40    
    |     |                    5  |      14                  34  33    
    |  +--+                    4  |      13  11          32            
    | 3|  |                    3  |                  10   9   5        
    +--+  +--+--+              2  |   3           8           6      31
    |  |    2| 1|              1  |           2   1               4    
    |  +--+--+  |             Y=0 |       0               7            
    |    0|     |                 +------------------------------------
    +-----+-----+                   X=0   1   2   3   4   5   6   7   8
    L_fill => 'upper'          8  |          53                  42
                               7  |      12              35  40
    +-----+                    6  |          14  15      34          41
    |    3|                    5  |  13          11  32              39
    |  +--+                    4  |              10          33
    |  | 2|                    3  |       3   8
    +--+  +--+--+              2  |       2           9           5
    | 0|     |  |              1  |   0               7   6          28
    |  +--+--+  |             Y=0 |           1               4
    |     | 1   |                 +------------------------------------
    +-----+-----+                   X=0   1   2   3   4   5   6   7   8

The effect is to disrupt the pattern a bit though the overall structure of the replications is unchanged.

``left'' is as viewed looking towards the L from above. It may have been better to call it ``right'', but won't change that now.

Ends

Option "L_fill => "ends"" numbers the two endpoints within each ``L'', first the left then upper. This is the inverse of the default middle shown above, ie. it visits all the points which the middle option doesn't, and so 2 of every 3 points in the first quadrant.

    +-----+
    |    7|
    |  +--+
    | 6| 5|
    +--+  +--+--+
    | 1|    4| 2|
    |  +--+--+  |
    |    0| 3   |
    +-----+-----+
     15  |      97 102         123 120         281 286         327 337
     14  |  96     101 103 122 124     121 280     285 287 326 325
     13  |  99 100     113 118     125 126 283 284     279 321     324
     12  |      98 112     117 119 127         282 278 277     320 323
     11  |     111 115 116      89  94         263 273     276 274 266
     10  | 110 109     114  88      93  95 262 261     272 275     268
      9  | 105     108 106  91  92      87 257     260 258 271 269
      8  |     104 107          90  86  85     256 259         270 265
      7  |      25  30          71  81      84  82  74          43  40
      6  |  24      29  31  70  69      80  83      76  75  42  44
      5  |  27  28      23  65      68  66  79  77      72  50      45
      4  |      26  22  21      64  67          78  73      52  51  47
      3  |       7  17      20  18  10          63  55  53      48  34
      2  |   6   5      16  19      12  11  62  61      54  49      36
      1  |   1       4   2  15  13       8  57      60  58  39  37
     Y=0 |       0   3          14   9          56  59          38  33
         +------------------------------------------------------------
           X=0   1   2   3   4   5   6   7   8   9  10  11  12  13  14

All

Option "L_fill => "all"" numbers all three points of each ``L'', as middle, left then right. With this the path visits all points of the first quadrant.

                           7  |  36  38  46  45 105 107 122 126
    +-----+                6  |  37  42  44  47 106 104 120 121
    | 9 11|                5  |  41  43  33  35  98 102 103 100
    |  +--+                4  |  39  40  34  32  96  97 101  99
    |10| 8|                3  |   9  11  26  30  31  28  16  15
    +--+  +--+--+          2  |  10   8  24  25  29  27  19  17
    | 2| 6  7| 4|          1  |   2   6   7   4  23  20  18  13
    |  +--+--+  |         Y=0 |   0   1   5   3  21  22  14  12
    | 0  1| 5  3|             +--------------------------------
    +-----+-----+               X=0   1   2   3   4   5   6   7

Along the X=Y leading diagonal N=0,6,24,30,96,etc are triples of the values from the single-point case, so 3* numbers using digits 0 and 2 in base 4, which is the same as 2* numbers using 0 and 3 in base 4.

Level Ranges

For the ``middles'', ``left'' or ``upper'' cases with one N per tile, and taking the initial N=0 tile as level 0, a replication level is

    Nstart = 0
     to
    Nlevel = 4^level - 1      inclusive
    Xmax = Ymax = 2 * 2^level - 1

For example level 2 which is the large tiling shown in the introduction is N=0 to N=4^2-1=15 and extends to Xmax=Ymax=2*2^2-1=7.

For the ``ends'' variation there's two points per tile, or for ``all'' there's three, in which case the Nlevel increases to

    Nlevel_ends = 2 * 4^level - 1
    Nlevel_all  = 3 * 4^level - 1

FUNCTIONS

See ``FUNCTIONS'' in Math::PlanePath for behaviour common to all path classes.
"$path = Math::PlanePath::LTiling->new ()"
"$path = Math::PlanePath::LTiling->new (L_fill => $str)"
Create and return a new path object. The "L_fill" choices are

    "middle"    the default
    "left"
    "upper"
    "ends"
    "all"
"($x,$y) = $path->n_to_xy ($n)"
Return the X,Y coordinates of point number $n on the path. Points begin at 0 and if "$n < 0" then the return is an empty list.

Level Methods

"($n_lo, $n_hi) = $path->level_to_n_range($level)"
Return

    0,   4**$level - 1      middle, left, upper
    0, 2*4**$level - 1      ends
    0, 3*4**$level - 1      all

There are 4^level L shapes in a level, each containing 1, 2 or 3 points, numbered starting from 0.

OEIS

Entries in Sloane's Online Encyclopedia of Integer Sequences related to this path include

<http://oeis.org/A062880> (etc)

    L_fill=middle
      A062880    N on X=Y diagonal, base 4 digits 0,2 only
      A048647    permutation N at transpose Y,X
                   base4 digits 1<->3 and 0,2 unchanged
      A112539    X+Y+1 mod 2, parity inverted
    L_fill=left or upper
      A112539    X+Y mod 2, parity

A112539 is a parity of bits at even positions in N, ie. count 1-bits at even bit positions (least significant is bit position 0), then add 1 and take mod 2. This works because in the pattern sub-blocks 0 and 2 are unchanged and 1 and 3 are turned so as to be on opposite X,Y odd/even parity, so a flip for every even position 1-bit. L_fill=middle starts on a 0 even parity, and L_fill=left and upper start on 1 odd parity. The latter is the form in A112539 and L_fill=middle is the bitwise 0<->1 inverse.

LICENSE

Copyright 2011, 2012, 2013, 2014, 2015, 2016 Kevin Ryde

This file is part of Math-PlanePath.

Math-PlanePath is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version.

Math-PlanePath is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with Math-PlanePath. If not, see <http://www.gnu.org/licenses/>.