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

#[allow(dead_code)]

#[macro_use]
pub mod coords;

#[macro_use]
pub mod vectors;

#[cfg(test)]
mod test {
    use crate::coords;
    use crate::vectors;
    
    #[test]
    fn test_coords () {

        let a: coords::Coord = new_coord!(1, 2.0);
        let o: coords::Coord = new_coord!(2.0);
        let x: i64 = 3;
        let y: f32 = 3.0;
        let b: coords::Coord = new_coord!(x, y);
        
        // math
        let c: coords::Coord = a + b;
        let d: coords::Coord = a - c;
        let e: coords::Coord = a * d;
        let f: coords::Coord = o / a;
        
        // to vec
        let g: Vec<f64> = a.to_vec();
        
        // to tuple
        let i: (f64, f64) = c.to_tuple();

    
        // split
        let (r, o) = e.split();
        
        println!("let a: coord::Coord = new_coord!(1, 2.0); | {:?}", a);
        println!("let o: coord::Coord = new_coord!(2.0); | {:?}", o);
        println!("\nlet (x , y) = (3.0, 3);\nlet b: coords::Coord = new_coord!(x, y); | {:?}", b);
        println!("\nlet c: coord::Coord = a + b; | {:?}", c);
        println!("\nlet d: coord::Coord = a - c; | {:?}", d);
        println!("\nlet e: coord::Coord = a * d; | {:?}", e);
        println!("\nlet f: coord::Coord = a / a; | {:?}", f);
        println!("\n let g: Vec<f64> = a.to_vec(); {:?}", g);
        println!("\n let i: (f64, f64) = c.to_tuple(); | {:?}", i);
        println!("\n let (r, o) = e.split(); r={}, o={}" ,r,o);
    }

    #[test]
    fn test_vector () {


        let a: coords::Coord = new_coord!(2.5 ,3.3);
        let o: coords::Coord = new_coord!(2.5);
        let x: f64 = 3.0;
        let y: f32 = 3.0;
        let b: coords::Coord = new_coord!(x, y);
        
        let d: coords::Coord = a - b;
        let e: coords::Coord = a * d;

        let h:vectors::Vector = new_vector!();
        let f:vectors::Vector = new_vector!(o);
        let l:vectors::Vector = new_vector!(a, e);

        let m:vectors::Vector = h + l;
        let s:vectors::Vector = h + l;
        let w:vectors::Vector = m + h;
        let t:vectors::Vector = h + s;

        let vec: Vec<coords::Coord> = s.to_vec();
        let tup:(coords::Coord, coords::Coord , f64) = s.to_tuple();
        let mag = t.get_magnitude();
        
        println!("\nlet h:vectors::Vector = new_vector!(); | {:?}", h);
        println!("\nlet f:vectors::Vector = new_vector!(); | {:?}", f);
        println!("\nlet l:vectors::Vector = new_vector!(a, e); | {:?}", l);
        println!("\nlet m = h + l; | {:?}", m);
        println!("\nlet s = h + l; | {:?}", s);
        println!("\nlet w = m + h; | {:?}", w);
        println!("\nlet t = h + s; | {:?}", t);
        println!("\nlet mag = t.get_magnitude(); | {}", mag);
        println!("\nlet vec = s.to_vec(); | {:?}" , vec);
        println!("let tup = s.to_tuple(); | {:?}" , tup);

    }
}