Polygon Struct

We will create a Polygon struct which contain some points. Copy the code below to <https://play.rust-lang.org/> and fill in the missing methods to make the tests pass:

1. // TODO: remove this when you're done with your implementation.
2. #![allow(unused_variables, dead_code)]

4. pub struct Point {
5. // add fields
6. }

8. impl Point {
9. // add methods
10. }

12. pub struct Polygon {
13. // add fields
14. }

16. impl Polygon {
17. // add methods
18. }

20. pub struct Circle {
21. // add fields
22. }

24. impl Circle {
25. // add methods
26. }

28. pub enum Shape {
29. Polygon(Polygon),
30. Circle(Circle),
31. }

33. #[cfg(test)]
34. mod tests {
35. use super::*;

37. fn round_two_digits(x: f64) -> f64 {
38. (x * 100.0).round() / 100.0
39. }

41. #[test]
42. fn test_point_magnitude() {
43. let p1 = Point::new(12, 13);
44. assert_eq!(round_two_digits(p1.magnitude()), 17.69);
45. }

47. #[test]
48. fn test_point_dist() {
49. let p1 = Point::new(10, 10);
50. let p2 = Point::new(14, 13);
51. assert_eq!(round_two_digits(p1.dist(p2)), 5.00);
52. }

54. #[test]
55. fn test_point_add() {
56. let p1 = Point::new(16, 16);
57. let p2 = p1 + Point::new(-4, 3);
58. assert_eq!(p2, Point::new(12, 19));
59. }

61. #[test]
62. fn test_polygon_left_most_point() {
63. let p1 = Point::new(12, 13);
64. let p2 = Point::new(16, 16);

66. let mut poly = Polygon::new();
67. poly.add_point(p1);
68. poly.add_point(p2);
69. assert_eq!(poly.left_most_point(), Some(p1));
70. }

72. #[test]
73. fn test_polygon_iter() {
74. let p1 = Point::new(12, 13);
75. let p2 = Point::new(16, 16);

77. let mut poly = Polygon::new();
78. poly.add_point(p1);
79. poly.add_point(p2);

81. let points = poly.iter().cloned().collect::<Vec<_>>();
82. assert_eq!(points, vec![Point::new(12, 13), Point::new(16, 16)]);
83. }

85. #[test]
86. fn test_shape_perimeters() {
87. let mut poly = Polygon::new();
88. poly.add_point(Point::new(12, 13));
89. poly.add_point(Point::new(17, 11));
90. poly.add_point(Point::new(16, 16));
91. let shapes = vec![
92. Shape::from(poly),
93. Shape::from(Circle::new(Point::new(10, 20), 5)),
94. ];
95. let perimeters = shapes
96. .iter()
97. .map(Shape::perimeter)
98. .map(round_two_digits)
99. .collect::<Vec<_>>();
100. assert_eq!(perimeters, vec![15.48, 31.42]);
101. }
102. }

104. #[allow(dead_code)]
105. fn main() {}

Since the method signatures are missing from the problem statements, the key part of the exercise is to specify those correctly. You don’t have to modify the tests.

Other interesting parts of the exercise:

• Derive a Copy trait for some structs, as in tests the methods sometimes don’t borrow their arguments.
• Discover that Add trait must be implemented for two objects to be addable via “+”. Note that we do not discuss generics until Day 3.