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

Use defaulted three-way comparison for geom::vector, point, and matrix

Browse source
This commit is contained in:
Nikita Lisitsa 2022-08-05 12:02:41 +03:00
parent 48801a69da
commit c28b93aadc
3 changed files with 6 additions and 124 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -45,6 +45,8 @@ 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);
@ -84,42 +86,6 @@ namespace psemek::geom
return m;
}
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 std::equal(m1.coords, m1.coords + R * C, m2.coords);
}
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 std::lexicographical_compare(m1.coords, m1.coords + R * C, m2.coords, m2.coords + R * C);
}
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 T1, typename T, std::size_t R, std::size_t C>
matrix<T1, R, C> cast(matrix<T, R, C> const & m)
{

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

@ -49,6 +49,8 @@ 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();
};
@ -64,45 +66,6 @@ namespace psemek::geom
return p;
}
template <typename T, std::size_t N>
bool 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 false;
return true;
}
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 std::lexicographical_compare(p1.coords, p1.coords + N, p2.coords, p2.coords + N);
}
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 T1, typename T, std::size_t N>
point<T1, N> cast(point<T, N> const & p)
{

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

@ -56,61 +56,14 @@ 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();
};
template <typename ... Args>
vector(Args && ...) -> vector<std::common_type_t<Args...>, sizeof...(Args)>;
template <typename T, std::size_t N>
bool operator == (vector<T, N> const & v1, vector<T, N> const & v2)
{
return std::equal(v1.coords, v1.coords + N, v2.coords);
}
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 std::lexicographical_compare(v1.coords, v1.coords + N, v2.coords, v2.coords + N);
}
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>
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;
if (v1[i] > v2[i])
return std::strong_ordering::greater;
}
return std::strong_ordering::equal;
}
template <typename T1, typename T, std::size_t N>
vector<T1, N> cast(vector<T, N> const & v)
{