Rename key variable in various techniques

huangsam · huangsam · commit e4abdaf1fe4a · 2025-06-05T08:48:27.000-07:00
diff --git a/rustoku-lib/src/core/techniques/hidden_pairs.rs b/rustoku-lib/src/core/techniques/hidden_pairs.rs
@@ -13,7 +13,7 @@ impl HiddenPairs {
         path: &mut SolvePath,
         flags: TechniqueFlags,
     ) -> bool {
-        let mut unit_placements_made = false;
+        let mut eliminations_made = false;
 
         for n1_val in 1..=9 {
             for n2_val in (n1_val + 1)..=9 {
@@ -50,7 +50,7 @@ impl HiddenPairs {
                     let elimination_mask1 = current_mask1 & !pair_mask;
 
                     if elimination_mask1 != 0 {
-                        unit_placements_made |= prop.eliminate_multiple_candidates(
+                        eliminations_made |= prop.eliminate_multiple_candidates(
                             r1,
                             c1,
                             elimination_mask1,
@@ -64,7 +64,7 @@ impl HiddenPairs {
                     let elimination_mask2 = current_mask2 & !pair_mask;
 
                     if elimination_mask2 != 0 {
-                        unit_placements_made |= prop.eliminate_multiple_candidates(
+                        eliminations_made |= prop.eliminate_multiple_candidates(
                             r2,
                             c2,
                             elimination_mask2,
@@ -75,7 +75,7 @@ impl HiddenPairs {
                 }
             }
         }
-        unit_placements_made
+        eliminations_made
     }
 }
 
diff --git a/rustoku-lib/src/core/techniques/locked_candidates.rs b/rustoku-lib/src/core/techniques/locked_candidates.rs
@@ -14,7 +14,7 @@ impl LockedCandidates {
         path: &mut SolvePath,
         flags: TechniqueFlags,
     ) -> bool {
-        let mut placements_made = false;
+        let mut eliminations_made = false;
 
         for candidate in 1..=9 {
             let candidate_bit = 1 << (candidate - 1);
@@ -41,15 +41,15 @@ impl LockedCandidates {
                         if r != row && prop.board.is_empty(r, c) {
                             let initial_mask = prop.candidates.get(r, c);
                             if (initial_mask & candidate_bit) != 0 {
-                                placements_made |=
+                                eliminations_made |=
                                     prop.eliminate_candidate(r, c, candidate_bit, flags, path);
                             }
                         }
                     }
                 }
             }
         }
-        placements_made
+        eliminations_made
     }
 
     // Helper function for Locked Candidates (column), private to this impl block
@@ -59,7 +59,7 @@ impl LockedCandidates {
         path: &mut SolvePath,
         flags: TechniqueFlags,
     ) -> bool {
-        let mut placements_made = false;
+        let mut eliminations_made = false;
 
         for candidate in 1..=9 {
             let candidate_bit = 1 << (candidate - 1);
@@ -86,15 +86,15 @@ impl LockedCandidates {
                         if c != col && prop.board.is_empty(r, c) {
                             let initial_mask = prop.candidates.get(r, c);
                             if (initial_mask & candidate_bit) != 0 {
-                                placements_made |=
+                                eliminations_made |=
                                     prop.eliminate_candidate(r, c, candidate_bit, flags, path);
                             }
                         }
                     }
                 }
             }
         }
-        placements_made
+        eliminations_made
     }
 
     // Helper function for Locked Candidates (box), private to this impl block
@@ -104,7 +104,7 @@ impl LockedCandidates {
         path: &mut SolvePath,
         flags: TechniqueFlags,
     ) -> bool {
-        let mut placements_made = false;
+        let mut eliminations_made = false;
         let start_row = (box_idx / 3) * 3;
         let start_col = (box_idx % 3) * 3;
 
@@ -132,7 +132,7 @@ impl LockedCandidates {
                     if (c < start_col || c >= start_col + 3) && prop.board.is_empty(row, c) {
                         let initial_mask = prop.candidates.get(row, c);
                         if (initial_mask & candidate_bit) != 0 {
-                            placements_made |=
+                            eliminations_made |=
                                 prop.eliminate_candidate(row, c, candidate_bit, flags, path);
                         }
                     }
@@ -148,40 +148,40 @@ impl LockedCandidates {
                     if (r < start_row || r >= start_row + 3) && prop.board.is_empty(r, col) {
                         let initial_mask = prop.candidates.get(r, col);
                         if (initial_mask & candidate_bit) != 0 {
-                            placements_made |=
+                            eliminations_made |=
                                 prop.eliminate_candidate(r, col, candidate_bit, flags, path);
                         }
                     }
                 }
             }
         }
-        placements_made
+        eliminations_made
     }
 }
 
 impl TechniqueRule for LockedCandidates {
     fn apply(&self, prop: &mut TechniquePropagator, path: &mut SolvePath) -> bool {
-        let mut overall_placements_made = false;
+        let mut overall_eliminations_made = false;
 
         // Check rows for pointing pairs/triples
         for row in 0..9 {
-            overall_placements_made |=
+            overall_eliminations_made |=
                 Self::process_row_for_locked_candidates(prop, row, path, self.flags());
         }
 
         // Check columns for pointing pairs/triples
         for col in 0..9 {
-            overall_placements_made |=
+            overall_eliminations_made |=
                 Self::process_col_for_locked_candidates(prop, col, path, self.flags());
         }
 
         // Check boxes for box/line reduction
         for box_idx in 0..9 {
-            overall_placements_made |=
+            overall_eliminations_made |=
                 Self::process_box_for_locked_candidates(prop, box_idx, path, self.flags());
         }
 
-        overall_placements_made
+        overall_eliminations_made
     }
 
     fn flags(&self) -> crate::core::TechniqueFlags {
diff --git a/rustoku-lib/src/core/techniques/x_wing.rs b/rustoku-lib/src/core/techniques/x_wing.rs
@@ -7,7 +7,7 @@ pub struct XWing;
 
 impl TechniqueRule for XWing {
     fn apply(&self, prop: &mut TechniquePropagator, path: &mut SolvePath) -> bool {
-        let mut placements_made = false;
+        let mut eliminations_made = false;
 
         for candidate_val in 1..=9 {
             let candidate_bit = 1 << (candidate_val - 1);
@@ -47,7 +47,7 @@ impl TechniqueRule for XWing {
                             if r_other != r1 && r_other != r2 && prop.board.is_empty(r_other, c1) {
                                 let initial_mask = prop.candidates.get(r_other, c1);
                                 if (initial_mask & candidate_bit) != 0 {
-                                    placements_made |= prop.eliminate_candidate(
+                                    eliminations_made |= prop.eliminate_candidate(
                                         r_other,
                                         c1,
                                         candidate_bit,
@@ -63,7 +63,7 @@ impl TechniqueRule for XWing {
                             if r_other != r1 && r_other != r2 && prop.board.is_empty(r_other, c2) {
                                 let initial_mask = prop.candidates.get(r_other, c2);
                                 if (initial_mask & candidate_bit) != 0 {
-                                    placements_made |= prop.eliminate_candidate(
+                                    eliminations_made |= prop.eliminate_candidate(
                                         r_other,
                                         c2,
                                         candidate_bit,
@@ -112,7 +112,7 @@ impl TechniqueRule for XWing {
                             if c_other != c1 && c_other != c2 && prop.board.is_empty(r1, c_other) {
                                 let initial_mask = prop.candidates.get(r1, c_other);
                                 if (initial_mask & candidate_bit) != 0 {
-                                    placements_made |= prop.eliminate_candidate(
+                                    eliminations_made |= prop.eliminate_candidate(
                                         r1,
                                         c_other,
                                         candidate_bit,
@@ -128,7 +128,7 @@ impl TechniqueRule for XWing {
                             if c_other != c1 && c_other != c2 && prop.board.is_empty(r2, c_other) {
                                 let initial_mask = prop.candidates.get(r2, c_other);
                                 if (initial_mask & candidate_bit) != 0 {
-                                    placements_made |= prop.eliminate_candidate(
+                                    eliminations_made |= prop.eliminate_candidate(
                                         r2,
                                         c_other,
                                         candidate_bit,
@@ -142,7 +142,7 @@ impl TechniqueRule for XWing {
                 }
             }
         }
-        placements_made
+        eliminations_made
     }
 
     fn flags(&self) -> crate::core::TechniqueFlags {

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ impl HiddenPairs {`
`13`	`13`	`path: &mut SolvePath,`
`14`	`14`	`flags: TechniqueFlags,`
`15`	`15`	`) -> bool {`
`16`		`- let mut unit_placements_made = false;`
	`16`	`+ let mut eliminations_made = false;`
`17`	`17`
`18`	`18`	`for n1_val in 1..=9 {`
`19`	`19`	`for n2_val in (n1_val + 1)..=9 {`
`@@ -50,7 +50,7 @@ impl HiddenPairs {`
`50`	`50`	`let elimination_mask1 = current_mask1 & !pair_mask;`
`51`	`51`
`52`	`52`	`if elimination_mask1 != 0 {`
`53`		`- unit_placements_made \|= prop.eliminate_multiple_candidates(`
	`53`	`+ eliminations_made \|= prop.eliminate_multiple_candidates(`
`54`	`54`	`r1,`
`55`	`55`	`c1,`
`56`	`56`	`elimination_mask1,`
`@@ -64,7 +64,7 @@ impl HiddenPairs {`
`64`	`64`	`let elimination_mask2 = current_mask2 & !pair_mask;`
`65`	`65`
`66`	`66`	`if elimination_mask2 != 0 {`
`67`		`- unit_placements_made \|= prop.eliminate_multiple_candidates(`
	`67`	`+ eliminations_made \|= prop.eliminate_multiple_candidates(`
`68`	`68`	`r2,`
`69`	`69`	`c2,`
`70`	`70`	`elimination_mask2,`
`@@ -75,7 +75,7 @@ impl HiddenPairs {`
`75`	`75`	`}`
`76`	`76`	`}`
`77`	`77`	`}`
`78`		`- unit_placements_made`
	`78`	`+ eliminations_made`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ impl LockedCandidates {`
`14`	`14`	`path: &mut SolvePath,`
`15`	`15`	`flags: TechniqueFlags,`
`16`	`16`	`) -> bool {`
`17`		`- let mut placements_made = false;`
	`17`	`+ let mut eliminations_made = false;`
`18`	`18`
`19`	`19`	`for candidate in 1..=9 {`
`20`	`20`	`let candidate_bit = 1 << (candidate - 1);`
`@@ -41,15 +41,15 @@ impl LockedCandidates {`
`41`	`41`	`if r != row && prop.board.is_empty(r, c) {`
`42`	`42`	`let initial_mask = prop.candidates.get(r, c);`
`43`	`43`	`if (initial_mask & candidate_bit) != 0 {`
`44`		`- placements_made \|=`
	`44`	`+ eliminations_made \|=`
`45`	`45`	`prop.eliminate_candidate(r, c, candidate_bit, flags, path);`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`	`}`
`52`		`- placements_made`
	`52`	`+ eliminations_made`
`53`	`53`	`}`
`54`	`54`
`55`	`55`	`// Helper function for Locked Candidates (column), private to this impl block`
`@@ -59,7 +59,7 @@ impl LockedCandidates {`
`59`	`59`	`path: &mut SolvePath,`
`60`	`60`	`flags: TechniqueFlags,`
`61`	`61`	`) -> bool {`
`62`		`- let mut placements_made = false;`
	`62`	`+ let mut eliminations_made = false;`
`63`	`63`
`64`	`64`	`for candidate in 1..=9 {`
`65`	`65`	`let candidate_bit = 1 << (candidate - 1);`
`@@ -86,15 +86,15 @@ impl LockedCandidates {`
`86`	`86`	`if c != col && prop.board.is_empty(r, c) {`
`87`	`87`	`let initial_mask = prop.candidates.get(r, c);`
`88`	`88`	`if (initial_mask & candidate_bit) != 0 {`
`89`		`- placements_made \|=`
	`89`	`+ eliminations_made \|=`
`90`	`90`	`prop.eliminate_candidate(r, c, candidate_bit, flags, path);`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`	`}`
`96`	`96`	`}`
`97`		`- placements_made`
	`97`	`+ eliminations_made`
`98`	`98`	`}`
`99`	`99`
`100`	`100`	`// Helper function for Locked Candidates (box), private to this impl block`
`@@ -104,7 +104,7 @@ impl LockedCandidates {`
`104`	`104`	`path: &mut SolvePath,`
`105`	`105`	`flags: TechniqueFlags,`
`106`	`106`	`) -> bool {`
`107`		`- let mut placements_made = false;`
	`107`	`+ let mut eliminations_made = false;`
`108`	`108`	`let start_row = (box_idx / 3) * 3;`
`109`	`109`	`let start_col = (box_idx % 3) * 3;`
`110`	`110`
`@@ -132,7 +132,7 @@ impl LockedCandidates {`
`132`	`132`	`if (c < start_col \|\| c >= start_col + 3) && prop.board.is_empty(row, c) {`
`133`	`133`	`let initial_mask = prop.candidates.get(row, c);`
`134`	`134`	`if (initial_mask & candidate_bit) != 0 {`
`135`		`- placements_made \|=`
	`135`	`+ eliminations_made \|=`
`136`	`136`	`prop.eliminate_candidate(row, c, candidate_bit, flags, path);`
`137`	`137`	`}`
`138`	`138`	`}`
`@@ -148,40 +148,40 @@ impl LockedCandidates {`
`148`	`148`	`if (r < start_row \|\| r >= start_row + 3) && prop.board.is_empty(r, col) {`
`149`	`149`	`let initial_mask = prop.candidates.get(r, col);`
`150`	`150`	`if (initial_mask & candidate_bit) != 0 {`
`151`		`- placements_made \|=`
	`151`	`+ eliminations_made \|=`
`152`	`152`	`prop.eliminate_candidate(r, col, candidate_bit, flags, path);`
`153`	`153`	`}`
`154`	`154`	`}`
`155`	`155`	`}`
`156`	`156`	`}`
`157`	`157`	`}`
`158`		`- placements_made`
	`158`	`+ eliminations_made`
`159`	`159`	`}`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`impl TechniqueRule for LockedCandidates {`
`163`	`163`	`fn apply(&self, prop: &mut TechniquePropagator, path: &mut SolvePath) -> bool {`
`164`		`- let mut overall_placements_made = false;`
	`164`	`+ let mut overall_eliminations_made = false;`
`165`	`165`
`166`	`166`	`// Check rows for pointing pairs/triples`
`167`	`167`	`for row in 0..9 {`
`168`		`- overall_placements_made \|=`
	`168`	`+ overall_eliminations_made \|=`
`169`	`169`	`Self::process_row_for_locked_candidates(prop, row, path, self.flags());`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`// Check columns for pointing pairs/triples`
`173`	`173`	`for col in 0..9 {`
`174`		`- overall_placements_made \|=`
	`174`	`+ overall_eliminations_made \|=`
`175`	`175`	`Self::process_col_for_locked_candidates(prop, col, path, self.flags());`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`// Check boxes for box/line reduction`
`179`	`179`	`for box_idx in 0..9 {`
`180`		`- overall_placements_made \|=`
	`180`	`+ overall_eliminations_made \|=`
`181`	`181`	`Self::process_box_for_locked_candidates(prop, box_idx, path, self.flags());`
`182`	`182`	`}`
`183`	`183`
`184`		`- overall_placements_made`
	`184`	`+ overall_eliminations_made`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`fn flags(&self) -> crate::core::TechniqueFlags {`