SIMPLE SOLUTIONS

# MATH::PLANEPATH::DRAGONCURVE(3PM) - man page online | library functions

Chapter
2016-01-11
```Math::PlanePath::DragonCurve(3pUser Contributed Perl DocumentatiMath::PlanePath::DragonCurve(3pm)

NAME
Math::PlanePath::DragonCurve -- dragon curve

SYNOPSIS
use Math::PlanePath::DragonCurve;
my \$path = Math::PlanePath::DragonCurve->new;
my (\$x, \$y) = \$path->n_to_xy (123);

DESCRIPTION
This is the dragon or paper folding curve by Heighway, Harter, et al.

9----8    5---4               2
|    |    |   |
10--11,7---6   3---2           1
|            |
17---16   13---12        0---1       <- Y=0
|    |    |
18-19,15-14,22-23                       -1
|    |    |
20--21,25-24                       -2
|
26---27                       -3
|
--32   29---28                       -4
|    |
31---30                            -5

^    ^    ^    ^    ^   ^   ^
-5   -4   -3   -2   -1  X=0  1 ...

The curve visits "inside" X,Y points twice.  The first of these is X=-2,Y=1 which is N=7
and also N=11.  The segments N=6,7,8 and N=10,11,12 have touched, but the path doesn't
cross itself.  The doubled vertices are all like this, touching but not crossing and no
edges repeating.

Arms
The curve fills a quarter of the plane and four copies mesh together perfectly when
rotated by 90, 180 and 270 degrees.  The "arms" parameter can choose 1 to 4 curve arms

For example arms=4 begins as follows, with N=0,4,8,12,etc being the first arm, N=1,5,9,13
the second, N=2,6,10,14 the third and N=3,7,11,15 the fourth.

arms => 4

20 ------ 16
|
9 ------5/12 -----  8       23
|         |         |        |
17 --- 13/6 --- 0/1/2/3 --- 4/15 --- 19
|       |         |         |
21      10 ----- 14/7 ----- 11
|
18 ------ 22

With four arms every X,Y point is visited twice (except the origin 0,0 where all four
begin) and every edge between the points is traversed once.

Level Angle
The first step N=1 is to the right along the X axis and the path then slowly spirals anti-
clockwise and progressively fatter.  The end of each replication is N=2^level which is at
level*45 degrees around,

----    -----    -----   -----------
1      1,0        0         1
2      1,1       45       sqrt(2)
4      0,2       90       sqrt(4)=2
8     -2,2      135       sqrt(8)
16     -4,0      180       sqrt(16)=4
32     -4,-4     225       sqrt(32)
...

Here's points N=0 to N=2^9=512.  "0" is the origin and "+" is N=512.  Notice it's
spiralled around full-circle to angle 45 degrees up again, like the initial N=2.

* *     * *
* * *   * * *
* * * * * * * * *
* * * * * * * * *
* *   * * * *       * *
* * *   * * * *     + * *
* * * * * *         * *
* * * * * * *
* * * * * * * *
* * * * * *
* * * *
* * * * * * *
* *   * * * * * * * *
* * *   * * * * * * * *
* * * * * * * * * *
* * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * *
* * * * * * * * * * * * * *
* * * * * * * * * * * *
* * * *                   * * * * * * * * * * *
* * * * *           * *   * * * *       * * * * *
* * * *   0 *         * * *   * * * *   * * * * * * *
* * * *               * * * * * *       * * * * *
* * *               * * * * * * *       * * * *
* * * *     * *   * * * * * * * *
* * * * * *   * * *   * * * * * * * *
* * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * *
* * * * *       * * * * *
* * * * * * *   * * * * * * *
* * * * *       * * * * *
* * * *         * * * *

At a power of two Nlevel=2^level for N=2 or higher, the curve always goes upward from
Nlevel-1 to Nlevel, and then goes to the left for Nlevel+1.  For example at N=16 the curve
goes up N=15 to N=16, then left for N=16 to N=17.  Likewise at N=32, etc.  The spiral
curls around ever further but the self-similar twist back means the Nlevel endpoint is
always at this same up/left orientation.  See "Total Turn" below for the net direction in
general.

Level Ranges
The X,Y extents of the path through to Nlevel=2^level can be expressed as a "length" in
the direction of the Xlevel,Ylevel endpoint and a "width" across.

level even, so endpoint is a straight line
k = level/2

+--+      <- Lmax
|  |
|  E      <- Lend = 2^k at Nlevel=2^level
|
+-----+
|
O  |   <- Lstart=0
|  |
+--+   <- Lmin

^     ^
Wmin     Wmax

Lmax = (7*2^k - 4)/6 if k even
(7*2^k - 2)/6 if k odd

Lmin = - (2^k - 1)/3 if k even
- (2^k - 2)/3 if k odd

Wmax = (2*2^k - 2) / 3 if k even
(2*2^k - 1) / 3 if k odd

Wmin = Lmin

For example level=2 is to Nlevel=2^2=4 and k=level/2=1 is odd so it measures as follows,

4      <- Lmax = (7*2^1 - 2)/6 = 2
|
3--2
|
0--1   <- Lmin = -(2^1 - 2)/3 = 0

^  ^Wmax = (2*2^1 - 1)/3 = 1
|
Wmin = Lmin = 0

Or level=4 is to Nlevel=2^4=16 and k=4/2=2 is even.  It measures as follows.  The
lengthways "L" measures are in the direction of the N=16 endpoint and the "W" measures are
across.

9----8    5---4        <- Wmax = (2*2^2 - 2)/3 = 2
|    |    |   |
10--11,7---6   3---2
|            |
16   13---12        0---1
|    |
15---14                      <- Wmin = -(2^2 - 1)/3 = -1

^                      ^Lmin = Wmin = -1
|
Lmax = (7*2^2 - 4)/6 = 4

The formulas are all integer values, but the fractions 7/6, 1/3 and 2/3 show the limits as
the level increases.  If scaled so that length Lend=2^k is reckoned as 1 unit then Lmax
extends 1/6 past the end, Lmin and Wmin extend 1/3, and Wmax extends across 2/3.

+--------+ --
| -      | 1/6   total length
|| |     |          = 1/6+1+1/3 = 3/2
|| E     | --
||       |
||       |
| \      |  1
|  \     |
|   --\  |
|      \ |
|       ||
|  O    || --
|  |    ||
|  |    || 1/3
|   ---- |
+--------+ --
1/3|  2/3

total width = 1/3+2/3 = 1

Paper Folding
The path is called a paper folding curve because it can be generated by thinking of a long
strip of paper folded in half repeatedly and then unfolded so each crease is a 90 degree
angle.  The effect is that the curve repeats in successive doublings turned by 90 degrees
and reversed.

The first segment unfolds, pivoting at the "1",

2
->   |
unfold         /     |
===>         |      |
|
0-------1                     0-------1

Then the same again with that L shape, pivoting at the "2", then after that pivoting at
the "4", and so on.

4
|
|
|
3--------2
2                              |
|        unfold          ^     |
|         ===>            \_   |
|                              |
0------1                     0--------1

It can be shown that this unfolding doesn't overlap itself but the corners may touch, such
as at the X=-2,Y=1 etc noted above.

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

"\$path = Math::PlanePath::DragonCurve->new ()"
"\$path = Math::PlanePath::DragonCurve->new (arms => \$int)"
Create and return a new path object.

The optional "arms" parameter can make 1 to 4 copies of the curve, each arm

"(\$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->xy_to_n (\$x,\$y)"
Return the point number for coordinates "\$x,\$y".  If there's nothing at "\$x,\$y" then
return "undef".

The curve visits an "\$x,\$y" twice for various points (all the "inside" points).  The
smaller of the two N values is returned.

"@n_list = \$path->xy_to_n_list (\$x,\$y)"
Return a list of N point numbers for coordinates "\$x,\$y".

The origin 0,0 has "arms_count()" many N since it's the starting point for each arm.
Other points have up to two Ns for a given "\$x,\$y".  If arms=4 then every "\$x,\$y"
except the origin has exactly two Ns.

"\$n = \$path->n_start()"
Return 0, the first N in the path.

Level Methods
"(\$n_lo, \$n_hi) = \$path->level_to_n_range(\$level)"
Return "(0, 2**\$level)", or for multiple arms return "(0, \$arms * 2**\$level +
(\$arms-1))".

There are 2^level segments in a curve level, so 2^level+1 points numbered from 0.  For
multiple arms there are arms*(2^level+1) points, numbered from 0 so n_hi =
arms*(2^level+1)-1.

FORMULAS
Various formulas for boundary length and area can be found in the author's mathematical
write-up

<http://user42.tuxfamily.org/dragon/index.html>

X,Y to N
The current code uses the "DragonMidpoint" "xy_to_n()" by rotating -45 degrees and
offsetting to the midpoints of the four edges around the target X,Y.  The "DragonMidpoint"
algorithm then gives four candidate N values and those which convert back to the desired
X,Y in the "DragonCurve" "n_to_xy()" are the results for "xy_to_n_list()".

Xmid,Ymid = X+Y, Y-X    # rotate -45 degrees
for dx = 0 or -1
for dy = 0 or 1
N candidate = DragonMidpoint xy_to_n(Xmid+dx,Ymid+dy)

Since there's at most two "DragonCurve" Ns at a given X,Y the loop can stop when two Ns
are found.

Only the "leaving" edges will convert back to the target N, so only two of the four edges
actually need to be considered.  Is there a way to identify them?  For arm 1 and 3 the
leaving edges are up,down on odd points (meaning sum X+Y odd) and right,left for even
points (meaning sum X+Y even).  But for arm 2 and 4 it's the other way around.  Without an
easy way to determine the arm this doesn't seem to help.

X,Y is Visited
Whether a given X,Y is visited by the curve can be determined from one or two segments
(rather then up to four for X,Y to N).

|             S midpoint Xmid = X+Y
|                        Ymid = Y-X
*---T--X,Y--S---*
|             T midpoint Xmid-1
|                        Ymid+1

Segment S is to the East of X,Y.  The arm it falls on can be determined as per "X,Y to N"
in Math::PlanePath::DragonMidpoint.  Numbering arm(S) = 0,1,2,3 then

X,Y Visited
-----------
if arms_count()==4                  yes     # whole plane
if arm(S) < arms_count()            yes
if arm(S)==2 and arms_count()==1    no
if arm(T) < arms_count()            yes

This works because when two arms touch they approach and leave by a right angle, without
crossing.  So two opposite segments S and T identify the two possible arms coming to the
X,Y point.

|
|
\
----   ----
\
|
|

An arm only touches its immediate neighbour, ie. arm-1 or arm+1 mod 4.  This means if
arm(S)==2 then arm(T) can only be 1,2,3, not 0.  So if "arms_count()" is 1 then arm(T)
cannot be on the curve and no need to run its segment check.

The only exception to the right-angle touching rule is at the origin X,Y = 0,0.  In that
case Xmid,Ymid = 0,0 is on the first arm and X,Y is correctly determined to be on the
curve.  If S was not to the East but some other direction away from X,Y then this wouldn't
be so.

Turn
At each point the curve always turns either left or right, it never goes straight ahead.
The bit above the lowest 1-bit in N gives the turn direction.

N = 0b...z10000   (possibly no trailing 0s)

z bit    Turn
-----    ----
0      left
1      right

For example N=12 is binary 0b1100, the lowest 1 bit is 0b_1__ and the bit above that is a
1, which means turn to the right.  Or N=18 is binary 0b10010, the lowest 1 is 0b___1_ and
the bit above that is 0, so turn left there.

This z bit can be picked out with some bit twiddling

\$mask = \$n & -\$n;          # lowest 1 bit, 000100..00
\$z = \$n & (\$mask << 1);    # the bit above it
\$turn = (\$z == 0 ? 'left' : 'right');

This sequence is in Knuth volume 2 "Seminumerical Algorithms" answer to section 4.5.3
question 41 and is called the "dragon sequence".  It's expressed there recursively as

d(0) = 1       # unused, since first turn at N=1
d(2N) = d(N)   # shift down looking for low 1-bit
d(4N+1) = 0    # bit above lowest 1-bit is 0
d(4N+3) = 1    # bit above lowest 1-bit is 1

Next Turn
The bits also give the turn after next by looking at the bit above the lowest 0-bit.  This
works because 011..11 + 1 = 100..00 so the bit above the lowest 0 becomes the bit above
the lowest 1.

N = 0b...w01111    (possibly no trailing 1s)

w bit    Next Turn
----     ---------
0       left
1       right

For example at N=12=0b1100 the lowest 0 is the least significant bit 0b___0, and above
that is a 0 too, so at N=13 the turn is to the left.  Or for N=18=0b10010 the lowest 0 is
again the least significant bit, but above it is a 1, so at N=19 the turn is to the right.

This too can be found with some bit twiddling, as for example

\$mask = \$n ^ (\$n+1);      # low one and below 000111..11
\$w = \$n & (\$mask + 1);    # the bit above there
\$turn = (\$w == 0 ? 'left' : 'right');

Total Turn
The total turn is the count of 0<->1 transitions in the runs of bits of N, which is the
same as how many bit pairs of N (including overlaps) are different so "01" or "10".

This can be seen from the segment replacements resulting from bits of N,

N bits from high to low, start in "plain" state

plain state
0 bit -> no change
1 bit -> count left, and go to reversed state

reversed state
0 bit -> count left, and go to plain state
1 bit -> no change

The 0 or 1 counts are from the different side a segment expands on in plain or reversed
state.  Segment A to B expands to an "L" shape bend which is on the right in plain state,
but on the left in reversed state.

plain state             reverse state

A = = = = B                    +
\       ^              0bit  / \
\     /               turn /   \ 1bit
0bit \   / 1bit           left/     \
\ /  turn              /       v
+   left             A = = = = B

In both cases a rotate of +45 degrees keeps the very first segment of the whole curve in a
fixed direction (along the X axis), which means the south-east slope shown is no-change.
This is the 0 of plain or the 1 of reversed.  And the north-east slope which is the other
new edge is a turn towards the left.

It can be seen the "state" above is simply the previous bit, so the effect for the bits of
N is to count a left turn at each transition from 0->1 or 1->0.  Initial "plain" state
means the infinite zero bits at the high end of N are included.  For example N=9 is 0b1001
so three left turns for curve direction south to N=10 (as can be seen in the diagram
above).

1 00 1   N=9
^ ^  ^
+-+--+---three transitions,
so three left turns for direction south

The transitions can also be viewed as a count of how many runs of contiguous 0s or 1s, up
to the highest 1-bit.

1 00 1   three blocks of 0s and 1s

This can be calculated by some bit twiddling with a shift and xor to turn transitions into
1-bits which can then be counted, as per Jorg Arndt (fxtbook section 1.31.3.1 "The Dragon
Curve").

total turn = count_1_bits (\$n ^ (\$n >> 1))

The reversing structure of the curve shows up in the total turn at each point.  The total
turns for a block of 2^N is followed by its own reversal plus 1.  For example,

------->
N=0 to N=7    0, 1, 2, 1, 2, 3, 2, 1

N=15 to N=8   1, 2, 3, 2, 3, 4, 3, 2    each is +1
<-------

N to dX,dY
"n_to_dxdy()" is the "total turn" per above, or for fractional N then an offset according
to the "next turn" above.  If using the bit twiddling operators described then the two can
be calculated separately.

The current "n_to_dxdy()" code tries to support floating point or other number types
without bitwise XOR etc by processing bits high to low with a state table which combines
the calculations for total turn and next turn.  The state encodes

total turn       0 to 3
next turn        0 or 1
previous bit     0 or 1  (the bit above the current bit)

The "next turn" remembers the bit above lowest 0 seen so far (or 0 initially).  The "total
turn" counts 0->1 or 1->0 transitions.  The "previous bit" shows when there's a
transition, or what bit is above when a 0 is seen.  It also works not to have this
previous bit in the state but instead pick out two bits each time.

At the end of bit processing any "previous bit" in state is no longer needed and can be
masked out to lookup the final four dx, dy, next dx, next dy.

OEIS
The Dragon curve is in Sloane's Online Encyclopedia of Integer Sequences in many forms
(and see "DragonMidpoint" for its forms too),

<http://oeis.org/A014577> (etc)

A246960   direction 0,1,2,3

A038189   turn, 0=left,1=right, bit above lowest 1, extra 0
A089013    same as A038189, but initial extra 1
A082410   turn, 1=left,0=right, reversing complement, extra 0
A099545   turn, 1=left,3=right, as [odd part n] mod 4
so turn by 90 degrees * 1 or 3
A034947   turn, 1=left,-1=right, Jacobi (-1/n)
A112347   turn, 1=left,-1=right, Kronecker (-1/n), extra 0
A121238   turn, 1=left,-1=right, -1^(n + some partitions) extra 1
A014577   next turn, 1=left,0=right
A014707   next turn, 0=left,1=right
A014709   next turn, 1=left,2=right
A014710   next turn, 2=left,1=right

These numerous turn sequences differ only in having left or right represented as 0, 1, -1,
etc, and possibly "extra" initial 0 or 1 at n=0 arising from the definitions and the first
turn being at n=N=1.  The "next turn" forms begin at n=0 for turn at N=1 and so are the
turn at N=n+1.

A005811   total turn
A088748   total turn + 1
A164910   cumulative(total turn + 1)
A166242   2^(total turn), by double/halving

A088431   turn sequence run lengths
A007400     2*runlength

A091072   N positions of the left turns, being odd part form 4K+1
A003460   turns N=1 to N=2^n-1 packed as bits 1=left,0=right
low to high, then written in octal
A126937   points numbered like SquareSpiral (start N=0 and flip Y)

A146559   X at N=2^k, for k>=1, being Re((i+1)^k)
A009545   Y at N=2^k, for k>=1, being Im((i+1)^k)

A227036   boundary length N=0 to N=2^k
also right boundary length to N=2^(k+1)
A203175   left boundary length N=0 to N=2^k
also differences of total boundary

A003230   area enclosed N=0 to N=2^k, for k=4 up
same as double points
A003478   area enclosed by left side,
also area increment
A003477   area of each connected block

A003479   join area between N=2^k replications
A003229   join area increment,
also area left side extra over doubling
A077949    same

A003476   squares on right boundary
also single points N=0 to N=2^(k-1) inclusive
A203175   squares on left boundary
A164395   single points N=0 to N=2^k-1 inclusive, for k=4 up

For reference, "dragon-like" A059125 is similar to the turn sequence A014707, but differs
in having the "middle" values for each replication come from successive values of the
sequence itself, or some such.

A088431 and A007400
The run lengths A088431 and A007400 are from a continued fraction expansion of an infinite
sum

1   1   1     1      1              1
1 + - + - + -- + --- + ----- + ... + ------- + ...
2   4   16   256   65536         2^(2^k)

Jeffrey Shallit and independently M. Kmosek show how continued fraction terms repeated in
reverse give rise to this sort of power sum,

Jeffrey Shallit, "Simple Continued Fractions for Some Irrational Numbers", Journal of
Number Theory, volume 11, 1979, pages 209-217.
<http://www.cs.uwaterloo.ca/~shallit/papers.html>
<http://www.cs.uwaterloo.ca/~shallit/Papers/scf.ps>

(And which appears in Knuth "Art of Computer Programming", volume 2, section 4.5.3
exercise 41.)

A126937
The A126937 "SquareSpiral" numbering has the dragon curve and square spiralling with their
Y axes in opposite directions, as shown in its a126937.pdf.  So the dragon curve turns up
towards positive Y but the square spiral is numbered down towards negative Y (or vice
versa).  "PlanePath" code for this starting at "\$i=0" would be

my \$dragon = Math::PlanePath::DragonCurve->new;
my \$square = Math::PlanePath::SquareSpiral->new (n_start => 0);
my (\$x, \$y) = \$dragon->n_to_xy (\$i);
my \$A126937_of_i = \$square->xy_to_n (\$x, -\$y);

Math::PlanePath, Math::PlanePath::DragonRounded, Math::PlanePath::DragonMidpoint,
Math::PlanePath::R5DragonCurve, Math::PlanePath::TerdragonCurve

Math::PlanePath::ComplexMinus, Math::PlanePath::ComplexPlus, Math::PlanePath::CCurve,
Math::PlanePath::AlternatePaper

<http://rosettacode.org/wiki/Dragon_curve>

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

Copyright 2011, 2012, 2013, 2014, 2015 Kevin Ryde

Math-PlanePath is free software; you can redistribute it and/or modify it under the terms