algs4 0.7.0

Algorithms, 4ed. MOOC in Coursera. in Rust.
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

use std::cmp::Ordering;
use std::mem;
use super::sorting::comparator::Comparator;

#[allow(non_snake_case)]
pub struct Point2D {
    x: f64,
    y: f64,
    pub POLAR_ORDER: PolarOrder,
}

pub struct PolarOrder {
    _dummy: f64,              // dummy position
}

// TODO
impl Comparator<Point2D> for PolarOrder {
    fn compare(&self, q1: &Point2D, q2: &Point2D) -> Ordering {

        // ugly hack, offset 2 f64 is the start addr of Point2D
        let p: &Point2D = unsafe { mem::transmute((&self._dummy as *const f64).offset(-2)) };

        let y = p.y;
        let dy1 = q1.y - y;
        let dy2 = q2.y - y;

        if dy1 == 0f64 && dy2 == 0f64 {
            // p, q1, q2 horizontal
            unimplemented!()
        } else if dy1 >= 0f64 && dy2 < 0f64 {
            // q1 above p; q2 below p
            Ordering::Less
        } else if dy2 >= 0f64 && dy1 < 0f64 {
            // q1 below p; q2 above p
            Ordering::Greater
        } else {
            // FIXME: type mismatch
            // -Point2D::ccw(self.p, q1, q2)
            unimplemented!()
        }
    }
}


impl Point2D {
    pub fn new(x: f64, y: f64) -> Point2D {
        Point2D { x: x, y: y,
                  POLAR_ORDER: PolarOrder { _dummy: 0.0}
        }
    }

    pub fn ccw(a: &Point2D, b: &Point2D, c: &Point2D) -> i32 {
        let area2 = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
        match area2 {
            _ if area2 < 0f64 => -1,
            _ if area2 > 0f64 =>  1,
            _                 =>  0
        }
    }
}


#[test]
fn test_point2d() {
    let p1 = Point2D::new(0.5, 0.6);
    let p2 = Point2D::new(1.0, 3.0);
    let p3 = Point2D::new(-2.0, -1.0);

    p1.POLAR_ORDER.compare(&p2, &p3);
}