Added in prelayouts, speed info

1 files changed, 43 insertions, 22 deletions

diff --git a/src/main.rs b/src/main.rs
index cee008c..3fee6a7 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,8 +10,10 @@ use rand_pcg::*;
 use corpus::*;
 use layout::*;
 
+use std::time::Instant;
+
 const NUM_CONTESTANTS: usize = 24;
-const SURVIVE_THRESHOLD: usize = 2;
+const SURVIVE_THRESHOLD: usize = 4;
 
 // TODO: Layout is really pre-layout, have something that takes a layout and
 // re-orders columns to balance hands, and keys per column (block really
@@ -25,61 +27,80 @@ fn main() {
     let corpus = Corpus::load("new.txt").unwrap();
     println!("{}", corpus);
 
-    let starting_layout = Layout::from_verbose(
+    let starting_prelayout = Layout::from_verbose(
         "
         Y W F L M  K P O , Q
         U R S N H  D T E A I
         Z X C V J  B G ' . /
         ",
     )
-    .unwrap();
+    .unwrap()
+    .as_prelayout();
 
     let mut rng = Pcg64::from_entropy();
 
-    type Fun = Vec<(Layout, u32)>;
+    type Fun = Vec<(Prelayout, u32)>;
 
     let mut best = std::u32::MAX;
-    let mut layouts: Fun = (0..NUM_CONTESTANTS)
+    let mut prelayouts: Fun = (0..NUM_CONTESTANTS)
         .into_iter()
-        .map(|_| {
-            let layout;
-            layout = Layout::new_random_from(&starting_layout, &mut rng);
-            return (layout, corpus.layout_fitness(&layout));
+        .map(|i| {
+            if i > 0 {
+                let layout;
+                layout = Prelayout::new_random_from(&starting_prelayout, &mut rng);
+                return (layout, std::u32::MAX);
+            } else {
+                (starting_prelayout, std::u32::MAX)
+            }
         })
         .collect();
 
+    let mut count: usize = 0;
+    let mut current = Instant::now();
     loop {
-        let new_layouts = layouts
+        let new_prelayouts = prelayouts
             .iter()
             .enumerate()
             .map(|(i, (kbd, _))| {
                 if i > SURVIVE_THRESHOLD {
                     let parent = rng.gen_range(0..=SURVIVE_THRESHOLD);
-                    Layout::new_random_from(&layouts[parent].0, &mut rng)
+                    Prelayout::new_random_from(&prelayouts[parent].0, &mut rng)
                 } else {
                     kbd.clone()
                 }
             })
-            .collect::<Vec<Layout>>();
+            .collect::<Vec<Prelayout>>();
 
-        new_layouts
+        new_prelayouts
             .par_iter()
             .map(|layout| {
-                return (*layout, corpus.layout_fitness(layout));
+                return (*layout, corpus.prelayout_fitness(layout));
             })
-            .collect_into_vec(&mut layouts);
+            .collect_into_vec(&mut prelayouts);
+
+        prelayouts.sort_by(|(_, lfit), (_, rfit)| lfit.cmp(rfit));
 
-        layouts.sort_by(|(_, lfit), (_, rfit)| lfit.cmp(rfit));
+        count += 1;
+        if count > 65535 {
+            let duration = current.elapsed();
+            eprint!(
+                "\u{001b}[2K\u{001b}[1000D{} iters/s",
+                count as f32 / duration.as_millis() as f32 * 1000.0
+            );
+            current = Instant::now();
+            count = 0;
+        }
 
-        if layouts[0].1 < best {
-            best = layouts[0].1;
-            let evl = corpus.evaluate_layout(&layouts[0].0);
+        if prelayouts[0].1 < best {
+            best = prelayouts[0].1;
+            let layout = Layout::from_prelayout(&prelayouts[0].0);
+            let evl = corpus.evaluate_layout(&layout);
             println!("");
             println!("================================================================================\nLayout:\n{}",
-                         layouts[0].0
-                    );
+                 layout
+            );
 
-            println!("{}\n{}", evl, layouts[0].1);
+            println!("{}", evl);
         }
     }
 }