Forest fire: Difference between revisions

{{task|Games}}{{wikipedia|Forest-fire model}}[[Category:Cellular automata]]

Implement the Drossel and Schwabl definition of the [[wp:Forest-fire model|forest-fire model]].

 

 

# A burning cell turns into an empty cell

# A tree will burn if at least one neighbor is burning

 

 

At the beginning, populate the lattice with empty and tree cells according to a specific probability (e.g. a cell has the probability 0.5 to be a tree). Then, let the system evolve.

 

 

=={{header|6502 Assembly}}==

; SYS 17239 or CALL 17239

 

; end COMMODORE 64 specific

 

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

Put (Forest);

end loop;

Sample output:

<pre style="height:30ex;overflow:scroll">

Y YYY# # YY Y # #Y

</pre>

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

===Textual version===

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-1.18.0/algol68g-1.18.0-9h.tiny.el5.centos.fc11.i386.rpm/download 1.18.0-9h.tiny].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

f prob = 0.01, # new combustion probability #

p prob = 0.01; # tree creation probability #

printf(($gl$, 2 UPB world * "-"))

OD

Output:

<pre>

This implementation uses AutoHotkey's pseudo-arrays to contain each cell.

The size of the (square) map, probabilities, and characters which correspond to burning, tree, or empty can be edited at the beginning of the script.

; The array Frame1%x%_%y% holds the current frame. frame2%x%_%y%

; is then calculated from this, and printed. frame2 is then copied to frame1.

return 0

}

Sample Output using the default settings:

<pre style="height:35ex;overflow:scroll;">

 

=={{header|BASIC}}==

==={{header|BASIC256}}===

[[File:Forest fire BASIC-256.gif|right|thumb|Forest fire animation: p=0.03, p/f=1000]]

 

dim f(N+2,M+2) # 1 tree, 0 empty, 2 fire

next y

next x

 

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

{{works with|BBC BASIC for Windows}}

OFF

NEXT x%

old&() = new&()

Output:

<p>

[[File:Forestbbc.gif|200px]]

 

==={{header|FreeBASIC}}===

'Program code based on BASIC256 from Rosettacode website

'http://rosettacode.org/wiki/Forest_fire#BASIC256

 

 

 

 

 

Print " Welcome to Forest Fire"

 

 

Print " Press 'space bar' to continue/pause, ESC to stop "

 

 

 

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

dim preGen(200,200)

dim newGen(200,200)

next x

next gen

[[File:ForestFire.png]]

 

=={{header|C}}==

{{libheader|SDL}}

 

#include <stdlib.h>

#include <stdint.h>

free(field[0]); free(field[1]);

exit(EXIT_SUCCESS);

===Console version===

C99. Uncomment srand() for variaty, usleep() for slower speed.

#include <stdlib.h>

#include <unistd.h>

 

evolve(w, h);

 

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

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

#include <windows.h>

#include <string>

}

//--------------------------------------------------------------------------------------------------

 

 

 

 

 

 

 

 

 

 

 

}

 

 

 

 

}

}

}

 

 

}

}

}

 

 

 

 

=={{header|Clojure}}==

(def burn-prob 0.1)

(def new-tree-prob 0.5)

(forest-fire)

 

 

example output

=={{header|COBOL}}==

{{works with|OpenCOBOL}}

PROGRAM-ID. forest-fire.

 

COMPUTE rand-num =

FUNCTION MOD(FUNCTION RANDOM * 100000, 10000)

 

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

(defvar *prob-t* 0.5)

(defvar *prob-f* 0.1)

(progn (format t "~%------ Generation ~d ------~%" (1+ i))

(print-forest forest)))))

Example results:

CL-USER>(simulate *forest* 5)

------ Initial forest ------

TTT TTT T

NIL

 

=={{header|D}}==

===Textual Version===

 

enum treeProb = 0.55; // Original tree probability.

alias World = Cell[][];

 

pure nothrow @safe @nogc {

foreach (immutable rowShift; -1 .. 2)

 

void nextState(in World world, World nextWorld) /*nothrow*/ @safe /*@nogc*/ {

final switch (elem) with (Cell) {

case empty:

world.swap(nextWorld);

}

{{out}}

<pre> T T T#TT T TT TT TTTT TT TTT T TT T# T T TT TT TTTTT

===Graphical Version===

{{libheader|simpledisplay}}

simpledisplay;

 

painter.drawImage(Point(0, 0), img);

});

 

=={{header|Déjà Vu}}==

set :p 0.004

#chance of spontaneous tree combustion

step

 

{{out}}

<pre>T.T.T...T..T..TT.T.T.

..TTTB....TTTTTT..T.T

TT..T....T..T..TTTT..</pre>

 

=={{header|Erlang}}==

Not even text graphics. Notice the use of random:seed/1 when creating a tree. Without it all calls to random:uniform/1 gave the same result for each tree.

 

-module( forest_fire ).

 

tree_init( Tree_probalility, Random ) when Tree_probalility > Random -> tree;

tree_init( _Tree_probalility, _Random ) -> empty.

 

{{out}}

{burning,{5,5}}]

</pre>

 

=={{header|F_Sharp|F#}}==

This implementation can be compiled or run in the interactive F# shell.

open System.Diagnostics

open System.Drawing

[<EntryPoint>]

let main args = ForestFire.main args

[[File:ForestFire-FSharp.png]]

 

=={{header|Fortran}}==

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

 

implicit none

 

end subroutine forestfire_print

 

 

use ForestFireModel

implicit none

call forestfire_destroy(f)

 

 

=={{header|Go}}==

Text. The program prints the configuration, waits for the Enter key, and prints the next. It makes a pretty good animation to just hold down the Enter key.

 

import (

}

}

 

=={{header|Haskell}}==

 

instance Show Cell where

evolveForest :: Int -> Int -> Int -> IO ()

evolveForest m n k = do

fs <- replicateM s randomCell

let nextState xs = do

ts <- replicateM s randomChance

vs <- replicateM s randomChance

return $ zipWith3 rv xs ts vs

 

>>>>>> 2:

>>>>>> 3:

 

=={{header|Icon}} and {{header|Unicon}}==

[[File:Forestfire-Unicon.png|400px|thumb|right|Forest fire 400 x 400 rounds=500 p.initial=0.100000 p/f=0.010000/0.000200 fps=1.495256]]

 

$define EDGE 0

procedure probability(P) #: succeed with probability P

if ?0 <= P then return

 

{{libheader|Icon Programming Library}}

 

=={{header|J}}==

dims =:10 10

 

smoutput ' #o' {~ forest=. step forest

end.

 

Example use:

 

##### #

## # #

o #

 

Note that I have used an artificially small grid here, and that I ran this several times until I could find one that had a fire from the start. Also, the current revision of this code does not show the starting state, though that would be easily changed.

 

Finally note that the grid size includes the one cell "border" which are blank. If the border cells are meant to be outside of the represented dimensions, you can add 2 to them (or change the code to do so).

 

=={{header|Java}}==

{{works with|Java|1.5+}}

===Text===

import java.util.LinkedList;

import java.util.List;

processNPrint(land, 10);

}

===Graphics===

See: [[Forest fire/Java/Graphics]]

 

 

 

 

 

 

 

 

X: 50,

Y: 50,

afterLoad(forest);

}, 100);

 

To actually see it work we need a small demo page with HTML5 compliant code:

 

<html>

<head>

</body>

</html>

 

The output is a (mostly fluent) animation of the area.

 

 

=={{header|Lua}}==

This program uses the Lua Curses library for graphics, although changing the code to avoid such dependency is easy.

-- ForestFire automaton implementation

-- Rules: at each step:

socket.sleep(naptime)

until false

 

Mathematica is good at working with cellular automata -- especially 2-color 1-dimensional cellular automata. The automaton function is awkward yet very powerful. This code implements a 3-color 2-dimensional cellular automaton with 9-cell neighbourhoods using a custom cell evolution function. There is probably a rule number specification that can replace the custom evolution function and make this simpler and faster. But this works well enough. The last line of code plots the state of the forest after the 300th step.

 

evolve[nbhd_List, k_] := 2 /; nbhd[[2, 2]] == 1 && Max@nbhd == 2 (*near_burning&nonempty->burning*)

evolve[nbhd_List, k_] := RandomChoice[{f, 1 - f} -> {2, nbhd[[2, 2]]}] /; nbhd[[2, 2]] == 1 && Max@nbhd < 2 (*spontaneously combusting tree*)

r = 100; c = 100; p = 10^-2; f = 10^-4;

init = RandomInteger[BernoulliDistribution[0.05], {r, c}];

[[File:ForestFire-Mathematica.png]]

 

=={{header|MATLAB}} / {{header|Octave}}==

% Forest fire

if nargin<4;

G = G + (F==3); % empty after burn

F = G;

 

=={{header|Nim}}==

{{trans|C}}

randomize()

 

 

const

 

 

# Set the size

var w, h: int

if paramCount() >= 2:

if w <= 0: w = 30

if h <= 0: h = 30

 

for y in max(a[0], 0) .. min(b[0], h-1):

for x in max(a[1], 0) .. min(b[1], w-1):

 

# Initialize

 

while true:

stdout.write "\e[H"

if x == 0: stdout.write "\e[E"

stdout.flushFile

 

case univ[y][x]

of Fire:

univNew[y][x] = Empty

of Empty:

of Tree:

univ = univNew

 

=={{header|OCaml}}==

This example uses a curses display (with the [http://www.nongnu.org/ocaml-tmk/ ocaml-curses] bindings).

 

 

let ignite_prob = 0.02

Unix.sleep 1;

done;

 

You can execute this script with:

$ ocaml unix.cma -I +curses curses.cma forest.ml

 

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

my(m=matsize(M)[1],n=matsize(M)[2]);

matrix(m,n,i,j,

while(1,print(M=step(M,p,f)))

};

 

=={{header|Perl}}==

use 5.10.0;

 

}

 

 

}

}

}

}

}

}

 

=={{header|PicoLisp}}==

 

(scl 3)

(put This @ T)

(=: burn)

Use:

<pre>(forestFire 26 0.5 0.01 0.001)</pre>

 

=={{header|PostScript}}==

%%BoundingBox: 0 0 400 400

 

 

1000 { drawforest showpage iter } repeat

 

=={{header|Python}}==

Just hit return to advance the simulation, or enter an integer to advance that integer amount of 'frames'.

Entering 'p' will print the grid, and 'q' will quit. A summary of the grids status is printed before each prompt for input.

Forest-Fire Cellular automation

See: http://en.wikipedia.org/wiki/Forest-fire_model

break

grid = gnew(grid)

 

'''Sample output'''

 

=={{header|Racket}}==

(require 2htdp/universe)

(require 2htdp/image)

[to-draw render-forest]))

 

 

I'll tweak with the parameters for a bit, and when I have some nice

photos I'll post them!