ic
/
magnum
mirror of https://github.com/mosra/magnum.git
6
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Math: functions were not inline by mistake. 

It's inline for all others of similar size, so why not this.
pull/286/merge
Vladimír Vondruš 8 years ago
parent
5792d7f06a
commit
edff639204
1 changed files with 19 additions and 19 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 38
      src/Magnum/Math/Functions.h

38
src/Magnum/Math/Functions.h
Unescape View File

@ -91,7 +91,7 @@ UnsignedInt MAGNUM_EXPORT log2(UnsignedInt number);
Returns natural (base @f$ e @f$) logarithm of given number. Returns natural (base @f$ e @f$) logarithm of given number.
@see @ref Constants::e(), @ref log(UnsignedInt, UnsignedInt), @ref log2() @see @ref Constants::e(), @ref log(UnsignedInt, UnsignedInt), @ref log2()
*/ */
template<class T> T log(T number) { return std::log(number); } template<class T> inline T log(T number) { return std::log(number); }
/** /**
@brief Natural exponential @brief Natural exponential
@ -99,7 +99,7 @@ template<class T> T log(T number) { return std::log(number); }
Returns @f$ e^x @f$. Returns @f$ e^x @f$.
@see @ref Constants::e(), @ref pow(T, T) @see @ref Constants::e(), @ref pow(T, T)
*/ */
template<class T> T exp(T exponent) { return std::exp(exponent); } template<class T> inline T exp(T exponent) { return std::exp(exponent); }
/** /**
@brief Integer division with remainder @brief Integer division with remainder
@ -118,7 +118,7 @@ Int quotient = 57/6;
Int remainder = 57%6; Int remainder = 57%6;
@endcode @endcode
*/ */
template<class Integral> std::pair<Integral, Integral> div(Integral x, Integral y) { template<class Integral> inline std::pair<Integral, Integral> div(Integral x, Integral y) {
static_assert(std::is_integral<Integral>{}, "Math::div(): not an integral type"); static_assert(std::is_integral<Integral>{}, "Math::div(): not an integral type");
const auto result = std::div(x, y); const auto result = std::div(x, y);
return {result.quot, result.rem}; return {result.quot, result.rem};
@ -220,7 +220,7 @@ template<UnsignedInt exponent, class T> constexpr T pow(T base);
template<UnsignedInt exponent, class T> constexpr typename std::enable_if<std::is_arithmetic<T>::value, T>::type pow(T base) { template<UnsignedInt exponent, class T> constexpr typename std::enable_if<std::is_arithmetic<T>::value, T>::type pow(T base) {
return Implementation::Pow<exponent>::pow(base); return Implementation::Pow<exponent>::pow(base);
} }
template<UnsignedInt exponent, std::size_t size, class T> Vector<size, T> pow(const Vector<size, T>& base) { template<UnsignedInt exponent, std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = Implementation::Pow<exponent>::pow(base[i]); out[i] = Implementation::Pow<exponent>::pow(base[i]);
@ -237,7 +237,7 @@ Returns power of @p base to the @p exponent.
#ifdef DOXYGEN_GENERATING_OUTPUT #ifdef DOXYGEN_GENERATING_OUTPUT
template<class T> T pow(T base, T exponent); template<class T> T pow(T base, T exponent);
#else #else
template<class T> typename std::enable_if<std::is_arithmetic<T>::value, T>::type pow(T base, T exponent) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type pow(T base, T exponent) {
return std::pow(base, exponent); return std::pow(base, exponent);
} }
template<std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base, T exponent) { template<std::size_t size, class T> inline Vector<size, T> pow(const Vector<size, T>& base, T exponent) {
@ -281,7 +281,7 @@ template<std::size_t size, class T> inline Vector<size, T> min(const Vector<size
If the range is empty, returns default-constructed value. If the range is empty, returns default-constructed value.
*/ */
template<class T> T min(Corrade::Containers::ArrayView<const T> range) { template<class T> inline T min(Corrade::Containers::ArrayView<const T> range) {
if(range.empty()) return {}; if(range.empty()) return {};
T out(range[0]); T out(range[0]);
@ -321,7 +321,7 @@ template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& v
#endif #endif
/** @overload */ /** @overload */
template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& value, T max) { template<std::size_t size, class T> inline Vector<size, T> max(const Vector<size, T>& value, T max) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = std::max(value[i], max); out[i] = std::max(value[i], max);
@ -333,7 +333,7 @@ template<std::size_t size, class T> Vector<size, T> max(const Vector<size, T>& v
If the range is empty, returns default-constructed value. If the range is empty, returns default-constructed value.
*/ */
template<class T> T max(Corrade::Containers::ArrayView<const T> range) { template<class T> inline T max(Corrade::Containers::ArrayView<const T> range) {
if(range.empty()) return {}; if(range.empty()) return {};
T out(range[0]); T out(range[0]);
@ -364,7 +364,7 @@ template<class T> inline std::pair<T, T> minmax(const T& a, const T& b);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, std::pair<T, T>>::type minmax(T a, T b) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, std::pair<T, T>>::type minmax(T a, T b) {
return a < b ? std::make_pair(a, b) : std::make_pair(b, a); return a < b ? std::make_pair(a, b) : std::make_pair(b, a);
} }
template<std::size_t size, class T> std::pair<Vector<size, T>, Vector<size, T>> minmax(const Vector<size, T>& a, const Vector<size, T>& b) { template<std::size_t size, class T> inline std::pair<Vector<size, T>, Vector<size, T>> minmax(const Vector<size, T>& a, const Vector<size, T>& b) {
using std::swap; using std::swap;
std::pair<Vector<size, T>, Vector<size, T>> out{a, b}; std::pair<Vector<size, T>, Vector<size, T>> out{a, b};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
@ -392,7 +392,7 @@ namespace Implementation {
If the range is empty, returns default-constructed values. If the range is empty, returns default-constructed values.
@see @ref Range::Range(const std::pair<VectorType, VectorType>&) @see @ref Range::Range(const std::pair<VectorType, VectorType>&)
*/ */
template<class T> std::pair<T, T> minmax(Corrade::Containers::ArrayView<const T> range) { template<class T> inline std::pair<T, T> minmax(Corrade::Containers::ArrayView<const T> range) {
if(range.empty()) return {}; if(range.empty()) return {};
T min{range[0]}, max{range[0]}; T min{range[0]}, max{range[0]};
@ -431,7 +431,7 @@ template<class T, class U> inline T clamp(const T& value, const T& min, const T&
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type clamp(T value, T min, T max) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type clamp(T value, T min, T max) {
return std::min(std::max(value, min), max); return std::min(std::max(value, min), max);
} }
template<std::size_t size, class T> Vector<size, T> clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) { template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, const Vector<size, T>& min, const Vector<size, T>& max) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = clamp(value[i], min[i], max[i]); out[i] = clamp(value[i], min[i], max[i]);
@ -440,7 +440,7 @@ template<std::size_t size, class T> Vector<size, T> clamp(const Vector<size, T>&
#endif #endif
/** @overload */ /** @overload */
template<std::size_t size, class T> Vector<size, T> clamp(const Vector<size, T>& value, T min, T max) { template<std::size_t size, class T> inline Vector<size, T> clamp(const Vector<size, T>& value, T min, T max) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = clamp(value[i], min, max); out[i] = clamp(value[i], min, max);
@ -460,7 +460,7 @@ template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T
if(scalar < T(0)) return T(-1); if(scalar < T(0)) return T(-1);
return T(0); return T(0);
} }
template<std::size_t size, class T> Vector<size, T> sign(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> sign(const Vector<size, T>& a) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = sign(a[i]); out[i] = sign(a[i]);
@ -475,7 +475,7 @@ template<class T> inline T abs(const T& a);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type abs(T a) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type abs(T a) {
return std::abs(a); return std::abs(a);
} }
template<std::size_t size, class T> Vector<size, T> abs(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> abs(const Vector<size, T>& a) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = std::abs(a[i]); out[i] = std::abs(a[i]);
@ -490,7 +490,7 @@ template<class T> inline T floor(const T& a);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type floor(T a) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type floor(T a) {
return std::floor(a); return std::floor(a);
} }
template<std::size_t size, class T> Vector<size, T> floor(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> floor(const Vector<size, T>& a) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = std::floor(a[i]); out[i] = std::floor(a[i]);
@ -505,7 +505,7 @@ template<class T> inline T round(const T& a);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type round(T a) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type round(T a) {
return std::round(a); return std::round(a);
} }
template<std::size_t size, class T> Vector<size, T> round(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> round(const Vector<size, T>& a) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = std::round(a[i]); out[i] = std::round(a[i]);
@ -520,7 +520,7 @@ template<class T> inline T ceil(const T& a);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type ceil(T a) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type ceil(T a) {
return std::ceil(a); return std::ceil(a);
} }
template<std::size_t size, class T> Vector<size, T> ceil(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> ceil(const Vector<size, T>& a) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = std::ceil(a[i]); out[i] = std::ceil(a[i]);
@ -539,7 +539,7 @@ template<class T> inline T sqrt(const T& a);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sqrt(T a) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sqrt(T a) {
return T(std::sqrt(a)); return T(std::sqrt(a));
} }
template<std::size_t size, class T> Vector<size, T> sqrt(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> sqrt(const Vector<size, T>& a) {
Vector<size, T> out{NoInit}; Vector<size, T> out{NoInit};
for(std::size_t i = 0; i != size; ++i) for(std::size_t i = 0; i != size; ++i)
out[i] = T(std::sqrt(a[i])); out[i] = T(std::sqrt(a[i]));
@ -559,7 +559,7 @@ template<class T> inline T sqrtInverted(const T& a);
template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sqrtInverted(T a) { template<class T> inline typename std::enable_if<std::is_arithmetic<T>::value, T>::type sqrtInverted(T a) {
return T(1)/std::sqrt(a); return T(1)/std::sqrt(a);
} }
template<std::size_t size, class T> Vector<size, T> sqrtInverted(const Vector<size, T>& a) { template<std::size_t size, class T> inline Vector<size, T> sqrtInverted(const Vector<size, T>& a) {
return Vector<size, T>(T(1))/sqrt(a); return Vector<size, T>(T(1))/sqrt(a);
} }
#endif #endif

Write Preview
Loading…
Cancel
Save