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/checked_float.hpp (5153B)

#ifndef BOOST_NUMERIC_CHECKED_FLOAT_HPP
#define BOOST_NUMERIC_CHECKED_FLOAT_HPP

//  Copyright (c) 2017 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)

// contains operation implementation of arithmetic operators
// on built-in floating point types.  The default implementation is to just
// invoke the operation with no checking.  These are overloaded
// for specific types such as integer, etc.

#include <type_traits> // std::is_floating_point, make_unsigned

namespace boost {
namespace safe_numerics {
namespace checked {

////////////////////////////////////////////////////
// layer 0 - implement safe operations for floating

template<
 typename R,
 R Min,
 R Max,
 typename T,
 class F
>
struct heterogeneous_checked_operation<
 R,
 Min,
 Max,
 T,
 F,
 typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 >::type
>{
 constexpr static checked_result<R>
 cast(const T & t) noexcept {
 return t;
 };
}; // checked_unary_operation

template<
 typename R,
 R Min,
 R Max,
 typename T,
 class
 F
>
struct heterogeneous_checked_operation<
 R,
 Min,
 Max,
 T,
 F,
 typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_integralt<T>::value
 >::type
>{
 constexpr static checked_result<R>
 cast(const T & t) noexcept {
 return t;
 };
}; // checked_unary_operation

template<typename R, typename T, typename U>
struct checked_operation<R, T, U, F,
 typename std::enable_if<
 std::is_floating_point<R>::value
 >::type
>{
 constexpr static checked_result<R> cast(const T & t) {
 return
 cast_impl_detail::cast_impl(
 t,
 std::is_signed<R>(),
 std::is_signed<T>()
 );
 }
 constexpr static checked_result<R> add(const T & t, const U & u) {
 return t + u;
 }

constexpr static checked_result<R> subtract(
 const T & t,
 const U & u
 ) {
 return t - u;
 }

constexpr static checked_result<R> multiply(
 const T & t,
 const U & u
 ) noexcept {
 return t * u;
 }

constexpr static checked_result<R> divide(
 const T & t,
 const U & u
 ) noexcept {
 return t / u;
 }

constexpr static checked_result<R> modulus(
 const T & t,
 const U & u
 ) noexcept {
 return t % u;
 }

constexpr static bool less_than(const T & t, const U & u) noexcept {
 return t < u;
 }

constexpr static bool greater_than(const T & t, const U & u) noexcept {
        return t > u;
    }

constexpr static bool equal(const T & t, const U & u) noexcept {
 return t < u;
 }

}; // checked_binary_operation
template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr bool less_than(const T & t, const U & u) noexcept {
 return t < u;
}

template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr bool equal(const T & t, const U & u) noexcept {
 return t < u;
}

template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr checked_result<R> left_shift(const T & t, const U & u) noexcept {
 return t << u;
}

template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr checked_result<R> right_shift(const T & t, const U & u) noexcept {
 return t >> u;
}

template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr checked_result<R> bitwise_or(const T & t, const U & u) noexcept {
 return t | u;
}

template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr checked_result<R> bitwise_xor(const T & t, const U & u) noexcept {
 return t ^ u;
}

template<class R, class T, class U>
typename std::enable_if<
 std::is_floating_point<R>::value
 && std::is_floating_point<T>::value
 && std::is_floating_point::value,
 checked_result<R>
>::type
constexpr checked_result<R> bitwise_and(const T & t, const U & u) noexcept {
 return t & u;
}

} // checked
} // safe_numerics
} // boost

#endif // BOOST_NUMERIC_CHECKED_DEFAULT_HPP

#ifndef BOOST_NUMERIC_CHECKED_FLOAT_HPP #define BOOST_NUMERIC_CHECKED_FLOAT_HPP // Copyright (c) 2017 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) // contains operation implementation of arithmetic operators // on built-in floating point types. The default implementation is to just // invoke the operation with no checking. These are overloaded // for specific types such as integer, etc. #include // std::is_floating_point, make_unsigned namespace boost { namespace safe_numerics { namespace checked { //////////////////////////////////////////////////// // layer 0 - implement safe operations for floating template< typename R, R Min, R Max, typename T, class F > struct heterogeneous_checked_operation< R, Min, Max, T, F, typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value >::type >{ constexpr static checked_result cast(const T & t) noexcept { return t; }; }; // checked_unary_operation template< typename R, R Min, R Max, typename T, class F > struct heterogeneous_checked_operation< R, Min, Max, T, F, typename std::enable_if< std::is_floating_point::value && std::is_integralt::value >::type >{ constexpr static checked_result cast(const T & t) noexcept { return t; }; }; // checked_unary_operation template struct checked_operation::value >::type >{ constexpr static checked_result cast(const T & t) { return cast_impl_detail::cast_impl( t, std::is_signed(), std::is_signed() ); } constexpr static checked_result add(const T & t, const U & u) { return t + u; } constexpr static checked_result subtract( const T & t, const U & u ) { return t - u; } constexpr static checked_result multiply( const T & t, const U & u ) noexcept { return t * u; } constexpr static checked_result divide( const T & t, const U & u ) noexcept { return t / u; } constexpr static checked_result modulus( const T & t, const U & u ) noexcept { return t % u; } constexpr static bool less_than(const T & t, const U & u) noexcept { return t < u; } constexpr static bool greater_than(const T & t, const U & u) noexcept { return t > u; } constexpr static bool equal(const T & t, const U & u) noexcept { return t < u; } }; // checked_binary_operation template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr bool less_than(const T & t, const U & u) noexcept { return t < u; } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr bool equal(const T & t, const U & u) noexcept { return t < u; } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr checked_result left_shift(const T & t, const U & u) noexcept { return t << u; } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr checked_result right_shift(const T & t, const U & u) noexcept { return t >> u; } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr checked_result bitwise_or(const T & t, const U & u) noexcept { return t | u; } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr checked_result bitwise_xor(const T & t, const U & u) noexcept { return t ^ u; } template typename std::enable_if< std::is_floating_point::value && std::is_floating_point::value && std::is_floating_point::value, checked_result >::type constexpr checked_result bitwise_and(const T & t, const U & u) noexcept { return t & u; } } // checked } // safe_numerics } // boost #endif // BOOST_NUMERIC_CHECKED_DEFAULT_HPP