Kevin Ryde > Math-PlanePath-116 > Math::PlanePath::DragonCurve

Download:
Math-PlanePath-116.tar.gz

Dependencies

Annotate this POD

Website

CPAN RT

Open  1
View/Report Bugs
Module Version: 116   Source   Latest Release: Math-PlanePath-117

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 successively advancing.

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,

    N       X,Y     angle   radial dist
   ----    -----    -----   -----------
     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 successively advancing.

($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 has exactly two Ns.

$n = $path->n_start()

Return 0, the first N in the path.

FORMULAS ^

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.

Boundary Parts

Boundary lengths can be obtained by taking the curve in five types of section,

                  R                           initial values
      8       5 <--- 4                    k    L  R  T  U  V
      |       ^      |                   ---  -- -- -- -- --
   R  |   U   |   V  |  T                 0    1  1  2  3  3
      v       |      v                    1    2  2  4  6
      7 <---- 6      3 <--- 2             2    4  4     8
          L                 |             3    8  8    12
                        U   |  L          4      16    20
                            v
                     0 ---> 1
                        R

L and R are the left and right sides of the curve. The other parts T, U and V are because the points measured must be on the boundary. The way the curve touches itself within the "U" part means only 0 and 3 are on the left boundary and so a measurement must be made between those only. Similarly T and V.

The arrowheads drawn show the direction of the curve sub-sections for replication. Sections U and V have different directions and are not the same. If rotated to upright then U has endpoint positions odd,even whereas V is even,odd (where odd or even is reckoned by N position along the curve and which is also odd or even of the sum X+Y).

    even odd  even odd      odd even          U=even,odd
      8   5     0   3        3   6            V=odd,even
      | U |     | U |        | V |
      7---6     1---2        4---5

Right-angle boundary points remain boundary points as the curve expands. In the following picture curves ja and jb meet at point j. When they replicate as ac and bd respectively the width and height of those is at most 2/3 of the length and so too small to touch j.

                    c
                    |
                    |
    a------j        a------j        ab and cd don't touch j
           |               |
           |               |
           b        d------b

The same applies if j is on the left boundary. The ac,bd parts are always too small to reach back and touch or surround j. So in the picture above the boundary points 0 to 8 remain boundary points when the curve doubles to the next replication level.

The curve expands from 8 sections to 16 sections in the following pattern. (Drawn here turned 45-degrees to stay horizontal and vertical.)

                        R              R
                    * <--- 4       * <--- 2
                    ^      |       ^      |
                  L |      |   U   |   V  |  T
                    |      v       |      v
                    5 ---> * <---- 3      * <--- 1
                           ^                     |
                        V  |  T              U   |  L
                           |                     v
            8       * <--- 6              0 ---> *
            |       ^                        R
          R |   U   |  T
            v       |
            * <---  7
                L

It can be seen R -> R+L, L -> T, T -> U+R, U -> U+V, and V->T. For V (3 to 6) the curve touches itself and so closes off some boundary leaving just T. The effect is that the V values are V[0]=3 and thereafter the T values, V[1]=T[0], V[2]=T[1], etc.

These expansions can be written as recurrences

    R[k+1] = R[k] + L[k]           for k >= 0
    L[k+1] = T[k]
    T[k+1] = R[k] + U[k]
    U[k+1] = U[k] + V[k]
    V[k+1] = T[k]

Some matrix manipulation can isolate each in terms of others or as a recurrence in itself. It's also easy enough to take the equations directly.

Left Boundary

The left boundary length L is given by a recurrence

    L[k+3] = L[k+2] + 2*L[k]       for k >= 1
    starting L[0] = 1
             L[1] = 2
             L[2] = 4
             L[3] = 8
    1, 2, 4, 8, 12, 20, 36, 60, 100, 172, 292, 492, 836, 1420, ...

                          (1 + x)*(1 + 2*x^2)
    generating function   -------------------
                             1 - x - 2*x^3

This is obtained from the equations above by first noticing L[k+1]=T[k] and V[k+1]=T[k] so L[k]=V[k] for k>=1, then substitute T[k+1]=R[k]+U[k] to eliminate T, leaving

    R[k+1] = R[k] + L[k]
    U[k+1] = U[k] + L[k]                     for k >= 1
    L[k+1] = R[k-1] + U[k-1]
           = R[k-2]+L[k-2] + U[k-2]+L[k-2]   for k >= 3
           = R[k-2]+U[k-2]  + 2*L[k-2]
    L[k+1] = L[k-1] + 2*L[k-2]               for k >= 3

which is the recurrence for L above. The generating function follows from the initial values.

The way T[k]=L[k+1] is simply that two inward pointing sub-curves is the same as the left side. T is reckoned as two segments, so this is L[k+1].

                  2
                  |
    T[k]=L[k+1]   |
                  v
           0 ---> 1

The recurrence can be seen directly in the expansion as follows. The expanded 0 to 3 plus 7 to 8 are the same as the original 0 to 8. In the middle is inserted two extra L[k+1].

              * <--- 4       * <--- 2
              ^      |       ^      |
              |      |       |   V  |
              |      v       |      v
              5 ---> * <---- 3      * <--- 1
                     ^                     |
                     |  L[k+1]         U   |
                     |                     v
      8       * <--- 6              0 ---> *
      |       ^
    R |       |  L[k+1]
      v       |
      * <---  7          extra two L[k+1] on left side
          L              so L[k+4] = L[k+3] + 2*L[k+1]

The fact that L[k]=V[k] (for k>=1) is not quite obvious from the geometry of their definition, only from the way they expand. L[0]=1 and V[0]=3 differ but thereafter they are the same.

Right Boundary

The right-side boundary length is given by a recurrence

    R[k+4] = 2*R[k+3] - R[k+2] + 2*R[k+1] - 2*R[k]     k >= 1
    starting R[0] =  1
             R[1] =  2
             R[2] =  4
             R[3] =  8
             R[4] = 16
    = 1, 2, 4, 8, 16, 28, 48, 84, 144, 244, 416, 708, 1200, 2036, ...

                            1 + x^2 + 2*x^4
    generating function  ---------------------
                         (1 - x - 2*x^3)*(1-x)

                              / -2    4 + 2*x + 4*x^2  \
                    = 1 + x * | --- + ---------------  |
                              \ 1-x    1 - x - 2*x^3   /

The recurrence is only for k>=1 as noted. At k=0 it would give R[4]=14 but that's incorrect, N=0 to N=2^4 has right side boundary R[4]=16.

The recurrence can be had from the three equations above. The second gives U[k-1]=L[k+1]-R[k-1]. Substitute that into the third to eliminate U,

    R[k+1] = R[k] + L[k]
    L[k+3]-R[k+1] = L[k+2]-R[k] + L[k]     for k >= 1

Then the first equation is L[k]=R[k+1]-R[k] and substitute that to eliminate L. The result is the fourth-order recurrence for R above. The generating function follows from it in the usual way.

Right Boundary by Summation

The right boundary is a cumulative left boundary, as per R[k+1]=R[k]+L[k] above. Substituting repeatedly gives

                                                      i=k-1
    R[k] = L[k-1] + L[k-2] + ... + L[0] + R[0] = 1 + sum  L[i]
     for k>=0                                         i=0
     empty sum if k=0

The usual ways to sum a linear recurrence give the same fourth-order as above. The generating function follows from the summation too by multiplying x/(1-x) in the usual way to sum to term k-1, then add 1/(1-x) for +1.

             x           1
    gR(x) = ---*gL(x) + ---
            1-x         1-x

The geometric interpretation of the sum is the repeated curve unfoldings. Each unfold copies the left side to the right side. So when level 0 unfolds it puts an L[0] onto the right. Then level 1 expands and copies L[1] onto the right, and so on up to L[k]. (This doesn't say anything about the nature of L, only that R the cumulative sum.)

              L[k-2]
           *----------*             section endpoints on
   L[k-1] /            \            45-degree angles as
         /              ...         per "Level Angle" above
        /                *
       *                 | L[0]
       |              *--*
  L[k] |              R[0]
       |
       *

Total Boundary

The total boundary is a left and a right,

    B[k] = L[k] + R[k]
         = R[k+1]       for k>=0
         = 2, 4, 8, 16, 28, 48, 84, 144, 244, 416, 708, 1200, ...

                               2 + 2*x^2
    generating function   ---------------------
                          (1 - x - 2*x^3)*(1-x)

                                / 2 + x + 2*x^2     1  \
                          = 2 * | -------------- - --- |
                                \ 1 - x - 2*x^3    1-x /

B[k]=R[k+1] is from the R[k+1]=R[k]+L[k] above, representing one more unfolding. The first term is dropped from the generating function of R and that simplifies the numerator.

All the boundary lengths start by doubling with N=2^k but when the curve begins to touch itself the boundary is then less than double. For B this happens at B[4]=28 onwards.

The characteristic equation of the recurrence for B and for R is

    x^4 - 2*x^3 + x^2 - 2*x + 2 = (x^3 - x^2 - 2) * (x-1)

The real root of the cubic can be had from the usual cubic formula (per Chang and Zhang, "Other Formulas" below).

        1    /      1      \
   r = --- * | C + --- + 1 |  where C = cbrt(28 + sqrt(29*27))
        3    \      C      /

     = 1.69562...

This shows how B grows,

    B[k] = approx 3.6 * 1.69562^k

U Boundary

U in the boundary parts above is

    U[k] = /  3          for k=0
           \  R[k] + 4   for k>=1
         = 3, 6, 8, 12, 20, 32, 52, 88, 148, 248, 420, 712, 1204, ...

                          3 - x^2 - 4*x^3 - 2*x^4
    generating function   -----------------------
                           (1 - x - 2*x^3)*(1-x)

                                    /  2    4 + 2*x + 4*x^2  \
                          = 3 + x * | --- + ---------------  |
                                    \ 1-x    1 - x - 2*x^3   /

U is a summation of L as per the equation U[k+1]=U[k]+L[k] for k>=1.

                                                      i=k
    U[k+1] = L[k] + L[k-1] + ... + L[1] + U[1] = 6 + sum  L[i]
     for k>=1                                         i=1

So U is the same summation as R except for different fixed term U[1]=6 whereas R[1]=2, hence U[k]=R[k]+4, except not at U[0] as the summation does not apply there. It's also possible to do some substitutions similar to those for R in "Right Boundary" to get U directly from the three equations.

U can also be obtained by considering the left side of a 2-level expansion, giving U as an L,R difference. This is also in the substitution formulas above.

                                        4      4
    L[k+2] = U[k] + R[k]                |      |
                                        |    R |
    so                           L[k+2] |      v
                                        |      3 <--- 2
    U[k] = L[k+2] - R[k]                |             |
                                        |          U  |
                                        v             v
                                        0      0 ---> 1

U Total Boundary

The U shape is a one-and-a-half dragon, as if a dragon curve plus a further half dragon (3/2)*2^k. The U[k] quantity is its left side. The right side and total can be calculated too.

       3 <---- 2               U shape 1+1/2 dragon
               |
               v
       0 ----> 1

The right side of this is

    RU[k] = R[k] + R[k+1]
          = 3, 6, 12, 24, 44, 76, 132, 228, 388, 660, 1124, ...

                          3 + 3*x^2 + 2*x^4
    generating function  --------------------
                         (1 - x - 2*x^3)*(1-x)

And the total is

    BU[k] = U[k] + RU[k]
          = /  6                     for k=0
            \  2*R[k] + R[k+1] + 4   for k>=1
          = 6, 12, 20, 36, 64, 108, 184, 316, 536, 908, 1544, ...

                          2*(3 + x^2 - 2*x^3)
    generating function  ---------------------
                         (1 - x - 2*x^3)*(1-x)

Area from Boundary

The area enclosed by the dragon curve for any 0 to N inclusive is related to the boundary by

    2*N = 4*A[N] + B[N]

Imagine each line segment as a diamond shape made from a right triangle of area 1/4 on each of the two sides.

      *
     / \         2 triangles
    0---1        one each side of line segment
     \ /         each triangle area 1/4
      *          total triangles=2*N

If a line segment is on the curve boundary then its outside triangle should not count towards the area enclosed, so subtract 1 for each unit boundary length. If a segment is both a left and right boundary, such as the initial N=0 to N=1 then it counts 2 to B[N] which makes its area 0 which is as desired. So

    area triangles = total triangles - B[N]
       4*A[N]      =     2*N         - B[N]

An enclosed area always has all four sides traversed exactly one. If there was ever an area enclosed bigger than a single unit then the curve would have to cross itself to traverse the inner lines to produce the "all inside segments traversed" pattern of the replications and expansions.

The relation can also be obtained by considering how the boundary and area change when a new line segment is added at the end of the curve. It will either touch or not touching the existing curve.

    * <---*                * <---*   curve touched
                           |     |     area +1
    no touch curve         |     |     boundary -3+1 = -2
    area unchanged         *-----*
    boundary +2

So boundary +2 for each segment, except -2 when a new area is enclosed. So boundary 2*N for each segment and -4*A to adjust down when the curve touched. Hence B=2*N-4*A.

Area

The area enclosed by the dragon curve N=0 to N=2^k can thus be calculated from the boundary recurrence B[k] as

    A[k] = 2^(k-1) - B[k]/4
         = 0, 0, 0, 0, 1, 4, 11, 28, 67, 152, 335, 724, 1539, ...

    A[k+5] = 4*A[k+4] - 5*A[k+3] + 4*A[k+2] - 6*A[k+1] + 4*A[k]
    starting A[0]=A[1]=A[2]=A[3]=0
             A[4]=1
                                    x^4
    generating function  -----------------------------
                         (1 - x - 2*x^3)*(1-x)*(1-2*x)

The recurrence form is the usual way to work a power into an existing linear recurrence. Or it can be obtained from the generating function which uses 1/(1-2x) to get 2^k to subtract from. The characteristic equation has a new factor (x-2) for 2 as a new root, and generating function denominator (1-2x) similarly.

    x^5 - 4*x^4 + 5*x^3 - 4*x^2 + 6*x^1 - 4
    = (x^3 - x^2 - 2) * (x-1) * (x-2)

Join Area

When the dragon curve doubles out from N=2^k to N=2^(k+1) the two copies enclose the same area each, plus where they meet encloses a further join area. This can be calculated as a difference

     JA[k] = A[k+1] - 2*A[k]      join area when N=2^k doubles

Using the A[k] area formula above gives JA[k] with the same recurrence as the boundary formula but different initial values. In the generating function the 1-2*x term in A[k] is eliminated.

     JA[k+4] = 2*JA[k+3] - JA[k+2] + 2*JA[k+1] - 2*JA[k]   k >= 0
     starting J[0] = 0
              J[1] = 0
              J[2] = 0
              J[3] = 1
     0, 0, 0, 1, 2, 3, 6, 11, 18, 31, 54, 91, 154, 263, 446, 755, ...

                                  x^3
    generating function  ---------------------
                         (1 - x - 2*x^3)*(1-x)

The B[k]=R[k+1] and difference L[k]=R[k+1]-R[k] from "Boundary Length" above also give

     JA[k] = (R[k+1] - L[k+1])/4

The geometric interpretation of this difference is that if the two copies of the curve did not touch at all then their boundary would be 2*(R[k]+L[k]) = 2*R[k+1]. But the doubled-out boundary is in fact only R[k+1]+L[k+1] so the shortfall is

    2*R[k+1] - (R[k+1]+L[k+1]) = R[k+1] - L[k+1]

Then each unit area of join has 4 sides worth of boundary, hence divide by 4 to JA[k] = (R[k+1]-L[k+1])/4.

Double Points from Area

The number of double-visited points is the same as the area enclosed for any N.

    Doubled[N] = Area[N]          points 0 to N inclusive

When a new line segment goes to an otherwise unvisited point it does not enclose new area and does not newly double a point.

When a line segment does touch an existing point it creates a new doubled point and encloses a new unit square area. As per "Area by Boundary" above the curve only ever closes a single unit square at a time, never a bigger area.

Single Points from Boundary

The number of single-visited points for any N is given by

    Single[N] = Boundary[N]/2 + 1

The single start point N=0 is Single[N]=1 and Boundary[N]=0. Thereafter when a new line segment goes to an otherwise unvisited point it creates 1 new single and 2 new boundary, maintaining the relation.

When a line segment does touch an existing point that point must be a single. It cannot be a double since no point is visited three times. So a single point becomes a new double, so single count -1. The following picture shows how the boundary is a net -2, maintaining the relation above.

     S <---*   new segment enclose 3 boundary
     |     |               create 1 new boundary
     |     |               net -2 boundary
     *-----*   single point S becomes double, so singles -1

All points are either singles or doubles and the total is

    N+1 = Single[N] + 2*Double[N]         points 0 to N inclusive

So the singles can also be obtained from Double[N]=Area[N] and Area[N]=N/2-B[N]/4 above.

    Single[N] = N+1 - 2*Double[N]
              = N+1 - 2*Area[N]
              = N+1 - 2*(N/2 - B[N]/4)
              = 1 + B[N]/2

Single Points

The number of single points for N=0 to N=2^k inclusive is

    S[k] = B[k]/2 + 1
    = 2, 3, 5, 9, 15, 25, 43, 73, 123, 209, 355, 601, 1019, 1729, ...

    S[k+3] = S[k+2] + 2*S[k]   for k >= 0
    starting S[0] = 2
             S[1] = 3
             S[2] = 5
                          2 + x + 2*x^2
    generating function   -------------
                          1 - x - 2*x^3

This is the same recurrence as left boundary L[k] but with different initial values. S[0] through S[4] inclusive are S[k]=2^k+1 since for k<=4 all points are singles. But for k>=5 some points double so there are fewer singles.

For the generating function the B[k]/2+1 cancels out the 2* and -1/(1-x) in the generating function of B ("Total Boundary" above) leaving just the 1-x-2*x^3 denominator.

Total Points

The total number of distinct points visited by the curve from 0 to N inclusive is

      P[N] = Single[N] + Doubled[N]
           = N+1 - Doubled[N]
           = N+1 - A[N]

For points N=0 to N=2^k inclusive the recurrence for A gives

      P[k] = 2^(k-1) + 1 + B[k]/4
           = 4*P[k-1] - 5*P[k-2] + 4*P[k-3] - 6*P[k-4] + 4*P[k-5]   k>=5
      starting P[0] =  2
               P[1] =  3
               P[2] =  5
               P[3] =  9
               P[4] = 16
      = 2, 3, 5, 9, 16, 29, 54, 101, 190, 361, 690, 1325, 2558, 4961, ...

                           2 - 5*x + 3*x^2 - 4*x^3 + 5*x^4
      generating function  -------------------------------
                            (1 - x - 2*x^3)*(1-x)*(1-2*x)

This is the same recurrence as the area but with different starting values.

Join Points

When the curve doubles the two copies have a certain number of join points in common. This is given by

    JP[k] = JA[k] + 1
          = 2*JP[k-1] - JP[k-2] + 2*JP[k-3] - 2*JP[k-4]   k>=0
    starting JP[0] = 1
             JP[1] = 1
             JP[2] = 1
             JP[3] = 2
    = 1, 1, 1, 2, 3, 4, 7, 12, 19, 32, 55, 92, 155, 264, 447, ...

                             1 - x - x^3
    generating function  ---------------------
                         (1 - x - 2*x^3)*(1-x)

The initial values are 1 because the copies meet at their endpoints only. For example N=0to2 becomes N=0to4 and the point N=2 is the single join point between the copies.

When a unit area of join is created, two points P and Q from the first and second copy touch. As in the following picture P and Q might be either two right angles meeting, or a little U closed off. In both cases the join takes 2 points from each of the two curve copies.

        |                                |
         \    second            first   /
    --- P -----*                  *----- P ---
       \       |                  |       /
        |      |                  |      | second
        |       \                 |       \
        *----- Q ---              *----- Q ---
    first     \                         \
               |                         |

The first join point is N=2^k itself, and thereafter each join area square adds 1 more join point. So the total join points is

    JP[k] = JA[k] + 1

Substituting the recurrence for JA and noticing the recurrence coefficients add up to -1 so cancelling out the +1 means JP is the same boundary recurrence as in B but with yet further different initial values.

The join points are pairs of singles in the previous level which have now become doubles, plus the N=2^k endpoint itself. So JP[k] can be had from the newly formed doubles

    JP[k] = 1 + Doubles[k+1] - 2*Doubles[k]

which with Doubles[N]=Area[N] is the same as from JA[k].

The join points can also be had from the total points. If two copies of the curve did not touch at all then the total visited points would double. The actual total visited is less and the shortfall is the join points.

    JP[k] = 2*P[k] - P[k+1]       # total points shortfall on doubling

Two Arm Endpoint Boundary

The boundary length between the endpoints of two arms is

    W[k] = / 2            for k=0
           | 4            for k=1
           \ 2*L[k-1]     for k>=2
    = 2, 4, 4, 8, 16, 24, 40, 72, 120, 200, 344, ...

    2
    ^
    |   W     boundary between endpoints 1 and 2
    |
    0----->1

The two arms expand each on the right as follows, giving an L and a V. (The following diagram rotated 45 degrees.)

       L
    2----->*      1      W[k+1] = V[k] + L[k]
           ^  V   |             = 2*L[k]    for k>=1
           |      v      since V[k]=L[k] for k>=1
           0----->*

The 2*L[k-1] can also be seen in a second expansion. The 1 to m and m to 2 are both T sections and which is the same as an L of one higher level (as per "Left Boundary").

    2
    |  T[k]=L[k+1]                1 to 2 = W[k+2]
    v                                    = 2*T[k]
    *<-----m                             = 2*L[k+1]
    ^      |   T[k]=L[k+1]
    |      v
    0----->*<-----1
    |      ^
    v      |
    *<-----*

W[k] is two curves directed away from a common origin whereas L[k+1] is two curves directed towards a common point.

    2  <-----3                  2<-----  3
    ^ \      |                  ^       /|
    |  \     |                  |      / |
    |    W   |                  |    L   |
    |      \ v                  |  /     |
    |       \                     /      v
    0------->1                  0------->1

    W[k] = 2*L[k-1]               L[k+1]
    W[0] = 2                      L[0+1]=2

W[k] is smaller, since some substitutions of the L recurrence gives L[k+1] as W[k] plus positive terms

    L[k+1] = L[k] + 2*L[k-2]
           = L[k-1] + 2*L[k-2] + 2*L[k-3]
           = L[k-1] + (L[k-1] - 2*L[k-4]) + L[k-2] + 2*L[k-3]
           = 2*L[k-1]  + L[k-2] + 2*(L[k-3] - L[k-4])
           = 2*L[k-1]  + L[k-2] + 4*L[k-6]
           = W[k]  + L[k-2] + 4*L[k-6]

Two Arm Boundary

The boundary length around the whole of two arms is

    Ba2[k] = B[k] + W[k]
    = 4, 8, 12, 24, 44, 72, 124, 216, 364, 616, 1052, 1784, 3020, ...
       2
       ^
       |  W          Ba2 = L+R + W
    L  |                 =  B  + W
       0----->1
          R

Three Arms Boundary

The boundary length around the whole of two arms is

    Ba3[k] = B[k] + 2*W[k]
    = 6, 12, 16, 32, 60, 96, 164, 288, 484, 816, 1396, 2368, 4004, ...
           2
           ^
       W   |  W
           |
    3<-----0----->1
       L      R

Four Arms Boundary

The boundary length around the whole of four arms is

    Ba4[k] = 4*W[k]
    = 8, 16, 16, 32, 64, 96, 160, 288, 480, 800, 1376, 2336, 3936, ...
           2
           ^
       W   |  W
           |
    3<-----0----->1
           |
       W   v  W
           4

This arms=4 boundary is almost the same as arms=3 for the first few terms, but for k>=8 the arms=3 is longer, and longer by an ever-increasing amount.

    Ba3[k]  > Ba4[k]   for k >= 8      (values 484, 480 onwards)
    Ba3[k] >= Ba4[k]   for k >= 5      (value 96 onwards)

This is found by

    Ba3[k] = 4*L[k-1] + B[k]
    Ba4[k] = 8*L[k-1]

and with B[k]=L[k]+R[k] expanding R[k] as a sum of L's and repeatedly applying the recurrence for L gives an identity

    B[k] = 4*L[k-1]
           - L[k-4] - L[k-5] + 5*L[k-6]
           + R[k-6]                      identity for k >= 7

The middle sum of L's is positive for k>=8,

    - L[k-4] - L[k-5] + 5*L[k-6] >= 0    for k >= 8

This is seen by direct evaluation until k=15 at which point repeated expansion by the L recurrence has positive multiples above negatives (or continuing two more steps to all positive multiples)

    - L[k-4] - L[k-5] + 5*L[k-6]
    =
    5*L[k-12] + 10*L[k-13] - 2*L[k-14]     for k >= 15

Roughly speaking L[k] grows as r^k where r=1.69562 is the root above. The power multiples -1,-1,5 is positive so the combination is positive eventually (in this case k>=8).

    - r^2 - r + 5 = 0.4292   > 0

Twin Dragons

Two dragons placed head to tail mesh perfectly. The second dragon is rotated 180 degrees and the two left sides mesh.

             9----8    5---4
             |    |    |   |
            10--11,7---6   3---2
                  |            |
       16   13---12        0---1
        |    |
       15---14        14--15
                       |   |      ^   second copy
    1---0         12--13  16      |   rotated 180
    |              |              |   left sides mesh,
    2---3     6---7,11-10             N=0 and N=16
        |     |    |    |             head to tail
        4-----5    8----9

This left side meshing can be seen by starting from an initial 1x1 square which is two dragons N=0 to N=2.

                          1
                         ^ ^
                        /   \           twin dragon
                      2      0,4        square N=0 to N=2
    1<---0 2           \     /          each expanding
    ^      |            v   v           to N=0 to N=4
    |      |             3 3
    |      v            ^   ^
    2 0--->1           /     \
                     4,0      2
                        \   /
                         v v
                          1

The arrows show the directions for the subsequent expansion on the right. The directions are per the odd/even X,Y point pattern and as per the expansions above the enclosed square remains enclosed and all interior segments are traversed precisely once, which means a perfect meshing.

Other Formulas

A boundary calculation for the curve as a fractal of infinite descent can be found in

Angel Chang and Tianrong Zhang, "The Fractal Geometry of the Boundary of Dragon Curves", Journal of Recreational Mathematics, volume 30, number 1, 1999-2000, pages 9-22. http://www.coiraweb.com/poignance/math/Fractals/Dragon/Bound.html http://stanford.edu/~angelx/pubs/dragonbound.pdf

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)

    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 increment, for k=4 up

    A003479   join area between N=2^k replications
    A077949   join area increments

    A003476   single points N=0 to N=2^k inclusive
                and initial 1 for N=0 to N=0
    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 something like that.

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);

SEE ALSO ^

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

HOME PAGE ^

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

LICENSE ^

Copyright 2011, 2012, 2013, 2014 Kevin Ryde

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

syntax highlighting: