Brownian tree: Difference between revisions

{{Wikipedia|Brownian_tree}}

{{task|Fractals}}

 

 

 

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

Takes a little while to run, be patient.

Requires the [http://www.autohotkey.com/forum/topic32238.html GDI+ Standard Library by Tic]

Process, Priority,, high

size := 400

Random, r, min, max

return r

 

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

{{works with|BBC BASIC for Windows}}

SIZE = 400

UNTIL FALSE

[[File:Brownian_BBC.gif]]

=={{header|C}}==

{{libheader|FreeImage}}

#include <stdlib.h>

#include <time.h>

FreeImage_Save(FIF_BMP, img, "brownian_tree.bmp", 0);

FreeImage_Unload(img);

 

'''Bold text'''

{{trans|D}}

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

#include <stdlib.h>

#include <time.h>

}

return 0;

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

 

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

[[File:brownianTree_cpp.png|300px]]

 

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

#include <iostream>

#include <string>

return 0;

}

 

 

 

 

=={{header|D}}==

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

import core.stdc.stdio, std.random, grayscale_image;

 

data[] += 255;

Image!ubyte.fromData(data, side, side).savePGM("brownian_tree.pgm");

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

SIZE = 256;

NUM_PARTICLES = 1000;

FreeAndNil(B);

end;

 

=={{header|Fantom}}==

 

using fwt

using gfx

}

}

=={{header|Fortran}}==

{{works with|Fortran|95 and later}}

For RCImageBasic and RCImageIO, see [[Basic bitmap storage/Fortran]] and [[Write ppm file#Fortran]]

 

use RCImageBasic

use RCImageIO

end subroutine draw_brownian_tree

 

=={{header|Gnuplot}}==

{{Works with|gnuplot|5.0 (patchlevel 3) and above}}

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

## plotff.gp 11/27/16 aev

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

plot dfn using 1:2 with points pt 7 ps 0.5 lc @clr

set output

 

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

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

 

## BTff.gp 11/27/16 aev

## Plotting 6 Brownian tree pictures.

ttl = "Brownian Tree v.#4-3"

load "plotff.gp"

{{Output}}

<pre>

BT1gp.png, BT2gp.png, BT3gp.png, BT41gp.png, BT43gp.png, BT43gp.png.

</pre>

=={{header|Go}}==

[[file:GoTree.png|right|thumb|Output png]]

 

Using standard image library:

 

import (

}

return false

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

 

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

}

return false

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

 

import Control.Monad.ST

import Data.STRef

liftM2 (,) [1 .. width - 2] [0, height - 1]

off = black

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

 

 

procedure main() # brownian tree

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

return pt

 

{{libheader|Icon Programming Library}}

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

 

seed=. ?x

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

end.

field

 

Example use:

 

 

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

import java.awt.image.BufferedImage;

import java.util.*;

}

}

 

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.

import java.awt.image.BufferedImage;

import java.io.File;

}

}

[http://switchb.org/kpreid/2010/brownian-tree/ Live version] <!-- If changing this example, add note this link is outdated -->

var canvas = document.getElementById(canvasId);

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

}, 1);

 

 

<head>

<script src="brownian.js"></script>

<div id="message"></div>

</body>

=={{header|Julia}}==

 

 

 

end

end

end

end

 

 

 

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

nomainwin

dim screen(600,600)

timer 0

close #1

=={{header|Lua}}==

The output is stored in as a ppm-image. The source code of these output-functions is located at

[[Grayscale image#Lua]],

[[Basic bitmap storage#Lua]].

for i = 1, #f[1] do -- the whole boundary of the scene is used as the seed

f[1][i] = 1

end

end

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

n = 0.35*canvasdim^2;

canvas = ConstantArray[0, {canvasdim, canvasdim}];

{i, (particle + ds), MatrixPlot@canvas}

]

 

Result:

 

[[File:BrownianTree.png]]

 

=={{header|OCaml}}==

{{trans|D}}

 

let world_height = 400

let num_particles = 20_000

dla ~world;

to_pbm ~world;

 

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

<pre>$ ocamlopt -o brownian_tree.opt brownian_tree.ml

$ ./brownian_tree.opt | display -</pre>

=={{header|Octave}}==

{{trans|C}}

 

r = zeros(xsize, ysize, "uint8");

r(unidrnd(xsize), unidrnd(ysize)) = 1;

r = browniantree(200);

r( r > 0 ) = 255;

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

All versions #1 - #4 are based on using 4 small plotting helper functions, which are allowing to unify

 

===Plotting helper functions===

\\ 2 old plotting helper functions 3/2/16 aev

\\ insm(): Check if x,y are inside matrix mat (+/- p deep).

plothraw(Vec(vx),Vec(vy));

}

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

{{trans|AutoHotkey}}

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

 

\\ Brownian tree v.#1. Translated from AutoHotkey

\\ 3/8/2016, upgraded 11/27/16 aev

{BrownianTree1(400,15000,"c:\\pariData\\BTAH1.dat");

plotff("c:\\pariData\\BTAH1.dat");} \\BTAH1.png

 

{{Output}}

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

 

\\ Brownian tree v.#2. Translated from Octave

\\ 3/8/2016, upgraded 11/27/16 aev

{BrownianTree2(1000,3000,"c:\\pariData\\BTOC1.dat");

plotff("c:\\pariData\\BTOC1.dat");} \\BTOC1.png

 

{{Output}}

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

 

\\ Brownian tree v.#3. Translated from Seed7

\\ 3/8/2016, upgraded 11/27/16 aev

{BrownianTree3(400,5000,"c:\\pariData\\BTSE1.dat");

plotff("c:\\pariData\\BTSE1.dat");} \\BTSE1.png

 

{{Output}}

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

 

\\ Brownian tree v.#4. Translated from PureBasic

\\ 3/8/2016, upgraded 11/27/16 aev

{BrownianTree4(200,4000,"c:\\pariData\\BTPB3.dat",2,5);

plotff("c:\\pariData\\BTPB3.dat");} \\BTPB3.png

 

{{Output}}

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

 

 

# At each step, move this much towards center. Bigger numbers help the speed because

# particles are less likely to wander off, but greatly affects tree shape.

# Should be between 0 and 1 ish. Set to 0 for pain.

 

my @particles = map([ map([], 0 .. 2 * STOP_RADIUS) ], 0 .. 2 * STOP_RADIUS);

push @{ $particles[STOP_RADIUS][STOP_RADIUS] }, [0, 0];

 

sub dist2 {

my ($dx, $dy) = ($_[0][0] - $_[1][0], $_[0][1] - $_[1][1]);

$dx * $dx + $dy * $dy

 

my $count;

my $a = rand(2 * PI);

my $p = [ $r_start * cos($a), $r_start * sin($a) ];

}

print STDERR "$count $max_dist/@{[int($r_start)]}/@{[STOP_RADIUS]}\r" unless $count% 7;

sub write_eps {

my $size = 128;

if ($p < 1) {

$size = STOP_RADIUS * 1.05;

}

my $hp = $p / 2;

 

 

for (@particles) {

}

 

 

=={{header|Phix}}==

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

=={{header|PicoLisp}}==

 

(de brownianTree (File Size Cnt)

(for This L

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

Use:

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

(call 'display "img.pbm")</pre>

=={{header|Processing}}==

boolean[][] isTaken;

 

void setup() {

size(512, 512);

isTaken = new boolean[width][height];

isTaken[width/2][height/2] = true;

 

void draw() {

);

}

}

}

 

=={{header|PureBasic}}==

#Image1 = 0

#ImgGadget = 0

Event = WaitWindowEvent()

Until Event = #PB_Event_CloseWindow

=={{header|Python}}==

{{libheader|pygame}}

from pygame.locals import *

from random import randint

while True:

input(pygame.event.get())

=={{header|R}}==

All versions #1 - #4 are based on using 2 small plotting helper functions, which are allowing to unify

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;

cat(" *** END:", date(), "\n");

}

 

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

 

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

# Generate and plot Brownian tree. Version #1.

# 7/27/16 aev

}

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

 

{{Output}}

 

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

# Generate and plot Brownian tree. Version #2.

# 7/27/16 aev

## Rename BT2R.dmp to BT2aR.dmp

plotv2("BT2aR", "orange", "Brownian Tree v.2a", 640)

 

{{Output}}

 

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

# Generate and plot Brownian tree. Version #3.

# 7/27/16 aev

}

gpBrownianTree3(400,5000,"dark green", "BT3R", "Brownian Tree v.3", 1);

 

{{Output}}

 

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

# Generate and plot Brownian tree. Version #4.

# 7/27/16 aev

}

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

 

{{Output}}

*** END: Mon Sep 05 11:50:47 2016

</pre>

=={{header|Racket}}==

(require 2htdp/image)

 

 

img

 

=={{header|REXX}}==

A large part of the REXX program's prologue was to handle the various options. <br>

 

With a little more REXX code, a &nbsp; ''petri dish'' &nbsp; option could be added, that is, when a particle hits the edge, <br>

 

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

mote = '·' /*character for a loose mote (of dust).*/

hole = ' ' /* " " an empty spot in field.*/

seedPos = 0 /*if =0, then use middle of the field.*/

/* " -1, " " a random placement.*/

/*otherwise, place the seed at seedPos.*/

/*use RANDSEED for RANDOM repeatability*/

if datatype(randSeed,'W') then call random ,,randSeed /*if an integer, use the seed.*/

/* [↑] set the first random number. */

parse var seedAt xs ys . /*obtain the X and Y seed coördinates*/

 

 

 

 

 

 

 

 

=={{header|Ruby}}==

{{libheader|RMagick}}

require 'RMagick'

 

 

draw.draw img

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

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

dim canvas(201,201)

graphic #g, 200,200

next i

render #g

=={{header|Rust}}==

{{trans|D}}

extern crate image;

extern crate rand;

 

use image::ColorType;

use std::cmp::{min, max};

use std::env;

use std::path::Path;

use std::process;

 

fn help() {

width as u32,

height as u32,

Err(e) => println!("Error writing output image:\n{}", e),

Ok(_) => println!("Output written to:\n{}", output_path.to_str().unwrap()),

let mut field_base: Vec<_> = raw.as_mut_slice().chunks_mut(width).collect();

// Addressable 2d vector

 

// Seed mote

field[width / 2][height / 2] = 1;

 

let mut rng = rand::thread_rng();

 

}

 

 

// Increment field value when motes spawn on top of the structure

loop {

let contacts = field[x - 1][y - 1] + field[x][y - 1] + field[x + 1][y - 1] +

 

if contacts > 0 {

break;

} else {

if xw < 1 || xw >= (width as i32 - 1) || yw < 1 || yw >= (height as i32 - 1) {

break;

}

}

<center>[[File:Rust-Brownian-512-20k.png]]</center>

 

=={{header|Scheme}}==

{{works with|Guile}}

(define (save-pbm bitmap filename)

(define f (open-output-file filename))

 

; Save to a portable bitmap file

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

 

include "draw.s7i";

include "keybd.s7i";

world[py][px] := 1;

rect(SCALE * pred(px), SCALE * pred(py), SCALE, SCALE, white);

bumped := TRUE;

else

until bumped;

end for;

 

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

=={{header|SequenceL}}==

'''SequenceL Code:'''<br>

import <Utilities/Sequence.sl>;

 

j within 1 ... worldSize;

in

 

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

{{libheader|CImg}}

#include <cstdlib>

#include "CImg.h"

 

return 0;

 

{{out}}

[http://i.imgur.com/OrB9tLI.gifv Output Video]

 

=={{header|Tcl}}==

{{libheader|Tk}}

package require Tk

 

update

makeBrownianTree 1000

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

:ClrDraw

:FnOff

:End

:Pause

 

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

Windows Forms Application.

 

Imports System.Drawing.Imaging

 

End Sub

End Class

{{out|Final output}}

[[File:SH_BrownianTree.jpg]]

 

=={{header|XPL0}}==

[[File:BrownXPL0.gif|right]]

def W=128, H=W; \width and height of field

int X, Y;

if KeyHit then [SetVid(3); quit]; \restore text mode

];

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

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

[[File:Brownian.zkl.jpg|250px|thumb|right]]

bitmap:=PPM(w+2,h+2,0); // add borders as clip regions

 

if(touching(x,y,bitmap)){

bitmap[x,y]=c;

numParticles-=1;

break;

}

}

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

20 PAPER 0: INK 4: CLS

30 PLOT 128,88

1020 LET y=RND*174

1030 RETURN