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

</pre>

 

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

 

{{works with|BBC BASIC for Windows}}

OFF

NEXT x%

old&() = new&()

Output:

<p>

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

 

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

 

enum { empty = 0, tree = 1, fire = 2 };

show: printf("\033[H");

for_y {

printf("\033[E");

}

 

evolve(w, h);

 

 

 

namespace ForestFire

{

{

{

 

 

uint generation = 0;

do

{

state = StepForestFire(state, f, p);

 

{

{

switch (state[y, x])

{

case CellState.Empty:

break;

case CellState.Tree:

break;

case CellState.Burning:

break;

}

}

}

}

 

{

// Create our state array, initialize all indices as Empty, and return it.

}

 

{

/* Clone our old state, so we can write to our new state

* without changing any values in the old state. */

 

 

{

{

/*

* If it's burning, set it to empty.

*/

{

case CellState.Empty:

break;

case CellState.Tree:

break;

case CellState.Burning:

break;

}

}

 

{

// Check each cell within a 1 cell radius for the specified value.

{

{

continue;

 

return true;

}

 

return false;

}

}

 

 

 

 

=={{header|Clojure}}==

(def burn-prob 0.1)

(def new-tree-prob 0.5)

(forest-fire)

 

 

example output

(:grass :fire! :fire! :burnt :tree))

</pre>

 

=={{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 Cell : char { empty=' ', tree='T', fire='#' }

 

}

 

 

 

}

 

 

{{out}}

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

 

===Graphical Version===

 

 

 

immutable white = Color(255, 255, 255),

void nextState(ref World world, ref World nextWorld,

ref Xorshift rnd, Image img) {

immutable nr = world.length;

immutable nc = world[0].length;

img.putPixel(c, r, white);

break;

 

img.putPixel(c, r, green);

 

if ((r + rowShift) >= 0 && (r + rowShift) < nr &&

(c + colShift) >= 0 && (c + colShift) < nc &&

world[r + rowShift][c + colShift] == Cell.burning) {

nextWorld[r][c] = Cell.burning;

}

 

 

img.putPixel(c, r, red);

break;

}

void main() {

auto rnd = Xorshift(1);

foreach (ref el; row)

 

auto w= new SimpleWindow(world.length,world[0].length,"ForestFire");

 

w.eventLoop(1, {

nextState(world, nextWorld, rnd, img);

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

});

 

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

 

 

 

 

 

 

 

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