Rosetta Code

Sunflower fractal: Difference between revisions

Page Discussion

Sunflower fractal (view source)

Revision as of 04:31, 24 March 2024

3,130 bytes added ,  1 month ago
m
→‎{{header|Fōrmulæ}}
(with credit to homme_chauve_souris. The 2*pi typo is corrected with their solution to use 8*ATN(1))
 
(13 intermediate revisions by 8 users not shown)
Line 9:
{{trans|Perl}}
 
<langsyntaxhighlight lang="11l">-V
phi = (1 + sqrt(5)) / 2
size = 600
Line 23:
r * cos(t) + size / 2, sqrt(i) / 13))
 
print(‘</svg>’)</langsyntaxhighlight>
 
=={{header|Action!}}==
Line 29:
{{libheader|Action! Tool Kit}}
{{libheader|Action! Real Math}}
<langsyntaxhighlight Actionlang="action!">INCLUDE "H6:REALMATH.ACT"
 
INT ARRAY SinTab=[
Line 144:
DO UNTIL CH#$FF OD
CH=$FF
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sunflower_fractal.png Screenshot from Atari 8-bit computer]
 
=={{header|Applesoft BASIC}}==
<langsyntaxhighlight 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</langsyntaxhighlight>
 
=={{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">
<lang C>
/*Abhishek Ghosh, 14th September 2018*/
 
Line 193:
return 0;
}
</syntaxhighlight>
</lang>
 
=={{header|C++}}==
{{trans|Perl}}
<langsyntaxhighlight lang="cpp">#include <cmath>
#include <fstream>
#include <iostream>
Line 237:
}
return EXIT_SUCCESS;
}</langsyntaxhighlight>
 
{{out}}
[[Media:Sunflower cpp.svg]]
See: [https://slack-files.com/T0CNUL56D-F016R4G8MQB-27761bfe01 sunflower.svg] (offsite SVG image)
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">
Const PI As Double = 4 * Atn(1)
Const ancho = 400
Line 269:
Sleep
End
</syntaxhighlight>
</lang>
 
=={{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 276 ⟶ 331:
<br>
The image produced, when viewed with (for example) EOG, is similar to the Ring entry.
<langsyntaxhighlight lang="go">package main
 
import (
Line 303 ⟶ 358:
dc.Stroke()
dc.SavePNG("sunflower_fractal.png")
}</langsyntaxhighlight>
 
=={{header|javascript}}==
Line 325 ⟶ 380:
</html>
</pre>
<langsyntaxhighlight lang="javascript">const SIZE = 400, HS = SIZE >> 1, WAIT = .005, SEEDS = 3000,
TPI = Math.PI * 2, C = (Math.sqrt(10) + 1) / 2;
class Sunflower {
Line 381 ⟶ 436:
const sunflower = new Sunflower();
sunflower.start();
}</langsyntaxhighlight>
 
=={{header|J}}==
Line 389 ⟶ 444:
This implementation assumes a recent J implementation (for example, J903):
 
<langsyntaxhighlight Jlang="j">require'format/printf'
 
sunfract=: {{ NB. y: number of "sunflower seeds"
Line 406 ⟶ 461:
</svg>
}} sprintf (;/<.20+}:>./fract),<C) fwrite y}}
</syntaxhighlight>
</lang>
 
Example use:
 
<syntaxhighlight lang="j">
<lang J>
3000 sunfractsvg '~/sunfract.html'
129147
</syntaxhighlight>
</lang>
 
(The number displayed is the size of the generated file.)
Line 422 ⟶ 477:
'''Works with gojq, the Go implementation of jq'''
 
<langsyntaxhighlight lang="jq"># SVG headers
def svg(size):
"<svg xmlns='http://www.w3.org/2000/svg' width='\(size)'",
Line 449 ⟶ 504:
svg(600),
sunflower(600),
end_svg</langsyntaxhighlight>
 
=={{header|Julia}}==
{{trans|R}}
Run from REPL.
<langsyntaxhighlight lang="julia">using MakieGLMakie
 
function sunflowerplot()
Line 464 ⟶ 519:
for i in 2:length(r)
θ[i] = θ[i - 1] + 2π * ϕ
markersizes[i] = div(i, 500) + 39
end
x = r .* cos.(θ)
y = r .* sin.(θ)
scenef = SceneFigure(backgroundcolor=:green)
ax = Axis(f[1, 1], backgroundcolor = :green)
scatter!(scene, x, y, color=:gold, markersize=markersizes, strokewidth=1, fill=false, show_axis=false)
scatter!(ax, x, y, color = :gold, markersize = markersizes, strokewidth = 1)
hidespines!(ax)
hidedecorations!(ax)
return f
end
 
sunflowerplot()
</syntaxhighlight>
</lang>
 
{{output}}
 
[[File:Sunflower-julia.png|center|thumb]]
 
 
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">
<lang lb>
nomainwin
UpperLeftX=1:UpperLeftY=1
Line 506 ⟶ 570:
close #1
end
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<langsyntaxhighlight Mathematicalang="mathematica">numseeds = 3000;
pts = Table[
i = N[ni];
Line 518 ⟶ 582:
{ni, numseeds}
];
Graphics[pts]</langsyntaxhighlight>
 
=={{header|Microsoft Small Basic}}==
{{trans|Ring}}
<langsyntaxhighlight lang="smallbasic">' Sunflower fractal - 24/07/2018
GraphicsWindow.Width=410
GraphicsWindow.Height=400
Line 533 ⟶ 597:
y=r*Math.Cos(angle)+200
GraphicsWindow.DrawEllipse(x, y, i/numberofseeds*10, i/numberofseeds*10)
EndFor </langsyntaxhighlight>
{{out}}
[https://1drv.ms/u/s!AoFH_AlpH9oZgf5kvtRou1Wuc5lSCg Sunflower fractal]
Line 540 ⟶ 604:
{{trans|Go}}
{{libheader|imageman}}
<langsyntaxhighlight Nimlang="nim">import math
import imageman
 
Line 563 ⟶ 627:
image.drawCircle(x, y, toInt(8 * fi / Fn), Foreground)
 
image.savePNG("sunflower.png", compression = 9)</langsyntaxhighlight>
 
=={{header|Objeck}}==
{{trans|C}}
<langsyntaxhighlight lang="perl">use Game.SDL2;
use Game.Framework;
 
Line 639 ⟶ 703:
SCREEN_HEIGHT := 480
}
</syntaxhighlight>
</lang>
 
=={{header|Perl}}==
{{trans|Sidef}}
<langsyntaxhighlight lang="perl">use utf8;
use constant π => 3.14159265;
use constant φ => (1 + sqrt(5)) / 2;
Line 661 ⟶ 725:
}
 
print "</svg>\n";</langsyntaxhighlight>
See [https://github.com/SqrtNegInf/Rosettacode-Perl5-Smoke/blob/master/ref/sunflower.svg Phi-packing image] (SVG image)
 
Line 668 ⟶ 732:
{{libheader|Phix/online}}
You can run this online [http://phix.x10.mx/p2js/SunflowerFractal.htm here].
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<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 723 ⟶ 787:
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>
<!--</langsyntaxhighlight>-->
 
=={{header|Processing}}==
{{trans|C}}
<langsyntaxhighlight lang="java">
//Abhishek Ghosh, 26th June 2022
 
Line 753 ⟶ 817:
ellipse(x + r*sin(theta), y + r*cos(theta), 10 * i/(1.0*iter),10 * i/(1.0*iter));
}
</syntaxhighlight>
</lang>
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">
from turtle import *
from math import *
Line 807 ⟶ 871:
 
done()
</syntaxhighlight>
</lang>
 
=={{header|R}}==
<syntaxhighlight lang="r">
<lang R>
phi=1/2+sqrt(5)/2
r=seq(0,1,length.out=2000)
Line 827 ⟶ 891:
points(x[i],y[i],cex=size[i],lwd=thick[i],col="goldenrod1")
}
</syntaxhighlight>
</lang>
{{Out}}
[https://raw.githubusercontent.com/schwartstack/sunflower/master/sunflower2.png Sunflower]
Line 835 ⟶ 899:
{{trans|C}}
 
<langsyntaxhighlight lang="racket">#lang racket
 
(require 2htdp/image)
Line 853 ⟶ 917:
(+ (/ WIDTH 2) (* r (sin theta)))
(+ (/ HEIGHT 2) (* r (cos theta)))
image))</langsyntaxhighlight>
 
=={{header|Raku}}==
Line 862 ⟶ 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" perl6line>use SVG;
 
my $seeds = 3000;
Line 881 ⟶ 945:
|@c.map( { :circle[:cx(.[0]), :cy(.[1]), :r(.[2])] } ),
],
);</langsyntaxhighlight>
See: [https://github.com/thundergnat/rc/blob/master/img/phi-packing-perl6.svg Phi packing] (SVG image)
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
# Project : Sunflower fractal
 
Line 937 ⟶ 1,001:
}
label1 { setpicture(p1) show() }
</syntaxhighlight>
</lang>
Output:
 
Line 944 ⟶ 1,008:
=={{header|Sidef}}==
{{trans|Go}}
<langsyntaxhighlight lang="ruby">require('Imager')
 
func draw_sunflower(seeds=3000) {
Line 965 ⟶ 1,029:
 
var img = draw_sunflower()
img.write(file => "sunflower.png")</langsyntaxhighlight>
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
Line 998 ⟶ 1,062:
}
ctx.end()
}</langsyntaxhighlight>
 
=={{header|Wren}}==
{{trans|Go}}
{{libheader|DOME}}
<langsyntaxhighlight ecmascriptlang="wren">import "graphics" for Canvas, Color
import "dome" for Window
 
Line 1,033 ⟶ 1,097:
}
}
}</langsyntaxhighlight>
 
=={{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}}
<langsyntaxhighlight Yabasiclang="yabasic">// Rosetta Code problem: http://rosettacode.org/wiki/Sunflower_fractal
// Adapted from Wren to Yabasic by Galileo, 01/2022
 
Line 1,057 ⟶ 1,151:
y = r * cos(angle) + 200
circle x, y, i / seeds * 5
next</langsyntaxhighlight>
 
=={{header|zkl}}==
Line 1,063 ⟶ 1,157:
Uses Image Magick and
the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl
<langsyntaxhighlight lang="zkl">fcn sunflower(seeds=3000){
img,color := PPM(400,400), 0x00ff00; // green
c:=((5.0).sqrt() + 1)/2;
Line 1,073 ⟶ 1,167:
}
img.writeJPGFile("sunflower.zkl.jpg");
}();</langsyntaxhighlight>
{{out}}
Image at [http://www.zenkinetic.com/Images/RosettaCode/sunflower.zkl.jpg sunflower fractal]
Laurence
2,120

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/283385...362749"