Brownian tree: Difference between revisions
m
Automated syntax highlighting fixup (second round - minor fixes) third times a charm
Thundergnat (talk | contribs) m (Undo revision 329197 by Thundergnat (talk) Really messed that one up...) Tag: Undo |
Thundergnat (talk | contribs) m (Automated syntax highlighting fixup (second round - minor fixes) third times a charm) |
||
Line 1:
[[Category:Raster graphics operations]]▼
[[Category:Geometry]]▼
{{Wikipedia|Brownian_tree}}
{{task|Fractals}}
▲[[Category:Raster graphics operations]]
[[File:Brownian_tree.jpg|450px||right]]
Line 16 ⟶ 17:
<br>Because of the lax rules governing the random nature of the particle's placement and motion, no two resulting trees are really expected to be the same, or even necessarily have the same general shape. <br><br>
=={{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.
<syntaxhighlight lang=
IF Locate(x-1,y-1)=1 THEN RETURN (1) FI
IF Locate(x,y-1)=1 THEN RETURN (1) FI
Line 111:
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Brownian_tree.png Screenshot from Atari 8-bit computer]
=={{header|Ada}}==
{{libheader|SDLAda}}
<syntaxhighlight lang=
with SDL.Video.Windows.Makers;
Line 239 ⟶ 238:
SDL.Finalise;
end Brownian_Tree;</syntaxhighlight>
=={{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.<syntaxhighlight 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 257 ⟶ 255:
14 HGR : POKE 49234,0
15 ROT= 0: SCALE= 1: RETURN</syntaxhighlight>
=={{header|AutoHotkey}}==
{{works with|AutoHotkey_L}}
Takes a little while to run, be patient.
Requires the [http://www.autohotkey.com/forum/topic32238.html GDI+ Standard Library by Tic]
<syntaxhighlight lang=
Process, Priority,, high
size := 400
Line 315 ⟶ 312:
return r
}</syntaxhighlight>Sample output file [http://www.autohotkey.net/~crazyfirex/Images/brownian.png here]
=={{header|BBC BASIC}}==
{{works with|BBC BASIC for Windows}}
<syntaxhighlight lang="bbcbasic"> SYS "SetWindowText", @hwnd%, "Brownian Tree"
SIZE = 400
Line 348 ⟶ 344:
</syntaxhighlight>
[[File:Brownian_BBC.gif]]
=={{header|C}}==
{{libheader|FreeImage}}
<syntaxhighlight lang="c">#include <string.h>
#include <stdlib.h>
#include <time.h>
Line 421 ⟶ 416:
{{trans|D}}
This version writes the image as Portable Bit Map to stdout and doesn't move already set particles.
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <time.h>
Line 465 ⟶ 460:
}</syntaxhighlight>
Run-time about 12.4 seconds with SIDE=600, NUM_PARTICLES=10000.
=={{header|C sharp|C#}}==
{{works with|C#|3.0}}
{{libheader|System.Drawing}}
<syntaxhighlight lang="csharp">using System;
using System.Drawing;
Line 520 ⟶ 514:
}
}</syntaxhighlight>
=={{header|C++}}==
[[File:brownianTree_cpp.png|300px]]
For an animated version based on this same code see: [[Brownian tree/C++ animated]]
<syntaxhighlight lang="cpp">#include <windows.h>
#include <iostream>
#include <string>
Line 820 ⟶ 813:
}
//--------------------------------------------------------------------</syntaxhighlight>
=={{header|Common Lisp}}==
When the random walk lands on a set pixel it sets the pixel at the previous position.
Line 826 ⟶ 818:
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.
<syntaxhighlight 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 912 ⟶ 904:
:compression-level 6 :if-exists :supersede)))
</syntaxhighlight>
=={{header|D}}==
Uses the module of the Grayscale Image task. Partial {{trans|PureBasic}}
<syntaxhighlight lang="d">void main() {
import core.stdc.stdio, std.random, grayscale_image;
Line 955 ⟶ 946:
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}}==
<syntaxhighlight lang="delphi">const
SIZE = 256;
NUM_PARTICLES = 1000;
Line 1,011 ⟶ 1,001:
end;
end;</syntaxhighlight>
=={{header|EasyLang}}==
[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,049 ⟶ 1,038:
.
.</syntaxhighlight>
=={{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.
<syntaxhighlight lang="factor">USING: accessors images images.loader kernel literals math
math.vectors random sets ;
FROM: sets => in? ;
Line 1,102 ⟶ 1,090:
{{out}}
[https://i.imgur.com/qDVylB9.png image]
=={{header|Fantom}}==
<syntaxhighlight lang="fantom">
using fwt
using gfx
Line 1,208 ⟶ 1,195:
}
</syntaxhighlight>
=={{header|Fortran}}==
{{works with|Fortran|95 and later}}
Line 1,216 ⟶ 1,202:
For RCImageBasic and RCImageIO, see [[Basic bitmap storage/Fortran]] and [[Write ppm file#Fortran]]
<syntaxhighlight lang="fortran">program BrownianTree
use RCImageBasic
use RCImageIO
Line 1,322 ⟶ 1,308:
end program</syntaxhighlight>
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">' version 16-03-2017
' compile with: fbc -s gui
Line 1,384 ⟶ 1,369:
Beep : Sleep 5000
End</syntaxhighlight>
=={{header|Gnuplot}}==
{{Works with|gnuplot|5.0 (patchlevel 3) and above}}
Line 1,391 ⟶ 1,375:
'''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.
<syntaxhighlight 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,417 ⟶ 1,401:
[[File:BT43gp.png|right|thumb|Output BT43gp.png]]
<syntaxhighlight lang="gnuplot">
## BTff.gp 11/27/16 aev
## Plotting 6 Brownian tree pictures.
Line 1,466 ⟶ 1,450:
BT1gp.png, BT2gp.png, BT3gp.png, BT41gp.png, BT43gp.png, BT43gp.png.
</pre>
=={{header|Go}}==
[[file:GoTree.png|right|thumb|Output png]]
Line 1,472 ⟶ 1,455:
Using standard image library:
<syntaxhighlight lang="go">package main
import (
Line 1,558 ⟶ 1,541:
}</syntaxhighlight>
Nearly the same, version below works with code from the bitmap task:
<syntaxhighlight lang="go">package main
// Files required to build supporting package raster are found in:
Line 1,637 ⟶ 1,620:
return false
}</syntaxhighlight>
=={{header|Haskell}}==
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.
<syntaxhighlight lang="haskell">import Control.Monad
import Control.Monad.ST
import Data.STRef
Line 1,688 ⟶ 1,670:
off = black
on = white</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
[[File:Brownian_tree_unicon.png|400px|thumb|right|400x400 PA=70% SA=50% D=8%]]
In this version the seed is randomly set within an inner area and particles are injected in an outer ring.
<syntaxhighlight lang=
procedure main() # brownian tree
Line 1,763 ⟶ 1,744:
[http://www.cs.arizona.edu/icon/library/src/procs/graphics.icn graphics.icn provides graphics]
[http://www.cs.arizona.edu/icon/library/src/procs/printf.icn printf.icn provides printf]
=={{header|J}}==
<syntaxhighlight lang="j">brtr=:4 :0
seed=. ?x
clip=. 0 >. (<:x) <."1 ]
Line 1,788 ⟶ 1,768:
Example use:
<syntaxhighlight lang="j"> require'viewmat'
viewmat 480 640 brtr 30000</syntaxhighlight>
Note that building a brownian tree like this takes a while and would be more interesting if this were animated.
=={{header|Java}}==
{{libheader|Swing}} {{libheader|AWT}}
<syntaxhighlight lang="java">import java.awt.Graphics;
import java.awt.image.BufferedImage;
import java.util.*;
Line 1,870 ⟶ 1,849:
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.
<syntaxhighlight lang=
import java.awt.image.BufferedImage;
import java.io.File;
Line 1,960 ⟶ 1,939:
}
}</syntaxhighlight>
=={{header|JavaScript}}==
===Using canvas===
[http://switchb.org/kpreid/2010/brownian-tree/ Live version] <!-- If changing this example, add note this link is outdated -->
<syntaxhighlight lang="javascript">function brownian(canvasId, messageId) {
var canvas = document.getElementById(canvasId);
var ctx = canvas.getContext("2d");
Line 2,094 ⟶ 2,072:
}</syntaxhighlight>
<syntaxhighlight lang="html"><html>
<head>
<script src="brownian.js"></script>
Line 2,103 ⟶ 2,081:
</body>
</html></syntaxhighlight>
=={{header|Julia}}==
{{works with|Julia|0.6}}
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 θ in polar coordinates.
<syntaxhighlight lang="julia">using Images, FileIO
function main(h::Integer, w::Integer, side::Bool=false)
Line 2,150 ⟶ 2,127:
save("data/browniantree_noside.jpg", imgnoside)
save("data/browniantree_wtside.jpg", imgwtside)</syntaxhighlight>
=={{header|Kotlin}}==
{{trans|Java}}
<syntaxhighlight lang="scala">// version 1.1.2
import java.awt.Graphics
Line 2,217 ⟶ 2,193:
Thread(b).start()
}</syntaxhighlight>
=={{header|Liberty BASIC}}==
<syntaxhighlight lang="lb">'[RC]Brownian motion tree
nomainwin
dim screen(600,600)
Line 2,302 ⟶ 2,277:
close #1
end</syntaxhighlight>
=={{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.
<syntaxhighlight 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,322 ⟶ 2,296:
1020 y=RND*400
1030 RETURN</syntaxhighlight>
=={{header|Lua}}==
The output is stored in as a ppm-image. The source code of these output-functions is located at
Line 2,328 ⟶ 2,301:
[[Grayscale image#Lua]],
[[Basic bitmap storage#Lua]].
<syntaxhighlight 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,395 ⟶ 2,368:
end
Write_PPM( "brownian_tree.ppm", ConvertToColorImage(f) )</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
There is a [http://demonstrations.wolfram.com/DiffusionLimitedAggregation/ prettier version] at the Mathematica demo site. Its source code is also available there but it is not mine.
Loose {{trans|D}}
<syntaxhighlight lang=
n = 0.35*canvasdim^2;
canvas = ConstantArray[0, {canvasdim, canvasdim}];
Line 2,430 ⟶ 2,402:
[[File:BrownianTree.png]]
=={{header|Nim}}==
{{libheader|imageman}}
<syntaxhighlight lang=
import imageman
Line 2,477 ⟶ 2,448:
# Save into a PNG file.
image.savePNG("brownian.png", compression = 9)</syntaxhighlight>
=={{header|OCaml}}==
{{trans|D}}
<syntaxhighlight lang="ocaml">let world_width = 400
let world_height = 400
let num_particles = 20_000
Line 2,534 ⟶ 2,504:
<pre>$ ocamlopt -o brownian_tree.opt brownian_tree.ml
$ ./brownian_tree.opt | display -</pre>
=={{header|Octave}}==
{{trans|C}}
<syntaxhighlight lang="octave">function r = browniantree(xsize, ysize = xsize, numparticle = 1000)
r = zeros(xsize, ysize, "uint8");
r(unidrnd(xsize), unidrnd(ysize)) = 1;
Line 2,565 ⟶ 2,534:
r( r > 0 ) = 255;
jpgwrite("browniantree.jpg", r, 100); % image package</syntaxhighlight>
=={{header|PARI/GP}}==
All versions #1 - #4 are based on using 4 small plotting helper functions, which are allowing to unify
Line 2,573 ⟶ 2,541:
===Plotting helper functions===
<syntaxhighlight lang="parigp">
\\ 2 old plotting helper functions 3/2/16 aev
\\ insm(): Check if x,y are inside matrix mat (+/- p deep).
Line 2,607 ⟶ 2,575:
[[File:BTAH1.png|right|thumb|Output BTAH1.png]]
<syntaxhighlight lang="parigp">
\\ Brownian tree v.#1. Translated from AutoHotkey
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,653 ⟶ 2,621:
[[File:BTOC1.png|right|thumb|Output BTOC1.png]]
<syntaxhighlight lang="parigp">
\\ Brownian tree v.#2. Translated from Octave
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,696 ⟶ 2,664:
[[File:BTSE1.png|right|thumb|Output BTSE1.png]]
<syntaxhighlight lang="parigp">
\\ Brownian tree v.#3. Translated from Seed7
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,743 ⟶ 2,711:
[[File:BTPB3.png|right|thumb|Output BTPB3.png]]
<syntaxhighlight lang="parigp">
\\ Brownian tree v.#4. Translated from PureBasic
\\ 3/8/2016, upgraded 11/27/16 aev
Line 2,814 ⟶ 2,782:
*** Plotting from: c:\pariData\BTPB3.dat - 3641 DOTS
</pre>
=={{header|Perl}}==
[[File:brownian-00.png|thumb]][[File:brownian-05.png|thumb]][[File:brownian-11.png|thumb]]
Line 2,820 ⟶ 2,787:
Code runs until the tree reached specified radius. Output is written to "test.eps" of wherever the current directory is.
<syntaxhighlight 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,976 ⟶ 2,943:
write_eps;</syntaxhighlight>
=={{header|Phix}}==
As-is, runs in about 2s, but can be very slow when bigger or (even worse) resize-able.
{{libheader|Phix/pGUI}}
<!--<syntaxhighlight lang=
<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,044 ⟶ 3,010:
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<!--</syntaxhighlight>-->
=={{header|PicoLisp}}==
<syntaxhighlight lang=
(de brownianTree (File Size Cnt)
Line 3,068 ⟶ 3,033:
<pre>(brownianTree "img.pbm" 300 9000)
(call 'display "img.pbm")</pre>
=={{header|Processing}}==
<syntaxhighlight lang="java">boolean SIDESTICK = false;
boolean[][] isTaken;
Line 3,114 ⟶ 3,078:
{{trans|Processing}}
<syntaxhighlight lang="python">SIDESTICK = False
def setup() :
Line 3,145 ⟶ 3,109:
if frameCount > width * height:
noLoop()</syntaxhighlight>
=={{header|PureBasic}}==
<syntaxhighlight lang=
#Image1 = 0
#ImgGadget = 0
Line 3,186 ⟶ 3,149:
Until Event = #PB_Event_CloseWindow
EndIf</syntaxhighlight>[[File:BrownianTree.pb.png]]
=={{header|Python}}==
{{libheader|pygame}}
<syntaxhighlight lang="python">import pygame, sys, os
from pygame.locals import *
from random import randint
Line 3,290 ⟶ 3,252:
input(pygame.event.get())
pygame.display.flip()</syntaxhighlight>
=={{header|R}}==
All versions #1 - #4 are based on using 2 small plotting helper functions, which are allowing to unify
Line 3,313 ⟶ 3,274:
file could be very slow too. Actually, plotv2() shows almost "pure" plotting time.
<syntaxhighlight 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,361 ⟶ 3,322:
====Version #1.====
<syntaxhighlight lang="r">
# Generate and plot Brownian tree. Version #1.
# 7/27/16 aev
Line 3,408 ⟶ 3,369:
====Version #2.====
<syntaxhighlight lang="r">
# Generate and plot Brownian tree. Version #2.
# 7/27/16 aev
Line 3,467 ⟶ 3,428:
====Version #3.====
<syntaxhighlight lang="r">
# Generate and plot Brownian tree. Version #3.
# 7/27/16 aev
Line 3,521 ⟶ 3,482:
====Version #4.====
<syntaxhighlight lang="r">
# Generate and plot Brownian tree. Version #4.
# 7/27/16 aev
Line 3,575 ⟶ 3,536:
*** END: Mon Sep 05 11:50:47 2016
</pre>
=={{header|Racket}}==
<syntaxhighlight lang="racket">#lang racket
(require 2htdp/image)
Line 3,701 ⟶ 3,661:
img
(save-image img "brownian-tree.png")</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
Line 3,711 ⟶ 3,670:
{{works with|Rakudo|2015.12}}
<syntaxhighlight lang="raku" line>constant size = 100;
constant particlenum = 1_000;
Line 3,778 ⟶ 3,737:
display;</syntaxhighlight>
=={{header|REXX}}==
A large part of the REXX program's prologue was to handle the various options. <br>
Line 3,786 ⟶ 3,744:
Program note: to keep things simple, the (system) command to clear the screen was hard-coded as '''CLS'''.
<syntaxhighlight 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,984 ⟶ 3,942:
■
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Brownian tree
Line 4,089 ⟶ 4,046:
[https://www.dropbox.com/s/a22tu6wf0ibu502/BrownianTree.jpg?dl=0 Brownian tree]
=={{header|Ruby}}==
{{libheader|RMagick}}
<syntaxhighlight lang="ruby">require 'rubygems'
require 'RMagick'
Line 4,148 ⟶ 4,104:
draw.draw img
img.write "brownian_tree.bmp"</syntaxhighlight>
=={{header|Run BASIC}}==
[[File:BrownianTreeKokenge.png|thumb|right|]]
<syntaxhighlight lang="runbasic">numParticles = 3000
dim canvas(201,201)
graphic #g, 200,200
Line 4,172 ⟶ 4,127:
render #g
#g "flush"</syntaxhighlight>
=={{header|Rust}}==
{{trans|D}}
{{libheader|rand}}
{{libheader|image}}
<syntaxhighlight lang="rust">
extern crate image;
extern crate rand;
Line 4,284 ⟶ 4,238:
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>
=={{header|Scala}}==
===Java Swing Interoperability===
<syntaxhighlight lang=
import java.awt.image.BufferedImage
Line 4,337 ⟶ 4,290:
new Thread(new BrownianTree).start()
}</syntaxhighlight>
=={{header|Scheme}}==
{{works with|Guile}}
<syntaxhighlight lang="scheme">; Save bitmap to external file
(define (save-pbm bitmap filename)
(define f (open-output-file filename))
Line 4,449 ⟶ 4,401:
(save-pbm bitmap "brownian-tree.pbm")</syntaxhighlight>
[[File:Scheme-guile-brownian-tree-large.png]]
=={{header|Seed7}}==
[[File:browniantree.png|300px|thumb|right|Simple brownian tree produced with Seed7 program]]
The program below generates a small brownian tree. You can watch how it grows.
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";
include "draw.s7i";
include "keybd.s7i";
Line 4,509 ⟶ 4,460:
Original source: [http://seed7.sourceforge.net/algorith/graphic.htm#brownian_tree]
=={{header|SequenceL}}==
'''SequenceL Code:'''<br>
<syntaxhighlight lang="sequencel">import <Utilities/Random.sl>;
import <Utilities/Sequence.sl>;
Line 4,562 ⟶ 4,512:
'''C++ Driver Code:'''<br>
{{libheader|CImg}}
<syntaxhighlight lang="c">#include <time.h>
#include <cstdlib>
#include "CImg.h"
Line 4,609 ⟶ 4,559:
{{out}}
[http://i.imgur.com/OrB9tLI.gifv Output Video]
=={{header|Sidef}}==
{{trans|Raku}}
<syntaxhighlight lang="ruby">const size = 100
const mid = size>>1
const particlenum = 1000
Line 4,731 ⟶ 4,680:
</pre>
=={{header|Simula}}==
<syntaxhighlight lang="simula">BEGIN
INTEGER NUM_PARTICLES;
INTEGER LINES, COLUMNS;
Line 4,849 ⟶ 4,798:
................................................................................
</pre>
=={{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.
<syntaxhighlight lang="basic"> 10 DIM A$(20,20)
20 LET A$(10,10)="1"
30 FOR Y=42 TO 23 STEP -1
Line 4,878 ⟶ 4,826:
{{out}}
Screenshot [http://www.edmundgriffiths.com/zx81browniantree.jpg here].
=={{header|Tcl}}==
{{libheader|Tk}}
<syntaxhighlight lang="tcl">package require Tcl 8.5
package require Tk
Line 4,933 ⟶ 4,880:
makeBrownianTree 1000
brownianTree write tree.ppm</syntaxhighlight>
=={{header|TI-83 BASIC}}==
<syntaxhighlight lang="ti83b">:StoreGDB 0
:ClrDraw
:FnOff
Line 4,962 ⟶ 4,908:
:Pause
:RecallGDB 0</syntaxhighlight>
=={{header|Visual Basic .NET}}==
Windows Forms Application.
<syntaxhighlight lang="vbnet">
Imports System.Drawing.Imaging
Line 5,099 ⟶ 5,044:
{{out|Final output}}
[[File:SH_BrownianTree.jpg]]
=={{header|Wren}}==
{{libheader|DOME}}
{{trans|Go}}
As you'd expect, not very fast so have halved Go's parameters to draw the tree in around 45 seconds.
<syntaxhighlight lang="ecmascript">import "graphics" for Canvas, Color
import "dome" for Window
import "random" for Random
Line 5,195 ⟶ 5,139:
var Game = BrownianTree.new(200, 150, 7500)</syntaxhighlight>
=={{header|XPL0}}==
[[File:BrownXPL0.gif|right]]
<syntaxhighlight lang=
def W=128, H=W; \width and height of field
int X, Y;
Line 5,216 ⟶ 5,159:
];
]</syntaxhighlight>
=={{header|zkl}}==
This grows rather slowly, so I've added a circle for barnacles to attach to. It looks like tendrils growing from the center to the circle and vice versa. The tree type is similar to that shown in the XPLO and Visual Basic .NET solutions.
Line 5,223 ⟶ 5,165:
Uses the PPM class from http://rosettacode.org/wiki/Bitmap/Bresenham%27s_line_algorithm#zkl
[[File:Brownian.zkl.jpg|250px|thumb|right]]
<syntaxhighlight lang="zkl">w:=h:=400; numParticles:=20_000;
bitmap:=PPM(w+2,h+2,0); // add borders as clip regions
Line 5,256 ⟶ 5,198:
}
bitmap.writeJPGFile("brownianTree.zkl.jpg"); // the final image</syntaxhighlight>
=={{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.
<syntaxhighlight lang="zxbasic">10 LET np=1000
20 PAPER 0: INK 4: CLS
30 PLOT 128,88
Line 5,277 ⟶ 5,218:
1030 RETURN
</syntaxhighlight>
▲[[Category:Geometry]]
| |||