chore: move history calc to a function

Ensure that the calculation is always "safe", even if end up saturating the value.
bench: 2517656

Author: DeveloperPaul123

engine/src/history_table.rs

@@ -10,6 +10,22 @@ pub struct HistoryTable {
     table: [[[LargeScoreType; NumberOf::SQUARES]; NumberOf::PIECE_TYPES]; NumberOf::SIDES],
 }
 
+/// Safe calculation of the bonus applied to quiet moves that are inserted into the history table.
+/// This uses `wrapping_mul` and `wrapping_sub` to safely calculate the value.
+///
+/// # Arguments
+///
+/// - depth: The current depth
+///
+/// # Returns
+///
+/// The calculated history score.
+pub(crate) fn calculate_bonus_for_depth(depth: i16) -> i16 {
+    depth
+        .wrapping_mul(Score::HISTORY_MULT)
+        .wrapping_sub(Score::HISTORY_OFFSET)
+}
+
 impl HistoryTable {
     pub(crate) fn new() -> Self {
         let table =
@@ -63,7 +79,9 @@ impl Default for HistoryTable {
 
 #[cfg(test)]
 mod tests {
-    use super::HistoryTable;
+    use crate::defs::MAX_DEPTH;
+
+    use super::{HistoryTable, calculate_bonus_for_depth};
     use chess::{definitions::Squares, pieces::Piece, side::Side};
 
     #[test]
@@ -94,4 +112,13 @@ mod tests {
         history_table.update(side, piece, square, score);
         assert_eq!(history_table.get(side, piece, square), score + score);
     }
+
+    #[test]
+    fn calculate_bonus_for_any_depth() {
+        for depth in 1..MAX_DEPTH {
+            let bonus = calculate_bonus_for_depth(depth as i16);
+            assert!(bonus > 0);
+            assert!(bonus as i32 <= i16::MAX.into());
+        }
+    }
 }

engine/src/score.rs

@@ -53,8 +53,13 @@ impl Score {
     pub const MINIMUM_MATE: Score = Score(Score::MATE.0 - MAX_DEPTH as ScoreType);
     pub const INF: Score = Score(ScoreType::MAX as ScoreType);
 
-    // Max/min score for history heuristic
-    // Must be lower then the minimum score for captures in MVV_LVA
+    /// Multiplier for the history bonus calculation.
+    pub const HISTORY_MULT: ScoreType = 300;
+    /// Offset for the history bonus calculation.
+    pub const HISTORY_OFFSET: ScoreType = 250;
+
+    /// Max/min score for history heuristic
+    /// Must be lower then the minimum score for captures in MVV_LVA
     pub const MAX_HISTORY: LargeScoreType = 16_384;
 
     pub fn new(score: ScoreType) -> Score {

engine/src/search.rs

@@ -33,7 +33,7 @@ use crate::{
     aspiration_window::AspirationWindow,
     defs::MAX_DEPTH,
     evaluation::ByteKnightEvaluation,
-    history_table::HistoryTable,
+    history_table::{self, HistoryTable},
     inplace_incremental_sort::InplaceIncrementalSort,
     lmr,
     move_order::MoveOrder,
@@ -478,7 +478,7 @@ impl<'a> Search<'a> {
                     // update history table for quiets
                     if mv.is_quiet() {
                         // calculate history bonus
-                        let bonus = depth.wrapping_mul(300) - 250;
+                        let bonus = history_table::calculate_bonus_for_depth(depth);
                         self.history_table.update(
                             board.side_to_move(),
                             mv.piece(),