1 /* 2 Copyright (c) Marshall Clow 2008-2012. 3 4 Distributed under the Boost Software License, Version 1.0. (See accompanying 5 file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 6 7 Revision history: 8 27 June 2009 mtc First version 9 23 Oct 2010 mtc Added predicate version 10 11 */ 12 13 /// \file clamp.hpp 14 /// \brief Clamp algorithm 15 /// \author Marshall Clow 16 /// 17 /// Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215 18 19 #ifndef BOOST_ALGORITHM_CLAMP_HPP 20 #define BOOST_ALGORITHM_CLAMP_HPP 21 22 #include <functional> // For std::less 23 #include <iterator> // For std::iterator_traits 24 #include <cassert> 25 26 #include <boost/config.hpp> 27 #include <boost/range/begin.hpp> 28 #include <boost/range/end.hpp> 29 #include <boost/mpl/identity.hpp> // for identity 30 #include <boost/utility/enable_if.hpp> // for boost::disable_if 31 32 namespace boost { namespace algorithm { 33 34 /// \fn clamp ( T const& val, 35 /// typename boost::mpl::identity<T>::type const & lo, 36 /// typename boost::mpl::identity<T>::type const & hi, Pred p ) 37 /// \return the value "val" brought into the range [ lo, hi ] 38 /// using the comparison predicate p. 39 /// If p ( val, lo ) return lo. 40 /// If p ( hi, val ) return hi. 41 /// Otherwise, return the original value. 42 /// 43 /// \param val The value to be clamped 44 /// \param lo The lower bound of the range to be clamped to 45 /// \param hi The upper bound of the range to be clamped to 46 /// \param p A predicate to use to compare the values. 47 /// p ( a, b ) returns a boolean. 48 /// 49 template<typename T, typename Pred> clamp(T const & val,typename boost::mpl::identity<T>::type const & lo,typename boost::mpl::identity<T>::type const & hi,Pred p)50 BOOST_CXX14_CONSTEXPR T const & clamp ( T const& val, 51 typename boost::mpl::identity<T>::type const & lo, 52 typename boost::mpl::identity<T>::type const & hi, Pred p ) 53 { 54 // assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they might be equal 55 return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val; 56 } 57 58 59 /// \fn clamp ( T const& val, 60 /// typename boost::mpl::identity<T>::type const & lo, 61 /// typename boost::mpl::identity<T>::type const & hi ) 62 /// \return the value "val" brought into the range [ lo, hi ]. 63 /// If the value is less than lo, return lo. 64 /// If the value is greater than "hi", return hi. 65 /// Otherwise, return the original value. 66 /// 67 /// \param val The value to be clamped 68 /// \param lo The lower bound of the range to be clamped to 69 /// \param hi The upper bound of the range to be clamped to 70 /// 71 template<typename T> clamp(const T & val,typename boost::mpl::identity<T>::type const & lo,typename boost::mpl::identity<T>::type const & hi)72 BOOST_CXX14_CONSTEXPR T const& clamp ( const T& val, 73 typename boost::mpl::identity<T>::type const & lo, 74 typename boost::mpl::identity<T>::type const & hi ) 75 { 76 return boost::algorithm::clamp ( val, lo, hi, std::less<T>()); 77 } 78 79 /// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 80 /// std::iterator_traits<InputIterator>::value_type const & lo, 81 /// std::iterator_traits<InputIterator>::value_type const & hi ) 82 /// \return clamp the sequence of values [first, last) into [ lo, hi ] 83 /// 84 /// \param first The start of the range of values 85 /// \param last One past the end of the range of input values 86 /// \param out An output iterator to write the clamped values into 87 /// \param lo The lower bound of the range to be clamped to 88 /// \param hi The upper bound of the range to be clamped to 89 /// 90 template<typename InputIterator, typename OutputIterator> clamp_range(InputIterator first,InputIterator last,OutputIterator out,typename std::iterator_traits<InputIterator>::value_type const & lo,typename std::iterator_traits<InputIterator>::value_type const & hi)91 BOOST_CXX14_CONSTEXPR OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 92 typename std::iterator_traits<InputIterator>::value_type const & lo, 93 typename std::iterator_traits<InputIterator>::value_type const & hi ) 94 { 95 // this could also be written with bind and std::transform 96 while ( first != last ) 97 *out++ = boost::algorithm::clamp ( *first++, lo, hi ); 98 return out; 99 } 100 101 /// \fn clamp_range ( const Range &r, OutputIterator out, 102 /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, 103 /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi ) 104 /// \return clamp the sequence of values [first, last) into [ lo, hi ] 105 /// 106 /// \param r The range of values to be clamped 107 /// \param out An output iterator to write the clamped values into 108 /// \param lo The lower bound of the range to be clamped to 109 /// \param hi The upper bound of the range to be clamped to 110 /// 111 template<typename Range, typename OutputIterator> 112 BOOST_CXX14_CONSTEXPR typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type clamp_range(const Range & r,OutputIterator out,typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo,typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi)113 clamp_range ( const Range &r, OutputIterator out, 114 typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, 115 typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi ) 116 { 117 return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi ); 118 } 119 120 121 /// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 122 /// std::iterator_traits<InputIterator>::value_type const & lo, 123 /// std::iterator_traits<InputIterator>::value_type const & hi, Pred p ) 124 /// \return clamp the sequence of values [first, last) into [ lo, hi ] 125 /// using the comparison predicate p. 126 /// 127 /// \param first The start of the range of values 128 /// \param last One past the end of the range of input values 129 /// \param out An output iterator to write the clamped values into 130 /// \param lo The lower bound of the range to be clamped to 131 /// \param hi The upper bound of the range to be clamped to 132 /// \param p A predicate to use to compare the values. 133 /// p ( a, b ) returns a boolean. 134 135 /// 136 template<typename InputIterator, typename OutputIterator, typename Pred> clamp_range(InputIterator first,InputIterator last,OutputIterator out,typename std::iterator_traits<InputIterator>::value_type const & lo,typename std::iterator_traits<InputIterator>::value_type const & hi,Pred p)137 BOOST_CXX14_CONSTEXPR OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out, 138 typename std::iterator_traits<InputIterator>::value_type const & lo, 139 typename std::iterator_traits<InputIterator>::value_type const & hi, Pred p ) 140 { 141 // this could also be written with bind and std::transform 142 while ( first != last ) 143 *out++ = boost::algorithm::clamp ( *first++, lo, hi, p ); 144 return out; 145 } 146 147 /// \fn clamp_range ( const Range &r, OutputIterator out, 148 /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, 149 /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi, 150 /// Pred p ) 151 /// \return clamp the sequence of values [first, last) into [ lo, hi ] 152 /// using the comparison predicate p. 153 /// 154 /// \param r The range of values to be clamped 155 /// \param out An output iterator to write the clamped values into 156 /// \param lo The lower bound of the range to be clamped to 157 /// \param hi The upper bound of the range to be clamped to 158 /// \param p A predicate to use to compare the values. 159 /// p ( a, b ) returns a boolean. 160 // 161 // Disable this template if the first two parameters are the same type; 162 // In that case, the user will get the two iterator version. 163 template<typename Range, typename OutputIterator, typename Pred> 164 BOOST_CXX14_CONSTEXPR typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type clamp_range(const Range & r,OutputIterator out,typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo,typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi,Pred p)165 clamp_range ( const Range &r, OutputIterator out, 166 typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, 167 typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi, 168 Pred p ) 169 { 170 return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p ); 171 } 172 173 174 }} 175 176 #endif // BOOST_ALGORITHM_CLAMP_HPP 177