and 1 contributors

# NAME

Math::PlanePath::CubicBase -- replications in three directions

# SYNOPSIS

`````` use Math::PlanePath::CubicBase;
my \$path = Math::PlanePath::CubicBase->new (radix => 4);
my (\$x, \$y) = \$path->n_to_xy (123);``````

# DESCRIPTION

This is a pattern of replications in three directions 0, 120 and 240 degrees.

``````                       18    19    26    27                      5
16    17    24    25                   4
22    23    30    31                            3
20    21    28    29                         2
50    51    58    59     2     3    10    11          1
48    49    56    57     0     1     8     9   <- Y=0
54    55    62    63     6     7    14    15               -1
52    53    60    61     4     5    12    13            -2
34    35    42    43                     -3
32    33    40    41                  -4
38    39    46    47                           -5
36    37    44    45                        -6

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

The points are on a triangular grid by using every second integer X,Y, as per "Triangular Lattice" in Math::PlanePath. All points on that triangular grid are visited.

The initial N=0,N=1 is replicated at +120 degrees. Then that trapezoid at +240 degrees

``````    +-----------+                       +-----------+
\  2     3  \                       \  2     3  \
+-----------+                       \           \
\  0     1  \                       \  0     1  \
+-----------+             ---------  -----------+
\  6     7  \
replicate +120deg              \          \    rep +240deg
\  4     5 \
+----------+``````

Then that bow-tie N=0to7 is replicated at 0 degrees again. Each replication is 1/3 of the circle around, 0, 120, 240 degrees repeating. The relative layout within a replication is unchanged.

``````                      -----------------------
\ 18    19    26    27 \
\                       \
\  16    17    24    25 \
----------              ----------
\ 22    23    30    31 \
\                      \
\ 20    21    28    29  \
--------- ------------ +----------- -----------
\ 50    51    58    59  \  2     3  \ 10    11 \
\                      +-----------+           \
\ 48    49    56    57  \  0     1  \  8     9 \
----------              --------- +-----------  ---------+
\ 54    55    62    63  \  6     7  \ 14    15  \
\                        \          \            \
\ 52    53    60    61  \  4     5 \  12    13  \
--------------          +----------+------------
\ 34    35    42    43 \
\                       \
\  32    33    40    41 \
---------+            -----------
\ 38    39    46    47 \
\                       \
\ 36    37    44    45 \
-----------------------``````

The radial distance doubles on every second replication, so N=1 and N=2 are at 1 unit from the origin, then N=4 and N=8 at 2 units, then N=16 and N=32 at 4 units. N=64 is not shown but is then at 8 units away (X=8,Y=0).

This is similar to the `ImaginaryBase`, but where that path repeats in 4 directions based on i=squareroot(-1), here it's 3 directions based on w=cuberoot(1) = -1/2+i*sqrt(3)/2.

The `radix` parameter controls the "r" used to break N into X,Y. For example radix 4 gives 4x4 blocks, with r-1 replications of the preceding level at each stage.

``````       3         radix => 4              12    13    14    15
2                                     8     9    10    11
1                                        4     5     6     7
Y=0 ->                                        0     1     2     3
-1                     28    29    30    31
-2                        24    25    26    27
-3                           20    21    22    23
-4                              16    17    18    19
-5         44    45    46    47
...           40    41    42    43
36    37    38    39
32    33    34    35
60    61    62    63
56    57    58    59
52    53    54    55
48    49    50    51

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

Notice the parts always replicate away from the origin, so the block N=16 to N=31 is near the origin at X=-4, then N=32,48,64 are further away.

In this layout the replications still mesh together perfectly and all points on the triangular grid are visited.

# FUNCTIONS

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

`\$path = Math::PlanePath::CubicBase->new ()`
`\$path = Math::PlanePath::CubicBase->new (radix => \$r)`

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.

## Level Methods

`(\$n_lo, \$n_hi) = \$path->level_to_n_range(\$level)`

Return `(0, \$radix**\$level - 1)`.

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