Struct Chain

pub struct Chain<T>
where
    T: Chainable,
{ /* private fields */ }

A generic Markov chain for almost any type. In particular, elements of the chain must be Eq, Hash, and Clone.

Implementations

impl<T> Chain<T>

where T: Chainable,

pub fn new() -> Chain<T>

Constructs a new Markov chain.

pub fn of_order(order: usize) -> Chain<T>

Creates a new Markov chain of the specified order. The order is the number of previous tokens to use for each mapping in the chain. Higher orders mean that the generated text will more closely resemble the training set. Increasing the order can yield more realistic output, but typically at the cost of requiring more training data.

Examples found in repository

examples/graph.rs (line 7)

fn main() {
    let mut chain = markov::Chain::of_order(2);
    chain.feed(vec!('e', 'r', 't', 'r', 't', 'y', 'r', 't', 'e', 'r', 't', 'y', 't', 'r'));
    let graph = chain.graph();

    println!("{:?}", petgraph::dot::Dot::new(&graph));
}

pub fn is_empty(&self) -> bool

Determines whether or not the chain is empty. A chain is considered empty if nothing has been fed into it.

pub fn feed<S: AsRef<[T]>>(&mut self, tokens: S) -> &mut Chain<T>

Feeds the chain a collection of tokens. This operation is O(n) where n is the number of tokens to be fed into the chain.

Examples found in repository

examples/graph.rs (line 8)

fn main() {
    let mut chain = markov::Chain::of_order(2);
    chain.feed(vec!('e', 'r', 't', 'r', 't', 'y', 'r', 't', 'e', 'r', 't', 'y', 't', 'r'));
    let graph = chain.graph();

    println!("{:?}", petgraph::dot::Dot::new(&graph));
}

pub fn generate(&self) -> Vec<T>

Generates a collection of tokens from the chain. This operation is O(mn) where m is the length of the generated collection, and n is the number of possible states from a given state.

pub fn generate_from_token(&self, token: T) -> Vec<T>

Generates a collection of tokens from the chain, starting with the given token. This operation is O(mn) where m is the length of the generated collection, and n is the number of possible states from a given state. This returns an empty vector if the token is not found.

pub fn iter(&self) -> InfiniteChainIterator<'_, T>

Produces an infinite iterator of generated token collections.

pub fn iter_for(&self, size: usize) -> SizedChainIterator<'_, T>

Produces an iterator for the specified number of generated token collections.

pub fn graph(&self) -> Graph<Vec<Option<T>>, f64>

Create a graph using petgraph from the markov chain.

Examples found in repository

examples/graph.rs (line 9)

fn main() {
    let mut chain = markov::Chain::of_order(2);
    chain.feed(vec!('e', 'r', 't', 'r', 't', 'y', 'r', 't', 'e', 'r', 't', 'y', 't', 'r'));
    let graph = chain.graph();

    println!("{:?}", petgraph::dot::Dot::new(&graph));
}

impl<T> Chain<T>

where T: Chainable + Serialize,

pub fn save<P: AsRef<Path>>(&self, path: P) -> Result<()>

Saves the current chain to the specified path.

impl<T> Chain<T>

where T: Chainable + DeserializeOwned,

pub fn load<P: AsRef<Path>>(path: P) -> Result<Chain<T>>

Loads a chain from the specified path.

impl Chain<String>

pub fn feed_str(&mut self, string: &str) -> &mut Chain<String>

Feeds a string of text into the chain.

pub fn feed_file<P: AsRef<Path>>( &mut self, path: P, ) -> Result<&mut Chain<String>>

Feeds a properly formatted file into the chain. This file should be formatted such that each line is a new sentence. Punctuation may be included if it is desired.

pub fn generate_str(&self) -> String

Generates a random string of text.

pub fn generate_str_from_token(&self, string: &str) -> String

Generates a random string of text starting with the desired token. This returns an empty string if the token is not found.

pub fn str_iter(&self) -> InfiniteChainStringIterator<'_>

Produces an infinite iterator of generated strings.

pub fn str_iter_for(&self, size: usize) -> SizedChainStringIterator<'_>

Produces a sized iterator of generated strings.

Trait Implementations

impl<T> Debug for Chain<T>

where T: Chainable + Debug,

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Chain<T>

where T: Chainable + Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> PartialEq for Chain<T>

where T: Chainable + PartialEq,

fn eq(&self, other: &Chain<T>) -> 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<T> Serialize for Chain<T>

where T: Chainable + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Chain<T>

where T: Chainable,