Rosetta Code

Brownian tree: Difference between revisions

Page Discussion

Brownian tree (view source)

Revision as of 18:34, 26 August 2022

2,088 bytes added ,  1 year ago
m
syntax highlighting fixup automation
m (syntax highlighting fixup automation)
Line 19:
=={{header|Action!}}==
Calculations on a real Atari 8-bit computer take quite long time. It is recommended to use an emulator capable with increasing speed of Atari CPU.
<langsyntaxhighlight lang=Action!>BYTE FUNC CheckNeighbors(CARD x BYTE y)
IF Locate(x-1,y-1)=1 THEN RETURN (1) FI
IF Locate(x,y-1)=1 THEN RETURN (1) FI
Line 108:
 
DrawTree()
RETURN</langsyntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Brownian_tree.png Screenshot from Atari 8-bit computer]
Line 114:
=={{header|Ada}}==
{{libheader|SDLAda}}
<langsyntaxhighlight lang=Ada>with Ada.Numerics.Discrete_Random;
 
with SDL.Video.Windows.Makers;
Line 238:
Window.Finalize;
SDL.Finalise;
end Brownian_Tree;</langsyntaxhighlight>
 
=={{header|Applesoft BASIC}}==
Uses XDRAW to plot to Hi-res GRaphics, in fullscreen [POKE 49234,0] 280 x 192, effectively 140 x 192 because colors stretch over two pixels, using a single pixel shape. The POKEs create one shape in a shape table starting at address 768 and point addresses 232 and 233 to this address. Address 234 is the collision counter which is used to detect if the randomly placed seed has hit anything and if the moving seed has collided with the tree. Plotting the seed creates an animation effect of the seed moving around in it's Brownian way.<langsyntaxhighlight lang=applesoftbasic>0GOSUB2:FORQ=0TOTSTEP0:X=A:Y=B:FORO=0TOTSTEP0:XDRAWTATX,Y:X=INT(RND(T)*J)*Z:Y=INT(RND(T)*H):XDRAWTATX,Y:O=PEEK(C)>0:NEXTO:FORP=0TOTSTEP0:A=X:B=Y:R=INT(RND(T)*E):X=X+X(R):Y=Y+Y(R):IFX<0ORX>MORY<0ORY>NTHENNEXTQ
1 XDRAW T AT X,Y:P = NOT PEEK (C): XDRAW T AT A,B: NEXT P: XDRAW T AT X,Y:Q = A = 0 OR A = M OR B = 0 OR B = N: NEXT Q: END
2 T = 1:Z = 2:E = 8:C = 234
Line 256:
13 POKE 232,0: POKE 233,3
14 HGR : POKE 49234,0
15 ROT= 0: SCALE= 1: RETURN</langsyntaxhighlight>
 
=={{header|AutoHotkey}}==
Line 262:
Takes a little while to run, be patient.
Requires the [http://www.autohotkey.com/forum/topic32238.html GDI+ Standard Library by Tic]
<langsyntaxhighlight lang=AHK>SetBatchLines -1
Process, Priority,, high
size := 400
Line 314:
Random, r, min, max
return r
}</langsyntaxhighlight>Sample output file [http://www.autohotkey.net/~crazyfirex/Images/brownian.png here]
 
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<langsyntaxhighlight lang=bbcbasic> SYS "SetWindowText", @hwnd%, "Brownian Tree"
SIZE = 400
Line 346:
UNTIL FALSE
</syntaxhighlight>
</lang>
[[File:Brownian_BBC.gif]]
 
=={{header|C}}==
{{libheader|FreeImage}}
<langsyntaxhighlight lang=c>#include <string.h>
#include <stdlib.h>
#include <time.h>
Line 415:
FreeImage_Save(FIF_BMP, img, "brownian_tree.bmp", 0);
FreeImage_Unload(img);
}</langsyntaxhighlight>
 
'''Bold text'''
Line 421:
{{trans|D}}
This version writes the image as Portable Bit Map to stdout and doesn't move already set particles.
<langsyntaxhighlight lang=c>#include <stdio.h>
#include <stdlib.h>
#include <time.h>
Line 463:
}
return 0;
}</langsyntaxhighlight>
Run-time about 12.4 seconds with SIDE=600, NUM_PARTICLES=10000.
 
Line 469:
{{works with|C#|3.0}}
{{libheader|System.Drawing}}
<langsyntaxhighlight lang=csharp>using System;
using System.Drawing;
 
Line 519:
}
}
}</langsyntaxhighlight>
 
=={{header|C++}}==
Line 525:
 
For an animated version based on this same code see: [[Brownian tree/C++ animated]]
<langsyntaxhighlight lang=cpp>#include <windows.h>
#include <iostream>
#include <string>
Line 819:
return 0;
}
//--------------------------------------------------------------------</langsyntaxhighlight>
 
=={{header|Common Lisp}}==
Line 826:
The former produces denser trees than the latter. If compiled with SBCL, providing a command line argument will invoke the latter method.
Requires Quicklisp library manager and the CL-GD package for producing PNG images.
<langsyntaxhighlight lang=lisp>;;; brownian.lisp
;;; sbcl compile: first load and then (sb-ext:save-lisp-and-die "brownian" :executable t :toplevel #'brownian::main)
(ql:quickload "cl-gd")
Line 911:
(write-image-to-file "brownian.png"
:compression-level 6 :if-exists :supersede)))
</langsyntaxhighlight>
 
=={{header|D}}==
Uses the module of the Grayscale Image task. Partial {{trans|PureBasic}}
<langsyntaxhighlight lang=d>void main() {
import core.stdc.stdio, std.random, grayscale_image;
 
Line 952:
data[] += 255;
Image!ubyte.fromData(data, side, side).savePGM("brownian_tree.pgm");
}</langsyntaxhighlight>
World side = 600, num_particles = 10_000, cropped (about 20 seconds run-time with dmd, about 4.3 seconds with ldc2):
<center>[[File:Dla_10000_d.png]]</center>
 
=={{header|Delphi}}==
<langsyntaxhighlight lang=delphi>const
SIZE = 256;
NUM_PARTICLES = 1000;
Line 1,010:
FreeAndNil(B);
end;
end;</langsyntaxhighlight>
 
=={{header|EasyLang}}==
Line 1,016:
[https://easylang.online/apps/_brownian-tree.html Run it]
 
<syntaxhighlight lang=text>color3 0 1 1
len f[] 200 * 200
move 50 50
Line 1,048:
.
.
.</langsyntaxhighlight>
 
=={{header|Factor}}==
This example sets four spawn points, one in each corner of the image, giving the result a vague x-shaped appearance. For visual reasons, movement is restricted to diagonals. So be careful if you change the seed or spawns — they should all fall on the same diagonal.
<langsyntaxhighlight lang=factor>USING: accessors images images.loader kernel literals math
math.vectors random sets ;
FROM: sets => in? ;
Line 1,099:
brownian-img "brownian.png" save-graphic-image ;
 
MAIN: save-brownian-tree-image</langsyntaxhighlight>
{{out}}
[https://i.imgur.com/qDVylB9.png image]
Line 1,105:
=={{header|Fantom}}==
 
<langsyntaxhighlight lang=fantom>
using fwt
using gfx
Line 1,207:
}
}
</syntaxhighlight>
</lang>
 
=={{header|Fortran}}==
Line 1,216:
For RCImageBasic and RCImageIO, see [[Basic bitmap storage/Fortran]] and [[Write ppm file#Fortran]]
 
<langsyntaxhighlight lang=fortran>program BrownianTree
use RCImageBasic
use RCImageIO
Line 1,321:
end subroutine draw_brownian_tree
 
end program</langsyntaxhighlight>
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang=freebasic>' version 16-03-2017
' compile with: fbc -s gui
 
Line 1,383:
 
Beep : Sleep 5000
End</langsyntaxhighlight>
 
=={{header|Gnuplot}}==
Line 1,391:
'''plotff.gp''' - Plotting from any data-file with 2 columns (space delimited), and writing to png-file.<br>
Especially useful to plot colored fractals using points.
<langsyntaxhighlight lang=gnuplot>
## plotff.gp 11/27/16 aev
## Plotting from any data-file with 2 columns (space delimited), and writing to png-file.
Line 1,406:
plot dfn using 1:2 with points pt 7 ps 0.5 lc @clr
set output
</langsyntaxhighlight>
 
===Versions #1 - #4. Plotting from PARI/GP generated dat-files===
Line 1,417:
[[File:BT43gp.png|right|thumb|Output BT43gp.png]]
 
<langsyntaxhighlight lang=gnuplot>
## BTff.gp 11/27/16 aev
## Plotting 6 Brownian tree pictures.
Line 1,459:
ttl = "Brownian Tree v.#4-3"
load "plotff.gp"
</langsyntaxhighlight>
{{Output}}
<pre>
Line 1,472:
 
Using standard image library:
<langsyntaxhighlight lang=go>package main
 
import (
Line 1,556:
}
return false
}</langsyntaxhighlight>
Nearly the same, version below works with code from the bitmap task:
<langsyntaxhighlight lang=go>package main
 
// Files required to build supporting package raster are found in:
Line 1,636:
}
return false
}</langsyntaxhighlight>
 
=={{header|Haskell}}==
Line 1,642:
The modules <code>[[Bitmap#Haskell|Bitmap]]</code>, <code>[[Bitmap/Write a PPM file#Haskell|Bitmap.Netpbm]]</code>, and <code>[[Bitmap/Histogram#Haskell|Bitmap.BW]]</code> are on Rosetta Code. The commented-out type signatures require [http://hackage.haskell.org/trac/haskell-prime/wiki/ScopedTypeVariables scoped type variables] in order to function.
 
<langsyntaxhighlight lang=haskell>import Control.Monad
import Control.Monad.ST
import Data.STRef
Line 1,687:
liftM2 (,) [1 .. width - 2] [0, height - 1]
off = black
on = white</langsyntaxhighlight>
 
=={{header|Icon}} and {{header|Unicon}}==
Line 1,693:
In this version the seed is randomly set within an inner area and particles are injected in an outer ring.
 
<langsyntaxhighlight lang=Icon>link graphics,printf
 
procedure main() # brownian tree
Line 1,758:
pt +:= ( pt > (1-core)/2, core)
return pt
end</langsyntaxhighlight>
 
{{libheader|Icon Programming Library}}
Line 1,766:
=={{header|J}}==
 
<langsyntaxhighlight lang=j>brtr=:4 :0
seed=. ?x
clip=. 0 >. (<:x) <."1 ]
Line 1,784:
end.
field
)</langsyntaxhighlight>
 
Example use:
 
<langsyntaxhighlight lang=j> require'viewmat'
viewmat 480 640 brtr 30000</langsyntaxhighlight>
 
Note that building a brownian tree like this takes a while and would be more interesting if this were animated.
Line 1,795:
=={{header|Java}}==
{{libheader|Swing}} {{libheader|AWT}}
<langsyntaxhighlight lang=java>import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.*;
Line 1,866:
}
}
}</langsyntaxhighlight>
 
This is an alternate version which is a port of most of the code here.
This code does not use a GUI and saves the output to image.png.
<langsyntaxhighlight lang=Java>import java.awt.Point;
import java.awt.image.BufferedImage;
import java.io.File;
Line 1,959:
}
}
}</langsyntaxhighlight>
 
=={{header|JavaScript}}==
===Using canvas===
[http://switchb.org/kpreid/2010/brownian-tree/ Live version] <!-- If changing this example, add note this link is outdated -->
<langsyntaxhighlight lang=javascript>function brownian(canvasId, messageId) {
var canvas = document.getElementById(canvasId);
var ctx = canvas.getContext("2d");
Line 2,092:
}, 1);
 
}</langsyntaxhighlight>
 
<langsyntaxhighlight lang=html><html>
<head>
<script src="brownian.js"></script>
Line 2,102:
<div id="message"></div>
</body>
</html></langsyntaxhighlight>
 
=={{header|Julia}}==
Line 2,108:
This solution puts the seed in the center of the canvas. Motes are generated randomly in space and do a simple drunkard's walk until they hit the tree or leave the canvas (unless the sides are made <tt>side</tt>). The Motes are colorized according to their &theta; in polar coordinates.
 
<langsyntaxhighlight lang=julia>using Images, FileIO
 
function main(h::Integer, w::Integer, side::Bool=false)
Line 2,149:
imgwtside = main(256, 256, true)
save("data/browniantree_noside.jpg", imgnoside)
save("data/browniantree_wtside.jpg", imgwtside)</langsyntaxhighlight>
 
=={{header|Kotlin}}==
{{trans|Java}}
<langsyntaxhighlight lang=scala>// version 1.1.2
 
import java.awt.Graphics
Line 2,216:
b.isVisible = true
Thread(b).start()
}</langsyntaxhighlight>
 
=={{header|Liberty BASIC}}==
<langsyntaxhighlight lang=lb>'[RC]Brownian motion tree
nomainwin
dim screen(600,600)
Line 2,301:
timer 0
close #1
end</langsyntaxhighlight>
 
=={{header|Locomotive Basic}}==
{{trans|ZX Spectrum Basic}}
This program is ideally run in [https://benchmarko.github.io/CPCBasic/cpcbasic.html CPCBasic] and should finish after about 20 to 25 minutes (Chrome, desktop CPU). At normal CPC speed, it would probably take several days to run when set to 10000 particles.
<langsyntaxhighlight lang=locobasic>10 MODE 1:DEFINT a-z:RANDOMIZE TIME:np=10000
20 INK 0,0:INK 1,26:BORDER 0
30 PLOT 320,200
Line 2,321:
1010 x=RND*640
1020 y=RND*400
1030 RETURN</langsyntaxhighlight>
 
=={{header|Lua}}==
Line 2,328:
[[Grayscale image#Lua]],
[[Basic bitmap storage#Lua]].
<langsyntaxhighlight lang=lua>function SetSeed( f )
for i = 1, #f[1] do -- the whole boundary of the scene is used as the seed
f[1][i] = 1
Line 2,394:
end
end
Write_PPM( "brownian_tree.ppm", ConvertToColorImage(f) )</langsyntaxhighlight>
 
=={{header|Mathematica}}/{{header|Wolfram Language}}==
Line 2,400:
 
Loose {{trans|D}}
<langsyntaxhighlight lang=Mathematica>canvasdim = 1000;
n = 0.35*canvasdim^2;
canvas = ConstantArray[0, {canvasdim, canvasdim}];
Line 2,425:
{i, (particle + ds), MatrixPlot@canvas}
]
MatrixPlot[canvas,FrameTicks->None,ColorFunction->"DarkRainbow",ColorRules->{0 -> None}]</langsyntaxhighlight>
 
Result:
Line 2,434:
{{libheader|imageman}}
 
<langsyntaxhighlight lang=Nim>import random
import imageman
 
Line 2,476:
 
# Save into a PNG file.
image.savePNG("brownian.png", compression = 9)</langsyntaxhighlight>
 
=={{header|OCaml}}==
{{trans|D}}
 
<langsyntaxhighlight lang=ocaml>let world_width = 400
let world_height = 400
let num_particles = 20_000
Line 2,528:
dla ~world;
to_pbm ~world;
;;</langsyntaxhighlight>
 
better to compile to native code to get a faster program:
Line 2,538:
{{trans|C}}
 
<langsyntaxhighlight lang=octave>function r = browniantree(xsize, ysize = xsize, numparticle = 1000)
r = zeros(xsize, ysize, "uint8");
r(unidrnd(xsize), unidrnd(ysize)) = 1;
Line 2,564:
r = browniantree(200);
r( r > 0 ) = 255;
jpgwrite("browniantree.jpg", r, 100); % image package</langsyntaxhighlight>
 
=={{header|PARI/GP}}==
Line 2,573:
 
===Plotting helper functions===
<langsyntaxhighlight lang=parigp>
\\ 2 old plotting helper functions 3/2/16 aev
\\ insm(): Check if x,y are inside matrix mat (+/- p deep).
Line 2,602:
plothraw(Vec(vx),Vec(vy));
}
</langsyntaxhighlight>
===Version #1. Translated from AutoHotkey.===
{{trans|AutoHotkey}}
[[File:BTAH1.png|right|thumb|Output BTAH1.png]]
 
<langsyntaxhighlight lang=parigp>
\\ Brownian tree v.#1. Translated from AutoHotkey
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,634:
{BrownianTree1(400,15000,"c:\\pariData\\BTAH1.dat");
plotff("c:\\pariData\\BTAH1.dat");} \\BTAH1.png
</langsyntaxhighlight>
 
{{Output}}
Line 2,653:
[[File:BTOC1.png|right|thumb|Output BTOC1.png]]
 
<langsyntaxhighlight lang=parigp>
\\ Brownian tree v.#2. Translated from Octave
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,678:
{BrownianTree2(1000,3000,"c:\\pariData\\BTOC1.dat");
plotff("c:\\pariData\\BTOC1.dat");} \\BTOC1.png
</langsyntaxhighlight>
 
{{Output}}
Line 2,696:
[[File:BTSE1.png|right|thumb|Output BTSE1.png]]
 
<langsyntaxhighlight lang=parigp>
\\ Brownian tree v.#3. Translated from Seed7
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,723:
{BrownianTree3(400,5000,"c:\\pariData\\BTSE1.dat");
plotff("c:\\pariData\\BTSE1.dat");} \\BTSE1.png
</langsyntaxhighlight>
 
{{Output}}
Line 2,743:
[[File:BTPB3.png|right|thumb|Output BTPB3.png]]
 
<langsyntaxhighlight lang=parigp>
\\ Brownian tree v.#4. Translated from PureBasic
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,783:
{BrownianTree4(200,4000,"c:\\pariData\\BTPB3.dat",2,5);
plotff("c:\\pariData\\BTPB3.dat");} \\BTPB3.png
</langsyntaxhighlight>
 
{{Output}}
Line 2,820:
 
Code runs until the tree reached specified radius. Output is written to "test.eps" of wherever the current directory is.
<langsyntaxhighlight lang=perl>sub PI() { atan2(1,1) * 4 } # The, er, pi
sub STEP() { .5 } # How far does the particle move each step. Affects
# both speed and accuracy greatly
Line 2,975:
}
 
write_eps;</langsyntaxhighlight>
 
=={{header|Phix}}==
As-is, runs in about 2s, but can be very slow when bigger or (even worse) resize-able.
{{libheader|Phix/pGUI}}
<!--<langsyntaxhighlight lang=Phix>(phixonline)-->
<span style="color: #000080;font-style:italic;">-- demo\rosetta\BrownianTree.exw</span>
<span style="color: #008080;">include</span> <span style="color: #000000;">pGUI</span><span style="color: #0000FF;">.</span><span style="color: #000000;">e</span>
Line 3,043:
<span style="color: #7060A8;">IupClose</span><span style="color: #0000FF;">()</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</langsyntaxhighlight>-->
 
=={{header|PicoLisp}}==
<langsyntaxhighlight lang=PicoLisp>(load "@lib/simul.l")
 
(de brownianTree (File Size Cnt)
Line 3,064:
(for This L
(prin (if (: pix) 1 0)) )
(prinl) ) ) ) )</langsyntaxhighlight>
Use:
<pre>(brownianTree "img.pbm" 300 9000)
Line 3,070:
 
=={{header|Processing}}==
<langsyntaxhighlight lang=java>boolean SIDESTICK = false;
boolean[][] isTaken;
 
Line 3,108:
noLoop();
}
}</langsyntaxhighlight>
 
==={{header|Processing Python mode}}===
Line 3,114:
{{trans|Processing}}
 
<langsyntaxhighlight lang=python>SIDESTICK = False
 
def setup() :
Line 3,144:
if frameCount > width * height:
noLoop()</langsyntaxhighlight>
 
=={{header|PureBasic}}==
<langsyntaxhighlight lang=PureBasic>#Window1 = 0
#Image1 = 0
#ImgGadget = 0
Line 3,185:
Event = WaitWindowEvent()
Until Event = #PB_Event_CloseWindow
EndIf</langsyntaxhighlight>[[File:BrownianTree.pb.png]]
 
=={{header|Python}}==
{{libheader|pygame}}
<langsyntaxhighlight lang=python>import pygame, sys, os
from pygame.locals import *
from random import randint
Line 3,289:
while True:
input(pygame.event.get())
pygame.display.flip()</langsyntaxhighlight>
 
=={{header|R}}==
Line 3,313:
file could be very slow too. Actually, plotv2() shows almost "pure" plotting time.
 
<syntaxhighlight lang=r>
<lang r>
# plotmat(): Simple plotting using a square matrix mat (filled with 0/1). v. 8/31/16
# Where: mat - matrix; fn - file name; clr - color; ttl - plot title;
Line 3,353:
cat(" *** END:", date(), "\n");
}
</langsyntaxhighlight>
 
===Versions #1- #4.===
Line 3,361:
 
====Version #1.====
<syntaxhighlight lang=r>
<lang r>
# Generate and plot Brownian tree. Version #1.
# 7/27/16 aev
Line 3,395:
}
gpBrownianTree1(400,15000,"red", "BT1R", "Brownian Tree v.1", 1);
</langsyntaxhighlight>
 
{{Output}}
Line 3,408:
 
====Version #2.====
<syntaxhighlight lang=r>
<lang r>
# Generate and plot Brownian tree. Version #2.
# 7/27/16 aev
Line 3,446:
## Rename BT2R.dmp to BT2aR.dmp
plotv2("BT2aR", "orange", "Brownian Tree v.2a", 640)
</langsyntaxhighlight>
 
{{Output}}
Line 3,467:
 
====Version #3.====
<syntaxhighlight lang=r>
<lang r>
# Generate and plot Brownian tree. Version #3.
# 7/27/16 aev
Line 3,507:
}
gpBrownianTree3(400,5000,"dark green", "BT3R", "Brownian Tree v.3", 1);
</langsyntaxhighlight>
 
{{Output}}
Line 3,521:
 
====Version #4.====
<syntaxhighlight lang=r>
<lang r>
# Generate and plot Brownian tree. Version #4.
# 7/27/16 aev
Line 3,563:
}
gpBrownianTree4(400,15000,"navy", "BT4R", "Brownian Tree v.4", 1);
</langsyntaxhighlight>
 
{{Output}}
Line 3,577:
 
=={{header|Racket}}==
<langsyntaxhighlight lang=racket>#lang racket
(require 2htdp/image)
 
Line 3,700:
 
img
(save-image img "brownian-tree.png")</langsyntaxhighlight>
 
=={{header|Raku}}==
Line 3,711:
{{works with|Rakudo|2015.12}}
 
<syntaxhighlight lang=raku perl6line>constant size = 100;
constant particlenum = 1_000;
 
Line 3,777:
}
 
display;</langsyntaxhighlight>
 
=={{header|REXX}}==
Line 3,786:
 
Program note: &nbsp; to keep things simple, the (system) command to clear the screen was hard-coded as &nbsp; '''CLS'''.
<langsyntaxhighlight lang=rexx>/*REXX program animates and displays Brownian motion of dust in a field (with one seed).*/
mote = '·' /*character for a loose mote (of dust).*/
hole = ' ' /* " " an empty spot in field.*/
Line 3,863:
if yb<loY then loY= max(1, yb); if yb>hiY then hiY= min(sd, yb)
end /*y*/ /* [↑] limit mote's movement to field.*/
end /*x*/; return</langsyntaxhighlight>
This REXX program makes use of &nbsp; '''scrsize''' &nbsp; REXX program (or BIF) which is used to determine the screen size of the terminal (console).
 
Line 3,986:
 
=={{header|Ring}}==
<langsyntaxhighlight lang=ring>
# Project : Brownian tree
 
Line 4,085:
next
return number(str)
</syntaxhighlight>
</lang>
Output:
 
Line 4,092:
=={{header|Ruby}}==
{{libheader|RMagick}}
<langsyntaxhighlight lang=ruby>require 'rubygems'
require 'RMagick'
 
Line 4,147:
 
draw.draw img
img.write "brownian_tree.bmp"</langsyntaxhighlight>
 
=={{header|Run BASIC}}==
[[File:BrownianTreeKokenge.png|thumb|right|]]
<langsyntaxhighlight lang=runbasic>numParticles = 3000
dim canvas(201,201)
graphic #g, 200,200
Line 4,171:
next i
render #g
#g "flush"</langsyntaxhighlight>
 
=={{header|Rust}}==
Line 4,177:
{{libheader|rand}}
{{libheader|image}}
<langsyntaxhighlight lang=rust>
extern crate image;
extern crate rand;
Line 4,281:
}
}
}</langsyntaxhighlight>
For a 512 x 512 field and 100k motes, run time is around 200 s on ~2019 hardware (Ryzen 5 3600X).
<center>[[File:Rust-Brownian-512-20k.png]]</center>
Line 4,287:
=={{header|Scala}}==
===Java Swing Interoperability===
<langsyntaxhighlight lang=Scala>import java.awt.Graphics
import java.awt.image.BufferedImage
 
Line 4,336:
 
new Thread(new BrownianTree).start()
}</langsyntaxhighlight>
 
=={{header|Scheme}}==
{{works with|Guile}}
<langsyntaxhighlight lang=scheme>; Save bitmap to external file
(define (save-pbm bitmap filename)
(define f (open-output-file filename))
Line 4,447:
 
; Save to a portable bitmap file
(save-pbm bitmap "brownian-tree.pbm")</langsyntaxhighlight>
[[File:Scheme-guile-brownian-tree-large.png]]
 
Line 4,454:
The program below generates a small brownian tree. You can watch how it grows.
 
<langsyntaxhighlight lang=seed7>$ include "seed7_05.s7i";
include "draw.s7i";
include "keybd.s7i";
Line 4,506:
genBrownianTree(SIZE, 20000);
readln(KEYBOARD);
end func;</langsyntaxhighlight>
 
Original source: [http://seed7.sourceforge.net/algorith/graphic.htm#brownian_tree]
Line 4,512:
=={{header|SequenceL}}==
'''SequenceL Code:'''<br>
<langsyntaxhighlight lang=sequencel>import <Utilities/Random.sl>;
import <Utilities/Sequence.sl>;
 
Line 4,558:
j within 1 ... worldSize;
in
(World: world, Rand: seedRandom(seed), Point: (X: worldSize / 2, Y: worldSize / 2));</langsyntaxhighlight>
 
'''C++ Driver Code:'''<br>
{{libheader|CImg}}
<langsyntaxhighlight lang=c>#include <time.h>
#include <cstdlib>
#include "CImg.h"
Line 4,605:
 
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 4,612:
=={{header|Sidef}}==
{{trans|Raku}}
<langsyntaxhighlight lang=ruby>const size = 100
const mid = size>>1
const particlenum = 1000
Line 4,689:
}
 
display()</langsyntaxhighlight>
{{out}}
<pre>
Line 4,731:
</pre>
=={{header|Simula}}==
<langsyntaxhighlight lang=simula>BEGIN
INTEGER NUM_PARTICLES;
INTEGER LINES, COLUMNS;
Line 4,797:
 
END;
END.</langsyntaxhighlight>
{{in}}
<pre>656565</pre>
Line 4,852:
=={{header|Sinclair ZX81 BASIC}}==
Requires at least 2k of RAM. If you have more, you can plot it on a larger grid—up to and including full-screen, provided you don't mind spending literally hours watching the first few dots maunder about without hitting anything.
<langsyntaxhighlight lang=basic> 10 DIM A$(20,20)
20 LET A$(10,10)="1"
30 FOR Y=42 TO 23 STEP -1
Line 4,875:
220 GOTO 130
230 LET A$(X,Y)="1"
240 NEXT I</langsyntaxhighlight>
{{out}}
Screenshot [http://www.edmundgriffiths.com/zx81browniantree.jpg here].
Line 4,881:
=={{header|Tcl}}==
{{libheader|Tk}}
<langsyntaxhighlight lang=tcl>package require Tcl 8.5
package require Tk
 
Line 4,932:
update
makeBrownianTree 1000
brownianTree write tree.ppm</langsyntaxhighlight>
 
=={{header|TI-83 BASIC}}==
<langsyntaxhighlight lang=ti83b>:StoreGDB 0
:ClrDraw
:FnOff
Line 4,961:
:End
:Pause
:RecallGDB 0</langsyntaxhighlight>
 
=={{header|Visual Basic .NET}}==
Windows Forms Application.
 
<langsyntaxhighlight lang=vbnet>
Imports System.Drawing.Imaging
 
Line 5,096:
End Sub
End Class
</syntaxhighlight>
</lang>
{{out|Final output}}
[[File:SH_BrownianTree.jpg]]
Line 5,104:
{{trans|Go}}
As you'd expect, not very fast so have halved Go's parameters to draw the tree in around 45 seconds.
<langsyntaxhighlight lang=ecmascript>import "graphics" for Canvas, Color
import "dome" for Window
import "random" for Random
Line 5,194:
}
 
var Game = BrownianTree.new(200, 150, 7500)</langsyntaxhighlight>
 
=={{header|XPL0}}==
[[File:BrownXPL0.gif|right]]
<langsyntaxhighlight lang=XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations
def W=128, H=W; \width and height of field
int X, Y;
Line 5,215:
if KeyHit then [SetVid(3); quit]; \restore text mode
];
]</langsyntaxhighlight>
 
=={{header|zkl}}==
Line 5,223:
Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl
[[File:Brownian.zkl.jpg|250px|thumb|right]]
<langsyntaxhighlight lang=zkl>w:=h:=400; numParticles:=20_000;
bitmap:=PPM(w+2,h+2,0); // add borders as clip regions
 
Line 5,255:
}
}
bitmap.writeJPGFile("brownianTree.zkl.jpg"); // the final image</langsyntaxhighlight>
 
=={{header|ZX Spectrum Basic}}==
{{trans|Run BASIC}}
Very, very slow on a ZX Spectrum (even emulate and at maximum speed). Best use SpecBAS, changing the value of the variable np to 6000.
<langsyntaxhighlight lang=zxbasic>10 LET np=1000
20 PAPER 0: INK 4: CLS
30 PLOT 128,88
Line 5,276:
1020 LET y=RND*174
1030 RETURN
</syntaxhighlight>
</lang>
 
[[Category:Geometry]]
Thundergnat
10,327

edits

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