FM / detail

/usr/include/boost/units/detail

Name	Size	Mode	Actions
absolute_impl.hpp	3055	0644	edit dl rm
cmath_impl.hpp	3757	0644	edit dl rm
conversion_impl.hpp	15443	0644	edit dl rm
dimensionless_unit.hpp	2221	0644	edit dl rm
dimension_impl.hpp	8683	0644	edit dl rm
dimension_list.hpp	2654	0644	edit dl rm
dim_impl.hpp	1744	0644	edit dl rm
heterogeneous_conversion.hpp	8071	0644	edit dl rm
linear_algebra.hpp	32647	0644	edit dl rm
one.hpp	2149	0644	edit dl rm
ordinal.hpp	1017	0644	edit dl rm
prevent_redefinition.hpp	1369	0644	edit dl rm
push_front_if.hpp	882	0644	edit dl rm
push_front_or_add.hpp	1948	0644	edit dl rm
sort.hpp	2640	0644	edit dl rm
static_rational_power.hpp	4922	0644	edit dl rm
unscale.hpp	5446	0644	edit dl rm
utility.hpp	1264	0644	edit dl rm

Edit: /usr/include/boost/units/detail/cmath_impl.hpp (3757B)

#ifndef BOOST_UNITS_CMATH_IMPL_HPP 
#define BOOST_UNITS_CMATH_IMPL_HPP

#include <boost/config.hpp>
#include <boost/math/special_functions/fpclassify.hpp>

namespace boost {
namespace units {
namespace detail {

template<class Y> 
inline bool isgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
    else return v1 > v2;
}

template<class Y> 
inline bool isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
    else return v1 >= v2;
}

template<class Y> 
inline bool isless BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
    else return v1 < v2;
}

template<class Y> 
inline bool islessequal BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
    else return v1 <= v2;
}

template<class Y> 
inline bool islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false;
    else return v1 < v2 || v1 > v2;
}

template<class Y> 
inline bool isunordered BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    return (boost::math::isnan)(v1) || (boost::math::isnan)(v2);
}

template<class Y>
inline Y fdim BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1)) return v1;
    else if((boost::math::isnan)(v2)) return v2;
    else if(v1 > v2) return(v1 - v2);
    else return(Y(0));
}

#if 0

template<class T>
struct fma_issue_warning {
    enum { value = false };
};

template<class Y>
inline Y fma(const Y& v1,const Y& v2,const Y& v3)
{
    //this implementation does *not* meet the
    //requirement of infinite intermediate precision
    BOOST_STATIC_WARNING((fma_issue_warning<Y>::value));

return v1 * v2 + v3;
}

#endif

template<class Y>
inline Y fmax BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1)) return(v2);
    else if((boost::math::isnan)(v2)) return(v1);
    else if(v1 > v2) return(v1);
    else return(v2);
}

template<class Y>
inline Y fmin BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2)
{
    if((boost::math::isnan)(v1)) return(v2);
    else if((boost::math::isnan)(v2)) return(v1);
    else if(v1 < v2) return(v1);
    else return(v2);
}

//template<class Y>
//inline long long llrint(const Y& val)
//{
//    return static_cast<long long>(rint(val));
//}
//
//template<class Y>
//inline long long llround(const Y& val)
//{
//    return static_cast<long long>(round(val));
//}

#if 0

template<class Y>
inline Y nearbyint(const Y& val)
{
    //this is not really correct.
    //the result should be according to the
    //current rounding mode.
    using boost::math::round;
    return round(val);
}

template<class Y>
inline Y rint(const Y& val)
{
    //I don't feel like trying to figure out
    //how to raise a floating pointer exception
    return nearbyint(val);
}

#endif

template<class Y>
inline Y trunc BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& val)
{
    if(val > 0) return std::floor(val);
    else if(val < 0) return std::ceil(val);
    else return val;
}

}
}
}

#endif // BOOST_UNITS_CMATH_IMPL_HPP

// Boost.Units - A C++ library for zero-overhead dimensional analysis and // unit/quantity manipulation and conversion // // Copyright (C) 2003-2008 Matthias Christian Schabel // Copyright (C) 2008 Steven Watanabe // // 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) #ifndef BOOST_UNITS_CMATH_IMPL_HPP #define BOOST_UNITS_CMATH_IMPL_HPP #include #include namespace boost { namespace units { namespace detail { template inline bool isgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false; else return v1 > v2; } template inline bool isgreaterequal BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false; else return v1 >= v2; } template inline bool isless BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false; else return v1 < v2; } template inline bool islessequal BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false; else return v1 <= v2; } template inline bool islessgreater BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1) || (boost::math::isnan)(v2)) return false; else return v1 < v2 || v1 > v2; } template inline bool isunordered BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { return (boost::math::isnan)(v1) || (boost::math::isnan)(v2); } template inline Y fdim BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1)) return v1; else if((boost::math::isnan)(v2)) return v2; else if(v1 > v2) return(v1 - v2); else return(Y(0)); } #if 0 template struct fma_issue_warning { enum { value = false }; }; template inline Y fma(const Y& v1,const Y& v2,const Y& v3) { //this implementation does *not* meet the //requirement of infinite intermediate precision BOOST_STATIC_WARNING((fma_issue_warning::value)); return v1 * v2 + v3; } #endif template inline Y fmax BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1)) return(v2); else if((boost::math::isnan)(v2)) return(v1); else if(v1 > v2) return(v1); else return(v2); } template inline Y fmin BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& v1,const Y& v2) { if((boost::math::isnan)(v1)) return(v2); else if((boost::math::isnan)(v2)) return(v1); else if(v1 < v2) return(v1); else return(v2); } //template //inline long long llrint(const Y& val) //{ // return static_cast(rint(val)); //} // //template //inline long long llround(const Y& val) //{ // return static_cast(round(val)); //} #if 0 template inline Y nearbyint(const Y& val) { //this is not really correct. //the result should be according to the //current rounding mode. using boost::math::round; return round(val); } template inline Y rint(const Y& val) { //I don't feel like trying to figure out //how to raise a floating pointer exception return nearbyint(val); } #endif template inline Y trunc BOOST_PREVENT_MACRO_SUBSTITUTION(const Y& val) { if(val > 0) return std::floor(val); else if(val < 0) return std::ceil(val); else return val; } } } } #endif // BOOST_UNITS_CMATH_IMPL_HPP