diff options
Diffstat (limited to 'boost/math/special_functions/trunc.hpp')
-rw-r--r-- | boost/math/special_functions/trunc.hpp | 92 |
1 files changed, 92 insertions, 0 deletions
diff --git a/boost/math/special_functions/trunc.hpp b/boost/math/special_functions/trunc.hpp new file mode 100644 index 0000000000..520ae89f5d --- /dev/null +++ b/boost/math/special_functions/trunc.hpp @@ -0,0 +1,92 @@ +// Copyright John Maddock 2007. +// Use, modification and distribution are subject to the +// Boost Software License, Version 1.0. (See accompanying file +// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +#ifndef BOOST_MATH_TRUNC_HPP +#define BOOST_MATH_TRUNC_HPP + +#ifdef _MSC_VER +#pragma once +#endif + +#include <boost/math/tools/config.hpp> +#include <boost/math/policies/error_handling.hpp> +#include <boost/math/special_functions/fpclassify.hpp> + +namespace boost{ namespace math{ + +template <class T, class Policy> +inline T trunc(const T& v, const Policy& pol) +{ + BOOST_MATH_STD_USING + if(!(boost::math::isfinite)(v)) + return policies::raise_rounding_error("boost::math::trunc<%1%>(%1%)", 0, v, v, pol); + return (v >= 0) ? static_cast<T>(floor(v)) : static_cast<T>(ceil(v)); +} +template <class T> +inline T trunc(const T& v) +{ + return trunc(v, policies::policy<>()); +} +// +// The following functions will not compile unless T has an +// implicit convertion to the integer types. For user-defined +// number types this will likely not be the case. In that case +// these functions should either be specialized for the UDT in +// question, or else overloads should be placed in the same +// namespace as the UDT: these will then be found via argument +// dependent lookup. See our concept archetypes for examples. +// +template <class T, class Policy> +inline int itrunc(const T& v, const Policy& pol) +{ + BOOST_MATH_STD_USING + T r = boost::math::trunc(v, pol); + if((r > (std::numeric_limits<int>::max)()) || (r < (std::numeric_limits<int>::min)())) + return static_cast<int>(policies::raise_rounding_error("boost::math::itrunc<%1%>(%1%)", 0, v, 0, pol)); + return static_cast<int>(r); +} +template <class T> +inline int itrunc(const T& v) +{ + return itrunc(v, policies::policy<>()); +} + +template <class T, class Policy> +inline long ltrunc(const T& v, const Policy& pol) +{ + BOOST_MATH_STD_USING + T r = boost::math::trunc(v, pol); + if((r > (std::numeric_limits<long>::max)()) || (r < (std::numeric_limits<long>::min)())) + return static_cast<long>(policies::raise_rounding_error("boost::math::ltrunc<%1%>(%1%)", 0, v, 0L, pol)); + return static_cast<long>(r); +} +template <class T> +inline long ltrunc(const T& v) +{ + return ltrunc(v, policies::policy<>()); +} + +#ifdef BOOST_HAS_LONG_LONG + +template <class T, class Policy> +inline boost::long_long_type lltrunc(const T& v, const Policy& pol) +{ + BOOST_MATH_STD_USING + T r = boost::math::trunc(v, pol); + if((r > (std::numeric_limits<boost::long_long_type>::max)()) || (r < (std::numeric_limits<boost::long_long_type>::min)())) + return static_cast<boost::long_long_type>(policies::raise_rounding_error("boost::math::lltrunc<%1%>(%1%)", 0, v, 0LL, pol)); + return static_cast<boost::long_long_type>(r); +} +template <class T> +inline boost::long_long_type lltrunc(const T& v) +{ + return lltrunc(v, policies::policy<>()); +} + +#endif + +}} // namespaces + +#endif // BOOST_MATH_TRUNC_HPP |