diff --git a/headers/vmath.hpp/vmath_fwd.hpp b/headers/vmath.hpp/vmath_fwd.hpp
index 7ef864a..cc3c879 100644
--- a/headers/vmath.hpp/vmath_fwd.hpp
+++ b/headers/vmath.hpp/vmath_fwd.hpp
@@ -49,13 +49,13 @@ namespace vmath_hpp
     using double3 = vec<double, 3>;
     using double4 = vec<double, 4>;
 
-    using size2 = vec<std::size_t, 2>;
-    using size3 = vec<std::size_t, 3>;
-    using size4 = vec<std::size_t, 4>;
+    using size2_t = vec<std::size_t, 2>;
+    using size3_t = vec<std::size_t, 3>;
+    using size4_t = vec<std::size_t, 4>;
 
-    using ptrdiff2 = vec<std::ptrdiff_t, 2>;
-    using ptrdiff3 = vec<std::ptrdiff_t, 3>;
-    using ptrdiff4 = vec<std::ptrdiff_t, 4>;
+    using ptrdiff2_t = vec<std::ptrdiff_t, 2>;
+    using ptrdiff3_t = vec<std::ptrdiff_t, 3>;
+    using ptrdiff4_t = vec<std::ptrdiff_t, 4>;
 }
 
 namespace vmath_hpp
@@ -83,13 +83,13 @@ namespace vmath_hpp
     using double3x3 = mat<double, 3>;
     using double4x4 = mat<double, 4>;
 
-    using size2x2 = mat<std::size_t, 2>;
-    using size3x3 = mat<std::size_t, 3>;
-    using size4x4 = mat<std::size_t, 4>;
+    using size2x2_t = mat<std::size_t, 2>;
+    using size3x3_t = mat<std::size_t, 3>;
+    using size4x4_t = mat<std::size_t, 4>;
 
-    using ptrdiff2x2 = mat<std::ptrdiff_t, 2>;
-    using ptrdiff3x3 = mat<std::ptrdiff_t, 3>;
-    using ptrdiff4x4 = mat<std::ptrdiff_t, 4>;
+    using ptrdiff2x2_t = mat<std::ptrdiff_t, 2>;
+    using ptrdiff3x3_t = mat<std::ptrdiff_t, 3>;
+    using ptrdiff4x4_t = mat<std::ptrdiff_t, 4>;
 }
 
 namespace vmath_hpp
@@ -97,6 +97,6 @@ namespace vmath_hpp
     template < typename T >
     class qua;
 
-    using fqua = qua<float>;
-    using dqua = qua<double>;
+    using qfloat = qua<float>;
+    using qdouble = qua<double>;
 }
diff --git a/untests/vmath_ext_tests.cpp b/untests/vmath_ext_tests.cpp
index feea51b..ed297fb 100644
--- a/untests/vmath_ext_tests.cpp
+++ b/untests/vmath_ext_tests.cpp
@@ -126,8 +126,8 @@ TEST_CASE("vmath/ext/hash") {
     }
 
     SUBCASE("quaternion") {
-        REQUIRE(std::hash<fqua>{}({1,2,3,4}) == std::hash<fqua>{}({1,2,3,4}));
-        REQUIRE_FALSE(std::hash<fqua>{}({1,2,3,4}) == std::hash<fqua>{}({3,2,1,4}));
+        REQUIRE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({1,2,3,4}));
+        REQUIRE_FALSE(std::hash<qfloat>{}({1,2,3,4}) == std::hash<qfloat>{}({3,2,1,4}));
 
         {
             std::set<qua<int>> s;
@@ -172,7 +172,7 @@ TEST_CASE("vmath/ext/cast") {
         STATIC_REQUIRE(m == int2x2(1));
         STATIC_REQUIRE(std::is_same_v<decltype(m)::row_type, int2>);
 
-        constexpr auto q = cast_to<int>(fqua(1.5f, 2.2f, 3.6f, 4.5f));
+        constexpr auto q = cast_to<int>(qfloat(1.5f, 2.2f, 3.6f, 4.5f));
         STATIC_REQUIRE(q == qua(1,2,3,4));
         STATIC_REQUIRE(std::is_same_v<decltype(q)::component_type, int>);
     }
diff --git a/untests/vmath_qua_fun_tests.cpp b/untests/vmath_qua_fun_tests.cpp
index 5c869e0..9fc1ac0 100644
--- a/untests/vmath_qua_fun_tests.cpp
+++ b/untests/vmath_qua_fun_tests.cpp
@@ -54,13 +54,13 @@ TEST_CASE("vmath/qua_fun") {
 
         {
             float3 v{1,0,0};
-            REQUIRE(&v == &(v *= fqua{0,0,0.7071067812f,0.7071067812f}));
+            REQUIRE(&v == &(v *= qfloat{0,0,0.7071067812f,0.7071067812f}));
             REQUIRE(v == uapprox3(0.f,1.f,0.f));
         }
 
-        STATIC_REQUIRE(fqua{} * fqua{} == fqua{});
-        STATIC_REQUIRE(float3{1,2,3} * fqua{} == uapprox3(1.f,2.f,3.f));
-        STATIC_REQUIRE(float3{1,0,0} * fqua{0,0,0.7071067812f,0.7071067812f} == uapprox3(0.f,1.f,0.f));
+        STATIC_REQUIRE(qfloat{} * qfloat{} == qfloat{});
+        STATIC_REQUIRE(float3{1,2,3} * qfloat{} == uapprox3(1.f,2.f,3.f));
+        STATIC_REQUIRE(float3{1,0,0} * qfloat{0,0,0.7071067812f,0.7071067812f} == uapprox3(0.f,1.f,0.f));
     }
 
     SUBCASE("Common Functions") {
@@ -130,20 +130,20 @@ TEST_CASE("vmath/qua_fun") {
         }
 
         {
-            REQUIRE_FALSE(any(isnan(fqua(1,1,1,1))));
-            REQUIRE_FALSE(any(isinf(fqua(1,1,1,1))));
-            REQUIRE(all(isfinite(fqua(1,1,1,1))));
+            REQUIRE_FALSE(any(isnan(qfloat(1,1,1,1))));
+            REQUIRE_FALSE(any(isinf(qfloat(1,1,1,1))));
+            REQUIRE(all(isfinite(qfloat(1,1,1,1))));
         }
     }
 
     SUBCASE("Geometric Functions") {
         STATIC_REQUIRE(dot(qua(1,2,3,4),qua(3,4,5,6)) == 50);
 
-        REQUIRE(length(fqua(10.f,0.f,0.f,0.f)) == uapprox(10.f));
-        REQUIRE(length(fqua(-10.f,0.f,0.f,0.f)) == uapprox(10.f));
+        REQUIRE(length(qfloat(10.f,0.f,0.f,0.f)) == uapprox(10.f));
+        REQUIRE(length(qfloat(-10.f,0.f,0.f,0.f)) == uapprox(10.f));
 
-        STATIC_REQUIRE(length2(fqua(10.f,0.f,0.f,0.f)) == uapprox(100.f));
-        STATIC_REQUIRE(length2(fqua(-10.f,0.f,0.f,0.f)) == uapprox(100.f));
+        STATIC_REQUIRE(length2(qfloat(10.f,0.f,0.f,0.f)) == uapprox(100.f));
+        STATIC_REQUIRE(length2(qfloat(-10.f,0.f,0.f,0.f)) == uapprox(100.f));
 
         REQUIRE(distance(qrotate_z(radians(0.f)) * 2.f, qrotate_z(radians(0.f)) * 1.5f) == uapprox(radians(0.f)));
         REQUIRE(distance(qrotate_z(radians(0.f)) * 3.f, qrotate_z(radians(360.f)) * 2.5f) == uapprox(radians(0.f)));
@@ -152,7 +152,7 @@ TEST_CASE("vmath/qua_fun") {
         REQUIRE(distance(qrotate_z(radians(15.f)) * 6.f, qrotate_z(radians(350.f)) * 5.5f) == uapprox(radians(25.f)));
         REQUIRE(distance(qrotate_z(radians(350.f)) * 7.f, qrotate_z(radians(15.f)) * 6.5f) == uapprox(radians(25.f)));
 
-        REQUIRE(normalize(fqua(0.5f,0.f,0.f,0.f)).v == uapprox3(1.f,0.f,0.f));
+        REQUIRE(normalize(qfloat(0.5f,0.f,0.f,0.f)).v == uapprox3(1.f,0.f,0.f));
     }
 
     SUBCASE("Relational Functions") {
diff --git a/untests/vmath_qua_tests.cpp b/untests/vmath_qua_tests.cpp
index a27b842..8ff13a1 100644
--- a/untests/vmath_qua_tests.cpp
+++ b/untests/vmath_qua_tests.cpp
@@ -14,11 +14,11 @@ namespace
 
 TEST_CASE("vmath/qua") {
     SUBCASE("size/sizeof") {
-        STATIC_REQUIRE(fqua{}.size == 4);
-        STATIC_REQUIRE(dqua{}.size == 4);
+        STATIC_REQUIRE(qfloat{}.size == 4);
+        STATIC_REQUIRE(qdouble{}.size == 4);
 
-        STATIC_REQUIRE(sizeof(fqua{}) == sizeof(float) * 4);
-        STATIC_REQUIRE(sizeof(dqua{}) == sizeof(double) * 4);
+        STATIC_REQUIRE(sizeof(qfloat{}) == sizeof(float) * 4);
+        STATIC_REQUIRE(sizeof(qdouble{}) == sizeof(double) * 4);
     }
 
     SUBCASE("guides") {
@@ -31,70 +31,70 @@ TEST_CASE("vmath/qua") {
 
     SUBCASE("ctors") {
         {
-            STATIC_REQUIRE(fqua{}.v == uapprox3(0.f));
-            STATIC_REQUIRE(fqua{}.s == uapprox(1.f));
+            STATIC_REQUIRE(qfloat{}.v == uapprox3(0.f));
+            STATIC_REQUIRE(qfloat{}.s == uapprox(1.f));
 
-            STATIC_REQUIRE(fqua{1,2,3,4}.v == uapprox3(1.f,2.f,3.f));
-            STATIC_REQUIRE(fqua{1,2,3,4}.s == uapprox(4.f));
+            STATIC_REQUIRE(qfloat{1,2,3,4}.v == uapprox3(1.f,2.f,3.f));
+            STATIC_REQUIRE(qfloat{1,2,3,4}.s == uapprox(4.f));
 
-            STATIC_REQUIRE(fqua{{1,2,3},4}.v == uapprox3(1.f,2.f,3.f));
-            STATIC_REQUIRE(fqua{{1,2,3},4}.s == uapprox(4.f));
+            STATIC_REQUIRE(qfloat{{1,2,3},4}.v == uapprox3(1.f,2.f,3.f));
+            STATIC_REQUIRE(qfloat{{1,2,3},4}.s == uapprox(4.f));
 
-            STATIC_REQUIRE(fqua{{1,2,3,4}}.v == uapprox3(1.f,2.f,3.f));
-            STATIC_REQUIRE(fqua{{1,2,3,4}}.s == uapprox(4.f));
+            STATIC_REQUIRE(qfloat{{1,2,3,4}}.v == uapprox3(1.f,2.f,3.f));
+            STATIC_REQUIRE(qfloat{{1,2,3,4}}.s == uapprox(4.f));
         }
         {
-            constexpr fqua q(1,2,3,4);
-            constexpr fqua q2 = q;
-            STATIC_REQUIRE(q2 == fqua(1,2,3,4));
+            constexpr qfloat q(1,2,3,4);
+            constexpr qfloat q2 = q;
+            STATIC_REQUIRE(q2 == qfloat(1,2,3,4));
         }
         {
-            constexpr fqua q(1,2,3,4);
-            constexpr fqua q2 = std::move(q);
-            STATIC_REQUIRE(q2 == fqua(1,2,3,4));
+            constexpr qfloat q(1,2,3,4);
+            constexpr qfloat q2 = std::move(q);
+            STATIC_REQUIRE(q2 == qfloat(1,2,3,4));
         }
         {
-            STATIC_REQUIRE(fqua(1,2,3,4) == fqua(1,2,3,4));
-            STATIC_REQUIRE(fqua(float3(1,2,3),4) == fqua(1,2,3,4));
-            STATIC_REQUIRE(fqua(float4(1,2,3,4)) == fqua(1,2,3,4));
+            STATIC_REQUIRE(qfloat(1,2,3,4) == qfloat(1,2,3,4));
+            STATIC_REQUIRE(qfloat(float3(1,2,3),4) == qfloat(1,2,3,4));
+            STATIC_REQUIRE(qfloat(float4(1,2,3,4)) == qfloat(1,2,3,4));
         }
     }
 
     SUBCASE("operator=") {
         {
-            fqua v(1,2,3,4);
-            fqua v2;
+            qfloat v(1,2,3,4);
+            qfloat v2;
             v2 = v;
-            REQUIRE(v2 == fqua(1,2,3,4));
+            REQUIRE(v2 == qfloat(1,2,3,4));
         }
         {
-            fqua v(1,2,3,4);
-            fqua v2;
+            qfloat v(1,2,3,4);
+            qfloat v2;
             v2 = std::move(v);
-            REQUIRE(v2 == fqua(1,2,3,4));
+            REQUIRE(v2 == qfloat(1,2,3,4));
         }
     }
 
     SUBCASE("swap") {
         {
-            fqua v1(1,2,3,4);
-            fqua v2(4,5,6,7);
+            qfloat v1(1,2,3,4);
+            qfloat v2(4,5,6,7);
             v1.swap(v2);
-            REQUIRE(v1 == fqua(4,5,6,7));
-            REQUIRE(v2 == fqua(1,2,3,4));
+            REQUIRE(v1 == qfloat(4,5,6,7));
+            REQUIRE(v2 == qfloat(1,2,3,4));
         }
         {
-            fqua v1(1,2,3,4);
-            fqua v2(4,5,6,7);
+            qfloat v1(1,2,3,4);
+            qfloat v2(4,5,6,7);
             swap(v1, v2);
-            REQUIRE(v1 == fqua(4,5,6,7));
-            REQUIRE(v2 == fqua(1,2,3,4));
+            REQUIRE(v1 == qfloat(4,5,6,7));
+            REQUIRE(v2 == qfloat(1,2,3,4));
         }
     }
 
     SUBCASE("iter") {
         {
-            fqua v{1,2,3,4};
+            qfloat v{1,2,3,4};
 
             REQUIRE(*v.begin() == 1);
             REQUIRE(*(v.begin() + 1) == 2);
@@ -125,12 +125,12 @@ TEST_CASE("vmath/qua") {
             REQUIRE(v.crend() - 4 == v.crbegin());
 
             *v.begin() = 3;
-            REQUIRE(v == fqua{3,2,3,4});
+            REQUIRE(v == qfloat{3,2,3,4});
             *v.rbegin() = 5;
-            REQUIRE(v == fqua{3,2,3,5});
+            REQUIRE(v == qfloat{3,2,3,5});
         }
         {
-            const fqua v{1,2,3,4};
+            const qfloat v{1,2,3,4};
 
             REQUIRE(*v.begin() == 1);
             REQUIRE(*(v.begin() + 1) == 2);
@@ -164,11 +164,11 @@ TEST_CASE("vmath/qua") {
 
     SUBCASE("data") {
         {
-            fqua i2;
+            qfloat i2;
             REQUIRE(i2.data() == &i2[0]);
         }
         {
-            const fqua i2;
+            const qfloat i2;
             REQUIRE(i2.data() == &i2[0]);
         }
     }
@@ -193,37 +193,37 @@ TEST_CASE("vmath/qua") {
     }
 
     SUBCASE("at") {
-        STATIC_REQUIRE(fqua(1,2,3,4).at(0) == 1);
-        STATIC_REQUIRE(fqua(1,2,3,4).at(1) == 2);
-        STATIC_REQUIRE(fqua(1,2,3,4).at(2) == 3);
-        STATIC_REQUIRE(fqua(1,2,3,4).at(3) == 4);
-        REQUIRE_THROWS_AS((void)fqua(1,2,3,4).at(4), std::out_of_range);
+        STATIC_REQUIRE(qfloat(1,2,3,4).at(0) == 1);
+        STATIC_REQUIRE(qfloat(1,2,3,4).at(1) == 2);
+        STATIC_REQUIRE(qfloat(1,2,3,4).at(2) == 3);
+        STATIC_REQUIRE(qfloat(1,2,3,4).at(3) == 4);
+        REQUIRE_THROWS_AS((void)qfloat(1,2,3,4).at(4), std::out_of_range);
     }
 
     SUBCASE("operator==/operator!=") {
-        STATIC_REQUIRE(fqua(1,2,3,4) == fqua(1,2,3,4));
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) == fqua(2,2,3,4));
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) == fqua(1,3,3,4));
+        STATIC_REQUIRE(qfloat(1,2,3,4) == qfloat(1,2,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) == qfloat(2,2,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) == qfloat(1,3,3,4));
 
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) != fqua(1,2,3,4));
-        STATIC_REQUIRE(fqua(1,2,3,4) != fqua(2,2,3,4));
-        STATIC_REQUIRE(fqua(1,2,3,4) != fqua(1,3,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) != qfloat(1,2,3,4));
+        STATIC_REQUIRE(qfloat(1,2,3,4) != qfloat(2,2,3,4));
+        STATIC_REQUIRE(qfloat(1,2,3,4) != qfloat(1,3,3,4));
     }
 
     SUBCASE("operator<") {
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) < fqua(1,2,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,2,3,4));
 
-        STATIC_REQUIRE(fqua(0,2,3,4) < fqua(1,2,3,4));
-        STATIC_REQUIRE(fqua(1,1,3,4) < fqua(1,2,3,4));
-        STATIC_REQUIRE(fqua(1,2,2,4) < fqua(1,2,3,4));
-        STATIC_REQUIRE(fqua(1,2,3,3) < fqua(1,2,3,4));
+        STATIC_REQUIRE(qfloat(0,2,3,4) < qfloat(1,2,3,4));
+        STATIC_REQUIRE(qfloat(1,1,3,4) < qfloat(1,2,3,4));
+        STATIC_REQUIRE(qfloat(1,2,2,4) < qfloat(1,2,3,4));
+        STATIC_REQUIRE(qfloat(1,2,3,3) < qfloat(1,2,3,4));
 
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) < fqua(0,2,3,4));
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) < fqua(1,1,3,4));
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) < fqua(1,2,2,4));
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) < fqua(1,2,3,3));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(0,2,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,1,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,2,2,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(1,2,3,3));
 
-        STATIC_REQUIRE(fqua(0,3,3,4) < fqua(1,2,3,4));
-        STATIC_REQUIRE_FALSE(fqua(1,2,3,4) < fqua(0,3,3,4));
+        STATIC_REQUIRE(qfloat(0,3,3,4) < qfloat(1,2,3,4));
+        STATIC_REQUIRE_FALSE(qfloat(1,2,3,4) < qfloat(0,3,3,4));
     }
 }