Merge pull request #5 from LelleSwe/main

sync

Author: LelleSwe

Cargo.lock

@@ -16,7 +16,7 @@ pub fn eval_no_legal_moves(board: &Board) -> f32 {
         f32::MAX
     };
 }
-pub fn new_eval_is_better(maximise: bool, old: &Evaluation, new: &Evaluation) -> bool {
+pub(crate) fn new_eval_is_better(maximise: bool, old: &Evaluation, new: &Evaluation) -> bool {
     new.eval.is_some()
         && (old.eval.is_none()
             || maximise && new.eval.unwrap() > old.eval.unwrap()

src/algorithms/eval.rs

@@ -13,6 +13,7 @@ use crate::modules::{alpha_beta, analyze};
 
 use super::utils::Evaluation;
 
+
 #[derive(Clone, Debug)]
 pub(crate) struct Algorithm {
     pub(crate) modules: u32,

src/algorithms/the_algorithm.rs

@@ -11,6 +11,8 @@ pub(crate) mod modules {
     pub(crate) const TAPERED_INCREMENTAL_PESTO_PSQT: u32 = 1 << 9;
 }
 
+pub(crate) const NUMBER_OF_MODULES: u32 = 9;
+
 //NAIVE_PSQT TABLES
 pub(crate) mod naive_psqt_tables {
     #[rustfmt::skip]

src/common/constants.rs

@@ -0,0 +1,39 @@
+use std::{fs::OpenOptions, io::{self, 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)?;
+    Ok(())
+}
+
+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 {
+        if (modules & (1 << i)).count_ones() == 1 {
+            let module_string = match i {
+                0 => "ANALYZE",
+                1 => "ALPHA_BETA",
+                2 => "TRANSPOSITION_TABLE",
+                3 => "SEARCH_EXTENSIONS",
+                4 => "SQUARE_CONTROL_METRIC",
+                5 => "SKIP_BAD_MOVES",
+                6 => "NAIVE_PSQT",
+                7 => "PAWN_STRUCTURE",
+                8 => "TAPERED_EVERY_PESTO_PSQT",
+                9 => "TAPERED_INCREMENTAL_PESTO_PSQT",
+                _ => "INVALID MODULE DETECTED"
+            };
+            if !start {
+                output = output + &", " + module_string;
+            } else {
+                start = false;
+                output = module_string.to_string();
+            }
+        }
+    }
+    output
+}

src/io.rs

@@ -1,32 +1,81 @@
 use std::time::Duration;
 
+
 use crate::algorithms::the_algorithm::Algorithm;
 #[allow(unused_imports)]
-use crate::common::constants::modules::{
+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 self::pitter::logic::Competition;
+use self::pitter::logic::{Competition, CompetitionResults};
 
 mod algorithms;
 mod common;
 mod modules;
 mod pitter;
+mod io;
 
 //If we should print the moves played and results of each game.
-pub(crate) const PRINT_GAME: bool = false;
+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() {
-    //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.
-    let modules1 = ALPHA_BETA | TAPERED_EVERY_PESTO_PSQT;
-    let modules2 = ALPHA_BETA;
-    let time_per_move1 = Duration::from_micros(4000);
-    let time_per_move2 = Duration::from_micros(2000);
+    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 time_per_move1 = Duration::from_micros(2000);
+        let time_per_move2 = Duration::from_micros(2000);
+        let game_pairs = 500;
+
+        //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");
+
+    } else {
+        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 mut competitions_run: u32 = 0;
+        for i in 0..NUMBER_OF_MODULES+1 {
+            for j in i+1..NUMBER_OF_MODULES+1 {
+                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;
+
+                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";
+                let buf = output.as_bytes();
+                let _ = write_result(buf, "./output.txt");   
+            }
+        }
+    }
+    
+}
 
+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),
@@ -35,6 +84,6 @@ async fn main() {
     // competition.analyze_algorithm_choices(|(game_info, _), _| {
     //     game_info.outcome == GameOutcome::InconclusiveTooLong
     // });
-    let results = competition.start_competition(1000).await;
-    dbg!(results);
+    let results = competition.start_competition(game_pairs).await;
+    results
 }

src/main.rs

@@ -9,16 +9,16 @@ use crate::common::utils::Stats;
 #[derive(Debug, Copy, Clone)]
 pub struct TranspositionEntry {
     pub depth: u32,
-    pub evaluation: Evaluation,
+    pub(crate) evaluation: Evaluation,
 }
 
 impl TranspositionEntry {
-    pub fn new(depth: u32, evaluation: Evaluation) -> Self {
+    pub(crate) fn new(depth: u32, evaluation: Evaluation) -> Self {
         TranspositionEntry { depth, evaluation }
     }
 }
 
-pub fn insert_in_transposition_table(
+pub(crate) fn insert_in_transposition_table(
     transposition_table: &mut HashMap<Board, TranspositionEntry>,
     board: &Board,
     depth: u32,
@@ -31,7 +31,7 @@ pub fn insert_in_transposition_table(
     stats.transposition_table_entries += 1
 }
 
-pub fn get_transposition_entry(
+pub(crate) fn get_transposition_entry(
     transposition_table: &HashMap<Board, TranspositionEntry>,
     stats: &mut Stats,
     board: &Board,

src/modules/transposition_table.rs

@@ -5,6 +5,7 @@ use tokio::time::{Duration, Instant};
 use chess::{Action, Board, Color, Game, GameResult};
 use tokio::sync::Mutex;
 
+
 use crate::algorithms::the_algorithm::Algorithm;
 use crate::common::constants::modules::ANALYZE;
 use crate::common::utils::{self, Stats};
@@ -243,8 +244,12 @@ impl Competition {
 
                 //Whether the game just played should be printed in console.
                 if PRINT_GAME {
-                    println!("Game pair played.  Outcome: {:?}", combined_outcome);
-                    println!("{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
+                    //println!("Game pair played.  Outcome: {:?}", combined_outcome);
+                    //println!("{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
+                    let mut buf = format!("\nGame pair played.  Outcome: {:?}", combined_outcome);
+                    buf += &format!("\n{}", utils::to_pgn(&game_pair_info.0.game.unwrap()));
+                    let buf = buf.as_bytes();
+                    let _ = crate::io::write_result(buf, "./output.txt");
                 }
 
                 results.lock().await.register_game_outcome(combined_outcome);
@@ -262,16 +267,27 @@ impl Competition {
             tasks.push(task);
         }
         for task in tasks {
-            task.await;
+            let _ = task.await;
         }
         let sum_stats = sum_stats.lock().await;
         let avg_stats = (
             sum_stats.0 / sum_stats.0.num_plies,
             sum_stats.1 / sum_stats.1.num_plies,
         );
 
-        println!("Stats for algo1: {:#?}", avg_stats.0);
-        println!("Stats for algo2: {:#?}", avg_stats.1);
+        //I don't know why I have to do this middle step terribleness, 
+        //but for some reason it won't compile otherwise.
+        let algo1stats = format!("Stats for algo1: {:#?}", avg_stats.0);
+        let algo1stats = algo1stats.as_bytes();
+        let algo2stats = format!("Stats for algo2: {:#?}", avg_stats.1);
+        let algo2stats = algo2stats.as_bytes();
+        
+        //Marking that the result from these calls won't be used.
+        let _ = crate::io::write_result(algo1stats, "./output.txt");
+        let _ = crate::io::write_result(algo2stats, "./output.txt");
+
+        //println!("Stats for algo1: {:#?}", avg_stats.0);
+        //println!("Stats for algo2: {:#?}", avg_stats.1);
 
         // Gives E0597 otherwise
         #[allow(clippy::let_and_return)]
@@ -359,7 +375,7 @@ impl Competition {
             i += 1;
         }
 
-        dbg!(&self.algo1.board_played_times.values());
-        dbg!(&self.algo2.board_played_times.values());
+        /*let _ = write_result(stringify!(&self.algo1.board_played_times.values()).as_bytes(), "./output.txt");
+        let _ = write_result(stringify!(&self.algo2.board_played_times.values()).as_bytes(), "./output.txt");*/
     }
 }