Minor cleanup & utilities

src/agents/util/partials.rs

@@ -1,10 +1,10 @@
 use itertools::Itertools;
-use std::num::NonZeroU8;
+use std::{mem::swap, num::NonZeroU8};
 
 use crate::{board::Board, util::Symb};
 
-/// Returns an iterator of (sort, coords, char_idx, f32) for each empty slot in the listed partials.
-/// - sort is the index of this slot.
+/// Returns an iterator of (idx, coords, char_idx, f32) for each empty slot in the listed partials.
+/// - idx is the index of this slot in the board string.
 /// - coords are the coordinate of this slot's partial
 /// - char_idx is the index of this slot in its partial
 /// - f32 is the influence of this slot
@@ -51,17 +51,14 @@ pub fn free_slots_by_influence(board: &Board) -> Option<Vec<(usize, f32)>> {
 	Some(slots)
 }
 
-/// Find the maximum possible value of the given board
-#[allow(dead_code)]
-pub fn maximize_value(board: &Board) -> Option<Board> {
+/// Find the minimum or maximum possible value of the given board,
+/// without adding any operations. Returns None if we couldn't find
+/// a best board.
+pub fn best_board_noop(board: &Board, minimize: bool) -> Option<Board> {
 	let n_free = board.get_board().iter().filter(|x| x.is_none()).count();
 
-	// Assume we have 10 or fewer available slots
-	if n_free >= 10 {
-		panic!()
-	}
-
-	let available_numbers = (0..=9)
+	// TODO: fix zero division
+	let available_numbers = (1..=9)
 		.map(|x| match x {
 			0 => Symb::Zero,
 			x => Symb::Number(NonZeroU8::new(x).unwrap()),
@@ -69,19 +66,36 @@ pub fn maximize_value(board: &Board) -> Option<Board> {
 		.filter(|x| !board.contains(*x))
 		.collect::<Vec<_>>();
 
+	if n_free > available_numbers.len() {
+		return None;
+	}
+
 	let slots = free_slots_by_influence(board)?;
 
 	let all_symbols = {
-		// We need this many from the bottom, and this many from the top.
-		let neg_count = slots.iter().filter(|(_, x)| *x <= 0.0).count();
-		let pos_count = slots.iter().filter(|(_, x)| *x > 0.0).count();
+		let mut a = {
+			// Number of slots we want to minimize
+			let mut neg_count = slots.iter().filter(|(_, x)| *x <= 0.0).count();
+			// Number of slots we want to maximize
+			let mut pos_count = slots.iter().filter(|(_, x)| *x > 0.0).count();
 
-		let mut a_iter = available_numbers
-			.iter()
-			.take(neg_count)
-			.chain(available_numbers.iter().rev().take(pos_count).rev());
+			if minimize {
+				swap(&mut neg_count, &mut pos_count);
+			}
 
-		let mut g = slots
+			available_numbers
+				.iter()
+				.take(neg_count)
+				.chain(available_numbers.iter().rev().take(pos_count).rev())
+				.collect_vec()
+		};
+
+		if !minimize {
+			a.reverse();
+		}
+		let mut a_iter = a.into_iter();
+
+		slots
 			// Group slots with equal weights
 			// and count the number of elements in each group
 			.iter()
@@ -101,37 +115,32 @@ pub fn maximize_value(board: &Board) -> Option<Board> {
 			// of this set of sets
 			.multi_cartesian_product()
 			.map(|x| x.iter().flatten().cloned().collect_vec())
-			.map(|v| slots.iter().zip(v).collect_vec())
-			.collect_vec();
-
-		// Sort these vectors so the order of values
-		// matches the order of empty slots
-		g.iter_mut()
-			.for_each(|v| v.sort_by(|(a, _), (b, _)| b.0.partial_cmp(&a.0).unwrap()));
-		g.into_iter()
-			.map(|v| v.into_iter().map(|(_, s)| s).collect_vec())
+			// Finally, attach the coordinate of each slot to each symbol
+			.map(|v| slots.iter().map(|x| x.0).zip(v).collect_vec())
+			.collect_vec()
 	};
 
 	let mut best_board = None;
 	let mut best_value = None;
-	for i in all_symbols {
-		let mut i_iter = i.iter();
-		let filled = Board::from_board(board.get_board().map(|x| match x {
-			None => i_iter.next().cloned(),
-			_ => x,
-		}));
+	for i_iter in all_symbols {
+		let mut tmp_board = board.clone();
+		for (i, s) in i_iter {
+			tmp_board.get_board_mut()[i] = Some(s);
+		}
 
-		let val = filled.evaluate();
+		let val = tmp_board.evaluate();
 
 		if let Some(val) = val {
-			if let Some(best) = best_value {
-				if val > best {
+			if minimize {
+				if best_value.is_none() || val < best_value.unwrap() {
 					best_value = Some(val);
-					best_board = Some(filled)
+					best_board = Some(tmp_board)
 				}
 			} else {
-				best_value = Some(val);
-				best_board = Some(filled)
+				if best_value.is_none() || val > best_value.unwrap() {
+					best_value = Some(val);
+					best_board = Some(tmp_board)
+				}
 			}
 		}
 	}