feat: show grouped solution parameters

1 files changed, 84 insertions, 57 deletions

diff --git a/src/main.rs b/src/main.rs
index f6dea25..4aa8236 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -542,14 +542,14 @@ fn pick_chip_by_logic<'input>(
     }
 }
 
-fn logic_to_chips<'input>(
-    logic: &Logic,
+fn logics_to_chips<'input>(
+    logics: &[&Logic],
     series: &ChipSeries<'input>,
 ) -> HashMap<&'input str, (usize, usize)> {
     let mut chips = HashMap::new();
     let mut visited = HashSet::new();
 
-    let mut queue = VecDeque::from([logic]);
+    let mut queue: VecDeque<_> = logics.iter().cloned().collect();
     while let Some(logic) = queue.pop_front() {
         if !visited.insert(logic) {
             continue;
@@ -644,8 +644,12 @@ fn sequence_to_delay<'input>(
         .sum()
 }
 
-fn logic_to_full_delay(logic: &Logic, series: &ChipSeries) -> usize {
-    let sequences = logic_to_sequences(logic, series);
+fn logics_to_full_delay(logics: &[&Logic], series: &ChipSeries) -> usize {
+    let sequences = logics
+        .iter()
+        .flat_map(|logic| logic_to_sequences(logic, series))
+        .collect_vec();
+
     sequences
         .iter()
         .map(|seq| sequence_to_delay(seq, series))
@@ -653,8 +657,12 @@ fn logic_to_full_delay(logic: &Logic, series: &ChipSeries) -> usize {
         .unwrap()
 }
 
-fn logic_to_reduced_delay(logic: &Logic, series: &ChipSeries) -> usize {
-    let mut sequences = logic_to_sequences(logic, series);
+fn logics_to_reduced_delay(logics: &[&Logic], series: &ChipSeries) -> usize {
+    let mut sequences = logics
+        .iter()
+        .flat_map(|logic| logic_to_sequences(logic, series))
+        .collect_vec();
+
     sequences.iter_mut().for_each(|seq| {
         // NOTE: sequence is reversed, so we are using last element to check for variable inversion
         seq.pop_if(|(gate, _)| *gate == "NOT");
@@ -667,14 +675,14 @@ fn logic_to_reduced_delay(logic: &Logic, series: &ChipSeries) -> usize {
         .unwrap()
 }
 
-fn logic_to_input_current<'input>(
-    logic: &'input Logic,
+fn logics_to_input_current<'input>(
+    logics: &[&'input Logic],
     series: &ChipSeries<'input>,
 ) -> HashMap<&'input str, (usize, usize)> {
     let mut consumptions = HashMap::new();
     let mut visited = HashSet::new();
 
-    let mut queue = VecDeque::from([logic]);
+    let mut queue: VecDeque<_> = logics.iter().cloned().collect();
     while let Some(logic) = queue.pop_front() {
         if !visited.insert(logic) {
             continue;
@@ -810,6 +818,55 @@ impl<'input> TruthTable<'input> {
     }
 }
 
+fn print_solution_parameters(solution: &[&Logic], chip_series: &ChipSeries) {
+    let chips = logics_to_chips(solution, chip_series);
+    let full_delay = logics_to_full_delay(solution, chip_series);
+    let reduced_delay = logics_to_reduced_delay(solution, chip_series);
+    let input_currents = logics_to_input_current(solution, chip_series);
+
+    println!("  - Количество использованных микросхем:");
+    if chips.is_empty() {
+        println!("    - <не требуется микросхем>");
+    }
+
+    let mut total_consumption = 0.;
+    let mut total_used_consumption = 0.;
+
+    for (chip, (used, size)) in chips.into_iter().sorted() {
+        println!(
+            "    - {chip}: {} шт (использовано {used} элементов -> {used}/{size} = {})",
+            used.div_ceil(size),
+            used as f32 / size as f32
+        );
+
+        let chip_info = match chip_series.chip_specification.get(chip) {
+            Some(info) => info,
+            None => continue,
+        };
+
+        let chip_usage = used as f32 / size as f32;
+        let chip_consumption = used.div_ceil(size) * chip_info.consumption();
+        let chip_used_consumption = chip_usage * chip_info.consumption() as f32;
+
+        total_consumption += chip_consumption as f32;
+        total_used_consumption += chip_used_consumption;
+
+        println!(
+            "      Максимальное потребление: {chip_consumption} мкА (реальное использованное: {chip_used_consumption})"
+        );
+    }
+
+    println!("  - Задержка (с инверсией входных переменных): {full_delay} нс");
+    println!("  - Задержка (без инверсии входных переменных): {reduced_delay} нс");
+    println!("  - Полное потребление схемы: {total_consumption} мкА");
+    println!("  - Использованное потребление схемы: {total_used_consumption} мкА");
+
+    println!("  - Потребляемый ток со входных сигналов:");
+    for (input, (low_current, high_current)) in input_currents.into_iter().sorted() {
+        println!("    - {input} - {low_current}/{high_current} мкА");
+    }
+}
+
 fn main() {
     let mut args = std::env::args().skip(1);
     let chip_series_file_path = args.next().unwrap();
@@ -833,57 +890,27 @@ fn main() {
             println!("    {solution}");
             println!();
 
-            let chips = logic_to_chips(solution, &chip_series);
-            let full_delay = logic_to_full_delay(solution, &chip_series);
-            let reduced_delay = logic_to_reduced_delay(solution, &chip_series);
-            let input_currents = logic_to_input_current(solution, &chip_series);
-
             println!("  Параметры решения:");
-            println!("  - Количество использованных микросхем:");
-            if chips.is_empty() {
-                println!("    - <не требуется микросхем>");
-            }
-
-            let mut total_consumption = 0.;
-            let mut total_used_consumption = 0.;
-
-            for (chip, (used, size)) in chips.into_iter().sorted() {
-                println!(
-                    "    - {chip}: {} шт (использовано {used} элементов -> {used}/{size} = {})",
-                    used.div_ceil(size),
-                    used as f32 / size as f32
-                );
-
-                let chip_info = match chip_series.chip_specification.get(chip) {
-                    Some(info) => info,
-                    None => continue,
-                };
-
-                let chip_usage = used as f32 / size as f32;
-                let chip_consumption = used.div_ceil(size) * chip_info.consumption();
-                let chip_used_consumption = chip_usage * chip_info.consumption() as f32;
-
-                total_consumption += chip_consumption as f32;
-                total_used_consumption += chip_used_consumption as f32;
-
-                println!(
-                    "      Максимальное потребление: {chip_consumption} мкВт (реальное использованное: {chip_used_consumption})"
-                );
-            }
-
-            println!("  - Задержка (с инверсией входных переменных): {full_delay} нс");
-            println!("  - Задержка (без инверсии входных переменных): {reduced_delay} нс");
-            println!("  - Полное потребление схемы: {total_consumption} мкВт");
-            println!("  - Использованное потребление схемы: {total_used_consumption} мкВт");
-
-            println!("  - Потребляемый ток со входных сигналов:");
-            for (input, (low_current, high_current)) in input_currents.into_iter().sorted() {
-                println!("    - {input} - {low_current}/{high_current} мкА");
-            }
-
+            print_solution_parameters(&[solution], &chip_series);
             println!();
         }
 
         println!();
     }
+
+    let mut grouped_solutions: HashMap<&str, Vec<&Logic>> = HashMap::new();
+    for (_, solutions) in all_solutions.iter() {
+        for (solution_type, solution) in SOLUTIONS.into_iter().zip(solutions) {
+            grouped_solutions
+                .entry(solution_type)
+                .or_default()
+                .push(solution);
+        }
+    }
+
+    println!("Параметры всех решений как целого:");
+    for solution_type in SOLUTIONS.into_iter() {
+        println!("- {solution_type}:");
+        print_solution_parameters(&grouped_solutions[solution_type], &chip_series);
+    }
 }