Struct lipsum::MarkovChain
source · pub struct MarkovChain<'a, R: Rng> { /* private fields */ }Expand description
Simple order two Markov chain implementation.
The Markov chain is a chain of order two, which means that it will use the previous two words (a bigram) when predicting the next word. This is normally enough to generate random text that looks somewhat plausible. The implementation is based on Generating arbitrary text with Markov chains in Rust.
Implementations
sourceimpl<'a> MarkovChain<'a, ThreadRng>
impl<'a> MarkovChain<'a, ThreadRng>
sourcepub fn new() -> MarkovChain<'a, ThreadRng>
pub fn new() -> MarkovChain<'a, ThreadRng>
Create a new empty Markov chain. It will use a default thread-local random number generator.
Examples
use lipsum::MarkovChain;
let chain = MarkovChain::new();
assert!(chain.is_empty());sourceimpl<'a, R: Rng> MarkovChain<'a, R>
impl<'a, R: Rng> MarkovChain<'a, R>
sourcepub fn new_with_rng(rng: R) -> MarkovChain<'a, R>
pub fn new_with_rng(rng: R) -> MarkovChain<'a, R>
Create a new empty Markov chain that uses the given random number generator.
Examples
extern crate rand;
extern crate rand_xorshift;
use rand::SeedableRng;
use rand_xorshift::XorShiftRng;
use lipsum::MarkovChain;
let rng = XorShiftRng::seed_from_u64(0);
let mut chain = MarkovChain::new_with_rng(rng);
chain.learn("infra-red red orange yellow green blue indigo x-ray");
// The chain jumps consistently like this:
assert_eq!(chain.generate(1), "Yellow.");
assert_eq!(chain.generate(1), "Blue.");
assert_eq!(chain.generate(1), "Green.");sourcepub fn learn(&mut self, sentence: &'a str)
pub fn learn(&mut self, sentence: &'a str)
Add new text to the Markov chain. This can be called several times to build up the chain.
Examples
use lipsum::MarkovChain;
let mut chain = MarkovChain::new();
chain.learn("red green blue");
assert_eq!(chain.words(("red", "green")), Some(&vec!["blue"]));
chain.learn("red green yellow");
assert_eq!(chain.words(("red", "green")), Some(&vec!["blue", "yellow"]));sourcepub fn len(&self) -> usize
pub fn len(&self) -> usize
Returs the number of states in the Markov chain.
Examples
use lipsum::MarkovChain;
let mut chain = MarkovChain::new();
assert_eq!(chain.len(), 0);
chain.learn("red orange yellow green blue indigo");
assert_eq!(chain.len(), 4);sourcepub fn is_empty(&self) -> bool
pub fn is_empty(&self) -> bool
Returns true if the Markov chain has no states.
Examples
use lipsum::MarkovChain;
let mut chain = MarkovChain::new();
assert!(chain.is_empty());
chain.learn("foo bar baz");
assert!(!chain.is_empty());sourcepub fn words(&self, state: Bigram<'a>) -> Option<&Vec<&str>>
pub fn words(&self, state: Bigram<'a>) -> Option<&Vec<&str>>
Get the possible words following the given bigram, or None
if the state is invalid.
Examples
use lipsum::MarkovChain;
let mut chain = MarkovChain::new();
chain.learn("red green blue");
assert_eq!(chain.words(("red", "green")), Some(&vec!["blue"]));
assert_eq!(chain.words(("foo", "bar")), None);sourcepub fn generate(&mut self, n: usize) -> String
pub fn generate(&mut self, n: usize) -> String
Generate a sentence with n words of lorem ipsum text. The
sentence will start from a random point in the Markov chain
and a . will be added as necessary to form a full sentence.
See generate_from if you want to control the starting
point for the generated text and see iter if you simply
want a sequence of words.
Examples
Generating the sounds of a grandfather clock:
use lipsum::MarkovChain;
let mut chain = MarkovChain::new();
chain.learn("Tick, Tock, Tick, Tock, Ding! Tick, Tock, Ding! Ding!");
println!("{}", chain.generate(15));The output looks like this:
Ding! Tick, Tock, Tick, Tock, Ding! Ding! Tock, Ding! Tick, Tock, Tick, Tock, Tick, Tock.