You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
349 lines
10 KiB
349 lines
10 KiB
// 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_STATIC_RATIONAL_HPP |
|
#define BOOST_UNITS_STATIC_RATIONAL_HPP |
|
|
|
#include <boost/math/common_factor_ct.hpp> |
|
#include <boost/mpl/less.hpp> |
|
#include <boost/mpl/arithmetic.hpp> |
|
|
|
#ifdef __BORLANDC__ |
|
#include <boost/mpl/eval_if.hpp> |
|
#include <boost/mpl/integral_c.hpp> |
|
#include <boost/mpl/identity.hpp> |
|
#endif |
|
|
|
#include <boost/units/config.hpp> |
|
#include <boost/units/operators.hpp> |
|
|
|
/// \file |
|
/// \brief Compile-time rational numbers and operators. |
|
|
|
namespace boost { |
|
|
|
namespace units { |
|
|
|
namespace detail { |
|
|
|
struct static_rational_tag {}; |
|
|
|
} |
|
|
|
typedef long integer_type; |
|
|
|
/// Compile time absolute value. |
|
template<integer_type Value> |
|
struct static_abs |
|
{ |
|
BOOST_STATIC_CONSTANT(integer_type,value = Value < 0 ? -Value : Value); |
|
}; |
|
|
|
// Compile time rational number. |
|
/** |
|
This is an implementation of a compile time rational number, where @c static_rational<N,D> represents |
|
a rational number with numerator @c N and denominator @c D. Because of the potential for ambiguity arising |
|
from multiple equivalent values of @c static_rational (e.g. @c static_rational<6,2>==static_rational<3>), |
|
static rationals should always be accessed through @c static_rational<N,D>::type. Template specialization |
|
prevents instantiation of zero denominators (i.e. @c static_rational<N,0>). The following compile-time |
|
arithmetic operators are provided for static_rational variables only (no operators are defined between |
|
long and static_rational): |
|
- @c mpl::negate |
|
- @c mpl::plus |
|
- @c mpl::minus |
|
- @c mpl::times |
|
- @c mpl::divides |
|
|
|
Neither @c static_power nor @c static_root are defined for @c static_rational. This is because template types |
|
may not be floating point values, while powers and roots of rational numbers can produce floating point |
|
values. |
|
*/ |
|
#ifdef __BORLANDC__ |
|
|
|
template<integer_type X> |
|
struct make_integral_c { |
|
typedef boost::mpl::integral_c<integer_type, X> type; |
|
}; |
|
|
|
template<integer_type N,integer_type D = 1> |
|
class static_rational |
|
{ |
|
public: |
|
|
|
typedef static_rational this_type; |
|
|
|
typedef boost::mpl::integral_c<integer_type, N> N_type; |
|
typedef boost::mpl::integral_c<integer_type, D> D_type; |
|
|
|
typedef typename make_integral_c< |
|
(::boost::math::static_gcd< |
|
::boost::units::static_abs<N>::value, |
|
::boost::units::static_abs<D>::value |
|
>::value)>::type gcd_type; |
|
typedef typename boost::mpl::eval_if< |
|
boost::mpl::less< |
|
D_type, |
|
boost::mpl::integral_c<integer_type, 0> |
|
>, |
|
boost::mpl::negate<gcd_type>, |
|
gcd_type |
|
>::type den_type; |
|
|
|
public: |
|
// for mpl arithmetic support |
|
typedef detail::static_rational_tag tag; |
|
|
|
BOOST_STATIC_CONSTANT(integer_type, Numerator = |
|
(::boost::mpl::divides<N_type, den_type>::value)); |
|
BOOST_STATIC_CONSTANT(integer_type, Denominator = |
|
(::boost::mpl::divides<D_type, den_type>::value)); |
|
|
|
/// INTERNAL ONLY |
|
typedef static_rational<N,D> this_type; |
|
|
|
/// static_rational<N,D> reduced by GCD |
|
typedef static_rational< |
|
(::boost::mpl::divides<N_type, den_type>::value), |
|
(::boost::mpl::divides<D_type, den_type>::value) |
|
> type; |
|
|
|
static integer_type numerator() { return Numerator; } |
|
static integer_type denominator() { return Denominator; } |
|
|
|
// INTERNAL ONLY |
|
static_rational() { } |
|
//~static_rational() { } |
|
}; |
|
#else |
|
template<integer_type N,integer_type D = 1> |
|
class static_rational |
|
{ |
|
private: |
|
|
|
static const integer_type nabs = static_abs<N>::value, |
|
dabs = static_abs<D>::value; |
|
|
|
/// greatest common divisor of N and D |
|
// need cast to signed because static_gcd returns unsigned long |
|
static const integer_type den = |
|
static_cast<integer_type>(boost::math::static_gcd<nabs,dabs>::value) * ((D < 0) ? -1 : 1); |
|
|
|
public: |
|
// for mpl arithmetic support |
|
typedef detail::static_rational_tag tag; |
|
|
|
static const integer_type Numerator = N/den, |
|
Denominator = D/den; |
|
|
|
/// INTERNAL ONLY |
|
typedef static_rational<N,D> this_type; |
|
|
|
/// static_rational<N,D> reduced by GCD |
|
typedef static_rational<Numerator,Denominator> type; |
|
|
|
static integer_type numerator() { return Numerator; } |
|
static integer_type denominator() { return Denominator; } |
|
|
|
// INTERNAL ONLY |
|
static_rational() { } |
|
//~static_rational() { } |
|
}; |
|
#endif |
|
|
|
} |
|
|
|
} |
|
|
|
#if BOOST_UNITS_HAS_BOOST_TYPEOF |
|
|
|
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() |
|
|
|
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::units::static_rational, (long)(long)) |
|
|
|
#endif |
|
|
|
namespace boost { |
|
|
|
namespace units { |
|
|
|
// prohibit zero denominator |
|
template<integer_type N> class static_rational<N,0>; |
|
|
|
/// get decimal value of @c static_rational |
|
template<class T,integer_type N,integer_type D> |
|
inline typename divide_typeof_helper<T,T>::type |
|
value(const static_rational<N,D>&) |
|
{ |
|
return T(N)/T(D); |
|
} |
|
|
|
} // namespace units |
|
|
|
#ifndef BOOST_UNITS_DOXYGEN |
|
|
|
namespace mpl { |
|
|
|
#ifdef __BORLANDC__ |
|
|
|
template<> |
|
struct plus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
::boost::mpl::plus< |
|
boost::mpl::times<typename T0::N_type, typename T1::D_type>, |
|
boost::mpl::times<typename T1::N_type, typename T0::D_type> |
|
>::value, |
|
::boost::mpl::times<typename T0::D_type, typename T1::D_type>::value |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct minus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
::boost::mpl::minus< |
|
boost::mpl::times<typename T0::N_type, typename T1::D_type>, |
|
boost::mpl::times<typename T1::N_type, typename T0::D_type> |
|
>::value, |
|
::boost::mpl::times<typename T0::D_type, typename T1::D_type>::value |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct times_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
::boost::mpl::times<typename T0::N_type, typename T1::N_type>::value, |
|
::boost::mpl::times<typename T0::D_type, typename T1::D_type>::value |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct divides_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
::boost::mpl::times<typename T0::N_type, typename T1::D_type>::value, |
|
::boost::mpl::times<typename T0::D_type, typename T1::N_type>::value |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct negate_impl<boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
::boost::mpl::negate<typename T0::N_type>::value, |
|
::boost::mpl::identity<T0>::type::Denominator |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct less_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply |
|
{ |
|
typedef mpl::bool_<((mpl::minus<T0, T1>::type::Numerator) < 0)> type; |
|
}; |
|
}; |
|
|
|
#else |
|
|
|
template<> |
|
struct plus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
T0::Numerator*T1::Denominator+T1::Numerator*T0::Denominator, |
|
T0::Denominator*T1::Denominator |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct minus_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
T0::Numerator*T1::Denominator-T1::Numerator*T0::Denominator, |
|
T0::Denominator*T1::Denominator |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct times_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
T0::Numerator*T1::Numerator, |
|
T0::Denominator*T1::Denominator |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct divides_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply { |
|
typedef typename boost::units::static_rational< |
|
T0::Numerator*T1::Denominator, |
|
T0::Denominator*T1::Numerator |
|
>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct negate_impl<boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0> |
|
struct apply { |
|
typedef typename boost::units::static_rational<-T0::Numerator,T0::Denominator>::type type; |
|
}; |
|
}; |
|
|
|
template<> |
|
struct less_impl<boost::units::detail::static_rational_tag, boost::units::detail::static_rational_tag> |
|
{ |
|
template<class T0, class T1> |
|
struct apply |
|
{ |
|
typedef mpl::bool_<((mpl::minus<T0, T1>::type::Numerator) < 0)> type; |
|
}; |
|
}; |
|
|
|
#endif |
|
|
|
|
|
} |
|
|
|
#endif |
|
|
|
} // namespace boost |
|
|
|
#endif // BOOST_UNITS_STATIC_RATIONAL_HPP
|
|
|