RustGraphix 0.2.1

Rust-Graphix is a Rust library for mathematics. It includes support for matrices, both two-dimensional and three-dimensional, along with various matrix operations and methods.
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

pub mod Vector3 {
    pub trait Props {}

    pub trait Op {
        fn add(&mut self, vector3: Vector3);
        fn sub(&mut self, other: Vector3) -> Vector3;
        fn dot(&self, vector3: Vector3) -> f64;
    }

    pub trait Transform {
        fn translate(&mut self, x: f64, y: f64, z: f64);
        fn normalize(&mut self);

    }

    pub trait Analysis {
        fn Distance(&mut self, vector: Vector3) -> f64;
    }

    #[derive(Debug, Clone, Copy)]
    pub struct Vector3 {
        pub x: f64,
        pub y: f64,
        pub z: f64,
        pub magnitude: f64,
    }

    impl Vector3 {
        pub fn new(x: f64, y: f64, z: f64) -> Self {
            Vector3 {
                x: x,
                y: y,
                z: z,
                magnitude: f64::sqrt(x * x + y * y + z * z),
            }
        }
    }

    impl Op for Vector3 {
        fn add(&mut self, vector: Vector3) {
            self.x += vector.x;
            self.y += vector.y;
            self.z += vector.z;
        }

        fn sub(&mut self, other: Vector3) -> Vector3 {
            Vector3::new(self.x - other.x, self.y - other.y, self.z - other.z)

        }

        fn dot(&self, vector: Vector3) -> f64 {
            self.x * vector.x + self.y * vector.y + self.z * vector.z
        }
    }

    impl Transform for Vector3 {
        fn translate(&mut self, x: f64, y: f64, z: f64) {
            self.x += x;
            self.y += y;
            self.z += z;
        }
        fn normalize(&mut self) {
            self.x/=self.magnitude;
            self.y/=self.magnitude;
            self.z/=self.magnitude;
            self.magnitude=1.0;
        }
    }
    impl Analysis for Vector3 {
        fn Distance(&mut self, vector: Vector3) -> f64 {
          let mut res = self.sub(vector).magnitude;
          return res;

        }
    }
}