penalise pinky columns with too high usage

even though we don't technically know which columns they are, we do
know they will be the two lowest ultimately when the prelayout becomes
a layout

1 files changed, 31 insertions, 18 deletions

diff --git a/srchr/src/evaluation.rs b/srchr/src/evaluation.rs
index 1c40b44..b412d88 100644
--- a/srchr/src/evaluation.rs
+++ b/srchr/src/evaluation.rs
@@ -7,6 +7,8 @@ use std::fmt;
 
 pub fn prelayout_fitness(corpus: &Corpus, layout: &Prelayout) -> f32 {
     let mut score: f32 = 0.0;
+    let mut min1: f32 = std::f32::INFINITY;
+    let mut min2: f32 = std::f32::INFINITY;
 
     for i in 0..6 {
         let keys = layout.get_standard_column(i);
@@ -18,12 +20,27 @@ pub fn prelayout_fitness(corpus: &Corpus, layout: &Prelayout) -> f32 {
             + corpus.get_bigram_perc(k1, k3)
             + corpus.get_bigram_perc(k2, k3);
 
+        let col_usage = corpus.get_character_perc(k1)
+            + corpus.get_character_perc(k2)
+            + corpus.get_character_perc(k3);
+
+        if col_usage < min2 {
+            if col_usage < min1 {
+                min2 = min1;
+                min1 = col_usage;
+            } else {
+                min2 = col_usage;
+            }
+        }
+
         score += (corpus.get_skipgram_perc(k1, k2)
             + corpus.get_skipgram_perc(k1, k3)
             + corpus.get_skipgram_perc(k2, k3))
             * STANDARD_DSFB_WEIGHT;
     }
 
+    score += pinky_col_penalty(min1, min2);
+
     for i in 0..2 {
         let keys = layout.get_index_column(i);
         let k1 = keys[0];
@@ -33,8 +50,8 @@ pub fn prelayout_fitness(corpus: &Corpus, layout: &Prelayout) -> f32 {
         let k5 = keys[4];
         let k6 = keys[5];
 
-        let index_percs = keys.iter().map(|&k| corpus.get_character_count(k)).sum();
-        score += index_usage_fitness(corpus.get_total_count(), index_percs);
+        let index_percs = keys.iter().map(|&k| corpus.get_character_perc(k)).sum();
+        score += index_usage_fitness(index_percs);
 
         score += corpus.get_bigram_perc(k1, k2)
             + corpus.get_bigram_perc(k1, k3)
@@ -74,8 +91,7 @@ pub fn prelayout_fitness(corpus: &Corpus, layout: &Prelayout) -> f32 {
 }
 
 pub struct Evaluation {
-    keypress: [u32; NUM_KEYS],
-    total_keypress: u32,
+    keypress_perc: [f32; NUM_KEYS],
     total_bigrams: u32,
     sfb: [f32; 8],
     dsfb: [f32; 8],
@@ -83,12 +99,12 @@ pub struct Evaluation {
 
 impl Evaluation {
     pub fn evaluate_layout(corpus: &Corpus, layout: &Layout) -> Evaluation {
-        let mut keypress: [u32; NUM_KEYS] = [0; NUM_KEYS];
+        let mut keypress_perc: [f32; NUM_KEYS] = [0.0; NUM_KEYS];
         let mut sfb: [f32; 8] = [0.0; 8];
         let mut dsfb: [f32; 8] = [0.0; 8];
 
         for (i, &c) in layout.get_keys().iter().enumerate() {
-            keypress[i] = corpus.get_character_count(c as u8);
+            keypress_perc[i] = corpus.get_character_perc(c as u8);
         }
 
         for i in 0..8 {
@@ -166,8 +182,7 @@ impl Evaluation {
         }
 
         return Evaluation {
-            keypress,
-            total_keypress: corpus.get_total_count(),
+            keypress_perc,
             total_bigrams: corpus.get_total_bigrams(),
             sfb,
             dsfb,
@@ -176,28 +191,26 @@ impl Evaluation {
 
     fn output_eval(&self) -> String {
         let mut result = String::new();
-        let tot = self.total_keypress as f32;
         let big = self.total_bigrams as f32;
         let tig = self.total_bigrams as f32;
 
         result += &"Percent per key:\n";
-        result += &format_block_output(self.keypress.into_iter().map(|k| 100.0 * k as f32 / tot));
+        result += &format_block_output(self.keypress_perc.into_iter().map(|u| u * 100.0));
 
-        let mut finger_usages = [0; 8];
-        for (i, &c) in self.keypress.iter().enumerate() {
-            finger_usages[KEY_TO_FINGER[i]] += c;
+        let mut finger_percs = [0.0; 8];
+        for (i, &c) in self.keypress_perc.iter().enumerate() {
+            finger_percs[KEY_TO_FINGER[i]] += c;
         }
 
         result += "\nFinger usage: ";
         let mut lh: f32 = 0.0;
         let mut rh: f32 = 0.0;
-        for (i, &u) in finger_usages.iter().enumerate() {
-            let f = u as f32 / tot * 100.0;
-            result += &format!("{:>5.2}%{}", f, if i < 7 { ", " } else { "" });
+        for (i, &u) in finger_percs.iter().enumerate() {
+            result += &format!("{:>5.2}%{}", u * 100.0, if i < 7 { ", " } else { "" });
             if i % 10 < 4 {
-                lh += f;
+                lh += u;
             } else {
-                rh += f;
+                rh += u;
             }
         }