Mercurial > hg > vamp-build-and-test
comparison DEPENDENCIES/generic/include/boost/math/special_functions/trunc.hpp @ 16:2665513ce2d3
Add boost headers
author | Chris Cannam |
---|---|
date | Tue, 05 Aug 2014 11:11:38 +0100 |
parents | |
children | c530137014c0 |
comparison
equal
deleted
inserted
replaced
15:663ca0da4350 | 16:2665513ce2d3 |
---|---|
1 // Copyright John Maddock 2007. | |
2 // Use, modification and distribution are subject to the | |
3 // Boost Software License, Version 1.0. (See accompanying file | |
4 // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
5 | |
6 #ifndef BOOST_MATH_TRUNC_HPP | |
7 #define BOOST_MATH_TRUNC_HPP | |
8 | |
9 #ifdef _MSC_VER | |
10 #pragma once | |
11 #endif | |
12 | |
13 #include <boost/math/tools/config.hpp> | |
14 #include <boost/math/policies/error_handling.hpp> | |
15 #include <boost/math/special_functions/fpclassify.hpp> | |
16 | |
17 namespace boost{ namespace math{ | |
18 | |
19 template <class T, class Policy> | |
20 inline typename tools::promote_args<T>::type trunc(const T& v, const Policy& pol) | |
21 { | |
22 BOOST_MATH_STD_USING | |
23 typedef typename tools::promote_args<T>::type result_type; | |
24 if(!(boost::math::isfinite)(v)) | |
25 return policies::raise_rounding_error("boost::math::trunc<%1%>(%1%)", 0, static_cast<result_type>(v), static_cast<result_type>(v), pol); | |
26 return (v >= 0) ? static_cast<result_type>(floor(v)) : static_cast<result_type>(ceil(v)); | |
27 } | |
28 template <class T> | |
29 inline typename tools::promote_args<T>::type trunc(const T& v) | |
30 { | |
31 return trunc(v, policies::policy<>()); | |
32 } | |
33 // | |
34 // The following functions will not compile unless T has an | |
35 // implicit convertion to the integer types. For user-defined | |
36 // number types this will likely not be the case. In that case | |
37 // these functions should either be specialized for the UDT in | |
38 // question, or else overloads should be placed in the same | |
39 // namespace as the UDT: these will then be found via argument | |
40 // dependent lookup. See our concept archetypes for examples. | |
41 // | |
42 template <class T, class Policy> | |
43 inline int itrunc(const T& v, const Policy& pol) | |
44 { | |
45 BOOST_MATH_STD_USING | |
46 typedef typename tools::promote_args<T>::type result_type; | |
47 result_type r = boost::math::trunc(v, pol); | |
48 if((r > (std::numeric_limits<int>::max)()) || (r < (std::numeric_limits<int>::min)())) | |
49 return static_cast<int>(policies::raise_rounding_error("boost::math::itrunc<%1%>(%1%)", 0, static_cast<result_type>(v), 0, pol)); | |
50 return static_cast<int>(r); | |
51 } | |
52 template <class T> | |
53 inline int itrunc(const T& v) | |
54 { | |
55 return itrunc(v, policies::policy<>()); | |
56 } | |
57 | |
58 template <class T, class Policy> | |
59 inline long ltrunc(const T& v, const Policy& pol) | |
60 { | |
61 BOOST_MATH_STD_USING | |
62 typedef typename tools::promote_args<T>::type result_type; | |
63 result_type r = boost::math::trunc(v, pol); | |
64 if((r > (std::numeric_limits<long>::max)()) || (r < (std::numeric_limits<long>::min)())) | |
65 return static_cast<long>(policies::raise_rounding_error("boost::math::ltrunc<%1%>(%1%)", 0, static_cast<result_type>(v), 0L, pol)); | |
66 return static_cast<long>(r); | |
67 } | |
68 template <class T> | |
69 inline long ltrunc(const T& v) | |
70 { | |
71 return ltrunc(v, policies::policy<>()); | |
72 } | |
73 | |
74 #ifdef BOOST_HAS_LONG_LONG | |
75 | |
76 template <class T, class Policy> | |
77 inline boost::long_long_type lltrunc(const T& v, const Policy& pol) | |
78 { | |
79 BOOST_MATH_STD_USING | |
80 typedef typename tools::promote_args<T>::type result_type; | |
81 result_type r = boost::math::trunc(v, pol); | |
82 if((r > (std::numeric_limits<boost::long_long_type>::max)()) || (r < (std::numeric_limits<boost::long_long_type>::min)())) | |
83 return static_cast<boost::long_long_type>(policies::raise_rounding_error("boost::math::lltrunc<%1%>(%1%)", 0, v, static_cast<boost::long_long_type>(0), pol)); | |
84 return static_cast<boost::long_long_type>(r); | |
85 } | |
86 template <class T> | |
87 inline boost::long_long_type lltrunc(const T& v) | |
88 { | |
89 return lltrunc(v, policies::policy<>()); | |
90 } | |
91 | |
92 #endif | |
93 | |
94 }} // namespaces | |
95 | |
96 #endif // BOOST_MATH_TRUNC_HPP |