Cleanup code and make it nicer. Implement spreadsheet printer, so that a nice table can be made.

Author: confusinguser

.gitignore

@@ -1,2 +1,3 @@
 /target
-.idea
+.idea
+output.txt

src/algorithms/draw_checker.rs

@@ -6,14 +6,14 @@ pub fn uncount_board(board_played_times_prediction: &mut HashMap<Board, u32>, ne
     board_played_times_prediction.insert(
         // TODO Hash it to avoid copying, we need a good hash function for Board
         *new_board,
-        *board_played_times_prediction.get(&new_board).unwrap_or(&0) - 1,
+        *board_played_times_prediction.get(new_board).unwrap_or(&0) - 1,
     );
 }
 
 pub fn count_board(board_played_times_prediction: &mut HashMap<Board, u32>, new_board: &Board) {
     board_played_times_prediction.insert(
         // TODO Hash it to avoid copying, we need a good hash function for Board
         *new_board,
-        *board_played_times_prediction.get(&new_board).unwrap_or(&0) + 1,
+        *board_played_times_prediction.get(new_board).unwrap_or(&0) + 1,
     );
 }

src/algorithms/eval.rs

@@ -10,11 +10,11 @@ pub fn eval_no_legal_moves(board: &Board) -> f32 {
 
     // If we arrive at here while it is checkmate, then we know that the side playing
     // has been checkmated.
-    return if board.side_to_move() == Color::White {
+    if board.side_to_move() == Color::White {
         f32::MIN
     } else {
         f32::MAX
-    };
+    }
 }
 pub(crate) fn new_eval_is_better(maximise: bool, old: &Evaluation, new: &Evaluation) -> bool {
     new.eval.is_some()

src/common/constants.rs

@@ -11,7 +11,7 @@ pub(crate) mod modules {
     pub(crate) const TAPERED_INCREMENTAL_PESTO_PSQT: u32 = 1 << 9;
 }
 
-pub(crate) const NUMBER_OF_MODULES: u32 = 9;
+pub(crate) const NUMBER_OF_MODULES: usize = 10;
 
 //NAIVE_PSQT TABLES
 pub(crate) mod naive_psqt_tables {

src/io.rs

@@ -1,18 +1,22 @@
-use std::{fs::OpenOptions, io::{self, prelude::*}};
+use std::{fs::OpenOptions, io::prelude::*};
 
 use crate::common::constants::NUMBER_OF_MODULES;
 
 pub(crate) fn write_result(buf: &[u8], file: &str) -> std::io::Result<()> {
-    let mut file = OpenOptions::new().write(true).create(true).append(true).open(file).unwrap();
-    file.write(buf)?;
+    let mut file = OpenOptions::new()
+        .create(true)
+        .append(true)
+        .open(file)
+        .unwrap();
+    file.write_all(buf)?;
     Ok(())
 }
 
-pub(crate)fn modules_to_string(modules: u32) -> String {
+pub(crate) fn modules_to_string(modules: u32) -> String {
     let mut start: bool = true;
     let mut output: String = "".to_string();
     //For loop ranges is all available modules index. +1 because we need inclusive.
-    for i in 0..NUMBER_OF_MODULES+1 {
+    for i in 0..NUMBER_OF_MODULES + 1 {
         if (modules & (1 << i)).count_ones() == 1 {
             let module_string = match i {
                 0 => "ANALYZE",
@@ -25,15 +29,15 @@ pub(crate)fn modules_to_string(modules: u32) -> String {
                 7 => "PAWN_STRUCTURE",
                 8 => "TAPERED_EVERY_PESTO_PSQT",
                 9 => "TAPERED_INCREMENTAL_PESTO_PSQT",
-                _ => "INVALID MODULE DETECTED"
+                _ => "INVALID MODULE DETECTED",
             };
             if !start {
-                output = output + &", " + module_string;
+                output = output + ", " + module_string;
             } else {
                 start = false;
                 output = module_string.to_string();
             }
         }
     }
     output
-}
+}

src/main.rs

@@ -1,81 +1,119 @@
+use std::fs::remove_file;
+use std::mem;
 use std::time::Duration;
 
-
 use crate::algorithms::the_algorithm::Algorithm;
 #[allow(unused_imports)]
-use crate::common::constants::{modules::{
-    ALPHA_BETA, ANALYZE, NAIVE_PSQT, PAWN_STRUCTURE, SEARCH_EXTENSIONS, SKIP_BAD_MOVES,
-    SQUARE_CONTROL_METRIC, TAPERED_EVERY_PESTO_PSQT, TAPERED_INCREMENTAL_PESTO_PSQT,
-    TRANSPOSITION_TABLE,
-}, NUMBER_OF_MODULES};
-use crate::io::{write_result, modules_to_string};
+use crate::common::constants::{
+    modules::{
+        ALPHA_BETA, ANALYZE, NAIVE_PSQT, PAWN_STRUCTURE, SEARCH_EXTENSIONS, SKIP_BAD_MOVES,
+        SQUARE_CONTROL_METRIC, TAPERED_EVERY_PESTO_PSQT, TAPERED_INCREMENTAL_PESTO_PSQT,
+        TRANSPOSITION_TABLE,
+    },
+    NUMBER_OF_MODULES,
+};
+use crate::io::write_result;
 
 use self::pitter::logic::{Competition, CompetitionResults};
 
 mod algorithms;
 mod common;
+mod io;
 mod modules;
 mod pitter;
-mod io;
 
 //If we should print the moves played and results of each game.
 pub(crate) const PRINT_GAME: bool = true;
 //If we should test all possible pairs of combinations.
 const TEST_ALL_PAIRS: bool = true;
 
-
 #[tokio::main]
 async fn main() {
+    remove_file("./output.txt").unwrap_or_default();
     if !TEST_ALL_PAIRS {
         //ALPHA_BETA | ANALYZE | SEARCH_EXTENSIONS | SKIP_BAD_MOVES | SQUARE_CONTROL_METRIC | TRANSPOSITION_TABLE | NAIVE_PSQT | PAWN_STRUCTURE | TAPERED_EVERY_PESTO_PSQT | TAPERED_INCREMENTAL_PESTO_PSQT
         //Put 0 for no modules.
         //Setup modules
-        let modules1 = ALPHA_BETA | TAPERED_INCREMENTAL_PESTO_PSQT;
-        let modules2 = ALPHA_BETA | TAPERED_EVERY_PESTO_PSQT;
+        let modules1 = TRANSPOSITION_TABLE;
+        let modules2 = 0;
         let time_per_move1 = Duration::from_micros(2000);
         let time_per_move2 = Duration::from_micros(2000);
-        let game_pairs = 500;
+        let game_pairs = 50;
 
         //Run competition
-        let result = do_competition(modules1, modules2, time_per_move1, time_per_move2, game_pairs).await;
-        
-        //Save results to file
-        let mut output: String = "\nAlgo 1 modules: ".to_owned() + &modules_to_string(modules1) + "\nAlgo 2 modules: " + &modules_to_string(modules2)
-                                + &"\nGame pairs: " + &game_pairs.to_string() + &"\nTime per move, algo1: " + &format!("{:?}", time_per_move1) + "\nTime per move, algo2: " + &format!("{:?}", time_per_move2);
-        let result = format!("\nCompetition results: {:#?}", &result);
-        output = output + &result + &"\n\n\n";
-        let buf = output.as_bytes();
-        let _ = write_result(buf, "./output.txt");
-
+        let result = do_competition(
+            modules1,
+            modules2,
+            time_per_move1,
+            time_per_move2,
+            game_pairs,
+        )
+        .await;
+        dbg!(result);
     } else {
-        println!("Running {} possibilites", (NUMBER_OF_MODULES+1)*NUMBER_OF_MODULES/2);
+        println!(
+            "Running {} possibilites",
+            (NUMBER_OF_MODULES + 1) * NUMBER_OF_MODULES / 2
+        );
         let time_per_move1 = Duration::from_micros(2000);
         let time_per_move2 = Duration::from_micros(2000);
-        let game_pairs = 1000;
-        
+        let game_pairs = 200;
+
         let mut competitions_run: u32 = 0;
-        for i in 0..NUMBER_OF_MODULES+1 {
-            for j in i+1..NUMBER_OF_MODULES+1 {
+        let mut dp: Vec<Vec<Option<CompetitionResults>>> =
+            vec![vec![None; NUMBER_OF_MODULES]; NUMBER_OF_MODULES];
+        for i in 0..NUMBER_OF_MODULES {
+            for j in 0..NUMBER_OF_MODULES {
+                if dp[j][i].is_some() {
+                    let mut temp = dp[j][i].unwrap();
+                    let output: String =
+                        format!("{}\t", temp.algo2_wins as i64 - temp.algo1_wins as i64);
+                    let buf = output.as_bytes();
+                    let _ = write_result(buf, "./output.txt");
+                    mem::swap(&mut temp.algo1_wins, &mut temp.algo2_wins);
+                    dp[i][j] = Some(temp);
+                    continue;
+                }
                 competitions_run += 1;
-                println!("\rTesting pair {} out of {}", competitions_run, (NUMBER_OF_MODULES+1)*NUMBER_OF_MODULES/2);
-                let modules1 = 1 << i;
-                let modules2 = 1 << j;
+                println!(
+                    "\rTesting pair {} out of {}",
+                    competitions_run,
+                    (NUMBER_OF_MODULES + 1) * NUMBER_OF_MODULES / 2
+                );
+
+                // Analyze is useless in this scenario
+                let modules1 = 1 << j;
+                let modules1 = if modules1 == ANALYZE { 0 } else { modules1 };
+                let modules2 = 1 << i;
+                let modules2 = if modules2 == ANALYZE { 0 } else { modules2 };
 
-                let result = do_competition(modules1, modules2, time_per_move1, time_per_move2, game_pairs).await;
+                let result = do_competition(
+                    modules1,
+                    modules2,
+                    time_per_move1,
+                    time_per_move2,
+                    game_pairs,
+                )
+                .await;
 
-                let mut output: String = "\nAlgo 1 modules: ".to_owned() + &modules_to_string(modules1) + "\nAlgo 2 modules: " + &modules_to_string(modules2)
-                                        + &"\nGame pairs: " + &game_pairs.to_string() + &"\nTime per move, algo1: " + &format!("{:?}", time_per_move1) + "\nTime per move, algo2: " + &format!("{:?}", time_per_move2);
-                let result = format!("\nCompetition results: {:#?}", &result);
-                output = output + &result + &"\n\n\n";
+                dp[i][j] = Some(result);
+                let output: String =
+                    format!("{}\t", result.algo1_wins as i64 - result.algo2_wins as i64);
                 let buf = output.as_bytes();
-                let _ = write_result(buf, "./output.txt");   
+                let _ = write_result(buf, "./output.txt");
             }
+            let _ = write_result("\n".as_bytes(), "./output.txt");
         }
     }
-    
 }
 
-async fn do_competition(modules1: u32, modules2: u32, time_per_move1: Duration, time_per_move2: Duration, game_pairs: u32) -> CompetitionResults {
+async fn do_competition(
+    modules1: u32,
+    modules2: u32,
+    time_per_move1: Duration,
+    time_per_move2: Duration,
+    game_pairs: u32,
+) -> CompetitionResults {
     let competition = Competition::new(
         Algorithm::new(modules1, time_per_move1),
         Algorithm::new(modules2, time_per_move2),
@@ -84,6 +122,5 @@ async fn do_competition(modules1: u32, modules2: u32, time_per_move1: Duration,
     // competition.analyze_algorithm_choices(|(game_info, _), _| {
     //     game_info.outcome == GameOutcome::InconclusiveTooLong
     // });
-    let results = competition.start_competition(game_pairs).await;
-    results
+    competition.start_competition(game_pairs).await
 }

src/modules/alpha_beta.rs

@@ -13,5 +13,5 @@ pub(crate) fn calc_new(
             beta = beta.min(eval);
         }
     }
-    return (alpha, beta);
+    (alpha, beta)
 }

src/modules/analyze.rs

@@ -26,5 +26,5 @@ pub(crate) fn get_debug_data(
         let previous_best_move = previous_best_move.to_string();
         utils::vector_push_debug!(vec, previous_best_move);
     }
-    return vec;
+    vec
 }

src/modules/search_extensions.rs

@@ -6,12 +6,11 @@ pub fn calculate(
     new_board: Board,
     search_extensions: bool,
 ) -> u32 {
-    let extend_by = if !search_extensions || num_extensions > 3 {
+    if !search_extensions || num_extensions > 3 {
         0
     } else if num_legal_moves == 1 || new_board.checkers().popcnt() >= 2 {
         1
     } else {
         0
-    };
-    extend_by
+    }
 }

src/modules/transposition_table.rs

@@ -38,7 +38,7 @@ pub(crate) fn get_transposition_entry(
 ) -> Option<TranspositionEntry> {
     let start = Instant::now();
 
-    let transposition_entry = transposition_table.get(&board).copied();
+    let transposition_entry = transposition_table.get(board).copied();
 
     let time_for_transposition_access = Instant::now() - start;
     stats.time_for_transposition_access += time_for_transposition_access;