Sunflower fractal: Difference between revisions
m
→{{header|Fōrmulæ}}
(Added solution for Action!) |
|||
(24 intermediate revisions by 14 users not shown) | |||
Line 9:
{{trans|Perl}}
<
phi = (1 + sqrt(5)) / 2
size = 600
Line 23:
r * cos(t) + size / 2, sqrt(i) / 13))
print(‘</svg>’)</
=={{header|Action!}}==
Line 29:
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<
INT ARRAY SinTab=[
Line 144:
DO UNTIL CH#$FF OD
CH=$FF
RETURN</
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sunflower_fractal.png Screenshot from Atari 8-bit computer]
=={{header|Applesoft BASIC}}==
<syntaxhighlight lang="gwbasic">HGR:A=PEEK(49234):C=(SQR(5)+1)/2:N=900:FORI=0TO1600:R=(I^C)/N:A=8*ATN(1)*C*I:X=R*SIN(A)+139:Y=R*COS(A)+96:F=7-4*((X-INT(X/2)*2)>=.75):X=(X>=0ANDX<280)*X:Y=(Y>=0ANDY<192)*Y:HCOLOR=F*(XANDY):HPLOTX,Y:NEXT</syntaxhighlight>
=={{header|C}}==
The colouring of the "fractal" is determined with every iteration to ensure that the resulting graphic looks similar to a real Sunflower, thus the parameter ''diskRatio'' determines the radius of the central disk as the maximum radius of the flower is known from the number of iterations. The scaling factor is currently hardcoded but can also be externalized. Requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library.
<syntaxhighlight lang="c">
/*Abhishek Ghosh, 14th September 2018*/
Line 190 ⟶ 193:
return 0;
}
</syntaxhighlight>
=={{header|C++}}==
{{trans|Perl}}
<
#include <fstream>
#include <iostream>
Line 234 ⟶ 237:
}
return EXIT_SUCCESS;
}</
{{out}}
[[Media:Sunflower cpp.svg]]
=={{header|FreeBASIC}}==
<
Const PI As Double = 4 * Atn(1)
Const ancho = 400
Line 266 ⟶ 269:
Sleep
End
</syntaxhighlight>
=={{header|Fōrmulæ}}==
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sunflower_model}}
'''Solution'''
The method consists in drawing points on a spriral, an archimedean spiral, where two contiguous points are separated (in angle) by the golden angle.
Because the points tend to agglomerate in the center, they are smaller there.
[[File:Fōrmulæ - Sunflower model 01.png]]
[[File:Fōrmulæ - Sunflower model 02.png]]
[[File:Fōrmulæ - Sunflower model 03.png]]
'''Improvement'''
Last result is not natural. Florets in a sunflower are all equal size.
H. Vogel proposed to use a Fermat spiral, in such a case, the florets are equally spaced, and we can use now circles with the same size:
[[File:Fōrmulæ - Sunflower model 04.png]]
[[File:Fōrmulæ - Sunflower model 05.png]]
[[File:Fōrmulæ - Sunflower model 06.png]]
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
window 1, @"Sunflower Fractal", ( 0, 0, 400, 400 )
WindowSetBackgroundColor( 1, fn ColorBlack )
void local fn SunflowerFractal
NSUinteger seeds = 4000
double c, i, angle, x, y, r
pen 2.0, fn ColorWithRGB( 0.997, 0.838, 0.038, 1.0 )
c = ( sqr(5) + 1 ) / 2
for i = 0 to seeds
r = (i ^ c) / seeds
angle = 2 * pi * c * i
x = r * sin(angle) + 200
y = r * cos(angle) + 200
oval ( x, y, i / seeds * 5, i / seeds * 5 )
next
end fn
fn SunflowerFractal
HandleEvents
</syntaxhighlight>
[[file:Sunflower_Fractal.png]]
=={{header|Go}}==
Line 273 ⟶ 331:
<br>
The image produced, when viewed with (for example) EOG, is similar to the Ring entry.
<
import (
Line 300 ⟶ 358:
dc.Stroke()
dc.SavePNG("sunflower_fractal.png")
}</
=={{header|javascript}}==
Line 322 ⟶ 380:
</html>
</pre>
<
TPI = Math.PI * 2, C = (Math.sqrt(10) + 1) / 2;
class Sunflower {
Line 378 ⟶ 436:
const sunflower = new Sunflower();
sunflower.start();
}</
=={{header|J}}==
This (currently draft) task really needs an adequate description. Still, it's straightforward to derive code from another implementation on this page.
This implementation assumes a recent J implementation (for example, J903):
<syntaxhighlight lang="j">require'format/printf'
sunfract=: {{ NB. y: number of "sunflower seeds"
phi=. 0.5*1+%:5
XY=. (y%10)+(2*(I^phi)%y) * +.^j.2*1p1*phi*I=.1+i.y
XY,.(%:I)%13
}}
sunfractsvg=: {{
fract=. sunfract x
C=.,'\n<circle cx="%.2f" cy="%.2f" r="%.1f" />' sprintf fract
({{)n
<svg xmlns="http://www.w3.org/2000/svg" width="%d" height="%d" style="stroke:gold">
<rect width="100%%" height="100%%" fill="black" />
%s
</svg>
}} sprintf (;/<.20+}:>./fract),<C) fwrite y}}
</syntaxhighlight>
Example use:
<syntaxhighlight lang="j">
3000 sunfractsvg '~/sunfract.html'
129147
</syntaxhighlight>
(The number displayed is the size of the generated file.)
=={{header|jq}}==
'''Adapted from [[#Perl|Perl]]'''
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''
<syntaxhighlight lang="jq"># SVG headers
def svg(size):
"<svg xmlns='http://www.w3.org/2000/svg' width='\(size)'",
"height='\(size)' style='stroke:gold'>",
"<rect width='100%' height='100%' fill='black'/>";
# emit the "<circle />" elements
def sunflower(size):
def rnd: 100*.|round/100;
(5 * size) as $seeds
| ((1|atan) * 4) as $pi
| ((1 + (5|sqrt)) / 2) as $phi
| range(1; 1 + $seeds) as $i
| {}
| .r = 2 * pow($i; $phi)/$seeds
| .theta = 2 * $pi * $phi * $i
| .x = .r * (.theta|sin) + size/2
| .y = .r * (.theta|cos) + size/2
| .radius = ($i|sqrt)/13
| "<circle cx='\(.x|rnd)' cy='\(.y|rnd)' r='\(.radius|rnd)' />" ;
def end_svg:
"</svg>";
svg(600),
sunflower(600),
end_svg</syntaxhighlight>
=={{header|Julia}}==
{{trans|R}}
Run from REPL.
<
function sunflowerplot()
Line 393 ⟶ 519:
for i in 2:length(r)
θ[i] = θ[i - 1] + 2π * ϕ
markersizes[i] = div(i, 500) +
end
x = r .* cos.(θ)
y = r .* sin.(θ)
ax = Axis(f[1, 1], backgroundcolor = :green)
scatter!(ax, x, y, color = :gold, markersize = markersizes, strokewidth = 1)
hidespines!(ax)
hidedecorations!(ax)
return f
end
sunflowerplot()
</syntaxhighlight>
{{output}}
[[File:Sunflower-julia.png|center|thumb]]
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
nomainwin
UpperLeftX=1:UpperLeftY=1
Line 435 ⟶ 570:
close #1
end
</syntaxhighlight>
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<
pts = Table[
i = N[ni];
Line 447 ⟶ 582:
{ni, numseeds}
];
Graphics[pts]</
=={{header|Microsoft Small Basic}}==
{{trans|Ring}}
<
GraphicsWindow.Width=410
GraphicsWindow.Height=400
Line 462 ⟶ 597:
y=r*Math.Cos(angle)+200
GraphicsWindow.DrawEllipse(x, y, i/numberofseeds*10, i/numberofseeds*10)
EndFor </
{{out}}
[https://1drv.ms/u/s!AoFH_AlpH9oZgf5kvtRou1Wuc5lSCg Sunflower fractal]
Line 469 ⟶ 604:
{{trans|Go}}
{{libheader|imageman}}
<
import imageman
Line 492 ⟶ 627:
image.drawCircle(x, y, toInt(8 * fi / Fn), Foreground)
image.savePNG("sunflower.png", compression = 9)</
=={{header|Objeck}}==
{{trans|C}}
<
use Game.Framework;
Line 568 ⟶ 703:
SCREEN_HEIGHT := 480
}
</syntaxhighlight>
=={{header|Perl}}==
{{trans|Sidef}}
<
use constant π => 3.14159265;
use constant φ => (1 + sqrt(5)) / 2;
Line 590 ⟶ 725:
}
print "</svg>\n";</
See [https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/sunflower.svg Phi-packing image] (SVG image)
Line 597 ⟶ 732:
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/SunflowerFractal.htm here].
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #008080;">constant</span> <span style="color: #000000;">numberofseeds</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">3000</span>
Line 652 ⟶ 787:
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</
=={{header|Processing}}==
{{trans|C}}
<syntaxhighlight lang="java">
//Abhishek Ghosh, 26th June 2022
size(1000,1000);
surface.setTitle("Sunflower...");
int iter = 3000;
float factor = .5 + sqrt(1.25),r,theta,diskRatio=0.5;
float x = width/2.0, y = height/2.0;
double maxRad = pow(iter,factor)/iter;
int i;
background(#add8e6); //Lightblue background
for(i=0;i<=iter;i++){
r = pow(i,factor)/iter;
if(r/maxRad < diskRatio){
stroke(#000000); // Black central disk
}
else
stroke(#ffff00); // Yellow Petals
theta = 2*PI*factor*i;
ellipse(x + r*sin(theta), y + r*cos(theta), 10 * i/(1.0*iter),10 * i/(1.0*iter));
}
</syntaxhighlight>
=={{header|Python}}==
<
from turtle import *
from math import *
Line 706 ⟶ 871:
done()
</syntaxhighlight>
=={{header|R}}==
<syntaxhighlight lang="r">
phi=1/2+sqrt(5)/2
r=seq(0,1,length.out=2000)
Line 726 ⟶ 891:
points(x[i],y[i],cex=size[i],lwd=thick[i],col="goldenrod1")
}
</syntaxhighlight>
{{Out}}
[https://raw.githubusercontent.com/schwartstack/sunflower/master/sunflower2.png Sunflower]
Line 734 ⟶ 899:
{{trans|C}}
<
(require 2htdp/image)
Line 752 ⟶ 917:
(+ (/ WIDTH 2) (* r (sin theta)))
(+ (/ HEIGHT 2) (* r (cos theta)))
image))</
=={{header|Raku}}==
Line 761 ⟶ 926:
Or, to be completely accurate: It is a variation of a generative [[wp:Fermat's_spiral|Fermat's spiral]] using the Vogel model to implement phi-packing. See: [https://thatsmaths.com/2014/06/05/sunflowers-and-fibonacci-models-of-efficiency/ https://thatsmaths.com/2014/06/05/sunflowers-and-fibonacci-models-of-efficiency]
<syntaxhighlight lang="raku"
my $seeds = 3000;
Line 780 ⟶ 945:
|@c.map( { :circle[:cx(.[0]), :cy(.[1]), :r(.[2])] } ),
],
);</
See: [https://github.com/thundergnat/rc/blob/master/img/phi-packing-perl6.svg Phi packing] (SVG image)
=={{header|Ring}}==
<
# Project : Sunflower fractal
Line 836 ⟶ 1,001:
}
label1 { setpicture(p1) show() }
</syntaxhighlight>
Output:
Line 843 ⟶ 1,008:
=={{header|Sidef}}==
{{trans|Go}}
<
func draw_sunflower(seeds=3000) {
Line 864 ⟶ 1,029:
var img = draw_sunflower()
img.write(file => "sunflower.png")</
Output image: [https://github.com/trizen/rc/blob/master/img/sunflower-sidef.png Sunflower fractal]
=={{header|V (Vlang)}}==
<syntaxhighlight lang="v (vlang)">import gg
import gx
import math
fn main() {
mut context := gg.new_context(
bg_color: gx.rgb(255, 255, 255)
width: 400
height: 400
frame_fn: frame
)
context.run()
}
fn frame(mut ctx gg.Context) {
ctx.begin()
c := (math.sqrt(5) + 1) / 2
num_of_seeds := 3000
for i := 0; i <= num_of_seeds; i++ {
mut fi := f64(i)
n := f64(num_of_seeds)
r := math.pow(fi, c) / n
angle := 2 * math.pi * c * fi
x := r*math.sin(angle) + 200
y := r*math.cos(angle) + 200
fi /= n / 5
ctx.draw_circle_filled(f32(x), f32(y), f32(fi), gx.black)
}
ctx.end()
}</syntaxhighlight>
=={{header|Wren}}==
{{trans|Go}}
{{libheader|DOME}}
<
import "dome" for Window
Line 900 ⟶ 1,097:
}
}
}</
=={{header|XPL0}}==
[[File:SunflowerXPL0.gif|200px|thumb|right]]
<syntaxhighlight lang "XPL0">
proc DrawCircle(X0, Y0, R, Color);
int X0, Y0, R, Color;
int X, Y, R2;
[R2:= R*R;
for Y:= -R to +R do
for X:= -R to +R do
if X*X + Y*Y <= R2 then
Point(X+X0, Y+Y0, Color);
];
def Seeds = 3000, Color = $0E; \yellow
def ScrW = 800, ScrH = 600;
def Phi = (sqrt(5.)+1.) / 2.; \golden ratio (1.618...)
def Pi = 3.14159265358979323846;
real R, Angle, X, Y;
int I;
[SetVid($103);
for I:= 0 to Seeds-1 do
[R:= Pow(float(I), Phi) / float(Seeds/2);
Angle:= 2. * Pi * Phi * float(I);
X:= R*Sin(Angle);
Y:= R*Cos(Angle);
DrawCircle(ScrW/2+fix(X), ScrH/2-fix(Y), I*7/Seeds, Color);
];
]</syntaxhighlight>
=={{header|Yabasic}}==
{{trans|Wren}}
<syntaxhighlight lang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Sunflower_fractal
// Adapted from Wren to Yabasic by Galileo, 01/2022
width = 400
height = 400
open window width, height
backcolor 0,0,0
clear window
color 0,255,0
seeds = 3000
c = (sqrt(5) + 1) / 2
for i = 0 to seeds
r = (i ** c) / seeds
angle = 2 * pi * c * i
x = r * sin(angle) + 200
y = r * cos(angle) + 200
circle x, y, i / seeds * 5
next</syntaxhighlight>
=={{header|zkl}}==
Line 906 ⟶ 1,157:
Uses Image Magick and
the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl
<
img,color := PPM(400,400), 0x00ff00; // green
c:=((5.0).sqrt() + 1)/2;
Line 916 ⟶ 1,167:
}
img.writeJPGFile("sunflower.zkl.jpg");
}();</
{{out}}
Image at [http://www.zenkinetic.com/Images/RosettaCode/sunflower.zkl.jpg sunflower fractal]
|