/ 
math-image-69
River stage zero No dependents
/ Math::PlanePath::MathImageTwinDragon

NAME

Math::PlanePath::MathImageTwinDragon -- points in complex number base i-r

SYNOPSIS

use Math::PlanePath::MathImageTwinDragon;
my $path = Math::PlanePath::MathImageTwinDragon->new (realpart=>1);
my ($x, $y) = $path->n_to_xy (123);

DESCRIPTION

In progress.

This an integer version of the "twindragon" formed from the complex number base i-1, and other i-r.

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

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

With base b=i-1, a complex integer can be represented by

X+Yi = a[n]*b^n + ... + a2*b^2 + a1*b + a0

where the digits a[n] to a0 are each either 0 or 1. The index N is those a[i] in binary and the X,Y is the resulting complex number. It can be shown that this is a one-to-one transformation, that every integer point of the plane is visited, just once.

The pattern of a given 0 to 2^level-1 is repeated in the following 2^level to (2*2^level)-1. For example the shape of N=0 to N=7 is repeated as N=8 to N=15, but starting up at X=2,Y=2. This is due to the base b^3 = 2+2i. There's no rotations or mirroring etc in this replication, just a simple shift.

Each each N=2^level point is at b^level, and that powering of the base rotates around by +135 degrees and a factor sqrt(2) on the radius each time. So for example b^3 = 2+2i is followed by b^4 = -4 which is 135 degrees around, and the radius |b^3|=sqrt(8) becomes |b^4|=sqrt(16).

Real Part

The realpart option gives complex bases i-r for a given r>=1. For example realpart => 2 is

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

N is broken into digits of base norm=r*r+1. This makes horizontal runs of norm many points, such as N=0 to N=4, then N=5 to N=9, etc. For the default r=1 above these are 2 long, for r=2 they're 2*2+1=5, r=3 would be 3*3+1=10, etc.

The offset back for each run like N=5 shown is the r in i-r, then the next level is (i-r)^2 = (-2r*i + r^2-1) so N=25 begins at X=-2*2=-4,Y=2*2-1=3.

The successive replications end up tiling the plane, though the N values to come around and do so may become large if the norm=r*r+1 is large.

Radius Range

In general, after the first few innermost levels, each N=2^level increases the covered radius around by a factor sqrt(2), ie.

N = 0 to 2^level-1
Xmin,Ymin closest to origin
Xmin^2+Ymin^2 approx 2^(level-7)

The "level-7" is since the innermost few levels take a while to cover the points surrounding the origin. Notice for example X=1,Y=-1 is not reached until N=58. But after that it grows like N approx = pi*R^2.

Fractal

The twindragon is generally conceived as taking fractional N like binary 0.abcde and giving complex components X,Y components. The twindragon is then all the points of the real plane reached by such N -- which can be shown to be connected and having a certain radius around the origin which is completely covered.

The code here might be pressed into use for that, for some finite number of N digits, by taking a suitable power N*256^k to get an integer then X/16^k, Y/16^k for fractions X,Y. 256 is a good base because b^8=16 so there's no rotations to apply to the X,Y, just a division. (b^4=-4 for multiplier 16^k and divisor (-4)^k would be almost as easy too.)

FUNCTIONS

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

$path = Math::PlanePath::MathImageTwinDragon->new ()
$path = Math::PlanePath::MathImageTwinDragon->new (realpart => $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.

$n should be an integer, it's unspecified yet what will be done for a fraction.

FORMULAS

X,Y to N

A given X,Y representing X+Yi can be broken into digits of N by complex division by i-1, with remainder 0 or 1 being each digit.

The remainder can be determined simply from (X+Y) mod 2. If it's 1 then X-1,Y gives a point which is an exact multiple of i-1 and that base can be divided out

X   <-   -(X-Y)/2
Y   <-   -(X+Y)/2

This can also be thought of as a rotate by -135 degrees and divide by sqrt(2).

The binary bits of N from low to high are generated this way.

SEE ALSO

Math::PlanePath, Math::PlanePath::DragonCurve