FM / tools

/usr/include/boost/math/tools

Name	Size	Mode	Actions
detail/	-	0755	rm
atomic.hpp	3255	0644	edit dl rm
big_constant.hpp	3412	0644	edit dl rm
bivariate_statistics.hpp	2858	0644	edit dl rm
complex.hpp	1744	0644	edit dl rm
condition_numbers.hpp	3498	0644	edit dl rm
config.hpp	14579	0644	edit dl rm
convert_from_string.hpp	1656	0644	edit dl rm
cxx03_warn.hpp	5128	0644	edit dl rm
fraction.hpp	8733	0644	edit dl rm
minima.hpp	4319	0644	edit dl rm
norms.hpp	16425	0644	edit dl rm
numerical_differentiation.hpp	533	0644	edit dl rm
polynomial.hpp	21946	0644	edit dl rm
polynomial_gcd.hpp	6044	0644	edit dl rm
precision.hpp	14133	0644	edit dl rm
promotion.hpp	8434	0644	edit dl rm
rational.hpp	13809	0644	edit dl rm
real_cast.hpp	744	0644	edit dl rm
recurrence.hpp	12901	0644	edit dl rm
roots.hpp	34373	0644	edit dl rm
series.hpp	6445	0644	edit dl rm
signal_statistics.hpp	12061	0644	edit dl rm
stats.hpp	2056	0644	edit dl rm
test_value.hpp	5523	0644	edit dl rm
toms748_solve.hpp	18329	0644	edit dl rm
traits.hpp	3001	0644	edit dl rm
tuple.hpp	2040	0644	edit dl rm
univariate_statistics.hpp	12465	0644	edit dl rm
user.hpp	2636	0644	edit dl rm
workaround.hpp	1067	0644	edit dl rm

Edit: /usr/include/boost/math/tools/fraction.hpp (8733B)

#ifndef BOOST_MATH_TOOLS_FRACTION_INCLUDED
#define BOOST_MATH_TOOLS_FRACTION_INCLUDED

#ifdef _MSC_VER
#pragma once
#endif

#include <boost/config/no_tr1/cmath.hpp>
#include <boost/cstdint.hpp>
#include <boost/type_traits/integral_constant.hpp>
#include <boost/mpl/if.hpp>
#include <boost/math/tools/precision.hpp>
#include <boost/math/tools/complex.hpp>

namespace boost{ namespace math{ namespace tools{

namespace detail
{

template <class T>
   struct is_pair : public boost::false_type{};

template <class T, class U>
   struct is_pair<std::pair<T,U> > : public boost::true_type{};

template <class Gen>
   struct fraction_traits_simple
   {
       typedef typename Gen::result_type result_type;
       typedef typename Gen::result_type value_type;

static result_type a(const value_type&) BOOST_MATH_NOEXCEPT(value_type)
       {
          return 1;
       }
       static result_type b(const value_type& v) BOOST_MATH_NOEXCEPT(value_type)
       {
          return v;
       }
   };

template <class Gen>
   struct fraction_traits_pair
   {
       typedef typename Gen::result_type value_type;
       typedef typename value_type::first_type result_type;

static result_type a(const value_type& v) BOOST_MATH_NOEXCEPT(value_type)
       {
          return v.first;
       }
       static result_type b(const value_type& v) BOOST_MATH_NOEXCEPT(value_type)
       {
          return v.second;
       }
   };

template <class Gen>
   struct fraction_traits
       : public boost::mpl::if_c<
         is_pair<typename Gen::result_type>::value,
         fraction_traits_pair<Gen>,
         fraction_traits_simple<Gen> >::type
   {
   };

template <class T, bool = is_complex_type<T>::value>
   struct tiny_value
   {
      static T get() {
         return tools::min_value<T>(); 
      }
   };
   template <class T>
   struct tiny_value<T, true>
   {
      typedef typename T::value_type value_type;
      static T get() {
         return tools::min_value<value_type>();
      }
   };

} // namespace detail

//
// continued_fraction_b
// Evaluates:
//
// b0 +       a1
//      ---------------
//      b1 +     a2
//           ----------
//           b2 +   a3
//                -----
//                b3 + ...
//
// Note that the first a0 returned by generator Gen is discarded.
//
template <class Gen, class U>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, const U& factor, boost::uintmax_t& max_terms) 
      BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   BOOST_MATH_STD_USING // ADL of std names

typedef detail::fraction_traits<Gen> traits;
   typedef typename traits::result_type result_type;
   typedef typename traits::value_type value_type;
   typedef typename integer_scalar_type<result_type>::type integer_type;
   typedef typename scalar_type<result_type>::type scalar_type;

integer_type const zero(0), one(1);

result_type tiny = detail::tiny_value<result_type>::get();
   scalar_type terminator = abs(factor);

value_type v = g();

result_type f, C, D, delta;
   f = traits::b(v);
   if(f == zero)
      f = tiny;
   C = f;
   D = 0;

boost::uintmax_t counter(max_terms);

do{
      v = g();
      D = traits::b(v) + traits::a(v) * D;
      if(D == result_type(0))
         D = tiny;
      C = traits::b(v) + traits::a(v) / C;
      if(C == zero)
         C = tiny;
      D = one/D;
      delta = C*D;
      f = f * delta;
   }while((abs(delta - one) > terminator) && --counter);

max_terms = max_terms - counter;

return f;
}

template <class Gen, class U>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, const U& factor)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   boost::uintmax_t max_terms = (std::numeric_limits<boost::uintmax_t>::max)();
   return continued_fraction_b(g, factor, max_terms);
}

template <class Gen>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, int bits)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   BOOST_MATH_STD_USING // ADL of std names

typedef detail::fraction_traits<Gen> traits;
   typedef typename traits::result_type result_type;

result_type factor = ldexp(1.0f, 1 - bits); // 1 / pow(result_type(2), bits);
   boost::uintmax_t max_terms = (std::numeric_limits<boost::uintmax_t>::max)();
   return continued_fraction_b(g, factor, max_terms);
}

template <class Gen>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_b(Gen& g, int bits, boost::uintmax_t& max_terms)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   BOOST_MATH_STD_USING // ADL of std names

typedef detail::fraction_traits<Gen> traits;
   typedef typename traits::result_type result_type;

result_type factor = ldexp(1.0f, 1 - bits); // 1 / pow(result_type(2), bits);
   return continued_fraction_b(g, factor, max_terms);
}

//
// continued_fraction_a
// Evaluates:
//
//            a1
//      ---------------
//      b1 +     a2
//           ----------
//           b2 +   a3
//                -----
//                b3 + ...
//
// Note that the first a1 and b1 returned by generator Gen are both used.
//
template <class Gen, class U>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, const U& factor, boost::uintmax_t& max_terms)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   BOOST_MATH_STD_USING // ADL of std names

integer_type const zero(0), one(1);

result_type tiny = detail::tiny_value<result_type>::get();
   scalar_type terminator = abs(factor);

value_type v = g();

result_type f, C, D, delta, a0;
   f = traits::b(v);
   a0 = traits::a(v);
   if(f == zero)
      f = tiny;
   C = f;
   D = 0;

boost::uintmax_t counter(max_terms);

do{
      v = g();
      D = traits::b(v) + traits::a(v) * D;
      if(D == zero)
         D = tiny;
      C = traits::b(v) + traits::a(v) / C;
      if(C == zero)
         C = tiny;
      D = one/D;
      delta = C*D;
      f = f * delta;
   }while((abs(delta - one) > terminator) && --counter);

max_terms = max_terms - counter;

return a0/f;
}

template <class Gen, class U>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, const U& factor)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   boost::uintmax_t max_iter = (std::numeric_limits<boost::uintmax_t>::max)();
   return continued_fraction_a(g, factor, max_iter);
}

template <class Gen>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, int bits)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   BOOST_MATH_STD_USING // ADL of std names

typedef detail::fraction_traits<Gen> traits;
   typedef typename traits::result_type result_type;

result_type factor = ldexp(1.0f, 1-bits); // 1 / pow(result_type(2), bits);
   boost::uintmax_t max_iter = (std::numeric_limits<boost::uintmax_t>::max)();

return continued_fraction_a(g, factor, max_iter);
}

template <class Gen>
inline typename detail::fraction_traits<Gen>::result_type continued_fraction_a(Gen& g, int bits, boost::uintmax_t& max_terms)
   BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits<Gen>::result_type) && noexcept(std::declval<Gen>()()))
{
   BOOST_MATH_STD_USING // ADL of std names

typedef detail::fraction_traits<Gen> traits;
   typedef typename traits::result_type result_type;

result_type factor = ldexp(1.0f, 1-bits); // 1 / pow(result_type(2), bits);
   return continued_fraction_a(g, factor, max_terms);
}

} // namespace tools
} // namespace math
} // namespace boost

#endif // BOOST_MATH_TOOLS_FRACTION_INCLUDED

// (C) Copyright John Maddock 2005-2006. // Use, modification and distribution are 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_MATH_TOOLS_FRACTION_INCLUDED #define BOOST_MATH_TOOLS_FRACTION_INCLUDED #ifdef _MSC_VER #pragma once #endif #include #include #include #include #include #include namespace boost{ namespace math{ namespace tools{ namespace detail { template struct is_pair : public boost::false_type{}; template struct is_pair > : public boost::true_type{}; template struct fraction_traits_simple { typedef typename Gen::result_type result_type; typedef typename Gen::result_type value_type; static result_type a(const value_type&) BOOST_MATH_NOEXCEPT(value_type) { return 1; } static result_type b(const value_type& v) BOOST_MATH_NOEXCEPT(value_type) { return v; } }; template struct fraction_traits_pair { typedef typename Gen::result_type value_type; typedef typename value_type::first_type result_type; static result_type a(const value_type& v) BOOST_MATH_NOEXCEPT(value_type) { return v.first; } static result_type b(const value_type& v) BOOST_MATH_NOEXCEPT(value_type) { return v.second; } }; template struct fraction_traits : public boost::mpl::if_c< is_pair::value, fraction_traits_pair, fraction_traits_simple >::type { }; template ::value> struct tiny_value { static T get() { return tools::min_value(); } }; template struct tiny_value { typedef typename T::value_type value_type; static T get() { return tools::min_value(); } }; } // namespace detail // // continued_fraction_b // Evaluates: // // b0 + a1 // --------------- // b1 + a2 // ---------- // b2 + a3 // ----- // b3 + ... // // Note that the first a0 returned by generator Gen is discarded. // template inline typename detail::fraction_traits::result_type continued_fraction_b(Gen& g, const U& factor, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { BOOST_MATH_STD_USING // ADL of std names typedef detail::fraction_traits traits; typedef typename traits::result_type result_type; typedef typename traits::value_type value_type; typedef typename integer_scalar_type::type integer_type; typedef typename scalar_type::type scalar_type; integer_type const zero(0), one(1); result_type tiny = detail::tiny_value::get(); scalar_type terminator = abs(factor); value_type v = g(); result_type f, C, D, delta; f = traits::b(v); if(f == zero) f = tiny; C = f; D = 0; boost::uintmax_t counter(max_terms); do{ v = g(); D = traits::b(v) + traits::a(v) * D; if(D == result_type(0)) D = tiny; C = traits::b(v) + traits::a(v) / C; if(C == zero) C = tiny; D = one/D; delta = C*D; f = f * delta; }while((abs(delta - one) > terminator) && --counter); max_terms = max_terms - counter; return f; } template inline typename detail::fraction_traits::result_type continued_fraction_b(Gen& g, const U& factor) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { boost::uintmax_t max_terms = (std::numeric_limits::max)(); return continued_fraction_b(g, factor, max_terms); } template inline typename detail::fraction_traits::result_type continued_fraction_b(Gen& g, int bits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { BOOST_MATH_STD_USING // ADL of std names typedef detail::fraction_traits traits; typedef typename traits::result_type result_type; result_type factor = ldexp(1.0f, 1 - bits); // 1 / pow(result_type(2), bits); boost::uintmax_t max_terms = (std::numeric_limits::max)(); return continued_fraction_b(g, factor, max_terms); } template inline typename detail::fraction_traits::result_type continued_fraction_b(Gen& g, int bits, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { BOOST_MATH_STD_USING // ADL of std names typedef detail::fraction_traits traits; typedef typename traits::result_type result_type; result_type factor = ldexp(1.0f, 1 - bits); // 1 / pow(result_type(2), bits); return continued_fraction_b(g, factor, max_terms); } // // continued_fraction_a // Evaluates: // // a1 // --------------- // b1 + a2 // ---------- // b2 + a3 // ----- // b3 + ... // // Note that the first a1 and b1 returned by generator Gen are both used. // template inline typename detail::fraction_traits::result_type continued_fraction_a(Gen& g, const U& factor, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { BOOST_MATH_STD_USING // ADL of std names typedef detail::fraction_traits traits; typedef typename traits::result_type result_type; typedef typename traits::value_type value_type; typedef typename integer_scalar_type::type integer_type; typedef typename scalar_type::type scalar_type; integer_type const zero(0), one(1); result_type tiny = detail::tiny_value::get(); scalar_type terminator = abs(factor); value_type v = g(); result_type f, C, D, delta, a0; f = traits::b(v); a0 = traits::a(v); if(f == zero) f = tiny; C = f; D = 0; boost::uintmax_t counter(max_terms); do{ v = g(); D = traits::b(v) + traits::a(v) * D; if(D == zero) D = tiny; C = traits::b(v) + traits::a(v) / C; if(C == zero) C = tiny; D = one/D; delta = C*D; f = f * delta; }while((abs(delta - one) > terminator) && --counter); max_terms = max_terms - counter; return a0/f; } template inline typename detail::fraction_traits::result_type continued_fraction_a(Gen& g, const U& factor) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { boost::uintmax_t max_iter = (std::numeric_limits::max)(); return continued_fraction_a(g, factor, max_iter); } template inline typename detail::fraction_traits::result_type continued_fraction_a(Gen& g, int bits) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { BOOST_MATH_STD_USING // ADL of std names typedef detail::fraction_traits traits; typedef typename traits::result_type result_type; result_type factor = ldexp(1.0f, 1-bits); // 1 / pow(result_type(2), bits); boost::uintmax_t max_iter = (std::numeric_limits::max)(); return continued_fraction_a(g, factor, max_iter); } template inline typename detail::fraction_traits::result_type continued_fraction_a(Gen& g, int bits, boost::uintmax_t& max_terms) BOOST_NOEXCEPT_IF(BOOST_MATH_IS_FLOAT(typename detail::fraction_traits::result_type) && noexcept(std::declval()())) { BOOST_MATH_STD_USING // ADL of std names typedef detail::fraction_traits traits; typedef typename traits::result_type result_type; result_type factor = ldexp(1.0f, 1-bits); // 1 / pow(result_type(2), bits); return continued_fraction_a(g, factor, max_terms); } } // namespace tools } // namespace math } // namespace boost #endif // BOOST_MATH_TOOLS_FRACTION_INCLUDED