---
name: "Math::PlanePath::QuintetCentres"
section: "3pm"
platform: "linux"
package: "libmath-planepath-perl"
version: "129-1"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/Math::PlanePath::QuintetCentres"
---

# 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

\<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, 2016, 2017, 2018, 2019, 2020 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/\>.
