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

# Math::PlanePath::CubicBase(3pm)

## 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)](/sqrt/3.md)/2.

### Radix

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)"`.

## SEE ALSO

Math::PlanePath, Math::PlanePath::ImaginaryBase, Math::PlanePath::ImaginaryHalf

## HOME PAGE

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

## LICENSE

Copyright 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/\>.
