summaryrefslogtreecommitdiff
path: root/boost/units/static_rational.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/units/static_rational.hpp')
-rw-r--r--boost/units/static_rational.hpp349
1 files changed, 349 insertions, 0 deletions
diff --git a/boost/units/static_rational.hpp b/boost/units/static_rational.hpp
new file mode 100644
index 0000000..5263e75
--- /dev/null
+++ b/boost/units/static_rational.hpp
@@ -0,0 +1,349 @@
+// 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