|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r77344 - in sandbox/big_number: boost/multiprecision libs/multiprecision/doc libs/multiprecision/doc/html libs/multiprecision/doc/html/boost_multiprecision libs/multiprecision/doc/html/boost_multiprecision/tut libs/multiprecision/example libs/multiprecision/performance
From: john_at_[hidden]
Date: 2012-03-15 14:41:01
Author: johnmaddock
Date: 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
New Revision: 77344
URL: http://svn.boost.org/trac/boost/changeset/77344
Log:
Add random number support.
Added:
sandbox/big_number/boost/multiprecision/random.hpp (contents, props changed)
sandbox/big_number/libs/multiprecision/example/random_snips.cpp (contents, props changed)
Text files modified:
sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/ref.html | 6
sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut.html | 1
sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html | 6
sandbox/big_number/libs/multiprecision/doc/html/index.html | 3
sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk | 32 +
sandbox/big_number/libs/multiprecision/performance/performance_test-gcc-linux.log | 841 ++++++++++++++++++++++++++++++++++-----
6 files changed, 759 insertions(+), 130 deletions(-)
Added: sandbox/big_number/boost/multiprecision/random.hpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/boost/multiprecision/random.hpp 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -0,0 +1,559 @@
+///////////////////////////////////////////////////////////////
+// Copyright 2012 John Maddock. 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_
+
+#ifndef BOOST_MP_RANDOM_HPP
+#define BOOST_MP_RANDOM_HPP
+
+#include <boost/multiprecision/mp_number.hpp>
+#include <boost/random.hpp>
+#include <boost/mpl/eval_if.hpp>
+
+namespace boost{
+namespace random{
+namespace detail{
+
+template<class Backend, bool ExpressionTemplates>
+struct subtract<boost::multiprecision::mp_number<Backend, ExpressionTemplates>, true>
+{
+ typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+ result_type operator()(result_type const& x, result_type const& y) { return x - y; }
+};
+
+}
+
+template<class Engine, std::size_t w, class Backend, bool ExpressionTemplates>
+class independent_bits_engine<Engine, w, boost::multiprecision::mp_number<Backend, ExpressionTemplates> >
+{
+public:
+ typedef Engine base_type;
+ typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+
+ static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+ { return 0; }
+ // This is the only function we modify compared to the primary template:
+ static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+ { return (result_type(1) << w) - 1; }
+
+ independent_bits_engine() { }
+
+ BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(independent_bits_engine,
+ result_type, seed_arg)
+ {
+ _base.seed(seed_arg);
+ }
+
+ BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(independent_bits_engine,
+ SeedSeq, seq)
+ { _base.seed(seq); }
+
+ independent_bits_engine(const base_type& base_arg) : _base(base_arg) {}
+
+ template<class It>
+ independent_bits_engine(It& first, It last) : _base(first, last) { }
+
+ void seed() { _base.seed(); }
+
+ BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(independent_bits_engine,
+ result_type, seed_arg)
+ { _base.seed(seed_arg); }
+
+ BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(independent_bits_engine,
+ SeedSeq, seq)
+ { _base.seed(seq); }
+
+ template<class It> void seed(It& first, It last)
+ { _base.seed(first, last); }
+
+ result_type operator()()
+ {
+ // While it may seem wasteful to recalculate this
+ // every time, both msvc and gcc can propagate
+ // constants, resolving this at compile time.
+ base_unsigned range =
+ detail::subtract<base_result>()((_base.max)(), (_base.min)());
+ std::size_t m =
+ (range == (std::numeric_limits<base_unsigned>::max)()) ?
+ std::numeric_limits<base_unsigned>::digits :
+ detail::integer_log2(range + 1);
+ std::size_t n = (w + m - 1) / m;
+ std::size_t w0, n0;
+ base_unsigned y0, y1;
+ base_unsigned y0_mask, y1_mask;
+ calc_params(n, range, w0, n0, y0, y1, y0_mask, y1_mask);
+ if(base_unsigned(range - y0 + 1) > y0 / n) {
+ // increment n and try again.
+ ++n;
+ calc_params(n, range, w0, n0, y0, y1, y0_mask, y1_mask);
+ }
+
+ BOOST_ASSERT(n0*w0 + (n - n0)*(w0 + 1) == w);
+
+ result_type S = 0;
+ for(std::size_t k = 0; k < n0; ++k) {
+ base_unsigned u;
+ do {
+ u = detail::subtract<base_result>()(_base(), (_base.min)());
+ } while(u > base_unsigned(y0 - 1));
+ S = (S << w0) + (u & y0_mask);
+ }
+ for(std::size_t k = 0; k < (n - n0); ++k) {
+ base_unsigned u;
+ do {
+ u = detail::subtract<base_result>()(_base(), (_base.min)());
+ } while(u > base_unsigned(y1 - 1));
+ S = (S << (w0 + 1)) + (u & y1_mask);
+ }
+ return S;
+ }
+
+ /** Fills a range with random values */
+ template<class Iter>
+ void generate(Iter first, Iter last)
+ { detail::generate_from_int(*this, first, last); }
+
+ /** Advances the state of the generator by @c z. */
+ void discard(boost::uintmax_t z)
+ {
+ for(boost::uintmax_t i = 0; i < z; ++i) {
+ (*this)();
+ }
+ }
+
+ const base_type& base() const { return _base; }
+
+ /**
+ * Writes the textual representation if the generator to a @c std::ostream.
+ * The textual representation of the engine is the textual representation
+ * of the base engine.
+ */
+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, independent_bits_engine, r)
+ {
+ os << r._base;
+ return os;
+ }
+
+ /**
+ * Reads the state of an @c independent_bits_engine from a
+ * @c std::istream.
+ */
+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, independent_bits_engine, r)
+ {
+ is >> r._base;
+ return is;
+ }
+
+ /**
+ * Returns: true iff the two @c independent_bits_engines will
+ * produce the same sequence of values.
+ */
+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(independent_bits_engine, x, y)
+ { return x._base == y._base; }
+ /**
+ * Returns: true iff the two @c independent_bits_engines will
+ * produce different sequences of values.
+ */
+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(independent_bits_engine)
+
+private:
+
+ /// \cond show_private
+ typedef typename base_type::result_type base_result;
+ typedef typename make_unsigned<base_result>::type base_unsigned;
+
+ void calc_params(
+ std::size_t n, base_unsigned range,
+ std::size_t& w0, std::size_t& n0,
+ base_unsigned& y0, base_unsigned& y1,
+ base_unsigned& y0_mask, base_unsigned& y1_mask)
+ {
+ BOOST_ASSERT(w >= n);
+ w0 = w/n;
+ n0 = n - w % n;
+ y0_mask = (base_unsigned(2) << (w0 - 1)) - 1;
+ y1_mask = (y0_mask << 1) | 1;
+ y0 = (range + 1) & ~y0_mask;
+ y1 = (range + 1) & ~y1_mask;
+ BOOST_ASSERT(y0 != 0 || base_unsigned(range + 1) == 0);
+ }
+ /// \endcond
+
+ Engine _base;
+};
+
+template<class Backend, bool ExpressionTemplates>
+class uniform_smallint<boost::multiprecision::mp_number<Backend, ExpressionTemplates> >
+{
+public:
+ typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> input_type;
+ typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+
+ class param_type
+ {
+ public:
+
+ typedef uniform_smallint distribution_type;
+
+ /** constructs the parameters of a @c uniform_smallint distribution. */
+ param_type(result_type const& min_arg = 0, result_type const& max_arg = 9)
+ : _min(min_arg), _max(max_arg)
+ {
+ BOOST_ASSERT(_min <= _max);
+ }
+
+ /** Returns the minimum value. */
+ result_type a() const { return _min; }
+ /** Returns the maximum value. */
+ result_type b() const { return _max; }
+
+
+ /** Writes the parameters to a @c std::ostream. */
+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, param_type, parm)
+ {
+ os << parm._min << " " << parm._max;
+ return os;
+ }
+
+ /** Reads the parameters from a @c std::istream. */
+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, param_type, parm)
+ {
+ is >> parm._min >> std::ws >> parm._max;
+ return is;
+ }
+
+ /** Returns true if the two sets of parameters are equal. */
+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(param_type, lhs, rhs)
+ { return lhs._min == rhs._min && lhs._max == rhs._max; }
+
+ /** Returns true if the two sets of parameters are different. */
+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
+
+ private:
+ result_type _min;
+ result_type _max;
+ };
+
+ /**
+ * Constructs a @c uniform_smallint. @c min and @c max are the
+ * lower and upper bounds of the output range, respectively.
+ */
+ explicit uniform_smallint(result_type const& min_arg = 0, result_type const& max_arg = 9)
+ : _min(min_arg), _max(max_arg) {}
+
+ /**
+ * Constructs a @c uniform_smallint from its parameters.
+ */
+ explicit uniform_smallint(const param_type& parm)
+ : _min(parm.a()), _max(parm.b()) {}
+
+ /** Returns the minimum value of the distribution. */
+ result_type a() const { return _min; }
+ /** Returns the maximum value of the distribution. */
+ result_type b() const { return _max; }
+ /** Returns the minimum value of the distribution. */
+ result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
+ /** Returns the maximum value of the distribution. */
+ result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
+
+ /** Returns the parameters of the distribution. */
+ param_type param() const { return param_type(_min, _max); }
+ /** Sets the parameters of the distribution. */
+ void param(const param_type& parm)
+ {
+ _min = parm.a();
+ _max = parm.b();
+ }
+
+ /**
+ * Effects: Subsequent uses of the distribution do not depend
+ * on values produced by any engine prior to invoking reset.
+ */
+ void reset() { }
+
+ /** Returns a value uniformly distributed in the range [min(), max()]. */
+ template<class Engine>
+ result_type operator()(Engine& eng) const
+ {
+ typedef typename Engine::result_type base_result;
+ return generate(eng, boost::is_integral<base_result>());
+ }
+
+ /** Returns a value uniformly distributed in the range [param.a(), param.b()]. */
+ template<class Engine>
+ result_type operator()(Engine& eng, const param_type& parm) const
+ { return uniform_smallint(parm)(eng); }
+
+ /** Writes the distribution to a @c std::ostream. */
+ BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, uniform_smallint, ud)
+ {
+ os << ud._min << " " << ud._max;
+ return os;
+ }
+
+ /** Reads the distribution from a @c std::istream. */
+ BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, uniform_smallint, ud)
+ {
+ is >> ud._min >> std::ws >> ud._max;
+ return is;
+ }
+
+ /**
+ * Returns true if the two distributions will produce identical
+ * sequences of values given equal generators.
+ */
+ BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(uniform_smallint, lhs, rhs)
+ { return lhs._min == rhs._min && lhs._max == rhs._max; }
+
+ /**
+ * Returns true if the two distributions may produce different
+ * sequences of values given equal generators.
+ */
+ BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(uniform_smallint)
+
+private:
+
+ // \cond show_private
+ template<class Engine>
+ result_type generate(Engine& eng, boost::mpl::true_) const
+ {
+ // equivalent to (eng() - eng.min()) % (_max - _min + 1) + _min,
+ // but guarantees no overflow.
+ typedef typename Engine::result_type base_result;
+ typedef typename boost::make_unsigned<base_result>::type base_unsigned;
+ typedef result_type range_type;
+ range_type range = random::detail::subtract<result_type>()(_max, _min);
+ base_unsigned base_range =
+ random::detail::subtract<result_type>()((eng.max)(), (eng.min)());
+ base_unsigned val =
+ random::detail::subtract<base_result>()(eng(), (eng.min)());
+ if(range >= base_range) {
+ return boost::random::detail::add<range_type, result_type>()(
+ static_cast<range_type>(val), _min);
+ } else {
+ base_unsigned modulus = static_cast<base_unsigned>(range) + 1;
+ return boost::random::detail::add<range_type, result_type>()(
+ static_cast<range_type>(val % modulus), _min);
+ }
+ }
+
+ template<class Engine>
+ result_type generate(Engine& eng, boost::mpl::false_) const
+ {
+ typedef typename Engine::result_type base_result;
+ typedef result_type range_type;
+ range_type range = random::detail::subtract<result_type>()(_max, _min);
+ base_result val = boost::uniform_01<base_result>()(eng);
+ // what is the worst that can possibly happen here?
+ // base_result may not be able to represent all the values in [0, range]
+ // exactly. If this happens, it will cause round off error and we
+ // won't be able to produce all the values in the range. We don't
+ // care about this because the user has already told us not to by
+ // using uniform_smallint. However, we do need to be careful
+ // to clamp the result, or floating point rounding can produce
+ // an out of range result.
+ range_type offset = static_cast<range_type>(val * (range + 1));
+ if(offset > range) return _max;
+ return boost::random::detail::add<range_type, result_type>()(offset , _min);
+ }
+ // \endcond
+
+ result_type _min;
+ result_type _max;
+};
+
+
+namespace detail{
+
+template<class Backend, bool ExpressionTemplates>
+struct select_uniform_01<boost::multiprecision::mp_number<Backend, ExpressionTemplates> >
+{
+ template<class RealType>
+ struct apply
+ {
+ typedef new_uniform_01<boost::multiprecision::mp_number<Backend, ExpressionTemplates> > type;
+ };
+};
+
+template<class Engine, class Backend, bool ExpressionTemplates>
+boost::multiprecision::mp_number<Backend, ExpressionTemplates>
+ generate_uniform_int(
+ Engine& eng, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& max_value,
+ boost::mpl::true_ /** is_integral<Engine::result_type> */)
+{
+ typedef boost::multiprecision::mp_number<Backend, ExpressionTemplates> result_type;
+ // Since we're using big-numbers, use the result type for all internal calculations:
+ typedef result_type range_type;
+ typedef result_type base_result;
+ typedef result_type base_unsigned;
+ const range_type range = random::detail::subtract<result_type>()(max_value, min_value);
+ const base_result bmin = (eng.min)();
+ const base_unsigned brange =
+ random::detail::subtract<base_result>()((eng.max)(), (eng.min)());
+
+ if(range == 0) {
+ return min_value;
+ } else if(brange == range) {
+ // this will probably never happen in real life
+ // basically nothing to do; just take care we don't overflow / underflow
+ base_unsigned v = random::detail::subtract<base_result>()(eng(), bmin);
+ return random::detail::add<base_unsigned, result_type>()(v, min_value);
+ } else if(brange < range) {
+ // use rejection method to handle things like 0..3 --> 0..4
+ for(;;) {
+ // concatenate several invocations of the base RNG
+ // take extra care to avoid overflows
+
+ // limit == floor((range+1)/(brange+1))
+ // Therefore limit*(brange+1) <= range+1
+ range_type limit;
+ if(std::numeric_limits<range_type>::is_bounded && (range == (std::numeric_limits<range_type>::max)())) {
+ limit = range/(range_type(brange)+1);
+ if(range % (range_type(brange)+1) == range_type(brange))
+ ++limit;
+ } else {
+ limit = (range+1)/(range_type(brange)+1);
+ }
+
+ // We consider "result" as expressed to base (brange+1):
+ // For every power of (brange+1), we determine a random factor
+ range_type result = range_type(0);
+ range_type mult = range_type(1);
+
+ // loop invariants:
+ // result < mult
+ // mult <= range
+ while(mult <= limit) {
+ // Postcondition: result <= range, thus no overflow
+ //
+ // limit*(brange+1)<=range+1 def. of limit (1)
+ // eng()-bmin<=brange eng() post. (2)
+ // and mult<=limit. loop condition (3)
+ // Therefore mult*(eng()-bmin+1)<=range+1 by (1),(2),(3) (4)
+ // Therefore mult*(eng()-bmin)+mult<=range+1 rearranging (4) (5)
+ // result<mult loop invariant (6)
+ // Therefore result+mult*(eng()-bmin)<range+1 by (5), (6) (7)
+ //
+ // Postcondition: result < mult*(brange+1)
+ //
+ // result<mult loop invariant (1)
+ // eng()-bmin<=brange eng() post. (2)
+ // Therefore result+mult*(eng()-bmin) <
+ // mult+mult*(eng()-bmin) by (1) (3)
+ // Therefore result+(eng()-bmin)*mult <
+ // mult+mult*brange by (2), (3) (4)
+ // Therefore result+(eng()-bmin)*mult <
+ // mult*(brange+1) by (4)
+ result += static_cast<range_type>(random::detail::subtract<base_result>()(eng(), bmin) * mult);
+
+ // equivalent to (mult * (brange+1)) == range+1, but avoids overflow.
+ if(mult * range_type(brange) == range - mult + 1) {
+ // The destination range is an integer power of
+ // the generator's range.
+ return(result);
+ }
+
+ // Postcondition: mult <= range
+ //
+ // limit*(brange+1)<=range+1 def. of limit (1)
+ // mult<=limit loop condition (2)
+ // Therefore mult*(brange+1)<=range+1 by (1), (2) (3)
+ // mult*(brange+1)!=range+1 preceding if (4)
+ // Therefore mult*(brange+1)<range+1 by (3), (4) (5)
+ //
+ // Postcondition: result < mult
+ //
+ // See the second postcondition on the change to result.
+ mult *= range_type(brange)+range_type(1);
+ }
+ // loop postcondition: range/mult < brange+1
+ //
+ // mult > limit loop condition (1)
+ // Suppose range/mult >= brange+1 Assumption (2)
+ // range >= mult*(brange+1) by (2) (3)
+ // range+1 > mult*(brange+1) by (3) (4)
+ // range+1 > (limit+1)*(brange+1) by (1), (4) (5)
+ // (range+1)/(brange+1) > limit+1 by (5) (6)
+ // limit < floor((range+1)/(brange+1)) by (6) (7)
+ // limit==floor((range+1)/(brange+1)) def. of limit (8)
+ // not (2) reductio (9)
+ //
+ // loop postcondition: (range/mult)*mult+(mult-1) >= range
+ //
+ // (range/mult)*mult + range%mult == range identity (1)
+ // range%mult < mult def. of % (2)
+ // (range/mult)*mult+mult > range by (1), (2) (3)
+ // (range/mult)*mult+(mult-1) >= range by (3) (4)
+ //
+ // Note that the maximum value of result at this point is (mult-1),
+ // so after this final step, we generate numbers that can be
+ // at least as large as range. We have to really careful to avoid
+ // overflow in this final addition and in the rejection. Anything
+ // that overflows is larger than range and can thus be rejected.
+
+ // range/mult < brange+1 -> no endless loop
+ range_type result_increment =
+ generate_uniform_int(
+ eng,
+ static_cast<range_type>(0),
+ static_cast<range_type>(range/mult),
+ boost::mpl::true_());
+ if(std::numeric_limits<range_type>::is_bounded && ((std::numeric_limits<range_type>::max)() / mult < result_increment)) {
+ // The multiplcation would overflow. Reject immediately.
+ continue;
+ }
+ result_increment *= mult;
+ // unsigned integers are guaranteed to wrap on overflow.
+ result += result_increment;
+ if(result < result_increment) {
+ // The addition overflowed. Reject.
+ continue;
+ }
+ if(result > range) {
+ // Too big. Reject.
+ continue;
+ }
+ return random::detail::add<range_type, result_type>()(result, min_value);
+ }
+ } else { // brange > range
+ range_type bucket_size;
+ // it's safe to add 1 to range, as long as we cast it first,
+ // because we know that it is less than brange. However,
+ // we do need to be careful not to cause overflow by adding 1
+ // to brange.
+ if(std::numeric_limits<base_unsigned>::is_bounded && (brange == (std::numeric_limits<base_unsigned>::max)())) {
+ bucket_size = brange / (range+1);
+ if(brange % (range+1) == range) {
+ ++bucket_size;
+ }
+ } else {
+ bucket_size = (brange+1) / (range+1);
+ }
+ for(;;) {
+ range_type result =
+ random::detail::subtract<base_result>()(eng(), bmin);
+ result /= bucket_size;
+ // result and range are non-negative, and result is possibly larger
+ // than range, so the cast is safe
+ if(result <= range)
+ return result + min_value;
+ }
+ }
+}
+
+template<class Engine, class Backend, bool ExpressionTemplates>
+inline boost::multiprecision::mp_number<Backend, ExpressionTemplates>
+ generate_uniform_int(Engine& eng, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& min_value, const boost::multiprecision::mp_number<Backend, ExpressionTemplates>& max_value)
+{
+ typedef typename Engine::result_type base_result;
+ typedef typename mpl::or_<boost::is_integral<base_result>, mpl::bool_<boost::multiprecision::number_category<Backend>::value == boost::multiprecision::number_kind_integer> >::type tag_type;
+ return generate_uniform_int(eng, min_value, max_value,
+ tag_type());
+}
+
+} // detail
+
+
+}} // namespaces
+
+#endif
Modified: sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/ref.html
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/ref.html (original)
+++ sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/ref.html 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -6,12 +6,12 @@
<meta name="generator" content="DocBook XSL Stylesheets V1.76.1">
<link rel="home" href="../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../index.html" title="Chapter 1. Boost.Multiprecision">
-<link rel="prev" href="tut/rational.html" title="Rational Number Types">
+<link rel="prev" href="tut/random.html" title="Generating Random Numbers">
<link rel="next" href="ref/mp_number.html" title="mp_number">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="spirit-nav">
-<a accesskey="p" href="tut/rational.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="ref/mp_number.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="tut/random.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="ref/mp_number.html"><img src="../images/next.png" alt="Next"></a>
</div>
<div class="section boost_multiprecision_ref">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
@@ -32,7 +32,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="tut/rational.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="ref/mp_number.html"><img src="../images/next.png" alt="Next"></a>
+<a accesskey="p" href="tut/random.html"><img src="../images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../images/home.png" alt="Home"></a><a accesskey="n" href="ref/mp_number.html"><img src="../images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut.html
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut.html (original)
+++ sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut.html 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -21,6 +21,7 @@
<dt><span class="section">Integer Types</span></dt>
<dt><span class="section">Floating Point Numbers</span></dt>
<dt><span class="section">Rational Number Types</span></dt>
+<dt><span class="section">Generating Random Numbers</span></dt>
</dl></div>
<p>
In order to use this library you need to make two choices: what kind of number
Modified: sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html (original)
+++ sandbox/big_number/libs/multiprecision/doc/html/boost_multiprecision/tut/rational.html 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -7,11 +7,11 @@
<link rel="home" href="../../index.html" title="Chapter 1. Boost.Multiprecision">
<link rel="up" href="../tut.html" title="Tutorial">
<link rel="prev" href="reals.html" title="Floating Point Numbers">
-<link rel="next" href="../ref.html" title="Reference">
+<link rel="next" href="random.html" title="Generating Random Numbers">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<div class="spirit-nav">
-<a accesskey="p" href="reals.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="reals.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="random.html"><img src="../../images/next.png" alt="Next"></a>
</div>
<div class="section boost_multiprecision_tut_rational">
<div class="titlepage"><div><div><h3 class="title">
@@ -539,7 +539,7 @@
</tr></table>
<hr>
<div class="spirit-nav">
-<a accesskey="p" href="reals.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="../ref.html"><img src="../../images/next.png" alt="Next"></a>
+<a accesskey="p" href="reals.html"><img src="../../images/prev.png" alt="Prev"></a><a accesskey="u" href="../tut.html"><img src="../../images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../images/home.png" alt="Home"></a><a accesskey="n" href="random.html"><img src="../../images/next.png" alt="Next"></a>
</div>
</body>
</html>
Modified: sandbox/big_number/libs/multiprecision/doc/html/index.html
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/html/index.html (original)
+++ sandbox/big_number/libs/multiprecision/doc/html/index.html 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -33,6 +33,7 @@
<dt><span class="section">Integer Types</span></dt>
<dt><span class="section">Floating Point Numbers</span></dt>
<dt><span class="section">Rational Number Types</span></dt>
+<dt><span class="section">Generating Random Numbers</span></dt>
</dl></dd>
<dt><span class="section">Reference</span></dt>
<dd><dl>
@@ -56,7 +57,7 @@
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: March 13, 2012 at 19:12:03 GMT</small></p></td>
+<td align="left"><p><small>Last revised: March 15, 2012 at 18:34:52 GMT</small></p></td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
Modified: sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk
==============================================================================
--- sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk (original)
+++ sandbox/big_number/libs/multiprecision/doc/multiprecision.qbk 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -23,6 +23,7 @@
[import ../example/cpp_dec_float_snips.cpp]
[import ../example/tommath_snips.cpp]
[import ../example/cpp_int_snips.cpp]
+[import ../example/random_snips.cpp]
[template mpfr[] [@http://www.mpfr.org MPFR]]
[template gmp[] [@http://gmplib.org GMP]]
@@ -666,6 +667,37 @@
[endsect]
+[section:random Generating Random Numbers]
+
+Random numbers are generated in conjunction with Boost.Random. However, since Boost.Random is unaware
+of arbitrary precision numbers, it's necessary to include the header:
+
+ #include <boost/multiprecision/random.hpp>
+
+In order to act as a bridge between the two libraries.
+
+Integers with /N/ random bits are generated using `independent_bits_engine`:
+
+[random_eg1]
+
+Alternatively we can generate integers in a given range using `uniform_int_distribution`, this will
+invoke the underlying engine multiple times to build up the required number of bits in the result:
+
+[random_eg2]
+
+Floating point values in \[0,1) are generated using `uniform_01`, the trick here is to ensure
+that the underlying generator produces as many random bits as there are digits in the floating
+point type. As above `independent_bits_engine` can be used for this purpose, note that we also have to
+convert decimal digits (in the floating point type) to bits (in the random number generator):
+
+[random_eg3]
+
+Finally, we can modify the above example to produce numbers distributed according to some distribution:
+
+[random_eg4]
+
+[endsect]
+
[endsect]
[section:ref Reference]
Added: sandbox/big_number/libs/multiprecision/example/random_snips.cpp
==============================================================================
--- (empty file)
+++ sandbox/big_number/libs/multiprecision/example/random_snips.cpp 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -0,0 +1,118 @@
+///////////////////////////////////////////////////////////////
+// Copyright 2011 John Maddock. 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_
+
+#include <boost/multiprecision/gmp.hpp>
+#include <boost/multiprecision/random.hpp>
+#include <iostream>
+#include <iomanip>
+
+void t1()
+{
+ //[random_eg1
+ //=#include <boost/multiprecision/gmp.hpp>
+ //=#include <boost/multiprecision/random.hpp>
+
+ using namespace boost::multiprecision;
+ using namespace boost::random;
+
+ //
+ // Declare our random number generator type, the underlying generator
+ // is the Mersenne twister mt19937 engine, and 256 bits are generated:
+ //
+ typedef independent_bits_engine<mt19937, 256, mpz_int> generator_type;
+ generator_type gen;
+ //
+ // Generate some values:
+ //
+ std::cout << std::hex << std::showbase;
+ for(unsigned i = 0; i < 10; ++i)
+ std::cout << gen() << std::endl;
+ //]
+}
+
+void t2()
+{
+ //[random_eg2
+ //=#include <boost/multiprecision/gmp.hpp>
+ //=#include <boost/multiprecision/random.hpp>
+
+ using namespace boost::multiprecision;
+ using namespace boost::random;
+
+ //
+ // Generate integers in a given range using uniform_int,
+ // the underlying generator is invoked multiple times
+ // to generate enough bits:
+ //
+ mt19937 mt;
+ uniform_int_distribution<mpz_int> ui(0, mpz_int(1) << 256);
+ //
+ // Generate the numbers:
+ //
+ std::cout << std::hex << std::showbase;
+ for(unsigned i = 0; i < 10; ++i)
+ std::cout << ui(mt) << std::endl;
+
+ //]
+}
+
+void t3()
+{
+ //[random_eg3
+ //=#include <boost/multiprecision/gmp.hpp>
+ //=#include <boost/multiprecision/random.hpp>
+
+ using namespace boost::multiprecision;
+ using namespace boost::random;
+ //
+ // We need an underlying generator with at least as many bits as the
+ // floating point type to generate numbers in [0, 1) with all the bits
+ // in the floating point type randomly filled:
+ //
+ uniform_01<mpf_float_50> uf;
+ independent_bits_engine<mt19937, 50L*1000L/301L, mpz_int> gen;
+ //
+ // Generate the values:
+ //
+ std::cout << std::setprecision(50);
+ for(unsigned i = 0; i < 20; ++i)
+ std::cout << uf(gen) << std::endl;
+ //]
+}
+
+void t4()
+{
+ //[random_eg4
+ //=#include <boost/multiprecision/gmp.hpp>
+ //=#include <boost/multiprecision/random.hpp>
+
+ using namespace boost::multiprecision;
+ using namespace boost::random;
+ //
+ // We can repeat the above example, with other distributions:
+ //
+ uniform_real_distribution<mpf_float_50> ur(-20, 20);
+ gamma_distribution<mpf_float_50> gd(20);
+ independent_bits_engine<mt19937, 50L*1000L/301L, mpz_int> gen;
+ //
+ // Generate some values:
+ //
+ std::cout << std::setprecision(50);
+ for(unsigned i = 0; i < 20; ++i)
+ std::cout << ur(gen) << std::endl;
+ for(unsigned i = 0; i < 20; ++i)
+ std::cout << gd(gen) << std::endl;
+ //]
+}
+
+int main()
+{
+ t1();
+ t2();
+ t3();
+ t4();
+ return 0;
+}
+
Modified: sandbox/big_number/libs/multiprecision/performance/performance_test-gcc-linux.log
==============================================================================
--- sandbox/big_number/libs/multiprecision/performance/performance_test-gcc-linux.log (original)
+++ sandbox/big_number/libs/multiprecision/performance/performance_test-gcc-linux.log 2012-03-15 14:41:00 EDT (Thu, 15 Mar 2012)
@@ -1,123 +1,718 @@
-gmp_int 64 + 0.0168163
-gmp_int 64 - 0.0186614
-gmp_int 64 * 0.0117134
-gmp_int 64 / 0.169732
-gmp_int 64 str 0.000328882
-gmp_int 64 +(int)0.00662982
-gmp_int 64 -(int)0.00709197
-gmp_int 64 *(int)0.0088044
-gmp_int 64 /(int)0.0460225
-gmp_int 64 % 0.158198
-gmp_int 64 | 0.00933212
-gmp_int 64 & 0.00941153
-gmp_int 64 ^ 0.0100066
-gmp_int 64 << 0.00917854
-gmp_int 64 >> 0.00925083
-gmp_int 64 %(int)0.0280589
-gmp_int 64 |(int)0.0400043
-gmp_int 64 &(int)0.0417312
-gmp_int 64 ^(int)0.040751
-gmp_int 64 gcd 0.176467
-gmp_int 128 + 0.0178204
-gmp_int 128 - 0.0189183
-gmp_int 128 * 0.0162167
-gmp_int 128 / 0.188989
-gmp_int 128 str 0.00036981
-gmp_int 128 +(int)0.00848453
-gmp_int 128 -(int)0.00871131
-gmp_int 128 *(int)0.0113603
-gmp_int 128 /(int)0.0532432
-gmp_int 128 % 0.156838
-gmp_int 128 | 0.0106143
-gmp_int 128 & 0.0112662
-gmp_int 128 ^ 0.0113
-gmp_int 128 << 0.0100873
-gmp_int 128 >> 0.0078452
-gmp_int 128 %(int)0.0347183
-gmp_int 128 |(int)0.0411793
-gmp_int 128 &(int)0.0429282
-gmp_int 128 ^(int)0.0423867
-gmp_int 128 gcd 0.433341
-gmp_int 256 + 0.0227099
-gmp_int 256 - 0.0253696
-gmp_int 256 * 0.0419669
-gmp_int 256 / 0.231062
-gmp_int 256 str 0.00059791
-gmp_int 256 +(int)0.011126
-gmp_int 256 -(int)0.0118753
-gmp_int 256 *(int)0.0134931
-gmp_int 256 /(int)0.0656163
-gmp_int 256 % 0.188537
-gmp_int 256 | 0.0128192
-gmp_int 256 & 0.0127349
-gmp_int 256 ^ 0.0133922
-gmp_int 256 << 0.0118988
-gmp_int 256 >> 0.00811877
-gmp_int 256 %(int)0.0471091
-gmp_int 256 |(int)0.042799
-gmp_int 256 &(int)0.0458343
-gmp_int 256 ^(int)0.043002
-gmp_int 256 gcd 2.06647
-gmp_int 512 + 0.0273102
-gmp_int 512 - 0.0317526
-gmp_int 512 * 0.0977565
-gmp_int 512 / 0.271981
-gmp_int 512 str 0.0012591
-gmp_int 512 +(int)0.0141478
-gmp_int 512 -(int)0.0148129
-gmp_int 512 *(int)0.0180329
-gmp_int 512 /(int)0.0904515
-gmp_int 512 % 0.22083
-gmp_int 512 | 0.020649
-gmp_int 512 & 0.0165353
-gmp_int 512 ^ 0.0222088
-gmp_int 512 << 0.0146297
-gmp_int 512 >> 0.0098618
-gmp_int 512 %(int)0.0601431
-gmp_int 512 |(int)0.0461385
-gmp_int 512 &(int)0.0469244
-gmp_int 512 ^(int)0.0460041
-gmp_int 512 gcd 4.68119
-gmp_int 1024 + 0.0392733
-gmp_int 1024 - 0.0423657
-gmp_int 1024 * 0.314956
-gmp_int 1024 / 0.351788
-gmp_int 1024 str 0.00268616
-gmp_int 1024 +(int)0.0187891
-gmp_int 1024 -(int)0.0194118
-gmp_int 1024 *(int)0.0259443
-gmp_int 1024 /(int)0.140347
-gmp_int 1024 % 0.283657
-gmp_int 1024 | 0.0242247
-gmp_int 1024 & 0.023592
-gmp_int 1024 ^ 0.0249
-gmp_int 1024 << 0.0204313
-gmp_int 1024 >> 0.0128395
-gmp_int 1024 %(int)0.0758694
-gmp_int 1024 |(int)0.0495895
-gmp_int 1024 &(int)0.0506897
-gmp_int 1024 ^(int)0.049433
-gmp_int 1024 gcd 10.1293
-cpp_int(fixed) 128 + 0.0181676
-cpp_int(fixed) 128 - 0.0184343
-cpp_int(fixed) 128 * 0.014376
-cpp_int(fixed) 128 / 0.202558
-cpp_int(fixed) 128 str 0.000652736
-cpp_int(fixed) 128 +(int)0.00948536
-cpp_int(fixed) 128 -(int)0.00886251
-cpp_int(fixed) 128 *(int)0.0173963
-cpp_int(fixed) 128 /(int)0.106251
-cpp_int(fixed) 128 % 0.20362
-cpp_int(fixed) 128 | 0.0137212
-cpp_int(fixed) 128 & 0.0144157
-cpp_int(fixed) 128 ^ 0.0137219
-cpp_int(fixed) 128 << 0.0125872
-cpp_int(fixed) 128 >> 0.00905059
-cpp_int(fixed) 128 %(int)0.109447
-cpp_int(fixed) 128 |(int)0.014533
-cpp_int(fixed) 128 &(int)0.0162133
-cpp_int(fixed) 128 ^(int)0.0131589
-cpp_int(fixed) 128 gcd 2.86508
-cpp_int(fixed) 256 + 0.0216349
-cpp_int(fixed) 256 - 0.0208758
-cpp_int(fixed) 256 * 0.0210219
+gmp_float 50 + 0.0180885
+gmp_float 50 - 0.0227712
+gmp_float 50 * 0.0567584
+gmp_float 50 / 0.289062
+gmp_float 50 str 0.00354863
+gmp_float 50 +(int)0.0129337
+gmp_float 50 -(int)0.0256267
+gmp_float 50 *(int)0.0197258
+gmp_float 50 /(int)0.087785
+gmp_float 100 + 0.0196977
+gmp_float 100 - 0.024745
+gmp_float 100 * 0.0972
+gmp_float 100 / 0.393792
+gmp_float 100 str 0.00528245
+gmp_float 100 +(int)0.0154802
+gmp_float 100 -(int)0.0242376
+gmp_float 100 *(int)0.0251239
+gmp_float 100 /(int)0.100588
+gmp_float 500 + 0.034133
+gmp_float 500 - 0.0411447
+gmp_float 500 * 0.938779
+gmp_float 500 / 1.5973
+gmp_float 500 str 0.0406575
+gmp_float 500 +(int)0.0220839
+gmp_float 500 -(int)0.0310849
+gmp_float 500 *(int)0.046899
+gmp_float 500 /(int)0.240511
+gmp_int 128 + 0.0236625
+gmp_int 128 - 0.0255431
+gmp_int 128 * 0.0164612
+gmp_int 128 / 0.20205
+gmp_int 128 str 0.000397397
+gmp_int 128 +(int)0.00907029
+gmp_int 128 -(int)0.0120936
+gmp_int 128 *(int)0.0139764
+gmp_int 128 /(int)0.061181
+gmp_int 128 % 0.167724
+gmp_int 128 | 0.0126627
+gmp_int 128 & 0.0129377
+gmp_int 128 ^ 0.0136018
+gmp_int 128 << 0.0109566
+gmp_int 128 >> 0.0107283
+gmp_int 128 %(int)0.0408971
+gmp_int 128 |(int)0.0463637
+gmp_int 128 &(int)0.0502028
+gmp_int 128 ^(int)0.047593
+gmp_int 128 gcd 0.452707
+gmp_int 256 + 0.0257277
+gmp_int 256 - 0.0314085
+gmp_int 256 * 0.0495293
+gmp_int 256 / 0.242695
+gmp_int 256 str 0.000617745
+gmp_int 256 +(int)0.0129046
+gmp_int 256 -(int)0.0163165
+gmp_int 256 *(int)0.0153128
+gmp_int 256 /(int)0.0730963
+gmp_int 256 % 0.203102
+gmp_int 256 | 0.0149383
+gmp_int 256 & 0.0170717
+gmp_int 256 ^ 0.0160796
+gmp_int 256 << 0.0146023
+gmp_int 256 >> 0.010293
+gmp_int 256 %(int)0.0525884
+gmp_int 256 |(int)0.0501017
+gmp_int 256 &(int)0.0508389
+gmp_int 256 ^(int)0.0498771
+gmp_int 256 gcd 2.17179
+gmp_int 512 + 0.0283556
+gmp_int 512 - 0.0398509
+gmp_int 512 * 0.104633
+gmp_int 512 / 0.294206
+gmp_int 512 str 0.00125749
+gmp_int 512 +(int)0.0156938
+gmp_int 512 -(int)0.0204795
+gmp_int 512 *(int)0.0190714
+gmp_int 512 /(int)0.09638
+gmp_int 512 % 0.23687
+gmp_int 512 | 0.0244134
+gmp_int 512 & 0.0209509
+gmp_int 512 ^ 0.0266707
+gmp_int 512 << 0.0178981
+gmp_int 512 >> 0.0122496
+gmp_int 512 %(int)0.0655264
+gmp_int 512 |(int)0.0536497
+gmp_int 512 &(int)0.0532932
+gmp_int 512 ^(int)0.0540655
+gmp_int 512 gcd 4.86569
+gmp_int 1024 + 0.0417292
+gmp_int 1024 - 0.0504965
+gmp_int 1024 * 0.330741
+gmp_int 1024 / 0.376529
+gmp_int 1024 str 0.00295526
+gmp_int 1024 +(int)0.0258726
+gmp_int 1024 -(int)0.0235972
+gmp_int 1024 *(int)0.0326542
+gmp_int 1024 /(int)0.148103
+gmp_int 1024 % 0.301177
+gmp_int 1024 | 0.0262977
+gmp_int 1024 & 0.0235786
+gmp_int 1024 ^ 0.0254182
+gmp_int 1024 << 0.0206225
+gmp_int 1024 >> 0.012848
+gmp_int 1024 %(int)0.0765616
+gmp_int 1024 |(int)0.0495613
+gmp_int 1024 &(int)0.0512979
+gmp_int 1024 ^(int)0.0491785
+gmp_int 1024 gcd 10.2899
+cpp_int 128 + 0.0226262
+cpp_int 128 - 0.0256171
+cpp_int 128 * 0.0363846
+cpp_int 128 / 0.227187
+cpp_int 128 str 0.000703371
+cpp_int 128 +(int)0.0156956
+cpp_int 128 -(int)0.0122229
+cpp_int 128 *(int)0.0257193
+cpp_int 128 /(int)0.129609
+cpp_int 128 % 0.226534
+cpp_int 128 | 0.0242976
+cpp_int 128 & 0.0244482
+cpp_int 128 ^ 0.0243197
+cpp_int 128 << 0.0182175
+cpp_int 128 >> 0.0215535
+cpp_int 128 %(int)0.181554
+cpp_int 128 |(int)0.0454215
+cpp_int 128 &(int)0.0426893
+cpp_int 128 ^(int)0.0404509
+cpp_int 128 gcd 4.16823
+cpp_int 256 + 0.0275581
+cpp_int 256 - 0.0305114
+cpp_int 256 * 0.100083
+cpp_int 256 / 0.467116
+cpp_int 256 str 0.00181769
+cpp_int 256 +(int)0.017033
+cpp_int 256 -(int)0.0143035
+cpp_int 256 *(int)0.0294836
+cpp_int 256 /(int)0.303922
+cpp_int 256 % 0.435207
+cpp_int 256 | 0.0281237
+cpp_int 256 & 0.028049
+cpp_int 256 ^ 0.0280192
+cpp_int 256 << 0.0210768
+cpp_int 256 >> 0.0175781
+cpp_int 256 %(int)0.279274
+cpp_int 256 |(int)0.0323883
+cpp_int 256 &(int)0.0338674
+cpp_int 256 ^(int)0.0299941
+cpp_int 256 gcd 8.51244
+cpp_int 512 + 0.033691
+cpp_int 512 - 0.0422701
+cpp_int 512 * 0.343683
+cpp_int 512 / 0.755608
+cpp_int 512 str 0.00434022
+cpp_int 512 +(int)0.0196755
+cpp_int 512 -(int)0.0171212
+cpp_int 512 *(int)0.039305
+cpp_int 512 /(int)0.535727
+cpp_int 512 % 0.719958
+cpp_int 512 | 0.0339623
+cpp_int 512 & 0.0342017
+cpp_int 512 ^ 0.033929
+cpp_int 512 << 0.0269161
+cpp_int 512 >> 0.0216914
+cpp_int 512 %(int)0.53345
+cpp_int 512 |(int)0.0324562
+cpp_int 512 &(int)0.0424884
+cpp_int 512 ^(int)0.0323887
+cpp_int 512 gcd 19.489
+cpp_int 1024 + 0.0456764
+cpp_int 1024 - 0.0574919
+cpp_int 1024 * 1.28548
+cpp_int 1024 / 1.30086
+cpp_int 1024 str 0.0122363
+cpp_int 1024 +(int)0.0241476
+cpp_int 1024 -(int)0.0212992
+cpp_int 1024 *(int)0.0540818
+cpp_int 1024 /(int)1.00179
+cpp_int 1024 % 1.27181
+cpp_int 1024 | 0.0457886
+cpp_int 1024 & 0.0456006
+cpp_int 1024 ^ 0.0456494
+cpp_int 1024 << 0.0394128
+cpp_int 1024 >> 0.0294462
+cpp_int 1024 %(int)0.962651
+cpp_int 1024 |(int)0.0372077
+cpp_int 1024 &(int)0.0577198
+cpp_int 1024 ^(int)0.0372218
+cpp_int 1024 gcd 47.7651
+cpp_int(fixed) 128 + 0.0183948
+cpp_int(fixed) 128 - 0.0182905
+cpp_int(fixed) 128 * 0.0201727
+cpp_int(fixed) 128 / 0.206852
+cpp_int(fixed) 128 str 0.000630107
+cpp_int(fixed) 128 +(int)0.00967714
+cpp_int(fixed) 128 -(int)0.00810627
+cpp_int(fixed) 128 *(int)0.0183201
+cpp_int(fixed) 128 /(int)0.111309
+cpp_int(fixed) 128 % 0.204164
+cpp_int(fixed) 128 | 0.0136789
+cpp_int(fixed) 128 & 0.0143848
+cpp_int(fixed) 128 ^ 0.0137773
+cpp_int(fixed) 128 << 0.0131154
+cpp_int(fixed) 128 >> 0.00912176
+cpp_int(fixed) 128 %(int)0.115583
+cpp_int(fixed) 128 |(int)0.0164462
+cpp_int(fixed) 128 &(int)0.0169816
+cpp_int(fixed) 128 ^(int)0.014607
+cpp_int(fixed) 128 gcd 2.87326
+cpp_int(fixed) 256 + 0.0217614
+cpp_int(fixed) 256 - 0.0208437
+cpp_int(fixed) 256 * 0.0385279
+cpp_int(fixed) 256 / 0.321272
+cpp_int(fixed) 256 str 0.00149991
+cpp_int(fixed) 256 +(int)0.0102395
+cpp_int(fixed) 256 -(int)0.00923316
+cpp_int(fixed) 256 *(int)0.021549
+cpp_int(fixed) 256 /(int)0.219146
+cpp_int(fixed) 256 % 0.321039
+cpp_int(fixed) 256 | 0.0154596
+cpp_int(fixed) 256 & 0.0156443
+cpp_int(fixed) 256 ^ 0.015493
+cpp_int(fixed) 256 << 0.0169546
+cpp_int(fixed) 256 >> 0.0114138
+cpp_int(fixed) 256 %(int)0.238857
+cpp_int(fixed) 256 |(int)0.015725
+cpp_int(fixed) 256 &(int)0.021641
+cpp_int(fixed) 256 ^(int)0.0163443
+cpp_int(fixed) 256 gcd 6.68597
+cpp_int(fixed) 512 + 0.0284799
+cpp_int(fixed) 512 - 0.028304
+cpp_int(fixed) 512 * 0.119904
+cpp_int(fixed) 512 / 0.616699
+cpp_int(fixed) 512 str 0.00415653
+cpp_int(fixed) 512 +(int)0.0122821
+cpp_int(fixed) 512 -(int)0.0110103
+cpp_int(fixed) 512 *(int)0.0283635
+cpp_int(fixed) 512 /(int)0.451373
+cpp_int(fixed) 512 % 0.620217
+cpp_int(fixed) 512 | 0.0189862
+cpp_int(fixed) 512 & 0.0192657
+cpp_int(fixed) 512 ^ 0.018973
+cpp_int(fixed) 512 << 0.0188263
+cpp_int(fixed) 512 >> 0.0152103
+cpp_int(fixed) 512 %(int)0.491398
+cpp_int(fixed) 512 |(int)0.0182191
+cpp_int(fixed) 512 &(int)0.0277722
+cpp_int(fixed) 512 ^(int)0.0182565
+cpp_int(fixed) 512 gcd 16.1788
+cpp_int(fixed) 1024 + 0.0396571
+cpp_int(fixed) 1024 - 0.0413187
+cpp_int(fixed) 1024 * 0.371065
+cpp_int(fixed) 1024 / 1.09072
+cpp_int(fixed) 1024 str 0.011546
+cpp_int(fixed) 1024 +(int)0.0254102
+cpp_int(fixed) 1024 -(int)0.020939
+cpp_int(fixed) 1024 *(int)0.0494233
+cpp_int(fixed) 1024 /(int)0.870306
+cpp_int(fixed) 1024 % 1.09888
+cpp_int(fixed) 1024 | 0.0393824
+cpp_int(fixed) 1024 & 0.0397966
+cpp_int(fixed) 1024 ^ 0.0394082
+cpp_int(fixed) 1024 << 0.0392477
+cpp_int(fixed) 1024 >> 0.0214742
+cpp_int(fixed) 1024 %(int)0.941513
+cpp_int(fixed) 1024 |(int)0.0304613
+cpp_int(fixed) 1024 &(int)0.0497983
+cpp_int(fixed) 1024 ^(int)0.0333848
+cpp_int(fixed) 1024 gcd 41.9178
+cpp_rational 128 + 8.33358
+cpp_rational 128 - 8.3543
+cpp_rational 128 * 15.3196
+cpp_rational 128 / 31.794
+cpp_rational 128 str 0.00980984
+cpp_rational 128 +(int)1.14042
+cpp_rational 128 -(int)1.13947
+cpp_rational 128 *(int)1.3425
+cpp_rational 128 /(int)1.35276
+cpp_rational 256 + 24.5753
+cpp_rational 256 - 24.3831
+cpp_rational 256 * 45.9283
+cpp_rational 256 / 80.7871
+cpp_rational 256 str 0.0288878
+cpp_rational 256 +(int)1.54697
+cpp_rational 256 -(int)1.55711
+cpp_rational 256 *(int)2.05921
+cpp_rational 256 /(int)2.12933
+cpp_rational 512 + 58.1983
+cpp_rational 512 - 58.3044
+cpp_rational 512 * 111.528
+cpp_rational 512 / 184.73
+cpp_rational 512 str 0.067039
+cpp_rational 512 +(int)1.83113
+cpp_rational 512 -(int)1.82889
+cpp_rational 512 *(int)2.75206
+cpp_rational 512 /(int)2.75885
+cpp_rational 1024 + 139.884
+cpp_rational 1024 - 139.665
+cpp_rational 1024 * 270.253
+cpp_rational 1024 / 436.471
+cpp_rational 1024 str 0.165057
+cpp_rational 1024 +(int)2.65768
+cpp_rational 1024 -(int)2.68279
+cpp_rational 1024 *(int)4.26866
+cpp_rational 1024 /(int)4.27228
+mpq_rational 128 + 0.518878
+mpq_rational 128 - 0.520249
+mpq_rational 128 * 0.940549
+mpq_rational 128 / 2.63335
+mpq_rational 128 str 0.000732008
+mpq_rational 128 +(int)0.145745
+mpq_rational 128 -(int)0.142505
+mpq_rational 128 *(int)0.173305
+mpq_rational 128 /(int)0.178914
+mpq_rational 256 + 2.2747
+mpq_rational 256 - 2.27886
+mpq_rational 256 * 4.27402
+mpq_rational 256 / 8.07149
+mpq_rational 256 str 0.00123256
+mpq_rational 256 +(int)0.164417
+mpq_rational 256 -(int)0.161741
+mpq_rational 256 *(int)0.193095
+mpq_rational 256 /(int)0.202255
+mpq_rational 512 + 5.09463
+mpq_rational 512 - 5.09757
+mpq_rational 512 * 9.6481
+mpq_rational 512 / 16.9064
+mpq_rational 512 str 0.00244388
+mpq_rational 512 +(int)0.202901
+mpq_rational 512 -(int)0.200644
+mpq_rational 512 *(int)0.248942
+mpq_rational 512 /(int)0.251928
+mpq_rational 1024 + 11.2492
+mpq_rational 1024 - 11.2528
+mpq_rational 1024 * 21.0227
+mpq_rational 1024 / 35.7647
+mpq_rational 1024 str 0.00559869
+mpq_rational 1024 +(int)0.287349
+mpq_rational 1024 -(int)0.28136
+mpq_rational 1024 *(int)0.337805
+mpq_rational 1024 /(int)0.351164
+tommath_int 128 + 0.0169999
+tommath_int 128 - 0.025088
+tommath_int 128 * 0.0608098
+tommath_int 128 / 1.14807
+tommath_int 128 str 0.00864677
+tommath_int 128 +(int)0.170239
+tommath_int 128 -(int)0.169805
+tommath_int 128 *(int)0.18998
+tommath_int 128 /(int)0.936106
+tommath_int 128 % 1.10993
+tommath_int 128 | 0.0742258
+tommath_int 128 & 0.0747022
+tommath_int 128 ^ 0.0734074
+tommath_int 128 << 0.0316344
+tommath_int 128 >> 0.139155
+tommath_int 128 %(int)0.871093
+tommath_int 128 |(int)0.249135
+tommath_int 128 &(int)0.224394
+tommath_int 128 ^(int)0.248407
+tommath_int 128 gcd 7.6073
+tommath_int 256 + 0.0191462
+tommath_int 256 - 0.0267191
+tommath_int 256 * 0.0843842
+tommath_int 256 / 1.34052
+tommath_int 256 str 0.0212684
+tommath_int 256 +(int)0.173633
+tommath_int 256 -(int)0.173084
+tommath_int 256 *(int)0.20074
+tommath_int 256 /(int)1.17192
+tommath_int 256 % 1.33781
+tommath_int 256 | 0.0740269
+tommath_int 256 & 0.0747001
+tommath_int 256 ^ 0.0741847
+tommath_int 256 << 0.0379471
+tommath_int 256 >> 0.14164
+tommath_int 256 %(int)1.52193
+tommath_int 256 |(int)0.251418
+tommath_int 256 &(int)0.230435
+tommath_int 256 ^(int)0.249516
+tommath_int 256 gcd 15.8851
+tommath_int 512 + 0.0241933
+tommath_int 512 - 0.032154
+tommath_int 512 * 0.195855
+tommath_int 512 / 2.061
+tommath_int 512 str 0.0827649
+tommath_int 512 +(int)0.25223
+tommath_int 512 -(int)0.25482
+tommath_int 512 *(int)0.305608
+tommath_int 512 /(int)1.76155
+tommath_int 512 % 1.97453
+tommath_int 512 | 0.0795209
+tommath_int 512 & 0.0815029
+tommath_int 512 ^ 0.0793004
+tommath_int 512 << 0.0449753
+tommath_int 512 >> 0.149597
+tommath_int 512 %(int)1.74258
+tommath_int 512 |(int)0.253519
+tommath_int 512 &(int)0.235246
+tommath_int 512 ^(int)0.261762
+tommath_int 512 gcd 33.8904
+tommath_int 1024 + 0.0356467
+tommath_int 1024 - 0.0426379
+tommath_int 1024 * 0.563154
+tommath_int 1024 / 3.3106
+tommath_int 1024 str 0.200351
+tommath_int 1024 +(int)0.183982
+tommath_int 1024 -(int)0.182348
+tommath_int 1024 *(int)0.265242
+tommath_int 1024 /(int)2.99248
+tommath_int 1024 % 3.36442
+tommath_int 1024 | 0.0935681
+tommath_int 1024 & 0.0990244
+tommath_int 1024 ^ 0.0948247
+tommath_int 1024 << 0.0671463
+tommath_int 1024 >> 0.167341
+tommath_int 1024 %(int)2.8911
+tommath_int 1024 |(int)0.26358
+tommath_int 1024 &(int)0.244976
+tommath_int 1024 ^(int)0.261357
+tommath_int 1024 gcd 67.1657
+cpp_dec_float 50 + 0.0139248
+cpp_dec_float 50 - 0.0142418
+cpp_dec_float 50 * 0.118247
+cpp_dec_float 50 / 1.82747
+cpp_dec_float 50 str 0.00932849
+cpp_dec_float 50 +(int)0.0253923
+cpp_dec_float 50 -(int)0.0248418
+cpp_dec_float 50 *(int)0.0371704
+cpp_dec_float 50 /(int)0.199883
+cpp_dec_float 100 + 0.0171021
+cpp_dec_float 100 - 0.0176287
+cpp_dec_float 100 * 0.237033
+cpp_dec_float 100 / 3.63766
+cpp_dec_float 100 str 0.0201057
+cpp_dec_float 100 +(int)0.0330663
+cpp_dec_float 100 -(int)0.0332922
+cpp_dec_float 100 *(int)0.0606472
+cpp_dec_float 100 /(int)0.343778
+cpp_dec_float 500 + 0.043194
+cpp_dec_float 500 - 0.0443422
+cpp_dec_float 500 * 2.12299
+cpp_dec_float 500 / 25.7245
+cpp_dec_float 500 str 0.0655127
+cpp_dec_float 500 +(int)0.0706977
+cpp_dec_float 500 -(int)0.0727089
+cpp_dec_float 500 *(int)0.239796
+cpp_dec_float 500 /(int)1.39609
+mpfr_float 50 + 0.019179
+mpfr_float 50 - 0.0225632
+mpfr_float 50 * 0.0588765
+mpfr_float 50 / 0.317276
+mpfr_float 50 str 0.00725414
+mpfr_float 50 +(int)0.0286079
+mpfr_float 50 -(int)0.0465151
+mpfr_float 50 *(int)0.0362579
+mpfr_float 50 /(int)0.0888645
+mpfr_float 100 + 0.0210236
+mpfr_float 100 - 0.0250703
+mpfr_float 100 * 0.0946262
+mpfr_float 100 / 0.456375
+mpfr_float 100 str 0.00900848
+mpfr_float 100 +(int)0.0320443
+mpfr_float 100 -(int)0.0487733
+mpfr_float 100 *(int)0.0437034
+mpfr_float 100 /(int)0.154203
+mpfr_float 500 + 0.033691
+mpfr_float 500 - 0.0371954
+mpfr_float 500 * 0.851721
+mpfr_float 500 / 2.7946
+mpfr_float 500 str 0.0342011
+mpfr_float 500 +(int)0.0414774
+mpfr_float 500 -(int)0.0616173
+mpfr_float 500 *(int)0.0826485
+mpfr_float 500 /(int)0.254227
+[section:float_performance Float Type Perfomance]
+[table Operator *
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][2.08334 (0.118247s)][2.50494 (0.237033s)][2.49259 (2.12299s)]]
+[[gmp_float][[*1] (0.0567584s)][1.0272 (0.0972s)][1.10221 (0.938779s)]]
+[[mpfr_float][1.03732 (0.0588765s)][[*1] (0.0946262s)][[*1] (0.851721s)]]
+]
+[table Operator *(int)
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][1.88436 (0.0371704s)][2.41392 (0.0606472s)][5.11303 (0.239796s)]]
+[[gmp_float][[*1] (0.0197258s)][[*1] (0.0251239s)][[*1] (0.046899s)]]
+[[mpfr_float][1.8381 (0.0362579s)][1.73951 (0.0437034s)][1.76227 (0.0826485s)]]
+]
+[table Operator +
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][[*1] (0.0139248s)][[*1] (0.0171021s)][1.28206 (0.043194s)]]
+[[gmp_float][1.29901 (0.0180885s)][1.15177 (0.0196977s)][1.01312 (0.034133s)]]
+[[mpfr_float][1.37732 (0.019179s)][1.2293 (0.0210236s)][[*1] (0.033691s)]]
+]
+[table Operator +(int)
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][1.96327 (0.0253923s)][2.13604 (0.0330663s)][3.20133 (0.0706977s)]]
+[[gmp_float][[*1] (0.0129337s)][[*1] (0.0154802s)][[*1] (0.0220839s)]]
+[[mpfr_float][2.21189 (0.0286079s)][2.07002 (0.0320443s)][1.87818 (0.0414774s)]]
+]
+[table Operator -
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][[*1] (0.0142418s)][[*1] (0.0176287s)][1.19214 (0.0443422s)]]
+[[gmp_float][1.5989 (0.0227712s)][1.40368 (0.024745s)][1.10618 (0.0411447s)]]
+[[mpfr_float][1.5843 (0.0225632s)][1.42213 (0.0250703s)][[*1] (0.0371954s)]]
+]
+[table Operator -(int)
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][[*1] (0.0248418s)][1.37357 (0.0332922s)][2.33904 (0.0727089s)]]
+[[gmp_float][1.03159 (0.0256267s)][[*1] (0.0242376s)][[*1] (0.0310849s)]]
+[[mpfr_float][1.87245 (0.0465151s)][2.0123 (0.0487733s)][1.98223 (0.0616173s)]]
+]
+[table Operator /
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][6.32206 (1.82747s)][9.23752 (3.63766s)][16.1049 (25.7245s)]]
+[[gmp_float][[*1] (0.289062s)][[*1] (0.393792s)][[*1] (1.5973s)]]
+[[mpfr_float][1.09761 (0.317276s)][1.15892 (0.456375s)][1.74957 (2.7946s)]]
+]
+[table Operator /(int)
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][2.27696 (0.199883s)][3.41769 (0.343778s)][5.8047 (1.39609s)]]
+[[gmp_float][[*1] (0.087785s)][[*1] (0.100588s)][[*1] (0.240511s)]]
+[[mpfr_float][1.0123 (0.0888645s)][1.53302 (0.154203s)][1.05703 (0.254227s)]]
+]
+[table Operator str
+[[Backend][50 Bits][100 Bits][500 Bits]]
+[[cpp_dec_float][2.62876 (0.00932849s)][3.80613 (0.0201057s)][1.91552 (0.0655127s)]]
+[[gmp_float][[*1] (0.00354863s)][[*1] (0.00528245s)][1.18878 (0.0406575s)]]
+[[mpfr_float][2.04421 (0.00725414s)][1.70536 (0.00900848s)][[*1] (0.0342011s)]]
+]
+[endsect]
+[section:integer_performance Integer Type Perfomance]
+[table Operator %
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.35064 (0.226534s)][2.1428 (0.435207s)][3.03946 (0.719958s)][4.22281 (1.27181s)]]
+[[cpp_int(fixed)][1.21726 (0.204164s)][1.58068 (0.321039s)][2.61838 (0.620217s)][3.6486 (1.09888s)]]
+[[gmp_int][[*1] (0.167724s)][[*1] (0.203102s)][[*1] (0.23687s)][[*1] (0.301177s)]]
+[[tommath_int][6.61759 (1.10993s)][6.58689 (1.33781s)][8.33593 (1.97453s)][11.1709 (3.36442s)]]
+]
+[table Operator %(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][4.43928 (0.181554s)][5.31056 (0.279274s)][8.141 (0.53345s)][12.5735 (0.962651s)]]
+[[cpp_int(fixed)][2.82619 (0.115583s)][4.54202 (0.238857s)][7.49924 (0.491398s)][12.2974 (0.941513s)]]
+[[gmp_int][[*1] (0.0408971s)][[*1] (0.0525884s)][[*1] (0.0655264s)][[*1] (0.0765616s)]]
+[[tommath_int][21.2996 (0.871093s)][28.9405 (1.52193s)][26.5936 (1.74258s)][37.7618 (2.8911s)]]
+]
+[table Operator &
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.88968 (0.0244482s)][1.79292 (0.028049s)][1.77526 (0.0342017s)][1.93398 (0.0456006s)]]
+[[cpp_int(fixed)][1.11185 (0.0143848s)][[*1] (0.0156443s)][[*1] (0.0192657s)][1.68783 (0.0397966s)]]
+[[gmp_int][[*1] (0.0129377s)][1.09124 (0.0170717s)][1.08747 (0.0209509s)][[*1] (0.0235786s)]]
+[[tommath_int][5.77397 (0.0747022s)][4.7749 (0.0747001s)][4.23046 (0.0815029s)][4.19976 (0.0990244s)]]
+]
+[table Operator &(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.51385 (0.0426893s)][1.56497 (0.0338674s)][1.52989 (0.0424884s)][1.15907 (0.0577198s)]]
+[[cpp_int(fixed)][[*1] (0.0169816s)][[*1] (0.021641s)][[*1] (0.0277722s)][[*1] (0.0497983s)]]
+[[gmp_int][2.9563 (0.0502028s)][2.3492 (0.0508389s)][1.91894 (0.0532932s)][1.03011 (0.0512979s)]]
+[[tommath_int][13.2139 (0.224394s)][10.6481 (0.230435s)][8.47057 (0.235246s)][4.91936 (0.244976s)]]
+]
+[table Operator *
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.21032 (0.0363846s)][2.59769 (0.100083s)][3.28466 (0.343683s)][3.88666 (1.28548s)]]
+[[cpp_int(fixed)][1.22547 (0.0201727s)][[*1] (0.0385279s)][1.14595 (0.119904s)][1.12192 (0.371065s)]]
+[[gmp_int][[*1] (0.0164612s)][1.28554 (0.0495293s)][[*1] (0.104633s)][[*1] (0.330741s)]]
+[[tommath_int][3.69412 (0.0608098s)][2.19021 (0.0843842s)][1.87184 (0.195855s)][1.70271 (0.563154s)]]
+]
+[table Operator *(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.8402 (0.0257193s)][1.92542 (0.0294836s)][2.06094 (0.039305s)][1.6562 (0.0540818s)]]
+[[cpp_int(fixed)][1.3108 (0.0183201s)][1.40725 (0.021549s)][1.48723 (0.0283635s)][1.51354 (0.0494233s)]]
+[[gmp_int][[*1] (0.0139764s)][[*1] (0.0153128s)][[*1] (0.0190714s)][[*1] (0.0326542s)]]
+[[tommath_int][13.593 (0.18998s)][13.1093 (0.20074s)][16.0244 (0.305608s)][8.12274 (0.265242s)]]
+]
+[table Operator +
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.33096 (0.0226262s)][1.43935 (0.0275581s)][1.39258 (0.033691s)][1.28136 (0.0456764s)]]
+[[cpp_int(fixed)][1.08205 (0.0183948s)][1.13659 (0.0217614s)][1.17718 (0.0284799s)][1.1125 (0.0396571s)]]
+[[gmp_int][1.39192 (0.0236625s)][1.34375 (0.0257277s)][1.17204 (0.0283556s)][1.17063 (0.0417292s)]]
+[[tommath_int][[*1] (0.0169999s)][[*1] (0.0191462s)][[*1] (0.0241933s)][[*1] (0.0356467s)]]
+]
+[table Operator +(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.73044 (0.0156956s)][1.66346 (0.017033s)][1.60196 (0.0196755s)][[*1] (0.0241476s)]]
+[[cpp_int(fixed)][1.06691 (0.00967714s)][[*1] (0.0102395s)][[*1] (0.0122821s)][1.05229 (0.0254102s)]]
+[[gmp_int][[*1] (0.00907029s)][1.26028 (0.0129046s)][1.27777 (0.0156938s)][1.07144 (0.0258726s)]]
+[[tommath_int][18.7688 (0.170239s)][16.9572 (0.173633s)][20.5363 (0.25223s)][7.61905 (0.183982s)]]
+]
+[table Operator -
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.40057 (0.0256171s)][1.46382 (0.0305114s)][1.49343 (0.0422701s)][1.39142 (0.0574919s)]]
+[[cpp_int(fixed)][[*1] (0.0182905s)][[*1] (0.0208437s)][[*1] (0.028304s)][[*1] (0.0413187s)]]
+[[gmp_int][1.39653 (0.0255431s)][1.50686 (0.0314085s)][1.40796 (0.0398509s)][1.22212 (0.0504965s)]]
+[[tommath_int][1.37164 (0.025088s)][1.28188 (0.0267191s)][1.13602 (0.032154s)][1.03193 (0.0426379s)]]
+]
+[table Operator -(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.50784 (0.0122229s)][1.54914 (0.0143035s)][1.55501 (0.0171212s)][1.0172 (0.0212992s)]]
+[[cpp_int(fixed)][[*1] (0.00810627s)][[*1] (0.00923316s)][[*1] (0.0110103s)][[*1] (0.020939s)]]
+[[gmp_int][1.49189 (0.0120936s)][1.76716 (0.0163165s)][1.86002 (0.0204795s)][1.12695 (0.0235972s)]]
+[[tommath_int][20.9474 (0.169805s)][18.7459 (0.173084s)][23.1437 (0.25482s)][8.70855 (0.182348s)]]
+]
+[table Operator /
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.12441 (0.227187s)][1.92471 (0.467116s)][2.5683 (0.755608s)][3.45487 (1.30086s)]]
+[[cpp_int(fixed)][1.02377 (0.206852s)][1.32377 (0.321272s)][2.09615 (0.616699s)][2.89679 (1.09072s)]]
+[[gmp_int][[*1] (0.20205s)][[*1] (0.242695s)][[*1] (0.294206s)][[*1] (0.376529s)]]
+[[tommath_int][5.68214 (1.14807s)][5.52349 (1.34052s)][7.00529 (2.061s)][8.79242 (3.3106s)]]
+]
+[table Operator /(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.11845 (0.129609s)][4.15783 (0.303922s)][5.55849 (0.535727s)][6.76415 (1.00179s)]]
+[[cpp_int(fixed)][1.81934 (0.111309s)][2.99804 (0.219146s)][4.68327 (0.451373s)][5.87635 (0.870306s)]]
+[[gmp_int][[*1] (0.061181s)][[*1] (0.0730963s)][[*1] (0.09638s)][[*1] (0.148103s)]]
+[[tommath_int][15.3006 (0.936106s)][16.0325 (1.17192s)][18.2771 (1.76155s)][20.2054 (2.99248s)]]
+]
+[table Operator <<
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.66271 (0.0182175s)][1.44338 (0.0210768s)][1.50386 (0.0269161s)][1.91115 (0.0394128s)]]
+[[cpp_int(fixed)][1.19703 (0.0131154s)][1.16109 (0.0169546s)][1.05186 (0.0188263s)][1.90315 (0.0392477s)]]
+[[gmp_int][[*1] (0.0109566s)][[*1] (0.0146023s)][[*1] (0.0178981s)][[*1] (0.0206225s)]]
+[[tommath_int][2.88726 (0.0316344s)][2.5987 (0.0379471s)][2.51285 (0.0449753s)][3.25597 (0.0671463s)]]
+]
+[table Operator >>
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.36287 (0.0215535s)][1.70778 (0.0175781s)][1.77078 (0.0216914s)][2.29189 (0.0294462s)]]
+[[cpp_int(fixed)][[*1] (0.00912176s)][1.10889 (0.0114138s)][1.2417 (0.0152103s)][1.6714 (0.0214742s)]]
+[[gmp_int][1.17612 (0.0107283s)][[*1] (0.010293s)][[*1] (0.0122496s)][[*1] (0.012848s)]]
+[[tommath_int][15.2553 (0.139155s)][13.7608 (0.14164s)][12.2124 (0.149597s)][13.0247 (0.167341s)]]
+]
+[table Operator ^
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.78798 (0.0243197s)][1.8085 (0.0280192s)][1.78828 (0.033929s)][1.79594 (0.0456494s)]]
+[[cpp_int(fixed)][1.0129 (0.0137773s)][[*1] (0.015493s)][[*1] (0.018973s)][1.5504 (0.0394082s)]]
+[[gmp_int][[*1] (0.0136018s)][1.03786 (0.0160796s)][1.40572 (0.0266707s)][[*1] (0.0254182s)]]
+[[tommath_int][5.39689 (0.0734074s)][4.78827 (0.0741847s)][4.17964 (0.0793004s)][3.73059 (0.0948247s)]]
+]
+[table Operator ^(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.76928 (0.0404509s)][1.83515 (0.0299941s)][1.77409 (0.0323887s)][1.11493 (0.0372218s)]]
+[[cpp_int(fixed)][[*1] (0.014607s)][[*1] (0.0163443s)][[*1] (0.0182565s)][[*1] (0.0333848s)]]
+[[gmp_int][3.25823 (0.047593s)][3.05166 (0.0498771s)][2.96144 (0.0540655s)][1.47308 (0.0491785s)]]
+[[tommath_int][17.006 (0.248407s)][15.2663 (0.249516s)][14.338 (0.261762s)][7.82864 (0.261357s)]]
+]
+[table Operator gcd
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][9.20736 (4.16823s)][3.91955 (8.51244s)][4.00539 (19.489s)][4.64192 (47.7651s)]]
+[[cpp_int(fixed)][6.34685 (2.87326s)][3.07855 (6.68597s)][3.32507 (16.1788s)][4.07366 (41.9178s)]]
+[[gmp_int][[*1] (0.452707s)][[*1] (2.17179s)][[*1] (4.86569s)][[*1] (10.2899s)]]
+[[tommath_int][16.804 (7.6073s)][7.31428 (15.8851s)][6.96518 (33.8904s)][6.52732 (67.1657s)]]
+]
+[table Operator str
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.76995 (0.000703371s)][2.94246 (0.00181769s)][3.45149 (0.00434022s)][4.14052 (0.0122363s)]]
+[[cpp_int(fixed)][1.58559 (0.000630107s)][2.42804 (0.00149991s)][3.30542 (0.00415653s)][3.90693 (0.011546s)]]
+[[gmp_int][[*1] (0.000397397s)][[*1] (0.000617745s)][[*1] (0.00125749s)][[*1] (0.00295526s)]]
+[[tommath_int][21.7585 (0.00864677s)][34.4291 (0.0212684s)][65.8175 (0.0827649s)][67.7946 (0.200351s)]]
+]
+[table Operator |
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][1.91883 (0.0242976s)][1.88265 (0.0281237s)][1.78879 (0.0339623s)][1.74117 (0.0457886s)]]
+[[cpp_int(fixed)][1.08025 (0.0136789s)][1.03489 (0.0154596s)][[*1] (0.0189862s)][1.49756 (0.0393824s)]]
+[[gmp_int][[*1] (0.0126627s)][[*1] (0.0149383s)][1.28585 (0.0244134s)][[*1] (0.0262977s)]]
+[[tommath_int][5.86177 (0.0742258s)][4.9555 (0.0740269s)][4.18835 (0.0795209s)][3.55804 (0.0935681s)]]
+]
+[table Operator |(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_int][2.76183 (0.0454215s)][2.05967 (0.0323883s)][1.78143 (0.0324562s)][1.22147 (0.0372077s)]]
+[[cpp_int(fixed)][[*1] (0.0164462s)][[*1] (0.015725s)][[*1] (0.0182191s)][[*1] (0.0304613s)]]
+[[gmp_int][2.81912 (0.0463637s)][3.18611 (0.0501017s)][2.94469 (0.0536497s)][1.62702 (0.0495613s)]]
+[[tommath_int][15.1485 (0.249135s)][15.9884 (0.251418s)][13.915 (0.253519s)][8.65293 (0.26358s)]]
+]
+[endsect]
+[section:rational_performance Rational Type Perfomance]
+[table Operator *
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][16.2879 (15.3196s)][10.7459 (45.9283s)][11.5596 (111.528s)][12.8553 (270.253s)]]
+[[mpq_rational][[*1] (0.940549s)][[*1] (4.27402s)][[*1] (9.6481s)][[*1] (21.0227s)]]
+]
+[table Operator *(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][7.7465 (1.3425s)][10.6643 (2.05921s)][11.055 (2.75206s)][12.6365 (4.26866s)]]
+[[mpq_rational][[*1] (0.173305s)][[*1] (0.193095s)][[*1] (0.248942s)][[*1] (0.337805s)]]
+]
+[table Operator +
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][16.0608 (8.33358s)][10.8037 (24.5753s)][11.4235 (58.1983s)][12.435 (139.884s)]]
+[[mpq_rational][[*1] (0.518878s)][[*1] (2.2747s)][[*1] (5.09463s)][[*1] (11.2492s)]]
+]
+[table Operator +(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][7.82472 (1.14042s)][9.40883 (1.54697s)][9.02478 (1.83113s)][9.24894 (2.65768s)]]
+[[mpq_rational][[*1] (0.145745s)][[*1] (0.164417s)][[*1] (0.202901s)][[*1] (0.287349s)]]
+]
+[table Operator -
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][16.0583 (8.3543s)][10.6997 (24.3831s)][11.4377 (58.3044s)][12.4116 (139.665s)]]
+[[mpq_rational][[*1] (0.520249s)][[*1] (2.27886s)][[*1] (5.09757s)][[*1] (11.2528s)]]
+]
+[table Operator -(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][7.99602 (1.13947s)][9.62717 (1.55711s)][9.1151 (1.82889s)][9.53508 (2.68279s)]]
+[[mpq_rational][[*1] (0.142505s)][[*1] (0.161741s)][[*1] (0.200644s)][[*1] (0.28136s)]]
+]
+[table Operator /
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][12.0736 (31.794s)][10.0089 (80.7871s)][10.9267 (184.73s)][12.204 (436.471s)]]
+[[mpq_rational][[*1] (2.63335s)][[*1] (8.07149s)][[*1] (16.9064s)][[*1] (35.7647s)]]
+]
+[table Operator /(int)
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][7.56092 (1.35276s)][10.5279 (2.12933s)][10.9509 (2.75885s)][12.166 (4.27228s)]]
+[[mpq_rational][[*1] (0.178914s)][[*1] (0.202255s)][[*1] (0.251928s)][[*1] (0.351164s)]]
+]
+[table Operator str
+[[Backend][128 Bits][256 Bits][512 Bits][1024 Bits]]
+[[cpp_rational][13.4013 (0.00980984s)][23.4372 (0.0288878s)][27.4314 (0.067039s)][29.4814 (0.165057s)]]
+[[mpq_rational][[*1] (0.000732008s)][[*1] (0.00123256s)][[*1] (0.00244388s)][[*1] (0.00559869s)]]
+]
+[endsect]
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk