replace printlns with real logging + move main.rs under 'examples'

Cargo.toml

@@ -12,7 +12,7 @@
 [package]
 edition = "2021"
 name = "multimarkov"
-version = "0.5.0"
+version = "1.0.0"
 authors = ["joeclark-phd <[email protected]>"]
 description = """
 This is a generic tool for training and using multi-order Markov chains for procedural generation applications
@@ -22,6 +22,12 @@ readme = "README.md"
 license = "MIT"
 repository = "https://github.com/joeclark-phd/multimarkov"
 
+[dependencies]
+log = "0.4.22"
+
 [dependencies.rand]
 version = "0.8.5"
 features = [ "small_rng" ]
+
+[dev-dependencies]
+env_logger = "0.11.5"

README.md

@@ -56,6 +56,8 @@ is much more likely to draw `'f'` because it has trained a model for what comes
 
 ## Release notes:
 
+**1.0.0**: Replaced `println`s with logging using the `log` crate.  Added logging of the number of known states and trained sequences within the `add_priors` function on `MultiMarkovBuilder`.  It turns out that that step can really explode if you have a large dataset, so this logging may be helpful downstream.  Also: moved the binary target (`main.rs`) into the "examples" directory.  Run it with `cargo run --example main`.
+
 0.5.0: MultiMarkov now implements `Debug`
 
 0.4.0: The addition of a method `with_rng()` on the builder allows you to add a custom RNG, for example, if you want to use a random number seed.  Thanks RicardRC.

src/main.rs → examples/main.rs

@@ -1,11 +1,14 @@
-mod builder;
-
 use multimarkov::MultiMarkov;
 use rand::{rngs::SmallRng, SeedableRng};
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 
 fn main() {
+
+    // initialize logging
+    env_logger::builder().filter_level(log::LevelFilter::Debug).init();
+
+
     let file = File::open("resources/romans.txt").unwrap();
     let reader = BufReader::new(file);
     let lines = reader

src/builder.rs

@@ -1,4 +1,5 @@
 use crate::MultiMarkov;
+use log::{debug, info};
 use rand::{thread_rng, RngCore};
 use std::cmp::max;
 use std::collections::{BTreeMap, HashMap, HashSet};
@@ -80,8 +81,8 @@ where
                 Err(_) => error_count += 1,
             };
         }
-        println!(
-            "{} sequences successfully trained; {} errors",
+        debug!(
+            "{} sequences successfully trained; {} errors.",
             success_count, error_count
         );
         self
@@ -90,7 +91,7 @@ where
     /// Learn all the transitions possible from one training sequence, adding observations to the Markov model.
     fn train_sequence(&mut self, sequence: Vec<T>) -> Result<(), &str> {
         if sequence.len() < 2 {
-            return Err("sequence was too short, must contain at least two states");
+            return Err("Sequence was too short, must contain at least two states.");
         }
 
         // loop backwards through the characters in the sequence
@@ -141,13 +142,15 @@ where
     /// Should be called after training is complete, because only then do we know the full set of
     /// known states, and which transitions are unobserved.
     fn add_priors(&mut self) {
+        let mut num_priors_added: usize = 0;
         match self.prior {
             Some(p) => {
                 for v in self.markov_chain.values_mut() {
                     for a in self.known_states.iter() {
-                        v.entry(a.clone()).or_insert(p);
+                        v.entry(a.clone()).or_insert_with(|| {num_priors_added+=1; p});
                     }
                 }
+                info!("Model has {} known states and {} trained sequences. {} priors added.",self.markov_chain.len(),self.known_states.len(),num_priors_added);
             }
             None => (),
         }