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

#[allow(dead_code)]

#[macro_use]
pub mod coords;

#[macro_use]
pub mod vectors;

#[macro_use]
pub mod debug;

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

    #[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: f64 = t.get_magnitude();
        let mid: coords::Coord = m.get_midpoint();
        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!("\nlet tup = s.to_tuple(); | {:?}" , tup);
        println!("\nlet mid: coords::Coord = m.get_midpoint(); | {:?}" , mid);

    }
    #[test]
    fn test_debug() {
        let a: coords::Coord = new_coord!(2.5 ,3.3);
        let o: coords::Coord = new_coord!(2.5);
        let l:vectors::Vector = new_vector!(a, o);

        debug::debug(a);
        debug::debug(l);

        let _type = debug::type_of(a);
        println!("{}", _type);
    }
}