Sierpinski pentagon: Difference between revisions
→{{header|jq}}
(15 intermediate revisions by 9 users not shown) | |||
Line 7:
* [http://ecademy.agnesscott.edu/~lriddle/ifs/pentagon/pentagon.htm Sierpinski pentagon]
<br><br>
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC Main()
INT ARRAY xs=[249 200 96 80 175]
BYTE ARRAY ys=[82 176 159 55 7]
INT x,y
BYTE i,CH=$02FC,COLOR1=$02C5,COLOR2=$02C6
Graphics(8+16)
Color=1
COLOR1=$0C
COLOR2=$02
x=160+Rand(30)
y=96+Rand(30)
DO
i=Rand(5)
x=x+(xs(i)-x)*62/100
y=y+(ys(i)-y)*62/100
Plot(x,y)
UNTIL CH#$FF
OD
CH=$FF
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sierpinski_pentagon.png Screenshot from Atari 8-bit computer]
=={{header|AutoHotkey}}==
{{trans|Go}}
Requires [https://www.autohotkey.com/boards/viewtopic.php?t=6517 Gdip Library]
<
hw := W / 2
margin := 20
Line 102 ⟶ 128:
Gdip_Shutdown(pToken)
ExitApp
Return</
=={{header|C}}==
The Sierpinski fractals can be generated via the [http://mathworld.wolfram.com/ChaosGame.html Chaos Game]. This implementation thus generalizes the [[Chaos game]] C implementation on Rosettacode. As the number of sides increases, the number of iterations must increase dramatically for a well pronounced fractal ( 30000 for a pentagon). This is in keeping with the requirements that the implementation should work for polygons with sides 1 to 4 as well. Requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library.
<syntaxhighlight lang="c">
#include<graphics.h>
#include<stdlib.h>
Line 168 ⟶ 194:
return 0;
}
</syntaxhighlight>
=={{header|C++}}==
{{trans|D}}
<
#include <iostream>
Line 326 ⟶ 352:
std::cout << "</svg>";
}</
=={{header|D}}==
Line 334 ⟶ 360:
This runs very quickly compared to the Python version.
<
import std.stdio;
Line 488 ⟶ 514:
tracing = false;
}
}</
=={{header|EasyLang}}==
{{Trans|Processing}}
[https://easylang.dev/show/#cod=pZHNrsIgEIX3PMVJ3GgbsSVpdNOHacroJemFBog/by+DqHXh3Vx2w/mYc2ZwXpNHj06sIMaJBi8mY+lidPxBI5UI4zBRAlrssFaoMbqAvUIFteE3s3cjZrJxODmLK24IRhM0zamBhBQAzLHUPRqu0/l1Z2K6lEfnMdhTdmoQIs3sER3U4VCQdK6o++z/QKts9ZZvLAdjv8g818IyJ6MpPIkcu0oNeOByp02I6B9SXYjFAv4Xnpv/Ef5T/rbhLdrlPFJI8UJVh7ZD18DlT2b0Dg== Run it]
<syntaxhighlight lang="easylang">
order = 5
#
clear
linewidth 0.2
scale = 1 / (2 + cos 72 * 2)
#
proc pentagon x y side depth . .
if depth = 0
move x y
for angle = 0 step 72 to 288
x += cos angle * side
y += sin angle * side
line x y
.
else
side *= scale
dist = side + side * cos 72 * 2
for angle = 0 step 72 to 288
x += cos angle * dist
y += sin angle * dist
pentagon x y side depth - 1
.
.
.
pentagon 25 15 50 order - 1
</syntaxhighlight>
=={{header|FreeBASIC}}==
{{trans|XPL0}}
<syntaxhighlight lang="vb">#define pi 4 * Atn(1)
#define yellow Rgb(255,255,0)
Dim As Byte orden = 5 'can also set this to 1, 2, 3, or 4
Dim Shared As Single deg72
deg72 = 72 * pi / 180 '72 degrees in radians
Dim As Integer HW = 640/2
Dim As Byte tam = 20
Dim As Integer radio = HW - 2*tam
Dim Shared As Single ScaleFactor
Sub DrawPentagon(posX As Integer, posY As Integer, largo As Single, fondo As Byte)
Dim As Byte i
Dim As Single angulo = 3 * deg72, dist
If fondo = 0 Then
Pset (posX, posY)
For i = 0 To 4
posX += Fix(largo * Cos(angulo))
posY -= Fix(largo * Sin(angulo))
Line - (posX, posY), yellow
angulo += Deg72
Next
Else
largo *= ScaleFactor
dist = largo * (1 + Cos(Deg72) * 2)
For i = 0 To 4
posX += Fix(dist * Cos(angulo))
posY -= Fix(dist * Sin(angulo))
DrawPentagon(posX, posY, largo, fondo-1)
angulo += deg72
Next
End If
End Sub
Screenres 640, 640, 32
ScaleFactor = 1 / (2 + Cos(Deg72) * 2)
Dim As Single largo
largo = radio * Sin(Pi/5) * 2
DrawPentagon (HW, 3*tam, largo, orden-1)
Windowtitle "Hit any key to end program"
Sleep</syntaxhighlight>
=={{header|Go}}==
Line 496 ⟶ 600:
As output is to an external .png file, only a pentaflake of order 5 is drawn though pentaflakes of lower orders can still be drawn by setting the 'order' variable to the appropriate figure.
<
import (
Line 556 ⟶ 660:
drawPentagon(hw, 3*margin, side, order-1)
dc.SavePNG("sierpinski_pentagon.png")
}</
{{out}}
Line 566 ⟶ 670:
For universal solution see [[Fractal tree#Haskell]]
<
pentaflake :: Int -> Picture
Line 578 ⟶ 682:
main = display dc white (Color blue $ Scale 300 300 $ pentaflake 5)
where dc = InWindow "Pentaflake" (400, 400) (0, 0)</
'''Explanation''': Since <tt>Picture</tt> forms a monoid with image overlaying as multiplication, so do functions having type <tt>Picture -> Picture</tt>:
Line 588 ⟶ 692:
If one wants to get all intermediate pentaflakes <code>transformation</code> shoud be changed as follows:
<
See also the implementation using [http://projects.haskell.org/diagrams/gallery/Pentaflake.html Diagrams]
Line 595 ⟶ 699:
[[File:sierpinski_pentagon.png|300px|thumb|right]]
{{works with|Java|8}}
<
import java.awt.event.ActionEvent;
import java.awt.geom.Path2D;
Line 703 ⟶ 807:
return Color.getHSBColor((float) hue, 1, 1);
}
}</
=={{header|JavaScript}}==
Line 713 ⟶ 817:
<
<html>
<head>
Line 802 ⟶ 906:
</body>
</html>
</
{{Output}}
Line 809 ⟶ 913:
Clicking Pentaflake you can see orders 1-6 of it in different colors.
</pre>
=={{header|jq}}==
'''Adapted from [[#Julia|Julia]]'''
'''Works with jq, the C implementation of jq'''
'''Works with gojq, the Go implementation of jq'''
The following program produces an SVG image.
To produce the .svg file, use a command such as:
<pre>
jq -nr -f sierpinski-pentagon.jq > sierpinski-pentagon.svg
</pre>
where "sierpinski-pentagon.jq" is a file containing the program shown
below.
The .svg file can conveniently be viewed as a graphic using a browser,
or an editor such as Emacs or Aquamacs.
<syntaxhighlight lang="jq">
### Generic functions
def addComplex(stream): reduce stream as [$x,$y] ([0,0]; .[0] += $x | .[1] += $y);
def lpad($len; $x): tostring | ($len - length) as $l | ($x * $l) + .;
# Input: an array
def multiply($x): map(. * $x);
# Round to approx $ndec places
def round($ndec): pow(10;$ndec) as $p | . * $p | round / $p;
def power($a; $b): reduce range(0;$b) as $i (1; . * $a);
def tau: 8 * atan2(1; 1);
def tobase($b):
def digit: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[.:.+1];
def mod: . % $b;
def div: ((. - mod) / $b);
def digits: recurse( select(. > 0) | div) | mod ;
# For jq it would be wise to protect against `infinite` as input, but using `isinfinite` confuses gojq
select( (tostring|test("^[0-9]+$")) and 2 <= $b and $b <= 36)
| if . == 0 then "0"
else [digits | digit] | reverse[1:] | add
end;
### Sierpinski Pentagons
def svgHead($width):
"<svg height=\"\($width)\" width=\"\($width)\" style=\"fill:blue\"",
"version=\"1.1\" xmlns=\"http://www.w3.org/2000/svg\">";
def svgEnd: "</svg>";
# SVG height and width will be 2 * dim
def pentagon($dim):
def sides: 5;
def order: 5;
def scale: (3 - (order | sqrt)) / 2;
def cis: [cos, sin];
def orders:
[range(0; order) | ((1 - scale) * $dim) * power(scale ; .) ];
def vertices:
tau as $tau | [range(0; sides) | ( . * $tau / sides | cis)];
svgHead(2*$dim),
(orders as $orders
| vertices as $vertices
| range(1; 1 + power(sides; order)) as $i
| [ ($i|tobase(sides) | lpad(order; "0") | split("")[]) | $vertices[tonumber]] as $varr
| addComplex(range(0; $orders|length) as $i | $varr[$i] | multiply($orders[$i])) as $vector
| ($vertices | map( addComplex($vector, multiply($orders[-1] * (1-scale))))) as $vprod
| ($vprod | map( map(round(3)) | "\(.[0]) \(.[1])") | join(" ")) as $points
| "<polygon points=\"\($points)\" transform=\"translate(\($dim),\($dim)) rotate(-18)\" />"),
svgEnd ;
pentagon(250)
</syntaxhighlight>
{{output}}
See [[#Julia|Julia]].
=={{header|Julia}}==
{{trans|Perl}}
<
const sides = 5
Line 837 ⟶ 1,023:
print(fh, "</svg>")
close(fh)</
=={{header|Kotlin}}==
{{trans|Java}}
<
import java.awt.*
Line 944 ⟶ 1,130:
f.isVisible = true
}
}</
=={{header|Lua}}==
An ASCII-interpretation of the task. Uses the Bitmap class and text renderer from [[Bitmap/Bresenham's_line_algorithm#Lua|here]].
<
local w, h, vertices = self.width, self.height, {}
for i = 1, n do
Line 967 ⟶ 1,153:
local bitmap = Bitmap(128, 128)
bitmap:chaosgame(5, 1/((1+math.sqrt(5))/2), 1e6)
bitmap:render({[0x000000]='..', [0xFFFFFFFF]='██'})</
{{out}}
Shown at 25% scale:
Line 1,100 ⟶ 1,286:
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
pentaFlake[n_] := GeometricTransformation[pentaFlake[n - 1], TranslationTransform /@ CirclePoints[{GoldenRatio^(2 n - 1), Pi/10}, 5]]
Graphics@pentaFlake[4]</
{{out}}
https://i.imgur.com/rvXvQc0.png
=={{header|MATLAB}}==
<
for k = 1 : 4
x = x(:) + x0 * (1 + sqrt(5)) * (3 + sqrt(5)) ^(k - 1) / 2 ^ k;
end
patch('Faces', reshape(1 : 5 * 5 ^ k, 5, '')', 'Vertices', [real(x(:)) imag(x(:))])
axis image off</
{{out}}
http://i.imgur.com/8ht6HqG.png
Line 1,119 ⟶ 1,305:
{{trans|Go}}
{{libheader|imageman}}
<
import imageman
Line 1,165 ⟶ 1,351:
let side = radius * sin(PI / 5) * 2
image.drawPentagon(hw, 3 * margin, side, order - 1)
image.savePNG("Sierpinski_pentagon.png", compression = 9)</
{{out}}
Line 1,173 ⟶ 1,359:
{{libheader|ntheory}}
{{trans|Raku}}
<
use Math::Complex;
Line 1,207 ⟶ 1,393:
print $fh '</svg>';
close $fh;</
[https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/sierpinski_pentagon.svg Sierpinski pentagon] (offsite image)
Line 1,213 ⟶ 1,399:
{{libheader|Phix/pGUI}}
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/SierpinskyPentagon.htm here]. Use +/- to change the level, 0..5.
<!--<
<span style="color: #000080;font-style:italic;">--
-- demo\rosetta\SierpinskyPentagon.exw
Line 1,310 ⟶ 1,496:
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</
=={{header|Processing}}==
<
float s_angle, scale, margin = 25, total = 4;
float p_size = 700;
Line 1,353 ⟶ 1,539:
}
}
}</
=={{header|Prolog}}==
{{works with|SWI Prolog}}
This code is based on the Java solution. The output is an SVG file.
<
write_sierpinski_pentagon('sierpinski_pentagon.svg', 600, 5).
Line 1,407 ⟶ 1,593:
Angle1 is Angle + 2 * pi/5,
sierpinski_pentagon(Stream, X1, Y1, Scale_factor, Side, N),
sierpinski_pentagons(Stream, X1, Y1, Scale_factor, Side, Angle1, N, I1).</
{{out}}
[[Media:Sierpinski_pentagon_prolog.svg]]
=={{header|Python}}==
Draws the result on a canvas. Runs pretty slowly.
<
import math
speed(0) # 0 is the fastest speed. Otherwise, 1 (slow) to 10 (fast)
Line 1,489 ⟶ 1,675:
sierpinski(i, t, size)
main()</
See [https://trinket.io/python/5137ae2b92 online implementation]. See [http://i.imgur.com/96D0c7i.png completed output].
=={{header|Quackery}}==
<
[ [ 1 1
Line 1,523 ⟶ 1,709:
turtle
0 frames
3 10 turn
300 1 fly
2 5 turn
' [ 79 126 229 ] colour
400 1 5 pentaflake
1 frames</syntaxhighlight>
{{output}}
[[File:Quackery Sierpinski pentaflake.png]]
=={{header|Racket}}==
{{trans|Java}}
<
(require racket/draw pict racket/math racket/class)
Line 1,592 ⟶ 1,780:
(dc-draw-pentagon 3 120 120)
(dc-draw-pentagon 4 120 120)
(dc-draw-pentagon 5 640 640)</
=={{header|Raku}}==
(formerly Perl 6)
{{works with|rakudo|2018-10}}
[[File:Perl6 pentaflake.svg|300x300px|thumb|right|5th order pentaflake]]
<syntaxhighlight lang="raku" line>constant $sides = 5;
constant order = 5;
constant $dim = 250;
Line 1,617 ⟶ 1,806:
$fh.say: '</svg>';
$fh.close;</
=={{header|Ruby}}==
Line 1,625 ⟶ 1,812:
{{libheader|JRubyArt}}
JRubyArt is a port of processing to ruby
<
THETA = Math::PI * 2 / 5
SCALE_FACTOR = (3 - Math.sqrt(5)) / 2
Line 1,705 ⟶ 1,892:
end
</syntaxhighlight>
=={{header|Rust}}==
This code is based on the Java solution. The output is a file in SVG format.
<
// svg = "0.8.0"
Line 1,781 ⟶ 1,968:
fn main() {
write_sierpinski_pentagon("sierpinski_pentagon.svg", 600, 5).unwrap();
}</
{{out}}
[[Media:Sierpinski_pentagon_rust.svg]]
=={{header|Scala}}==
===Java Swing Interoperability===
<
import java.awt.event.ActionEvent
import java.awt.geom.Path2D
Line 1,894 ⟶ 2,081:
})
}</
=={{header|Sidef}}==
{{trans|Raku}}
Generates a SVG image to STDOUT. Redirect to a file to capture and display it.
<
define sides = 5
define dim = 500
Line 1,922 ⟶ 2,109:
}
say '</svg>'</
=={{header|VBA}}==
Using Excel
<
Dim Circumradius As Double, Inradius As Double
Dim Height As Double, Diagonal As Double, HeightDiagonal As Double
Line 1,972 ⟶ 2,159:
Public Sub main()
sierpinski Order_:=5, Side:=200
End Sub</
=={{header|Wren}}==
Line 1,978 ⟶ 2,165:
{{libheader|DOME}}
Black backgound and slightly different palette to Go. Also pentagons are unfilled.
<
import "dome" for Window
import "math" for Math
Line 2,039 ⟶ 2,226:
}
var Game = SierpinskiPentagon.new(640, 640)</
{{out}}
[[File:Wren-Sierpinski_pentagon.png|400px]]
=={{header|XPL0}}==
{{trans|Wren}}
[[File:SierXPL0.gif|200px|thumb|right]]
<syntaxhighlight lang "XPL0">def Order = 5; \can also set this to 1, 2, 3, or 4
def Width=640, Height=640;
def Pi = 3.14159265358979323846;
def Deg72 = 72.*Pi/180.; \72 degrees in radians
def HW = Width/2;
def Margin = 20;
def Radius = HW - 2*Margin;
real ScaleFactor;
int ColorIndex;
proc DrawPentagon(X, Y, Side, Depth);
real X, Y, Side; int Depth;
real Angle, Dist;
int I;
[Angle:= 3. * Deg72;
if Depth = 0 then
[Move(fix(X), fix(Y));
for I:= 0 to 4 do
[X:= X + Cos(Angle) * Side;
Y:= Y - Sin(Angle) * Side;
Line(fix(X), fix(Y), ColorIndex+9);
Angle:= Angle + Deg72;
];
ColorIndex:= ColorIndex+1;
if ColorIndex >= 5 then ColorIndex:= 0;
]
else [Side:= Side * ScaleFactor;
Dist:= Side * (1. + Cos(Deg72) * 2.);
for I:= 0 to 4 do
[X:= X + Cos(Angle) * Dist;
Y:= Y - Sin(Angle) * Dist;
DrawPentagon(X, Y, Side, Depth-1);
Angle:= Angle + Deg72;
];
];
];
real Side;
[SetFB(Width, Height, 8);
ScaleFactor:= 1. / (2. + Cos(Deg72) * 2.);
ColorIndex:= 0;
Side:= float(Radius) * Sin(Pi/5.) * 2.;
DrawPentagon(float(HW), float(3*Margin), Side, Order-1);
]</syntaxhighlight>
=={{header|zkl}}==
{{trans|Raku}}
<
const tau=(0.0).pi*2; // 2*pi*r
orders:=order.pump(List,fcn(n){ (1.0 - scaleFactor)*dim*scaleFactor.pow(n) });
Line 2,072 ⟶ 2,310:
0'|<polygon points="%s"/>|.fmt(
vertices.pump(String,fcn(v){ "%.3f %.3f ".fmt(v.xplode()) }) )
}</
{{out}}
See [http://www.zenkinetic.com/Images/RosettaCode/sierpinskiPentagon.zkl.svg this image].
|