update and use less emojis

Author: williambdean

examples/sample_callback.rs

@@ -179,7 +179,7 @@ fn main() -> Result<()> {
             // Print progress information periodically
             if *count <= 10 {
                 println!(
-                    "📊 Progress callback #{}: Elapsed: {:.1}s, {} chains",
+                    "Progress callback #{}: Elapsed: {:.1}s, {} chains",
                     count,
                     elapsed.as_secs_f64(),
                     chains.len()
@@ -188,26 +188,45 @@ fn main() -> Result<()> {
                 for chain_progress in chains.iter() {
                     // Access the latest sample data if available
                     if let Some(sample_data) = &chain_progress.latest_sample {
+                        // Demonstrate accessing optional fields with proper handling
+                        let energy_str = sample_data
+                            .draw_energy
+                            .map(|e| format!("{:.3}", e))
+                            .unwrap_or_else(|| "N/A".to_string());
+                        let diverging_str = sample_data
+                            .diverging
+                            .map(|d| d.to_string())
+                            .unwrap_or_else(|| "N/A".to_string());
+                        let tree_depth_str = sample_data
+                            .tree_depth
+                            .map(|d| d.to_string())
+                            .unwrap_or_else(|| "N/A".to_string());
+
                         println!(
-                            "   Chain {}: Draw {}/{}, Energy: {:.3}, Diverging: {}, Tree depth: {}",
+                            "   Chain {}: Draw {}/{}, Energy: {}, Diverging: {}, Tree depth: {}",
                             sample_data.chain_id,
                             chain_progress.finished_draws,
                             chain_progress.total_draws,
-                            sample_data.energy,
-                            sample_data.diverging,
-                            sample_data.tree_depth
-                        );
-                        println!(
-                            "   Position: [{:.4}, {:.4}]",
-                            sample_data.position[0], sample_data.position[1]
-                        );
-                        println!(
-                            "   Step size: {:.6}, Tuning: {}",
-                            sample_data.step_size, sample_data.is_tuning
+                            energy_str,
+                            diverging_str,
+                            tree_depth_str
                         );
 
+                        if let Some(step_size) = sample_data.step_size {
+                            println!(
+                                "   Step size: {:.6}, Tuning: {}",
+                                step_size, sample_data.is_tuning
+                            );
+                        }
+
+                        if let Some(max_depth) = sample_data.reached_max_treedepth {
+                            if max_depth {
+                                println!("   ⚠ Maximum tree depth reached!");
+                            }
+                        }
+
                         // Track divergences
-                        if sample_data.diverging {
+                        if sample_data.diverging.unwrap_or(false) {
                             let mut div_count = divergence_count_clone.lock().unwrap();
                             *div_count += 1;
                         }
@@ -276,11 +295,14 @@ fn main() -> Result<()> {
         }
     }
 
-    println!("\n✅ Example completed successfully!");
+    println!("\n✓ Example completed successfully!");
     println!("\nKey features demonstrated:");
     println!("  - ProgressCallback provides both chain progress and latest sample data");
     println!("  - Time-based rate limiting (10ms) prevents excessive overhead");
-    println!("  - latest_sample includes rich data (position, energy, divergence, etc.)");
+    println!(
+        "  - latest_sample includes rich optional data (energy, divergence, tree depth, etc.)"
+    );
+    println!("  - All sampler-specific stats are Option<T> for compatibility with other samplers");
     println!("  - Works seamlessly with multi-chain sampling");
     println!("  - Single callback mechanism for all monitoring needs");
 

tests/sample_callback_test.rs

@@ -15,14 +15,13 @@ fn test_sample_data_type_exists() {
         chain_id: 0,
         draw: 42,
         is_tuning: true,
-        position: vec![1.0, 2.0, 3.0],
-        energy: -10.5,
-        diverging: false,
-        tree_depth: 5,
-        step_size: 0.1,
+        tree_depth: Some(5),
+        reached_max_treedepth: Some(false),
+        diverging: Some(false),
+        initial_energy: None,
+        draw_energy: Some(-10.5),
+        step_size: Some(0.1),
     };
-
-    println!("✅ SampleData struct exists and can be constructed");
 }
 
 #[test]
@@ -49,18 +48,17 @@ fn test_progress_callback_creation() {
                     let _ = sample_data.chain_id;
                     let _ = sample_data.draw;
                     let _ = sample_data.is_tuning;
-                    let _ = &sample_data.position;
-                    let _ = sample_data.energy;
-                    let _ = sample_data.diverging;
                     let _ = sample_data.tree_depth;
+                    let _ = sample_data.reached_max_treedepth;
+                    let _ = sample_data.diverging;
+                    let _ = sample_data.initial_energy;
+                    let _ = sample_data.draw_energy;
                     let _ = sample_data.step_size;
                 }
             }
         }),
         rate: Duration::from_millis(100),
     };
-
-    println!("✅ ProgressCallback can be created with closure that accesses sample data");
 }
 
 #[test]
@@ -70,26 +68,24 @@ fn test_chain_progress_with_sample_data() {
         chain_id: 1,
         draw: 10,
         is_tuning: true,
-        position: vec![0.5, -0.3],
-        energy: -5.2,
-        diverging: false,
-        tree_depth: 3,
-        step_size: 0.05,
+        tree_depth: Some(3),
+        reached_max_treedepth: Some(false),
+        diverging: Some(false),
+        initial_energy: None,
+        draw_energy: Some(-5.2),
+        step_size: Some(0.05),
     };
 
     // Verify we can access sample data fields
     assert_eq!(sample_data.chain_id, 1);
     assert_eq!(sample_data.draw, 10);
     assert!(sample_data.is_tuning);
-    assert_eq!(sample_data.position.len(), 2);
-    assert_eq!(sample_data.position[0], 0.5);
-    assert_eq!(sample_data.position[1], -0.3);
-    assert_eq!(sample_data.energy, -5.2);
-    assert!(!sample_data.diverging);
-    assert_eq!(sample_data.tree_depth, 3);
-    assert_eq!(sample_data.step_size, 0.05);
-
-    println!("✅ Sample data can be created and accessed");
+    assert_eq!(sample_data.tree_depth, Some(3));
+    assert_eq!(sample_data.reached_max_treedepth, Some(false));
+    assert_eq!(sample_data.diverging, Some(false));
+    assert_eq!(sample_data.initial_energy, None);
+    assert_eq!(sample_data.draw_energy, Some(-5.2));
+    assert_eq!(sample_data.step_size, Some(0.05));
 }
 
 #[test]
@@ -99,22 +95,25 @@ fn test_sample_data_clone() {
         chain_id: 0,
         draw: 1,
         is_tuning: false,
-        position: vec![1.0, 2.0],
-        energy: -3.0,
-        diverging: true,
-        tree_depth: 4,
-        step_size: 0.1,
+        tree_depth: Some(4),
+        reached_max_treedepth: Some(true),
+        diverging: Some(true),
+        initial_energy: Some(-2.5),
+        draw_energy: Some(-3.0),
+        step_size: Some(0.1),
     };
 
     let data2 = data1.clone();
 
     assert_eq!(data1.chain_id, data2.chain_id);
     assert_eq!(data1.draw, data2.draw);
-    assert_eq!(data1.position, data2.position);
-    assert_eq!(data1.energy, data2.energy);
+    assert_eq!(data1.is_tuning, data2.is_tuning);
+    assert_eq!(data1.tree_depth, data2.tree_depth);
+    assert_eq!(data1.reached_max_treedepth, data2.reached_max_treedepth);
     assert_eq!(data1.diverging, data2.diverging);
-
-    println!("✅ SampleData can be cloned");
+    assert_eq!(data1.initial_energy, data2.initial_energy);
+    assert_eq!(data1.draw_energy, data2.draw_energy);
+    assert_eq!(data1.step_size, data2.step_size);
 }
 
 #[test]
@@ -139,7 +138,7 @@ fn test_progress_callback_invocation() {
 
                     // Verify we can access the data
                     let _ = sample_data.chain_id;
-                    let _ = sample_data.position.len();
+                    let _ = sample_data.draw_energy;
                 }
             }
         }),
@@ -151,5 +150,4 @@ fn test_progress_callback_invocation() {
     (callback.callback)(Duration::from_secs(1), chains.into());
 
     assert_eq!(*callback_count.lock().unwrap(), 1);
-    println!("✅ ProgressCallback can be invoked");
 }