Dragon curve: Difference between revisions

 

The string rewrites can be done recursively without building the whole string, just follow its instructions at the target level. See for example [[#C by IFS Drawing|C by IFS Drawing]] code. The effect is the same as "recursive with parameter" above but can draw other curves defined by L-systems. <br><br>

 

=={{header|ALGOL 68}}==

{{trans|python}}

<!-- {{works with|ALGOL 68|Standard - but ''draw'' is not part of the standard prelude}} -->

<!-- {{does not work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386 - when I figure out how to link to the linux plot lib, then it might work}} -->

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.8 algol68g-2.8].}}

 

STRUCT (REAL x, y, heading, BOOL pen down) turtle;

);

 

 

COMMENT

PROC raise unimplemented = (EXCEPTOBJS obj, STRING msg)VOID: IF NOT on unimplemented mend(obj, msg) THEN stop FI;

 

# -*- coding: utf-8 -*- #

 

VOID(system("sleep 1"))

OD;

 

Output:

|}

Note: each Dragon curve is composed of many smaller dragon curves (shown in a different colour).

 

=={{header|AmigaE}}==

Example code using mutual recursion can be found in [http://cshandley.co.uk/JasonHulance/beginner_170.html Recursion Example] of "A Beginner's Guide to Amiga E".

 

=={{header|Asymptote}}==

=={{header|BASIC}}==

{{works with|QBasic}}

SUB turn (degrees AS Double)

PSET (150,180), 0

dragon 400, 12, 1

 

 

* https://archive.org/details/byte-magazine-1983-12

 

 

[[File:Dragon curve BASIC-256.png|220px|thumb|right|Image created by the BASIC-256 script]]

 

graphsize 390,270

level = level + 1

insize = insize*SQ

 

{{works with|BBC BASIC for Windows}}

MOVE 800,400

GCOL 11

angle += d*PI/4

ENDIF

 

 

This is loosely based on the [[Dragon_curve#M4|M4]] predicate algorithm, only it produces a more compact ASCII output (which is also a little easier to implement), and it lets you choose the depth of the expansion rather than having to specify the coordinates of the viewing area.

 

In Befunge-93 the 8-bit cell size restricts you to a maximum depth of 15, but in Befunge-98 you should be able go quite a bit deeper before other limits of the implementation come into play.

 

| v%2\/3-1$_\#!4#:*#-\#1<\1+1:/4+1g00:\_\#$1<%2/2+1\g02\-1+%-g012\/-*<v"*/

_ >!>0$#0\#$\_-10p20p::00g4/:1+1>\#<1#*-#4:#\_$1-2*3/\2%!>0$#0\#$\_--vv|+2

>:1+*!60g*!#v_!\!*50g0`*!40gg,::30g40g:2-#^_>>$>>:^:+1g02::\,+55_55+,@v":*

v%2/2+*">~":< ^\-1g05-*">~"/2+*"|~"-%*"|~"\/*"|~":\-*">~"/2+%*"|~"\/*<^<:

 

{{out}}

_|_|_|_| _|_|_|_|

|_| |_| |_| |_|</pre>

 

=={{header|C}}==

[[file:dragon-C.png|thumb|center]]

C code that writes PNM of dragon curve. run as <code>a.out [depth] > dragon.pnm</code>. Sample image was with depth 9 (512 pixel length).

#include <stdlib.h>

#include <string.h>

 

return 0;

 

=={{header|C++}}==

 

This program will generate the curve and save it to your hard drive.

#include <windows.h>

#include <iostream>

}

//-----------------------------------------------------------------------------------------

 

 

 

 

 

 

=={{header|COBOL}}==

{{works with|GnuCOBOL}}

*> This code is dedicated to the public domain

identification division.

stop run

.

 

{{out}}

....... ...

hjkl?q</pre>

 

=={{header|Common Lisp}}==

 

The recursive <tt>dragon-part</tt> function draws a curve connecting (0,0) to (1,0); if <var>depth</var> is 0 then the curve is a straight line. <var>bend-direction</var> is either 1 or -1 to specify whether the deviation from a straight line should be to the right or left.

(:use #:clim-lisp #:clim)

(:export #:dragon #:dragon-part))

(with-room-for-graphics ()

(with-scaling (t size)

 

=={{header|D}}==

*rules : (X → X+YF+),(Y → -FX-Y)

*angle : 90°

 

struct Board {

dragonX(7, t, b); // <- X

writeln(b);

{{out}}

<pre> - - - -

===PostScript Output Version===

{{trans|Haskell}}

 

string drx(in size_t n) pure nothrow {

void main() {

writeln(dragonCurvePS(9)); // Increase this for a bigger curve.

 

===On a Bitmap===

First a small "turtle.d" module, useful for other tasks:

 

 

import bitmap_bresenhams_line_algorithm, grayscale_image, std.math;

y += dy;

}

 

Then the implementation is simple:

{{trans|PicoLisp}}

 

void drawDragon(Color)(Image!Color img, ref Turtle t, in uint depth,

img.drawDragon(t, 14, 45.0, 3);

img.savePGM("dragon_curve.pgm");

 

===With QD===

===With DFL===

See: [[Dragon curve/D/DFL]]

 

 

linewidth 0.5

x = 25

angle = 0

#

.

 

=={{header|Elm}}==

import Collage exposing (..)

import Element exposing (..)

, update = update

, subscriptions = subscriptions

 

Link to live demo: http://dc25.github.io/dragonCurveElm

Drawing ascii art characters into a buffer using <code>[http://www.gnu.org/software/emacs/manual/html_node/emacs/Picture-Mode.html picture-mode]</code>

 

"If point is in the first line of the buffer then insert a new line above."

(when (= (line-beginning-position) (point-min))

(goto-char (point-min)))

 

 

<pre>

| | | |

+-+ +-+</pre>

 

=={{header|ERRE}}==

Graphic solution with PC.LIB library

PROGRAM DRAGON

 

GET(A$)

END PROGRAM

 

=={{header|F Sharp|F#}}==

Using {{libheader|Windows Presentation Foundation}} for visualization:

open System.Windows.Media

 

[ for a, b in nest 13 step (seq [Point(0.0, 0.0), Point(1.0, 0.0)]) ->

PathFigure(a, [(LineSegment(b, true) :> PathSegment)], false) ]

 

=={{header|Factor}}==

A translation of the BASIC example, using OpenGL, drawing with HSV coloring similar to the C example.

 

USING: accessors colors colors.hsv fry kernel locals math

math.constants math.functions opengl.gl typed ui ui.gadgets

 

MAIN: dragon-window

 

=={{header|Forth}}==

{{works with|bigFORTH}}

 

2 value dragon-step

 

home clear

{{works with|4tH}}

Basically the same code as the BigForth version.

[[file:4tHdragon.png|right|thumb|Output png]]

include lib/gturtle.4th

 

clear-screen 50 95 turtle!

xpendown 13 45 dragon

 

=={{header|Gnuplot}}==

Implemented by "parametric" mode running an index t through the desired number of curve segments with X,Y position calculated for each. The "lines" plot joins them up.

 

# The least significant bit is position 0.

# For example n=13 is binary "1101" and the high bit is pos=3.

set parametric

set key off

 

===Version #2.===

 

;plotdcf.gp:

## plotdcf.gp 1/11/17 aev

## Plotting a Dragon curve fractal to the png-file.

plot -100

set output

;Plotting 3 Dragon curve fractals:

## pDCF.gp 1/11/17 aev

## Plotting 3 Dragon curve fractals.

filename = "DCF"; ttl = "Dragon curve fractal, order ".ord;

load "plotdcf.gp"

{{Output}}

<pre>

2. 3 plotted png-files: DCF11gp, DCF13gp and DCF15gp

</pre>

 

=={{header|Go}}==

[[file:GoDragon.png|right|thumb|Output png]]

Version using standard image libriary is an adaptation of the version below using the Bitmap task. The only major change is that line drawing code was needed. See comments in code.

 

import (

dragon(n-1, a1, 1, d, x, y)

dragon(n-1, a2, -1, d, x+d*cos[a1], y+d*sin[a1])

Original version written to Bitmap task:

 

// Files required to build supporting package raster are found in:

dragon(n-1, a1, 1, d, x, y)

dragon(n-1, a2, -1, d, x+d*cos[a1], y+d*sin[a1])

 

=={{header|Haskell}}==

import Graphics.Gnuplot.Simple

 

where lxs = last xs

 

For plotting I use the gnuplot interface module from [http://hackage.haskell.org/packages/hackage.html hackageDB]

 

 

String rewrite, and outputs a postscript:

x n = (x$n-1)++" +"++(y$n-1)++" f +"

y 0 = ""

"f", x n, " stroke showpage"]

 

 

=={{header|HicEst}}==

A straightforward approach, since HicEst does not know recursion (rarely needed in daily work)

 

1 DLG(NameEdit=orders,DNum, Button='&OK', TItle=dragon) ! input orders

GOTO 1 ! this is to stimulate a discussion

 

 

=={{header|Icon}} and {{header|Unicon}}==

The following implements a Heighway Dragon using the [[Lindenmayer system]]. It's based on the ''linden'' program in the Icon Programming Library.

 

procedure main()

WriteImage("dragon-unicon" || ".gif") # save the image

WDone()

 

{{libheader|Icon Programming Library}}

 

=={{header|J}}==

start=: 0 0,: 1 0

step=: ],{: +"1 (0 _1,: 1 0) +/ .*~ |.@}: -"1 {:

In English: Start with a line segment. For each step of iteration, retrace that geometry backwards, but oriented 90 degrees about its original end point. To show the curve you need to pick some arbitrary number of iterations.

 

 

For a more colorful display, with a different color for the geometry introduced at each iteration, replace that last line of code with:

 

<div style="border: 1px solid #FFFFFF; overflow: auto; width: 100%"></div>

 

Giving the code

f1=.*&(-:1j1)

f2=.[: -. *&(-:1j_1)

 

Where both functions are applied successively to starting complex values of 0 and 1.

 

=={{header|Java}}==

import java.awt.Graphics;

import java.util.*;

new DragonCurve(14).setVisible(true);

}

 

=={{header|JavaScript}}==

{{works with|Chrome 8.0}}

I'm sure this can be simplified further, but I have this working [http://kevincantu.org/code/dragon/dragon.html here]!

 

Though there is an impressive SVG example further below, this uses JavaScript to recurse through the expansion and simply displays each line with SVG. It is invoked as a method <code>DRAGON.fractal(...)</code> as described.

// MATRIX MATH

// -----------

};

 

 

My current demo page includes the following to invoke this:

<script src='./dragon.js'></script>

...

DRAGON.fractal('fractal', [100,300], [500,300], 15, false, 700);

</script>

 

{{works with|Chrome}}

[[File:DC11.png|200px|right|thumb|Output DC11.png]]

[[File:DC19.png|200px|right|thumb|Output DC19.png]]

[[File:DC25.png|200px|right|thumb|Output DC25.png]]

<!-- DragonCurve.html -->

<html>

</body>

</html>

'''Testing cases:'''

<pre>

<pre>

Page with different plotted Dragon curves. Right-clicking on the canvas you can save each of them

 

=={{header|jq}}==

{{works with|jq|1.4}}

The following is based on the JavaScript example, with some variations, notably:

* the last argument of the main function allows CSS style elements to be specified

# left if true, make new point on left; if false, then on right

# css a JSON object optionally specifying "stroke" and "stroke-width"

def mult(m; v):

[ m[0][0] * v[0] + m[0][1] * v[1],

grow(ptA; ptC; steps; left),

"'/>",

'''Example''':

{{out}}

[https://drive.google.com/file/d/0BwMI1gZaY2-MYW1oanVfMVRTVms/view SVG converted to png]

 

The command to generate the SVG and the first few lines of output are as follows:

<svg width='100%' height='100% '

id='roar'

M259.375 218.75L262.5 218.75

...

 

=={{header|Julia}}==

Code uses Luxor library[https://juliagraphics.github.io/Luxor.jl/latest/turtle.html].

 

using Luxor

function dragon(turtle::Turtle, level=4, size=200, direction=45)

finish()

preview()

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.Color

fun main(args: Array<String>) {

DragonCurve(14).isVisible = true

 

 

 

 

 

 

 

=={{header|Logo}}==

===Recursive===

make "step :step - 1

make "length :length / 1.41421

if :step > 0 [lt 45 dcr :step :length rt 90 dcl :step :length lt 45]

if :step = 0 [lt 45 fd :length rt 90 fd :length lt 45]

The program can be started using <tt>dcr 4 300</tt> or <tt>dcl 4 300</tt>.

 

Or removing duplication:

if :step = 0 [fd :length stop]

rt :dir

to dragon :step :length

dc :step :length 45

An alternative approach by using sentence-like grammar using four productions o->on, n->wn, w->ws, s->os. O, S, N and W mean cardinal points.

if :step=1 [Rt 90 fd :length Lt 90] [O (:step - 1) (:length / 1.41421) N (:step - 1) (:length / 1.41421)]

end

to S :step :length

if :step=1 [Rt 180 fd :length Lt 180] [O (:step - 1) (:length / 1.41421) S (:step - 1) (:length / 1.41421)]

 

===Iterative===

 

{{works with|UCB Logo}}

; If :n = binary "...z100..00" then the return is "z000..00".

; Eg. n=22 is binary 10110 the lowest 1-bit is the "...1." and the return is

end

 

 

; off with little 45-degree diagonals.

; Done this way the vertices don't touch.

end

 

 

=={{header|Lua}}==

{{works with|Lua|5.1.4}}

Could be made much more compact, but this was written for speed. It has two rendering modes, one which renders the curve in text mode (default,) and one which just dumps all the coordinates for use by an external rendering application.

local l = "l"

local r = "r"

 

--replace this line with dump_points() to output a list of coordinates:

Output:

<pre>

**** ****

</pre>

=={{header|M2000 Interpreter}}==

[https://1.bp.blogspot.com/-KTPvvri-EAQ/W_7C9ug1WFI/AAAAAAAAHck/NeWCuJ0GXpkMwkANM6i6UJRgZxqig_mXgCLcBGAs/s1600/dragon_curve.png Image]

 

Module Checkit {

def double angle, d45, d90, change=5000

Checkit

 

 

=={{header|M4}}==

This code uses the "predicate" approach. A given x,y position is tested by a predicate as to whether it's on the curve or not and printed as a character or a space accordingly. The output goes row by row and column by column with no image storage or buffering.

 

# which is suitable as arguments to a further macro. The quoting is slack

# because the values are always integers and so won't suffer unwanted macro

#

dragon_ascii(-6,5, dnl X range

 

;Output

=={{header|Mathematica}} / {{header|Wolfram Language}}==

Two functions: one that makes 2 lines from 1 line. And another that applies this function to all existing lines:

NextStep[in_]:=Flatten[FoldOutLine/@in,1]

lines={{{0.,0.},{1.,0.}}};

 

=={{header|Metafont}}==

The following code produces a single character font, 25 points wide and tall (0 points in depth), and store it in the position where one could expect to find the character D.

 

dragoniter := 8;

beginchar("D", 25pt#, 25pt#, 0pt#);

draw for v:=1 step 2mstep until (2-2mstep): z[v] -- endfor z[2];

endchar;

 

The resulting character, magnified by 2, looks like:

 

<div style="text-align:center">[[Image:Dragon1.png]]</div>

 

=={{header|OCaml}}==

{{libheader|Tk}}

Example solution, using an OCaml class and displaying the result in a Tk canvas, mostly inspired by the Tcl solution.

let pi = acos (-1.0);

 

ignore (Canvas.create_line ~xys: dcc#get_coords c);

Tk.mainLoop ();

=== A functional version ===

Here is another OCaml solution, in a functional rather than OO style:

let zag (x1,y1) (x2,y2) = (x1+x2-y1+y2)/2, (x1-x2+y1+y2)/2

 

let points = dragon p1 (zig p1 p2) p2 15 in

ignore (Canvas.create_line ~xys: points c);

producing:

<div>[[File:OCaml_Dragon-curve-example2.png‎]]</div>

Using the two sub-curves inward approach. The sub-curves are rotated and shifted explicitly. That could be combined into a <code>multmatrix()</code> each if desired. Lines segments are drawn as elongated cuboids.

 

linewidth = .1; // fraction of segment length

sqrt2 = pow(2, .5);

dragon(level);

}

 

=={{header|PARI/GP}}==

Using the "high level" <code>plothraw</code> with real and imaginary parts of vertex points as X and Y coordinates. Change <code>plothraw()</code> to <code>psplothraw()</code> to write a PostScript file "pari.ps" instead of drawing on-screen.

 

p = [0, 1]; \\ complex number points, initially 0 to 1

 

p = concat(p, apply(z->(end - I*z), Vecrev(p[^-1]))))

 

 

===Version #2.===

Using the "low level" plotting functions to draw to a GUI window (X etc).

 

bit_above_low_1(n) = bittest(n, valuation(n,2)+1);

for(i=1,len, plotrline(0,dx,dy); \

if(bit_above_low_1(i), turn_right(), turn_left()));

 

===Version #3.===

{{Works with|PARI/GP|2.7.4 and above}}

 

\\ Dragon curve

\\ 4/8/16 aev

}

 

 

{{Output}}

=={{header|Pascal}}==

using Compas (Pascal with Logo-expansion):

begin;

step:=step -1;

end;

end;

main program:

init;

penup;

dcr(step,direction,length);

close;

 

=={{header|Perl}}==

use List::Util qw(max min);

 

open $fh, '>', 'dragon_curve.svg';

print $fh $svg->xmlify(-namespace=>'svg');

[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/dragon_curve.svg Dragon curve] (offsite image)

 

=={{header|Phix}}==

Changing the colour and depth give some mildly interesting results.

 

=={{header|PicoLisp}}==

{{trans|Forth}}

This uses the 'brez' line drawing function from [[Bitmap/Bresenham's line algorithm#PicoLisp]].

(load "@lib/math.l")

 

(prinl "P1")

(prinl 300 " " 200)

 

=={{header|PL/I}}==

 

A restriction of the pl/i compiler in the 1980s was that array indices could not exceed 32767, thus the escalation to a two-dimensional array, as in <code>DECLARE FOLD(0:31,0:32767) BOOLEAN; /*Oh for (0:1000000) or so..*/</code> This made the array indexing rather messy.

* PROCESS GONUMBER, MARGINS(1,72), NOINTERRUPT, MACRO;

TEST:PROCEDURE OPTIONS(MAIN);

CALL PLOT(0,0,-3); CALL PLOT(0,0,999);

END TEST;

 

=={{header|PostScript}}==

%%BoundingBox: 0 0 550 400

/ifpendown false def

% 0 0 moveto 550 0 rlineto 0 400 rlineto -550 0 rlineto closepath stroke

showpage

 

Or (almost) verbatim string rewrite: (this is a 20 page document, and don't try to print it,

or you might have a very angry printer).

%%BoundingBox 0 0 300 300

 

1 1 20 { dragon showpage } for

 

;See also:

* [http://www.cs.unh.edu/~charpov/Programming/L-systems/ L-systems in Postscript]

=={{header|POV-Ray}}==

Example code recursive and iterative can be found at [http://aesculier.fr/fichiersPovray/dragon/dragon.html Courbe du Dragon].

 

=={{header|Prolog}}==

Works with SWI-Prolog which has a Graphic interface XPCE.<BR>

DCG are used to compute the list of "turns" of the Dragon Curve and the list of points.

dcg_dg(N, [left], DCL, []),

Side = 4,

 

inverse(right) -->

Output :

<pre>1 ?- dragonCurve(13).

true </pre>[[File : Prolog-DragonCurve.jpg]]

 

=={{header|Python}}==

{{trans|Logo}}

{{libheader|turtle}}

 

def dragon(step, length):

right(90)

forward(length)

A more pythonic version:

 

def dragon(level=4, size=200, zig=right, zag=left):

hideturtle()

dragon(6)

Other version:

 

def dragon(level=4, size=200, direction=45):

hideturtle()

dragon(6)

 

=={{header|R}}==

===Version #1.===

Dragon<-function(Iters){

Rotation<-matrix(c(0,-1,1,0),ncol=2,byrow=T) ########Rotation multiplication matrix

segments(Iteration[[i]][s,1], Iteration[[i]][s,2], Iteration[[i]][s,3], Iteration[[i]][s,4], col= 'red')

}}#########################################################################

[https://commons.wikimedia.org/wiki/File:Dragon_Curve_16_Iterations_R_programming_language.png#mediaviewer/File:Dragon_Curve_16_Iterations_R_programming_language.png]

 

[[File:DCR13.png|200px|right|thumb|Output DCR13.png]]

[[File:DCR16.png|200px|right|thumb|Output DCR16.png]]

# Generate and plot Dragon curve.

# translation of JavaScript v.#2: http://rosettacode.org/wiki/Dragon_curve#JavaScript

##gpDragonCurve(15, "darkgreen", "", 10, 2, -450, -500)

gpDragonCurve(16, "darkgreen", "", 10, 3, -1050, -500)

 

{{Output}}

 

=={{header|Racket}}==

 

(require plot)

new-pos

(cons new-pos trail))))])

[[Image:Racket_Dragon_curve.png]]

 

 

 

 

 

 

 

 

=={{header|REXX}}==

 

This, in effect, allows the dragon curve to be plotted/displayed with a different (starting) orientation.

plot_pts = '123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZΘ' /*plot chars*/

parse arg # p c . /*#: number of iterations; P=init dir.*/

if p=='' | p=="," then p= 'north'; upper p /* " " " " " " */

end /*c*/ /* [↑] append a single column of a row.*/

Choosing a &nbsp; ''high visibility'' &nbsp; glyph can really help make the dragon much more viewable; &nbsp; the

<br>solid fill ASCII character &nbsp; (█ &nbsp; or &nbsp; hexadecimal &nbsp; '''db''' &nbsp; in code page 437) &nbsp; is quite good for this.

=={{header|Ruby}}==

{{libheader|Shoes}}

Line = Struct.new(:start, :stop)

 

end

end

 

 

 

 

 

 

=={{header|Scala}}==

import java.awt.Graphics

 

object DragonCurve extends App {

new DragonCurve(14).setVisible(true);

 

=={{header|Scilab}}==

It uses complex numbers and treats them as vectors to perform rotations of the edges of the curve around one of its ends. The output is a shown in a graphic window.

 

folds=[];

 

set(gca(),"isoview","on");

 

=={{header|Seed7}}==

include "float.s7i";

include "math.s7i";

dragon(768.0, 14, 1);

ignore(getc(KEYBOARD));

 

Original source: [http://seed7.sourceforge.net/algorith/graphic.htm#dragon_curve]

=={{header|SequenceL}}==

'''Tail-Recursive SequenceL Code:'''<br>

import <Utilities/Conversion.sl>;

 

result when steps <= 0

else