 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.

## HOME PAGE

<http://user42.tuxfamily.org/math-planepath/index.html>

## 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/>.