lisyarus/psemek
1
0
Fork 1
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

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

Browse source
This commit is contained in:
Nikita Lisitsa 2022-08-06 19:15:39 +03:00
parent 0a3df26873
commit 742c74e07e
3 changed files with 147 additions and 6 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

51
libs/geom/include/psemek/geom/matrix.hpp
View file

@ -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)
{

51
libs/geom/include/psemek/geom/point.hpp
View file

@ -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)
{

51
libs/geom/include/psemek/geom/vector.hpp
View file

@ -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)
{