Struct GraphGrammar 

pub struct GraphGrammar<I: Index, NL: Label, EL: Label> {
    pub start_graph: Graph<I, NL, EL>,
    pub productions: HashMap<String, Production<I, NL, EL>>,
    pub terminal_nodes: HashSet<NL>,
}

A GraphGrammar yields different graphs, that are constructible using a starting graph and a list of transformations (productions). It is also used to further transform generated graphs using evolve. Refer to generate_random.

Fields

start_graph: Graph<I, NL, EL>

Starting graph

productions: HashMap<String, Production<I, NL, EL>>

Number of productions, that transform a matching subgraph to another

terminal_nodes: HashSet<NL>

List of terminal nodes. A graph has to consist only of terminal nodes to be considered valid.

Implementations

impl<NL: Label, EL: Label> GraphGrammar<u32, NL, EL>

pub fn evolve_single_step( &self, g: &Graph<u32, NL, EL>, ) -> Option<Graph<u32, NL, EL>>

Applies a random production, that can applied. This function is very expensive. Return None if it can’t be transformed.

impl<I: Index, NL: Label, EL: Label> GraphGrammar<I, NL, EL>

pub fn is_valid(&self, g: &Graph<I, NL, EL>) -> bool

A graph has to consist only of terminal nodes to be considered valid. This validates if a graph g is valid under the used GraphGrammar.

pub fn evolve( &self, g: &Graph<I, NL, EL>, qc: &QuitCondition, ) -> Graph<I, NL, EL>

Evolves g by applying productions of the GraphGrammar until the first condition specified in qc is statisfied and returns the resulting graph.

pub fn generate_random( &self, g: &Graph<I, NL, EL>, cond: QuitCondition, ) -> Graph<I, NL, EL>

Similar to evolve. Returns the first valid graph that is part of the language specified by the grammar using random productions on the starting graph.

Panics

Panics if quitcondition is invalid.

Trait Implementations

impl<I: Clone + Index, NL: Clone + Label, EL: Clone + Label> Clone for GraphGrammar<I, NL, EL>

fn clone(&self) -> GraphGrammar<I, NL, EL>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Index, NL: Debug + Label, EL: Debug + Label> Debug for GraphGrammar<I, NL, EL>

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

Formats the value using the given formatter.

impl<'de, I, NL, EL> Deserialize<'de> for GraphGrammar<I, NL, EL>

where I: Deserialize<'de> + Index, NL: Deserialize<'de> + Label, EL: Deserialize<'de> + Label,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: Index> From<&GraphGrammar<I, &str, ()>> for GraphGrammar<I, String, ()>

fn from(gg: &GraphGrammar<I, &str, ()>) -> Self

Converts to this type from the input type.

impl<I: Index> From<GraphGrammar<I, &str, ()>> for GraphGrammar<I, String, ()>

fn from(gg: GraphGrammar<I, &str, ()>) -> Self

Converts to this type from the input type.

impl<I: PartialEq + Index, NL: PartialEq + Label, EL: PartialEq + Label> PartialEq for GraphGrammar<I, NL, EL>

fn eq(&self, other: &GraphGrammar<I, NL, EL>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<I, NL, EL> Serialize for GraphGrammar<I, NL, EL>

where I: Serialize + Index, NL: Serialize + Label, EL: Serialize + Label,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: Index, NL: Label, EL: Label> StructuralPartialEq for GraphGrammar<I, NL, EL>