Move vector into math/vector/ matching its actual namespace

Add clang-format.

.clang-format

@@ -0,0 +1,108 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -2
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllParametersOfDeclarationOnNextLine: true
+AllowShortBlocksOnASingleLine: true
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: false
+BinPackArguments: true
+BinPackParameters: true
+BraceWrapping:   
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Attach
+BreakBeforeInheritanceComma: false
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: true
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: false
+ForEachMacros:   
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeCategories: 
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+  - Regex:           '.*'
+    Priority:        1
+IncludeIsMainRegex: '(Test)?$'
+IndentCaseLabels: false
+IndentWidth:     2
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: All
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Middle
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeParens: ControlStatements
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+Standard:        Cpp11
+TabWidth:        8
+UseTab:          Never
+...
+

include/vector/vector.hpp

@@ -20,70 +20,73 @@
 
 namespace math { namespace matrix {
   template <typename, size_t, size_t> class matrix;
-} }
+}}
 
 namespace math { namespace vector {
-#define VECTOR_ENABLE_IF_LT_N(index, expr) \
-template <bool _ = true> \
-typename std::enable_if<std::size_t(index) < N && _, expr>::type
-  
-#define VECTOR_ENABLE_IF_EQ_N(index, t, n) \
-template <bool _ = true> \
-typename std::enable_if<std::size_t(index) == N && _, vector<t, n> >::type
-  
-#define VECTOR_ENABLE_IF_EQ_T(_type, t, n) \
-typename std::enable_if<std::is_same<_type, t>::value, vector<t, n> >::type
-  
-#define VECTOR_DISABLE_IF_VECTOR(_type, t, n) \
-typename std::enable_if<!is_vector<_type>::value, vector<t, n> >::type
-  
-#define VECTOR_ACCESS_FN(name, i) \
-VECTOR_ENABLE_IF_LT_N(i, value_type const &) name() const { return _data[i]; } \
-VECTOR_ENABLE_IF_LT_N(i, value_type &) name() { return _data[i]; }
-  
-#define VECTOR_FOR_EACH_RANGE(var, end) for (std::size_t var = 0; var < end; ++var)
+#define VECTOR_ENABLE_IF_LT_N(index, expr)                                     \
+  template <bool _ = true>                                                     \
+  typename std::enable_if<std::size_t(index) < N && _, expr>::type
+
+#define VECTOR_ENABLE_IF_EQ_N(index, t, n)                                     \
+  template <bool _ = true>                                                     \
+  typename std::enable_if<std::size_t(index) == N && _, vector<t, n>>::type
+
+#define VECTOR_ENABLE_IF_EQ_T(_type, t, n)                                     \
+  typename std::enable_if<std::is_same<_type, t>::value, vector<t, n>>::type
+
+#define VECTOR_DISABLE_IF_VECTOR(_type, t, n)                                  \
+  typename std::enable_if<!is_vector<_type>::value, vector<t, n>>::type
+
+#define VECTOR_ACCESS_FN(name, i)                                              \
+  VECTOR_ENABLE_IF_LT_N(i, value_type const &) name() const {                  \
+    return _data[i];                                                           \
+  }                                                                            \
+  VECTOR_ENABLE_IF_LT_N(i, value_type &) name() { return _data[i]; }
+
+#define VECTOR_FOR_EACH_RANGE(var, end)                                        \
+  for (std::size_t var = 0; var < end; ++var)
 #define VECTOR_FOR_EACH(var) VECTOR_FOR_EACH_RANGE(var, N)
-  
-  struct {} fill;
+
+  struct {
+  } fill;
   using fill_t = decltype(fill);
-  
-  template <typename T>
-  struct is_vector { static const constexpr bool value = false; };
-  
-  template <typename T, std::size_t N>
-  class vector;
-  template <typename T, std::size_t N>
-  struct is_vector<vector<T, N>> { static const constexpr bool value = true; };
+
+  template <typename T> struct is_vector {
+    static const constexpr bool value = false;
+  };
+
+  template <typename T, std::size_t N> class vector;
+  template <typename T, std::size_t N> struct is_vector<vector<T, N>> {
+    static const constexpr bool value = true;
+  };
   template <typename T, std::size_t R, std::size_t C>
-  struct is_vector<matrix::matrix<T, R, C>> { static const constexpr bool value = true; };
-  
-  template <typename T, std::size_t N>
-  class vector {
+  struct is_vector<matrix::matrix<T, R, C>> {
+    static const constexpr bool value = true;
+  };
+
+  template <typename T, std::size_t N> class vector {
   public:
     using value_type = T;
+
   private:
     using mag_t = decltype(std::sqrt(std::declval<T>()));
     template <typename M>
-    using mul_t = decltype(std::declval<T>()*std::declval<M>());
+    using mul_t = decltype(std::declval<T>() * std::declval<M>());
     template <typename M>
-    using div_t = decltype(std::declval<T>()/std::declval<M>());
+    using div_t = decltype(std::declval<T>() / std::declval<M>());
+
   public:
-    
     // Constructors
     vector() = default;
-    
+
     vector(std::array<T, N> const & init) {
       VECTOR_FOR_EACH(i) { _data[i] = init[i]; }
     }
-    
-    vector(vector const & other) {
-      *this = other;
-    }
-    
-    vector(vector && other) {
-      *this = std::move(other);
-    }
-    
+
+    vector(vector const & other) { *this = other; }
+
+    vector(vector && other) { *this = std::move(other); }
+
     // Conversion
     template <typename T2, std::size_t N2>
     explicit vector(vector<T2, N2> const & other) {
@@ -91,188 +94,181 @@ VECTOR_ENABLE_IF_LT_N(i, value_type &) name() { return _data[i]; }
         _data[i] = static_cast<T>(other[i]);
       }
     }
-    
+
     vector(T const & v, fill_t) {
       VECTOR_FOR_EACH(i) { _data[i] = v; }
     }
-    
+
     // Assignment
-    vector& operator=(vector const & other) {
+    vector & operator=(vector const & other) {
       VECTOR_FOR_EACH(i) { _data[i] = other[i]; }
       return *this;
     }
-    
-    vector& operator=(vector && other) {
+
+    vector & operator=(vector && other) {
       VECTOR_FOR_EACH(i) { _data[i] = std::move(other._data[i]); }
       return *this;
     }
-    
+
     // Named Accessors
     // - Numeric Vector Accessors
     VECTOR_ACCESS_FN(x, 0)
     VECTOR_ACCESS_FN(y, 1)
     VECTOR_ACCESS_FN(z, 2)
     VECTOR_ACCESS_FN(w, 3)
-    
+
     // - Color Vector Accessors
     VECTOR_ACCESS_FN(r, 0)
     VECTOR_ACCESS_FN(g, 1)
     VECTOR_ACCESS_FN(b, 2)
     VECTOR_ACCESS_FN(a, 3)
-    
+
     // Unnamed Accessors
-    value_type const & operator[](std::size_t idx) const {
-      return _data[idx];
-    }
-    
-    value_type & operator[](std::size_t idx) {
-      return _data[idx];
-    }
-    
+    value_type const & operator[](std::size_t idx) const { return _data[idx]; }
+
+    value_type & operator[](std::size_t idx) { return _data[idx]; }
+
     value_type const & at(std::size_t idx) const {
       expects(idx < N, std::out_of_range, "index out of range");
       return _data[idx];
     }
-    
+
     value_type & at(std::size_t idx) {
       expects(idx < N, std::out_of_range, "index out of range");
       return _data[idx];
     }
-    
+
     // Mathematical Operations
-    vector& operator+=(vector const & other) {
+    vector & operator+=(vector const & other) {
       VECTOR_FOR_EACH(i) { _data[i] += other[i]; }
       return *this;
     }
-    
-    vector& operator+=(T const & other) {
+
+    vector & operator+=(T const & other) {
       return operator+=(vector(other, fill));
     }
-    
+
     vector operator+(vector const & other) const {
       return vector{*this} += other;
     }
-    
+
     vector operator+(T const & other) const {
       return operator+(vector(other, fill));
     }
-    
+
     friend vector operator+(T const & lhs, vector const & rhs) {
       return rhs + lhs;
     }
-    
-    vector& operator-=(vector const & other) {
+
+    vector & operator-=(vector const & other) {
       VECTOR_FOR_EACH(i) { _data[i] -= other[i]; }
       return *this;
     }
-    
-    vector& operator-=(T const & other) {
+
+    vector & operator-=(T const & other) {
       return operator-=(vector(other, fill));
     }
-    
+
     vector operator-(vector const & other) const {
       return vector{*this} -= other;
     }
-    
+
     vector operator-(T const & other) const {
       return operator-(vector(other, fill));
     }
-    
+
     friend vector operator-(T const & lhs, vector const & rhs) {
       return vector(lhs, fill) - rhs;
     }
-    
-    vector operator-() const {
-      return vector{} -= *this;
-    }
-    
+
+    vector operator-() const { return vector{} -= *this; }
+
     template <typename M>
-    VECTOR_ENABLE_IF_EQ_T(mul_t<M>, T, N)& operator*=(M c) {
+    VECTOR_ENABLE_IF_EQ_T(mul_t<M>, T, N) & operator*=(M c) {
       VECTOR_FOR_EACH(i) { _data[i] *= c; }
       return *this;
     }
-    
+
     template <typename M>
-    VECTOR_DISABLE_IF_VECTOR(M, mul_t<M>, N) operator*(M c) const {
+    VECTOR_DISABLE_IF_VECTOR(M, mul_t<M>, N)
+    operator*(M c) const {
       return vector<mul_t<M>, N>{*this} *= c;
     }
-    
+
     template <typename M>
-    friend VECTOR_DISABLE_IF_VECTOR(M, mul_t<M>, N) operator*(M c, vector<T, N> const & v) {
+    friend VECTOR_DISABLE_IF_VECTOR(M, mul_t<M>, N)
+    operator*(M c, vector<T, N> const & v) {
       return v * c;
     }
-    
+
     template <typename M>
-    VECTOR_ENABLE_IF_EQ_T(mul_t<M>, T, N)& operator*=(vector<M, N> c) {
+    VECTOR_ENABLE_IF_EQ_T(mul_t<M>, T, N) & operator*=(vector<M, N> c) {
       VECTOR_FOR_EACH(i) { _data[i] *= c[i]; }
       return *this;
     }
-    
+
     template <typename M>
     vector<mul_t<M>, N> operator*(vector<M, N> const & other) const {
       return vector<mul_t<M>, N>{*this} *= other;
     }
-    
+
     template <typename M>
-    VECTOR_ENABLE_IF_EQ_T(div_t<M>, T, N)& operator/=(M c) {
+    VECTOR_ENABLE_IF_EQ_T(div_t<M>, T, N) & operator/=(M c) {
       expects(c != 0, std::domain_error, "divide by zero");
       VECTOR_FOR_EACH(i) { _data[i] /= c; }
       return *this;
     }
-    
+
     template <typename M>
-    VECTOR_DISABLE_IF_VECTOR(M, div_t<M>, N) operator/(M c) const {
+    VECTOR_DISABLE_IF_VECTOR(M, div_t<M>, N)
+    operator/(M c) const {
       return vector<div_t<M>, N>{*this} /= c;
     }
-    
+
     template <typename M>
-    VECTOR_ENABLE_IF_EQ_T(div_t<M>, T, N)& operator/=(vector<M, N> c) {
-      VECTOR_FOR_EACH(i) { expects(c[i] != 0, std::domain_error, "divide by zero"); }
+    VECTOR_ENABLE_IF_EQ_T(div_t<M>, T, N) & operator/=(vector<M, N> c) {
+      VECTOR_FOR_EACH(i) {
+        expects(c[i] != 0, std::domain_error, "divide by zero");
+      }
       VECTOR_FOR_EACH(i) { _data[i] /= c[i]; }
       return *this;
     }
-    
+
     template <typename M>
     vector<div_t<M>, N> operator/(vector<M, N> const & other) const {
       return vector<div_t<M>, N>{*this} /= other;
     }
-    
+
     // Vector Operations
     value_type dot(vector const & other) const {
       value_type accum{};
       VECTOR_FOR_EACH(i) { accum += at(i) * other.at(i); }
       return accum;
     }
-    
-    mag_t magnitude() const {
-      return std::sqrt(dot(*this));
-    }
-    
-    vector<mag_t, N> unit() const {
-      return *this / magnitude();
-    }
-    
+
+    mag_t magnitude() const { return std::sqrt(dot(*this)); }
+
+    vector<mag_t, N> unit() const { return *this / magnitude(); }
+
     VECTOR_ENABLE_IF_EQ_N(3, T, N) cross(vector const & other) const {
-      return {{
-        y()*other.z() - z()*other.y(),
-        z()*other.x() - x()*other.z(),
-        x()*other.y() - y()*other.x()
-      }};
+      return {{y() * other.z() - z() * other.y(),
+               z() * other.x() - x() * other.z(),
+               x() * other.y() - y() * other.x()}};
     }
-    
+
     VECTOR_ENABLE_IF_EQ_N(2, T, 3) cross(vector const & other) const {
-      return {{ 0, 0, x()*other.y() - y()*other.x() }};
+      return {{0, 0, x() * other.y() - y() * other.x()}};
     }
-    
+
     vector<mag_t, N> projection(vector const & other) const {
       vector<mag_t, N> b_p = other.unit();
       return b_p * vector<mag_t, N>{*this}.dot(b_p);
     }
-    
+
   private:
     value_type _data[N] = {value_type()};
   };
-  
+
   template <typename T, std::size_t N>
   vector<T, N> abs(vector<T, N> const & self) {
     vector<T, N> tmp(self);
@@ -280,34 +276,49 @@ VECTOR_ENABLE_IF_LT_N(i, value_type &) name() { return _data[i]; }
     VECTOR_FOR_EACH(i) { tmp[i] = abs(tmp[i]); }
     return tmp;
   }
-  
+
   template <typename T, std::size_t N>
   int compare(vector<T, N> const & lhs, vector<T, N> const & rhs) {
     VECTOR_FOR_EACH(i) {
-      if (lhs[i] < rhs[i]) return -1;
-      else if (lhs[i] > rhs[i]) return 1;
+      if (lhs[i] < rhs[i])
+        return -1;
+      else if (lhs[i] > rhs[i])
+        return 1;
     }
     return 0;
   }
-  
+
   template <typename T, std::size_t N>
-  bool operator==(vector<T, N> const & lhs, vector<T, N> const & rhs) { return compare(lhs, rhs) == 0; }
+  bool operator==(vector<T, N> const & lhs, vector<T, N> const & rhs) {
+    return compare(lhs, rhs) == 0;
+  }
   template <typename T, std::size_t N>
-  bool operator!=(vector<T, N> const & lhs, vector<T, N> const & rhs) { return compare(lhs, rhs) != 0; }
+  bool operator!=(vector<T, N> const & lhs, vector<T, N> const & rhs) {
+    return compare(lhs, rhs) != 0;
+  }
   template <typename T, std::size_t N>
-  bool operator< (vector<T, N> const & lhs, vector<T, N> const & rhs) { return compare(lhs, rhs) <  0; }
+  bool operator<(vector<T, N> const & lhs, vector<T, N> const & rhs) {
+    return compare(lhs, rhs) < 0;
+  }
   template <typename T, std::size_t N>
-  bool operator<=(vector<T, N> const & lhs, vector<T, N> const & rhs) { return compare(lhs, rhs) <= 0; }
+  bool operator<=(vector<T, N> const & lhs, vector<T, N> const & rhs) {
+    return compare(lhs, rhs) <= 0;
+  }
   template <typename T, std::size_t N>
-  bool operator> (vector<T, N> const & lhs, vector<T, N> const & rhs) { return compare(lhs, rhs) >  0; }
+  bool operator>(vector<T, N> const & lhs, vector<T, N> const & rhs) {
+    return compare(lhs, rhs) > 0;
+  }
   template <typename T, std::size_t N>
-  bool operator>=(vector<T, N> const & lhs, vector<T, N> const & rhs) { return compare(lhs, rhs) >= 0; }
-} }
+  bool operator>=(vector<T, N> const & lhs, vector<T, N> const & rhs) {
+    return compare(lhs, rhs) >= 0;
+  }
+}}
 
 template <typename... Ts>
-auto make_vector(Ts && ...elems) -> math::vector::vector<typename std::common_type<Ts...>::type, sizeof...(Ts)> {
+auto make_vector(Ts &&... elems)
+    -> math::vector::vector<typename std::common_type<Ts...>::type,
+                            sizeof...(Ts)> {
   return {{elems...}};
 }
 
-
 using math::vector::abs;

test/vector_test.cxx

@@ -7,17 +7,17 @@
 
 #include <gmock/gmock.h>
 
-#include "vector/vector.hpp"
+#include "math/vector/vector.hpp"
 
-template <typename T, size_t N>
-math::vector::vector<T, N> iota() {
+template <typename T, size_t N> math::vector::vector<T, N> iota() {
   math::vector::vector<T, N> rval;
-  for (size_t i = 0; i < N; ++i) rval[i] = static_cast<T>(i+1);
+  for (size_t i = 0; i < N; ++i)
+    rval[i] = static_cast<T>(i + 1);
   return rval;
 }
 
 using vec2i = math::vector::vector<int, 2>;
-using vec3  = math::vector::vector<double, 3>;
+using vec3 = math::vector::vector<double, 3>;
 using vec3i = math::vector::vector<int, 3>;
 using vec4i = math::vector::vector<int, 4>;
 
@@ -30,7 +30,7 @@ TEST(Vector, Equality) {
 }
 
 TEST(Vector, DefaultConstructorIsAllZero) {
-  EXPECT_THAT(vec3i(), vec3i({0,0,0}));
+  EXPECT_THAT(vec3i(), vec3i({0, 0, 0}));
 }
 
 TEST(Vector, FillConstructorInsertsAllElements) {
@@ -38,7 +38,7 @@ TEST(Vector, FillConstructorInsertsAllElements) {
 }
 
 TEST(Vector, ExtensionConstructorAppendsZeros) {
-  EXPECT_THAT(vec4i(iota3i()), vec4i({1,2,3,0}));
+  EXPECT_THAT(vec4i(iota3i()), vec4i({1, 2, 3, 0}));
 }
 
 TEST(Vector, CanAccessVectorElements) {
@@ -53,52 +53,53 @@ TEST(Vector, AccessingOutOfRangeThrows) {
 }
 
 TEST(Vector, CrossProduct2DHasOnlyZElement) {
-  EXPECT_THAT(vec2i({1,1}).cross(vec2i({-1,1})), vec3i({0,0,2}));
+  EXPECT_THAT(vec2i({1, 1}).cross(vec2i({-1, 1})), vec3i({0, 0, 2}));
 }
 
 TEST(Vector, CrossProduct3DHasAllElements) {
-  EXPECT_THAT(vec3i({1,1,2}).cross(vec3i({-1,1,1})), vec3i({-1,-3,2}));
+  EXPECT_THAT(vec3i({1, 1, 2}).cross(vec3i({-1, 1, 1})), vec3i({-1, -3, 2}));
 }
 
 TEST(Vector, AdditionIsPiecewise) {
-  EXPECT_THAT((vec2i{{1,0}} + vec2i{{0,1}}), vec2i({1,1}));
+  EXPECT_THAT((vec2i{{1, 0}} + vec2i{{0, 1}}), vec2i({1, 1}));
 }
 
 TEST(Vector, SubtractionIsPiecewise) {
-  EXPECT_THAT((vec2i{{1,0}} - vec2i{{0,1}}), vec2i({1,-1}));
+  EXPECT_THAT((vec2i{{1, 0}} - vec2i{{0, 1}}), vec2i({1, -1}));
 }
 
 TEST(Vector, MultiplicationIsPiecewise) {
-  EXPECT_THAT((vec2i{{1,0}}*vec2i({2,1})), vec2i({2,0}));
+  EXPECT_THAT((vec2i{{1, 0}} * vec2i({2, 1})), vec2i({2, 0}));
 }
 
 TEST(Vector, DivisionIsPiecewise) {
-  EXPECT_THAT((vec2i{{6,4}}/vec2i({2,1})), vec2i({3,4}));
+  EXPECT_THAT((vec2i{{6, 4}} / vec2i({2, 1})), vec2i({3, 4}));
 }
 
 TEST(Vector, DivisionByZeroThrowsException) {
   EXPECT_THROW(vec3{} / 0, std::domain_error);
-  EXPECT_THROW((vec3{{1.0, 1.0, 1.0}}/vec3({1.0, 0.5, 0.0})), std::domain_error);
+  EXPECT_THROW((vec3{{1.0, 1.0, 1.0}} / vec3({1.0, 0.5, 0.0})),
+               std::domain_error);
 }
 
 TEST(Vector, AdditionWithValueType) {
-  EXPECT_THAT(vec2i({1,0}) + 1, vec2i({2,1}));
-  EXPECT_THAT(1+iota2i(), vec2i({2,3}));
+  EXPECT_THAT(vec2i({1, 0}) + 1, vec2i({2, 1}));
+  EXPECT_THAT(1 + iota2i(), vec2i({2, 3}));
 }
 
 TEST(Vector, SubtractionWithValueType) {
-  EXPECT_THAT(4-iota2i(), vec2i({3,2}));
-  EXPECT_THAT(vec2i({1,0}) - 1, vec2i({0,-1}));
+  EXPECT_THAT(4 - iota2i(), vec2i({3, 2}));
+  EXPECT_THAT(vec2i({1, 0}) - 1, vec2i({0, -1}));
 }
 
 TEST(Vector, MultiplicationWithValueType) {
-  EXPECT_THAT((vec2i{{1,0}} * 3), vec2i({3,0}));
-  EXPECT_THAT(2*iota2i(), vec2i({2,4}));
+  EXPECT_THAT((vec2i{{1, 0}} * 3), vec2i({3, 0}));
+  EXPECT_THAT(2 * iota2i(), vec2i({2, 4}));
 }
 
 TEST(Vector, DivisionWithValueType) {
-  EXPECT_THAT((vec2i{{6,4}} / 2), vec2i({3,2}));
-//  EXPECT_THAT(4/iota2i(), (vec2i{4,2}));
+  EXPECT_THAT((vec2i{{6, 4}} / 2), vec2i({3, 2}));
+  //  EXPECT_THAT(4/iota2i(), (vec2i{4,2}));
 }
 
 TEST(Vector, OperatorPlusEqualsMutatesValue) {
@@ -118,32 +119,35 @@ TEST(Vector, OperatorMinusEqualsMutatesValue) {
 }
 
 TEST(Vector, MultiplicationWorksAcrossTypes) {
-  EXPECT_THAT(iota3i()*0.5, vec3({0.5, 1.0, 1.5}));
-  EXPECT_THAT(0.5*iota3i(), vec3({0.5, 1.0, 1.5}));
-  EXPECT_THAT(vec3({2.0, 1.5, -2})*iota3i(), vec3({2.0, 3.0, -6.0}));
+  EXPECT_THAT(iota3i() * 0.5, vec3({0.5, 1.0, 1.5}));
+  EXPECT_THAT(0.5 * iota3i(), vec3({0.5, 1.0, 1.5}));
+  EXPECT_THAT(vec3({2.0, 1.5, -2}) * iota3i(), vec3({2.0, 3.0, -6.0}));
 }
 
 TEST(Vector, DivisionWorksAcrossTypes) {
-  EXPECT_THAT(iota3i()/0.5, vec3({2.0, 4.0, 6.0}));
-  EXPECT_THAT(iota3i()/vec3({2.0, 2.5, -2}), vec3({0.5, 0.8, -1.5}));
-  EXPECT_THAT(vec3({2.0, 2.5, -3})/iota3i(), vec3({2.0, 1.25, -1.0}));
+  EXPECT_THAT(iota3i() / 0.5, vec3({2.0, 4.0, 6.0}));
+  EXPECT_THAT(iota3i() / vec3({2.0, 2.5, -2}), vec3({0.5, 0.8, -1.5}));
+  EXPECT_THAT(vec3({2.0, 2.5, -3}) / iota3i(), vec3({2.0, 1.25, -1.0}));
 }
 
 TEST(Vector, Length) {
   //    EXPECT_THAT(iota3i().lengthSquared(), 14);
   EXPECT_THAT(iota3i().magnitude(),
-              ::testing::DoubleNear(std::sqrt(14),  std::numeric_limits<double>::epsilon()));
+              ::testing::DoubleNear(std::sqrt(14),
+                                    std::numeric_limits<double>::epsilon()));
 }
 
 TEST(Vector, Distance) {
   //    EXPECT_THAT((iota3i().distanceSquared(vec3i{3, 1, -1})), 21);
   EXPECT_THAT((iota3i() - vec3i({3, 1, -1})).magnitude(),
-              ::testing::DoubleNear(std::sqrt(21),  std::numeric_limits<double>::epsilon()));
+              ::testing::DoubleNear(std::sqrt(21),
+                                    std::numeric_limits<double>::epsilon()));
 }
 
 TEST(Vector, Projection) {
   EXPECT_THAT(iota3i().projection(vec3i({3, 1, -1})).magnitude(),
-              ::testing::DoubleNear(std::sqrt(4.0/11.0),  std::numeric_limits<double>::epsilon()));
+              ::testing::DoubleNear(std::sqrt(4.0 / 11.0),
+                                    std::numeric_limits<double>::epsilon()));
 }
 
 TEST(Vector, DotProductIsSumOfElementProducts) {
@@ -153,9 +157,12 @@ TEST(Vector, DotProductIsSumOfElementProducts) {
 TEST(Vector, UnitFunctionCreatesNewVectorOverMagnitude) {
   double sq = std::sqrt(14);
   auto unit = iota3i().unit();
-  EXPECT_THAT(unit[0], ::testing::DoubleNear(1/sq,  std::numeric_limits<double>::epsilon()));
-  EXPECT_THAT(unit[1], ::testing::DoubleNear(2/sq,  std::numeric_limits<double>::epsilon()));
-  EXPECT_THAT(unit[2], ::testing::DoubleNear(3/sq,  std::numeric_limits<double>::epsilon()));
+  EXPECT_THAT(unit[0], ::testing::DoubleNear(
+                           1 / sq, std::numeric_limits<double>::epsilon()));
+  EXPECT_THAT(unit[1], ::testing::DoubleNear(
+                           2 / sq, std::numeric_limits<double>::epsilon()));
+  EXPECT_THAT(unit[2], ::testing::DoubleNear(
+                           3 / sq, std::numeric_limits<double>::epsilon()));
 }
 
 TEST(Vector, CanCastEntireVectorThroughConstructor) {
@@ -164,15 +171,17 @@ TEST(Vector, CanCastEntireVectorThroughConstructor) {
 
 TEST(Vector, SwapExchangesAllValues) {
   using std::swap;
-  vec2i a{{1, 2}}; const vec2i ac = a;
-  vec2i b{{5, 7}}; const vec2i bc = b;
+  vec2i a{{1, 2}};
+  const vec2i ac = a;
+  vec2i b{{5, 7}};
+  const vec2i bc = b;
   swap(a, b);
   EXPECT_THAT(a, bc);
   EXPECT_THAT(b, ac);
 }
 
 TEST(Vector, UnaryNegateOperatorNegatesAllElements) {
-  EXPECT_THAT(-iota3i(), vec3i({-1,-2,-3}));
+  EXPECT_THAT(-iota3i(), vec3i({-1, -2, -3}));
 }
 
 TEST(Vector, AbsoluteValueOfVectorAbsAllElements) {

vector.xcodeproj/project.pbxproj

@@ -9,6 +9,7 @@
 /* Begin PBXBuildFile section */
 		CD10426124E8380600C0DF2A /* GoogleMock.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = CD0C598220C31CC300454F82 /* GoogleMock.framework */; };
 		CD10426224E8382400C0DF2A /* vector_test.cxx in Sources */ = {isa = PBXBuildFile; fileRef = CD10423624E836A700C0DF2A /* vector_test.cxx */; };
+		CD10426924E8701200C0DF2A /* math in Resources */ = {isa = PBXBuildFile; fileRef = CD10426824E8701100C0DF2A /* math */; };
 /* End PBXBuildFile section */
 
 /* Begin PBXContainerItemProxy section */
@@ -45,9 +46,9 @@
 /* Begin PBXFileReference section */
 		CD0C597A20C31CC300454F82 /* GoogleMock.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = GoogleMock.xcodeproj; path = "../../../gmock-xcode-master/GoogleMock.xcodeproj"; sourceTree = "<group>"; };
 		CD10423624E836A700C0DF2A /* vector_test.cxx */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vector_test.cxx; sourceTree = "<group>"; };
-		CD10423E24E836BD00C0DF2A /* vector */ = {isa = PBXFileReference; lastKnownFileType = folder; name = vector; path = include/vector; sourceTree = "<group>"; };
 		CD10425824E837FB00C0DF2A /* vector-test.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = "vector-test.xctest"; sourceTree = BUILT_PRODUCTS_DIR; };
 		CD10425C24E837FB00C0DF2A /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		CD10426824E8701100C0DF2A /* math */ = {isa = PBXFileReference; lastKnownFileType = folder; name = math; path = include/math; sourceTree = "<group>"; };
 /* End PBXFileReference section */
 
 /* Begin PBXFrameworksBuildPhase section */
@@ -66,7 +67,7 @@
 			isa = PBXGroup;
 			children = (
 				CD0C597A20C31CC300454F82 /* GoogleMock.xcodeproj */,
-				CD10423E24E836BD00C0DF2A /* vector */,
+				CD10426824E8701100C0DF2A /* math */,
 				CD10423524E836A700C0DF2A /* test */,
 				CD10425924E837FB00C0DF2A /* vector-test */,
 				0E5DFDF41BB4D5040063976E /* Products */,
@@ -210,6 +211,7 @@
 			isa = PBXResourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				CD10426924E8701200C0DF2A /* math in Resources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
 		};