libcruft-util/coord/ops.hpp

346 lines
12 KiB
C++
Raw Normal View History

/*
2015-04-13 18:05:28 +10:00
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
2015-04-13 18:05:28 +10:00
* http://www.apache.org/licenses/LICENSE-2.0
*
2015-04-13 18:05:28 +10:00
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* Copyright 2012-2015 Danny Robson <danny@nerdcruft.net>
*/
#ifndef __UTIL_COORDS_OPS
#define __UTIL_COORDS_OPS
#include "../preprocessor.hpp"
#include "../maths.hpp"
2015-05-29 15:51:08 +10:00
#include "../types/bits.hpp"
#include <cstdlib>
2015-09-29 18:06:52 +10:00
#include <cmath>
namespace util {
// forward declerations for traits
template <size_t,typename> struct point;
template <size_t,typename> struct extent;
template <size_t,typename> struct vector;
template <size_t,typename> struct colour;
///////////////////////////////////////////////////////////////////////
// operation traits
namespace coord {
template <
size_t S,
typename T,
typename U,
template <size_t,typename> class A,
template <size_t,typename> class B
>
struct traits { };
//-------------------------------------------------------------------------
template <size_t S, typename T, typename U> struct traits<S,T,U,colour,colour> { typedef colour<S,typename std::common_type<T,U>::type> result; };
template <size_t S, typename T, typename U> struct traits<S,T,U,extent,extent> { typedef extent<S,typename std::common_type<T,U>::type> result; };
template <size_t S, typename T, typename U> struct traits<S,T,U,extent,vector> { typedef extent<S,typename std::common_type<T,U>::type> result; };
template <size_t S, typename T, typename U> struct traits<S,T,U,point,extent> { typedef point <S,typename std::common_type<T,U>::type> result; };
template <size_t S, typename T, typename U> struct traits<S,T,U,point,vector> { typedef point <S,typename std::common_type<T,U>::type> result; };
template <size_t S, typename T, typename U> struct traits<S,T,U,vector,point> { typedef point <S,typename std::common_type<T,U>::type> result; };
template <size_t S, typename T, typename U> struct traits<S,T,U,vector,vector> { typedef vector<S,typename std::common_type<T,U>::type> result; };
}
///////////////////////////////////////////////////////////////////////////
// vector operators
#define ELEMENT_OP(OP) \
template < \
size_t S, \
typename T, \
typename U, \
template <size_t,typename> class A, \
template <size_t,typename> class B \
> \
typename coord::traits<S,T,U,A,B>::result \
operator OP (A<S,T> a, B<S,U> b) \
{ \
typename coord::traits<S,T,U,A,B>::result out; \
for (size_t i = 0; i < S; ++i) \
out[i] = a[i] OP b[i]; \
return out; \
} \
\
template < \
size_t S, \
typename T, \
template <size_t,typename> class A, \
template <size_t,typename> class B \
> \
typename coord::traits<S,T,T,A,B>::result& \
operator PASTE(OP,=) (A<S,T>& a, B<S,T> b) \
{ \
for (size_t i = 0; i < S; ++i) \
a[i] PASTE(OP,=) b[i]; \
return a; \
}
ELEMENT_OP(+)
ELEMENT_OP(-)
ELEMENT_OP(*)
ELEMENT_OP(/)
2015-07-21 01:39:01 +10:00
ELEMENT_OP(%)
#undef ELEMENT_OP
///////////////////////////////////////////////////////////////////////////
// scalar operators
#define SCALAR_OP(OP) \
template < \
size_t S, \
typename T, \
typename U, \
template <size_t,typename> class K \
> \
2015-07-21 01:39:01 +10:00
typename std::enable_if<std::is_fundamental<U>::value, K<S,T>>::type \
operator OP (U u, K<S,T> k) \
{ \
K<S,T> out; \
for (size_t i = 0; i < S; ++i) \
out[i] = u OP k[i]; \
return out; \
} \
\
template < \
size_t S, \
typename T, \
typename U, \
template <size_t,typename> class K \
> \
2015-07-21 01:39:01 +10:00
typename std::enable_if<std::is_fundamental<U>::value, K<S,T>>::type \
operator OP (K<S,T> k, U u) \
{ \
K<S,T> out; \
for (size_t i = 0; i < S; ++i) \
out[i] = k[i] OP u; \
return out; \
}
SCALAR_OP(+)
SCALAR_OP(-)
SCALAR_OP(*)
SCALAR_OP(/)
2015-07-21 01:39:01 +10:00
SCALAR_OP(%)
#undef SCALAR_OP
2015-03-07 03:18:32 +11:00
//-------------------------------------------------------------------------
#define SCALAR_OP(OP) \
template < \
size_t S, \
typename T, \
template <size_t,typename> class K \
> \
K<S,T>& \
operator OP (K<S,T> &k, T t) \
{ \
for (size_t i = 0; i < S; ++i) \
k[i] OP t; \
return k; \
}
SCALAR_OP(+=)
SCALAR_OP(-=)
SCALAR_OP(*=)
SCALAR_OP(/=)
2015-07-21 01:39:01 +10:00
SCALAR_OP(%=)
#undef SCALAR_OP
2015-03-07 03:18:13 +11:00
//-------------------------------------------------------------------------
// negation
template <size_t S, typename T, template<size_t,typename> class K>
K<S,T> operator- (K<S,T> k)
{
return k * T{-1};
2015-03-07 03:18:13 +11:00
}
///////////////////////////////////////////////////////////////////////////
// logic operators
2015-03-07 03:18:32 +11:00
/// elementwise equality operator
template <
size_t S,
typename T,
template <size_t,typename> class K
>
bool
operator== (K<S,T> a, K<S,T> b)
{
2015-07-21 01:39:14 +10:00
bool (*predicate)(const T&, const T&) = almost_equal;
return std::equal (std::begin (a),
std::end (a),
2015-07-21 01:39:14 +10:00
std::begin (b),
predicate);
}
2015-03-07 03:18:32 +11:00
///------------------------------------------------------------------------
/// elementwise inquality operator
template <
size_t S,
typename T,
template <size_t,typename> class K
>
bool
operator!= (K<S,T> a, K<S,T> b)
{
return !(a == b);
}
///////////////////////////////////////////////////////////////////////////
// special operators
2015-03-07 03:18:32 +11:00
/// point-point subtraction giving a vector difference
template <
size_t S,
typename T,
typename U
>
vector<S,typename std::common_type<T,U>::type>
operator- (point<S,T> a, point<S,U> b)
{
vector<S,typename std::common_type<T,U>::type> out;
for (size_t i = 0; i < S; ++i)
out[i] = a[i] - b[i];
return out;
}
2015-03-07 03:18:32 +11:00
//-------------------------------------------------------------------------
template <
size_t S,
typename T,
typename U
2015-03-07 03:18:32 +11:00
>
vector<S,typename std::common_type<T,U>::type>
operator- (U u, point<S,T> p)
2015-03-07 03:18:32 +11:00
{
return point<S,U> {u} - p;
2015-03-07 03:18:32 +11:00
}
//-------------------------------------------------------------------------
template <
size_t S,
typename T,
2015-05-29 15:51:08 +10:00
template <size_t,typename> class A,
template <size_t,typename> class B
>
T dot (A<S,T> a, B<S,T> b)
{
T sum { 0 };
for (size_t i = 0; i < S; ++i)
sum += a[i] * b[i];
return sum;
}
2015-05-29 15:51:08 +10:00
//-------------------------------------------------------------------------
template <
size_t S,
typename T,
template <size_t,typename> class K
>
K<S,T>
abs (K<S,T> k)
{
for (auto &v: k)
v = std::abs (v);
return k;
}
2015-03-07 03:18:32 +11:00
///////////////////////////////////////////////////////////////////////////
// logical element operators
/// return a coord type containing the max element at each offset
template <
size_t S,
typename T,
template <size_t,typename> class K
>
K<S,T>
min (K<S,T> a, K<S,T> b)
{
K<S,T> out;
for (size_t i = 0; i < S; ++i)
out[i] = min (a[i], b[i]);
return out;
}
2015-03-07 03:18:32 +11:00
///------------------------------------------------------------------------
// /return a coord type containing the max element at each offset
template <
size_t S,
typename T,
template <size_t,typename> class K
>
K<S,T>
max (K<S,T> a, K<S,T> b)
{
K<S,T> out;
for (size_t i = 0; i < S; ++i)
out[i] = max (a[i], b[i]);
return out;
}
2015-03-07 03:18:32 +11:00
///------------------------------------------------------------------------
/// return the minimum element of the coordinate type
template <size_t S, typename T, template<size_t,typename> class K>
T
min (K<S,T> k)
{ return *std::min_element (k.begin (), k.end ()); }
2015-03-07 03:18:32 +11:00
///------------------------------------------------------------------------
/// return the maximum element of the coordinate type
template <size_t S, typename T, template<size_t,typename> class K>
T
max (K<S,T> k)
{ return *std::max_element (k.begin (), k.end ()); }
2015-05-26 16:25:41 +10:00
template <size_t S, typename T, template<size_t,typename> class K>
bool
operator>= (K<S,T> k, T t)
{ return min (k) >= t; }
template <size_t S, typename T, template<size_t,typename> class K>
bool
operator<= (K<S,T> k, T t)
{ return max (k) <= t; }
2015-09-29 18:06:52 +10:00
///////////////////////////////////////////////////////////////////////////
template <size_t S, typename T, template<size_t,typename> class K>
typename std::enable_if<
std::is_floating_point<T>::value,
K<S,T>
>::type
floor (K<S,T> k)
{
T (*floor_func)(T) = std::floor;
K<S,T> v;
std::transform (k.begin (), k.end (), v.begin (), floor_func);
return v;
}
}
#endif