#[derive(Copy, Clone)]
struct Vector {
    pub i: f64,
    pub j: f64,
    pub k: f64,
}

impl Vector {
    pub fn new(i: f64, j: f64, k: f64) -> Self {
        Self { i, j, k }
    }
    pub fn get_i(&self) -> Self {
        Self { i: 1.0, j: 0.0, k: 0.0 }
    }
    pub fn get_j(&self) -> Self {
        Vector { i: 0.0, j: 1.0, k: 0.0 }
    }
    pub fn get_k(&self) -> Self {
        Self { i: 0.0, j: 0.0, k: 1.0 }
    }
    pub fn get_magnitude(&self) -> f64 {
        (self.i.powi(2) + self.j.powi(2) + self.k.powi(2)).sqrt()
    }
    pub fn add(&self, mut v: Self) -> Self {
        v.i += self.i;
        v.j += self.j;
        v.k += self.k;
        v
    }
    pub fn multiply_by_scalar(&self, s: f64) -> Self {
        Self {
            i: self.i * s,
            j: self.j * s,
            k: self.k * s
        }
    }
    pub fn dot(&self, v: Self) -> f64 {
        self.i * v.i + self.j * v.j + self.k * v.k
    }
    pub fn cross(&self, v: Self) -> Self {
        Self {
            i: self.j * v.k - v.j * self.k,
            j: self.k * v.i - v.k * self.i,
            k: self.i * v.j - v.i * self.j
        }
    }
    fn is_zero(&self, eps: f64) -> bool {
        self.i < eps && self.j < eps && self.k < eps
    }
    pub fn is_parallel_to(&self, v: Self) -> bool {
        !v.is_zero(1e-8) && self.cross(v).is_zero(1e-8)
    }
    pub fn is_perpendicular_to(&self, v: Self) -> bool {
        self.dot(v) < 1e-8
    }
    pub fn normalize(&self) -> Self {
        let m = self.get_magnitude();
        Self {
            i: self.i / m,
            j: self.j / m,
            k: self.k / m
        }
    }
    pub fn is_normalized(&self) -> bool {
        (self.get_magnitude() - 1.0) < 1e-8
    }
}