From 68dd25fbe6e4d3c3513fa5993863419769aa08fc Mon Sep 17 00:00:00 2001 From: Sang-Hoon Park Date: Mon, 19 Oct 2020 16:00:11 +0100 Subject: COMPMID-3637: Move utility headers from arm_compute to src Signed-off-by: Georgios Pinitas Change-Id: If9d6fa8c900b68c4b6fd373f2fc1f9abb83ea917 Signed-off-by: Michalis Spyrou Reviewed-on: https://review.mlplatform.org/c/ml/ComputeLibrary/+/4145 Tested-by: Arm Jenkins Reviewed-by: Sang-Hoon Park Comments-Addressed: Arm Jenkins --- support/CRTP.h | 55 +++++++++++++ support/Cast.h | 119 +++++++++++++++++++++++++++ support/ICloneable.h | 48 +++++++++++ support/Iterable.h | 108 ++++++++++++++++++++++++ support/Random.h | 98 ++++++++++++++++++++++ support/Requires.h | 51 ++++++++++++ support/Rounding.h | 205 ++++++++++++++++++++++++++++++++++++++++++++++ support/SaturateCast.h | 218 +++++++++++++++++++++++++++++++++++++++++++++++++ support/Traits.h | 47 +++++++++++ 9 files changed, 949 insertions(+) create mode 100644 support/CRTP.h create mode 100644 support/Cast.h create mode 100644 support/ICloneable.h create mode 100644 support/Iterable.h create mode 100644 support/Random.h create mode 100644 support/Requires.h create mode 100644 support/Rounding.h create mode 100644 support/SaturateCast.h create mode 100644 support/Traits.h (limited to 'support') diff --git a/support/CRTP.h b/support/CRTP.h new file mode 100644 index 0000000000..eb358d0600 --- /dev/null +++ b/support/CRTP.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2018-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_MISC_CRTP_H +#define ARM_COMPUTE_MISC_CRTP_H + +namespace arm_compute +{ +namespace misc +{ +/** Curiously recurring template pattern Interface */ +template class Type> +struct CRTP +{ +public: + /** Exact type */ + using ExactType = T; + +protected: + const T &impl() const + { + return static_cast(*this); + } + T &impl() + { + return static_cast(*this); + } + +private: + CRTP() = default; + friend Type; +}; +} // namespace misc +} // namespace arm_compute +#endif /* ARM_COMPUTE_MISC_CRTP_H */ diff --git a/support/Cast.h b/support/Cast.h new file mode 100644 index 0000000000..53d5f68065 --- /dev/null +++ b/support/Cast.h @@ -0,0 +1,119 @@ +/* + * Copyright (c) 2018-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_MISC_CAST_H +#define ARM_COMPUTE_MISC_CAST_H + +#include "arm_compute/core/Error.h" + +namespace arm_compute +{ +namespace utils +{ +namespace cast +{ +/** Polymorphic cast between two types + * + * @warning Will throw an exception if cast cannot take place + * + * @tparam Target Target to cast type + * @tparam Source Source from cast type + * + * @param[in] v Value to cast + * + * @return The casted value + */ +template +inline Target polymorphic_cast(Source *v) +{ + if(dynamic_cast(v) == nullptr) + { + ARM_COMPUTE_THROW(std::bad_cast()); + } + return static_cast(v); +} + +/** Polymorphic down cast between two types + * + * @warning Will assert if cannot take place + * + * @tparam Target Target to cast type + * @tparam Source Source from cast type + * + * @param[in] v Value to cast + * + * @return The casted value + */ +template +inline Target polymorphic_downcast(Source *v) +{ + ARM_COMPUTE_ERROR_ON(dynamic_cast(v) != static_cast(v)); + return static_cast(v); +} + +/** Polymorphic cast between two unique pointer types + * + * @warning Will throw an exception if cast cannot take place + * + * @tparam Target Target to cast type + * @tparam Source Source from cast type + * @tparam Deleter Deleter function type + * + * @param[in] v Value to cast + * + * @return The casted value + */ +template +std::unique_ptr polymorphic_cast_unique_ptr(std::unique_ptr &&v) +{ + if(dynamic_cast(v.get()) == nullptr) + { + ARM_COMPUTE_THROW(std::bad_cast()); + } + auto r = static_cast(v.release()); + return std::unique_ptr(r, std::move(v.get_deleter())); +} + +/** Polymorphic down cast between two unique pointer types + * + * @warning Will assert if cannot take place + * + * @tparam Target Target to cast type + * @tparam Source Source from cast type + * @tparam Deleter Deleter function type + * + * @param[in] v Value to cast + * + * @return The casted value + */ +template +std::unique_ptr polymorphic_downcast_unique_ptr(std::unique_ptr &&v) +{ + ARM_COMPUTE_ERROR_ON(dynamic_cast(v.get()) != static_cast(v.get())); + auto r = static_cast(v.release()); + return std::unique_ptr(r, std::move(v.get_deleter())); +} +} // namespace cast +} // namespace utils +} // namespace arm_compute +#endif /* ARM_COMPUTE_MISC_CAST_H */ diff --git a/support/ICloneable.h b/support/ICloneable.h new file mode 100644 index 0000000000..5d333c8442 --- /dev/null +++ b/support/ICloneable.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2017-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_MISC_ICLONEABLE_H +#define ARM_COMPUTE_MISC_ICLONEABLE_H + +#include + +namespace arm_compute +{ +namespace misc +{ +/** Clonable Interface */ +template +class ICloneable +{ +public: + /** Default virtual desctructor */ + virtual ~ICloneable() = default; + /** Provide a clone of the current object of class T + * + * @return Clone object of class T + */ + virtual std::unique_ptr clone() const = 0; +}; +} // namespace misc +} // namespace arm_compute +#endif /* ARM_COMPUTE_MISC_ICLONEABLE_H */ diff --git a/support/Iterable.h b/support/Iterable.h new file mode 100644 index 0000000000..a0bafaf4ce --- /dev/null +++ b/support/Iterable.h @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2018-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_MISC_ITERABLE_H +#define ARM_COMPUTE_MISC_ITERABLE_H + +#include + +namespace arm_compute +{ +namespace utils +{ +namespace iterable +{ +/** Reverse range iterable class + * + * @tparam T Type to create a reverse range on + */ +template +class reverse_iterable +{ +public: + /** Default constructor + * + * @param[in] it Value to reverse iterate on + */ + explicit reverse_iterable(T &it) + : _it(it) + { + } + + /** Get beginning of iterator. + * + * @return beginning of iterator. + */ + typename T::reverse_iterator begin() + { + return _it.rbegin(); + } + + /** Get end of iterator. + * + * @return end of iterator. + */ + typename T::reverse_iterator end() + { + return _it.rend(); + } + + /** Get beginning of const iterator. + * + * @return beginning of const iterator. + */ + typename T::const_reverse_iterator cbegin() + { + return _it.rbegin(); + } + + /** Get end of const iterator. + * + * @return end of const iterator. + */ + typename T::const_reverse_iterator cend() + { + return _it.rend(); + } + +private: + T &_it; +}; + +/** Creates a reverse iterable for a given type + * + * @tparam T Type to create a reverse iterable on + * + * @param[in] val Iterable input + * + * @return Reverse iterable container + */ +template +reverse_iterable reverse_iterate(T &val) +{ + return reverse_iterable(val); +} +} // namespace iterable +} // namespace utils +} // namespace arm_compute +#endif /* ARM_COMPUTE_MISC_ITERABLE_H */ diff --git a/support/Random.h b/support/Random.h new file mode 100644 index 0000000000..c8b767e505 --- /dev/null +++ b/support/Random.h @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2019-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_MISC_RANDOM_H +#define ARM_COMPUTE_MISC_RANDOM_H + +#include "arm_compute/core/Error.h" + +#include +#include + +namespace arm_compute +{ +namespace utils +{ +namespace random +{ +/** Uniform distribution within a given number of sub-ranges + * + * @tparam T Distribution primitive type + */ +template +class RangedUniformDistribution +{ +public: + using DT = typename std::conditional::value, + std::uniform_int_distribution, + std::uniform_real_distribution>::type; + using result_type = T; + using range_pair = std::pair; + +public: + /** Constructor + * + * @param[in] low lowest value in the range (inclusive) + * @param[in] high highest value in the range (inclusive for uniform_int_distribution, exclusive for uniform_real_distribution) + * @param[in] exclude_ranges Ranges to exclude from the generator + */ + RangedUniformDistribution(result_type low, result_type high, const std::vector &exclude_ranges) + : _distributions(), _selector() + { + result_type clow = low; + for(const auto &erange : exclude_ranges) + { + result_type epsilon = std::is_integral::value ? 1 : static_cast(std::numeric_limits::epsilon()); + + ARM_COMPUTE_ERROR_ON(clow > erange.first || clow >= erange.second); + + _distributions.emplace_back(DT(clow, erange.first - epsilon)); + clow = erange.second + epsilon; + } + ARM_COMPUTE_ERROR_ON(clow > high); + _distributions.emplace_back(DT(clow, high)); + _selector = std::uniform_int_distribution(0, _distributions.size() - 1); + } + /** Generate random number + * + * @tparam URNG Random number generator object type + * + * @param[in] g A uniform random number generator object, used as the source of randomness. + * + * @return A new random number. + */ + template + result_type operator()(URNG &g) + { + unsigned int rand_select = _selector(g); + return _distributions[rand_select](g); + } + +private: + std::vector
_distributions; + std::uniform_int_distribution _selector; +}; +} // namespace random +} // namespace utils +} // namespace arm_compute +#endif /* ARM_COMPUTE_MISC_RANDOM_H */ diff --git a/support/Requires.h b/support/Requires.h new file mode 100644 index 0000000000..bc4932adc5 --- /dev/null +++ b/support/Requires.h @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2018-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_UTILS_REQUIRES_H +#define ARM_COMPUTE_UTILS_REQUIRES_H + +namespace arm_compute +{ +namespace utils +{ +namespace requires +{ +// *INDENT-OFF* +// clang-format off +namespace detail +{ +enum class enabler +{ +}; +} // namespace arm_compute + +/** Requirements as template */ +#define REQUIRES_T(...) template ::type = 0> +/** Requirements as template argument */ +#define REQUIRES_TA(...) typename = typename std::enable_if<(__VA_ARGS__), arm_compute::utils::requires::detail::enabler>::type +// clang-format on +// *INDENT-ON* +} // namespace requires +} // namespace utils +} // namespace arm_compute +#endif /*ARM_COMPUTE_UTILS_REQUIRES_H */ diff --git a/support/Rounding.h b/support/Rounding.h new file mode 100644 index 0000000000..ba9266d323 --- /dev/null +++ b/support/Rounding.h @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2018-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_UTILS_ROUNDING_H +#define ARM_COMPUTE_UTILS_ROUNDING_H + +#include "arm_compute/core/Error.h" +#include "arm_compute/core/utils/misc/Traits.h" +#include "support/Requires.h" +#include "support/ToolchainSupport.h" + +#include + +namespace arm_compute +{ +namespace utils +{ +namespace rounding +{ +/** Rounding mode */ +enum class RoundingMode +{ + TO_ZERO, /**< Round towards zero */ + AWAY_FROM_ZERO, /**< Round away from zero */ + HALF_TO_ZERO, /**< Round half towards from zero */ + HALF_AWAY_FROM_ZERO, /**< Round half away from zero */ + HALF_UP, /**< Round half towards positive infinity */ + HALF_DOWN, /**< Round half towards negative infinity */ + HALF_EVEN /**< Round half towards nearest even */ +}; + +/** Round floating-point value with round to zero + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_to_zero(T value) +{ + T res = std::floor(std::fabs(value)); + return (value < 0.f) ? -res : res; +} + +/** Round floating-point value with round away from zero + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_away_from_zero(T value) +{ + T res = std::ceil(std::fabs(value)); + return (value < 0.f) ? -res : res; +} + +/** Round floating-point value with half value rounding towards zero. + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_half_to_zero(T value) +{ + T res = T(std::ceil(std::fabs(value) - 0.5f)); + return (value < 0.f) ? -res : res; +} + +/** Round floating-point value with half value rounding away from zero. + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_half_away_from_zero(T value) +{ + T res = T(std::floor(std::fabs(value) + 0.5f)); + return (value < 0.f) ? -res : res; +} + +/** Round floating-point value with half value rounding to positive infinity. + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_half_up(T value) +{ + return std::floor(value + 0.5f); +} + +/** Round floating-point value with half value rounding to negative infinity. + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_half_down(T value) +{ + return std::ceil(value - 0.5f); +} + +/** Round floating-point value with half value rounding to nearest even. + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * @param[in] epsilon precision. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round_half_even(T value, T epsilon = std::numeric_limits::epsilon()) +{ + T positive_value = std::abs(value); + T ipart = 0; + std::modf(positive_value, &ipart); + // If 'value' is exactly halfway between two integers + if(std::abs(positive_value - (ipart + 0.5f)) < epsilon) + { + // If 'ipart' is even then return 'ipart' + if(std::fmod(ipart, 2.f) < epsilon) + { + return support::cpp11::copysign(ipart, value); + } + // Else return the nearest even integer + return support::cpp11::copysign(std::ceil(ipart + 0.5f), value); + } + // Otherwise use the usual round to closest + return support::cpp11::copysign(support::cpp11::round(positive_value), value); +} + +/** Round floating-point value given a rounding mode + * + * @tparam T Parameter type. Should be of floating point type. + * + * @param[in] value floating-point value to be rounded. + * @param[in] rounding_mode Rounding mode to use. + * + * @return Floating-point value of rounded @p value. + */ +template ::value)> +inline T round(T value, RoundingMode rounding_mode) +{ + switch(rounding_mode) + { + case RoundingMode::TO_ZERO: + return round_to_zero(value); + case RoundingMode::AWAY_FROM_ZERO: + return round_away_from_zero(value); + case RoundingMode::HALF_TO_ZERO: + return round_half_to_zero(value); + case RoundingMode::HALF_AWAY_FROM_ZERO: + return round_half_away_from_zero(value); + case RoundingMode::HALF_UP: + return round_half_up(value); + case RoundingMode::HALF_DOWN: + return round_half_down(value); + case RoundingMode::HALF_EVEN: + return round_half_even(value); + default: + ARM_COMPUTE_ERROR("Unsupported rounding mode!"); + } +} +} // namespace rounding +} // namespace utils +} // namespace arm_compute +#endif /*ARM_COMPUTE_UTILS_ROUNDING_H */ diff --git a/support/SaturateCast.h b/support/SaturateCast.h new file mode 100644 index 0000000000..a9982d8e96 --- /dev/null +++ b/support/SaturateCast.h @@ -0,0 +1,218 @@ +/* + * Copyright (c) 2018-2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef ARM_COMPUTE_UTILS_CAST_SATURATE_CAST_H +#define ARM_COMPUTE_UTILS_CAST_SATURATE_CAST_H + +#include "arm_compute/core/utils/misc/Traits.h" +#include "arm_compute/core/utils/misc/Utility.h" +#include "support/Rounding.h" + +namespace arm_compute +{ +namespace utils +{ +namespace cast +{ +// *INDENT-OFF* +// clang-format off +// same type +template::value, int >::type = 0 > +T saturate_cast(U v) +{ + return v; +} + +// signed -> signed widening/same_width +template::value && + std::is_integral::value && + std::is_signed() && + std::is_signed() && + !std::is_same::value && + sizeof(T) >= sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(v); +} +// signed -> signed narrowing +template::value && + std::is_integral::value && + std::is_signed() && + std::is_signed() && + !std::is_same::value && + sizeof(T) < sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(utility::clamp(v, std::numeric_limits::lowest(), std::numeric_limits::max())); +} + +// unsigned -> signed widening +template::value && + std::is_integral::value && + std::is_unsigned() && + std::is_signed() && + !std::is_same::value && + (sizeof(T) > sizeof(U)), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(v); +} +// unsigned -> signed narrowing +template::value && + std::is_integral::value && + std::is_unsigned() && + std::is_signed() && + !std::is_same::value && + sizeof(T) < sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(std::min(v, std::numeric_limits::max())); +} +// unsigned -> signed same_width +template::value && + std::is_integral::value && + std::is_unsigned() && + std::is_signed() && + !std::is_same::value && + sizeof(T) == sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(std::min(v, std::numeric_limits::max())); +} + +// signed -> unsigned widening/same width +template::value && + std::is_integral::value && + std::is_signed() && + std::is_unsigned() && + !std::is_same::value && + sizeof(T) >= sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(std::max(0, v)); +} + +// signed -> unsigned narrowing +template::value && + std::is_integral::value && + std::is_signed() && + std::is_unsigned() && + !std::is_same::value && + sizeof(T) < sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(utility::clamp(v, 0, std::numeric_limits::max())); +} + +// unsigned -> unsigned widening/same width +template::value && + std::is_integral::value && + std::is_unsigned() && + std::is_unsigned() && + !std::is_same::value && + sizeof(T) >= sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(v); +} + +// unsigned -> unsigned narrowing +template::value && + std::is_integral::value && + std::is_unsigned() && + std::is_unsigned() && + !std::is_same::value && + sizeof(T) < sizeof(U), + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(utility::clamp(v, std::numeric_limits::lowest(), std::numeric_limits::max())); +} + +// float -> int +template::value && + traits::is_floating_point::value, + int >::type = 0 > +inline T saturate_cast(U v) +{ + int32_t vi = utils::rounding::round_half_away_from_zero(v); + return saturate_cast(vi); +} + +// int -> float +template::value && + std::is_integral::value, + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(v); +} + +// float -> float +template::value && + traits::is_floating_point::value, + int >::type = 0 > +inline T saturate_cast(U v) +{ + return static_cast(v); +} +// clang-format on +// *INDENT-ON* +} // namespace cast +} // namespace utils +} // namespace arm_compute +#endif /* ARM_COMPUTE_UTILS_CAST_SATURATE_CAST_H */ diff --git a/support/Traits.h b/support/Traits.h new file mode 100644 index 0000000000..e892c631f7 --- /dev/null +++ b/support/Traits.h @@ -0,0 +1,47 @@ +/* +* Copyright (c) 2020 Arm Limited. + * + * SPDX-License-Identifier: MIT + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#ifndef SUPPORT_TRAITS_H +#define SUPPORT_TRAITS_H + +#include + +namespace arm_compute +{ +/** Disable bitwise operations by default */ +template +struct enable_bitwise_ops +{ + static constexpr bool value = false; /**< Disabled */ +}; + +#ifndef DOXYGEN_SKIP_THIS +template +typename std::enable_if::value, T>::type operator&(T lhs, T rhs) +{ + using underlying_type = typename std::underlying_type::type; + return static_cast(static_cast(lhs) & static_cast(rhs)); +} +#endif /* DOXYGEN_SKIP_THIS */ +} // namespace arm_compute +#endif /* SUPPORT_TRAITS_H */ -- cgit v1.2.1