val of_int : int -> t
- val to_int : t -> int
+ val is_alive : t -> bool
val to_cell : t -> Cell.t
val of_cell_state : Cell.State.t -> t
+
+ val next : t -> live_neighbors:int -> t
end =
struct
type t = D | A
| 1 -> A
| _ -> assert false
- let to_int = function
- | D -> 0
- | A -> 1
+ let is_alive = function
+ | D -> false
+ | A -> true
let to_pheno = function
| D -> PhenoType.create ' ' None
{ Cell.state = t |> to_cell_state
; Cell.pheno = t |> to_pheno
}
- end
- let next state ~live_neighbors =
- match state with
- | State.A when live_neighbors < 2 -> State.D
- | State.A when live_neighbors < 4 -> State.A
- | State.A when live_neighbors > 3 -> State.D
- | State.D when live_neighbors = 3 -> State.A
- | State.A -> State.A
- | State.D -> State.D
+ let next t ~live_neighbors =
+ match t with
+ | A when live_neighbors < 2 -> D
+ | A when live_neighbors < 4 -> A
+ | A when live_neighbors > 3 -> D
+ | D when live_neighbors = 3 -> A
+ | A -> A
+ | D -> D
+ end
let create () =
Random.int 2 |> State.of_int |> State.to_cell
- let live_neighbors neighbors =
- neighbors |> List.map ~f:(State.of_cell_state |- State.to_int)
- |> List.fold_left ~init:0 ~f:(+)
+ let count_of_live =
+ List.map ~f:State.of_cell_state
+ |- List.filter ~f:State.is_alive
+ |- List.length
let transition ~self ~neighbors =
self |> State.of_cell_state
- |> next ~live_neighbors:(live_neighbors neighbors)
+ |> State.next ~live_neighbors:(count_of_live neighbors)
|> State.to_cell
end
val of_int : int -> t
- val to_int : t -> int
-
val to_cell : t -> Cell.t
val of_cell_state : Cell.State.t -> t
+
+ val next : t -> burning_neighbors:int -> t
end =
struct
type t = E | T | B
| 2 -> B
| _ -> assert false
- let to_int = function
- | E -> 0
- | T -> 1
- | B -> 2
-
let to_pheno = function
| E -> PhenoType.create ' ' None
| T -> PhenoType.create 'T' (Some `green)
{ Cell.state = t |> to_cell_state
; Cell.pheno = t |> to_pheno
}
- end
- let create () =
- Random.int 3 |> State.of_int |> State.to_cell
+ let f = 0.000001 (* Probability of spontaneous ignition *)
+ let p = 0.1 (* Probability of spontaneous growth *)
- let f = 0.000001 (* Probability of spontaneous ignition *)
- let p = 0.1 (* Probability of spontaneous growth *)
+ let is_probable p =
+ (Random.float 1.0) <= p
- let is_probable p =
- (Random.float 1.0) <= p
+ let next t ~burning_neighbors =
+ match t, burning_neighbors with
+ | E, _ when is_probable p -> T
+ | E, _ -> E
+ | T, 0 when is_probable f -> B
+ | T, _ when burning_neighbors > 0 -> B
+ | T, _ -> T
+ | B, _ -> E
+ end
- let next state ~burning_neighbors =
- match state, burning_neighbors with
- | State.E, _ when is_probable p -> State.T
- | State.E, _ -> State.E
- | State.T, 0 when is_probable f -> State.B
- | State.T, _ when burning_neighbors > 0 -> State.B
- | State.T, _ -> State.T
- | State.B, _ -> State.E
+ let create () =
+ Random.int 3 |> State.of_int |> State.to_cell
- let burning_neighbors neighbors =
- neighbors |> List.map ~f:State.of_cell_state
- |> List.filter ~f:State.is_burning
- |> List.map ~f:State.to_int
- |> List.fold_left ~init:0 ~f:(+)
+ let count_of_burning =
+ List.map ~f:State.of_cell_state
+ |- List.filter ~f:State.is_burning
+ |- List.length
let transition ~self ~neighbors =
self |> State.of_cell_state
- |> next ~burning_neighbors:(burning_neighbors neighbors)
+ |> State.next ~burning_neighbors:(count_of_burning neighbors)
|> State.to_cell
end