formatting

Author: Ferdinand Schober

solitaire-game/src/solver.rs

@@ -85,7 +85,8 @@ fn calculate_random_move_chances(
     let wake = wake.clone();
     let task = thread_pool.spawn(async move {
         let feasible = feasible;
-        let p_random_chance = solitaire_solver::calculate_p_random_chance_success(feasible.into_iter());
+        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

@@ -6,7 +6,9 @@ use super::{
 };
 
 /// calculate the chances of winning the game by chosing possible moves at random
-pub fn calculate_p_random_chance_success(feasible: impl Iterator<Item = Board>) -> HashMap<Board, f64> {
+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);
 
@@ -50,7 +52,10 @@ fn successors_of(board: Board, buffer: &mut [Board; MAX_MOVES]) -> &[Board] {
     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");
+            debug_assert!(
+                len < MAX_MOVES,
+                "more than {MAX_MOVES} moves from one board"
+            );
             buffer[len] = Board::normalize_after_move(&syms, idx, dir);
             len += 1;
         }

solitaire-solver/src/unique_solutions.rs

@@ -1,12 +1,12 @@
-use crate::solution::SolutionMultiset;
+use crate::board::Idx;
 use crate::dir::Dir;
 use crate::par;
-use crate::board::Idx;
+use crate::solution::SolutionMultiset;
 use crate::{Board, Move};
 use crate::{HashMap, HashSet, Solution};
+use rustc_hash::FxHashSet;
 use std::collections::BTreeMap;
 use std::num::NonZero;
-use rustc_hash::FxHashSet;
 
 /// Dense slot for a move, keyed by its starting bit and direction: 64 positions x 4
 /// directions. Sparse - only 76 of the 256 are reachable - but it makes the occurrence
@@ -248,7 +248,6 @@ impl ZobristTable {
     }
 }
 
-
 /// Upper bound on the moves available from one board.
 ///
 /// The cross holds 38 collinear triples and each can be jumped from either end, so no
@@ -386,7 +385,10 @@ fn successors_of(board: Board, buffer: &mut [Board; MAX_MOVES], kind: PathKind)
     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");
+            debug_assert!(
+                len < MAX_MOVES,
+                "more than {MAX_MOVES} moves from one board"
+            );
             buffer[len] = Board::normalize_after_move(&syms, idx, dir);
             len += 1;
         }
@@ -412,15 +414,16 @@ fn successors_of(board: Board, buffer: &mut [Board; MAX_MOVES], kind: PathKind)
 /// The search uses the former for every edge, so they had better agree.
 #[test]
 fn test_move_at_matches_get_legal_moves() {
-    let boards = [
-        Board::default(),
-        Board(Board::full().0 & !Board::solved().0),
-        Board::solved(),
-    ]
-    .into_iter()
-    .chain((0..500).map(|_| {
-        Board::from_compressed_repr(rand::random::<u64>() & ((1 << Board::SLOTS) - 1))
-    }));
+    let boards =
+        [
+            Board::default(),
+            Board(Board::full().0 & !Board::solved().0),
+            Board::solved(),
+        ]
+        .into_iter()
+        .chain((0..500).map(|_| {
+            Board::from_compressed_repr(rand::random::<u64>() & ((1 << Board::SLOTS) - 1))
+        }));
 
     let mut checked = 0usize;
     for board in boards {

src/main.rs

@@ -188,10 +188,14 @@ fn main() {
 
                     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 (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();
@@ -226,8 +230,7 @@ fn main() {
                         "distinct move sequences:  {}",
                         moves.get(&Board::default()).unwrap()
                     );
-                    let boards =
-                        solitaire_solver::all_unique_board_paths(feasible, args.threads);
+                    let boards = solitaire_solver::all_unique_board_paths(feasible, args.threads);
                     log::info!(
                         "distinct board sequences: {}",
                         boards.get(&Board::default()).unwrap()