Merge pull request #1 from Nervonment/fish

basic fish

Cargo.toml

@@ -7,11 +7,20 @@ default-run = "example"
 [dependencies]
 criterion = "0.5.1"
 rand = "0.8.5"
+itertools = "0.13.0"
 
 [[bench]]
 name = "solver_benches"
 harness = false
 
+[[bench]]
+name = "generator_benches"
+harness = false
+
+[[bench]]
+name = "techniques_benches"
+harness = false
+
 [[bin]]
 name = "example"
 test = false

README.md

@@ -1,5 +1,5 @@
 # sudoku
 
-A library for sudoku puzzle generating & solving. 
+A library for sudoku puzzle generating, analyzing & solving. 
 
 Run `cargo run` to see the example. 

benches/generator_benches.rs

@@ -0,0 +1,31 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use sudoku::generator::{
+    random_sudoku_puzzle_easy, random_sudoku_puzzle_extrahard, random_sudoku_puzzle_hard,
+    random_sudoku_puzzle_normal,
+};
+
+fn benchmarks(c: &mut Criterion) {
+    c.bench_function("easy", |b| {
+        b.iter(|| {
+            random_sudoku_puzzle_easy();
+        })
+    });
+    c.bench_function("normal", |b| {
+        b.iter(|| {
+            random_sudoku_puzzle_normal();
+        })
+    });
+    c.bench_function("hard", |b| {
+        b.iter(|| {
+            random_sudoku_puzzle_hard();
+        })
+    });
+    c.bench_function("extrahard", |b| {
+        b.iter(|| {
+            random_sudoku_puzzle_extrahard();
+        })
+    });
+}
+
+criterion_group!(benches, benchmarks);
+criterion_main!(benches);

benches/techniques_benches.rs

@@ -0,0 +1,65 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use sudoku::{
+    generator::random_sudoku_puzzle_ultimate,
+    state::full_state::FullState,
+    techniques::{
+        fish::{Jellyfish, Swordfish, XWing},
+        hidden_subsets::HiddenPair,
+        locked_candidates::{Claiming, Pointing},
+        naked_subsets::{NakedPair, NakedSubset},
+        Technique,
+    },
+};
+
+fn benchmarks(c: &mut Criterion) {
+    let puzzle = random_sudoku_puzzle_ultimate();
+    let state = FullState::from(puzzle);
+
+    c.bench_function("Hidden Pair", |b| {
+        b.iter(|| {
+            HiddenPair::default().analyze(&state);
+        })
+    });
+    c.bench_function("Naked Pair", |b| {
+        b.iter(|| {
+            NakedPair::default().analyze(&state);
+        })
+    });
+    c.bench_function("Pointing", |b| {
+        b.iter(|| {
+            Pointing::default().analyze(&state);
+        })
+    });
+    c.bench_function("Claiming", |b| {
+        b.iter(|| {
+            Claiming::default().analyze(&state);
+        })
+    });
+    c.bench_function("Naked Subset", |b| {
+        b.iter(|| {
+            NakedSubset::default().analyze(&state);
+        })
+    });
+    c.bench_function("X-Wing", |b| {
+        b.iter(|| {
+            XWing::default().analyze(&state);
+        })
+    });
+    c.bench_function("Swordfish", |b| {
+        b.iter(|| {
+            Swordfish::default().analyze(&state);
+        })
+    });
+    c.bench_function("Jellyfish", |b| {
+        b.iter(|| {
+            Jellyfish::default().analyze(&state);
+        })
+    });
+}
+
+criterion_group! {
+    name=benches;
+    config=Criterion::default().significance_level(0.1).sample_size(1000);
+    targets=benchmarks
+}
+criterion_main!(benches);

src/bin/example.rs

@@ -1,8 +1,9 @@
 use sudoku::{
-    generator::random_sudoku_puzzle_normal,
+    generator::random_sudoku_puzzle_hard,
     solver::{advanced::AdvancedSolver, Grader, Solver},
     state::full_state::FullState,
     techniques::{
+        fish::XWing,
         hidden_subsets::{HiddenPair, HiddenPairBlock, HiddenPairColumn, HiddenPairRow},
         locked_candidates::{Claiming, Pointing},
         naked_subsets::{NakedPair, NakedPairBlock, NakedPairColumn, NakedPairRow, NakedSubset},
@@ -14,7 +15,7 @@ use sudoku::{
 };
 
 fn main() {
-    let grid = random_sudoku_puzzle_normal();
+    let grid = random_sudoku_puzzle_hard();
     println!("The sudoku puzzle: ");
     println!("{}", grid);
     println!();
@@ -38,7 +39,7 @@ fn main() {
     }
     println!();
 
-    let reducing_techniques: [(&mut dyn ReducingCandidates<FullState>, &str); 11] = [
+    let reducing_techniques: [(&mut dyn ReducingCandidates<FullState>, &str); 12] = [
         (&mut Pointing::default(), "Pointing"),
         (&mut Claiming::default(), "Claiming"),
         (&mut NakedPair::default(), "NakedPair"),
@@ -50,6 +51,7 @@ fn main() {
         (&mut HiddenPairRow::default(), "HiddenPairRow"),
         (&mut HiddenPairColumn::default(), "HiddenPairColumn"),
         (&mut NakedSubset::default(), "NakedSubset"),
+        (&mut XWing::default(), "X-Wing"),
     ];
 
     println!("Reducing-candidates techniques appliable: ");

src/generator.rs

@@ -137,7 +137,7 @@ pub fn random_sudoku_puzzle_hard() -> Grid {
 pub fn random_sudoku_puzzle_extrahard() -> Grid {
     random_sudoku_puzzle::<StochasticSolver, AdvancedSolver, f32>(
         45,
-        55.0 * 2.6 * 7.2f32.ln(),
+        55.0 * 2.6 * 6.0f32.ln(),
         55.0 * 3.2 * 12.0f32.ln(),
     )
 }

src/solver/advanced.rs

@@ -4,6 +4,7 @@ use crate::{
         TrackingCandidates, TrackingCellCountOfCandidate,
     },
     techniques::{
+        fish::{Jellyfish, Swordfish, XWing},
         hidden_subsets::HiddenPair,
         locked_candidates::{Claiming, Pointing},
         naked_subsets::{NakedPair, NakedSubset},
@@ -77,12 +78,15 @@ where
             }
         }
 
-        let reducing_techniques: [&mut dyn ReducingCandidates<T>; 5] = [
+        let reducing_techniques: [&mut dyn ReducingCandidates<T>; 8] = [
             &mut Pointing::default(),
             &mut Claiming::default(),
             &mut NakedPair::default(),
             &mut HiddenPair::default(),
+            &mut XWing::default(),
             &mut NakedSubset::default(),
+            &mut Swordfish::default(),
+            &mut Jellyfish::default(),
         ];
         // TODO: Fish, Unique Rectangle
 

src/techniques.rs

@@ -70,6 +70,7 @@ pub enum House {
     Block(usize),
 }
 
+pub mod fish;
 pub mod hidden_subsets;
 pub mod locked_candidates;
 pub mod naked_subsets;