From b03a61da5ded80bd402bcfeff27ffdba24e82f72 Mon Sep 17 00:00:00 2001 From: Kenneth Moreland Date: Thu, 25 May 2017 18:50:45 -0600 Subject: [PATCH] Make .in files match new formatting The automatic formatter formatted the result of the .in files, but not the .in files themselves. This caused the .in file check to fail. --- vtkm/Math.h | 5 +- vtkm/Math.h.in | 632 +++++++++--------- .../internal/WorkletInvokeFunctorDetail.h.in | 4 +- 3 files changed, 307 insertions(+), 334 deletions(-) diff --git a/vtkm/Math.h b/vtkm/Math.h index 680e17477..b7341a892 100644 --- a/vtkm/Math.h +++ b/vtkm/Math.h @@ -108,7 +108,7 @@ struct FloatingPointReturnType::type { typedef vtkm::Float32 Type; }; -} +} // namespace detail /// Compute the sine of \p x. /// @@ -1361,18 +1361,15 @@ static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(T x) static inline VTKM_EXEC_CONT vtkm::Float32 Exp10(vtkm::Float32 x) { return vtkm::Pow(10, x); - ; } static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(vtkm::Float64 x) { return vtkm::Pow(10, x); - ; } template static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(T x) { return vtkm::Pow(10, static_cast(x)); - ; } #endif // !VTKM_CUDA diff --git a/vtkm/Math.h.in b/vtkm/Math.h.in index 0600da040..f0c65945e 100644 --- a/vtkm/Math.h.in +++ b/vtkm/Math.h.in @@ -37,15 +37,15 @@ $# Ignore the following comment. It is meant for the generated file. #ifndef vtk_m_Math_h #define vtk_m_Math_h -#include #include +#include #include #ifndef VTKM_CUDA +#include #include #include #include -#include #endif // !VTKM_CUDA #if !defined(__CUDA_ARCH__) @@ -57,15 +57,14 @@ $# Ignore the following comment. It is meant for the generated file. #include #endif -#define VTKM_CUDA_MATH_FUNCTION_32(func) func ## f +#define VTKM_CUDA_MATH_FUNCTION_32(func) func##f #define VTKM_CUDA_MATH_FUNCTION_64(func) func $py( def unary_function(name, type, returntype, cuda_expression, std_expression, template_header, static_keywords): return '''{5} -{6} VTKM_EXEC_CONT -{2} -{0}({1} x) {{ +{6} VTKM_EXEC_CONT {2} {0}({1} x) +{{ #ifdef VTKM_CUDA return {3}; #else @@ -75,40 +74,37 @@ def unary_function(name, type, returntype, cuda_expression, std_expression, temp '''.format(name, type, returntype, cuda_expression, std_expression, template_header, static_keywords) def unary_Vec_function(vtkmname): - return '''template -static inline VTKM_EXEC_CONT -vtkm::Vec::Type,N> -{0}(const vtkm::Vec &x) {{ - vtkm::Vec::Type,N> result; + return '''template +static inline VTKM_EXEC_CONT vtkm::Vec::Type, N> {0}( + const vtkm::Vec& x) +{{ + vtkm::Vec::Type, N> result; for (vtkm::IdComponent index = 0; index < N; index++) {{ result[index] = vtkm::{0}(x[index]); }} return result; }} -template -static inline VTKM_EXEC_CONT -vtkm::Vec::Type,4> -{0}(const vtkm::Vec &x) {{ - return vtkm::Vec::Type,4>(vtkm::{0}(x[0]), - vtkm::{0}(x[1]), - vtkm::{0}(x[2]), - vtkm::{0}(x[3])); +template +static inline VTKM_EXEC_CONT vtkm::Vec::Type, 4> {0}( + const vtkm::Vec& x) +{{ + return vtkm::Vec::Type, 4>( + vtkm::{0}(x[0]), vtkm::{0}(x[1]), vtkm::{0}(x[2]), vtkm::{0}(x[3])); }} -template -static inline VTKM_EXEC_CONT -vtkm::Vec::Type,3> -{0}(const vtkm::Vec &x) {{ - return vtkm::Vec::Type,3>(vtkm::{0}(x[0]), - vtkm::{0}(x[1]), - vtkm::{0}(x[2])); +template +static inline VTKM_EXEC_CONT vtkm::Vec::Type, 3> {0}( + const vtkm::Vec& x) +{{ + return vtkm::Vec::Type, 3>( + vtkm::{0}(x[0]), vtkm::{0}(x[1]), vtkm::{0}(x[2])); }} -template -static inline VTKM_EXEC_CONT -vtkm::Vec::Type,2> -{0}(const vtkm::Vec &x) {{ - return vtkm::Vec::Type,2>(vtkm::{0}(x[0]), - vtkm::{0}(x[1])); +template +static inline VTKM_EXEC_CONT vtkm::Vec::Type, 2> {0}( + const vtkm::Vec& x) +{{ + return vtkm::Vec::Type, 2>(vtkm::{0}(x[0]), + vtkm::{0}(x[1])); }} '''.format(vtkmname) @@ -118,21 +114,21 @@ def unary_math_function_no_vec(vtkmname, sysname, returntype = None): 'typename detail::FloatingPointReturnType::Type' if returntype == None else returntype, 'VTKM_CUDA_MATH_FUNCTION_64(' + sysname + ')(static_cast(x))', 'std::' + sysname + '(static_cast(x))', - 'template', + 'template ', 'static inline') + \ unary_function(vtkmname, 'vtkm::Float32', 'detail::FloatingPointReturnType::Type' if returntype == None else returntype, 'VTKM_CUDA_MATH_FUNCTION_32(' + sysname + ')(x)', 'std::' + sysname + '(x)', - 'template<>', + 'template <>', 'inline') + \ unary_function(vtkmname, 'vtkm::Float64', 'detail::FloatingPointReturnType::Type' if returntype == None else returntype, 'VTKM_CUDA_MATH_FUNCTION_64(' + sysname + ')(x)', 'std::' + sysname + '(x)', - 'template<>', + 'template <>', 'inline') def unary_math_function(vtkmname, sysname): @@ -143,16 +139,16 @@ def unary_template_function_no_vec(vtkmname, expression, returntype = None, preexpression = ''): - return '''static inline VTKM_EXEC_CONT -{2} {0}(vtkm::Float32 x) {{ + return '''static inline VTKM_EXEC_CONT {2} {0}(vtkm::Float32 x) +{{ {3} return {1}; }} '''.format(vtkmname, expression, 'vtkm::Float32' if returntype == None else returntype, preexpression) + \ -'''static inline VTKM_EXEC_CONT -{2} {0}(vtkm::Float64 x) {{ +'''static inline VTKM_EXEC_CONT {2} {0}(vtkm::Float64 x) +{{ {3} return {1}; }} '''.format(vtkmname, @@ -161,8 +157,8 @@ def unary_template_function_no_vec(vtkmname, preexpression) def binary_function(name, type, cuda_expression, std_expression): - return '''static inline VTKM_EXEC_CONT -{1} {0}({1} x, {1} y) {{ + return '''static inline VTKM_EXEC_CONT {1} {0}({1} x, {1} y) +{{ #ifdef VTKM_CUDA return {2}; #else @@ -174,95 +170,92 @@ def binary_function(name, type, cuda_expression, std_expression): def binary_math_function(vtkmname, sysname): return binary_function(vtkmname, 'vtkm::Float32', - 'VTKM_CUDA_MATH_FUNCTION_32(' + sysname + ')(x,y)', - 'std::' + sysname + '(x,y)') + \ + 'VTKM_CUDA_MATH_FUNCTION_32(' + sysname + ')(x, y)', + 'std::' + sysname + '(x, y)') + \ binary_function(vtkmname, 'vtkm::Float64', - 'VTKM_CUDA_MATH_FUNCTION_64(' + sysname + ')(x,y)', - 'std::' + sysname + '(x,y)') + 'VTKM_CUDA_MATH_FUNCTION_64(' + sysname + ')(x, y)', + 'std::' + sysname + '(x, y)') def binary_template_function(vtkmname, expression): - return '''static inline VTKM_EXEC_CONT -vtkm::Float32 {0}(vtkm::Float32 x, vtkm::Float32 y) {{ + return '''static inline VTKM_EXEC_CONT vtkm::Float32 {0}(vtkm::Float32 x, vtkm::Float32 y) +{{ return {1}; }} -static inline VTKM_EXEC_CONT -vtkm::Float64 {0}(vtkm::Float64 x, vtkm::Float64 y) {{ +static inline VTKM_EXEC_CONT vtkm::Float64 {0}(vtkm::Float64 x, vtkm::Float64 y) +{{ return {1}; }} '''.format(vtkmname, expression) -) -$extend(unary_math_function) -$extend(unary_math_function_no_vec) -$extend(unary_Vec_function) -$extend(unary_template_function_no_vec) -$extend(binary_math_function) -$extend(binary_template_function) - -namespace vtkm { +)\ +$extend(unary_math_function)\ +$extend(unary_math_function_no_vec)\ +$extend(unary_Vec_function)\ +$extend(unary_template_function_no_vec)\ +$extend(binary_math_function)\ +$extend(binary_template_function)\ +\ +namespace vtkm +{ //----------------------------------------------------------------------------- /// Returns the constant 2 times Pi. /// -static inline VTKM_EXEC_CONT -vtkm::Float64 TwoPi() +static inline VTKM_EXEC_CONT vtkm::Float64 TwoPi() { return 6.28318530717958647692528676655900576; } /// Returns the constant Pi. /// -static inline VTKM_EXEC_CONT -vtkm::Float64 Pi() +static inline VTKM_EXEC_CONT vtkm::Float64 Pi() { return 3.14159265358979323846264338327950288; } /// Returns the constant Pi halves. /// -static inline VTKM_EXEC_CONT -vtkm::Float64 Pi_2() +static inline VTKM_EXEC_CONT vtkm::Float64 Pi_2() { return 1.57079632679489661923132169163975144; } /// Returns the constant Pi thirds. /// -static inline VTKM_EXEC_CONT -vtkm::Float64 Pi_3() +static inline VTKM_EXEC_CONT vtkm::Float64 Pi_3() { return 1.04719755119659774615421446109316762; } /// Returns the constant Pi fourths. /// -static inline VTKM_EXEC_CONT -vtkm::Float64 Pi_4() +static inline VTKM_EXEC_CONT vtkm::Float64 Pi_4() { return 0.78539816339744830961566084581987572; } -namespace detail { +namespace detail +{ - template - struct FloatingPointReturnCondition : - std::enable_if::ComponentType, vtkm::Float32>::value || - std::is_same::ComponentType, const vtkm::Float32>::value> - { - }; - - template - struct FloatingPointReturnType - { - typedef vtkm::Float64 Type; - }; +template +struct FloatingPointReturnCondition + : std::enable_if< + std::is_same::ComponentType, vtkm::Float32>::value || + std::is_same::ComponentType, const vtkm::Float32>::value> +{ +}; - template - struct FloatingPointReturnType::type> - { - typedef vtkm::Float32 Type; - }; +template +struct FloatingPointReturnType +{ + typedef vtkm::Float64 Type; +}; -} +template +struct FloatingPointReturnType::type> +{ + typedef vtkm::Float32 Type; +}; +} // namespace detail /// Compute the sine of \p x. /// @@ -338,32 +331,32 @@ $unary_math_function('Sqrt', 'sqrt')\ /// should use this function whenever dividing by the square root. /// #ifdef VTKM_CUDA -static inline VTKM_EXEC_CONT -vtkm::Float32 RSqrt(vtkm::Float32 x) { +static inline VTKM_EXEC_CONT vtkm::Float32 RSqrt(vtkm::Float32 x) +{ return rsqrtf(x); } -static inline VTKM_EXEC_CONT -vtkm::Float64 RSqrt(vtkm::Float64 x) { +static inline VTKM_EXEC_CONT vtkm::Float64 RSqrt(vtkm::Float64 x) +{ return rsqrt(x); } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 RSqrt(T x) { +template +static inline VTKM_EXEC_CONT vtkm::Float64 RSqrt(T x) +{ return rsqrt(static_cast(x)); } -#else // !VTKM_CUDA -static inline VTKM_EXEC_CONT -vtkm::Float32 RSqrt(vtkm::Float32 x) { - return 1/vtkm::Sqrt(x); +#else // !VTKM_CUDA +static inline VTKM_EXEC_CONT vtkm::Float32 RSqrt(vtkm::Float32 x) +{ + return 1 / vtkm::Sqrt(x); } -static inline VTKM_EXEC_CONT -vtkm::Float64 RSqrt(vtkm::Float64 x) { - return 1/vtkm::Sqrt(x); +static inline VTKM_EXEC_CONT vtkm::Float64 RSqrt(vtkm::Float64 x) +{ + return 1 / vtkm::Sqrt(x); } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 RSqrt(T x) { - return 1/static_cast(x); +template +static inline VTKM_EXEC_CONT vtkm::Float64 RSqrt(T x) +{ + return 1 / static_cast(x); } #endif // !VTKM_CUDA @@ -381,32 +374,32 @@ $unary_Vec_function('Cbrt')\ /// should use this function whenever dividing by the cube root. /// #ifdef VTKM_CUDA -static inline VTKM_EXEC_CONT -vtkm::Float32 RCbrt(vtkm::Float32 x) { +static inline VTKM_EXEC_CONT vtkm::Float32 RCbrt(vtkm::Float32 x) +{ return rcbrtf(x); } -static inline VTKM_EXEC_CONT -vtkm::Float64 RCbrt(vtkm::Float64 x) { +static inline VTKM_EXEC_CONT vtkm::Float64 RCbrt(vtkm::Float64 x) +{ return rcbrt(x); } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 RCbrt(T x) { +template +static inline VTKM_EXEC_CONT vtkm::Float64 RCbrt(T x) +{ return rcbrt(static_cast(x)); } -#else // !VTKM_CUDA -static inline VTKM_EXEC_CONT -vtkm::Float32 RCbrt(vtkm::Float32 x) { - return 1/vtkm::Cbrt(x); +#else // !VTKM_CUDA +static inline VTKM_EXEC_CONT vtkm::Float32 RCbrt(vtkm::Float32 x) +{ + return 1 / vtkm::Cbrt(x); } -static inline VTKM_EXEC_CONT -vtkm::Float64 RCbrt(vtkm::Float64 x) { - return 1/vtkm::Cbrt(x); +static inline VTKM_EXEC_CONT vtkm::Float64 RCbrt(vtkm::Float64 x) +{ + return 1 / vtkm::Cbrt(x); } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 RCbrt(T x) { - return 1/vtkm::Cbrt(static_cast(x)); +template +static inline VTKM_EXEC_CONT vtkm::Float64 RCbrt(T x) +{ + return 1 / vtkm::Cbrt(static_cast(x)); } #endif // !VTKM_CUDA @@ -432,32 +425,32 @@ $unary_Vec_function('ExpM1')\ /// Computes 10**\p x, the base-10 exponential of \p x. /// #ifdef VTKM_CUDA -static inline VTKM_EXEC_CONT -vtkm::Float32 Exp10(vtkm::Float32 x) { +static inline VTKM_EXEC_CONT vtkm::Float32 Exp10(vtkm::Float32 x) +{ return exp10f(x); } -static inline VTKM_EXEC_CONT -vtkm::Float64 Exp10(vtkm::Float64 x) { +static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(vtkm::Float64 x) +{ return exp10(x); } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 Exp10(T x) { +template +static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(T x) +{ return exp10(static_cast(x)); } -#else // !VTKM_CUDA -static inline VTKM_EXEC_CONT -vtkm::Float32 Exp10(vtkm::Float32 x) { - return vtkm::Pow(10, x);; +#else // !VTKM_CUDA +static inline VTKM_EXEC_CONT vtkm::Float32 Exp10(vtkm::Float32 x) +{ + return vtkm::Pow(10, x); } -static inline VTKM_EXEC_CONT -vtkm::Float64 Exp10(vtkm::Float64 x) { - return vtkm::Pow(10, x);; +static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(vtkm::Float64 x) +{ + return vtkm::Pow(10, x); } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 Exp10(T x) { - return vtkm::Pow(10, static_cast(x));; +template +static inline VTKM_EXEC_CONT vtkm::Float64 Exp10(T x) +{ + return vtkm::Pow(10, static_cast(x)); } #endif // !VTKM_CUDA @@ -486,9 +479,8 @@ $unary_Vec_function('Log1P')\ //----------------------------------------------------------------------------- /// Returns \p x or \p y, whichever is larger. /// -template -static inline VTKM_EXEC_CONT -T Max(const T &x, const T &y); +template +static inline VTKM_EXEC_CONT T Max(const T& x, const T& y); #ifdef VTKM_USE_STL $binary_template_function('Max', '(std::max)(x, y)')\ $# @@ -499,9 +491,8 @@ $# /// Returns \p x or \p y, whichever is smaller. /// -template -static inline VTKM_EXEC_CONT -T Min(const T &x, const T &y); +template +static inline VTKM_EXEC_CONT T Min(const T& x, const T& y); #ifdef VTKM_USE_STL $binary_template_function('Min', '(std::min)(x, y)')\ $# @@ -510,50 +501,43 @@ $binary_math_function('Min', 'fmin')\ $# #endif // !VTKM_USE_STL -namespace detail { +namespace detail +{ -template -static inline VTKM_EXEC_CONT -T Max(T x, T y, vtkm::TypeTraitsScalarTag) +template +static inline VTKM_EXEC_CONT T Max(T x, T y, vtkm::TypeTraitsScalarTag) { return (x < y) ? y : x; } -template -static inline VTKM_EXEC_CONT -T Max(const T &x, const T &y, vtkm::TypeTraitsVectorTag) +template +static inline VTKM_EXEC_CONT T Max(const T& x, const T& y, vtkm::TypeTraitsVectorTag) { typedef vtkm::VecTraits Traits; T result; for (vtkm::IdComponent index = 0; index < Traits::NUM_COMPONENTS; index++) { - Traits::SetComponent(result, - index, - vtkm::Max(Traits::GetComponent(x, index), - Traits::GetComponent(y, index))); + Traits::SetComponent(result, index, + vtkm::Max(Traits::GetComponent(x, index), Traits::GetComponent(y, index))); } return result; } -template -static inline VTKM_EXEC_CONT -T Min(T x, T y, vtkm::TypeTraitsScalarTag) +template +static inline VTKM_EXEC_CONT T Min(T x, T y, vtkm::TypeTraitsScalarTag) { return (x < y) ? x : y; } -template -static inline VTKM_EXEC_CONT -T Min(const T &x, const T &y, vtkm::TypeTraitsVectorTag) +template +static inline VTKM_EXEC_CONT T Min(const T& x, const T& y, vtkm::TypeTraitsVectorTag) { typedef vtkm::VecTraits Traits; T result; for (vtkm::IdComponent index = 0; index < Traits::NUM_COMPONENTS; index++) { - Traits::SetComponent(result, - index, - vtkm::Min(Traits::GetComponent(x, index), - Traits::GetComponent(y, index))); + Traits::SetComponent(result, index, + vtkm::Min(Traits::GetComponent(x, index), Traits::GetComponent(y, index))); } return result; } @@ -562,21 +546,20 @@ T Min(const T &x, const T &y, vtkm::TypeTraitsVectorTag) /// Returns \p x or \p y, whichever is larger. /// -template -static inline VTKM_EXEC_CONT -T Max(const T &x, const T &y) { +template +static inline VTKM_EXEC_CONT T Max(const T& x, const T& y) +{ return detail::Max(x, y, typename vtkm::TypeTraits::DimensionalityTag()); } /// Returns \p x or \p y, whichever is smaller. /// -template -static inline VTKM_EXEC_CONT -T Min(const T &x, const T &y) { +template +static inline VTKM_EXEC_CONT T Min(const T& x, const T& y) +{ return detail::Min(x, y, typename vtkm::TypeTraits::DimensionalityTag()); } - //----------------------------------------------------------------------------- //#ifdef VTKM_CUDA @@ -585,141 +568,153 @@ T Min(const T &x, const T &y) { #ifdef VTKM_USE_IEEE_NONFINITE -namespace detail { +namespace detail +{ union IEEE754Bits32 { vtkm::UInt32 bits; vtkm::Float32 scalar; }; -#define VTKM_NAN_BITS_32 0x7FC00000U -#define VTKM_INF_BITS_32 0x7F800000U -#define VTKM_NEG_INF_BITS_32 0xFF800000U -#define VTKM_EPSILON_32 1e-5f +#define VTKM_NAN_BITS_32 0x7FC00000U +#define VTKM_INF_BITS_32 0x7F800000U +#define VTKM_NEG_INF_BITS_32 0xFF800000U +#define VTKM_EPSILON_32 1e-5f union IEEE754Bits64 { vtkm::UInt64 bits; vtkm::Float64 scalar; }; -#define VTKM_NAN_BITS_64 0x7FF8000000000000ULL -#define VTKM_INF_BITS_64 0x7FF0000000000000ULL -#define VTKM_NEG_INF_BITS_64 0xFFF0000000000000ULL -#define VTKM_EPSILON_64 1e-9 +#define VTKM_NAN_BITS_64 0x7FF8000000000000ULL +#define VTKM_INF_BITS_64 0x7FF0000000000000ULL +#define VTKM_NEG_INF_BITS_64 0xFFF0000000000000ULL +#define VTKM_EPSILON_64 1e-9 -template struct FloatLimits; +template +struct FloatLimits; -template<> +template <> struct FloatLimits { typedef vtkm::detail::IEEE754Bits32 BitsType; VTKM_EXEC_CONT - static vtkm::Float32 Nan() { - BitsType nan = {VTKM_NAN_BITS_32}; + static vtkm::Float32 Nan() + { + BitsType nan = { VTKM_NAN_BITS_32 }; return nan.scalar; } VTKM_EXEC_CONT - static vtkm::Float32 Infinity() { - BitsType inf = {VTKM_INF_BITS_32}; + static vtkm::Float32 Infinity() + { + BitsType inf = { VTKM_INF_BITS_32 }; return inf.scalar; } VTKM_EXEC_CONT - static vtkm::Float32 NegativeInfinity() { - BitsType neginf = {VTKM_NEG_INF_BITS_32}; + static vtkm::Float32 NegativeInfinity() + { + BitsType neginf = { VTKM_NEG_INF_BITS_32 }; return neginf.scalar; } VTKM_EXEC_CONT - static vtkm::Float32 Epsilon() { - return VTKM_EPSILON_32; - } + static vtkm::Float32 Epsilon() { return VTKM_EPSILON_32; } }; -template -struct FloatLimits< vtkm::Vec > +template +struct FloatLimits> { typedef vtkm::detail::IEEE754Bits32 BitsType; VTKM_EXEC_CONT - static vtkm::Vec Nan() { - BitsType nan = {VTKM_NAN_BITS_32}; - return vtkm::Vec(nan.scalar); + static vtkm::Vec Nan() + { + BitsType nan = { VTKM_NAN_BITS_32 }; + return vtkm::Vec(nan.scalar); } VTKM_EXEC_CONT - static vtkm::Vec Infinity() { - BitsType inf = {VTKM_INF_BITS_32}; - return vtkm::Vec(inf.scalar); + static vtkm::Vec Infinity() + { + BitsType inf = { VTKM_INF_BITS_32 }; + return vtkm::Vec(inf.scalar); } VTKM_EXEC_CONT - static vtkm::Vec NegativeInfinity() { - BitsType neginf = {VTKM_NEG_INF_BITS_32}; - return vtkm::Vec(neginf.scalar); + static vtkm::Vec NegativeInfinity() + { + BitsType neginf = { VTKM_NEG_INF_BITS_32 }; + return vtkm::Vec(neginf.scalar); } VTKM_EXEC_CONT - static vtkm::Vec Epsilon() { - return vtkm::Vec(VTKM_EPSILON_32); + static vtkm::Vec Epsilon() + { + return vtkm::Vec(VTKM_EPSILON_32); } }; -template<> +template <> struct FloatLimits { typedef vtkm::detail::IEEE754Bits64 BitsType; VTKM_EXEC_CONT - static vtkm::Float64 Nan() { - BitsType nan = {VTKM_NAN_BITS_64}; + static vtkm::Float64 Nan() + { + BitsType nan = { VTKM_NAN_BITS_64 }; return nan.scalar; } VTKM_EXEC_CONT - static vtkm::Float64 Infinity() { - BitsType inf = {VTKM_INF_BITS_64}; + static vtkm::Float64 Infinity() + { + BitsType inf = { VTKM_INF_BITS_64 }; return inf.scalar; } VTKM_EXEC_CONT - static vtkm::Float64 NegativeInfinity() { - BitsType neginf = {VTKM_NEG_INF_BITS_64}; + static vtkm::Float64 NegativeInfinity() + { + BitsType neginf = { VTKM_NEG_INF_BITS_64 }; return neginf.scalar; } VTKM_EXEC_CONT - static vtkm::Float64 Epsilon() { - return VTKM_EPSILON_64; - } + static vtkm::Float64 Epsilon() { return VTKM_EPSILON_64; } }; -template -struct FloatLimits< vtkm::Vec > +template +struct FloatLimits> { typedef vtkm::detail::IEEE754Bits64 BitsType; VTKM_EXEC_CONT - static vtkm::Vec Nan() { - BitsType nan = {VTKM_NAN_BITS_64}; - return vtkm::Vec(nan.scalar); + static vtkm::Vec Nan() + { + BitsType nan = { VTKM_NAN_BITS_64 }; + return vtkm::Vec(nan.scalar); } VTKM_EXEC_CONT - static vtkm::Vec Infinity() { - BitsType inf = {VTKM_INF_BITS_64}; - return vtkm::Vec(inf.scalar); + static vtkm::Vec Infinity() + { + BitsType inf = { VTKM_INF_BITS_64 }; + return vtkm::Vec(inf.scalar); } VTKM_EXEC_CONT - static vtkm::Vec NegativeInfinity() { - BitsType neginf = {VTKM_NEG_INF_BITS_64}; - return vtkm::Vec(neginf.scalar); + static vtkm::Vec NegativeInfinity() + { + BitsType neginf = { VTKM_NEG_INF_BITS_64 }; + return vtkm::Vec(neginf.scalar); } VTKM_EXEC_CONT - static vtkm::Vec Epsilon() { - return vtkm::Vec(VTKM_EPSILON_64); + static vtkm::Vec Epsilon() + { + return vtkm::Vec(VTKM_EPSILON_64); } }; @@ -736,27 +731,24 @@ struct FloatLimits< vtkm::Vec > /// Returns the representation for not-a-number (NaN). /// -template -static inline VTKM_EXEC_CONT -T Nan() +template +static inline VTKM_EXEC_CONT T Nan() { return detail::FloatLimits::Nan(); } /// Returns the representation for infinity. /// -template -static inline VTKM_EXEC_CONT -T Infinity() +template +static inline VTKM_EXEC_CONT T Infinity() { return detail::FloatLimits::Infinity(); } /// Returns the representation for negative infinity. /// -template -static inline VTKM_EXEC_CONT -T NegativeInfinity() +template +static inline VTKM_EXEC_CONT T NegativeInfinity() { return detail::FloatLimits::NegativeInfinity(); } @@ -764,38 +756,34 @@ T NegativeInfinity() /// Returns the difference between 1 and the least value greater than 1 /// that is representable. /// -template -static inline VTKM_EXEC_CONT -T Epsilon() +template +static inline VTKM_EXEC_CONT T Epsilon() { return detail::FloatLimits::Epsilon(); } -#else // !VTKM_USE_IEEE_NONFINITE +#else // !VTKM_USE_IEEE_NONFINITE /// Returns the representation for not-a-number (NaN). /// -template -static inline VTKM_EXEC_CONT -T Nan() +template +static inline VTKM_EXEC_CONT T Nan() { return std::numeric_limits::quiet_NaN(); } /// Returns the representation for infinity. /// -template -static inline VTKM_EXEC_CONT -T Infinity() +template +static inline VTKM_EXEC_CONT T Infinity() { return std::numeric_limits::infinity(); } /// Returns the representation for negative infinity. /// -template -static inline VTKM_EXEC_CONT -T NegativeInfinity() +template +static inline VTKM_EXEC_CONT T NegativeInfinity() { return -std::numeric_limits::infinity(); } @@ -803,9 +791,8 @@ T NegativeInfinity() /// Returns the difference between 1 and the least value greater than 1 /// that is representable. /// -template -static inline VTKM_EXEC_CONT -T Epsilon() +template +static inline VTKM_EXEC_CONT T Epsilon() { return std::numeric_limits::epsilon(); } @@ -813,28 +800,34 @@ T Epsilon() /// Returns the representation for not-a-number (NaN). /// -static inline VTKM_EXEC_CONT vtkm::Float32 Nan32() { +static inline VTKM_EXEC_CONT vtkm::Float32 Nan32() +{ return vtkm::Nan(); } -static inline VTKM_EXEC_CONT vtkm::Float64 Nan64() { +static inline VTKM_EXEC_CONT vtkm::Float64 Nan64() +{ return vtkm::Nan(); } /// Returns the representation for infinity. /// -static inline VTKM_EXEC_CONT vtkm::Float32 Infinity32() { +static inline VTKM_EXEC_CONT vtkm::Float32 Infinity32() +{ return vtkm::Infinity(); } -static inline VTKM_EXEC_CONT vtkm::Float64 Infinity64() { +static inline VTKM_EXEC_CONT vtkm::Float64 Infinity64() +{ return vtkm::Infinity(); } /// Returns the representation for negative infinity. /// -static inline VTKM_EXEC_CONT vtkm::Float32 NegativeInfinity32() { +static inline VTKM_EXEC_CONT vtkm::Float32 NegativeInfinity32() +{ return vtkm::NegativeInfinity(); } -static inline VTKM_EXEC_CONT vtkm::Float64 NegativeInfinity64() { +static inline VTKM_EXEC_CONT vtkm::Float64 NegativeInfinity64() +{ return vtkm::NegativeInfinity(); } @@ -853,9 +846,8 @@ static inline VTKM_EXEC_CONT vtkm::Float64 Epsilon64() //----------------------------------------------------------------------------- /// Returns true if \p x is not a number. /// -template -static inline VTKM_EXEC_CONT -bool IsNan(T x) +template +static inline VTKM_EXEC_CONT bool IsNan(T x) { #ifndef VTKM_CUDA using std::isnan; @@ -865,9 +857,8 @@ bool IsNan(T x) /// Returns true if \p x is positive or negative infinity. /// -template -static inline VTKM_EXEC_CONT -bool IsInf(T x) +template +static inline VTKM_EXEC_CONT bool IsInf(T x) { #ifndef VTKM_CUDA using std::isinf; @@ -877,9 +868,8 @@ bool IsInf(T x) /// Returns true if \p x is a normal number (not NaN or infinite). /// -template -static inline VTKM_EXEC_CONT -bool IsFinite(T x) +template +static inline VTKM_EXEC_CONT bool IsFinite(T x) { #ifndef VTKM_CUDA using std::isfinite; @@ -917,12 +907,11 @@ $binary_math_function('FMod', 'fmod')\ /// returns -0.4, which is 6.5 - 3*2.3. /// #ifdef VTKM_MSVC -template -static inline VTKM_EXEC_CONT -T Remainder(T numerator, T denominator) +template +static inline VTKM_EXEC_CONT T Remainder(T numerator, T denominator) { - T quotient = vtkm::Round(numerator/denominator); - return numerator - quotient*denominator; + T quotient = vtkm::Round(numerator / denominator); + return numerator - quotient * denominator; } #else // !VTKM_MSVC $binary_math_function('Remainder', 'remainder')\ @@ -933,22 +922,20 @@ $# /// Remainder. In addition, this function also returns the \c quotient used to /// get that remainder. /// -template -static inline VTKM_EXEC_CONT -vtkm::Float32 RemainderQuotient(vtkm::Float32 numerator, - vtkm::Float32 denominator, - QType "ient) +template +static inline VTKM_EXEC_CONT vtkm::Float32 RemainderQuotient(vtkm::Float32 numerator, + vtkm::Float32 denominator, + QType& quotient) { int iQuotient; vtkm::Float32 result = std::remquo(numerator, denominator, &iQuotient); quotient = iQuotient; return result; } -template -static inline VTKM_EXEC_CONT -vtkm::Float64 RemainderQuotient(vtkm::Float64 numerator, - vtkm::Float64 denominator, - QType "ient) +template +static inline VTKM_EXEC_CONT vtkm::Float64 RemainderQuotient(vtkm::Float64 numerator, + vtkm::Float64 denominator, + QType& quotient) { int iQuotient; vtkm::Float64 result = std::remquo(numerator, denominator, &iQuotient); @@ -959,13 +946,11 @@ vtkm::Float64 RemainderQuotient(vtkm::Float64 numerator, /// Gets the integral and fractional parts of \c x. The return value is the /// fractional part and \c integral is set to the integral part. /// -static inline VTKM_EXEC_CONT -vtkm::Float32 ModF(vtkm::Float32 x, vtkm::Float32 &integral) +static inline VTKM_EXEC_CONT vtkm::Float32 ModF(vtkm::Float32 x, vtkm::Float32& integral) { return std::modf(x, &integral); } -static inline VTKM_EXEC_CONT -vtkm::Float64 ModF(vtkm::Float64 x, vtkm::Float64 &integral) +static inline VTKM_EXEC_CONT vtkm::Float64 ModF(vtkm::Float64 x, vtkm::Float64& integral) { return std::modf(x, &integral); } @@ -974,8 +959,7 @@ vtkm::Float64 ModF(vtkm::Float64 x, vtkm::Float64 &integral) /// Return the absolute value of \p x. That is, return \p x if it is positive or /// \p -x if it is negative. /// -static inline VTKM_EXEC_CONT -vtkm::Int32 Abs(vtkm::Int32 x) +static inline VTKM_EXEC_CONT vtkm::Int32 Abs(vtkm::Int32 x) { #if VTKM_SIZE_INT == 4 return abs(x); @@ -983,8 +967,7 @@ vtkm::Int32 Abs(vtkm::Int32 x) #error Unknown size of Int32. #endif } -static inline VTKM_EXEC_CONT -vtkm::Int64 Abs(vtkm::Int64 x) +static inline VTKM_EXEC_CONT vtkm::Int64 Abs(vtkm::Int64 x) { #if VTKM_SIZE_LONG == 8 return labs(x); @@ -994,62 +977,55 @@ vtkm::Int64 Abs(vtkm::Int64 x) #error Unknown size of Int64. #endif } -static inline VTKM_EXEC_CONT -vtkm::Float32 Abs(vtkm::Float32 x) { +static inline VTKM_EXEC_CONT vtkm::Float32 Abs(vtkm::Float32 x) +{ #ifdef VTKM_CUDA return VTKM_CUDA_MATH_FUNCTION_32(fabs)(x); #else return std::fabs(x); #endif } -static inline VTKM_EXEC_CONT -vtkm::Float64 Abs(vtkm::Float64 x) { +static inline VTKM_EXEC_CONT vtkm::Float64 Abs(vtkm::Float64 x) +{ #ifdef VTKM_CUDA return VTKM_CUDA_MATH_FUNCTION_64(fabs)(x); #else return std::fabs(x); #endif } -template -static inline VTKM_EXEC_CONT -typename detail::FloatingPointReturnType::Type -Abs(T x) { +template +static inline VTKM_EXEC_CONT typename detail::FloatingPointReturnType::Type Abs(T x) +{ #ifdef VTKM_CUDA return VTKM_CUDA_MATH_FUNCTION_64(fabs)(static_cast(x)); #else return std::fabs(static_cast(x)); #endif } -template -static inline VTKM_EXEC_CONT -vtkm::Vec Abs(const vtkm::Vec &x) { - vtkm::Vec result; +template +static inline VTKM_EXEC_CONT vtkm::Vec Abs(const vtkm::Vec& x) +{ + vtkm::Vec result; for (vtkm::IdComponent index = 0; index < N; index++) { result[index] = vtkm::Abs(x[index]); } return result; } -template -static inline VTKM_EXEC_CONT -vtkm::Vec Abs(const vtkm::Vec &x) { - return vtkm::Vec(vtkm::Abs(x[0]), - vtkm::Abs(x[1]), - vtkm::Abs(x[2]), - vtkm::Abs(x[3])); +template +static inline VTKM_EXEC_CONT vtkm::Vec Abs(const vtkm::Vec& x) +{ + return vtkm::Vec(vtkm::Abs(x[0]), vtkm::Abs(x[1]), vtkm::Abs(x[2]), vtkm::Abs(x[3])); } -template -static inline VTKM_EXEC_CONT -vtkm::Vec Abs(const vtkm::Vec &x) { - return vtkm::Vec(vtkm::Abs(x[0]), - vtkm::Abs(x[1]), - vtkm::Abs(x[2])); +template +static inline VTKM_EXEC_CONT vtkm::Vec Abs(const vtkm::Vec& x) +{ + return vtkm::Vec(vtkm::Abs(x[0]), vtkm::Abs(x[1]), vtkm::Abs(x[2])); } -template -static inline VTKM_EXEC_CONT -vtkm::Vec Abs(const vtkm::Vec &x) { - return vtkm::Vec(vtkm::Abs(x[0]), - vtkm::Abs(x[1])); +template +static inline VTKM_EXEC_CONT vtkm::Vec Abs(const vtkm::Vec& x) +{ + return vtkm::Vec(vtkm::Abs(x[0]), vtkm::Abs(x[1])); } /// Returns a nonzero value if \p x is negative. @@ -1072,11 +1048,11 @@ $unary_template_function_no_vec('IsNegative', '(vtkm::SignBit(x) != 0)', 'bool') $binary_math_function('CopySign', 'copysign')\ $# -template -static inline VTKM_EXEC_CONT -vtkm::Vec CopySign(const vtkm::Vec &x, const vtkm::Vec &y) +template +static inline VTKM_EXEC_CONT vtkm::Vec CopySign(const vtkm::Vec& x, + const vtkm::Vec& y) { - vtkm::Vec result; + vtkm::Vec result; for (vtkm::IdComponent index = 0; index < N; index++) { result[index] = vtkm::CopySign(x[index], y[index]); diff --git a/vtkm/exec/internal/WorkletInvokeFunctorDetail.h.in b/vtkm/exec/internal/WorkletInvokeFunctorDetail.h.in index a44ab9127..0d16f8ba7 100644 --- a/vtkm/exec/internal/WorkletInvokeFunctorDetail.h.in +++ b/vtkm/exec/internal/WorkletInvokeFunctorDetail.h.in @@ -40,8 +40,8 @@ $# Ignore the following comment. It is meant for the generated file. #ifndef vtk_m_exec_internal_WorkletInvokeFunctorDetail_h #define vtk_m_exec_internal_WorkletInvokeFunctorDetail_h -#if !defined(vtk_m_exec_internal_TaskSingular_h) && \ - !defined(vtk_m_exec_internal_TaskTiling_h) && \ +#if !defined(vtk_m_exec_internal_TaskSingular_h) && \\ + !defined(vtk_m_exec_internal_TaskTiling_h) && \\ !defined(VTKM_TEST_HEADER_BUILD) #error WorkletInvokeFunctorDetail.h must be included from TaskSingular.h or TaskTiling.h #endif