Focus on sfb

3 files changed, 88 insertions, 49 deletions

diff --git a/src/corpus.rs b/src/corpus.rs
index 20ddbb3..2fab5a4 100644
--- a/src/corpus.rs
+++ b/src/corpus.rs
@@ -51,6 +51,58 @@ impl Corpus {
         });
     }
 
+    pub fn layout_fitness(&self, layout: &Layout) -> u32 {
+        let mut sfb: u32 = 0;
+
+        // TODO: We make assumptions about NUM_KEYS here
+        for i in 0..8 {
+            let ind = if i < 4 { i } else { i + 2 };
+
+            let k1 = layout.get_key(ind + 10 * 0);
+            let k2 = layout.get_key(ind + 10 * 1);
+            let k3 = layout.get_key(ind + 10 * 2);
+
+            sfb += self.bigram_count[pair_to_index(k1, k2)]
+                + self.bigram_count[pair_to_index(k1, k3)]
+                + self.bigram_count[pair_to_index(k2, k3)];
+
+            if i == 3 {
+                let k4 = layout.get_key(4 + 10 * 0);
+                let k5 = layout.get_key(4 + 10 * 1);
+                let k6 = layout.get_key(4 + 10 * 2);
+                sfb += self.bigram_count[pair_to_index(k4, k5)]
+                    + self.bigram_count[pair_to_index(k4, k6)]
+                    + self.bigram_count[pair_to_index(k5, k6)]
+                    + self.bigram_count[pair_to_index(k1, k4)]
+                    + self.bigram_count[pair_to_index(k1, k5)]
+                    + self.bigram_count[pair_to_index(k1, k6)]
+                    + self.bigram_count[pair_to_index(k2, k4)]
+                    + self.bigram_count[pair_to_index(k2, k5)]
+                    + self.bigram_count[pair_to_index(k2, k6)]
+                    + self.bigram_count[pair_to_index(k3, k4)]
+                    + self.bigram_count[pair_to_index(k3, k5)]
+                    + self.bigram_count[pair_to_index(k3, k6)];
+            } else if i == 4 {
+                let k4 = layout.get_key(5 + 10 * 0);
+                let k5 = layout.get_key(5 + 10 * 1);
+                let k6 = layout.get_key(5 + 10 * 2);
+                sfb += self.bigram_count[pair_to_index(k4, k5)]
+                    + self.bigram_count[pair_to_index(k5, k6)]
+                    + self.bigram_count[pair_to_index(k4, k6)]
+                    + self.bigram_count[pair_to_index(k1, k4)]
+                    + self.bigram_count[pair_to_index(k1, k5)]
+                    + self.bigram_count[pair_to_index(k1, k6)]
+                    + self.bigram_count[pair_to_index(k2, k4)]
+                    + self.bigram_count[pair_to_index(k2, k5)]
+                    + self.bigram_count[pair_to_index(k2, k6)]
+                    + self.bigram_count[pair_to_index(k3, k4)]
+                    + self.bigram_count[pair_to_index(k3, k5)]
+                    + self.bigram_count[pair_to_index(k3, k6)];
+            }
+        }
+        sfb
+    }
+
     pub fn evaluate_layout(&self, layout: &Layout) -> Evaluation {
         let mut keypress: [u32; NUM_KEYS] = [0; NUM_KEYS];
         let mut sfb: [u32; 8] = [0; 8];
diff --git a/src/layout.rs b/src/layout.rs
index 0ce3fdc..0ebad27 100644
--- a/src/layout.rs
+++ b/src/layout.rs
@@ -129,30 +129,30 @@ impl Evaluation {
     }
 
     // TODO
-    pub fn fitness(&self) -> f32 {
-        // let mut finger_usages = [0; 8];
-        // let tot = self.total_keypress as f32;
-        // for (i, &c) in self.keypress.iter().enumerate() {
-        //     finger_usages[KEY_TO_FINGER[i]] += c;
-        // }
-        // const MAX_FINGER_USAGES: [f32; 8] = [8.0, 11.0, 21.0, 21.0, 21.0, 21.0, 11.0, 8.0];
-        // const MAX_FINGER_USAGES: [f32; 8] =
-        //     [100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0];
-        // if finger_usages
-        //     .iter()
-        //     .enumerate()
-        //     .any(|(i, &c)| c as f32 / tot * 100.00 > MAX_FINGER_USAGES[i])
-        // {
-        //     std::u32::MAX
-        // } else {
-        // self.sfb
-        //     .iter()
-        //     .enumerate()
-        //     .map(|(i, &s)| s as f32 / finger_usages[i] as f32 * 50.0)
-        //     .sum()
-        // }
-        self.sfb.iter().sum::<u32>() as f32
-    }
+    // pub fn fitness(&self) -> f32 {
+    // let mut finger_usages = [0; 8];
+    // let tot = self.total_keypress as f32;
+    // for (i, &c) in self.keypress.iter().enumerate() {
+    //     finger_usages[KEY_TO_FINGER[i]] += c;
+    // }
+    // const MAX_FINGER_USAGES: [f32; 8] = [8.0, 11.0, 21.0, 21.0, 21.0, 21.0, 11.0, 8.0];
+    // const MAX_FINGER_USAGES: [f32; 8] =
+    //     [100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0, 100.0];
+    // if finger_usages
+    //     .iter()
+    //     .enumerate()
+    //     .any(|(i, &c)| c as f32 / tot * 100.00 > MAX_FINGER_USAGES[i])
+    // {
+    //     std::u32::MAX
+    // } else {
+    // self.sfb
+    //     .iter()
+    //     .enumerate()
+    //     .map(|(i, &s)| s as f32 / finger_usages[i] as f32 * 50.0)
+    //     .sum()
+    // }
+    // self.sfb.iter().sum::<u32>() as f32
+    // }
 }
 
 impl fmt::Display for Evaluation {
diff --git a/src/main.rs b/src/main.rs
index 462d2fe..905d3c6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,7 +2,6 @@ mod config;
 mod corpus;
 mod layout;
 
-use core::cmp::Ordering;
 use rayon::prelude::*;
 
 use rand::prelude::*;
@@ -12,7 +11,7 @@ use corpus::*;
 use layout::*;
 
 fn main() {
-    let corpus = Corpus::load("chained_english_bigrams_1m.txt").unwrap();
+    let corpus = Corpus::load("new.txt").unwrap();
     println!("{}", corpus);
 
     let starting_layout = Layout::from_verbose(
@@ -26,9 +25,9 @@ fn main() {
 
     let mut rng = Pcg64::from_entropy();
 
-    type Fun = Vec<(Layout, Evaluation, f32)>;
+    type Fun = Vec<(Layout, u32)>;
 
-    let mut best = std::f32::INFINITY;
+    let mut best = std::u32::MAX;
     let mut layouts: Fun = (0..10)
         .into_iter()
         .map(|i| {
@@ -39,18 +38,15 @@ fn main() {
                 layout = starting_layout;
             }
 
-            let evl = corpus.evaluate_layout(&layout);
-            let fitness = evl.fitness();
-            return (layout, evl, fitness);
+            return (layout, corpus.layout_fitness(&layout));
         })
         .collect();
 
-    let mut counter: u64 = 0;
-    while counter < 10000000000000 {
+    loop {
         let new_layouts = layouts
             .iter()
             .enumerate()
-            .map(|(i, (kbd, _, _))| {
+            .map(|(i, (kbd, _))| {
                 if i > 0 {
                     Layout::new_random_from(kbd, &mut rng)
                 } else {
@@ -62,30 +58,21 @@ fn main() {
         new_layouts
             .par_iter()
             .map(|layout| {
-                let evl = corpus.evaluate_layout(layout);
-                let fitness = evl.fitness();
-                return (*layout, evl, fitness);
+                return (*layout, corpus.layout_fitness(layout));
             })
             .collect_into_vec(&mut layouts);
 
-        layouts.sort_by(|(_, _, lfit), (_, _, rfit)| {
-            if lfit < rfit {
-                Ordering::Less
-            } else {
-                Ordering::Greater
-            }
-        });
+        layouts.sort_by(|(_, lfit), (_, rfit)| lfit.cmp(rfit));
 
-        if layouts[0].2 < best {
-            best = layouts[0].2;
+        if layouts[0].1 < best {
+            best = layouts[0].1;
+            let evl = corpus.evaluate_layout(&layouts[0].0);
             println!("");
             println!("================================================================================\nLayout:\n{}",
                          layouts[0].0
                     );
 
-            println!("{}\n{}", layouts[0].1, layouts[0].2);
+            println!("{}\n{}", evl, layouts[0].1);
         }
-
-        counter += 1;
     }
 }