From c0460b31c612016b25049dbd451c1b3fa8065bff Mon Sep 17 00:00:00 2001
From: "C. J. Howard" <cjhoward@cjhoward.org>
Date: Sat, 22 Oct 2022 19:06:36 +0800
Subject: [PATCH] Move vector and matrix operators into the math::operators
 namespace for documentation purposes

---
 src/math/matrix.hpp    | 108 ++++++++++++++++++++++-------------------
 src/math/operators.hpp |   8 ++-
 src/math/vector.hpp    | 102 ++++++++++++++++++++------------------
 3 files changed, 118 insertions(+), 100 deletions(-)

diff --git a/src/math/matrix.hpp b/src/math/matrix.hpp
index 4d46974..a6a98a2 100644
--- a/src/math/matrix.hpp
+++ b/src/math/matrix.hpp
@@ -974,104 +974,104 @@ constexpr matrix<T, M, N> transpose(const matrix<T, N, M>& m) noexcept
 	return transpose(m, std::make_index_sequence<M>{});
 }
 
-} // namespace math
+namespace operators {
 
-/// @copydoc math::add(const math::matrix<T, N, M>&, const math::matrix<T, N, M>&)
+/// @copydoc add(const matrix<T, N, M>&, const matrix<T, N, M>&)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator+(const math::matrix<T, N, M>& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator+(const matrix<T, N, M>& a, const matrix<T, N, M>& b) noexcept
 {
-	return math::add(a, b);
+	return add(a, b);
 }
 
-/// @copydoc math::add(const math::matrix<T, N, M>&, T)
+/// @copydoc add(const matrix<T, N, M>&, T)
 /// @{
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator+(const math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M> operator+(const matrix<T, N, M>& a, T b) noexcept
 {
-	return math::add(a, b);
+	return add(a, b);
 }
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator+(T a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator+(T a, const matrix<T, N, M>& b) noexcept
 {
-	return math::add(b, a);
+	return add(b, a);
 }
 /// @}
 
-/// @copydoc math::div(const math::matrix<T, N, M>&, const math::matrix<T, N, M>&)
+/// @copydoc div(const matrix<T, N, M>&, const matrix<T, N, M>&)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator/(const math::matrix<T, N, M>& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator/(const matrix<T, N, M>& a, const matrix<T, N, M>& b) noexcept
 {
-	return math::div(a, b);
+	return div(a, b);
 }
 
-/// @copydoc math::div(const math::matrix<T, N, M>&, T)
+/// @copydoc div(const matrix<T, N, M>&, T)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator/(const math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M> operator/(const matrix<T, N, M>& a, T b) noexcept
 {
-	return math::div(a, b);
+	return div(a, b);
 }
 
-/// @copydoc math::div(T, const math::matrix<T, N, M>&)
+/// @copydoc div(T, const matrix<T, N, M>&)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator/(T a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator/(T a, const matrix<T, N, M>& b) noexcept
 {
-	return math::div(a, b);
+	return div(a, b);
 }
 
-/// @copydoc math::mul(const math::matrix<T, N, M>&, const math::matrix<T, P, N>&)
+/// @copydoc mul(const matrix<T, N, M>&, const matrix<T, P, N>&)
 template <typename T, std::size_t N, std::size_t M, std::size_t P>
-constexpr inline math::matrix<T, P, M> operator*(const math::matrix<T, N, M>& a, const math::matrix<T, P, N>& b) noexcept
+constexpr inline matrix<T, P, M> operator*(const matrix<T, N, M>& a, const matrix<T, P, N>& b) noexcept
 {
-	return math::mul(a, b);
+	return mul(a, b);
 }
 
-/// @copydoc math::mul(const math::matrix<T, N, M>&, T)
+/// @copydoc mul(const matrix<T, N, M>&, T)
 /// @{
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator*(const math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M> operator*(const matrix<T, N, M>& a, T b) noexcept
 {
-	return math::mul(a, b);
+	return mul(a, b);
 }
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator*(T a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator*(T a, const matrix<T, N, M>& b) noexcept
 {
-	return math::mul(b, a);
+	return mul(b, a);
 }
 /// @}
 
-/// @copydoc math::mul(const math::matrix<T, N, M>&, const typename math::matrix<T, N, M>::row_vector_type&)
+/// @copydoc mul(const matrix<T, N, M>&, const typename matrix<T, N, M>::row_vector_type&)
 template <typename T, std::size_t N, std::size_t M>
-constexpr inline typename math::matrix<T, N, M>::column_vector_type operator*(const math::matrix<T, N, M>& a, const typename math::matrix<T, N, M>::row_vector_type& b) noexcept
+constexpr inline typename matrix<T, N, M>::column_vector_type operator*(const matrix<T, N, M>& a, const typename matrix<T, N, M>::row_vector_type& b) noexcept
 {
-	return math::mul(a, b);
+	return mul(a, b);
 }
 
-/// @copydoc math::mul(const typename math::matrix<T, N, M>::column_vector_type&, const math::matrix<T, N, M>&)
+/// @copydoc mul(const typename matrix<T, N, M>::column_vector_type&, const matrix<T, N, M>&)
 template <typename T, std::size_t N, std::size_t M>
-constexpr inline typename math::matrix<T, N, M>::row_vector_type operator*(const typename math::matrix<T, N, M>::column_vector_type& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline typename matrix<T, N, M>::row_vector_type operator*(const typename matrix<T, N, M>::column_vector_type& a, const matrix<T, N, M>& b) noexcept
 {
-	return math::mul(a, b);
+	return mul(a, b);
 }
 
-/// @copydoc math::sub(const math::matrix<T, N, M>&, const math::matrix<T, N, M>&)
+/// @copydoc sub(const matrix<T, N, M>&, const matrix<T, N, M>&)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator-(const math::matrix<T, N, M>& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator-(const matrix<T, N, M>& a, const matrix<T, N, M>& b) noexcept
 {
-	return math::sub(a, b);
+	return sub(a, b);
 }
 
-/// @copydoc math::sub(const math::matrix<T, N, M>&, T)
+/// @copydoc sub(const matrix<T, N, M>&, T)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator-(const math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M> operator-(const matrix<T, N, M>& a, T b) noexcept
 {
-	return math::sub(a, b);
+	return sub(a, b);
 }
 
-/// @copydoc math::sub(T, const math::matrix<T, N, M>&)
+/// @copydoc sub(T, const matrix<T, N, M>&)
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M> operator-(T a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M> operator-(T a, const matrix<T, N, M>& b) noexcept
 {
-	return math::sub(a, b);
+	return sub(a, b);
 }
 
 /**
@@ -1083,12 +1083,12 @@ constexpr inline math::matrix<T, N, M> operator-(T a, const math::matrix<T, N, M
  */
 /// @{
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator+=(math::matrix<T, N, M>& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M>& operator+=(matrix<T, N, M>& a, const matrix<T, N, M>& b) noexcept
 {
 	return (a = a + b);
 }
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator+=(math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M>& operator+=(matrix<T, N, M>& a, T b) noexcept
 {
 	return (a = a + b);
 }
@@ -1103,12 +1103,12 @@ constexpr inline math::matrix<T, N, M>& operator+=(math::matrix<T, N, M>& a, T b
  */
 /// @{
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator-=(math::matrix<T, N, M>& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M>& operator-=(matrix<T, N, M>& a, const matrix<T, N, M>& b) noexcept
 {
 	return (a = a - b);
 }
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator-=(math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M>& operator-=(matrix<T, N, M>& a, T b) noexcept
 {
 	return (a = a - b);
 }
@@ -1123,12 +1123,12 @@ constexpr inline math::matrix<T, N, M>& operator-=(math::matrix<T, N, M>& a, T b
  */
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::matrix<T, N, N>& operator*=(math::matrix<T, N, N>& a, math::matrix<T, N, N>& b) noexcept
+constexpr inline matrix<T, N, N>& operator*=(matrix<T, N, N>& a, matrix<T, N, N>& b) noexcept
 {
 	return (a = a * b);
 }
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator*=(math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M>& operator*=(matrix<T, N, M>& a, T b) noexcept
 {
 	return (a = a * b);
 }
@@ -1143,12 +1143,12 @@ constexpr inline math::matrix<T, N, M>& operator*=(math::matrix<T, N, M>& a, T b
  */
 /// @{
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator/=(math::matrix<T, N, M>& a, const math::matrix<T, N, M>& b) noexcept
+constexpr inline matrix<T, N, M>& operator/=(matrix<T, N, M>& a, const matrix<T, N, M>& b) noexcept
 {
 	return (a = a / b);
 }
 template <class T, std::size_t N, std::size_t M>
-constexpr inline math::matrix<T, N, M>& operator/=(math::matrix<T, N, M>& a, T b) noexcept
+constexpr inline matrix<T, N, M>& operator/=(matrix<T, N, M>& a, T b) noexcept
 {
 	return (a = a / b);
 }
@@ -1162,7 +1162,7 @@ constexpr inline math::matrix<T, N, M>& operator/=(math::matrix<T, N, M>& a, T b
  * @return Output stream.
  */
 template <class T, std::size_t N, std::size_t M>
-std::ostream& operator<<(std::ostream& os, const math::matrix<T, N, M>& m)
+std::ostream& operator<<(std::ostream& os, const matrix<T, N, M>& m)
 {
 	for (std::size_t i = 0; i < m.size(); ++i)
 	{
@@ -1182,7 +1182,7 @@ std::ostream& operator<<(std::ostream& os, const math::matrix<T, N, M>& m)
  * @return Input stream.
  */
 template <class T, std::size_t N, std::size_t M>
-std::istream& operator>>(std::istream& is, math::matrix<T, N, M>& m)
+std::istream& operator>>(std::istream& is, matrix<T, N, M>& m)
 {
 	for (std::size_t i = 0; i < m.size(); ++i)
 		is >> m.element(i);
@@ -1190,4 +1190,10 @@ std::istream& operator>>(std::istream& is, math::matrix<T, N, M>& m)
 	return is;
 }
 
+} // namespace operators
+
+} // namespace math
+
+using namespace math::operators;
+
 #endif // ANTKEEPER_MATH_MATRIX_HPP
diff --git a/src/math/operators.hpp b/src/math/operators.hpp
index 64ed239..0387520 100644
--- a/src/math/operators.hpp
+++ b/src/math/operators.hpp
@@ -20,9 +20,15 @@
 #ifndef ANTKEEPER_MATH_OPERATORS_HPP
 #define ANTKEEPER_MATH_OPERATORS_HPP
 
-#include "math/matrix-operators.hpp"
 #include "math/quaternion-operators.hpp"
 #include "math/transform-operators.hpp"
 #include "math/stream-operators.hpp"
 
+namespace math {
+
+/// Mathematical operators.
+namespace operators {}
+
+} // namespace math
+
 #endif // ANTKEEPER_MATH_OPERATORS_HPP
diff --git a/src/math/vector.hpp b/src/math/vector.hpp
index 62fd7a2..e5ad5cb 100644
--- a/src/math/vector.hpp
+++ b/src/math/vector.hpp
@@ -1324,97 +1324,97 @@ constexpr inline vector<T, N> trunc(const vector<T, N>& x)
 	return trunc(x, std::make_index_sequence<N>{});
 }
 
-} // namespace math
+namespace operators {
 
-/// @copydoc math::add(const math::vector<T, N>&, const math::vector<T, N>&)
+/// @copydoc add(const vector<T, N>&, const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator+(const math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator+(const vector<T, N>& x, const vector<T, N>& y) noexcept
 {
-	return math::add(x, y);
+	return add(x, y);
 }
 
-/// @copydoc math::add(const math::vector<T, N>&, T)
+/// @copydoc add(const vector<T, N>&, T)
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator+(const math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N> operator+(const vector<T, N>& x, T y) noexcept
 {
-	return math::add(x, y);
+	return add(x, y);
 }
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator+(T x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator+(T x, const vector<T, N>& y) noexcept
 {
-	return math::add(y, x);
+	return add(y, x);
 }
 /// @}
 
-/// @copydoc math::div(const math::vector<T, N>&, const math::vector<T, N>&)
+/// @copydoc div(const vector<T, N>&, const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator/(const math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator/(const vector<T, N>& x, const vector<T, N>& y) noexcept
 {
-	return math::div(x, y);
+	return div(x, y);
 }
 
-/// @copydoc math::div(const math::vector<T, N>&, T)
+/// @copydoc div(const vector<T, N>&, T)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator/(const math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N> operator/(const vector<T, N>& x, T y) noexcept
 {
-	return math::div(x, y);
+	return div(x, y);
 }
 
-/// @copydoc math::div(T, const math::vector<T, N>&)
+/// @copydoc div(T, const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator/(T x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator/(T x, const vector<T, N>& y) noexcept
 {
-	return math::div(x, y);
+	return div(x, y);
 }
 
-/// @copydoc math::mul(const math::vector<T, N>&, const math::vector<T, N>&)
+/// @copydoc mul(const vector<T, N>&, const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator*(const math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator*(const vector<T, N>& x, const vector<T, N>& y) noexcept
 {
-	return math::mul(x, y);
+	return mul(x, y);
 }
 
-/// @copydoc math::mul(const math::vector<T, N>&, T)
+/// @copydoc mul(const vector<T, N>&, T)
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator*(const math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N> operator*(const vector<T, N>& x, T y) noexcept
 {
-	return math::mul(x, y);
+	return mul(x, y);
 }
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator*(T x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator*(T x, const vector<T, N>& y) noexcept
 {
-	return math::mul(y, x);
+	return mul(y, x);
 }
 /// @}
 
-/// @copydoc math::negate(const math::vector<T, N>&)
+/// @copydoc negate(const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator-(const math::vector<T, N>& x) noexcept
+constexpr inline vector<T, N> operator-(const vector<T, N>& x) noexcept
 {
-	return math::negate(x);
+	return negate(x);
 }
 
-/// @copydoc math::sub(const math::vector<T, N>&, const math::vector<T, N>&)
+/// @copydoc sub(const vector<T, N>&, const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator-(const math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator-(const vector<T, N>& x, const vector<T, N>& y) noexcept
 {
-	return math::sub(x, y);
+	return sub(x, y);
 }
 
-/// @copydoc math::sub(const math::vector<T, N>&, T)
+/// @copydoc sub(const vector<T, N>&, T)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator-(const math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N> operator-(const vector<T, N>& x, T y) noexcept
 {
-	return math::sub(x, y);
+	return sub(x, y);
 }
 
-/// @copydoc math::sub(T, const math::vector<T, N>&)
+/// @copydoc sub(T, const vector<T, N>&)
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N> operator-(T x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N> operator-(T x, const vector<T, N>& y) noexcept
 {
-	return math::sub(x, y);
+	return sub(x, y);
 }
 
 /**
@@ -1426,12 +1426,12 @@ constexpr inline math::vector<T, N> operator-(T x, const math::vector<T, N>& y)
  */
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator+=(math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N>& operator+=(vector<T, N>& x, const vector<T, N>& y) noexcept
 {
 	return (x = x + y);
 }
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator+=(math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N>& operator+=(vector<T, N>& x, T y) noexcept
 {
 	return (x = x + y);
 }
@@ -1446,12 +1446,12 @@ constexpr inline math::vector<T, N>& operator+=(math::vector<T, N>& x, T y) noex
  */
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator-=(math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N>& operator-=(vector<T, N>& x, const vector<T, N>& y) noexcept
 {
 	return (x = x - y);
 }
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator-=(math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N>& operator-=(vector<T, N>& x, T y) noexcept
 {
 	return (x = x - y);
 }
@@ -1466,12 +1466,12 @@ constexpr inline math::vector<T, N>& operator-=(math::vector<T, N>& x, T y) noex
  */
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator*=(math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N>& operator*=(vector<T, N>& x, const vector<T, N>& y) noexcept
 {
 	return (x = x * y);
 }
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator*=(math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N>& operator*=(vector<T, N>& x, T y) noexcept
 {
 	return (x = x * y);
 }
@@ -1486,12 +1486,12 @@ constexpr inline math::vector<T, N>& operator*=(math::vector<T, N>& x, T y) noex
  */
 /// @{
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator/=(math::vector<T, N>& x, const math::vector<T, N>& y) noexcept
+constexpr inline vector<T, N>& operator/=(vector<T, N>& x, const vector<T, N>& y) noexcept
 {
 	return (x = x / y);
 }
 template <class T, std::size_t N>
-constexpr inline math::vector<T, N>& operator/=(math::vector<T, N>& x, T y) noexcept
+constexpr inline vector<T, N>& operator/=(vector<T, N>& x, T y) noexcept
 {
 	return (x = x / y);
 }
@@ -1506,7 +1506,7 @@ constexpr inline math::vector<T, N>& operator/=(math::vector<T, N>& x, T y) noex
  * @return Output stream.
  */
 template <class T, std::size_t N>
-std::ostream& operator<<(std::ostream& os, const math::vector<T, N>& x)
+std::ostream& operator<<(std::ostream& os, const vector<T, N>& x)
 {
 	for (std::size_t i = 0; i < N; ++i)
 	{
@@ -1527,7 +1527,7 @@ std::ostream& operator<<(std::ostream& os, const math::vector<T, N>& x)
  * @return Input stream.
  */
 template <class T, std::size_t N>
-std::istream& operator>>(std::istream& is, math::vector<T, N>& x)
+std::istream& operator>>(std::istream& is, vector<T, N>& x)
 {
 	for (std::size_t i = 0; i < N; ++i)
 		is >> x[i];
@@ -1535,4 +1535,10 @@ std::istream& operator>>(std::istream& is, math::vector<T, N>& x)
 	return is;
 }
 
+} // namespace operators
+
+} // namespace math
+
+using namespace math::operators;
+
 #endif // ANTKEEPER_MATH_VECTOR_HPP