Koch curve: Difference between revisions

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

DEFINE MAXSIZE="20"

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

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

=={{header|Ada}}==

{{libheader|APDF}}

with Ada.Numerics.Generic_Elementary_Functions;

with Ada.Text_IO;

Rule => Even_Odd);

Doc.Close;

=={{header|BASIC256}}==

RtoD = 180 / Pi

DtoR = Pi / 180

imgsave "Koch_curve.jpg", "jpg"

=={{header|Amazing Hopper}}==

or

./src/kock_curve.com > kockcurve.svg

#!/usr/bin/hopper

{output}

back

{{trans|Go}}

Requires [https://www.autohotkey.com/boards/viewtopic.php?t=6517 Gdip Library]

KochX := 0, KochY := 0

Koch(0, 0, A_ScreenWidth, A_ScreenHeight, 4, Arr:=[])

Gdip_Shutdown(pToken)

ExitApp

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

The output of this program is an SVG file depicting a Koch snowflake.

#include <fstream>

#include <iostream>

koch_curve_svg(out, 600, 5);

return EXIT_SUCCESS;

{{out}}

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

{{works with|4tH v3.64}}

include lib/math.4th

include lib/enter.4th

450 500 115 300 r> koch

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

)

)

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

[[j:File:Koch-snowflake.png|example]]

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

'use strict';

// MAIN ---

return main();

=={{header|jq}}==

depending on the location of the included file, and the command-line

options used.

def rules:

koch_curve(5)

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

=={{header|Lambdatalk}}==

{def koch

{lambda {:d :n}

The output is a "square of Koch" which can be seen in

http://lambdaway.free.fr/lambdawalks/?view=koch

=={{header|Logo}}==

Make "startup [zzz]

=={{header|Lua}}==

Using the Bitmap class [[Bitmap#Lua|here]], with an ASCII pixel representation, then extending with <code>line()</code> as [[Bitmap/Bresenham%27s_line_algorithm#Lua|here]], then extending further..

function Bitmap:render()

bitmap:render()

print()

{{out}}

<pre style="font-size:50%">...........

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

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

=={{header|Nim}}==

{{works with|nim|1.4.2}}

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

{{libheader|Phix/online}}

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

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

-- demo\rosetta\Koch_curve.exw

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

=={{header|Processing}}==

void setup() {

kcurve(0, s);

popMatrix();

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

def setup():

rotate(radians(-120))

kcurve(0, s)

=={{header|Prolog}}==

{{works with|SWI Prolog}}

Produces an SVG file showing a Koch snowflake.

write_koch_snowflake('koch_snowflake.svg').

koch_curve(Stream, X2, Y2, X3, Y3, N1),

koch_curve(Stream, X3, Y3, X4, Y4, N1),

{{out}}

{{Trans|Haskell}}

from math import cos, pi, sin

# MAIN ---

if __name__ == '__main__':

===String rewriting===

import matplotlib.pyplot as plt

from matplotlib.colors import hsv_to_rgb as hsv

#curve('F', {'F': 'G-F-G', 'G': 'F+G+F'}, 60, 7)

#curve('A', {'A': '+BF-AFA-FB+', 'B': '-AF+BFB+FA-'}, 90, 6)

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

Using an L-system.

[ $ "" swap witheach

char L = iff

[ -1 6 turn ] done

{{output}}

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

Output is a file in SVG format depicting a Koch snowflake.

// svg = "0.8.0"

fn main() {

write_koch_snowflake("koch_snowflake.svg", 600, 5).unwrap();

{{out}}

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

A Turtle graphics library makes defining the curve easy.

option explicit

set x=nothing 'show image in browser

=={{header|Wren}}==

{{trans|Go}}

{{libheader|DOME}}

import "dome" for Window

import "math" for M

static draw(dt) {}

=={{header|XPL0}}==

proc DrawSide(Depth, Dist); \Draw side as 4 segments

Angle:= Angle + 120.;

];

{{out}}

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]