Struct HtmlReportObserver 

pub struct HtmlReportObserver { /* private fields */ }

Observer that generates an HTML execution report with metrics and charts.

Output layout

By default, each run is written to: target/observers_outputs/reports/<algorithm_slug>/run_<timestamp_ms>_<pid>/report.html.

Use HtmlReportObserver::with_flat_output if you prefer a flat output folder without per-run subdirectories.

Typical usage

Create and register the observer in your algorithm before calling run(). At the end of execution, the observer prints a clickable terminal link to the generated HTML file.

Implementations

impl HtmlReportObserver

pub fn new(base_output_path: PathBuf) -> Self

Creates a report observer with a custom base output directory.

The generated report path is: <base>/<algorithm_slug>/run_<timestamp_ms>_<pid>/report.html.

pub fn new_default() -> Self

Creates a report observer with default base directory: target/observers_outputs/reports.

Examples found in repository

examples/knapsack_hc_demo.rs (line 35)

fn main() {
    let seed = seed_from_cli_or(42);

    let problem = KnapsackBuilder::new()
        .with_capacity(90.0)
        .add_item(12.0, 24.0)
        .add_item(22.0, 33.0)
        .add_item(41.0, 80.0)
        .build();

    let parameters = HillClimbingParameters::new(
        BitFlipMutation::new(),
        0.10,
        TerminationCriteria::new(vec![TerminationCriterion::MaxIterations(120)]),
    )
    .with_seed(seed);
    let mut algorithm = HillClimbing::new(parameters);

    algorithm.add_observer(Box::new(ConsoleObserver::new(true)));
    algorithm.add_observer(Box::new(ChartObserver::new_default()));
    algorithm.add_observer(Box::new(HtmlReportObserver::new_default()));

    let result = algorithm
        .run(&problem)
        .expect("Hill Climbing run failed");

    if let Some(best) = result.best_solution(&problem) {
        println!(
            "Hill-Climbing finished (seed={}). Best fitness={:.4}",
            seed,
            best.quality_value()
        );
    } else {
        println!("Hill-Climbing finished with no solutions (seed={})", seed);
    }
}

examples/knapsack_items_file/main.rs (line 230)

fn main() {
    if print_help_if_requested() {
        return;
    }

    let seed = seed_from_cli_or(42);
    let input_path = resolve_input_path();
    let input_format = resolve_input_format(&input_path).unwrap_or_else(|msg| panic!("{}", msg));
    let records_path = records_path_for_format(input_format);
    let weight_key = weight_key_for_format(input_format);
    let value_key = value_key_for_format(input_format);
    let (capacity, row_limit) =
        resolve_capacity_and_limit(&input_path, input_format).unwrap_or_else(|msg| panic!("{}", msg));

    let records = read_records_from_input(&input_path, input_format, records_path)
        .unwrap_or_else(|msg| panic!("{}", msg));

    let (problem, loaded_items) =
        build_knapsack_from_records(&records, capacity, row_limit, weight_key, value_key)
            .unwrap_or_else(|msg| panic!("{}", msg));

    // Build the algorithm 
    let parameters = GeneticAlgorithmParameters::new(
        80,
        0.85,
        0.04,
        SinglePointCrossover::new(),
        BitFlipMutation::new(),
        BinaryTournamentSelection::new(),
        TerminationCriteria::new(vec![TerminationCriterion::MaxIterations(60)]),
    )
    .with_seed(seed);

    let chart_observer = ChartObserver::new_default();
    let html_observer = HtmlReportObserver::new_default();

    let mut algorithm = GeneticAlgorithm::new(parameters);
    algorithm.add_observer(Box::new(chart_observer));
    algorithm.add_observer(Box::new(html_observer));
    let result = algorithm.run(&problem).expect("Large CSV GA run failed");

    if let Some(best) = result.best_solution(&problem) {
        println!(
            "Large dataset GA demo finished (seed={}). input='{}', format={:?}, capacity={}, limit={}, records_path='{}', weight_key='{}', value_key='{}', items={}, best fitness={:.4}",
            seed,
            input_path.display(),
            input_format,
            capacity,
            row_limit,
            records_path,
            weight_key,
            value_key,
            loaded_items,
            best.quality_value()
        );
    } else {
        println!("Large CSV GA demo finished with no solutions (seed={})", seed);
    }
}

pub fn with_flat_output(self) -> Self

Disables automatic per-run subdirectories.

When enabled (default), each run gets its own timestamped folder. When disabled, the report is written directly to <base_output_path>/report.html.

Trait Implementations

impl<T, Q> AlgorithmObserver<T, Q> for HtmlReportObserver

where T: Clone + Send + Debug + 'static, Q: Clone + Send + 'static,

fn update(&mut self, event: &AlgorithmEvent<T, Q>)

Called when an event occurs during algorithm execution

fn finalize(&mut self)

Called at the end of the algorithm to finalize any resources

fn name(&self) -> &str

Returns the name of this observer