Revert defaulted three-way comparison: ubuntu 22.04 doesn't have mingw-11 yet

libs/geom/include/psemek/geom/matrix.hpp

@@ -45,8 +45,6 @@ namespace psemek::geom
 		matrix & operator += (matrix const & v);
 		matrix & operator -= (matrix const & v);
 
-		friend auto operator <=> (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2) = default;
-
 		static matrix zero();
 		static matrix identity();
 		static matrix scalar(T const & s);
@@ -95,6 +93,55 @@ namespace psemek::geom
 		return r;
 	}
 
+	template <typename T, std::size_t R, std::size_t C>
+	std::strong_ordering operator <=> (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		for (std::size_t i = 0; i < R * C; ++i)
+		{
+			if (m1.coords[i] < m2.coords[i])
+				return std::strong_ordering::less;
+			else if (m1.coords[i] > m2.coords[i])
+				return std::strong_ordering::greater;
+		}
+		return std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator == (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return (m1 <=> m2) == std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator != (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return !(m1 == m2);
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator < (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return (m1 <=> m2) == std::strong_ordering::less;
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator > (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return (m2 < m1);
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator <= (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return !(m2 < m1);
+	}
+
+	template <typename T, std::size_t R, std::size_t C>
+	bool operator >= (matrix<T, R, C> const & m1, matrix<T, R, C> const & m2)
+	{
+		return !(m1 < m2);
+	}
+
 	template <typename T, std::size_t R, std::size_t C>
 	matrix<T, R, C> operator * (matrix<T, R, C> const & m, T const & s)
 	{

libs/geom/include/psemek/geom/point.hpp

@@ -49,8 +49,6 @@ namespace psemek::geom
 		point & operator += (vector<T, N> const & v);
 		point & operator -= (vector<T, N> const & v);
 
-		friend auto operator <=> (point<T, N> const & p1, point<T, N> const & p2) = default;
-
 		static point zero();
 	};
 
@@ -75,6 +73,55 @@ namespace psemek::geom
 		return r;
 	}
 
+	template <typename T, std::size_t N>
+	bool operator == (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return (p1 <=> p2) == std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator != (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return !(p1 == p2);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator < (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return (p1 <=> p2) == std::strong_ordering::less;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator > (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return (p2 < p1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator <= (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return !(p2 < p1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator >= (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		return !(p1 < p2);
+	}
+
+	template <typename T, std::size_t N>
+	std::strong_ordering operator <=> (point<T, N> const & p1, point<T, N> const & p2)
+	{
+		for (std::size_t i = 0; i < N; ++i)
+		{
+			if (p1[i] < p2[i])
+				return std::strong_ordering::less;
+			else if (p1[i] > p2[i])
+				return std::strong_ordering::greater;
+		}
+		return std::strong_ordering::equal;
+	}
+
 	template <typename T, std::size_t N>
 	point<T, N> operator + (point<T, N> const & p, vector<T, N> const & v)
 	{

libs/geom/include/psemek/geom/vector.hpp

@@ -56,8 +56,6 @@ namespace psemek::geom
 		vector & operator += (vector const & v);
 		vector & operator -= (vector const & v);
 
-		friend auto operator <=> (vector<T, N> const & v1, vector<T, N> const & v2) = default;
-
 		static vector zero();
 	};
 
@@ -73,6 +71,55 @@ namespace psemek::geom
 		return r;
 	}
 
+	template <typename T, std::size_t N>
+	std::strong_ordering operator <=> (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		for (std::size_t i = 0; i < N; ++i)
+		{
+			if (v1[i] < v2[i])
+				return std::strong_ordering::less;
+			else if (v1[i] > v2[i])
+				return std::strong_ordering::greater;
+		}
+		return std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator == (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return (v1 <=> v2) == std::strong_ordering::equal;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator != (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return !(v1 == v2);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator < (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return (v1 <=> v2) == std::strong_ordering::less;
+	}
+
+	template <typename T, std::size_t N>
+	bool operator > (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return (v2 < v1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator <= (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return !(v2 < v1);
+	}
+
+	template <typename T, std::size_t N>
+	bool operator >= (vector<T, N> const & v1, vector<T, N> const & v2)
+	{
+		return !(v1 < v2);
+	}
+
 	template <typename T, std::size_t N>
 	vector<T, N> operator * (vector<T, N> const & v, T const & s)
 	{