Merge pull request #63 from Apricot-S/develop

v3.0.0

Author: Apricot-S

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "xiangting"
 description = "A library for calculating the deficiency number (a.k.a. xiangting number, 向聴数)."
-version = "2.0.6"
+version = "3.0.0"
 authors = ["Apricot S."]
 edition = "2021"
 license = "MIT"
@@ -15,16 +15,16 @@ name = "xiangting"
 path = "src/lib.rs"
 
 [dependencies]
-thiserror = "2.0.0"
+thiserror = "2.0.11"
 
 [dev-dependencies]
 criterion = "0.5.1"
-cxx = "1.0.128"
-mt19937 = "2.0.1"
-rand = "0.8.5"
+cxx = "1.0.137"
+mt19937 = "3.1.0"
+rand = "0.9.0"
 
 [build-dependencies]
-cxx-build = { version = "1.0.128", optional = true }
+cxx-build = { version = "1.0.137", optional = true }
 
 [features]
 build-file = []

README.md

@@ -2,7 +2,7 @@
 
 A library for calculating the deficiency number (a.k.a. xiangting number, 向聴数).
 
-This library is based on the algorithm in [Nyanten](https://github.com/Cryolite/nyanten).  
+This library is based on the algorithm in [Cryolite's Nyanten](https://github.com/Cryolite/nyanten).  
 However, it introduces the following additional features:
 
 - Supports rules that include and exclude melded tiles when determining if a hand contains four identical tiles.

benches/random_hand.rs

@@ -3,7 +3,7 @@
 // This file is part of https://github.com/Apricot-S/xiangting
 
 use mt19937::MT19937;
-use rand::seq::SliceRandom;
+use rand::seq::{IndexedRandom, SliceRandom};
 use rand::{Rng, SeedableRng};
 
 pub fn create_rng() -> MT19937 {

scripts/build_map.sh

@@ -1,13 +1,6 @@
 #!/usr/bin/env bash
 
-start_time=$(date +%s)
-
 cargo run --bin build-map --release --features build-map -- \
     src/standard/shupai_map.rs \
     src/standard/zipai_map.rs \
     src/standard/wanzi_19_map.rs
-
-end_time=$(date +%s)
-execution_time=$((end_time - start_time))
-
-echo "Execution time: $execution_time seconds"

src/bin/build_map/main.rs

@@ -175,6 +175,8 @@ fn dump_map<const N: usize>(map: &Map, map_path: &Path) -> io::Result<()> {
 }
 
 fn main() {
+    let start = std::time::Instant::now();
+
     let args: Vec<String> = env::args().collect();
     if args.len() != 4 {
         eprintln!(
@@ -214,4 +216,7 @@ fn main() {
 
         dump_map::<2>(&wanzi_19_map, wanzi_19_map_path).expect("Failed to dump wanzi 19 map");
     }
+
+    let elapsed_time = start.elapsed();
+    println!("elapsed time: {:?}", elapsed_time);
 }

src/bin/build_map/replacement_number.rs

@@ -6,9 +6,12 @@
 // https://github.com/gimite/MjaiClients/blob/master/src/org/ymatsux/mjai/client/ShantensuUtil.java
 // https://github.com/gimite/mjai-manue/blob/master/coffee/shanten_analysis.coffee
 
+#![allow(clippy::too_many_arguments)]
+
+use std::cmp::Ordering;
+
 const NUM_SHUPAI_IDS: usize = 9;
 const NUM_ZIPAI_IDS: usize = 7;
-
 // 1-7{m,p,s}
 const SEQUENCE_IDS: [usize; 7] = [0, 1, 2, 3, 4, 5, 6];
 
@@ -33,12 +36,16 @@ fn update_upperbound_and_necessary_tiles_0_pair<const N: usize>(
     upperbound: &mut u8,
     necessary_tiles: &mut u16,
 ) {
-    if current_distance < *upperbound {
-        *upperbound = current_distance;
-        *current_necessary_tiles = 0;
-        *necessary_tiles = get_necessary_tiles(hand, winning_hand);
-    } else if current_distance == *upperbound {
-        *necessary_tiles |= get_necessary_tiles(hand, winning_hand);
+    match current_distance.cmp(upperbound) {
+        Ordering::Less => {
+            *upperbound = current_distance;
+            *current_necessary_tiles = 0;
+            *necessary_tiles = get_necessary_tiles(hand, winning_hand);
+        }
+        Ordering::Equal => {
+            *necessary_tiles |= get_necessary_tiles(hand, winning_hand);
+        }
+        Ordering::Greater => {}
     }
 }
 
@@ -149,8 +156,7 @@ pub(super) fn get_shupai_replacement_number(
     // Add sequences
     let start_sequence_id = min_meld_id.saturating_sub(NUM_SHUPAI_IDS);
 
-    for sequence_id in start_sequence_id..SEQUENCE_IDS.len() {
-        let i = SEQUENCE_IDS[sequence_id];
+    for (sequence_id, &i) in SEQUENCE_IDS.iter().enumerate().skip(start_sequence_id) {
         if winning_hand[i..=i + 2].iter().any(|&c| c == 4) {
             // Can't add a sequence
             continue;

src/bingpai.rs

@@ -50,19 +50,23 @@ use thiserror::Error;
 /// ```
 pub type Bingpai = [u8; NUM_TILE_INDEX];
 
+/// Errors that occur when an invalid pure hand (純手牌) is provided.
 #[derive(Debug, Error)]
-pub(crate) enum InvalidBingpaiError {
+pub enum InvalidBingpaiError {
+    /// Same tile count exceeds 4.
     #[error("same tile count must be 4 or less but was {0}")]
     ExceedsMaxNumSameTile(u8),
+    /// Total tile count exceeds 14.
     #[error("total tile count must be 14 or less but was {0}")]
     ExceedsMaxNumBingpai(u8),
-    #[error("hand is empty")]
+    /// Pure hand is empty.
+    #[error("pure hand is empty")]
     EmptyBingpai,
+    /// Total tile count is not a multiple of 3 plus 1 or 2.
     #[error("total tile count must be a multiple of 3 plus 1 or 2 but was {0}")]
     InvalidNumBingpai(u8),
-    #[error(
-        "tile index {0} (must be outside 1 (2m) to 7 (8m)) cannot be used in 3-player mahjong"
-    )]
+    /// Contains tiles that cannot be used in 3-player mahjong (2m to 8m).
+    #[error("tile index {0} cannot be used in 3-player mahjong")]
     InvalidTileFor3Player(usize),
 }
 
@@ -83,10 +87,10 @@ impl BingpaiExt for Bingpai {
         if num_bingpai > MAX_NUM_SHOUPAI {
             return Err(InvalidBingpaiError::ExceedsMaxNumBingpai(num_bingpai));
         }
-        if num_bingpai == 0 {
-            return Err(InvalidBingpaiError::EmptyBingpai);
-        }
         if num_bingpai % 3 == 0 {
+            if num_bingpai == 0 {
+                return Err(InvalidBingpaiError::EmptyBingpai);
+            }
             return Err(InvalidBingpaiError::InvalidNumBingpai(num_bingpai));
         }
 

src/calculate.rs

@@ -203,6 +203,7 @@ pub fn calculate_replacement_number_3_player(
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::bingpai::InvalidBingpaiError;
 
     #[test]
     fn calculate_replacement_number_standard_tenpai() {
@@ -251,7 +252,52 @@ mod tests {
         let replacement_number = calculate_replacement_number(&bingpai, &None);
         assert!(matches!(
             replacement_number.unwrap_err(),
-            InvalidShoupaiError::EmptyShoupai
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::EmptyBingpai)
+        ));
+    }
+
+    #[test]
+    fn calculate_replacement_number_too_many_tiles() {
+        let bingpai: Bingpai = [
+            1, 1, 1, 1, 0, 0, 0, 0, 0, // m
+            1, 1, 1, 1, 0, 0, 0, 0, 0, // p
+            1, 1, 1, 1, 0, 0, 0, 0, 0, // s
+            1, 1, 1, 0, 0, 0, 0, // z
+        ];
+        let replacement_number = calculate_replacement_number(&bingpai, &None);
+        assert!(matches!(
+            replacement_number.unwrap_err(),
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::ExceedsMaxNumBingpai(15))
+        ));
+    }
+
+    #[test]
+    fn calculate_replacement_number_5th_tile() {
+        let bingpai: Bingpai = [
+            5, 0, 0, 0, 0, 0, 0, 0, 0, // m
+            1, 1, 1, 1, 0, 0, 0, 0, 0, // p
+            1, 1, 1, 1, 0, 0, 0, 0, 0, // s
+            1, 0, 0, 0, 0, 0, 0, // z
+        ];
+        let replacement_number = calculate_replacement_number(&bingpai, &None);
+        assert!(matches!(
+            replacement_number.unwrap_err(),
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::ExceedsMaxNumSameTile(5))
+        ));
+    }
+
+    #[test]
+    fn calculate_replacement_number_incomplete_hand() {
+        let bingpai: Bingpai = [
+            4, 4, 4, 0, 0, 0, 0, 0, 0, // m
+            0, 0, 0, 0, 0, 0, 0, 0, 0, // p
+            0, 0, 0, 0, 0, 0, 0, 0, 0, // s
+            0, 0, 0, 0, 0, 0, 0, // z
+        ];
+        let replacement_number = calculate_replacement_number(&bingpai, &None);
+        assert!(matches!(
+            replacement_number.unwrap_err(),
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::InvalidNumBingpai(12))
         ));
     }
 
@@ -302,7 +348,35 @@ mod tests {
         let replacement_number = calculate_replacement_number_3_player(&bingpai, &None);
         assert!(matches!(
             replacement_number.unwrap_err(),
-            InvalidShoupaiError::EmptyShoupai
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::EmptyBingpai)
+        ));
+    }
+
+    #[test]
+    fn calculate_replacement_number_3_player_2m_8m() {
+        let bingpai_2m: Bingpai = [
+            0, 1, 0, 0, 0, 0, 0, 0, 0, // m
+            0, 0, 0, 0, 0, 0, 0, 0, 0, // p
+            0, 0, 0, 0, 0, 0, 0, 0, 0, // s
+            0, 0, 0, 0, 0, 0, 0, // z
+        ];
+        let bingpai_8m: Bingpai = [
+            0, 0, 0, 0, 0, 0, 0, 1, 0, // m
+            0, 0, 0, 0, 0, 0, 0, 0, 0, // p
+            0, 0, 0, 0, 0, 0, 0, 0, 0, // s
+            0, 0, 0, 0, 0, 0, 0, // z
+        ];
+
+        let replacement_number_2m = calculate_replacement_number_3_player(&bingpai_2m, &None);
+        let replacement_number_8m = calculate_replacement_number_3_player(&bingpai_8m, &None);
+
+        assert!(matches!(
+            replacement_number_2m.unwrap_err(),
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::InvalidTileFor3Player(1))
+        ));
+        assert!(matches!(
+            replacement_number_8m.unwrap_err(),
+            InvalidShoupaiError::InvalidBingpai(InvalidBingpaiError::InvalidTileFor3Player(7))
         ));
     }
 }

src/fulu_mianzi.rs

@@ -103,6 +103,9 @@ pub enum InvalidFuluMianziError {
     /// The tile and position combination cannot form a valid sequence.
     #[error("a sequence cannot be made with {0} and {1:?}")]
     InvalidShunziCombination(Tile, ClaimedTilePosition),
+    /// This meld cannot be used in 3-player mahjong (2m to 8m or sequence).
+    #[error("{0} cannot be used in 3-player mahjong")]
+    InvalidFuluMianziFor3Player(FuluMianzi),
 }
 
 impl FuluMianzi {
@@ -132,6 +135,25 @@ impl FuluMianzi {
         }
     }
 
+    pub(crate) fn validate_3_player(&self) -> Result<(), InvalidFuluMianziError> {
+        match self {
+            FuluMianzi::Shunzi(_, _) => {
+                return Err(InvalidFuluMianziError::InvalidFuluMianziFor3Player(
+                    self.clone(),
+                ));
+            }
+            FuluMianzi::Kezi(t) | FuluMianzi::Gangzi(t) => {
+                if (1..8).contains(t) {
+                    return Err(InvalidFuluMianziError::InvalidFuluMianziFor3Player(
+                        self.clone(),
+                    ));
+                }
+            }
+        }
+
+        self.validate()
+    }
+
     #[inline]
     fn is_valid_shunzi_combination(tile: &Tile, position: &ClaimedTilePosition) -> bool {
         match position {

src/lib.rs

@@ -6,7 +6,7 @@
 
 //! A library for calculating the deficiency number (a.k.a. xiangting number, 向聴数).
 //!
-//! This library is based on the algorithm in [Nyanten](https://github.com/Cryolite/nyanten).  
+//! This library is based on the algorithm in [Cryolite's Nyanten](https://github.com/Cryolite/nyanten).  
 //! However, it introduces the following additional features:
 //!
 //! - Supports rules that include and exclude melded tiles when determining if a hand contains four identical tiles.
@@ -50,7 +50,7 @@ mod shoupai;
 mod standard;
 
 #[cfg(not(feature = "build-file"))]
-pub use bingpai::Bingpai;
+pub use bingpai::{Bingpai, InvalidBingpaiError};
 #[cfg(not(feature = "build-file"))]
 pub use calculate::{calculate_replacement_number, calculate_replacement_number_3_player};
 #[cfg(not(feature = "build-file"))]