malevich 1.18.2

Terminal plotting: a small grammar of marks, honest axes, millions of points
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

//! The rule mark: a reference line across the whole plot.

use crate::render::Color;

/// A reference line spanning the plot: horizontal at a y value, or vertical at an
/// x value. The zero line, a target, a threshold — annotations, not data.
///
/// A rule extends the axis domain to include its position, so it is always visible.
#[derive(Debug, Clone, Copy, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub(crate) enum Orientation {
    Horizontal(f64),
    Vertical(f64),
}

/// A reference line across the plot area.
#[derive(Debug, Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Rule {
    pub(crate) orientation: Orientation,
    pub(crate) color: Option<Color>,
    pub(crate) label: Option<String>,
}

impl Rule {
    /// A horizontal rule at `y`, spanning the plot's width.
    ///
    /// # Panics
    ///
    /// Panics if `y` is not finite.
    pub fn h(y: f64) -> Rule {
        let rule = Rule {
            orientation: Orientation::Horizontal(y),
            color: None,
            label: None,
        };
        rule.validate().expect("Rule::h requires a finite position");
        rule
    }

    /// A vertical rule at `x`, spanning the plot's height.
    ///
    /// # Panics
    ///
    /// Panics if `x` is not finite.
    pub fn v(x: f64) -> Rule {
        let rule = Rule {
            orientation: Orientation::Vertical(x),
            color: None,
            label: None,
        };
        rule.validate().expect("Rule::v requires a finite position");
        rule
    }

    /// Sets an explicit color; without one, rules draw in the default foreground —
    /// annotations should recede, not compete.
    #[must_use]
    pub fn color(mut self, color: Color) -> Rule {
        self.color = Some(color);
        self
    }

    /// Names this rule in the legend.
    #[must_use]
    pub fn label(mut self, label: impl Into<String>) -> Rule {
        self.label = Some(label.into());
        self
    }

    /// Checks the rule position after any construction path.
    pub(crate) fn validate(&self) -> crate::Result<()> {
        let position = match self.orientation {
            Orientation::Horizontal(value) | Orientation::Vertical(value) => value,
        };
        if position.is_finite() {
            Ok(())
        } else {
            Err(crate::Error::InvalidParameter {
                detail: "a Rule position must be finite",
            })
        }
    }
}

#[cfg(test)]
#[path = "tests/rule_tests.rs"]
mod tests;