/usr/include/boost/geometry/util/rational.hpp is in libboost1.48-dev 1.48.0-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 | // Boost.Geometry (aka GGL, Generic Geometry Library)
// Copyright (c) 2011-2011 Barend Gehrels, Amsterdam, the Netherlands.
// Copyright (c) 2011-2011 Bruno Lalande, Paris, France.
// Copyright (c) 2011-2011 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 <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
|