gdsr 0.0.1-alpha.3

A GDSII reader and writer for Rust
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

use crate::{Point, Unit};

use super::ensure_points_same_units;

/// Calculate the perimeter (total path length) of a sequence of points.
///
/// Sums [Euclidean distances](https://en.wikipedia.org/wiki/Euclidean_distance)
/// between consecutive points. For closed polygons the caller should include
/// the closing segment by repeating the first point at the end.
pub fn perimeter(points: &[Point]) -> Unit {
    if points.len() < 2 {
        return Unit::default_integer(0);
    }

    let first_point = points[0];
    let units = first_point.units().0;

    let points = ensure_points_same_units(points, units);

    let mut length = 0.0;
    for i in 0..points.len() - 1 {
        let dx = points[i + 1].x().float_value() - points[i].x().float_value();
        let dy = points[i + 1].y().float_value() - points[i].y().float_value();
        length += (dx * dx + dy * dy).sqrt();
    }

    Unit::float(length, units)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_perimeter_closed_square() {
        let square = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(2.0, 0.0, 1e-6),
            Point::float(2.0, 2.0, 1e-6),
            Point::float(0.0, 2.0, 1e-6),
            Point::float(0.0, 0.0, 1e-6),
        ];
        assert_eq!(perimeter(&square), Unit::float(8.0, 1e-6));
    }

    #[test]
    fn test_perimeter_open_polygon() {
        let line = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(3.0, 0.0, 1e-6),
            Point::float(3.0, 4.0, 1e-6),
        ];
        assert_eq!(perimeter(&line), Unit::float(7.0, 1e-6));
    }

    #[test]
    fn test_perimeter_triangle() {
        let triangle = [
            Point::float(0.0, 0.0, 1e-6),
            Point::float(3.0, 0.0, 1e-6),
            Point::float(0.0, 4.0, 1e-6),
            Point::float(0.0, 0.0, 1e-6),
        ];
        assert_eq!(perimeter(&triangle), Unit::float(12.0, 1e-6));
    }

    #[test]
    fn test_perimeter_single_point() {
        let points = [Point::integer(1, 1, 1e-9)];
        assert_eq!(perimeter(&points), Unit::float(0.0, 1e-6));
    }

    #[test]
    fn test_perimeter_two_points() {
        let points = [Point::float(0.0, 0.0, 1e-6), Point::float(3.0, 4.0, 1e-6)];
        assert_eq!(perimeter(&points), Unit::float(5.0, 1e-6));
    }
}

#[cfg(test)]
#[allow(clippy::needless_pass_by_value)]
mod property_tests {
    use super::*;
    use quickcheck_macros::quickcheck;

    #[quickcheck]
    fn perimeter_is_non_negative(coords: Vec<(i16, i16)>) -> bool {
        let points: Vec<Point> = coords
            .iter()
            .map(|&(x, y)| Point::float(f64::from(x), f64::from(y), 1e-6))
            .collect();
        perimeter(&points).float_value() >= 0.0
    }

    /// A single segment's perimeter equals its Euclidean length.
    #[quickcheck]
    fn perimeter_of_segment_equals_distance(x1: i16, y1: i16, x2: i16, y2: i16) -> bool {
        let a = Point::float(f64::from(x1), f64::from(y1), 1e-6);
        let b = Point::float(f64::from(x2), f64::from(y2), 1e-6);
        let dx = f64::from(x2) - f64::from(x1);
        let dy = f64::from(y2) - f64::from(y1);
        let expected = (dx * dx + dy * dy).sqrt();
        (perimeter(&[a, b]).float_value() - expected).abs() < 1e-10
    }
}