FM / util

/usr/include/boost/geometry/util

Name	Size	Mode	Actions
add_const_if_c.hpp	1677	0644	edit dl rm
bare_type.hpp	1330	0644	edit dl rm
calculation_type.hpp	4873	0644	edit dl rm
closure_as_bool.hpp	1080	0644	edit dl rm
combine_if.hpp	2927	0644	edit dl rm
compress_variant.hpp	3098	0644	edit dl rm
condition.hpp	1346	0644	edit dl rm
coordinate_cast.hpp	1530	0644	edit dl rm
for_each_coordinate.hpp	2627	0644	edit dl rm
has_infinite_coordinate.hpp	1376	0644	edit dl rm
has_nan_coordinate.hpp	2375	0644	edit dl rm
has_non_finite_coordinate.hpp	1405	0644	edit dl rm
is_inverse_spheroidal_coordinates.hpp	1553	0644	edit dl rm
math.hpp	21972	0644	edit dl rm
normalize_spheroidal_box_coordinates.hpp	7317	0644	edit dl rm
normalize_spheroidal_coordinates.hpp	14416	0644	edit dl rm
order_as_direction.hpp	1211	0644	edit dl rm
parameter_type_of.hpp	2156	0644	edit dl rm
promote_floating_point.hpp	1356	0644	edit dl rm
promote_integral.hpp	9775	0644	edit dl rm
range.hpp	12445	0644	edit dl rm
rational.hpp	4580	0644	edit dl rm
select_calculation_type.hpp	2532	0644	edit dl rm
select_coordinate_type.hpp	2003	0644	edit dl rm
select_most_precise.hpp	5459	0644	edit dl rm
select_sequence_element.hpp	2052	0644	edit dl rm
series_expansion.hpp	25670	0644	edit dl rm
transform_variant.hpp	2735	0644	edit dl rm
tuples.hpp	8819	0644	edit dl rm

Edit: /usr/include/boost/geometry/util/rational.hpp (4580B)

// Boost.Geometry (aka GGL, Generic Geometry Library)

// Parts of Boost.Geometry are redesigned from Geodan's Geographic Library
// (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands.

// Use, modification and distribution is subject to 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_GEOMETRY_UTIL_RATIONAL_HPP
#define BOOST_GEOMETRY_UTIL_RATIONAL_HPP

#include <boost/rational.hpp>
#include <boost/numeric/conversion/bounds.hpp>

#include <boost/geometry/util/coordinate_cast.hpp>
#include <boost/geometry/util/select_most_precise.hpp>

namespace boost{ namespace geometry
{

// Specialize for Boost.Geometry's coordinate cast
// (from string to coordinate type)
namespace detail
{

template <typename T>
struct coordinate_cast<rational<T> >
{
    static inline void split_parts(std::string const& source, std::string::size_type p,
        T& before, T& after, bool& negate, std::string::size_type& len)
    {
        std::string before_part = source.substr(0, p);
        std::string const after_part = source.substr(p + 1);

negate = false;

if (before_part.size() > 0 && before_part[0] == '-')
        {
            negate = true;
            before_part.erase(0, 1);
        }
        before = atol(before_part.c_str());
        after = atol(after_part.c_str());
        len = after_part.length();
    }

static inline rational<T> apply(std::string const& source)
    {
        T before, after;
        bool negate;
        std::string::size_type len;

// Note: decimal comma is not (yet) supported, it does (and should) not
        // occur in a WKT, where points are comma separated.
        std::string::size_type p = source.find(".");
        if (p == std::string::npos)
        {
            p = source.find("/");
            if (p == std::string::npos)
            {
                return rational<T>(atol(source.c_str()));
            }
            split_parts(source, p, before, after, negate, len);

return negate
                ? -rational<T>(before, after)
                : rational<T>(before, after)
                ;

}

split_parts(source, p, before, after, negate, len);

T den = 1;
        for (std::string::size_type i = 0; i < len; i++)
        {
            den *= 10;
        }

return negate
            ? -rational<T>(before) - rational<T>(after, den)
            : rational<T>(before) + rational<T>(after, den)
            ;
    }
};

} // namespace detail

// Specialize for Boost.Geometry's select_most_precise
template <typename T1, typename T2>
struct select_most_precise<boost::rational<T1>, boost::rational<T2> >
{
    typedef typename boost::rational
        <
            typename select_most_precise<T1, T2>::type
        > type;
};

template <typename T>
struct select_most_precise<boost::rational<T>, double>
{
    typedef typename boost::rational<T> type;
};

}} // namespace boost::geometry

// Specializes boost::rational to boost::numeric::bounds
namespace boost { namespace numeric
{

template<class T>
struct bounds<rational<T> >
{
    static inline rational<T> lowest()
    {
        return rational<T>(bounds<T>::lowest(), 1);
    }
    static inline rational<T> highest()
    {
        return rational<T>(bounds<T>::highest(), 1);
    }
};

}} // namespace boost::numeric

// Support for boost::numeric_cast to int and to double (necessary for SVG-mapper)
namespace boost { namespace numeric
{

template
<
    typename T,
    typename Traits,
    typename OverflowHandler,
    typename Float2IntRounder,
    typename RawConverter,
    typename UserRangeChecker
>
struct converter<int, rational<T>, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker>
{
    static inline int convert(rational<T> const& arg)
    {
        return int(rational_cast<double>(arg));
    }
};

template
<
    typename T,
    typename Traits,
    typename OverflowHandler,
    typename Float2IntRounder,
    typename RawConverter,
    typename UserRangeChecker
>
struct converter<double, rational<T>, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker>
{
    static inline double convert(rational<T> const& arg)
    {
        return rational_cast<double>(arg);
    }
};

}}

#endif // BOOST_GEOMETRY_UTIL_RATIONAL_HPP

// Boost.Geometry (aka GGL, Generic Geometry Library) // Copyright (c) 2011-2012 Barend Gehrels, Amsterdam, the Netherlands. // Copyright (c) 2011-2012 Bruno Lalande, Paris, France. // Copyright (c) 2011-2012 Mateusz Loskot, London, UK. // Parts of Boost.Geometry are redesigned from Geodan's Geographic Library // (geolib/GGL), copyright (c) 1995-2010 Geodan, Amsterdam, the Netherlands. // Use, modification and distribution is subject to 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_GEOMETRY_UTIL_RATIONAL_HPP #define BOOST_GEOMETRY_UTIL_RATIONAL_HPP #include #include #include #include namespace boost{ namespace geometry { // Specialize for Boost.Geometry's coordinate cast // (from string to coordinate type) namespace detail { template struct coordinate_cast > { static inline void split_parts(std::string const& source, std::string::size_type p, T& before, T& after, bool& negate, std::string::size_type& len) { std::string before_part = source.substr(0, p); std::string const after_part = source.substr(p + 1); negate = false; if (before_part.size() > 0 && before_part[0] == '-') { negate = true; before_part.erase(0, 1); } before = atol(before_part.c_str()); after = atol(after_part.c_str()); len = after_part.length(); } static inline rational apply(std::string const& source) { T before, after; bool negate; std::string::size_type len; // Note: decimal comma is not (yet) supported, it does (and should) not // occur in a WKT, where points are comma separated. std::string::size_type p = source.find("."); if (p == std::string::npos) { p = source.find("/"); if (p == std::string::npos) { return rational(atol(source.c_str())); } split_parts(source, p, before, after, negate, len); return negate ? -rational(before, after) : rational(before, after) ; } split_parts(source, p, before, after, negate, len); T den = 1; for (std::string::size_type i = 0; i < len; i++) { den *= 10; } return negate ? -rational(before) - rational(after, den) : rational(before) + rational(after, den) ; } }; } // namespace detail // Specialize for Boost.Geometry's select_most_precise template struct select_most_precise, boost::rational > { typedef typename boost::rational < typename select_most_precise::type > type; }; template struct select_most_precise, double> { typedef typename boost::rational type; }; }} // namespace boost::geometry // Specializes boost::rational to boost::numeric::bounds namespace boost { namespace numeric { template struct bounds > { static inline rational lowest() { return rational(bounds::lowest(), 1); } static inline rational highest() { return rational(bounds::highest(), 1); } }; }} // namespace boost::numeric // Support for boost::numeric_cast to int and to double (necessary for SVG-mapper) namespace boost { namespace numeric { template < typename T, typename Traits, typename OverflowHandler, typename Float2IntRounder, typename RawConverter, typename UserRangeChecker > struct converter, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker> { static inline int convert(rational const& arg) { return int(rational_cast(arg)); } }; template < typename T, typename Traits, typename OverflowHandler, typename Float2IntRounder, typename RawConverter, typename UserRangeChecker > struct converter, Traits, OverflowHandler, Float2IntRounder, RawConverter, UserRangeChecker> { static inline double convert(rational const& arg) { return rational_cast(arg); } }; }} #endif // BOOST_GEOMETRY_UTIL_RATIONAL_HPP