Koch curve: Difference between revisions

 

Draw a Koch curve. See details: [https://en.wikipedia.org/wiki/Koch_snowflake Koch curve]

 

=={{header|BASIC256}}==

RtoD = 180 / Pi

DtoR = Pi / 180

 

imgsave "Koch_curve.jpg", "jpg"

 

=={{header|C}}==

Interactive program which takes the width, height (of the Graphics window) and recursion level of the Koch curve as inputs, prints out usage on incorrect invocation. Requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library.

#include<graphics.h>

#include<stdlib.h>

return 0;

}

 

=={{header|Factor}}==

The approach taken is to generate a [[Thue-Morse]] sequence. Using turtle graphics, move forward for each 0 encountered and rotate 60 degrees for each 1 encountered. Remarkably, this produces a Koch curve.

literals math math.constants math.functions sequences ;

IN: rosetta-code.koch-curve

] 2with each image-window ;

 

{{out}}

[https://i.imgur.com/MVS8QiS.png]

 

=={{header|FreeBASIC}}==

Const Pi = 4 * Atn(1)

Const RtoD = 180 / Pi

Sleep

End

 

=={{header|Go}}==

{{libheader|Go Graphics}}

{{trans|Ring}}

 

import (

dc.Stroke()

dc.SavePNG("koch.png")

 

{{out}}

Generates SVG for a Koch snowflake. To view, save to a text file with an .svg extension, and open in a browser.

 

import Text.Printf (printf)

 

kochSnowflake n a b =

 

 

equilateralApex = rotatedPoint (pi / 3)

 

 

rotatedVector :: Float -> (Float, Float) -> (Float, Float)

rotatedVector angle (x, y) =

 

 

main :: IO ()

 

svgFromPoints :: Int -> [(Float, Float)] -> String

svgFromPoints w xys =

 

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

110 OPTION ANGLE DEGREES

120 SET 22,1:SET 23,0:SET 24,42:SET 25,26

290 PLOT LEFT A;FORWARD D;

300 END IF

 

=={{header|J}}==

 

koch=: [: ,/ 2 seg/\ ]

 

require'plot'

tri=: ^ j. 4r3 * (_2 o. 0) * i._4

 

The idea is to continually expand the segments between a list of points in the complex plane. Given consecutive x and y in the list, v = (y-x)/3 is a vector representing 1/3 of the trip from x to y. An iteration building the Koch curve starts at x, advances by v, advances by v rotated by 60 degrees, advances by v rotated -60 degrees, and finally advances by another v, reaching y. x seg y produces this expansion. koch takes a list of points and expands segments between consecutive ones, producing another list. koch ^: 5 does this 5 times, and plot shows the snowflake in a window.

 

=={{header|JavaScript}}==

 

{{Trans|Haskell}}{{Trans|Python}}

'use strict';

 

// MAIN ---

return main();

 

=={{header|Julia}}==

Multiple snowflake plots. Copied from https://www.juliabloggers.com/koch-snowflakes-for-the-holidays/.

 

function pointskoch(points, maxk, α = sqrt(3)/2)

#large_koch()

koch_julia()

 

=={{header|Kotlin}}==

{{trans|Ring}}

This incorporates code from other relevant tasks in order to provide a runnable example. The image produced is saved to disk where it can be viewed with a utility such as EOG.

 

import java.awt.Color

ImageIO.write(image, "jpg", kFile)

}

 

{{output}}

</pre>

 

GeometricTransformation[KochCurve[5], RotationTransform[-Pi/3, {1, 0}]],

 

=={{header|Nim}}==

{{libheader|nim-libgd}}

from math import sin, cos, PI

import libgd

 

main()

 

=={{header|Perl}}==

use List::Util qw(max min);

 

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

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

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

 

=={{header|Phix}}==

 

=={{header|Processing}}==

 

void setup() {

kcurve(0, s);

popMatrix();

 

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

 

def setup():

rotate(radians(-120))

kcurve(0, s)

 

=={{header|Python}}==

 

{{Trans|Haskell}}

 

from math import cos, pi, sin

'''

points = [a, equilateralApex(a, b), b]

 

 

# kochCurve :: Int -> (Float, Float) -> (Float, Float)

def kochCurve(n):

'''List of points on a Koch curve of order n,

starting at point ab, and ending at point xy.

'''

 

 

# equilateralApex :: (Float, Float) -> (Float, Float) -> (Float, Float)

def equilateralApex(p, q):

return rotatedPoint(pi / 3)(p, q)

 

'''

def go(xy, ab):

 

 

# rotatedVector :: Float -> (Float, Float) -> (Float, Float)

def rotatedVector(theta, xy):

return (

x * cos(theta) - y * sin(theta),

 

 

# main :: IO ()

def main():

print(

svgFromPoints(1024)(

 

 

 

# svgFromPoints :: Int -> [(Float, Float)] -> SVG String

def svgFromPoints(w):

xs = ' '.join(map(

lambda xy: str(round(xy[0], 2)) + ' ' + str(round(xy[1], 2)),

xys

))

 

 

 

 

 

 

 

 

=={{header|QBasic}}==

' degrees of freedom (a direction) is chosen at random (by throwing a six-sided die), and a line

' is drawn from the old point to the new point in the direction indicated by the pip on the die.

Y= Y + YP(N, R)

LINE -(X, Y) ' depending on the "die", draw the next part of the chaos curve.

 

=={{header|Racket}}==

 

(require metapict)

(koch a c n)))

 

 

=={{header|Raku}}==

{{works with|Rakudo|2018.03}}

Koch curve, actually a full Koch snowflake.

 

role Lindenmayer {

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

],

 

See: [https://github.com/thundergnat/rc/blob/master/img/koch1.svg Koch snowflake]

 

Variation using 90° angles:

 

role Lindenmayer {

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

],

See: [https://github.com/thundergnat/rc/blob/master/img/koch2.svg Koch curve variant with 90° angles]

 

=={{header|Ring}}==

# Project : Koch curve

 

paint.drawline(x4, y4, x2, y2)

ok

Output image:

 

{{libheader|JRubyArt}}

Using a Lindenmayer System to produce a KochSnowflake or simple Koch Fractal

attr_reader :koch

def settings

end

 

 

=={{header|Sidef}}==

Using the LSystem class defined at [https://rosettacode.org/wiki/Hilbert_curve#Sidef Hilbert curve].

F => 'F+F--F+F',

)

)

 

 

Output image: [https://github.com/trizen/rc/blob/master/img/koch-snowflake-sidef.png Koch snowflake]

 

=={{header|zkl}}==

Uses Image Magick and

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

var angle=(60.0).toRad();

const green=0x00FF00;

 

koch(100.0,100.0, 400.0,400.0, 4);

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

 

Using a Lindenmayer system and turtle graphics to draw a Koch snowflake:

 

//lsystem("F", Dictionary("F","F+F--F+F"), "+-", 3) // curve

: turtle(_);

}

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

Image at [http://www.zenkinetic.com/Images/RosettaCode/kochSnowFlake.zkl.jpg Koch snow flake]