[Boost-commit] svn:boost r68822 - in trunk: boost/random libs/random/doc libs/random/example

Subject: [Boost-commit] svn:boost r68822 - in trunk: boost/random libs/random/doc libs/random/example
From: steven_at_[hidden]
Date: 2011-02-12 22:29:04

Author: steven_watanabe
Date: 2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
New Revision: 68822
URL: http://svn.boost.org/trac/boost/changeset/68822

Log:
Sync the docs with the current library.
Text files modified: 
   trunk/boost/random/additive_combine.hpp                |     4 +                                       
   trunk/boost/random/bernoulli_distribution.hpp          |     3 -                                       
   trunk/boost/random/binomial_distribution.hpp           |     2                                         
   trunk/boost/random/cauchy_distribution.hpp             |     3 -                                       
   trunk/boost/random/chi_squared_distribution.hpp        |     2                                         
   trunk/boost/random/discard_block.hpp                   |     4 ++                                      
   trunk/boost/random/discrete_distribution.hpp           |     4 +-                                      
   trunk/boost/random/exponential_distribution.hpp        |     2 -                                       
   trunk/boost/random/geometric_distribution.hpp          |     6 ++                                      
   trunk/boost/random/independent_bits.hpp                |    10 +---                                    
   trunk/boost/random/inversive_congruential.hpp          |     2                                         
   trunk/boost/random/lagged_fibonacci.hpp                |    14 +++---                                  
   trunk/boost/random/linear_congruential.hpp             |     6 +-                                      
   trunk/boost/random/linear_feedback_shift.hpp           |     4 +-                                      
   trunk/boost/random/lognormal_distribution.hpp          |     8 +++-                                    
   trunk/boost/random/mersenne_twister.hpp                |     7 +--                                     
   trunk/boost/random/negative_binomial_distribution.hpp  |     2                                         
   trunk/boost/random/normal_distribution.hpp             |     5 --                                      
   trunk/boost/random/piecewise_constant_distribution.hpp |    11 -----                                   
   trunk/boost/random/piecewise_linear_distribution.hpp   |     7 ---                                     
   trunk/boost/random/poisson_distribution.hpp            |     2                                         
   trunk/boost/random/random_device.hpp                   |     2                                         
   trunk/boost/random/seed_seq.hpp                        |    18 +++++++++                               
   trunk/boost/random/shuffle_order.hpp                   |    12 +++++-                                  
   trunk/boost/random/student_t_distribution.hpp          |     2                                         
   trunk/boost/random/subtract_with_carry.hpp             |    30 ++++++++++-----                         
   trunk/boost/random/triangle_distribution.hpp           |     2                                         
   trunk/boost/random/uniform_01.hpp                      |     5 ++                                      
   trunk/boost/random/uniform_smallint.hpp                |     6 ++-                                     
   trunk/boost/random/variate_generator.hpp               |     3 -                                       
   trunk/boost/random/xor_combine.hpp                     |     2                                         
   trunk/libs/random/doc/Jamfile.v2                       |    41 +++++++++++++++-------                  
   trunk/libs/random/doc/concepts.qbk                     |    67 ++++++++----------------------------    
   trunk/libs/random/doc/distributions.qbk                |    55 +++++++++++++++++++++++------           
   trunk/libs/random/doc/random.qbk                       |    74 ++++++++++++++++++--------------------- 
   trunk/libs/random/example/die.cpp                      |    26 ++++---------                           
   trunk/libs/random/example/password.cpp                 |    12 ++---                                   
   trunk/libs/random/example/weighted_die.cpp             |    31 +++++++---------                        
   38 files changed, 253 insertions(+), 243 deletions(-)

Modified: trunk/boost/random/additive_combine.hpp
==============================================================================
--- trunk/boost/random/additive_combine.hpp	(original)
+++ trunk/boost/random/additive_combine.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -247,7 +247,8 @@
 const bool additive_combine_engine<MLCG1, MLCG2>::has_fixed_range;
 #endif
 
-/// \cond
+/// \cond show_deprecated
+
 /** Provided for backwards compatibility. */
 template<class MLCG1, class MLCG2, typename MLCG1::result_type val = 0>
 class additive_combine : public additive_combine_engine<MLCG1, MLCG2>
@@ -263,6 +264,7 @@
     template<class It>
     additive_combine(It& first, It last) : base_t(first, last) {}
 };
+
 /// \endcond
 
 /**

Modified: trunk/boost/random/bernoulli_distribution.hpp
==============================================================================
--- trunk/boost/random/bernoulli_distribution.hpp	(original)
+++ trunk/boost/random/bernoulli_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -185,10 +185,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(bernoulli_distribution)
 
 private:
-
-    /// \cond
     RealType _p;
-    /// \endcond
 };
 
 } // namespace random

Modified: trunk/boost/random/binomial_distribution.hpp
==============================================================================
--- trunk/boost/random/binomial_distribution.hpp	(original)
+++ trunk/boost/random/binomial_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -236,7 +236,7 @@
 
 private:
 
-    /// @cond
+    /// @cond show_private
 
     template<class CharT, class Traits>
     void read(std::basic_istream<CharT, Traits>& is) {

Modified: trunk/boost/random/cauchy_distribution.hpp
==============================================================================
--- trunk/boost/random/cauchy_distribution.hpp	(original)
+++ trunk/boost/random/cauchy_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -201,11 +201,8 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(cauchy_distribution)
 
 private:
-  
-    /// \cond
     RealType _median;
     RealType _sigma;
-    /// \endcond
 };
 
 } // namespace random

Modified: trunk/boost/random/chi_squared_distribution.hpp
==============================================================================
--- trunk/boost/random/chi_squared_distribution.hpp	(original)
+++ trunk/boost/random/chi_squared_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -187,7 +187,7 @@
 
 private:
 
-    /// @cond
+    /// @cond show_private
 
     template<class CharT, class Traits>
     void read(std::basic_istream<CharT, Traits>& is) {

Modified: trunk/boost/random/discard_block.hpp
==============================================================================
--- trunk/boost/random/discard_block.hpp	(original)
+++ trunk/boost/random/discard_block.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -202,6 +202,8 @@
 const std::size_t discard_block_engine<URNG, p, r>::used_block;
 #endif
 
+/// \cond \show_deprecated
+
 template<class URNG, int p, int r>
 class discard_block : public discard_block_engine<URNG, p, r>
 {
@@ -221,6 +223,8 @@
     { return (this->base().max)(); }
 };
 
+/// \endcond
+
 } // namespace random
 
 } // namespace boost

Modified: trunk/boost/random/discrete_distribution.hpp
==============================================================================
--- trunk/boost/random/discrete_distribution.hpp	(original)
+++ trunk/boost/random/discrete_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -146,7 +146,7 @@
         /** Returns true if the two sets of parameters are different. */
         BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
     private:
-        /// @cond
+        /// @cond show_private
         friend class discrete_distribution;
         explicit param_type(const discrete_distribution& dist)
           : _probabilities(dist.probabilities())
@@ -374,7 +374,7 @@
 
 private:
 
-    /// @cond
+    /// @cond show_private
 
     template<class Iter>
     void init(Iter first, Iter last, std::input_iterator_tag)

Modified: trunk/boost/random/exponential_distribution.hpp
==============================================================================
--- trunk/boost/random/exponential_distribution.hpp	(original)
+++ trunk/boost/random/exponential_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -170,9 +170,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(exponential_distribution)
 
 private:
-    /// \cond
     result_type _lambda;
-    /// \endcond
 };
 
 } // namespace random

Modified: trunk/boost/random/geometric_distribution.hpp
==============================================================================
--- trunk/boost/random/geometric_distribution.hpp	(original)
+++ trunk/boost/random/geometric_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -199,7 +199,7 @@
 
 private:
 
-    /// \cond
+    /// \cond show_private
 
     void init()
     {
@@ -215,6 +215,8 @@
 
 } // namespace random
 
+/// \cond show_deprecated
+
 /**
  * Provided for backwards compatibility.  This class is
  * deprecated.  It provides the old behavior of geometric_distribution
@@ -258,6 +260,8 @@
     impl_type _impl;
 };
 
+/// \endcond
+
 } // namespace boost
 
 #endif // BOOST_RANDOM_GEOMETRIC_DISTRIBUTION_HPP

Modified: trunk/boost/random/independent_bits.hpp
==============================================================================
--- trunk/boost/random/independent_bits.hpp	(original)
+++ trunk/boost/random/independent_bits.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -84,14 +84,10 @@
     // Required by old Boost.Random concept
     BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
 
-    /**
-     * Returns the smallest value that the generator can produce
-     */
+    /** Returns the smallest value that the generator can produce. */
     static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return 0; }
-    /**
-     * Returns the largest value that the generator can produce
-     */
+    /** Returns the largest value that the generator can produce. */
     static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
     { return boost::low_bits_mask_t<w>::sig_bits; }
 
@@ -265,7 +261,7 @@
 
 private:
 
-    /// \cond
+    /// \cond show_private
     typedef typename base_type::result_type base_result;
     typedef typename make_unsigned<base_result>::type base_unsigned;
 

Modified: trunk/boost/random/inversive_congruential.hpp
==============================================================================
--- trunk/boost/random/inversive_congruential.hpp	(original)
+++ trunk/boost/random/inversive_congruential.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -235,7 +235,7 @@
 const typename inversive_congruential_engine<IntType, a, b, p>::result_type inversive_congruential_engine<IntType, a, b, p>::default_seed;
 #endif
 
-/// \cond
+/// \cond show_deprecated
 
 // provided for backwards compatibility
 template<class IntType, IntType a, IntType b, IntType p, IntType val = 0>

Modified: trunk/boost/random/lagged_fibonacci.hpp
==============================================================================
--- trunk/boost/random/lagged_fibonacci.hpp	(original)
+++ trunk/boost/random/lagged_fibonacci.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -35,7 +35,7 @@
 namespace random {
 
 /** 
- * Instantiations of class template \lagged_fibonacci model a
+ * Instantiations of class template \lagged_fibonacci_engine model a
  * \pseudo_random_number_generator. It uses a lagged Fibonacci
  * algorithm with two lags @c p and @c q:
  * x(i) = x(i-p) + x(i-q) (mod 2<sup>w</sup>) with p > q.
@@ -184,7 +184,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lagged_fibonacci_engine)
 
 private:
-    /// \cond hide_private_members
+    /// \cond show_private
     void fill();
     /// \endcond
 
@@ -202,7 +202,7 @@
 const unsigned int lagged_fibonacci_engine<UIntType, w, p, q>::short_lag;
 #endif
 
-/// \cond
+/// \cond show_private
 
 template<class UIntType, int w, unsigned int p, unsigned int q>
 void lagged_fibonacci_engine<UIntType, w, p, q>::fill()
@@ -219,7 +219,7 @@
 
 /// \endcond
 
-/// \cond
+/// \cond show_deprecated
 
 // provided for backwards compatibility
 template<class UIntType, int w, unsigned int p, unsigned int q, UIntType v = 0>
@@ -432,7 +432,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(lagged_fibonacci_01_engine)
 
 private:
-    /// \cond
+    /// \cond show_private
     void fill();
     static RealType modulus()
     {
@@ -457,7 +457,7 @@
 
 #endif
 
-/// \cond
+/// \cond show_private
 template<class RealType, int w, unsigned int p, unsigned int q>
 void lagged_fibonacci_01_engine<RealType, w, p, q>::fill()
 {
@@ -480,7 +480,7 @@
 }
 /// \endcond
 
-/// \cond
+/// \cond show_deprecated
 
 // provided for backwards compatibility
 template<class RealType, int w, unsigned int p, unsigned int q>

Modified: trunk/boost/random/linear_congruential.hpp
==============================================================================
--- trunk/boost/random/linear_congruential.hpp	(original)
+++ trunk/boost/random/linear_congruential.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -234,7 +234,7 @@
 
 private:
 
-    /// \cond
+    /// \cond show_private
 
     template<class CharT, class Traits>
     void read(std::basic_istream<CharT, Traits>& is) {
@@ -267,7 +267,7 @@
 const IntType linear_congruential_engine<IntType,a,c,m>::default_seed;
 #endif
 
-/// \cond
+/// \cond show_deprecated
 
 // provided for backwards compatibility
 template<class IntType, IntType a, IntType c, IntType m, IntType val = 0>
@@ -421,7 +421,7 @@
     friend bool operator!=(const rand48& x, const rand48& y)
     { return !(x == y); }
 private:
-    /// \cond
+    /// \cond show_private
     typedef random::linear_congruential_engine<uint64_t,
         // xxxxULL is not portable
         uint64_t(0xDEECE66DUL) | (uint64_t(0x5) << 32),

Modified: trunk/boost/random/linear_feedback_shift.hpp
==============================================================================
--- trunk/boost/random/linear_feedback_shift.hpp	(original)
+++ trunk/boost/random/linear_feedback_shift.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -170,7 +170,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(linear_feedback_shift_engine)
 
 private:
-    /// \cond
+    /// \cond show_private
     static UIntType wordmask() { return boost::low_bits_mask_t<w>::sig_bits; }
     /// \endcond
     UIntType value;
@@ -192,7 +192,7 @@
 const UIntType linear_feedback_shift_engine<UIntType, w, k, q, s>::default_seed;
 #endif
 
-/// \cond
+/// \cond show_deprecated
 
 /** Provided for backwards compatibility. */
 template<class UIntType, int w, int k, int q, int s, UIntType v = 0>

Modified: trunk/boost/random/lognormal_distribution.hpp
==============================================================================
--- trunk/boost/random/lognormal_distribution.hpp	(original)
+++ trunk/boost/random/lognormal_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -188,12 +188,14 @@
 
 } // namespace random
 
+/// \cond show_deprecated
+
 /**
  * Provided for backwards compatibility.  This class is
  * deprecated.  It provides the old behavior of lognormal_distribution with
  * \f$\displaystyle p(x) = \frac{1}{x \sigma_N \sqrt{2\pi}} e^{\frac{-\left(\log(x)-\mu_N\right)^2}{2\sigma_N^2}}\f$
  * for x > 0, where \f$\displaystyle \mu_N = \log\left(\frac{\mu^2}{\sqrt{\sigma^2 + \mu^2}}\right)\f$ and
- * \f$\displaystyle \sigma_N = \sqrt{\log\left(1 + \frac{\sigma^2}{\mu^2}\right)}.
+ * \f$\displaystyle \sigma_N = \sqrt{\log\left(1 + \frac{\sigma^2}{\mu^2}\right)}\f$.
  */
 template<class RealType = double>
 class lognormal_distribution
@@ -229,7 +231,7 @@
         return is;
     }
 private:
-    /// \cond
+    /// \cond show_private
     void init()
     {
         using std::log;
@@ -245,6 +247,8 @@
     /// \endcond
 };
 
+/// \endcond
+
 } // namespace boost
 
 #endif // BOOST_RANDOM_LOGNORMAL_DISTRIBUTION_HPP

Modified: trunk/boost/random/mersenne_twister.hpp
==============================================================================
--- trunk/boost/random/mersenne_twister.hpp	(original)
+++ trunk/boost/random/mersenne_twister.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -262,7 +262,7 @@
     { return !(x == y); }
 
 private:
-    /// \cond hide_private_members
+    /// \cond show_private
 
     void twist();
 
@@ -361,7 +361,7 @@
     std::size_t i;
 };
 
-/// \cond
+/// \cond show_private
 
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //  A definition is required even for integral static constants
@@ -498,8 +498,7 @@
     UINT64_C(6364136223846793005)> mt19937_64;
 #endif
 
-
-/// \cond
+/// \cond show_deprecated
 
 template<class UIntType,
          int w, int n, int m, int r,

Modified: trunk/boost/random/negative_binomial_distribution.hpp
==============================================================================
--- trunk/boost/random/negative_binomial_distribution.hpp	(original)
+++ trunk/boost/random/negative_binomial_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -196,7 +196,7 @@
 
 private:
 
-    /// @cond
+    /// @cond \show_private
 
     template<class CharT, class Traits>
     void read(std::basic_istream<CharT, Traits>& is) {

Modified: trunk/boost/random/normal_distribution.hpp
==============================================================================
--- trunk/boost/random/normal_distribution.hpp	(original)
+++ trunk/boost/random/normal_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -208,15 +208,10 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(normal_distribution)
 
 private:
-
-    /// @cond
-
     RealType _mean, _sigma;
     RealType _r1, _r2, _cached_rho;
     bool _valid;
 
-    /// @endcond
-
 };
 
 } // namespace random

Modified: trunk/boost/random/piecewise_constant_distribution.hpp
==============================================================================
--- trunk/boost/random/piecewise_constant_distribution.hpp	(original)
+++ trunk/boost/random/piecewise_constant_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -211,19 +211,15 @@
 
     private:
 
-        /// @cond
-
         friend class piecewise_constant_distribution;
 
         std::vector<RealType> _intervals;
         std::vector<WeightType> _weights;
-
-        /// @endcond
     };
 
     /**
      * Creates a new @c piecewise_constant_distribution with
-     * a single interval, [0, 1)$.
+     * a single interval, [0, 1).
      */
     piecewise_constant_distribution()
     {
@@ -460,13 +456,8 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(piecewise_constant_distribution)
 
 private:
-
-    /// @cond
-
     discrete_distribution<std::size_t, WeightType> _bins;
     std::vector<RealType> _intervals;
-
-    /// @endcond
 };
 
 }

Modified: trunk/boost/random/piecewise_linear_distribution.hpp
==============================================================================
--- trunk/boost/random/piecewise_linear_distribution.hpp	(original)
+++ trunk/boost/random/piecewise_linear_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -225,15 +225,10 @@
         BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(param_type)
 
     private:
-
-        /// @cond
-
         friend class piecewise_linear_distribution;
 
         std::vector<RealType> _intervals;
         std::vector<WeightType> _weights;
-
-        /// @endcond
     };
 
     /**
@@ -487,7 +482,7 @@
 
 private:
 
-    /// @cond
+    /// @cond \show_private
 
     void init(const std::vector<RealType>& intervals_arg,
               const std::vector<WeightType>& weights_arg)

Modified: trunk/boost/random/poisson_distribution.hpp
==============================================================================
--- trunk/boost/random/poisson_distribution.hpp	(original)
+++ trunk/boost/random/poisson_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -225,7 +225,7 @@
 
 private:
 
-    /// @cond
+    /// @cond show_private
 
     template<class CharT, class Traits>
     void read(std::basic_istream<CharT, Traits>& is) {

Modified: trunk/boost/random/random_device.hpp
==============================================================================
--- trunk/boost/random/random_device.hpp	(original)
+++ trunk/boost/random/random_device.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -77,7 +77,7 @@
  *
  * <table cols="2">
  *   <tr><th>class</th><th>time per invocation [usec]</th></tr>
- *   <tr><td> @xmlonly <classname alt="boost::random_device">random_device</classname> @endxmlonly </td><td>92.0</td></tr>
+ *   <tr><td> \random_device </td><td>92.0</td></tr>
  * </table>
  *
  * The measurement error is estimated at +/- 1 usec.

Modified: trunk/boost/random/seed_seq.hpp
==============================================================================
--- trunk/boost/random/seed_seq.hpp	(original)
+++ trunk/boost/random/seed_seq.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -30,21 +30,37 @@
 namespace boost {
 namespace random {
 
+/**
+ * The class @c seed_seq stores a sequence of 32-bit words
+ * for seeding a \pseudo_random_number_generator.  These
+ * words will be combined to fill the entire state of the
+ * generator.
+ */
 class seed_seq {
 public:
     typedef boost::uint_least32_t result_type;
 
+    /** Initializes a seed_seq to hold an empty sequence. */
     seed_seq() {}
 #ifndef BOOST_NO_INITIALIZER_LISTS
+    /** Initializes the sequence from an initializer_list. */
     template<class T>
     seed_seq(const std::initializer_list<T>& il) : v(il.begin(), il.end()) {}
 #endif
+    /** Initializes the sequence from an iterator range. */
     template<class Iter>
     seed_seq(Iter first, Iter last) : v(first, last) {}
+    /** Initializes the sequence from Boost.Range range. */
     template<class Range>
     explicit seed_seq(const Range& range)
       : v(boost::begin(range), boost::end(range)) {}
 
+    /**
+     * Fills a range with 32-bit values based on the stored sequence.
+     *
+     * Requires: Iter must be a Random Access Iterator whose value type
+     * is an unsigned integral type at least 32 bits wide.
+     */
     template<class Iter>
     void generate(Iter first, Iter last) const
     {
@@ -87,7 +103,9 @@
             *(first + k%n) = r4;
         }
     }
+    /** Returns the size of the sequence. */
     std::size_t size() const { return v.size(); }
+    /** Writes the stored sequence to iter. */
     template<class Iter>
     void param(Iter out) { std::copy(v.begin(), v.end(), out); }
 private:

Modified: trunk/boost/random/shuffle_order.hpp
==============================================================================
--- trunk/boost/random/shuffle_order.hpp	(original)
+++ trunk/boost/random/shuffle_order.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -233,7 +233,7 @@
 
 private:
 
-    /// \cond
+    /// \cond show_private
 
     void init()
     {
@@ -260,7 +260,6 @@
 const std::size_t shuffle_order_engine<URNG, k>::buffer_size;
 #endif
 
-// validation by experiment from Harry Erwin's generator.h (private e-mail)
 /**
  * According to Harry Erwin (private e-mail), the specialization
  * @c kreutzer1986 was suggested in:
@@ -274,6 +273,15 @@
     linear_congruential_engine<uint32_t, 1366, 150889, 714025>,
     97> kreutzer1986;
 
+/**
+ * The specialization @c knuth_b is specified by the C++ standard.
+ * It is described in
+ *
+ * @blockquote
+ * "The Art of Computer Programming, Second Edition, Volume 2,
+ * Seminumerical Algorithms", Donald Knuth, Addison-Wesley, 1981.
+ * @endblockquote
+ */
 typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
 
 } // namespace random

Modified: trunk/boost/random/student_t_distribution.hpp
==============================================================================
--- trunk/boost/random/student_t_distribution.hpp	(original)
+++ trunk/boost/random/student_t_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -31,7 +31,7 @@
  * It has \f$\displaystyle p(x) =
  *   \frac{1}{\sqrt{n\pi}}
  *   \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
- *   \left(1}\frac{x^2}{n}\right)^{-(n+1)/2}
+ *   \left(1+\frac{x^2}{n}\right)^{-(n+1)/2}
  * \f$.
  */
 template<class RealType = double>

Modified: trunk/boost/random/subtract_with_carry.hpp
==============================================================================
--- trunk/boost/random/subtract_with_carry.hpp	(original)
+++ trunk/boost/random/subtract_with_carry.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -225,7 +225,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(subtract_with_carry_engine)
 
 private:
-    /// \cond
+    /// \cond show_private
     // returns x(i-r+index), where index is in 0..r-1
     IntType compute(unsigned int index) const
     {
@@ -270,7 +270,17 @@
 
 
 // use a floating-point representation to produce values in [0..1)
-/** @copydoc boost::random::subtract_with_carry_engine */
+/**
+ * Instantiations of \subtract_with_carry_01_engine model a
+ * \pseudo_random_number_generator.  The algorithm is
+ * described in
+ *
+ *  @blockquote
+ *  "A New Class of Random Number Generators", George
+ *  Marsaglia and Arif Zaman, Annals of Applied Probability,
+ *  Volume 1, Number 3 (1991), 462-480.
+ *  @endblockquote
+ */
 template<class RealType, std::size_t w, std::size_t s, std::size_t r>
 class subtract_with_carry_01_engine
 {
@@ -284,21 +294,21 @@
 
     BOOST_STATIC_ASSERT(!std::numeric_limits<result_type>::is_integer);
 
-    /** Creates a new subtract_with_carry_01_engine using the default seed. */
+    /** Creates a new \subtract_with_carry_01_engine using the default seed. */
     subtract_with_carry_01_engine() { init_modulus(); seed(); }
     /** Creates a new subtract_with_carry_01_engine and seeds it with value. */
     BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(subtract_with_carry_01_engine,
                                                uint32_t, value)
     { init_modulus(); seed(value); }
     /**
-     * Creates a new subtract_with_carry_01_engine and seeds with with values
+     * Creates a new \subtract_with_carry_01_engine and seeds with with values
      * produced by seq.generate().
      */
     BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(subtract_with_carry_01_engine,
                                              SeedSeq, seq)
     { init_modulus(); seed(seq); }
     /**
-     * Creates a new subtract_with_carry_01_engine and seeds it with values
+     * Creates a new \subtract_with_carry_01_engine and seeds it with values
      * from a range.  Advances first to point one past the last consumed
      * value.  If the range does not contain enough elements to fill the
      * entire state, throws @c std::invalid_argument.
@@ -307,7 +317,7 @@
     { init_modulus(); seed(first,last); }
 
 private:
-    /// \cond
+    /// \cond show_private
     void init_modulus()
     {
 #ifndef BOOST_NO_STDC_NAMESPACE
@@ -433,7 +443,7 @@
         }
     }
 
-    /** Writes a subtract_with_carry_01_engine to a @c std::ostream. */
+    /** Writes a \subtract_with_carry_01_engine to a @c std::ostream. */
     BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os, subtract_with_carry_01_engine, f)
     {
         std::ios_base::fmtflags oldflags =
@@ -445,7 +455,7 @@
         return os;
     }
     
-    /** Reads a subtract_with_carry_01_engine from a @c std::istream. */
+    /** Reads a \subtract_with_carry_01_engine from a @c std::istream. */
     BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is, subtract_with_carry_01_engine, f)
     {
         RealType value;
@@ -472,7 +482,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(subtract_with_carry_01_engine)
 
 private:
-    /// \cond
+    /// \cond show_private
     RealType compute(unsigned int index) const
     {
         return x[(k+index) % long_lag];
@@ -499,7 +509,7 @@
 #endif
 
 
-/// \cond
+/// \cond show_deprecated
 
 template<class IntType, IntType m, unsigned s, unsigned r, IntType v>
 class subtract_with_carry :

Modified: trunk/boost/random/triangle_distribution.hpp
==============================================================================
--- trunk/boost/random/triangle_distribution.hpp	(original)
+++ trunk/boost/random/triangle_distribution.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -207,7 +207,7 @@
     BOOST_RANDOM_DETAIL_INEQUALITY_OPERATOR(triangle_distribution)
 
 private:
-    /// \cond
+    /// \cond show_private
     void init()
     {
         using std::sqrt;

Modified: trunk/boost/random/uniform_01.hpp
==============================================================================
--- trunk/boost/random/uniform_01.hpp	(original)
+++ trunk/boost/random/uniform_01.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -26,6 +26,7 @@
 #include <boost/random/detail/disable_warnings.hpp>
 
 namespace boost {
+namespace random {
 
 #ifdef BOOST_RANDOM_DOXYGEN
 
@@ -266,6 +267,10 @@
 
 #endif
 
+} // namespace random
+
+using random::uniform_01;
+
 } // namespace boost
 
 #include <boost/random/detail/enable_warnings.hpp>

Modified: trunk/boost/random/uniform_smallint.hpp
==============================================================================
--- trunk/boost/random/uniform_smallint.hpp	(original)
+++ trunk/boost/random/uniform_smallint.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -63,7 +63,8 @@
  *
  * The template parameter IntType shall denote an integer-like value type.
  *
- * Note: The property above is the square sum of the relative differences
+ * @xmlnote
+ * The property above is the square sum of the relative differences
  * in probabilities between the desired uniform distribution
  * \f$p_{\mathtt{out}}(i)\f$ and the generated distribution
  * \f$p_{\mathtt{out\_s}}(i)\f$.
@@ -85,6 +86,7 @@
  * {r_{\mathtt{out}}}\right\rfloor/r_{\mathtt{base}}\f$ otherwise.
  * Substituting this in the
  * above sum formula leads to the desired result.
+ * @endxmlnote
  *
  * Note: The upper bound for
  * \f$(r_{\mathtt{base}} \mbox{ mod } r_{\mathtt{out}})
@@ -228,7 +230,7 @@
 
 private:
     
-    // \cond
+    // \cond show_private
     template<class Engine>
     result_type generate(Engine& eng, boost::mpl::true_) const
     {

Modified: trunk/boost/random/variate_generator.hpp
==============================================================================
--- trunk/boost/random/variate_generator.hpp	(original)
+++ trunk/boost/random/variate_generator.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -33,9 +33,6 @@
  * Boost.Random provides a vast choice of \generators as well
  * as \distributions.
  *
- * Instantations of class template @c variate_generator model
- * a \number_generator.
- *
  * The argument for the template parameter Engine shall be of
  * the form U, U&, or U*, where U models a
  * \uniform_random_number_generator.  Then, the member

Modified: trunk/boost/random/xor_combine.hpp
==============================================================================
--- trunk/boost/random/xor_combine.hpp	(original)
+++ trunk/boost/random/xor_combine.hpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -176,7 +176,7 @@
 const int xor_combine_engine<URNG1, s1, URNG2, s2>::shift2;
 #endif
 
-/// \cond
+/// \cond show_private
 
 /** Provided for backwards compatibility. */
 template<class URNG1, int s1, class URNG2, int s2,

Modified: trunk/libs/random/doc/Jamfile.v2
==============================================================================
--- trunk/libs/random/doc/Jamfile.v2	(original)
+++ trunk/libs/random/doc/Jamfile.v2	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -19,30 +19,40 @@
     bernoulli_distribution
     binomial_distribution
     cauchy_distribution
+    chi_squared_distribution
     discard_block
     discrete_distribution
     exponential_distribution
     extreme_value_distribution
+    fisher_f_distribution
     gamma_distribution
     geometric_distribution
+    independent_bits
     inversive_congruential
     lagged_fibonacci
     linear_congruential
     linear_feedback_shift
     lognormal_distribution
     mersenne_twister
+    negative_binomial_distribution
     normal_distribution
+    piecewise_constant_distribution
+    piecewise_linear_distribution
     poisson_distribution
+    random_device
     random_number_generator
     ranlux
+    seed_seq
     shuffle_order
     # shuffle_output
+    student_t_distribution
     subtract_with_carry
+    taus88
     triangle_distribution
     uniform_01
-    uniform_int
+    uniform_int_distribution
     uniform_on_sphere
-    uniform_real
+    uniform_real_distribution
     uniform_smallint
     variate_generator
     weibull_distribution
@@ -62,7 +72,6 @@
 
 doxygen reference :
     $(here)/../../../boost/random/$(doxygen_files).hpp
-    $(here)/../../../boost/nondet_random.hpp
     $(here)/../../../boost/random.hpp
   :
     <doxygen:param>EXPAND_ONLY_PREDEF=YES
@@ -78,25 +87,25 @@
         pseudo_random_number_generator=\"@xmlonly <link linkend=\\\"boost_random.reference.concepts.pseudo_random_number_generator\\\">pseudo-random number generator</link> @endxmlonly\" \\
         uniform_random_number_generator=\"@xmlonly <link linkend=\\\"boost_random.reference.concepts.uniform_random_number_generator\\\">uniform random number generator</link> @endxmlonly\" \\
         nondeterministic_random_number_generator=\"@xmlonly <link linkend=\\\"boost_random.reference.concepts.non_deterministic_uniform_random_number_generator\\\">non-deterministic random number generator</link> @endxmlonly\" \\
-        number_generator=\"@xmlonly <link linkend=\\\"boost_random.reference.concepts.number_generator\\\">number generator</link> @endxmlonly\" \\
         generators=\"@xmlonly <link linkend=\\\"boost_random.reference.generators\\\">generators</link> @endxmlonly\" \\
         distributions=\"@xmlonly <link linkend=\\\"boost_random.reference.distributions\\\">distributions</link> @endxmlonly\" \\
-        additive_combine=\"@xmlonly <classname alt=\\\"boost::random::additive_combine\\\">additive_combine</classname> @endxmlonly\" \\
+        additive_combine_engine=\"@xmlonly <classname alt=\\\"boost::random::additive_combine_engine\\\">additive_combine_engine</classname> @endxmlonly\" \\
         discard_block_engine=\"@xmlonly <classname alt=\\\"boost::random::discard_block_engine\\\">discard_block_engine</classname> @endxmlonly\" \\
-        lagged_fibonacci=\"@xmlonly<classname alt=\\\"boost::random::lagged_fibonacci\\\">lagged_fibonacci</classname>@endxmlonly\" \\
+        lagged_fibonacci_engine=\"@xmlonly<classname alt=\\\"boost::random::lagged_fibonacci_engine\\\">lagged_fibonacci_engine</classname>@endxmlonly\" \\
+        subtract_with_carry_01_engine=\"@xmlonly<classname alt=\\\"boost::random::subtract_with_carry_01_engine\\\">subtract_with_carry_01_engine</classname>@endxmlonly\" \\
         linear_congruential_engine=\"@xmlonly<classname alt=\\\"boost::random::linear_congruential_engine\\\">linear_congruential_engine</classname>@endxmlonly\" \\
         minstd_rand=\"@xmlonly <classname alt=\\\"boost::random::minstd_rand\\\">minstd_rand</classname> @endxmlonly\" \\
         minstd_rand0=\"@xmlonly <classname alt=\\\"boost::random::minstd_rand0\\\">minstd_rand0</classname> @endxmlonly\" \\
         rand48=\"@xmlonly <classname alt=\\\"boost::random::rand48\\\">rand48</classname> @endxmlonly\" \\
         mt11213b=\"@xmlonly <classname alt=\\\"boost::random::mt11213b\\\">mt11213b</classname> @endxmlonly\" \\
         mt19937=\"@xmlonly <classname alt=\\\"boost::random::mt19937\\\">mt19937</classname> @endxmlonly\" \\
-        ecuyer1988=\"@xmlonly <classname alt=\\\"boost::ecuyer1988\\\">ecuyer1988</classname> @endxmlonly\" \\
-        lagged_fibonacci607=\"@xmlonly <classname alt=\\\"boost::lagged_fibonacci607\\\">lagged_fibonacci607</classname> @endxmlonly\" \\
-        lagged_fibonacci44497=\"@xmlonly <classname alt=\\\"boost::lagged_fibonacci44497\\\">lagged_fibonacci44497</classname> @endxmlonly\" \\
-        bernoulli_distribution=\"@xmlonly <classname alt=\\\"boost::bernoulli_distribution\\\">bernoulli_distribution</classname> @endxmlonly\" \\
-        cauchy_distribution=\"@xmlonly <classname alt=\\\"boost::cauchy_distribution\\\">cauchy_distribution</classname> @endxmlonly\" \\
-        uniform_01=\"@xmlonly<classname alt=\\\"boost::uniform_01\\\">uniform_01</classname>@endxmlonly\" \\
-        random_device=\"@xmlonly<classname alt=\\\"boost::random_device\\\">random_device</classname>@endxmlonly\""
+        ecuyer1988=\"@xmlonly <classname alt=\\\"boost::random::ecuyer1988\\\">ecuyer1988</classname> @endxmlonly\" \\
+        lagged_fibonacci607=\"@xmlonly <classname alt=\\\"boost::random::lagged_fibonacci607\\\">lagged_fibonacci607</classname> @endxmlonly\" \\
+        lagged_fibonacci44497=\"@xmlonly <classname alt=\\\"boost::random::lagged_fibonacci44497\\\">lagged_fibonacci44497</classname> @endxmlonly\" \\
+        bernoulli_distribution=\"@xmlonly <classname alt=\\\"boost::random::bernoulli_distribution\\\">bernoulli_distribution</classname> @endxmlonly\" \\
+        cauchy_distribution=\"@xmlonly <classname alt=\\\"boost::random::cauchy_distribution\\\">cauchy_distribution</classname> @endxmlonly\" \\
+        uniform_01=\"@xmlonly<classname alt=\\\"boost::random::uniform_01\\\">uniform_01</classname>@endxmlonly\" \\
+        random_device=\"@xmlonly<classname alt=\\\"boost::random::random_device\\\">random_device</classname>@endxmlonly\""
     <doxygen:param>HIDE_UNDOC_MEMBERS=NO
     <doxygen:param>QUIET=YES
     <doxygen:param>WARN_IF_UNDOCUMENTED=NO
@@ -125,10 +134,16 @@
         \"b_arg=b\" \\
         \"c_arg=c\" \\
         \"t_arg=t\" \\
+        \"m_arg=m\" \\
+        \"n_arg=n\" \\
+        \"s_arg=s\" \\
+        \"k_arg=k\" \\
         \"min_arg=min\" \\
         \"max_arg=max\" \\
+        \"dim_arg=dim\" \\
         \"parm=param\" \\
         \"aseed=seed\" \\
+        \"seed_arg=seed\" \\
         \"BOOST_RANDOM_DETAIL_OSTREAM_OPERATOR(os,T,t)=template<class CharT, class Traits> friend std::basic_ostream<CharT,Traits>& operator<<(std::basic_ostream<CharT,Traits>& os, const T& t)\" \\
         \"BOOST_RANDOM_DETAIL_ISTREAM_OPERATOR(is,T,t)=template<class CharT, class Traits> friend std::basic_istream<CharT,Traits>& operator>>(std::basic_istream<CharT,Traits>& is, const T& t)\" \\
         \"BOOST_RANDOM_DETAIL_EQUALITY_OPERATOR(T,lhs,rhs)=friend bool operator==(const T& lhs, const T& rhs)\" \\

Modified: trunk/libs/random/doc/concepts.qbk
==============================================================================
--- trunk/libs/random/doc/concepts.qbk	(original)
+++ trunk/libs/random/doc/concepts.qbk	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -31,42 +31,21 @@
 * pseudo-random number generator 
 * quasi-random number generator 
 
-All variations have some properties in common, these concepts (in the STL
-sense) are called __NumberGenerator and __UniformRandomNumberGenerator. Each
-concept will be defined in a subsequent section. 
+All variations have some properties in common, the concepts (in the STL
+sense) is called __UniformRandomNumberGenerator. This
+concept will be defined in a subsequent section.
 
 The goals for this library are the following:
 
-* allow easy integration of third-party random-number generators 
-* define a validation interface for the generators 
+* allow easy integration of third-party random-number generators
 * provide easy-to-use front-end classes which model popular distributions 
 * provide maximum efficiency 
-* allow control on quantization effects in front-end processing (not yet done) 
-
-[endsect]
-
-[section Number Generator]
-
-A number generator is a /function object/ (std:20.3 [lib.function.objects]) that
-takes zero arguments. Each call to `operator()` returns a number. In the
-following table, X denotes a number generator class returning objects of type
-T, and u is a value of X.
-
-[table NumberGenerator requirements
-  [[expression] [return type] [pre/post-condition]]
-  [[`X::result_type`] [`T`] [`std::numeric_limits<T>::is_specialized` is
-                             `true`, `T` is __LessThanComparable]]
-  [[`u.operator()()`] [`T`] [-]]
-] 
-
-[note The NumberGenerator requirements do not impose any restrictions on the
-characteristics of the returned numbers.]
 
 [endsect]
 
 [section Uniform Random Number Generator]
 
-A uniform random number generator is a __NumberGenerator that provides a
+A uniform random number generator provides a
 sequence of random numbers uniformly distributed on a given range. The
 range can be compile-time fixed or available (only) after run-time construction
 of the object.
@@ -81,18 +60,9 @@
 
 [table UniformRandomNumberGenerator requirements
   [[expression] [return type] [pre/post-condition]]
-  [[`X::has_fixed_range`] [`bool`] [compile-time constant; if `true`, the range
-                                    on which the random numbers are uniformly
-                                    distributed is known at compile-time and
-                                    members `min_value` and `max_value` exist.
-                                    Note: This flag may also be `false` due to
-                                    compiler limitations]]
-  [[`X::min_value`] [`T`] [compile-time constant; `min_value` is only defined if
-                           `has_fixed_range` is `true`.  If it exists, it is
-                           equal to `v.min()`.]]
-  [[`X::max_value`] [`T`] [compile-time constant; `max_value` is only defined if
-                           `has_fixed_range` is `true`.  If it exists, it is
-                           equal to `v.max()`]] 
+  [[`X::result_type`] [`T`] [`std::numeric_limits<T>::is_specialized` is
+                             `true`, `T` is __LessThanComparable]]
+  [[`u.operator()()`] [`T`] [-]]
   [[`v.min()`] [`T`] [tight lower bound on the set of all values returned by
                       `operator()`. The return value of this function shall not
                       change during the lifetime of the object.]]
@@ -160,7 +130,7 @@
 provides a deterministic sequence of pseudo-random numbers, based on some
 algorithm and internal state.
 [classref boost::random::linear_congruential_engine
-Linear congruential] and [classref boost::random::inversive_congruential
+Linear congruential] and [classref boost::random::inversive_congruential_engine
 inversive congruential] generators are examples of such [prng pseudo-random
 number generators]. Often, these generators are very sensitive to their
 parameters. In order to prevent wrong implementations from being used, an
@@ -187,20 +157,13 @@
   [[`X()`] [-] [creates a generator in some implementation-defined state.
                 Note: Several generators thusly created may possibly produce
                 dependent or identical sequences of random numbers.]]
-  [[`explicit X(...)`] [-] [creates a generator with user-provided state; the
+  [[`X(...)`] [-] [creates a generator with user-provided state; the
                             implementation shall specify the constructor
                             argument(s)]]
   [[`u.seed(...)`] [`void`] [sets the current state according to the
                              argument(s); at least functions with the same
                              signature as the non-default constructor(s)
                              shall be provided.]]
-  [[`X::validation(x)`] [`bool`] [compares the pre-computed and hardcoded
-                                  10001th element in the generator's random
-                                  number sequence with x. The generator must
-                                  have been constructed by its default
-                                  constructor and seed must not have been
-                                  called for the validation to be
-                                  meaningful.]]
 ]
 
 [note The seed member function is similar to the assign member function in
@@ -220,7 +183,7 @@
 pseudo-random number generator with the restored state and the original at
 the just-written state shall be equivalent.
 
-Classes which model a pseudo-random number generator may also model the
+Classes which model a pseudo-random number generator should also model the
 __CopyConstructible and __Assignable concepts. However, note that the
 sequences of the original and the copy are strongly correlated (in fact,
 they are identical), which may make them unsuitable for some problem domains.
@@ -248,16 +211,16 @@
 `e` is an lvalue of an arbitrary type that meets the requirements of a
 __UniformRandomNumberGenerator, returning values of type `U`.
 
-[table Random distribution requirements (in addition to NumberGenerator, CopyConstructible, and Assignable)
+[table Random distribution requirements (in addition to CopyConstructible, and Assignable)
   [[expression] [return type] [pre/post-condition] [complexity]]
-  [[`X::input_type`] [`U`] [-] [compile-time]]
+  [[`X::result_type`] [`T`] [-] [compile-time]]
   [[`u.reset()`] [`void`] [subsequent uses of `u` do not depend on values
-                           produced by `e` prior to invoking `reset`.]
+                           produced by any engine prior to invoking `reset`.]
                          [constant]]
   [[`u(e)`] [`T`] [the sequence of numbers returned by successive invocations
                    with the same object `e` is randomly distributed with some
                    probability density function `p(x)`]
-                  [amortized constant  number of invocations of `e`]]
+                  [amortized constant number of invocations of `e`]]
   [[`os << x`] [`std::ostream&`] [writes a textual representation for the
                                   parameters and additional internal data of
                                   the distribution `x` to `os`.

Modified: trunk/libs/random/doc/distributions.qbk
==============================================================================
--- trunk/libs/random/doc/distributions.qbk	(original)
+++ trunk/libs/random/doc/distributions.qbk	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -18,24 +18,28 @@
 values of the specified distribution or otherwise do not converge
 statistically to it are not acceptable.
 
-[table distributions
+[table Uniform Distributions
   [[distribution] [explanation] [example]]
   [[__uniform_smallint] [discrete uniform distribution on a small set of integers
                          (much smaller than the range of the underlying
                          generator)]
                         [drawing from an urn]]
-  [[__uniform_int] [discrete uniform distribution on a set of integers; the
+  [[__uniform_int_distribution] [discrete uniform distribution on a set of integers; the
                     underlying generator may be called several times to gather
                     enough randomness for the output]
                    [drawing from an urn]]
   [[__uniform_01] [continuous uniform distribution on the range [0,1);
                    important basis for other distributions]
                   [-]]
-  [[__uniform_real] [continuous uniform distribution on some range [min, max) of
+  [[__uniform_real_distribution] [continuous uniform distribution on some range [min, max) of
                      real numbers]
                     [for the range [0, 2pi): randomly dropping a stick and
                      measuring its angle in radians (assuming the angle is
                      uniformly distributed)]]
+]
+
+[table Bernoulli Distributions
+  [[distribution] [explanation] [example]]
   [[__bernoulli_distribution] [Bernoulli experiment: discrete boolean valued
                                distribution with configurable probability]
                               [tossing a coin (p=0.5)]]
@@ -43,21 +47,33 @@
                               experiments]
                              [tossing a coin 20 times and counting how many
                                 front sides are shown]]
-  [[__cauchy_distribution][cauchy distribution][-]]
-  [[__discrete_distribution][discrete distribution with specific probabilities][rolling an unfair die]]
-  [[__gamma_distribution][gamma distribution][-]]
-  [[__poisson_distribution][poisson distribution]
-                           [counting the number of alpha particles emitted
-                            by radioactive matter in a fixed period of time]]
   [[__geometric_distribution] [measures distance between outcomes of repeated
                              Bernoulli experiments]
                             [throwing a die several times and counting the
                              number of tries until a "6" appears for the
                              first time]]
-  [[__triangle_distribution] [triangle distribution] [-]]
+  [[__negative_binomial_distribution] [Counts the number of failures of repeated
+                             Bernoulli experiments required to get some constant
+                             number of successes.]
+                            [flipping a coin and counting the number of
+                             heads that show up before we get 3 tails]]
+]
+
+[table Poisson Distributions
+  [[distribution] [explanation] [example]]
+  [[__poisson_distribution][poisson distribution]
+                           [counting the number of alpha particles emitted
+                            by radioactive matter in a fixed period of time]]
   [[__exponential_distribution] [exponential distribution]
                                 [measuring the inter-arrival time of alpha
                                  particles emitted by radioactive matter]]
+  [[__gamma_distribution][gamma distribution][-]]
+  [[__weibull_distribution] [weibull distribution] [-]]
+  [[__extreme_value_distribution] [extreme value distribution] [-]]
+]
+
+[table Normal Distributions
+  [[distribution] [explanation] [example]]
   [[__normal_distribution] [counts outcomes of (infinitely) repeated Bernoulli
                             experiments]
                            [tossing a coin 10000 times and counting how many
@@ -66,8 +82,23 @@
                                simulations)]
                               [measuring the job completion time of an assembly
                                line worker]]
-  [[__weibull_distribution] [weibull distribution] [-]]
-  [[__extreme_value_distribution] [extreme value distribution] [-]]
+  [[__chi_squared_distribution][chi-squared distribution][-]]
+  [[__cauchy_distribution][Cauchy distribution][-]]
+  [[__fisher_f_distribution][Fisher F distribution][-]]
+  [[__student_t_distribution][Student t distribution][-]]
+]
+
+[table Sampling Distributions
+  [[distribution] [explanation] [example]]
+  [[__discrete_distribution][discrete distribution with specific probabilities][rolling an unfair die]]
+  [[__piecewise_constant_distribution][-][-]]
+  [[__piecewise_linear_distribution][-][-]]
+]
+
+
+[table Miscellaneous Distributions
+  [[distribution] [explanation] [example]]
+  [[__triangle_distribution] [triangle distribution] [-]]
   [[__uniform_on_sphere] [uniform distribution on a unit sphere of arbitrary
                           dimension]
                          [choosing a random point on Earth (assumed to be a

Modified: trunk/libs/random/doc/random.qbk
==============================================================================
--- trunk/libs/random/doc/random.qbk	(original)
+++ trunk/libs/random/doc/random.qbk	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -26,30 +26,30 @@
 [def __EqualityComparable [@boost:/doc/html/EqualityComparable.html EqualityComparable]]
 [def __Streamable Streamable]
 
-[def __random_device [classref boost::random_device random_device]]
+[def __random_device [classref boost::random::random_device random_device]]
 [def __random_number_generator [classref boost::random_number_generator random_number_generator]]
 [def __variate_generator [classref boost::variate_generator variate_generator]]
 
 [def __minstd_rand0 [classref boost::random::minstd_rand0 minstd_rand0]]
 [def __minstd_rand [classref boost::random::minstd_rand minstd_rand]]
 [def __rand48 [classref boost::random::rand48 rand48]]
-[def __ecuyer1988 [classref boost::ecuyer1988 ecuyer1988]]
+[def __ecuyer1988 [classref boost::random::ecuyer1988 ecuyer1988]]
 [def __kreutzer1986 [classref boost::random::kreutzer1986 kreutzer1986]]
 [def __knuth_b [classref boost::random::knuth_b knuth_b]]
-[def __taus88 [classref boost::taus88 taus88]]
-[def __hellekalek1995 [classref boost::hellekalek1995 hellekalek1995]]
+[def __taus88 [classref boost::random::taus88 taus88]]
+[def __hellekalek1995 [classref boost::random::hellekalek1995 hellekalek1995]]
 [def __mt11213b [classref boost::random::mt11213b mt11213b]]
 [def __mt19937 [classref boost::random::mt19937 mt19937]]
 [def __mt19937_64 [classref boost::random::mt19937_64 mt19937_64]]
-[def __lagged_fibonacci607 [classref boost::lagged_fibonacci607 lagged_fibonacci607]]
-[def __lagged_fibonacci1279 [classref boost::lagged_fibonacci1279 lagged_fibonacci1279]]
-[def __lagged_fibonacci2281 [classref boost::lagged_fibonacci2281 lagged_fibonacci2281]]
-[def __lagged_fibonacci3217 [classref boost::lagged_fibonacci3217 lagged_fibonacci3217]]
-[def __lagged_fibonacci4423 [classref boost::lagged_fibonacci4423 lagged_fibonacci4423]]
-[def __lagged_fibonacci9689 [classref boost::lagged_fibonacci9689 lagged_fibonacci9689]]
-[def __lagged_fibonacci19937 [classref boost::lagged_fibonacci19937 lagged_fibonacci19937]]
-[def __lagged_fibonacci23209 [classref boost::lagged_fibonacci23209 lagged_fibonacci23209]]
-[def __lagged_fibonacci44497 [classref boost::lagged_fibonacci44497 lagged_fibonacci44497]]
+[def __lagged_fibonacci607 [classref boost::random::lagged_fibonacci607 lagged_fibonacci607]]
+[def __lagged_fibonacci1279 [classref boost::random::lagged_fibonacci1279 lagged_fibonacci1279]]
+[def __lagged_fibonacci2281 [classref boost::random::lagged_fibonacci2281 lagged_fibonacci2281]]
+[def __lagged_fibonacci3217 [classref boost::random::lagged_fibonacci3217 lagged_fibonacci3217]]
+[def __lagged_fibonacci4423 [classref boost::random::lagged_fibonacci4423 lagged_fibonacci4423]]
+[def __lagged_fibonacci9689 [classref boost::random::lagged_fibonacci9689 lagged_fibonacci9689]]
+[def __lagged_fibonacci19937 [classref boost::random::lagged_fibonacci19937 lagged_fibonacci19937]]
+[def __lagged_fibonacci23209 [classref boost::random::lagged_fibonacci23209 lagged_fibonacci23209]]
+[def __lagged_fibonacci44497 [classref boost::random::lagged_fibonacci44497 lagged_fibonacci44497]]
 [def __ranlux3 [classref boost::random::ranlux3 ranlux3]]
 [def __ranlux4 [classref boost::random::ranlux4 ranlux4]]
 [def __ranlux64_3 [classref boost::random::ranlux64_3 ranlux64_3]]
@@ -61,24 +61,30 @@
 [def __ranlux24 [classref boost::random::ranlux24 ranlux24]]
 [def __ranlux48 [classref boost::random::ranlux48 ranlux48]]
 
-[def __uniform_smallint [classref boost::uniform_smallint uniform_smallint]]
-[def __uniform_int [classref boost::uniform_int uniform_int]]
-[def __uniform_01 [classref boost::uniform_01 uniform_01]]
-[def __uniform_real [classref boost::uniform_real uniform_real]]
-[def __bernoulli_distribution [classref boost::bernoulli_distribution bernoulli_distribution]]
+[def __uniform_smallint [classref boost::random::uniform_smallint uniform_smallint]]
+[def __uniform_int_distribution [classref boost::random::uniform_int_distribution uniform_int_distribution]]
+[def __uniform_01 [classref boost::random::uniform_01 uniform_01]]
+[def __uniform_real_distribution [classref boost::random::uniform_real_distribution uniform_real_distribution]]
+[def __bernoulli_distribution [classref boost::random::bernoulli_distribution bernoulli_distribution]]
 [def __binomial_distribution [classref boost::random::binomial_distribution binomial_distribution]]
-[def __cauchy_distribution [classref boost::cauchy_distribution cauchy_distribution]]
+[def __cauchy_distribution [classref boost::random::cauchy_distribution cauchy_distribution]]
 [def __discrete_distribution [classref boost::random::discrete_distribution discrete_distribution]]
 [def __gamma_distribution [classref boost::random::gamma_distribution gamma_distribution]]
 [def __poisson_distribution [classref boost::random::poisson_distribution poisson_distribution]]
-[def __geometric_distribution [classref boost::geometric_distribution geometric_distribution]]
-[def __triangle_distribution [classref boost::triangle_distribution triangle_distribution]]
-[def __exponential_distribution [classref boost::exponential_distribution exponential_distribution]]
-[def __normal_distribution [classref boost::normal_distribution normal_distribution]]
-[def __lognormal_distribution [classref boost::lognormal_distribution lognormal_distribution]]
-[def __uniform_on_sphere [classref boost::uniform_on_sphere uniform_on_sphere]]
+[def __geometric_distribution [classref boost::random::geometric_distribution geometric_distribution]]
+[def __triangle_distribution [classref boost::random::triangle_distribution triangle_distribution]]
+[def __exponential_distribution [classref boost::random::exponential_distribution exponential_distribution]]
+[def __normal_distribution [classref boost::random::normal_distribution normal_distribution]]
+[def __lognormal_distribution [classref boost::random::lognormal_distribution lognormal_distribution]]
+[def __uniform_on_sphere [classref boost::random::uniform_on_sphere uniform_on_sphere]]
 [def __weibull_distribution [classref boost::random::weibull_distribution weibull_distribution]]
 [def __extreme_value_distribution [classref boost::random::extreme_value_distribution extreme_value_distribution]]
+[def __negative_binomial_distribution [classref boost::random::negative_binomial_distribution negative_binomial_distribution]]
+[def __student_t_distribution [classref boost::random::student_t_distribution student_t_distribution]]
+[def __fisher_f_distribution [classref boost::random::fisher_f_distribution fisher_f_distribution]]
+[def __chi_squared_distribution [classref boost::random::chi_squared_distribution chi_squared_distribution]]
+[def __piecewise_constant_distribution [classref boost::random::piecewise_constant_distribution piecewise_constant_distribution]]
+[def __piecewise_linear_distribution [classref boost::random::piecewise_linear_distribution piecewise_linear_distribution]]
 
 [include performance_data.qbk]
 
@@ -97,11 +103,10 @@
 
   ``[classref boost::random::mt19937]`` rng;         // produces randomness out of thin air
                                       // see pseudo-random number generators
-  ``[classref boost::uniform_int]<>`` six(1,6);      // distribution that maps to 1..6
+  ``[classref boost::random::uniform_int_distribution]<>`` six(1,6);
+                                      // distribution that maps to 1..6
                                       // see random number distributions
-  ``[classref boost::variate_generator]``<``[classref boost::random::mt19937]``&, ``[classref boost::uniform_int]``<> >
-           die(rng, six);             // glues randomness with mapping
-  int x = die();                      // simulate rolling a die
+  int x = six(rng);                   // simulate rolling a die
 
 [endsect]
 
@@ -131,17 +136,6 @@
 [include performance.qbk]
 [endsect]
 
-[section Rationale]
-
-The methods for generating and evaluating deterministic and non-deterministic
-random numbers differ radically. Furthermore, due to the inherent
-deterministic design of present-day computers, it is often difficult to
-implement non-deterministic random number generation facilities. Thus, the
-random number library is split into separate header files, mirroring the two
-different application domains.
-
-[endsect]
-
 [section History and Acknowledgements]
 
 In November 1999, Jeet Sukumaran proposed a framework based on virtual

Modified: trunk/libs/random/example/die.cpp
==============================================================================
--- trunk/libs/random/example/die.cpp	(original)
+++ trunk/libs/random/example/die.cpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -12,11 +12,10 @@
     For the source of this example see
     [@boost://libs/random/example/die.cpp die.cpp].
     First we include the headers we need for __mt19937
-    and __uniform_int.
+    and __uniform_int_distribution.
 */
 #include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_int.hpp>
-#include <boost/random/variate_generator.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
 
 /*`
   We use __mt19937 with the default seed as a source of
@@ -38,24 +37,17 @@
 int roll_die() {
     /*<< __mt19937 produces integers in the range [0, 2[sup 32]-1].
         However, we want numbers in the range [1, 6].  The distribution
-        __uniform_int performs this transformation.
-        [warning Contrary to common C++ usage __uniform_int
+        __uniform_int_distribution performs this transformation.
+        [warning Contrary to common C++ usage __uniform_int_distribution
         does not take a /half-open range/.  Instead it takes a /closed range/.
-        Given the parameters 1 and 6, __uniform_int can
+        Given the parameters 1 and 6, __uniform_int_distribution can
         can produce any of the values 1, 2, 3, 4, 5, or 6.]
     >>*/
-    boost::uniform_int<> dist(1, 6);
-    /*<< __variate_generator combines a generator with a distribution.
-        [important We pass [classref boost::random::mt19937 boost::mt19937&] to
-        __variate_generator instead of just [classref boost::random::mt19937]
-        (note the reference).  Without the reference, __variate_generator
-        would make a copy of the generator and would leave the global
-        `gen` unchanged.  Consequently, `roll_die` would produce *the same value*
-        every time it was called.]
+    boost::random::uniform_int_distribution<> dist(1, 6);
+    /*<< A distribution is a function object.  We generate a random
+        number by calling `dist` with the generator.
     >>*/
-    boost::variate_generator<boost::random::mt19937&, boost::uniform_int<> > die(gen, dist);
-    /*<< A __variate_generator is a function object. >>*/
-    return die();
+    return dist(gen);
 }
 //]
 

Modified: trunk/libs/random/example/password.cpp
==============================================================================
--- trunk/libs/random/example/password.cpp	(original)
+++ trunk/libs/random/example/password.cpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -17,9 +17,8 @@
  */
 
 
-#include <boost/nondet_random.hpp>
-#include <boost/random/variate_generator.hpp>
-#include <boost/random/uniform_int.hpp>
+#include <boost/random/random_device.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
 
 int main() {
     /*<< We first define the characters that we're going
@@ -35,14 +34,13 @@
     /*<< We use __random_device as a source of entropy, since we want
          passwords that are not predictable.
     >>*/
-    boost::random_device rng;
+    boost::random::random_device rng;
     /*<< Finally we select 8 random characters from the
          string and print them to cout.
     >>*/
-    boost::variate_generator<boost::random_device&, boost::uniform_int<> >
-        gen(rng, boost::uniform_int<>(0, chars.size()));
+    boost::random::uniform_int_distribution<> index_dist(0, chars.size() - 1);
     for(int i = 0; i < 8; ++i) {
-        std::cout << chars[gen()];
+        std::cout << chars[index_dist(rng)];
     }
     std::cout << std::endl;
 }

Modified: trunk/libs/random/example/weighted_die.cpp
==============================================================================
--- trunk/libs/random/example/weighted_die.cpp	(original)
+++ trunk/libs/random/example/weighted_die.cpp	2011-02-12 22:28:59 EST (Sat, 12 Feb 2011)
@@ -13,12 +13,7 @@
     [@boost://libs/random/example/weighted_die.cpp weighted_die.cpp].
 */
 #include <boost/random/mersenne_twister.hpp>
-#include <boost/random/uniform_real.hpp>
-#include <boost/random/variate_generator.hpp>
-#include <vector>
-#include <algorithm>
-#include <numeric>
-#include <iterator>
+#include <boost/random/discrete_distribution.hpp>
 
 boost::mt19937 gen;
 
@@ -26,27 +21,27 @@
    This time, instead of a fair die, the probability of
    rolling a 1 is 50% (!).  The other five faces are all
    equally likely.
+
+   __discrete_distribution works nicely here by allowing
+   us to assign weights to each of the possible outcomes.
+
+   [tip If your compiler supports `std::initializer_list`,
+   you can initialize __discrete_distribution directly with
+   the weights.]
 */
-static const double probabilities[] = {
+double probabilities[] = {
     0.5, 0.1, 0.1, 0.1, 0.1, 0.1
 };
+boost::random::discrete_distribution<> dist(probabilities);
 
 /*`
   Now define a function that simulates rolling this die.
-  Note that the C++0x library contains a `discrete_distribution`
-  class which would be a better way to do this.
 */
 int roll_weighted_die() {
-    std::vector<double> cumulative;
-    std::partial_sum(&probabilities[0], &probabilities[0] + 6,
-                     std::back_inserter(cumulative));
-    boost::uniform_real<> dist(0, cumulative.back());
-    boost::variate_generator<boost::mt19937&, boost::uniform_real<> > die(gen, dist);
-    /*<< Find the position within the sequence and add 1
-         (to make sure that the result is in the range [1,6]
-         instead of [0,5])
+    /*<< Add 1 to make sure that the result is in the range [1,6]
+         instead of [0,5].
     >>*/
-    return (std::lower_bound(cumulative.begin(), cumulative.end(), die()) - cumulative.begin()) + 1;
+    return dist(gen) + 1;
 }
 
 //]