Forest fire: Difference between revisions

 

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

'written for FreeBASIC

'Program code based on BASIC256 from Rosettacode website

Print " You entered ESC - goodbye "

Print " Press any key to exit "

 

==={{header|GFA Basic}}===

 

width%=80

height%=50

CLOSEW 1

RETURN

 

==={{header|PureBasic}}===

; This may likely be due to the graphic driver used in the

; 2D-function Plot().

ForEver

EndIf

[[Image:Forest_Fire_in_PureBasic,_frame_300.png]]

 

==={{header|REALbasic}}===

This example puts all of the forestry logic into a Thread class. This allows the UI to remain responsive while the Thread does all the work in the background. We create a Thread by subclassing the Thread object in the IDE, in this case creating ''forestfire'' as a subclass of the Thread object and put the following code in its ''Run()'' event:

Sub Run()

//Handy named constants

Wend

End Sub

As you can see, this Thread is expecting a Window object called Window1 with several other objects within it. The IDE will automatically create a Window object called Window1 when a new GUI application is created. Our Window1 has 5 objects (widgets) in it: a Canvas (for displaying graphics), three sliders, and a pushbutton.

Sub Open()

//First method to run on the creation of a new Window. We instantiate an instance of our forestFire thread and run it.

stop = True

End Sub

[[Image:ForestFireRB.PNG]]

 

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

dim preGen(200,200)

dim newGen(200,200)

next x

next gen

[[File:ForestFire.png]]

 

 

(2) this program differs from most BASIC examples on Rosetta Code, but resembles most real BASIC programs of more than about 20 lines, in that the line numbers do not always go up smoothly in multiples of ten.

20 DIM N$(20,30)

30 LET INIT=.5

1030 LET I$=I$+CHR$ (128+CODE S$(K))

1040 NEXT K

{{out}}

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

This program sits behind a Windows form with fixed borders, the only component of which is a timer (named Timer1, set to something like 50 or 100ms depending on the speed the user wants to see it). Other constant values (the probabilities and the window dimensions) can be set at the top of the code.

 

Private _forest(,) As ForestState

Private _isBuilding As Boolean

Me.Text = "Gen " & _gen.ToString() & " @ " & (_gen / (_sw.ElapsedMilliseconds / 1000)).ToString("F02") & " FPS: Forest Fire"

End Sub

 

==={{header|ZX Spectrum Basic}}===

 

A screenshot of the program running can be found [http://www.edmundgriffiths.com/spectrumforestfire.jpg here].

20 DIM n$(20,30)

30 LET init=.5

540 NEXT j

550 NEXT i

 

=={{header|Batch File}}==

</pre>

Default is <code> 10 50 5 5 </code>

@echo off

setlocal enabledelayedexpansion

)

exit /b

{{out}}

'''Sample Default Output'''

# T T T #

</pre>

 

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

 

abstract class Cell() of tree | dirt | burning {}

forest.evolve();

}

 

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

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

;; -*- lexical-binding: t -*-

;; run: ./forest-fire forest-fire.config

 

(simulate-forest (elt command-line-args-left 0))

 

The configuration file controls the simulation.

(cols . 45)

(time . 100)

(f . 0.001) ;; probability tree ignites

(p . 0.01) ;; probability empty space fills with a tree

 

{{out}}

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

{{works with|Gforth|0.7.3}}

30 CONSTANT HEIGHT

WIDTH HEIGHT * CONSTANT SIZE

DUP .FOREST \ print the current state

SWAP ; \ prepare for next iteration

 

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

import Data.List (tails, transpose)

 

data Cell

| Fire

deriving (Eq)

instance Show Cell where

show Empty = " "

show Tree = "T"

show Fire = "$"

randomCell :: IO Cell

randomCell = fmap ([Empty, Tree] !!) (randomRIO (0, 1) :: IO Int)

randomChance :: IO Double

randomChance = randomRIO (0, 1.0) :: IO Double

rim :: a -> [[a]] -> [[a]]

rim b = fmap (fb b) . (fb =<< rb)

where

rb = fst . unzip . zip (repeat b) . head

take3x3 :: [[a]] -> [[[a]]]

take3x3 = concatMap (transpose . fmap take3) . take3

where

take3 = init . init . takeWhile (not . null) . fmap (take 3) . tails

list2Mat :: Int -> [a] -> [[a]]

list2Mat n = takeWhile (not . null) . fmap (take n) . iterate (drop n)

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

evolveForest m n k = do

nfs >>= evolve (i + 1)

evolve 1 fs

main :: IO ()

{{Out}} Sample:

<pre>>>>>>> 1:

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

 

 

 

Functional approach using [https://lodash.com/ lodash]

 

 

const _ = require('lodash');

}, 20);

 

 

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

 

@enum State empty tree fire

end

end

# A burning cell turns into an empty cell

if forest[i] == fire forest[i] = empty end

end

 

 

{{out}}

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

 

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

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

 

define('WIDTH', 10);

return rand(0, 100) < $prob;

}

 

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

 

=={{header|REXX}}==

 

Glyphs were chosen in an attempt to pictorialize a tree &nbsp; (<big>↑</big>) &nbsp; and also a fire &nbsp; (<big>▒</big>).

 

<pre>

┌───────────────────────────elided version──────────────────────────┐

└───────────────────────────────────────────────────────────────────┘

</pre>

parse value scrSize() with sd sw . /*the size of the terminal display. */

parse arg generations birth lightning rSeed . /*obtain the optional arguments from CL*/

return random(1, field) <= lightning /*lightning ignition*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

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

<br>The &nbsp; '''SCRSIZE.REX''' &nbsp; REXX program is included here &nbsp; ──► &nbsp; &nbsp;[[SCRSIZE.REX]]. <br><br>

 

=={{header|Ring}}==

# Project : Forest fire

 

load "guilib.ring"

label1 { setpicture(p1) show() }

return

Output:

 

 

=={{header|Ruby}}==

Neighborhood = [-1,0,1].product([-1,0,1]) - [0,0]

States = {empty:" ", tree:"T", fire:"#"}

forest.evolve

forest.display

Sample Output:

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

T # # TT TT ##TTT

</pre>

=={{header|Rust}}==

{{libheader|rand}}

{{libheader|ansi_term}}

extern crate ansi_term;

 

write!(writer, "{}", String::from_utf8_lossy(&output.stdout)).unwrap();

}

 

=={{header|Sather}}==

private attr fields:ARRAY{ARRAY{INT}};

private attr swapu:INT;

end;

 

 

=={{header|Scala}}==

 

class Forest(matrix:Array[Array[Char]]){

val EMPTY='.'

def apply(x:Int=30, y:Int=15)=new Forest(Array.tabulate(y, x)((y,x)=> if (Random.nextDouble<0.5) TREE else EMPTY))

 

def main(args: Array[String]): Unit = {

var l=Forest()

}

}

Sample output:

<pre>.T..TTT.TT .T..TTT.TT TT..TTT.TT TT..TTTTTT TT..TTTTTT

=={{header|Sidef}}==

{{trans|Perl}}

define h = `tput lines`.to_i-1

define r = "\033[H"

}

 

 

OO approach:

define YELLOW = "\e[1;33m"

define GREEN = "\e[1;32m"

forest.show

forest.step

 

=={{header|Tcl}}==

 

# Build a grid

printGrid

if {[gets stdin line] < 0} break

Sample output:

<pre>

=={{header|uBasic/4tH}}==

It's a small forest, since it's a small interpreter.

E = 16 ' An empty space

T = 256 ' A living tree

Next ' Try next row

 

{{out}}

<pre> @ @ @ @

 

Note: In order to display the graphics characters correctly, use DOS (OEM) font such as "Terminal".

#2 = 60 // width of the grid

#3 = 2 // probability of random fire, per 1000

#93 = 0x7fffffff % 48271

#90 = (48271 * (#90 % #92) - #93 * (#90 / #92)) & 0x7fffffff

 

Sample output, 10th generation:

--------------------------------------------------------------

</pre>