Provided by: libmath-planepath-perl_122-1_all bug

NAME

       Math::PlanePath::QuintetCentres -- self-similar "plus" shape centres

SYNOPSIS

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

DESCRIPTION

       This a self-similar curve tracing out a "+" shape like the "QuintetCurve" but taking the
       centre of each square visited by that curve.

                                                92                        12
                                              /  |
                   124-...                  93  91--90      88            11
                     |                        \       \   /   \
               122-123 120     102              94  82  89  86--87        10
                  \   /  |    /  |            /   /  |       |
                   121 119 103 101-100      95  81  83--84--85             9
                          \   \       \       \   \
               114-115-116 118 104  32  99--98  96  80  78                 8
                 |       |/   /   /  |       |/      |/   \
           112-113 110 117 105  31  33--34  97  36  79  76--77             7
              \   /   \       \   \       \   /   \      |
               111     109-108 106  30  42  35  38--37  75                 6
                             |/   /   /  |       |    /
                           107  29  43  41--40--39  74                     5
                                  \   \              |
                        24--25--26  28  44  46  72--73  70      68         4
                         |       |/      |/   \   \   /   \   /   \
                    22--23  20  27  18  45  48--47  71  56  69  66--67     3
                      \   /   \   /   \      |        /   \      |
                        21   6  19  16--17  49  54--55  58--57  65         2
                          /   \      |       |    \      |    /
                     4-- 5   8-- 7  15      50--51  53  59  64             1
                      \      |    /              |/      |    \
                 0-- 1   3   9  14              52      60--61  63     <- Y=0
                     |/      |    \                          |/
                     2      10--11  13                      62            -1
                                 |/
                                12                                        -2

                 ^
            -1  X=0  1   2   3   4   5   6   7   8   9  10  11  12  13

       The base figure is the initial the initial N=0 to N=4.  It fills a "+" shape as

                  .....
                  .   .
                  . 4 .
                  .  \.
              ........\....
              .   .   .\  .
              . 0---1 . 3 .
              .   . | ./  .
              ......|./....
                  . |/.
                  . 2 .
                  .   .
                  .....

   Arms
       The optional "arms" parameter can give up to four copies of the curve, each advancing
       successively.  For example "arms=>4" is as follows.  Notice the N=4*k points are the plain
       curve, and N=4*k+1, N=4*k+2 and N=4*k+3 are rotated copies of it.

                                69                     ...              7
                              /  |                        \
               121     113  73  65--61      53             120          6
              /   \   /   \   \       \   /   \           /
           ...     117 105-109  77  29  57  45--49     116              5
                         |    /   /  |       |            \
                       101  81  25  33--37--41  96-100-104 112          4
                         |    \   \              |       |/
                    50  97--93  85  21  13  88--92  80 108  72          3
                  /  |       |/      |/   \   \   /   \   /   \
                54  46--42  89  10  17   5-- 9  84  24  76  64--68      2
                  \      |    /  |       |        /   \      |
                    58  38  14   6-- 2   1  16--20  32--28  60          1
                  /      |    \               \      |    /
                62  30--34  22--18   3   0-- 4  12  36  56          <- Y=0
                 |    \   /          |       |/      |    \
            70--66  78  26  86  11-- 7  19   8  91  40--44  52         -1
              \   /   \   /   \   \   /  |    /  |       |/
                74 110  82  94--90  15  23  87  95--99  48             -2
                  /  |       |            \   \      |
               114 106-102--98  43--39--35  27  83 103                 -3
                  \              |       |/   /      |
                   118      51--47  59  31  79 111-107 119     ...     -4
                  /           \   /   \       \   \   /   \   /
               122              55      63--67  75 115     123         -5
                  \                          |/
                   ...                      71                         -6

                                         ^
            -7  -6  -5  -4  -3  -2  -1  X=0  1   2   3   4   5   6

       The pattern an ever expanding "+" shape with first cell N=0 at the origin.  The further
       parts are effectively as follows,

                       +---+
                       |   |
               +---+---    +---+
               |   |           |
           +---+   +---+   +---+
           |         2 | 1 |   |
           +---+   +---+---+   +---+
               |   | 3 | 0         |
               +---+   +---+   +---+
               |           |   |
               +---+   +---+---+
                   |   |
                   +---+

       At higher replication levels the sides become wiggly and spiralling, but they're symmetric
       and mesh to fill the plane.

FUNCTIONS

       See "FUNCTIONS" in Math::PlanePath for behaviour common to all path classes.

       "$path = Math::PlanePath::QuintetCentres->new ()"
       "$path = Math::PlanePath::QuintetCentres->new (arms => $a)"
           Create and return a new path object.

       "($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.

           Fractional positions give an X,Y position along a straight line between the integer
           positions.

       "$n = $path->n_start()"
           Return 0, the first N in the path.

       "($n_lo, $n_hi) = $path->rect_to_n_range ($x1,$y1, $x2,$y2)"
           In the current code the returned range is exact, meaning $n_lo and $n_hi are the
           smallest and biggest in the rectangle, but don't rely on that yet since finding the
           exact range is a touch on the slow side.  (The advantage of which though is that it
           helps avoid very big ranges from a simple over-estimate.)

   Level Methods
       "($n_lo, $n_hi) = $path->level_to_n_range($level)"
           Return "(0, 5**$level - 1)", or for multiple arms return "(0, $arms * 5**$level - 1)".

           There are 5^level points in a level, or arms*5^level for multiple arms, numbered
           starting from 0.

FORMULAS

   X,Y to N
       The "xy_to_n()" calculation is similar to the "FlowsnakeCentres".  For a given X,Y a
       modulo 5 remainder is formed

           m = (2*X + Y) mod 5

       This distinguishes the five squares making up the base figure.  For example in the base
       N=0 to N=4 part the m values are

                 +-----+
                 | m=3 |           1
           +-----+-----+-----+
           | m=0 | m=2 | m=4 |   <- Y=0
           +-----+-----+-----+
                 | m=1 |          -1
                 +-----+
            X=0     1      2

       From this remainder X,Y can be shifted down to the 0 position.  That position corresponds
       to a vector multiple of X=2,Y=1 and 90-degree rotated forms of that vector.  That vector
       can be divided out and X,Y shrunk with

           Xshrunk = (Y + 2*X) / 5
           Yshrunk = (2*Y - X) / 5

       If X,Y are considered a complex integer X+iY the effect is a remainder modulo 2+i,
       subtract that to give a multiple of 2+i, then divide by 2+i.  The vector X=2,Y=1 or 2+i is
       because that's the N=5 position after the base shape.

       The remainders can then be mapped to base 5 digits of N going from high to low and making
       suitable rotations for the sub-part orientation of the curve.  The remainders alone give a
       traversal in the style of "QuintetReplicate".  Applying suitable rotations produces the
       connected path of "QuintetCentres".

OEIS

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

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

           A099456   level Y end, being Im((2+i)^k)

           arms=2
             A139011   level Y end, being Re((2+i)^k)

SEE ALSO

       Math::PlanePath, Math::PlanePath::QuintetCurve, Math::PlanePath::QuintetReplicate,
       Math::PlanePath::FlowsnakeCentres

HOME PAGE

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

LICENSE

       Copyright 2011, 2012, 2013, 2014, 2015 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/>.