ggplot-rs 0.6.0

A Rust implementation of ggplot2's Grammar of Graphics
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::aes::Aesthetic;
use crate::data::{DataFrame, Value};
use crate::scale::ScaleSet;

use super::Stat;

/// Computes boxplot statistics: quartiles, whiskers, outliers.
pub struct StatBoxplot;

impl Stat for StatBoxplot {
    fn compute_group(&self, data: &DataFrame, _scales: &ScaleSet) -> DataFrame {
        let y_col = match data.column("y") {
            Some(c) => c,
            None => return DataFrame::new(),
        };

        let mut values: Vec<f64> = y_col.iter().filter_map(|v| v.as_f64()).collect();
        if values.is_empty() {
            return DataFrame::new();
        }

        values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));

        let n = values.len();
        let q1 = percentile(&values, 25.0);
        let median = percentile(&values, 50.0);
        let q3 = percentile(&values, 75.0);
        let iqr = q3 - q1;

        let lower_fence = q1 - 1.5 * iqr;
        let upper_fence = q3 + 1.5 * iqr;

        // Whiskers extend to most extreme non-outlier
        let ymin = values
            .iter()
            .find(|&&v| v >= lower_fence)
            .copied()
            .unwrap_or(q1);
        let ymax = values
            .iter()
            .rev()
            .find(|&&v| v <= upper_fence)
            .copied()
            .unwrap_or(q3);

        // Outliers
        let outliers: Vec<f64> = values
            .iter()
            .filter(|&&v| v < lower_fence || v > upper_fence)
            .copied()
            .collect();

        // Get x value (group identifier)
        let x_val = data
            .column("x")
            .and_then(|c| c.first())
            .cloned()
            .unwrap_or(Value::Float(0.0));

        let mut result = DataFrame::new();
        result.add_column("x".to_string(), vec![x_val.clone()]);
        result.add_column("ymin".to_string(), vec![Value::Float(ymin)]);
        result.add_column("lower".to_string(), vec![Value::Float(q1)]);
        result.add_column("middle".to_string(), vec![Value::Float(median)]);
        result.add_column("upper".to_string(), vec![Value::Float(q3)]);
        result.add_column("ymax".to_string(), vec![Value::Float(ymax)]);
        result.add_column(
            "notchupper".to_string(),
            vec![Value::Float(median + 1.58 * iqr / (n as f64).sqrt())],
        );
        result.add_column(
            "notchlower".to_string(),
            vec![Value::Float(median - 1.58 * iqr / (n as f64).sqrt())],
        );

        // Store outliers as separate rows in a companion column
        if !outliers.is_empty() {
            // We'll encode outlier count; actual outlier drawing handled by geom
            let outlier_str = outliers
                .iter()
                .map(|v| v.to_string())
                .collect::<Vec<_>>()
                .join(",");
            result.add_column("outliers".to_string(), vec![Value::Str(outlier_str)]);
        }

        // Carry over fill/color
        for col_name in &["fill", "color"] {
            if let Some(col) = data.column(col_name) {
                if let Some(first) = col.first() {
                    result.add_column(col_name.to_string(), vec![first.clone()]);
                }
            }
        }

        result
    }

    fn required_aes(&self) -> Vec<Aesthetic> {
        vec![Aesthetic::X, Aesthetic::Y]
    }

    fn name(&self) -> &str {
        "boxplot"
    }
}

fn percentile(sorted: &[f64], p: f64) -> f64 {
    if sorted.is_empty() {
        return 0.0;
    }
    if sorted.len() == 1 {
        return sorted[0];
    }

    let k = (p / 100.0) * (sorted.len() - 1) as f64;
    let f = k.floor() as usize;
    let c = k.ceil() as usize;

    if f == c {
        sorted[f]
    } else {
        let d = k - f as f64;
        sorted[f] * (1.0 - d) + sorted[c] * d
    }
}