Created tuples and with structs.

Need to do the cannon exercise yet

structs/src/lib.rs

@@ -62,6 +62,39 @@ impl Tuple {
         self.w == 0.0
     }
 
+    fn magnitude(&self) -> f32 {
+        (
+            (self.x * self.x) +
+            (self.y * self.y) +
+            (self.z * self.z) +
+            (self.w * self.w)
+        ).sqrt()
+    }
+
+    fn normalize(&self) -> Tuple {
+        let m = self.magnitude();
+        Tuple::new(
+            self.x / m,
+            self.y / m,
+            self.z / m,
+            self.w / m,
+        )
+    }
+
+    fn dot(&self, rhs: &Tuple) -> f32 {
+        self.x * rhs.x +
+            self.y * rhs.y +
+            self.z * rhs.z +
+            self.w * rhs.w
+    }
+
+    fn cross(&self, rhs: &Tuple) -> Tuple {
+        Tuple::vector(
+            self.y * rhs.z - self.z * rhs.y,
+            self.z * rhs.x - self.x * rhs.z,
+            self.x * rhs.y - self.y * rhs.x
+        )
+    }
 }
 
 impl PartialEq for Tuple {
@@ -294,4 +327,84 @@ mod tests {
  
          assert_eq!(result, a / 2.0);
      }
+
+     #[test]
+     fn magnitude_x() {
+         let v = Tuple::vector(1.0, 0.0, 0.0);
+         assert_eq!(1.0, v.magnitude());
+     }
+
+     #[test]
+     fn magnitude_y() {
+         let v = Tuple::vector(0.0, 1.0, 0.0);
+         assert_eq!(1.0, v.magnitude());
+     }
+
+     #[test]
+     fn magnitude_z() {
+         let v = Tuple::vector(0.0, 0.0, 1.0);
+         assert_eq!(1.0, v.magnitude());
+     }
+
+     #[test]
+     fn magnitude_123() {
+         let v = Tuple::vector(1.0, 2.0, 3.0);
+         assert_eq!(14.0_f32.sqrt(), v.magnitude());
+     }
+
+     #[test]
+     fn magnitude_123_neg() {
+         let v = Tuple::vector(-1.0, -2.0, -3.0);
+         assert_eq!(14.0_f32.sqrt(), v.magnitude());
+     }
+
+     #[test]
+     fn normalize_x() {
+         let v = Tuple::vector(4.0, 0.0, 0.0);
+         let norm = v.normalize();
+
+         let result = Tuple::vector(1.0, 0.0, 0.0);
+         assert_eq!(result, norm);
+         
+     }
+
+     #[test]
+     fn normalize_123() {
+         let v = Tuple::vector(1.0, 2.0, 3.0);
+         let norm = v.normalize();
+
+
+         let sqrt_of_14 = 14.0_f32.sqrt();
+         assert_relative_eq!(norm.x, 1.0 / sqrt_of_14);
+         assert_relative_eq!(norm.y, 2.0 / sqrt_of_14);
+         assert_relative_eq!(norm.z, 3.0 / sqrt_of_14);
+     }
+
+     #[test]
+     fn normalize_magnitude() {
+         let v = Tuple::vector(1.0, 2.0, 3.0);
+         let norm = v.normalize();
+         let m = norm.magnitude();
+
+         assert_relative_eq!(1.0, m);
+     }
+
+     #[test]
+     fn dot_product() {
+         let a = Tuple::vector(1.0, 2.0, 3.0);
+         let b = Tuple::vector(2.0, 3.0, 4.0);
+
+         assert_eq!(20.0, a.dot(&b));
+     }
+
+     #[test]
+     fn cross_product() {
+         let a = Tuple::vector(1.0, 2.0, 3.0);
+         let b = Tuple::vector(2.0, 3.0, 4.0);
+
+         let a_cross_b = Tuple::vector(-1.0, 2.0, -1.0);
+         assert_eq!(a_cross_b, a.cross(&b));
+         let b_cross_a = Tuple::vector(1.0, -2.0, 1.0);
+         assert_eq!(b_cross_a, b.cross(&a));
+     }
 }