Struct Chain

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

A struct representing a markov chain.

A markov chain has an order, which determines how many items per node are held. The chain itself is a map of vectors, which point to a map of single elements pointing at a weight.

use markov_chain::Chain;
 
let mut chain = Chain::new(1); // 1 is the order of the chain
 
// Train the chain on some vectors
chain.train(vec![1, 2, 3, 2, 1, 2, 3, 4, 3, 2, 1])
    .train(vec![5, 4, 3, 2, 1]);
 
// Generate a sequence and print it out
let sequence = chain.generate();
println!("{:?} ", sequence);

Implementations

impl<T> Chain<T>

where T: Clone + Chainable,

pub fn new(order: usize) -> Self

Initializes a new markov chain with a given order.

Examples

use markov_chain::Chain;
let chain: Chain<u32> = Chain::new(1);

pub fn order(&self) -> usize

Gets the order of the markov chain. This is static from chain to chain.

pub fn train(&mut self, string: Vec<T>) -> &mut Self

Trains a sentence on a string of items.

Examples

use markov_chain::Chain;
let mut chain = Chain::new(1);
let data = vec![10, 15, 20];
chain.train(data)
    .train(vec![]);

pub fn merge(&mut self, other: &Self) -> &mut Self

Merges this markov chain with another.

Examples

use markov_chain::Chain;
let mut chain1 = Chain::new(1);
let mut chain2 = chain1.clone();
chain1.train(vec![1, 2, 3]);
chain2.train(vec![2, 3, 4, 5, 6])
    .merge(&chain1);

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

Generates a string of items with no maximum limit. This is equivalent to generate_limit(-1).

pub fn generate_limit(&self, max: isize) -> Vec<T>

Generates a string of items, based on the training, of up to N items. Specifying a maximum of -1 allows any arbitrary size of list.

impl Chain<String>

String-specific implementation of the chain. Contains some special string- specific functions.

pub fn train_string(&mut self, sentence: &str) -> &mut Self

Trains this chain on a single string. Strings are broken into words, which are split by whitespace and punctuation.

pub fn generate_sentence(&self) -> String

Generates a sentence, which are ended by “break” strings or null links. “Break” strings are: ., ?, !, .", !", ?", ,"

pub fn generate_paragraph(&self, sentences: usize) -> String

Generates a paragraph of N sentences. Each sentence is broken off by N spaces.

Trait Implementations

impl<T> Clone for Chain<T>

where T: Clone + Chainable + Clone,

fn clone(&self) -> Chain<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Chain<T>

where T: Clone + 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: Clone + 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: Clone + 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: Clone + 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: Clone + Chainable,