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

use super::Entry;
use crate::benchmark::report::generate_yaml_tagged;
use crate::parser::yaml::write_yaml_document;
use std::collections::BTreeMap;
use std::fs;
use std::path::Path;

pub(super) fn build_yaml(
    entries: &[Entry<'_>],
    title: &str,
    group_key: &str,
    dir: &Path,
) -> std::io::Result<(BTreeMap<String, String>, usize)> {
    let yaml_dir = dir.join("yaml");
    fs::create_dir_all(&yaml_dir)?;
    let mut files_written = 0usize;
    let mut yaml_files: BTreeMap<String, String> = BTreeMap::new();
    let mut yaml_items_data: Vec<Vec<(String, String)>> = Vec::new();
    let mut group_yaml_data: BTreeMap<String, Vec<Vec<(String, String)>>> = BTreeMap::new();

    for entry in entries {
        let m = entry.metrics;

        let yaml = generate_yaml_tagged(m, entry.result, &entry.tags);
        let yname = format!("{}.yaml", entry.label);
        fs::write(yaml_dir.join(&yname), &yaml)?;
        yaml_files.insert(yname, yaml.clone());
        files_written += 1;

        let mut fields = vec![("label".to_string(), entry.label.to_string())];
        for (k, v) in &entry.tags {
            fields.push((k.to_string(), v.to_string()));
        }
        fields.push(("avg_time_ns".to_string(), format!("{:.2}", m.avg_time_ns)));
        fields.push((
            "iterations_per_sec".to_string(),
            format!("{:.2}", m.iterations_per_sec),
        ));
        yaml_items_data.push(fields);

        if let Some(group_tag) = entry.tags.first() {
            let items = group_yaml_data.entry(group_tag.1.to_string()).or_default();
            let mut gfields = vec![("label".to_string(), entry.label.to_string())];
            for (k, v) in entry.tags.iter().skip(1) {
                gfields.push((k.to_string(), v.to_string()));
            }
            gfields.push(("avg_time_ns".to_string(), format!("{:.2}", m.avg_time_ns)));
            items.push(gfields);
        }
    }

    let count_str = entries.len().to_string();
    let yaml_header: Vec<(&str, &str)> = vec![("title", title), ("count", &count_str)];
    let yaml_items: Vec<Vec<(&str, &str)>> = yaml_items_data
        .iter()
        .map(|item| item.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect())
        .collect();
    let yaml_all = write_yaml_document(&yaml_header, "entries", &yaml_items);
    yaml_files.insert("summary.yaml".into(), yaml_all.clone());
    fs::write(yaml_dir.join("summary.yaml"), &yaml_all)?;
    files_written += 1;

    for (cat, items_data) in &group_yaml_data {
        let grp_count_str = items_data.len().to_string();
        let header: Vec<(&str, &str)> = vec![(group_key, cat.as_str()), ("count", &grp_count_str)];
        let items: Vec<Vec<(&str, &str)>> = items_data
            .iter()
            .map(|item| item.iter().map(|(k, v)| (k.as_str(), v.as_str())).collect())
            .collect();
        let y = write_yaml_document(&header, "entries", &items);
        let fname = format!("{}.yaml", cat.replace(' ', "_"));
        yaml_files.insert(fname.clone(), y.clone());
        fs::write(yaml_dir.join(&fname), &y)?;
        files_written += 1;
    }

    Ok((yaml_files, files_written))
}