and 1 contributors

# NAME

Math::PlanePath::ImaginaryBase -- replications in four directions

# SYNOPSIS

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

# DESCRIPTION

This is a simple pattern arising from complex numbers expressed in a base i*sqrt(2) and other i*sqrt(r) bases. The default r=2 gives

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

After N=0 at the origin, N=1 is to the right. Then that little 2x1 block is repeated above as N=2 and N=3. Then that 2x2 pattern repeated to the right as N=4 to N=7, 4x2 repeated below N=8 to N=16, and 4x4 block to the right again as N=16 to N=31. Each repeat is 90 degrees further around each time, and just a simple offset so the same orientation and relative layout within the repetition.

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

This arises from representing a complex number in "base" b=i*sqrt(r) with digits a[i] in the range 0 to r-1. For integer X,Y,

``    X+Y*i*sqrt(r) = a[n]*b^n + ... + a*b^2 + a*b + a``

and N is a base-r integer

``    N = a[n]*r^n + ... + a*r^2 + a*r + a``

The factor sqrt(r) makes the generated Y an integer. In actual use that factor can be omitted and fractional digits a[-1]*r^-1 etc used to reach smaller Y values, as for example Knuth's "quater-imaginary" system of base 2*i (which is i*sqrt(4)) and digits 0,1,2,3.

The powers of i in the base give the replication direction, so i^0=1 right, i^1=i up, i^2=-1 right, i^3=-i down, etc. The sqrt(r) part then spreads the replication in the respective direction. It takes two steps to repeat horizontally and sqrt(r)^2=r hence the doubling of 1x1 to the right, 2x2 to the left, 4x4 to the left, etc, and similarly vertically.

The pattern can be compared to the ZOrderCurve. In Z-Order the replications are alternately right and above, but here they progress through four directions right, above, left, below.

The `radix` parameter controls the "r" used to break N into X,Y. For example `radix => 3` gives 3x3 blocks, with r-1 copies of the preceding level at each stage,

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

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

# FUNCTIONS

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

`\$path = Math::PlanePath::ImaginaryBase->new ()`
`\$path = Math::PlanePath::ImaginaryBase->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.