Hilbert curve: Difference between revisions

;Task

 

 

=={{header|C}}==

{{trans|Kotlin}}

 

#define N 32

}

return 0;

{{output}}

<pre>Same as Kotlin entry.</pre>

 

=={{header|Go}}==

<br>

The following is based on the recursive algorithm and C code in [https://www.researchgate.net/profile/Christoph_Schierz2/publication/228982573_A_recursive_algorithm_for_the_generation_of_space-filling_curves/links/0912f505c2f419782c000000/A-recursive-algorithm-for-the-generation-of-space-filling-curves.pdf this paper]. The image produced is similar to the one linked to in the zkl example.

 

import "github.com/fogleman/gg"

dc.Stroke()

dc.SavePNG("hilbert.png")

 

=={{header|IS-BASIC}}==

110 OPTION ANGLE DEGREES

120 GRAPHICS HIRES 2

250 CALL HILBERT(S,N-1,-P)

260 PLOT LEFT 90*P;

 

=={{header|Java}}==

 

import java.util.ArrayList;

return;

}

{{out}}

<pre>Hilbert curve, order=1

 

An implementation of GO. Prints an SVG string that can be read in a browser.

if (lg === 1) {

const px = (width - x) * spacing;

};

 

 

===Functional===

{{Trans|Python}}

 

 

A list of points is derived by serialization of that tree.

Like the version above, generates an SVG string for display in a browser.

 

 

 

};

 

[-1, 1],

[-1, -1],

[1, 1]

],

[1, -1],

[-1, -1],

[1, 1]

],

[1, -1],

[1, 1],

[-1, -1]

],

[-1, 1],

[1, 1],

[-1, -1]

]

 

 

 

 

 

);

 

 

 

 

// iterate :: (a -> a) -> a -> Gen [a]

 

 

// length :: [a] -> Int

const length = xs =>

 

 

// take :: Int -> [a] -> [a]

// take :: Int -> String -> String

 

 

// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]

 

// MAIN ---

return main();

 

=={{header|Julia}}==

Color graphics version using the Gtk package.

 

Base.isless(p1::Vec2, p2::Vec2) = (p1.x == p2.x ? p1.y < p2.y : p1.x < p2.x)

signal_connect(endit, win, :destroy)

wait(cond)

 

=={{header|Kotlin}}==

 

The coordinates of the points are generated using a translation of the C code in the Wikipedia article and then scaled by a factor of 3 (n = 32).

 

data class Point(var x: Int, var y: Int)

println()

}

 

{{output}}

| | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

.__. .__. .__. .__. .__. .__. .__. .__. .__. .__. .__. .__. .__. .__. .__. .__. </pre>

 

=={{header|Lua}}==

* <num> repeat the following draw command <num> times

* <any> move on canvas without drawing

local bit=bit32 or bit -- Lua 5.2/5.3 compatibilty

-- Hilbert curve implemented by Lindenmayer system

local str=arg[2] or "A"

draw(str:hilbert(n))

{{output}} luajit hilbert.lua 4 1M9FAF-4F2+2F-2F-2F++4F-F-4F+2F+2F+2F++3F+2F+3F--4FA10F-16F-58F-16F-

<pre>

 

</pre>

 

=={{header|Perl}}==

use List::Util qw(max min);

 

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

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

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

 

 

 

}

 

 

}

 

}

}

 

 

 

}

 

 

 

 

 

 

=={{header|Python}}==

===Functional===

Composition of pure functions, with type comments for the reader rather than the compiler.

 

(To view the Hilbert curve, save the output SVG text in a file with an appropriate extension (e.g. '''.svg'''), and open it with a browser).

 

 

 

 

# hilbertCurve :: Int -> SVG String

def hilbertCurve(n):

w = 1024

return svgFromPoints(w)(

# hilbertTree :: Int -> Tree Char

def hilbertTree(n):

 

# go :: Tree Char -> Tree Char

# hilbertPoints :: Int -> Tree Char -> [(Int, Int)]

def hilbertPoints(w):

 

# points :: Int -> ((Int, Int), Tree Char) -> [(Int, Int)]

def points(d):

def go(xy, tree):

r = d // 2

xy[0] + (r * v[0]),

xy[1] + (r * v[1])

return chain.from_iterable(

) if tree['nest'] else centres

 

d = w // 2

'''Width of square canvas -> Point list -> SVG string'''

 

return '\n'.join(

['<svg xmlns="http://www.w3.org/2000/svg"',

]

)

 

 

 

 

# Node :: a -> [Tree a] -> Tree a

def Node(v):

 

 

# flip :: (a -> b -> c) -> b -> a -> c

def flip(f):

return lambda a: lambda b: f(b)(a)

 

# iterate :: (a -> a) -> a -> Gen [a]

def iterate(f):

def go(x):

v = x

while True:

v = f(v)

 

 

# TEST ---------------------------------------------------

if __name__ == '__main__':

 

=={{header|Ring}}==

# Project : Hilbert curve

 

x1 = x2

y1 = y2

Output image:

[https://www.dropbox.com/s/anwtxtrnqhubh4a/HilbertCurve.jpg?dl=0 Hilbert curve]

 

=={{header|Scala}}==

===[https://www.scala-js.org/ Scala.js]===

object ScalaFiddle {

// $FiddleStart

}

// $FiddleEnd

{{Out}}Best seen running in your browser by [https://scalafiddle.io/sf/x7t2zdK/0 ScalaFiddle (ES aka JavaScript, non JVM)].

 

=={{header|Sidef}}==

 

class Turtle(

primitive => 'line',

points => join(' ',

),

stroke => color,

turn = 0,

) {

 

 

':' => { turtle.mirror },

'[' => { stack.push(turtle.state) },

']' => { turtle.setstate(stack.pop) },

)

 

repetitions.times {

table{c}.run

}

turtle.forward(len)

}

turtle.save_as(filename)

}

 

a => '-bF+aFa+Fb-',

b => '+aF-bFb-Fa+',

)

 

 

=={{header|Vala}}==

{{libheader|Gtk+-3.0}}

 

int x;

int y;

Gtk.main();

return 0;

 

=={{header|zkl}}==

Uses Image Magick and

the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl

 

fcn hilbert(n){ // Lindenmayer system --> Data of As & Bs

}

img.writeJPGFile("hilbert.zkl.jpg");

Image at [http://www.zenkinetic.com/Images/RosettaCode/hilbert.zkl.jpg hilbert curve]