optimize success chances as well

Author: Ferdinand Schober

Cargo.toml

@@ -38,7 +38,7 @@ game = ["dep:solitaire-game"]
 count-allocs = []
 
 [profile.release]
-lto = "fat"
+lto = "thin"
 strip = "symbols"
 panic = "abort"
 codegen-units = 1

solitaire-game/src/solver.rs

@@ -84,8 +84,8 @@ fn calculate_random_move_chances(
     let feasible = feasible.0.clone();
     let wake = wake.clone();
     let task = thread_pool.spawn(async move {
-        let feasible = feasible.iter().copied().collect();
-        let p_random_chance = solitaire_solver::calculate_p_random_chance_success(feasible);
+        let feasible = feasible;
+        let p_random_chance = solitaire_solver::calculate_p_random_chance_success(feasible.into_iter());
 
         let mut command_queue = CommandQueue::default();
         command_queue.push(move |world: &mut World| {

solitaire-solver/src/calc_success.rs

@@ -1,40 +1,59 @@
+use crate::Dir;
+
 use super::{
     Board,
     hash::{CustomHashMap as HashMap, CustomHashSet as HashSet},
 };
 
 /// calculate the chances of winning the game by chosing possible moves at random
-pub fn calculate_p_random_chance_success(feasible: Vec<Board>) -> HashMap<Board, f64> {
-    let feasible: HashSet<_> = feasible.into_iter().collect();
+pub fn calculate_p_random_chance_success(feasible: impl Iterator<Item = Board>) -> HashMap<Board, f64> {
     let mut chances = HashMap::default();
     chances.insert(Board::solved(), 1.0);
-    for i in 2..=(Board::SLOTS - 1) {
-        let feasible_with_i_pegs = feasible
-            .iter()
-            .copied()
-            .filter(|b| b.count_pegs() == i)
-            .collect::<Vec<_>>();
-        for constellation in feasible_with_i_pegs {
-            let legal_moves = constellation.get_legal_moves();
+
+    let mut index: HashSet<Board> = HashSet::default();
+    let mut by_pegs: Vec<Vec<Board>> = vec![Vec::new(); Board::SLOTS + 2];
+    for board in feasible {
+        index.insert(board);
+        by_pegs[board.count_pegs()].push(board);
+    }
+
+    for layer in by_pegs.iter().skip(2) {
+        for board in layer {
+            let mut buffer = [Board::empty(); MAX_MOVES];
+            let successors = successors_of(*board, &mut buffer);
 
             // we assume each legal move has equal chance of being taken (1 / n)
             // p_success = sum(moves, P(move) * P(success | move))
             // P(success | move) = 0.0 if infeasible, else lookup
-            let p_move = 1.0 / legal_moves.len() as f64;
+            let p_move = 1.0 / successors.len() as f64;
 
             let mut p_success = 0.0;
 
-            for mov in legal_moves {
-                let c_new = constellation.mov(mov).normalize();
-                p_success += if feasible.contains(&c_new) {
-                    p_move * *chances.get(&c_new).expect("already present")
+            for succ in successors {
+                p_success += if index.contains(&succ) {
+                    p_move * *chances.get(&succ).expect("already present")
                 } else {
                     p_move * 0.0
                 };
             }
 
-            chances.insert(constellation, p_success);
+            chances.insert(*board, p_success);
         }
     }
     chances
 }
+
+const MAX_MOVES: usize = 76;
+
+fn successors_of(board: Board, buffer: &mut [Board; MAX_MOVES]) -> &[Board] {
+    let syms = board.symmetries();
+    let mut len = 0;
+    for dir in Dir::enumerate() {
+        for idx in board.mov_pattern_mask(dir) {
+            debug_assert!(len < MAX_MOVES, "more than {MAX_MOVES} moves from one board");
+            buffer[len] = Board::normalize_after_move(&syms, idx, dir);
+            len += 1;
+        }
+    }
+    &buffer[..len]
+}

src/main.rs

@@ -178,16 +178,20 @@ fn main() {
                     solitaire_solver::calculate_all_solutions_naive();
                 }
                 Command::CalculateRandomChanceSuccessRatio => {
-                    let feasible = solitaire_solver::calculate_feasible_set(None);
+                    let feasible = solitaire_solver::calculate_feasible_set(args.threads);
                     let start = std::time::Instant::now();
-                    let feasible = feasible.into_iter().collect();
+                    let feasible: Vec<_> = feasible.into_iter().collect();
                     let success_probabilities =
-                        solitaire_solver::calculate_p_random_chance_success(feasible);
+                        solitaire_solver::calculate_p_random_chance_success(feasible.into_iter());
                     let p = *success_probabilities.get(&Board::default()).unwrap();
                     let percentage = p * 100.;
 
                     println!("took {:?}", start.elapsed());
                     println!("success probability when chosing moves at random: {percentage}%");
+                    let (b, p) = success_probabilities.iter().map(|(b, p)| (*b, *p)).fold((Board::default(), f64::INFINITY), |(b1, p1), (b2, p2)| if p2 < p1 { (b2, p2) } else { (b1, p1) });
+                    let perc = p * 100.;
+                    println!("minimum success chance: \n{b} ({perc}%)");
+
                 }
                 Command::CalculateSingle => {
                     let solution = solitaire_solver::calculate_first_solution();