pub mod calculus {
    // struct Vec3Cache {
    //     mag: Option<f64>,
    //     mag_sql: Option<f64>,
    //     unit: Option<Vec3>,
    // }

    pub struct Vec3 {
        pub x: f64,
        pub y: f64,
        pub z: f64,
        // cached: Vec3Cache,
    }

    impl Vec3 {
        pub fn new(x: f64, y: f64, z: f64) -> Self {
            Self { x, y, z }
        }

        pub fn add(&self, other: &Self) -> Self {
            Self {
                x: self.x + other.x,
                y: self.y + other.y,
                z: self.z + other.z
            }
        }

        pub fn sub(&self, other: &Self) -> Self {
            Self {
                x: self.x - other.x,
                y: self.y - other.y,
                z: self.z - other.z
            }
        }

        pub fn scalar_mul(&mut self, multiplier: f64) {
            self.x *= multiplier;
            self.y *= multiplier;
            self.z *= multiplier;
        }

        pub fn mag_sqr(&self) -> f64 {
            self.x * self.x + self.y * self.y + self.z * self.z
        }

        pub fn mag(&self) -> f64 {
            self.mag_sqr().sqrt()
        }

        pub fn dot_prod(&self, other: &Self) -> f64 {
            self.x * other.x + self.y * other.y + self.z * other.z
        }

        pub fn cross_prod(&self, other: &Self) -> Self {
            Self {
                x: self.y * other.z - self.z - other.y,
                y: self.z * other.x - self.x * other.z,
                z: self.x * other.y - self.y * other.x,
            }
        }

        pub fn unit(&self) -> Self {
            let mag = self.mag();
            Self {
                x: self.x / mag,
                y: self.y / mag,
                z: self.z / mag,
            }
        }
    }
}