Brownian tree: Difference between revisions

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.

<~~lang~~ Action!>BYTE FUNC CheckNeighbors(CARD x BYTE y)

<syntaxhighlight 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</~~lang~~>

RETURN</syntaxhighlight>

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

Line 114:

=={{header|Ada}}==

<~~lang~~ Ada>with Ada.Numerics.Discrete_Random;

<syntaxhighlight lang=Ada>with Ada.Numerics.Discrete_Random;

with SDL.Video.Windows.Makers;

Line 238:

Window.Finalize;

SDL.Finalise;

end Brownian_Tree;</~~lang~~>

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.<~~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

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 256:

13 POKE 232,0: POKE 233,3

14 HGR : POKE 49234,0

15 ROT= 0: SCALE= 1: RETURN</~~lang~~>

15 ROT= 0: SCALE= 1: RETURN</syntaxhighlight>

=={{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]

<~~lang~~ AHK>SetBatchLines -1

<syntaxhighlight lang=AHK>SetBatchLines -1

Process, Priority,, high

size := 400

Line 314:

Random, r, min, max

return r

}</~~lang~~>Sample output file [http://www.autohotkey.net/~crazyfirex/Images/brownian.png here]

}</syntaxhighlight>Sample output file [http://www.autohotkey.net/~crazyfirex/Images/brownian.png here]

=={{header|BBC BASIC}}==

<~~lang~~ bbcbasic> SYS "SetWindowText", @hwnd%, "Brownian Tree"

<syntaxhighlight lang=bbcbasic> SYS "SetWindowText", @hwnd%, "Brownian Tree"

SIZE = 400

Line 346:

UNTIL FALSE

</syntaxhighlight>

</lang>

[[File:Brownian_BBC.gif]]

=={{header|C}}==

<~~lang~~ c>#include <string.h>

<syntaxhighlight 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);

}</~~lang~~>

}</syntaxhighlight>

'''Bold text'''

Line 421:

This version writes the image as Portable Bit Map to stdout and doesn't move already set particles.

<~~lang~~ c>#include <stdio.h>

<syntaxhighlight lang=c>#include <stdio.h>

#include <stdlib.h>

#include <time.h>

Line 463:

}

return 0;

}</~~lang~~>

}</syntaxhighlight>

Run-time about 12.4 seconds with SIDE=600, NUM_PARTICLES=10000.

Line 469:

<~~lang~~ csharp>using System;

<syntaxhighlight lang=csharp>using System;

using System.Drawing;

Line 519:

}

}</~~lang~~>

}</syntaxhighlight>

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

Line 525:

For an animated version based on this same code see: [[Brownian tree/C++ animated]]

<~~lang~~ cpp>#include <windows.h>

<syntaxhighlight lang=cpp>#include <windows.h>

#include <iostream>

#include <string>

Line 819:

return 0;

}

//--------------------------------------------------------------------</~~lang~~>

//--------------------------------------------------------------------</syntaxhighlight>

=={{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.

<~~lang~~ lisp>;;; brownian.lisp

<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 911:

(write-image-to-file "brownian.png"

:compression-level 6 :if-exists :supersede)))

</~~lang~~>

</syntaxhighlight>

=={{header|D}}==

Uses the module of the Grayscale Image task. Partial {{trans|PureBasic}}

<~~lang~~ d>void main() {

<syntaxhighlight 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");

}</~~lang~~>

}</syntaxhighlight>

World side = 600, num_particles = 10_000, cropped (about 20 seconds run-time with dmd, about 4.3 seconds with ldc2):

=={{header|Delphi}}==

<~~lang~~ delphi>const

<syntaxhighlight lang=delphi>const

SIZE = 256;

NUM_PARTICLES = 1000;

Line 1,010:

FreeAndNil(B);

end;

end;</~~lang~~>

end;</syntaxhighlight>

=={{header|EasyLang}}==

Line 1,016:

[https://easylang.online/apps/_brownian-tree.html Run it]

<lang>color3 0 1 1

<syntaxhighlight lang=text>color3 0 1 1

len f[] 200 * 200

move 50 50

Line 1,048:

.

.</~~lang~~>

.</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.

<~~lang~~ factor>USING: accessors images images.loader kernel literals math

<syntaxhighlight 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</~~lang~~>

MAIN: save-brownian-tree-image</syntaxhighlight>

[https://i.imgur.com/qDVylB9.png image]

Line 1,105:

=={{header|Fantom}}==

<~~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]]

<~~lang~~ fortran>program BrownianTree

<syntaxhighlight lang=fortran>program BrownianTree

use RCImageBasic

use RCImageIO

Line 1,321:

end subroutine draw_brownian_tree

end program</~~lang~~>

end program</syntaxhighlight>

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>' version 16-03-2017

<syntaxhighlight lang=freebasic>' version 16-03-2017

' compile with: fbc -s gui

Line 1,383:

Beep : Sleep 5000

End</~~lang~~>

End</syntaxhighlight>

=={{header|Gnuplot}}==

Line 1,391:

'''plotff.gp''' - Plotting from any data-file with 2 columns (space delimited), and writing to png-file.

Especially useful to plot colored fractals using points.

<~~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

</~~lang~~>

</syntaxhighlight>

===Versions #1 - #4. Plotting from PARI/GP generated dat-files===

Line 1,417:

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

<~~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"

</~~lang~~>

</syntaxhighlight>

<pre>

Line 1,472:

Using standard image library:

<~~lang~~ go>package main

<syntaxhighlight lang=go>package main

import (

Line 1,556:

}

return false

}</~~lang~~>

}</syntaxhighlight>

Nearly the same, version below works with code from the bitmap task:

<~~lang~~ go>package main

<syntaxhighlight lang=go>package main

// Files required to build supporting package raster are found in:

Line 1,636:

}

return false

}</~~lang~~>

}</syntaxhighlight>

=={{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.

<~~lang~~ haskell>import Control.Monad

<syntaxhighlight 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</~~lang~~>

on = white</syntaxhighlight>

=={{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.

<~~lang~~ Icon>link graphics,printf

<syntaxhighlight lang=Icon>link graphics,printf

procedure main() # brownian tree

Line 1,758:

pt +:= ( pt > (1-core)/2, core)

return pt

end</~~lang~~>

end</syntaxhighlight>

Line 1,766:

=={{header|J}}==

<~~lang~~ j>brtr=:4 :0

<syntaxhighlight lang=j>brtr=:4 :0

seed=. ?x

clip=. 0 >. (<:x) <."1 ]

Line 1,784:

end.

field

)</~~lang~~>

)</syntaxhighlight>

Example use:

<~~lang~~ j> require'viewmat'

<syntaxhighlight lang=j> require'viewmat'

viewmat 480 640 brtr 30000</~~lang~~>

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.

Line 1,795:

=={{header|Java}}==

<~~lang~~ java>import java.awt.Graphics;

<syntaxhighlight lang=java>import java.awt.Graphics;

import java.awt.image.BufferedImage;

import java.util.*;

Line 1,866:

}

}</~~lang~~>

}</syntaxhighlight>

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.

<~~lang~~ Java>import java.awt.Point;

<syntaxhighlight lang=Java>import java.awt.Point;

import java.awt.image.BufferedImage;

import java.io.File;

Line 1,959:

}

}</~~lang~~>

}</syntaxhighlight>

=={{header|JavaScript}}==

===Using canvas===

[http://switchb.org/kpreid/2010/brownian-tree/ Live version]

<~~lang~~ javascript>function brownian(canvasId, messageId) {

<syntaxhighlight lang=javascript>function brownian(canvasId, messageId) {

var canvas = document.getElementById(canvasId);

var ctx = canvas.getContext("2d");

Line 2,092:

}, 1);

}</~~lang~~>

}</syntaxhighlight>

<~~lang~~ html><html>

<head>

Line 2,102:

</body>

</html></~~lang~~>

</html></syntaxhighlight>

=={{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 θ in polar coordinates.

<~~lang~~ julia>using Images, FileIO

<syntaxhighlight 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)</~~lang~~>

save("data/browniantree_wtside.jpg", imgwtside)</syntaxhighlight>

=={{header|Kotlin}}==

<~~lang~~ scala>// version 1.1.2

<syntaxhighlight lang=scala>// version 1.1.2

import java.awt.Graphics

Line 2,216:

b.isVisible = true

Thread(b).start()

}</~~lang~~>

}</syntaxhighlight>

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

<~~lang~~ lb>'[RC]Brownian motion tree

<syntaxhighlight lang=lb>'[RC]Brownian motion tree

nomainwin

dim screen(600,600)

Line 2,301:

timer 0

close #1

end</~~lang~~>

end</syntaxhighlight>

=={{header|Locomotive 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.

<~~lang~~ locobasic>10 MODE 1:DEFINT a-z:RANDOMIZE TIME:np=10000

<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,321:

1010 x=RND*640

1020 y=RND*400

1030 RETURN</~~lang~~>

1030 RETURN</syntaxhighlight>

=={{header|Lua}}==

Line 2,328:

[[Grayscale image#Lua]],

[[Basic bitmap storage#Lua]].

<~~lang~~ lua>function SetSeed( f )

<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,394:

end

Write_PPM( "brownian_tree.ppm", ConvertToColorImage(f) )</~~lang~~>

Write_PPM( "brownian_tree.ppm", ConvertToColorImage(f) )</syntaxhighlight>

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

Line 2,400:

Loose {{trans|D}}

<~~lang~~ Mathematica>canvasdim = 1000;

<syntaxhighlight 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}]</~~lang~~>

MatrixPlot[canvas,FrameTicks->None,ColorFunction->"DarkRainbow",ColorRules->{0 -> None}]</syntaxhighlight>

Result:

Line 2,434:

<~~lang~~ Nim>import random

<syntaxhighlight lang=Nim>import random

import imageman

Line 2,476:

# Save into a PNG file.

image.savePNG("brownian.png", compression = 9)</~~lang~~>

image.savePNG("brownian.png", compression = 9)</syntaxhighlight>

=={{header|OCaml}}==

<~~lang~~ ocaml>let world_width = 400

<syntaxhighlight lang=ocaml>let world_width = 400

let world_height = 400

let num_particles = 20_000

Line 2,528:

dla ~world;

to_pbm ~world;

;;</~~lang~~>

;;</syntaxhighlight>

better to compile to native code to get a faster program:

Line 2,538:

<~~lang~~ octave>function r = browniantree(xsize, ysize = xsize, numparticle = 1000)

<syntaxhighlight 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</~~lang~~>

jpgwrite("browniantree.jpg", r, 100); % image package</syntaxhighlight>

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

Line 2,573:

===Plotting helper functions===

<~~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));

}

</~~lang~~>

</syntaxhighlight>

===Version #1. Translated from AutoHotkey.===

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

<~~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

</~~lang~~>

</syntaxhighlight>

Line 2,653:

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

<~~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

</~~lang~~>

</syntaxhighlight>

Line 2,696:

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

<~~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

</~~lang~~>

</syntaxhighlight>

Line 2,743:

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

<~~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

</~~lang~~>

</syntaxhighlight>

Line 2,820:

Code runs until the tree reached specified radius. Output is written to "test.eps" of wherever the current directory is.

<~~lang~~ perl>sub PI() { atan2(1,1) * 4 } # The, er, pi

<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,975:

}

write_eps;</~~lang~~>

write_eps;</syntaxhighlight>

=={{header|Phix}}==

As-is, runs in about 2s, but can be very slow when bigger or (even worse) resize-able.

-- demo\rosetta\BrownianTree.exw

include pGUI.e

Line 3,043:

IupClose()

end if

=={{header|PicoLisp}}==

<~~lang~~ PicoLisp>(load "@lib/simul.l")

<syntaxhighlight lang=PicoLisp>(load "@lib/simul.l")

(de brownianTree (File Size Cnt)

Line 3,064:

(for This L

(prin (if (: pix) 1 0)) )

(prinl) ) ) ) )</~~lang~~>

(prinl) ) ) ) )</syntaxhighlight>

Use:

<pre>(brownianTree "img.pbm" 300 9000)

Line 3,070:

=={{header|Processing}}==

<~~lang~~ java>boolean SIDESTICK = false;

<syntaxhighlight lang=java>boolean SIDESTICK = false;

boolean[][] isTaken;

Line 3,108:

noLoop();

}

}</~~lang~~>

}</syntaxhighlight>

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

Line 3,114:

<~~lang~~ python>SIDESTICK = False

<syntaxhighlight lang=python>SIDESTICK = False

def setup() :

Line 3,144:

if frameCount > width * height:

noLoop()</~~lang~~>

noLoop()</syntaxhighlight>

=={{header|PureBasic}}==

<~~lang~~ PureBasic>#Window1 = 0

<syntaxhighlight lang=PureBasic>#Window1 = 0

#Image1 = 0

#ImgGadget = 0

Line 3,185:

Event = WaitWindowEvent()

Until Event = #PB_Event_CloseWindow

EndIf</~~lang~~>[[File:BrownianTree.pb.png]]

EndIf</syntaxhighlight>[[File:BrownianTree.pb.png]]

=={{header|Python}}==

<~~lang~~ python>import pygame, sys, os

<syntaxhighlight 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()</~~lang~~>

pygame.display.flip()</syntaxhighlight>

=={{header|R}}==

Line 3,313:

file could be very slow too. Actually, plotv2() shows almost "pure" plotting time.

# 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");

}

</~~lang~~>

</syntaxhighlight>

===Versions #1- #4.===

Line 3,361:

====Version #1.====

# Generate and plot Brownian tree. Version #1.

# 7/27/16 aev

Line 3,395:

}

gpBrownianTree1(400,15000,"red", "BT1R", "Brownian Tree v.1", 1);

</~~lang~~>

</syntaxhighlight>

Line 3,408:

====Version #2.====

# 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)

</~~lang~~>

</syntaxhighlight>

Line 3,467:

====Version #3.====

# 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);

</~~lang~~>

</syntaxhighlight>

Line 3,521:

====Version #4.====

# Generate and plot Brownian tree. Version #4.

# 7/27/16 aev

Line 3,563:

}

gpBrownianTree4(400,15000,"navy", "BT4R", "Brownian Tree v.4", 1);

</~~lang~~>

</syntaxhighlight>

Line 3,577:

=={{header|Racket}}==

<~~lang~~ racket>#lang racket

<syntaxhighlight lang=racket>#lang racket

(require 2htdp/image)

Line 3,700:

img

(save-image img "brownian-tree.png")</~~lang~~>

(save-image img "brownian-tree.png")</syntaxhighlight>

=={{header|Raku}}==

Line 3,711:

<lang ~~perl6~~>constant size = 100;

<syntaxhighlight lang=raku line>constant size = 100;

constant particlenum = 1_000;

Line 3,777:

}

display;</~~lang~~>

display;</syntaxhighlight>

=={{header|REXX}}==

Line 3,786:

Program note:   to keep things simple, the (system) command to clear the screen was hard-coded as   '''CLS'''.

<~~lang~~ rexx>/*REXX program animates and displays Brownian motion of dust in a field (with one seed).*/

<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,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</~~lang~~>

end /*x*/; return</syntaxhighlight>

This REXX program makes use of   '''scrsize'''   REXX program (or BIF) which is used to determine the screen size of the terminal (console).

Line 3,986:

=={{header|Ring}}==

<~~lang~~ ring>

# Project : Brownian tree

Line 4,085:

return number(str)

</syntaxhighlight>

</lang>

Output:

Line 4,092:

=={{header|Ruby}}==

<~~lang~~ ruby>require 'rubygems'

<syntaxhighlight lang=ruby>require 'rubygems'

require 'RMagick'

Line 4,147:

draw.draw img

img.write "brownian_tree.bmp"</~~lang~~>

img.write "brownian_tree.bmp"</syntaxhighlight>

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

[[File:BrownianTreeKokenge.png|thumb|right|]]

<~~lang~~ runbasic>numParticles = 3000

<syntaxhighlight lang=runbasic>numParticles = 3000

dim canvas(201,201)

graphic #g, 200,200

Line 4,171:

next i

render #g

#g "flush"</~~lang~~>

#g "flush"</syntaxhighlight>

=={{header|Rust}}==

Line 4,177:

<~~lang~~ rust>

extern crate image;

extern crate rand;

Line 4,281:

}

}</~~lang~~>

}</syntaxhighlight>

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===

<~~lang~~ Scala>import java.awt.Graphics

<syntaxhighlight lang=Scala>import java.awt.Graphics

import java.awt.image.BufferedImage

Line 4,336:

new Thread(new BrownianTree).start()

}</~~lang~~>

}</syntaxhighlight>

=={{header|Scheme}}==

<~~lang~~ scheme>; Save bitmap to external file

<syntaxhighlight 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")</~~lang~~>

(save-pbm bitmap "brownian-tree.pbm")</syntaxhighlight>

[[File:Scheme-guile-brownian-tree-large.png]]

Line 4,454:

The program below generates a small brownian tree. You can watch how it grows.

<~~lang~~ seed7>$ include "seed7_05.s7i";

<syntaxhighlight lang=seed7>$ include "seed7_05.s7i";

include "draw.s7i";

include "keybd.s7i";

Line 4,506:

genBrownianTree(SIZE, 20000);

readln(KEYBOARD);

end func;</~~lang~~>

end func;</syntaxhighlight>

Original source: [http://seed7.sourceforge.net/algorith/graphic.htm#brownian_tree]

Line 4,512:

=={{header|SequenceL}}==

'''SequenceL Code:'''

<~~lang~~ sequencel>import <Utilities/Random.sl>;

<syntaxhighlight 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));</~~lang~~>

(World: world, Rand: seedRandom(seed), Point: (X: worldSize / 2, Y: worldSize / 2));</syntaxhighlight>

'''C++ Driver Code:'''

<~~lang~~ c>#include <time.h>

<syntaxhighlight lang=c>#include <time.h>

#include <cstdlib>

#include "CImg.h"

Line 4,605:

return 0;

}</~~lang~~>

}</syntaxhighlight>

Line 4,612:

=={{header|Sidef}}==

<~~lang~~ ruby>const size = 100

<syntaxhighlight lang=ruby>const size = 100

const mid = size>>1

const particlenum = 1000

Line 4,689:

}

display()</~~lang~~>

display()</syntaxhighlight>

<pre>

Line 4,731:

</pre>

=={{header|Simula}}==

<~~lang~~ simula>BEGIN

<syntaxhighlight lang=simula>BEGIN

INTEGER NUM_PARTICLES;

INTEGER LINES, COLUMNS;

Line 4,797:

END;

END.</~~lang~~>

END.</syntaxhighlight>

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.

<~~lang~~ basic> 10 DIM A$(20,20)

<syntaxhighlight 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</~~lang~~>

240 NEXT I</syntaxhighlight>

Screenshot [http://www.edmundgriffiths.com/zx81browniantree.jpg here].

Line 4,881:

=={{header|Tcl}}==

<~~lang~~ tcl>package require Tcl 8.5

<syntaxhighlight lang=tcl>package require Tcl 8.5

package require Tk

Line 4,932:

update

makeBrownianTree 1000

brownianTree write tree.ppm</~~lang~~>

brownianTree write tree.ppm</syntaxhighlight>

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

<~~lang~~ ti83b>:StoreGDB 0

<syntaxhighlight lang=ti83b>:StoreGDB 0

:ClrDraw

:FnOff

Line 4,961:

:End

:Pause

:RecallGDB 0</~~lang~~>

:RecallGDB 0</syntaxhighlight>

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

Windows Forms Application.

<~~lang~~ vbnet>

Imports System.Drawing.Imaging

Line 5,096:

End Sub

End Class

</syntaxhighlight>

</lang>

[[File:SH_BrownianTree.jpg]]

Line 5,104:

As you'd expect, not very fast so have halved Go's parameters to draw the tree in around 45 seconds.

<~~lang~~ ecmascript>import "graphics" for Canvas, Color

<syntaxhighlight 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)</~~lang~~>

var Game = BrownianTree.new(200, 150, 7500)</syntaxhighlight>

=={{header|XPL0}}==

[[File:BrownXPL0.gif|right]]

<~~lang~~ XPL0>include c:\cxpl\codes; \intrinsic 'code' declarations

<syntaxhighlight 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

];

]</~~lang~~>

]</syntaxhighlight>

=={{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]]

<~~lang~~ zkl>w:=h:=400; numParticles:=20_000;

<syntaxhighlight 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</~~lang~~>

bitmap.writeJPGFile("brownianTree.zkl.jpg"); // the final image</syntaxhighlight>

=={{header|ZX Spectrum 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.

<~~lang~~ zxbasic>10 LET np=1000

<syntaxhighlight 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]]