Barnsley fern: Difference between revisions

{{libheader|Action! Tool Kit}}

{{libheader|Action! Real Math}}

 

BYTE CH=$02FC,COLOR1=$02C5,COLOR2=$02C6

ValR("30",scale)

Fern(scale)

{{out}}

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

=={{header|Ada}}==

{{libheader|SDLAda}}

 

with SDL.Video.Windows.Makers;

Window.Finalize;

SDL.Finalise;

 

=={{header|ALGOL 68}}==

 

This program generates a [https://en.wikipedia.org/wiki/Netpbm_format PBM file].

BEGIN

INT iterations = 300000;

leave: SKIP

END

 

110 XX(2) = .85:XY(2) = .04

120 YX(2) = - .04:YY(2) = .85

330 HPLOT X% * 2 + 1,Y%

340 NEXT

 

{{works with|BBC BASIC for Windows}}

X=0 : Y=0

FOR I%=1 TO 100000

PLOT 1000 + X * 130 , Y * 130

NEXT

 

=={{header|C}}==

This implementation requires the [http://www.cs.colorado.edu/~main/bgi/cs1300/ WinBGIm] library. Iteration starts from (0,0) as required by the task however before plotting the point is translated and scaled as negative co-ordinates are not supported by the graphics window, scaling is necessary as otherwise the fern is tiny even for large iterations ( > 1000000).

#include<graphics.h>

#include<stdlib.h>

return 0;

}

 

=={{header|C sharp|C#}}==

 

using System.Diagnostics;

using System.Drawing;

}

}

 

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

[[File:BFCpp.png|200px|thumb|right]]

#include <windows.h>

#include <ctime>

fern f; f.draw(); return 0;

}

 

===Cross-Platform Alternative===

This version uses the QImage class from the Qt toolkit as an easy way to save an image in PNG format.

It also uses the C++ 11 random number library. Built and tested on macOS 10.15.4 with Qt 5.12.5.

#include <random>

#include <vector>

}

return EXIT_SUCCESS;

 

{{out}}

 

=={{header|Common Lisp}}==

(:use #:cl

#:opticl))

(set-pixel image x y)

(multiple-value-setq (x y) (funcall (choose-transform) x y)))

 

=={{header|D}}==

{{trans|Raku}}

{{libheader|dlib}}

/+ dub.sdl:

dependency "dlib" version="~>0.21.0"

}

img.saveImage(`barnsley_dlib.png`);

 

=={{header|Delphi}}==

{{trans|Java}}

Hint: After putting a TPaintBox on the main form align it to alClient. Client width / height of the main form should be no less than 640 x 480.

 

interface

end;

 

 

=={{header|EasyLang}}==

 

 

r = randomf

if r < 0.01

x = nx

y = ny

 

=={{header|F sharp|F#}}==

 

open System.Drawing

 

|> Seq.fold (fun (b:Bitmap) (x,y) -> b.SetPixel(x-1,y-1,Color.ForestGreen); b) emptyBitmap // add pixels to bitmap

bitmap.Save("BFFsharp.png")

 

{{Out|Use}}

BarnsleyFern.run 720 720

 

=={{header|Forth}}==

Traditionaly, Forth use Fixed-Point Arithmetic (here with a 1000 scale). For transformation function choice, a formula is used to pick coefficients in a matrix.

 

s" SDL2" add-lib

\c #include <SDL2/SDL.h>

;

 

 

===Floating Point and Multiple Functions solution===

Forth may use a dedicated Floating Point Stack. For transformation, a pointer to one of the 4 functions is used to be be called at the end of the loop.

 

s" SDL2" add-lib

\c #include <SDL2/SDL.h>

;

 

 

 

 

=={{header|Fortran}}==

!Generates an output file "plot.dat" that contains the x and y coordinates

!for a scatter plot that can be visualized with say, GNUPlot

close(1)

end program BarnsleyFern

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Windowtitle "hit any key to end program"

Sleep

 

=={{header|Frink}}==

g = new graphics

g.backgroundColor[0,0,0] // black

 

g.show[]

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|G'MIC}}==

# Put this into a new file 'fern.gmic' and invoke it from the command line, like this:

# $ gmic fern.gmic -barnsley_fern

)"}

-r 40%,40%,1,1,2

 

=={{header|gnuplot}}==

[[File:BarnsleyFernGnu.png|right|thumb|Output BarnsleyFernGnu.png]]

 

## Barnsley fern fractal 2/17/17 aev

reset

set output

unset print

{{Output}}

<pre>

 

=={{header|Go}}==

 

import (

log.Fatal(err)

}

 

=={{header|Groovy}}==

{{libheader|JavaFX}}

 

import javafx.application.Application

import javafx.scene.Group

}

}

 

=={{header|Haskell}}==

import Diagrams.Backend.Rasterific.CmdLine

import Diagrams.Prelude

main = do

rand <- getStdGen

 

=={{header|IS-BASIC}}==

110 RANDOMIZE

120 SET VIDEO MODE 1:SET VIDEO COLOR 0:SET VIDEO X 40:SET VIDEO Y 27

290 LET X=NX:LET Y=NY

300 PLOT X*96+600,Y*96

 

=={{header|J}}==

)

ifs=: (fa@] + fm@] +/ .* [) prob

getPoints=: ifs^:(<200000)

 

=={{header|Java}}==

[[File:barnsley_fern.png|200px|thumb|right]]

{{works with|Java|8}}

import java.awt.image.BufferedImage;

import javax.swing.*;

});

}

 

=={{header|JavaScript}}==

[[File:BarnsleyFernjs.png|right|thumb|Output BarnsleyFernjs.png]]

 

//6/17/16 aev

function pBarnsleyFern(canvasId, lim) {

ctx.fillRect(x * 50 + 260, -y * 50 + 540, 1, 1);

} //fend i

'''Executing:'''

<html>

<head><script src="BarnsleyFern.js"></script></head>

</body>

</html>

{{Output}}

<pre>

 

=={{header|Julia}}==

 

end

 

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.awt.*

f.setVisible(true)

}

 

=={{header|Lambdatalk}}==

{def fern

{lambda {:size :sign}

{def F {fern 25 1}}

 

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

 

=={{header|Liberty BASIC}}==

 

WindowWidth=800

WindowHeight=600

[q]

close #1

 

=={{header|Locomotive Basic}}==

{{trans|ZX Spectrum Basic}}

20 scale=38

30 maxpoints=20000: x=0: y=0

100 x=nx: y=ny

110 plot scale*x+320,scale*y

 

=={{header|Lua}}==

Needs L&Ouml;VE 2D Engine

g = love.graphics

wid, hei = g.getWidth(), g.getHeight()

g.draw( canvas )

end

 

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

BarnsleyFern[{x_, y_}] := Module[{},

i = RandomInteger[{1, 100}];

points = NestList[BarnsleyFern, {0,0}, 100000];

Show[Graphics[{Hue[.35, 1, .7], PointSize[.001], Point[#] & /@ points}]]

 

=={{header|MiniScript}}==

{{trans|C#}}

{{works with|Mini Micro}}

x = 0

y = 0

y = 0.26 * xp + 0.24 * y + 0.44

end if

 

=={{header|Nim}}==

 

randomize()

 

for i in 1..iterations:

var nx, ny: float

if r <= 85:

 

discard savePNG24("fern.png",img.toString, width, height)

 

=={{header|Oberon-2}}==

[[File:Barnsleyfern-oberon2.png|250px|thumb|right]]

 

MODULE BarnsleyFern;

(**

Init;Draw

END BarnsleyFern.

 

=={{header|PARI/GP}}==

[[File:BarnsleyFern.png|right|thumb|Output BarnsleyFern.png]]

 

\\ Barnsley fern fractal

\\ 6/17/16 aev

pBarnsleyFern(530,100000); \\ BarnsleyFern.png

}

{{Output}}

=={{header|Perl}}==

[[File:BarnsleyFernPerl.png|250px|thumb|right]]

 

my $w = 640;

 

$img->flip(dir => 'v');

 

=={{header|Phix}}==

{{libheader|Phix/online}}

You can run this online [http://phix.x10.mx/p2js/BarnsleyFern.htm here], or see the output [https://imgur.com/a/04ZZZt9 on imgur]

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

-- pwa\phix\BarnsleyFern.exw

<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

 

=={{header|PicoLisp}}==

(seed (in "/dev/urandom" (rd 8)))

(scl 20)

(prinl "P1")

(prinl 640 " " 640)

 

=={{header|Processing}}==

size(640, 640);

background(0, 0, 0);

}

noLoop();

 

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

 

background(0)

 

n = height - round(60 * y)

 

 

=={{header|PureBasic}}==

DisableDebugger

 

Repeat : Until WaitWindowEvent(50)=#PB_Event_CloseWindow

EndIf

 

=={{header|Python}}==

 

import random

fern.iterate(1000000)

fern.fern.show()

 

=={{header|QB64}}==

Dim As Integer sw, sh

sw = 400: sh = 600

 

Sleep

 

 

=={{header|R}}==

{{trans|PARI/GP}}

[[File:BarnsleyFernR.png|right|thumb|Output BarnsleyFernR.png]]

## Where: fn - file name; n - number of dots; clr - color; ttl - plot title;

## psz - picture size.

## Executing:

pBarnsleyFern("BarnsleyFernR", 100000, "dark green", "Barnsley Fern Fractal", psz=600)

 

{{Output}}

==='Obvious' solution===

The matrix solution above is a clever approach, but the following solution is more readable if you're unfamiliar with linear algebra. This is very much a blind "just do what the task says" solution. It's so simple that it probably runs unadapted in S. I suspect that there is room for an interesting use of R's ifelse function somewhere, but I couldn't find a clean way.

{

{

}

{

}

{

}

{

}

return(invisible())

}

#It will look better if you use a bigger input, but the plot might take a while.

#I find that there's a large delay between RStudio saying that my code is finished running and the plot appearing.

 

=={{header|Racket}}==

[[File:racket-barnsley-fern.png]] : file uploading broken :-(

 

(require racket/draw)

 

bmp

 

=={{header|Raku}}==

{{trans|Perl}}

[[File:Barnsley-fern-perl6.png|250px|thumb|right]]

 

my ($w, $h) = (640, 640);

}

 

 

=={{header|REXX}}==

<br>contains the &nbsp; '''X''' &nbsp; and &nbsp; '''Y''' &nbsp; coördinates for a scatter plot that can be

visualized with a plotting program.

parse arg N FID seed . /*obtain optional arguments from the CL*/

if N=='' | N=="," then N= 100000 /*Not specified? Then use the default*/

call lineout FID, x","y

end /*#*/ /* [↓] close the file (safe practice).*/

{{out|output|text=&nbsp; is generated to an output file: &nbsp; BARNSLEY.DAT &nbsp; which contains the &nbsp; '''X''' &nbsp; and &nbsp; '''Y''' &nbsp; coördinates of a scatter plot.}}<br><br>

 

=={{header|Ring}}==

 

Load "guilib.ring"

return

 

=={{header|Ruby}}==

{{libheader|RubyGems}}

{{libheader|JRubyArt}}

MAX_ITERATIONS = 200_000

 

size 500, 500

end

 

=={{header|Run BASIC}}==

'http://rosettacode.org/wiki/Barnsley_fern#Run_BASIC

'copy code and run it at http://www.runbasic.com

NEXT n

render #g

 

=={{header|Rust}}==

{{libheader|rand}}

 

extern crate raster;

 

 

raster::save(&image, "fractal.png").unwrap();

 

=={{header|Scala}}==

===Java Swing Interoperability===

import java.awt.image.BufferedImage

 

})

 

 

=={{header|Scheme}}==

This version creates a list of points, defining the fern, which are then rescaled and output to an eps file.

(scheme cxr)

(scheme file)

(display "\n%%EOF")))))

 

 

=={{header|Scilab}}==

{{Works with|Scilab|5.4.0 and above}}

This version creates a list of points, defining the fern, and shows them on a graphic window which can then be saved to a file via the GUI or the console by the user.

iteractions=1.0d6;

 

axes.isoview="on";

axes.children.children.mark_foreground=13;

 

=={{header|SequenceL}}==

'''Tail-Recursive SequenceL Code:'''<br>

import <Utilities/Random.sl>;

 

fern := barnsleyFern(seedRandom(seed), count, [[0.0,0.0]]);

in

 

'''C++ Driver Code:'''<br>

{{libheader|CImg}}

#include "CImg.h"

 

 

return 0;

 

{{out}}

 

=={{header|Sidef}}==

 

var w = 640

 

img.flip(dir => 'v')

Output image: [https://github.com/trizen/rc/blob/master/img/barnsley-fern-sidef.png Barnsley fern]

 

=={{header|SPL}}==

x,y = 0

>

f2(x,y) <= 0.85*x+0.04*y, -0.04*x+0.85*y+1.6

f3(x,y) <= 0.2*x-0.26*y, 0.23*x+0.22*y+1.6

 

=={{header|Standard ML}}==

Works with PolyML. Random generator copy from the [[Random_numbers#Standard_ML]] task. Window slimmed down from [[Animation#Standard_ML]].

open Motif ;

 

XtRealizeWidget shell

)

call

demoWindow () ;

Output is viewable in a playground.

 

import CoreImage

import PlaygroundSupport

}

 

 

=={{header|TI-83 BASIC}}==

Input "ITERS:",M

[[0,0,1]]→[A]

Pxl-On(E,F)

I+1→I

 

=={{header|Unicon}}==

{{libheader|graphics}}

link graphics

 

}

end

 

=={{header|VBA}}==

Dim chrt As Chart

Set chrt = ActiveSheet.Shapes.AddChart.Chart

Next i

plot_coordinate_pairs x, y

/* {{header|Visual Basic .NET}} */ Section added

 

=={{header|Visual Basic .NET}}==

{{works with|Visual Basic .NET|2011}}

Public Class BarnsleyFern

 

End Sub 'Paint

 

 

=={{header|Wren}}==

{{trans|Kotlin}}

{{libheader|DOME}}

import "dome" for Window

import "random" for Random

}

 

 

=={{header|XPL0}}==

real NX, NY, X, Y;

[SetVid($12); \set 640x480x4 VGA graphics (on PC or RPi)

Point(320+fix(X*40.0), 440-fix(Y*40.0), 2\green\);

]

 

=={{header|Yabasic}}==

{{trans|ZX Spectrum Basic}}

Classic style

20 LET wid = 800 : LET hei = 600 : open window wid, hei : window origin "cb"

25 backcolor 0, 0, 0 : color 0, 255, 0 : clear window

100 LET x=nx: LET y=ny

110 DOT x*wid/12,y*hei/12

wid = 800 : hei = 600 : open window wid, hei : window origin "cb"

backcolor 0, 0, 0 : color 0, 255, 0 : clear window

x = nx : y = ny

dot x * wid / 12, y * hei / 12

 

=={{header|zkl}}==

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

{{trans|Java}}

w,h:=640,640;

bitmap:=PPM(w+1,h+1,0xFF|FF|FF); // White background

}

bitmap.writeJPGFile("barnsleyFern.jpg");

 

=={{header|ZX Spectrum Basic}}==

{{trans|zkl}}

20 PAPER 7: BORDER 7: BRIGHT 1: INK 4: CLS

30 LET maxpoints=20000: LET x=0: LET y=0

110 PLOT x*17+127,y*17

120 NEXT n

It is recommended to run on an emulator that supports running at full speed.