cas-graph 0.2.0

A customizable graphing calculator for CalcScript
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

/// A pair of `(x, y)` values in **graph** units.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct GraphPoint<T>(pub T, pub T);

impl<T> From<(T, T)> for GraphPoint<T> {
    fn from((x, y): (T, T)) -> GraphPoint<T> {
        GraphPoint(x, y)
    }
}

impl<T> GraphPoint<T>
where
    T: Into<f64> + Copy,
{
    /// Returns the distance between two points.
    pub fn distance(self, other: GraphPoint<T>) -> f64 {
        (self.0.into() - other.0.into()).hypot(self.1.into() - other.1.into())
    }
}

/// A pair of `(x, y)` values in **canvas** units.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct CanvasPoint<T>(pub T, pub T);

impl<T> From<(T, T)> for CanvasPoint<T> {
    fn from((x, y): (T, T)) -> CanvasPoint<T> {
        CanvasPoint(x, y)
    }
}

/// A point to draw in a graph with style information.
///
/// The default point color is red.
#[derive(Clone, Debug, PartialEq)]
pub struct Point<T> {
    /// The coordinates of the point to draw.
    pub coordinates: GraphPoint<T>,

    /// The color of the point, given as an RGB tuple with each value in the
    /// range 0.0 to 1.0.
    ///
    /// The default color is a solid red.
    pub color: (f64, f64, f64),

    /// The label of the point. If omitted, the point will be labeled with its
    /// coordinates, to a maximum of 3 decimal places for each coordinate.
    pub label: Option<String>,
}

impl Default for Point<f64> {
    fn default() -> Point<f64> {
        Point {
            coordinates: (0.0, 0.0).into(),
            color: (1.0, 0.0, 0.0),
            label: None,
        }
    }
}

impl<T> Point<T>
where
    T: Into<f64> + Copy,
    Point<T>: Default,
{
    /// Creates a new point with the given coordinates.
    pub fn new(coordinates: impl Into<GraphPoint<T>>) -> Point<T> {
        Point {
            coordinates: coordinates.into(),
            ..Default::default()
        }
    }

    /// Sets the color of the point.
    ///
    /// Returns the point itself to allow chaining.
    pub fn with_color(mut self, color: (f64, f64, f64)) -> Point<T> {
        self.color = color;
        self
    }

    /// Sets the label of the point.
    ///
    /// Returns the point itself to allow chaining.
    pub fn with_label(mut self, label: String) -> Point<T> {
        self.label = Some(label);
        self
    }
}

impl<T> From<(T, T)> for Point<T>
where
    Point<T>: Default,
{
    fn from((x, y): (T, T)) -> Point<T> {
        Point {
            coordinates: GraphPoint(x, y),
            ..Default::default()
        }
    }
}