lilis

Library to Interpret Lindenmayer Systems
IN THIS PACKAGE
Module Lilis . Make

Parameters

module Lstream : S

Signature

val eval_lsys : int -> ('a * string Calc.t list) lsystem -> ('a * float array) Lstream.t

Evaluate a L-system at the n-th generation.

Compression functions

A L-system is first compressed before being iterated on. This compression allows far better performances.

One of the steps of compression is to transform string symbols into int. To be allowed to transform back and forth a lstream, the compress_lstream function provides an environment from string symbols to int. This environment can be used by compress_lstream and uncompress_lstream for O(n) compression/uncompression. The laziness of Lstream is respected.

type 'a lstream = ('a * float array) Lstream.t
type 'a crules
val compress_rules : SymbEnv.t -> (string * string Calc.t list) rule list -> int crules
val compress_post_rules : SymbEnv.t -> ('a * string Calc.t list) rule list -> 'a crules
val compress_lslist : SymbEnv.t -> string stream -> (int * float array) Lstream.stored
val compress_lsys : ('a * string Calc.t list) lsystem -> SymbEnv.t * (int * float array) Lstream.stored * int crules * 'a crules
val compress_lstream : SymbEnv.t -> string lstream -> int lstream
val uncompress_lstream : SymbEnv.t -> int lstream -> string lstream
val map_crules : ( 'a -> 'b ) -> 'a crules -> 'b crules

Engine

val apply : ?n:int -> int crules -> int lstream -> int lstream

apply rules lstream will apply rules once to lstream. The optional argument n can be used to apply more than once.

val apply_complete : 'a crules -> int lstream -> 'a lstream

As apply but with a complete mapping. Symbols without rules are suppressed.

val eval_lsys_uncompress : int -> ('a * string Calc.t list) lsystem -> (string * float array) Lstream.t

Like eval_lsys , but will ignore post rules and uncompress the stream instead.

Not really safe

val iter_complete : ( ( float array -> float ) array -> float array -> unit ) crules -> int lstream -> unit

Take a rule composed of unit functions and apply it to the stream.

val eval_iter_lsys : int -> ('a * string Calc.t list) lsystem -> store:bool -> ( 'a -> ( float array -> float ) array -> float array -> unit ) -> unit -> unit
val eval_fold_lsys : int -> ('a * string Calc.t list) lsystem -> store:bool -> ( 'a -> ( float array -> float ) array -> 'b -> float array -> 'b ) -> 'b -> 'b