FM / safe_numerics

/usr/include/boost/safe_numerics

Name	Size	Mode	Actions
concept/	-	0755	rm
automatic.hpp	17772	0644	edit dl rm
checked_default.hpp	7134	0644	edit dl rm
checked_float.hpp	5153	0644	edit dl rm
checked_integer.hpp	26535	0644	edit dl rm
checked_result.hpp	4135	0644	edit dl rm
checked_result_operations.hpp	42560	0644	edit dl rm
cpp.hpp	6802	0644	edit dl rm
exception.hpp	6811	0644	edit dl rm
exception_policies.hpp	7462	0644	edit dl rm
interval.hpp	8357	0644	edit dl rm
native.hpp	3183	0644	edit dl rm
range_value.hpp	1491	0644	edit dl rm
safe_base.hpp	9157	0644	edit dl rm
safe_base_operations.hpp	53080	0644	edit dl rm
safe_common.hpp	913	0644	edit dl rm
safe_compare.hpp	4858	0644	edit dl rm
safe_integer.hpp	956	0644	edit dl rm
safe_integer_literal.hpp	7055	0644	edit dl rm
safe_integer_range.hpp	1600	0644	edit dl rm
utility.hpp	8213	0644	edit dl rm

Edit: /usr/include/boost/safe_numerics/safe_compare.hpp (4858B)

#ifndef BOOST_NUMERIC_SAFE_COMPARE_HPP
#define BOOST_NUMERIC_SAFE_COMPARE_HPP

//  Copyright (c) 2012 Robert Ramey
//
// Distributed under 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)

#include <type_traits>
#include <limits>

namespace boost {
namespace safe_numerics {
namespace safe_compare {

////////////////////////////////////////////////////
// safe comparison on primitive integral types
namespace safe_compare_detail {
 template<typename T>
 using make_unsigned = typename std::conditional<
 std::is_signed<T>::value,
 std::make_unsigned<T>,
 T
 >::type;

// both arguments unsigned or signed
 template<bool TS, bool US>
 struct less_than {
 template<class T, class U>
 constexpr static bool invoke(const T & t, const U & u){
 return t < u;
 }
 };

// T unsigned, U signed
 template<>
 struct less_than<false, true> {
 template<class T, class U>
 constexpr static bool invoke(const T & t, const U & u){
 return
 (u < 0) ?
 false
 :
 less_than<false, false>::invoke(
 t,
 static_cast<const typename make_unsigned::type &>(u)
 )
 ;
 }
 };
 // T signed, U unsigned
 template<>
 struct less_than<true, false> {
 template<class T, class U>
 constexpr static bool invoke(const T & t, const U & u){
 return
 (t < 0) ?
 true
 :
 less_than<false, false>::invoke(
 static_cast<const typename make_unsigned<T>::type &>(t),
 u
 )
 ;
 }
 };
} // safe_compare_detail

template<class T, class U>
typename std::enable_if<
 std::is_integral<T>::value && std::is_integral::value,
 bool
>::type
constexpr less_than(const T & lhs, const U & rhs) {
 return safe_compare_detail::less_than<
 std::is_signed<T>::value,
 std::is_signed::value
 >::template invoke(lhs, rhs);
}

template<class T, class U>
typename std::enable_if<
 std::is_floating_point<T>::value && std::is_floating_point::value,
 bool
>::type
constexpr less_than(const T & lhs, const U & rhs) {
 return lhs < rhs;
}

template<class T, class U>
constexpr bool greater_than(const T & lhs, const U & rhs) {
 return less_than(rhs, lhs);
}

template<class T, class U>
constexpr bool less_than_equal(const T & lhs, const U & rhs) {
 return ! greater_than(lhs, rhs);
}

template<class T, class U>
constexpr bool greater_than_equal(const T & lhs, const U & rhs) {
 return ! less_than(lhs, rhs);
}

namespace safe_compare_detail {
 // both arguments unsigned or signed
 template<bool TS, bool US>
 struct equal {
 template<class T, class U>
 constexpr static bool invoke(const T & t, const U & u){
 return t == u;
 }
 };

// T unsigned, U signed
 template<>
 struct equal<false, true> {
 template<class T, class U>
 constexpr static bool invoke(const T & t, const U & u){
 return
 (u < 0) ?
 false
 :
 equal<false, false>::invoke(
 t,
 static_cast<const typename make_unsigned::type &>(u)
 )
 ;
 }
 };
 // T signed, U unsigned
 template<>
 struct equal<true, false> {
 template<class T, class U>
 constexpr static bool invoke(const T & t, const U & u){
 return
 (t < 0) ?
 false
 :
 equal<false, false>::invoke(
 static_cast<const typename make_unsigned<T>::type &>(t),
 u
 )
 ;
 }
 };
} // safe_compare_detail

template<class T, class U>
typename std::enable_if<
 std::is_integral<T>::value && std::is_integral::value,
 bool
>::type
constexpr equal(const T & lhs, const U & rhs) {
 return safe_compare_detail::equal<
 std::numeric_limits<T>::is_signed,
 std::numeric_limits::is_signed
 >::template invoke(lhs, rhs);
}

template<class T, class U>
typename std::enable_if<
 std::is_floating_point<T>::value && std::is_floating_point::value,
 bool
>::type
constexpr equal(const T & lhs, const U & rhs) {
 return lhs == rhs;
}

template<class T, class U>
constexpr bool not_equal(const T & lhs, const U & rhs) {
 return ! equal(lhs, rhs);
}

} // safe_compare
} // safe_numerics
} // boost

#endif // BOOST_NUMERIC_SAFE_COMPARE_HPP

#ifndef BOOST_NUMERIC_SAFE_COMPARE_HPP #define BOOST_NUMERIC_SAFE_COMPARE_HPP // Copyright (c) 2012 Robert Ramey // // Distributed under 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) #include #include namespace boost { namespace safe_numerics { namespace safe_compare { //////////////////////////////////////////////////// // safe comparison on primitive integral types namespace safe_compare_detail { template using make_unsigned = typename std::conditional< std::is_signed::value, std::make_unsigned, T >::type; // both arguments unsigned or signed template struct less_than { template constexpr static bool invoke(const T & t, const U & u){ return t < u; } }; // T unsigned, U signed template<> struct less_than { template constexpr static bool invoke(const T & t, const U & u){ return (u < 0) ? false : less_than::invoke( t, static_cast::type &>(u) ) ; } }; // T signed, U unsigned template<> struct less_than { template constexpr static bool invoke(const T & t, const U & u){ return (t < 0) ? true : less_than::invoke( static_cast::type &>(t), u ) ; } }; } // safe_compare_detail template typename std::enable_if< std::is_integral::value && std::is_integral::value, bool >::type constexpr less_than(const T & lhs, const U & rhs) { return safe_compare_detail::less_than< std::is_signed::value, std::is_signed::value >::template invoke(lhs, rhs); } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value, bool >::type constexpr less_than(const T & lhs, const U & rhs) { return lhs < rhs; } template constexpr bool greater_than(const T & lhs, const U & rhs) { return less_than(rhs, lhs); } template constexpr bool less_than_equal(const T & lhs, const U & rhs) { return ! greater_than(lhs, rhs); } template constexpr bool greater_than_equal(const T & lhs, const U & rhs) { return ! less_than(lhs, rhs); } namespace safe_compare_detail { // both arguments unsigned or signed template struct equal { template constexpr static bool invoke(const T & t, const U & u){ return t == u; } }; // T unsigned, U signed template<> struct equal { template constexpr static bool invoke(const T & t, const U & u){ return (u < 0) ? false : equal::invoke( t, static_cast::type &>(u) ) ; } }; // T signed, U unsigned template<> struct equal { template constexpr static bool invoke(const T & t, const U & u){ return (t < 0) ? false : equal::invoke( static_cast::type &>(t), u ) ; } }; } // safe_compare_detail template typename std::enable_if< std::is_integral::value && std::is_integral::value, bool >::type constexpr equal(const T & lhs, const U & rhs) { return safe_compare_detail::equal< std::numeric_limits::is_signed, std::numeric_limits::is_signed >::template invoke(lhs, rhs); } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value, bool >::type constexpr equal(const T & lhs, const U & rhs) { return lhs == rhs; } template constexpr bool not_equal(const T & lhs, const U & rhs) { return ! equal(lhs, rhs); } } // safe_compare } // safe_numerics } // boost #endif // BOOST_NUMERIC_SAFE_COMPARE_HPP