Scroll to navigation

Math::PlanePath::QuintetCentres(3pm) User Contributed Perl Documentation Math::PlanePath::QuintetCentres(3pm)
 

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
    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 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/>.
2014-09-02 perl v5.20.1