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|Action!}}==

Action! language does not support recursion. Therefore an iterative approach with a stack has been proposed.

 

INT ARRAY

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Dragon_curve.png Screenshot from Atari 8-bit computer]

 

=={{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}}

The drawing may be skewed for some iterations since it is drawn to fit the bounding box.

 

Turns ← {{𝕩∾1∾¬⌾((⌊2÷˜≠)⊸⊑)𝕩}⍟𝕩 ⥊1}

 

[https://mlochbaum.github.io/BQN/try.html#code=Um90IOKGkCDCrOKKuHst4oy+KPCdlajiirjiipEp4oy98J2VqX0KVHVybnMg4oaQIHt78J2VqeKIvjHiiL7CrOKMvigo4oyKMsO3y5ziiaAp4oq44oqRKfCdlal94o2f8J2VqSDipYoxfQoK4oCiUGxvdMK0IDzLmOKNiT4rYCAoPDDigL8xKShSb3TLnClgVHVybnMgNAoK Try It!]

 

[[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 sharp|C#}}==

{{trans|Java}}

using System.Collections.Generic;

using System.Drawing;

Application.Run(new DragonCurve(14));

}

 

=={{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}}

 

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===

{{libheader| Vcl.Graphics}}

{{Trans|Go}}

program Dragon_curve;

 

Dragon.AsBitmap.SaveToFile('dragon.bmp');

Dragon.Free;

 

=={{header|EasyLang}}==

 

 

x = 25

y = 60

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>

=={{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|Fōrmulæ}}==

 

 

 

 

 

 

 

 

 

=={{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>

[[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|Gri}}==

Recursively by a dragon curve comprising two smaller dragons drawn towards a midpoint.

 

Draw a dragon curve going from .x1. .y1. to .x2. .y2. with recursion

depth .level.

set y axis -1 1 .25

 

 

=={{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}}==

 

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>

 

====Version #2.====

[[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>

 

(Pure JS, without HTML or DOM)

'use strict';

 

// MAIN ---

return main();

 

=={{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|Lambdatalk}}==

1) two twinned recursive functions

 

{def dcr

{lambda {:step :length}

}}}

-> dcl

The word Tθ rotates the drawing direction of the pen from θ degrees

and the word Md moves it on d pixels.

 

3) drawing three dragon curves [2,6,10] of decreasing width:

{svg

{@ width="580px" height="580px"

fill="transparent" stroke=":c" stroke-width=":w"}}

-> stroke

The output can be seen in http://lambdaway.free.fr/lambdawalks/?view=dragon

 

=={{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>

[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:

Rather than producing a big PPM file, we output a PNG file.

 

import imageman

 

 

# Save into a PNG file.

 

=={{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}}==

As in the Raku solution, we'll use a [[wp:L-System|Lindenmayer system]] and draw the dragon in [[wp:SVG|SVG]].

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)

 

You can run this online [http://phix.x10.mx/p2js/dragoncurve.htm here].

Changing the colour and depth give some mildly interesting results.

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\DragonCurve.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

=={{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]

{{trans|Logo}}

{{libheader|turtle}}

[Single]$script:QUARTER_PI=0.7853982

[Single]$script:HALF_PI=1.570796

# display the GDI Form window, which triggers its prepared anonymous drawing function

$Form.ShowDialog()

 

=={{header|Processing}}==

int ints = 13;

 

turn_right(l, ints-1);

}

 

==={{header|Processing Python mode}}===

ints = 13

 

turn_left(l, ints - 1)

rotate(radians(-90))

 

=={{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|Quackery}}==

 

[ 2 *

right ] resolves left ( n --> )

-260 1 fly

3 4 turn

100 1 fly

5 8 turn

 

{{output}}

 

 

=={{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]]

 

(formerly Perl 6)

We'll use a L-System role, and draw the dragon in SVG.

 

role Lindenmayer {

:polyline[ :points(@points.join: ','), :fill<white> ],

],

 

=={{header|REXX}}==

 

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

d.= 1; d.L= -d.; @.= ' '; x= 0; x2= x; y= 0; y2= y; z= d.; @.x.y= "∙"

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

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

if a\=='' then say strip(a, "T") /*display a line (row) of curve points.*/

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

 

{{libheader|RubyGems}}

{{libheader|JRubyArt}}

GEN = 14

attr_reader :angle

size(700, 600)

end

 

{{libheader|RubyGems}}

{{libheader|cf3ruby}}

Context Free Art version

 

INV_SQRT = 1 / Math.sqrt(2)

start_x: width / 3, start_y: height / 3.5

end

 

=={{header|Rust}}==

use ggez::{

conf::{WindowMode, WindowSetup},

event::run(ctx, event_loop, state)

}

<div>[[File:dragon_curve_rust.gif]]</div>

 

=={{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

 

'''C++ Driver Code:'''<br>

{{libheader|CImg}}

#include <vector>

#include "SL_Generated.h"

sl_done();

return 0;

 

{{out}}

=={{header|Sidef}}==

Uses the '''LSystem()''' class from [https://rosettacode.org/wiki/Hilbert_curve#Sidef Hilbert curve].

x => 'x+yF+',

y => '-Fx-y',

)

 

Output image: [https://github.com/trizen/rc/blob/master/img/dragon_curve-sidef.png Dragon curve]

 

=={{header|SPL}}==

Animation of dragon curve.

level = 0

step = 1

<

#.scr()

 

=={{header|SVG}}==

 

<div style="clear: right;"></div>

<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"

"http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">

</g>

 

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

{{libheader|Tk}}

 

set pi [expr acos(-1)]

.c create line {0 0 0 0} -tag dragon

dragon 400 17

 

See also the Tcl/Tk wiki [http://wiki.tcl.tk/3349 Dragon Curves] and [http://wiki.tcl.tk/10745 Recursive curves] pages.

So, for [[plainTeX]],

 

\usetikzlibrary{lindenmayersystems}

 

lindenmayer system;

\endtikzpicture

 

=={{header|LaTeX}}==

Or fixed-direction variant to stay horizontal, this time for [[LaTeX]],

 

\usepackage{tikz}

\usetikzlibrary{lindenmayersystems}

}

\begin{document}

 

=={{header|Vedit macro language}}==

This way we can avoid using any floating point calculations, trigonometric functions etc.

 

BOF Del_Char(ALL)

 

#10 = #10 >> 8

}

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

 

 

static draw(alpha) {}

 

=={{header|X86 Assembly}}==

[[File:DragX86.gif|right]]

Translation of XPL0. Assemble with tasm, tlink /t

.code

.486

pop cx

ret

 

=={{header|Xfractint}}==

The <code>xfractint</code> program includes two dragon curves in its lsystem/fractint.l. Here is another version. Xfractint has only a single "F" drawing symbol, so empty symbols X and Y are used for even and odd positions to control the expansion. Each X and each Y is always followed by a single F each.

 

Angle 4

Axiom XF

X=XF+Y

Y=XF-Y

 

Put this in a file <code>dragon3.l</code> and run as follows. <code>params=8</code> means an 8-order curve.

 

 

=={{header|XPL0}}==

[[File:DragonXPL0.gif|right]]

 

proc Dragon(D, P, Q); \Draw a colorful dragon curve

X:= ChIn(1); \wait for keystroke

SetVid(3); \restore normal text mode

 

=={{header|zkl}}==

Draw the curve in SVG to stdout.

{{trans|Raku}}

0'|<!DOCTYPE svg PUBLIC '-//W3C//DTD SVG 1.1//EN'|"\n"

0'|'http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd'>|"\n"

x=dx; y=dy;

}

{{out}}

<pre>

</pre>

http://home.comcast.net/~zenkinetic/Images/dragon.svg

 

{{omit from|AWK}}

 

[[Category:Geometry]]