Struct dcc_lsystem::system::LSystem

pub struct LSystem { /* fields omitted */ }

An L-system.

Basic Usage

The suggested method for constructing an LSystem is to use a LSystemBuilder, as shown in our implementation of Lindenmayer's system below.

use dcc_lsystem::{LSystemBuilder, variable};

let mut builder = LSystemBuilder::new();

// Set up our two tokens
let a = variable!(builder, "A");
let b = variable!(builder, "B");

// Set the axiom
builder.axiom(vec![a]);

// Set the transformation rules
builder.transformation_rule(a, vec![a, b]);
builder.transformation_rule(b, vec![a]);

// Build our L-system
let mut system = builder.finish();

Once the LSystem has been built, you can use the step() and step_by() methods to iterate the system.

use dcc_lsystem::LSystemBuilder;

let mut builder = LSystemBuilder::new();

/* <---- snip ----> */

let mut system = builder.finish();

// The initial state of our system
assert_eq!(system.render(), "A");

system.step();

assert_eq!(system.render(), "AB");

system.step();

assert_eq!(system.render(), "ABA");

system.step_by(5);

// The state after 7 iterations
assert_eq!(system.render(), "ABAABABAABAABABAABABAABAABABAABAAB");

Methods

impl LSystem

pub fn new(
    arena: Arena<Token>,
    axiom: Vec<ArenaId>,
    rules_map: HashMap<ArenaId, Vec<ArenaId>>
) -> Self

Create a new instance of LSystem. In general you should avoid using this and use an LSystemBuilder instead.

pub fn reset(&mut self)

Reset the system to its initial state.

Example

use dcc_lsystem::{LSystemBuilder, variable};

let mut builder = LSystemBuilder::new();

//  Create a simple L-System with one variable `A` and production rule `A -> AA`
let a = variable!(builder, "A");
builder.axiom(vec![a]);
builder.transformation_rule(a, vec![a,a]);
let mut system = builder.finish();

// Do some work with the system
system.step_by(3);
assert_eq!(system.render(), "AAAAAAAA");

// Reset the system back to its axiom
system.reset();
assert_eq!(system.render(), "A");

pub fn step(&mut self)

Iterate the system a single step.

pub fn step_by(&mut self, n: usize)

Iterate the system by n steps.

pub fn steps(&self) -> usize

Returns the number of iterations the system has undergone so far

pub fn render(&self) -> String

Returns the current state of the system as a String.

pub fn get_state(&self) -> &[ArenaId]

Returns the current state of the system.

Trait Implementations

impl Clone for LSystem

fn clone(&self) -> LSystem

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LSystem

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.