sciforge 0.0.3

A comprehensive scientific computing library in pure Rust with zero dependencies
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

//! Multi-step experiment campaigns.
//!
//! A [`Campaign`] groups ordered [`Step`]s, each wrapping an
//! [`Experiment`], and collects their results in a [`CampaignResult`].

use super::experience::experiment::Experiment;
use super::experience::runner::{ExperimentRunner, RunOutput};
use crate::hub::domain::common::errors::HubResult;

/// Single step in a campaign.
pub struct Step {
    /// Step name.
    pub name: String,
    /// Experiment to run.
    pub experiment: Experiment,
}

/// Collected results from a campaign run.
pub struct CampaignResult {
    /// Ordered pairs of (step name, output).
    pub step_results: Vec<(String, RunOutput)>,
}

impl CampaignResult {
    /// Returns the output for a step by name.
    pub fn get(&self, name: &str) -> Option<&RunOutput> {
        self.step_results
            .iter()
            .find(|(n, _)| n == name)
            .map(|(_, r)| r)
    }

    /// Number of completed steps.
    pub fn len(&self) -> usize {
        self.step_results.len()
    }

    /// Returns `true` if no steps were executed.
    pub fn is_empty(&self) -> bool {
        self.step_results.is_empty()
    }

    /// Extracts all scalar results as (name, value) pairs.
    pub fn scalars(&self) -> Vec<(&str, f64)> {
        self.step_results
            .iter()
            .filter_map(|(n, r)| {
                if let RunOutput::Scalar(v) = r {
                    Some((n.as_str(), *v))
                } else {
                    None
                }
            })
            .collect()
    }
}

/// Ordered sequence of experiments executed in series.
pub struct Campaign {
    /// Campaign name.
    pub name: String,
    steps: Vec<Step>,
}

impl Campaign {
    /// Creates a new empty campaign.
    pub fn new(name: &str) -> Self {
        Self {
            name: name.to_string(),
            steps: Vec::new(),
        }
    }

    /// Appends a named experiment step.
    pub fn add_step(mut self, name: &str, experiment: Experiment) -> Self {
        self.steps.push(Step {
            name: name.to_string(),
            experiment,
        });
        self
    }

    /// Number of registered steps.
    pub fn step_count(&self) -> usize {
        self.steps.len()
    }

    /// Runs all steps sequentially and collects results.
    pub fn run(&self, runner: &ExperimentRunner) -> HubResult<CampaignResult> {
        let mut results = Vec::with_capacity(self.steps.len());
        for step in &self.steps {
            let output = runner.run(&step.experiment)?;
            results.push((step.name.clone(), output));
        }
        Ok(CampaignResult {
            step_results: results,
        })
    }
}