diff --git a/util/Ray.h b/util/Ray.h
index b0a175d..a38dd60 100644
--- a/util/Ray.h
+++ b/util/Ray.h
@@ -24,11 +24,10 @@ class Ray
          */
         Vector getPositionAt(double dist) const
         {
-            Vector v;
-            v[0] = m_origin[0] + dist * m_direction[0];
-            v[1] = m_origin[1] + dist * m_direction[1];
-            v[2] = m_origin[2] + dist * m_direction[2];
-            return v;
+            return Vector(
+                    m_origin[0] + dist * m_direction[0],
+                    m_origin[1] + dist * m_direction[1],
+                    m_origin[2] + dist * m_direction[2]);
         }
 
         Ray shift(double amt)
diff --git a/util/Vector.h b/util/Vector.h
index 35920b3..7fac54c 100644
--- a/util/Vector.h
+++ b/util/Vector.h
@@ -79,29 +79,26 @@ class Vector
 
         Vector mult(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] * v2.m_array[0];
-            result[1] = m_array[1] * v2.m_array[1];
-            result[2] = m_array[2] * v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] * v2.m_array[0],
+                    m_array[1] * v2.m_array[1],
+                    m_array[2] * v2.m_array[2]);
         }
 
         Vector div(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] / v2.m_array[0];
-            result[1] = m_array[1] / v2.m_array[1];
-            result[2] = m_array[2] / v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] / v2.m_array[0],
+                    m_array[1] / v2.m_array[1],
+                    m_array[2] / v2.m_array[2]);
         }
 
         Vector operator-() const
         {
-            Vector result;
-            result[0] = -m_array[0];
-            result[1] = -m_array[1];
-            result[2] = -m_array[2];
-            return result;
+            return Vector(
+                    -m_array[0],
+                    -m_array[1],
+                    -m_array[2]);
         }
 
         /* Compute the dot-product of two vectors */
@@ -115,47 +112,42 @@ class Vector
         /* Compute the cross-product of two vectors */
         Vector operator*(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[1] * v2.m_array[2] - m_array[2] * v2.m_array[1];
-            result[1] = m_array[2] * v2.m_array[0] - m_array[0] * v2.m_array[2];
-            result[2] = m_array[0] * v2.m_array[1] - m_array[1] * v2.m_array[0];
-            return result;
+            return Vector(
+                    m_array[1] * v2.m_array[2] - m_array[2] * v2.m_array[1],
+                    m_array[2] * v2.m_array[0] - m_array[0] * v2.m_array[2],
+                    m_array[0] * v2.m_array[1] - m_array[1] * v2.m_array[0]);
         }
 
         Vector operator+(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] + v2.m_array[0];
-            result[1] = m_array[1] + v2.m_array[1];
-            result[2] = m_array[2] + v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] + v2.m_array[0],
+                    m_array[1] + v2.m_array[1],
+                    m_array[2] + v2.m_array[2]);
         }
 
         Vector operator-(const Vector & v2) const
         {
-            Vector result;
-            result[0] = m_array[0] - v2.m_array[0];
-            result[1] = m_array[1] - v2.m_array[1];
-            result[2] = m_array[2] - v2.m_array[2];
-            return result;
+            return Vector(
+                    m_array[0] - v2.m_array[0],
+                    m_array[1] - v2.m_array[1],
+                    m_array[2] - v2.m_array[2]);
         }
 
         Vector operator*(double scale) const
         {
-            Vector result;
-            result[0] = m_array[0] * scale;
-            result[1] = m_array[1] * scale;
-            result[2] = m_array[2] * scale;
-            return result;
+            return Vector(
+                    m_array[0] * scale,
+                    m_array[1] * scale,
+                    m_array[2] * scale);
         }
 
         Vector operator/(double scale) const
         {
-            Vector result;
-            result[0] = m_array[0] / scale;
-            result[1] = m_array[0] / scale;
-            result[2] = m_array[0] / scale;
-            return result;
+            return Vector(
+                    m_array[0] / scale,
+                    m_array[0] / scale,
+                    m_array[0] / scale);
         }
 
         Vector & operator+=(const Vector & v2)