Forest fire: Difference between revisions

 

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

; SYS 17239 or CALL 17239

 

; end COMMODORE 64 specific

 

 

=={{header|8086 Assembly}}==

It uses a field size of 320x200 (the CGA screen) and runs at about one frame per second on a 20mhz 286.

 

probF: equ 7 ; P(spontaneous combustion) ~= 0.0001

probP: equ 655 ; P(spontaneous growth) ~= 0.01

rnddat: resb 4 ; RNG state

stack: resw 128 ; Stack space

 

 

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

 

Put (Forest);

end loop;

Sample output:

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

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

{{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 sharp|C#}}==

 

using System.Drawing;

using System.Drawing.Drawing2D;

}

}

 

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

=={{header|EasyLang}}==

 

 

p_tree = 0.002

#

background 100

clear

.

timer 0

#

subr show

.

.

subr update

.

.

on timer

 

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

{{works with|Factor|0.99 Development version 2019-07-10}}

math.vectors prettyprint random raylib.ffi sequences ;

IN: rosetta-code.forest-fire

end-drawing

next-forest

{{out}}

[https://gfycat.com/boilingenviousboto]

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

import System.Random (randomRIO)

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.

 

=={{header|JAMES II/Rule-based Cellular Automata}}==

 

dimensions 2;

 

// a tree is hit by lightning with a change of f = 0.006 %

The starting configuration cannot be given in the modeling language since the concepts of the ''model'' and its ''parameters'' (which includes the starting configuration) are separate in JAMES II.

 

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

 

 

 

===JavaScript===

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

 

 

{{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()

if chance(BurnProb): univNew[y][x] = Fire

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:

 

=={{header|Ol}}==

(import (lib gl))

(import (otus random!))

(glEnd)

(gl:set-userdata step))))

 

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

 

}

 

 

===Alternate Perl Solution===

use warnings;

 

my $p = 0.01; # probability of empty -> tree

print "\e[H", $forest =~ tr/0123/ ^#/r, "\n"; # ^=tree #=burning tree

my $n = $forest =~ tr/123/004/r; # 4=a neighbor is burning

$forest =~ tr/1-7/et10e31/; # step to next generation

$forest =~ s/t/ rand() < $f ? 3 : 2 /ge; # rule 3) tree cell to burning

$forest =~ s/e/ rand() < $p ? 2 : 1 /ge; # rule 4) empty cell to tree

select undef, undef, undef, 0.1; # comment out for full speed

 

=={{header|Phix}}==

{{libheader|Phix/pGUI}}

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Forest_fire.exw

<span style="color: #000000;">main</span><span style="color: #0000FF;">()</span>

 

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

{{works with|rakudo|2015-10-04}}

This version saves a lot of looking around by using four states instead of three; the <tt>Heating</tt> state does a lookahead to track trees that are being heated up by burning trees, so we only ever have to traverse the neighbors of burning trees, not all trees. Also, by only checking the list of burning trees, we can avoid copying the entire forest each iteration, since real forests are mutable.

enum Cell-State <Empty Tree Heating Burning>;

$forest.step;

}

 

===SDL2 Animation===

An alternate version implemented in SDL2.

 

use SDL2::Raw;

 

}

$fps

 

=={{header|REXX}}==

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

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

 

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

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

}

 

 

{{trans|Raku}}

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>

 

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

{{trans|go}}

import strings

import os

}

}

 

=={{header|Wren}}==

{{trans|Go}}

import "io" for Stdin

 

step.call(odd, even)

Stdin.readLine()