Sierpinski arrowhead curve: Difference between revisions

{{trans|Nim}}

 

 

F sierpinski_arrowhead_next(points)

outfile.write(I L.index == 0 {‘M’} E ‘L’)

outfile.write(point.x‘,’point.y"\n")

 

{{out}}

=={{header|Ada}}==

{{libheader|APDF}}Even order curves are drawn pointing downwards.

with Ada.Numerics.Generic_Elementary_Functions;

with Ada.Text_IO;

Rule => Nonzero_Winding_Number);

Doc.Close;

 

=={{header|ALGOL W}}==

Produces an Ascii Art Sierpinski Arrowhead Curve using the algorithm from the Wikipedia page.<br>

Note that the Wikipedia algotrithm draws even order curves with the base at the top.

integer CANVAS_WIDTH;

CANVAS_WIDTH := 200;

end for_order

end

{{out}}

<pre>

{{trans|Go}}

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

theta := 0

 

Gdip_Shutdown(pToken)

ExitApp

 

=={{header|C}}==

This code is based on the Phix and Go solutions, but produces a file in SVG format.

#include <math.h>

#include <stdio.h>

fclose(out);

return EXIT_SUCCESS;

 

{{out}}

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

The output of this program is an SVG file.

#include <iostream>

#include <vector>

write_sierpinski_arrowhead(out, 600, 8);

return EXIT_SUCCESS;

 

{{out}}

=={{header|Factor}}==

{{works with|Factor|0.99 2020-08-14}}

 

: arrowhead ( L-system -- L-system )

} >>rules ;

 

 

 

 

===ASCII===

 

: draw-line ( direction -- )

;

 

 

{{out}}

 

===SVG file===

 

: draw-line ( direction -- ) \ line-length=10 ; sin(60)=0.87 ; cos(60)=0.5

;

 

 

 

{{trans|Phix}}

A partial translation anyway which produces a static image of a SAC of order 6, magenta on black, which can be viewed with a utility such as EOG.

 

import (

dc.Stroke()

dc.SavePNG("sierpinski_arrowhead_curve.png")

 

=={{header|jq}}==

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

options used.

 

# Compute the curve using a Lindenmayer system of rules

sierpinski_curve(8)

| svg

 

=={{header|Julia}}==

scurve = LSystem(Dict("F" => "G+F+Gt", "G"=>"F-G-F"), "G")

showpreview = true

)

 

=={{header|Lambdatalk}}==

{def sierp

{def sierp.r

 

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

 

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

DoStep[Line[{x_, y_}]] := Module[{diff, perp, pts},

diff = y - x;

lns = {Line[{{0.0, 0.0}, {1.0, 0.0}}]};

lns = Nest[Catenate[DoStep /@ #] &, lns, 5];

 

=={{header|Nim}}==

{{trans|C++}}

Output is an SVG file.

 

const Sqrt3_2 = sqrt(3.0) / 2.0

let outfile = open("sierpinski_arrowhead.svg", fmWrite)

outfile.writeSierpinskiArrowhead(600, 8)

 

{{out}}

 

=={{header|Perl}}==

use warnings;

use SVG;

open my $fh, '>', 'sierpinski-arrowhead-curve.svg';

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

See: [https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/sierpinski-arrowhead-curve.svg sierpinski-arrowhead-curve.svg] (offsite SVG image)

 

{{libheader|Phix/pGUI}}

You can run this online [http://phix.x10.mx/p2js/Sierpinski_arrowhead_curve.htm here], and experiment with [shift] +/- as noted below.

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

-- demo\rosetta\Sierpinski_arrowhead_curve.exw

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

 

=={{header|Processing}}==

 

void setup() {

s.y += sin(radians(s.z)) * l);

return s;

 

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

 

t = { 'x': 20, 'y': 30, 'a': 60 }

 

return s

 

'''The sketch can be run online''' :<BR> [https://Trinket.io/processing/de6eddb155 here.]

 

=={{header|Python}}==

import matplotlib.pyplot as plt

import math

 

draw_lsystem(s_axiom, s_rules, s_angle, 7)

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

{{Trans|C}}

write_sierpinski_arrowhead('sierpinski_arrowhead.svg', 600, 8).

 

curve(Stream, Order1, Length2, Cursor3, Cursor4, Angle),

turn(Cursor4, Angle, Cursor5),

 

{{out}}

Using an L-system.

 

[ stack ] is switch.arg ( --> [ )

[ char L case [ -1 6 turn ]

char R case [ 1 6 turn ]

 

{{output}}

{{works with|Rakudo|2020.02}}

 

 

role Lindenmayer {

:polyline[ :points(@points.join: ','), :fill<black>, :style<stroke:#FF4EA9> ],

],

See: [https://github.com/thundergnat/rc/blob/master/img/sierpinski-arrowhead-curve-perl6.svg Sierpinski-arrowhead-curve-perl6.svg] (offsite SVG image)

 

=={{header|REXX}}==

{{trans|Algol W}}

parse arg order . /*obtain optional argument from the CL.*/

if order=='' | order=="," then order= 5 /*Not specified? Then use the default.*/

end /*select*/ /*curve character is based on direction*/

Lx= min(Lx,x); Hx= max(Hx,x); Ly= min(Ly,y); Hy= max(Hy,y) /*min&max of x,y*/

{{out|output|text=&nbsp; when using the default input value of: &nbsp; &nbsp; <tt> 5 </tt>}}

<b><pre>

{{libheader|JRubyArt}}

For grammar see Hilbert Curve

load_libraries :grammar

attr_reader :points

end

 

 

=={{header|Rust}}==

Output is a file in SVG format. Another variation on the same theme as the C, Go and Phix solutions.

// svg = "0.8.0"

 

fn main() {

write_sierpinski_arrowhead("sierpinski_arrowhead.svg", 600, 8).unwrap();

 

{{out}}

=={{header|Sidef}}==

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

x => 'yF+xF+y',

y => 'xF-yF-x',

)

 

Output image: [https://github.com/trizen/rc/blob/master/img/sierpi%C5%84ski_arrowhead-sidef.png Sierpiński arrowhead]

 

{{trans|Go}}

{{libheader|DOME}}

import "dome" for Window

 

}

}

 

=={{header|XPL0}}==

real Dir;

 

Curve(Order, Length, -Sixty);

];

 

{{out}}

Uses Image Magick and

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

sierpinskiArrowheadCurve(order) : turtle(_,order);

 

}

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

{{out}}

Offsite image at [http://www.zenkinetic.com/Images/RosettaCode/sierpinskiArrowheadCurve.zkl.jpg Sierpinski arrowhead curve order 7]