wip

Author: acharneski

src/benchmarks/evaluation.rs

@@ -1080,6 +1080,9 @@ impl ProblemSpec {
             .clone()
             .unwrap_or_else(|| self.problem.name().to_string())
     }
+    pub fn get_family(&self) -> String {
+        self.family.clone()
+    }
 }
 
 pub fn new_initial_point(

src/experiment_runner/adaptive_runner.rs

@@ -451,6 +451,8 @@ pub fn get_optimizer_family(optimizer_name: &str) -> String {
         "L-BFGS".to_string()
     } else if optimizer_name.starts_with("Trust Region") {
         "Trust Region".to_string()
+    } else if optimizer_name.starts_with("TrustRegion") {
+        "Trust Region".to_string()
     } else if optimizer_name.starts_with("GD") {
         "GD".to_string()
     } else if optimizer_name.starts_with("Adam") {

src/experiment_runner/experiment_runner.rs

@@ -15,6 +15,9 @@ use std::sync::Arc;
 /// Represents a genome for an optimizer configuration
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct OptimizerGenome {
+    pub success_rate: Option<f64>,
+    pub mean_final_value: Option<f64>,
+    pub total_evaluations: Option<usize>,
     pub optimizer_type: OptimizerType,
     pub parameters: HashMap<String, f64>,
     pub fitness: Option<f64>,
@@ -67,6 +70,9 @@ impl OptimizerGenome {
             parameters
         );
         Self {
+            success_rate: None,
+            mean_final_value: None,
+            total_evaluations: None,
             optimizer_type,
             parameters,
             fitness: None,
@@ -565,6 +571,9 @@ impl ParameterEvolution {
 
         // Create offspring with selected type
         let mut offspring = OptimizerGenome {
+            success_rate: None,
+            mean_final_value: None,
+            total_evaluations: None,
             optimizer_type: offspring_type.clone(),
             parameters: HashMap::new(),
             fitness: None,
@@ -849,6 +858,9 @@ mod tests {
 
         for i in 0..5 {
             let mut genome = OptimizerGenome {
+                success_rate: None,
+                mean_final_value: None,
+                total_evaluations: None,
                 optimizer_type: OptimizerType::QQN,
                 parameters: HashMap::new(),
                 fitness: Some(i as f64),

src/experiment_runner/parameter_evolution.rs

@@ -1157,9 +1157,13 @@ pub(crate) fn shorten_optimizer_name(name: &str, max_length: usize) -> String {
             .replace("Quadratic", "Quad")
             .replace("Trust Region ", "")
             .replace("Trust Region-", "")
+            .replace("TrustRegion-", "")
             .replace("Adam-", "")
             .replace("GD-", "")
             .replace("L-BFGS-", "")
+            .replace("LBFGS-", "")
+            .replace("Evolved-", "")
+            .replace("Family-", "")
             .replace("QQN-", "");
 
         if shortened.len() <= max_length {

src/experiment_runner/report_generator.rs

@@ -587,17 +587,19 @@ pub(crate) fn calculate_family_performance_data(
         // Sort by success rate first, then by mean final value, then by total evaluations
         perf_data.sort_by(|a, b| {
             if is_no_threshold_mode() {
-                // In no-threshold mode, sort by best value, then by total evaluations
-                match a.2.total_cmp(&b.2) {
-                    std::cmp::Ordering::Equal => a.3.total_cmp(&b.3),
-                    ord => ord,
-                }
+                // In no-threshold mode, sort by best value (mean_final)
+                a.2.total_cmp(&b.2)
             } else {
+                // Sort by success rate first, then by total evaluations
+                use std::cmp::Ordering;
                 match b.1.total_cmp(&a.1) {
-                    std::cmp::Ordering::Equal => match a.2.total_cmp(&b.2) {
-                        std::cmp::Ordering::Equal => a.3.total_cmp(&b.3),
-                        ord => ord,
-                    },
+                    Ordering::Equal => {
+                        if b.1 > 0.0 {
+                            a.3.total_cmp(&b.3)
+                        } else {
+                            a.2.total_cmp(&b.2)
+                        }
+                    }
                     ord => ord,
                 }
             }

src/experiment_runner/reports/family_vs_family.rs

@@ -87,6 +87,7 @@ pub fn generate_problem_table_content(
         ));
     }
 
+    // Canonical ranking sort
     if is_no_threshold_mode() {
         // In no-threshold mode, sort by best value
         perf_data.sort_by(|a, b| a.3.total_cmp(&b.3));
@@ -346,7 +347,6 @@ pub fn generate_problem_section(
             } else {
                 (f64::NAN, f64::NAN, f64::NAN)
             };
-
         let std_final = {
             let variance = final_values
                 .iter()
@@ -384,6 +384,7 @@ pub fn generate_problem_section(
         ));
     }
 
+    // Canonical ranking sort
     if is_no_threshold_mode() {
         // In no-threshold mode, sort by best value
         perf_data.sort_by(|a, b| a.3.total_cmp(&b.3));
@@ -729,7 +730,13 @@ fn generate_problem_performance_table(results: &BenchmarkResults) -> anyhow::Res
     } else {
         // Sort by success rate first, then by mean final value
         perf_data.sort_by(|a, b| match b.2.total_cmp(&a.2) {
-            std::cmp::Ordering::Equal => a.1.total_cmp(&b.1),
+            std::cmp::Ordering::Equal => {
+                if (b.2 > 0.0) {
+                    a.3.total_cmp(&b.3)
+                } else {
+                    a.1.total_cmp(&b.1)
+                }
+            }
             other => other,
         });
     }

src/experiment_runner/reports/optimizer_problems.rs

@@ -15,7 +15,8 @@ use tokio::task::LocalSet;
 #[tokio::test]
 async fn test_adaptive_simple_problems() -> Result<(), Box<dyn Error + Send + Sync>> {
     init_logging(false)?;
-    enable_no_threshold_mode();
+    disable_no_threshold_mode();
+    // enable_no_threshold_mode();
 
     let local = LocalSet::new();
     local