[boost-doc-zh commit] r202 - trunk/libs/random

  • From: codesite-noreply@xxxxxxxxxx
  • To: boost-doc-zh-notify@xxxxxxxxxxxxx
  • Date: Tue, 20 Jan 2009 23:32:41 +0000

Author: xiaqqaix@xxxxxxxxx
Date: Tue Jan 20 06:26:10 2009
New Revision: 202

Modified:
   trunk/libs/random/random-generators.html

Log:
导入先前的成果

Modified: trunk/libs/random/random-generators.html
==============================================================================
--- trunk/libs/random/random-generators.html    (original)
+++ trunk/libs/random/random-generators.html    Tue Jan 20 06:26:10 2009
@@ -2,95 +2,59 @@

 <html>
 <head>
-  <meta http-equiv="Content-Type" content="text/html; charset=us-ascii">
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">

-  <title>Boost Random Number Library Generators</title>
+  <title>Boost 随机数库:生成器</title>
 </head>

 <body bgcolor="#FFFFFF" text="#000000">
-  <h1>Random Number Library Generators</h1>
+  <h1>随机数库:生成器</h2>

   <ul>
-    <li><a href="#intro">Introduction</a></li>
+    <li><a href="#intro">简介</a></li>

-    <li><a href="#synopsis">Synopsis</a></li>
+    <li><a href="#synopsis">概览</a></li>

-    <li><a href="#const_mod">Class template
-    <code>random::const_mod</code></a></li>
+    <li><a href="#const_mod"><code>random::const_mod</code> 类模板</a></li>

-    <li><a href="#linear_congruential">Class template
-    <code>random::linear_congruential</code></a></li>
+ <li><a href="#linear_congruential"><code>random::linear_congruential</code> 类模板 </a></li>

-    <li><a href="#rand48">Class <code>rand48</code></a></li>
+    <li><a href="#rand48"><code>rand48</code> 类</a></li>

-    <li><a href="#additive_combine">Class template
-    <code>random::additive_combined</code></a></li>
+ <li><a href="#additive_combine"><code>random::additive_combined</code> 类模板</a></li>

-    <li><a href="#shuffle_output">Class template
-    <code>random::shuffle_output</code></a></li>
+ <li><a href="#shuffle_output"><code>random::shuffle_output</code> 类模 板</a></li>

-    <li><a href="#inversive_congruential">Class template
-    <code>random::inversive_congruential</code></a></li>
+ <li><a href="#inversive_congruential"><code>random::inversive_congruential</code> 类模板</a></li>

-    <li><a href="#mersenne_twister">Class template
-    <code>random::mersenne_twister</code></a></li>
+ <li><a href="#mersenne_twister"><code>random::mersenne_twister</code> 类模板</a></li>

-    <li><a href="#lagged_fibonacci">Class template
-    <code>random::lagged_fibonacci</code></a></li>
+ <li><a href="#lagged_fibonacci"><code>random::lagged_fibonacci</code> 类模板</a></li>

-    <li><a href="#performance">Performance</a></li>
+    <li><a href="#performance">性能</a></li>
   </ul>

-  <h2><a name="intro" id="intro">Introduction</a></h2>
+  <h2><a name="intro" id="intro">简介</a></h2>

-  <p>This library provides several pseudo-random number generators. The
-  quality of a pseudo-random number generator crucially depends on both the
-  algorithm and its parameters. This library implements the algorithms as
-  class templates with template value parameters, hidden in namespace
-  <code>boost::random</code>. Any particular choice of parameters is
-  represented as the appropriately specializing <code>typedef</code> in
-  namespace <code>boost</code>.</p>
-
- <p>Pseudo-random number generators should not be constructed (initialized) - frequently during program execution, for two reasons. First, initialization - requires full initialization of the internal state of the generator. Thus,
-  generators with a lot of internal state (see below) are costly to
-  initialize. Second, initialization always requires some value used as a
-  "seed" for the generated sequence. It is usually difficult to obtain
-  several good seed values. For example, one method to obtain a seed is to
-  determine the current time at the highest resolution available, e.g.
-  microseconds or nanoseconds. When the pseudo-random number generator is
- initialized again with the then-current time as the seed, it is likely that - this is at a near-constant (non-random) distance from the time given as the
-  seed for first initialization. The distance could even be zero if the
-  resolution of the clock is low, thus the generator re-iterates the same
-  sequence of random numbers. For some applications, this is
-  inappropriate.</p>
-
-  <p>Note that all pseudo-random number generators described below are
-  CopyConstructible and Assignable. Copying or assigning a generator will
- copy all its internal state, so the original and the copy will generate the
-  identical sequence of random numbers. Often, such behavior is not wanted.
-  In particular, beware of the algorithms from the standard library such as
- std::generate. They take a functor argument by value, thereby invoking the
-  copy constructor when called.</p>
-
-  <p>The following table gives an overview of some characteristics of the
-  generators. The cycle length is a rough estimate of the quality of the
- generator; the approximate relative speed is a performance measure, higher
-  numbers mean faster random number generation.</p>
+ <p>本库提供了数个伪随机数生成器。伪随机数生成器的性质与其算法和参数都有密 切的关系。生成算法用取数值参数的类模板实现,封装在 <code>boost::random</code> 名字空间中。预先选择好的一组参数通过用 <code>typedef</code> 进行专门化来给出,置于 <code>boost</code> 名字空间中。 </p>
+
+ <p>程序执行过程中不应当频繁构造伪随机数生成器。原因有二:其一,生成器的构 造要求对其内部状态进行完全的初始化;因此包含大量内部状态的生成器 (详下) 的构 造往往是昂贵的。其二,生成器的构造需要提供序列的“种子”。取得多个良好的“种子 ”值往往是困难的。取得种子的方法之一是使用精确度尽可能高 (毫秒甚至纳秒) 的系 统时间。如果再构建一个生成器之后再构建另一个,那么它们所使用的种子值之差会很 接近一个常数。若系统时间的精确度不够高,这个差值甚至为零,从而得到两个行为相 同的生成器。对于很多应用,这样的行为都是不合适的。</p>
+
+ <p>注意以下描述的所有伪随机数生成器都是 CopyConstructible and Assignable。生成器的复制或赋值将会复制其内部状态,因此原有生成器和副本将会生 成完全相同的随机数序列。这种行为往往不是需要的。特别注意标准库中的算法,如 std::generate。它们取函子的值作为参数,因此会调用复制构造函数。</p>
+
+ <p>下表给出了生成器某些性质的概览。循环长度是给出了生成器性质的粗略描 述;相对速度是性能的量度,值越大表示随机数生成越快。</p>

   <table border="1" summary="">
     <tr>
-      <th>generator</th>
+      <th>生成器</th>

-      <th>length of cycle</th>
+      <th>循环长度</th>

-      <th>approx. memory requirements</th>
+      <th>内存需求 (近似)</th>

-      <th>approx. relative speed</th>
+      <th>相对速度 (近似)</th>

-      <th>comment</th>
+      <th>备注</th>
     </tr>

     <tr>
@@ -126,13 +90,13 @@

       <td>20</td>

-      <td>global state</td>
+      <td>状态由全局变量保存</td>
     </tr>

     <tr>
       <td><a href="#ecuyer1988"><code>ecuyer1988</code></a></td>

-      <td>approx. 2<sup>61</sup></td>
+      <td>约 2<sup>61</sup></td>

       <td><code>2*sizeof(int32_t)</code></td>

@@ -193,7 +157,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci607</a></code></td>

-      <td>approx. 2<sup>32000</sup></td>
+      <td>约 2<sup>32000</sup></td>

       <td><code>607*sizeof(double)</code></td>

@@ -206,7 +170,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci1279</a></code></td>

-      <td>approx. 2<sup>67000</sup></td>
+      <td>约 2<sup>67000</sup></td>

       <td><code>1279*sizeof(double)</code></td>

@@ -219,7 +183,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci2281</a></code></td>

-      <td>approx. 2<sup>120000</sup></td>
+      <td>约 2<sup>120000</sup></td>

       <td><code>2281*sizeof(double)</code></td>

@@ -232,7 +196,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci3217</a></code></td>

-      <td>approx. 2<sup>170000</sup></td>
+      <td>约 2<sup>170000</sup></td>

       <td><code>3217*sizeof(double)</code></td>

@@ -245,7 +209,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci4423</a></code></td>

-      <td>approx. 2<sup>230000</sup></td>
+      <td>约 2<sup>230000</sup></td>

       <td><code>4423*sizeof(double)</code></td>

@@ -258,7 +222,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci9689</a></code></td>

-      <td>approx. 2<sup>510000</sup></td>
+      <td>约 2<sup>510000</sup></td>

       <td><code>9689*sizeof(double)</code></td>

@@ -271,7 +235,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci19937</a></code></td>

-      <td>approx. 2<sup>1050000</sup></td>
+      <td>约 2<sup>1050000</sup></td>

       <td><code>19937*sizeof(double)</code></td>

@@ -284,7 +248,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci23209</a></code></td>

-      <td>approx. 2<sup>1200000</sup></td>
+      <td>约 2<sup>1200000</sup></td>

       <td><code>23209*sizeof(double)</code></td>

@@ -297,7 +261,7 @@
       <td><code><a href=
       "#lagged_fibonacci_spec">lagged_fibonacci44497</a></code></td>

-      <td>approx. 2<sup>2300000</sup></td>
+      <td>约 2<sup>2300000</sup></td>

       <td><code>44497*sizeof(double)</code></td>

@@ -307,29 +271,15 @@
     </tr>
   </table>

-  <p>As observable from the table, there is generally a
-  quality/performance/memory trade-off to be decided upon when choosing a
-  random-number generator. The multitude of generators provided in this
-  library allows the application programmer to optimize the trade-off with
-  regard to his application domain. Additionally, employing several
- fundamentally different random number generators for a given application of
-  Monte Carlo simulation will improve the confidence in the results.</p>
-
- <p>If the names of the generators don't ring any bell and you have no idea - which generator to use, it is reasonable to employ <code>mt19937</code> for
-  a start: It is fast and has acceptable quality.</p>
-
-  <p><em>Note:</em> These random number generators are not intended for use
-  in applications where non-deterministic random numbers are required. See
-  <a href="nondet_random.html">nondet_random.html</a> for a choice of
-  (hopefully) non-deterministic random number generators.</p>
-
- <p>In this description, I have refrained from documenting those members in
-  detail which are already defined in the <a href=
-  "random-concepts.html">concept documentation</a>.</p>
+ <p>可以从上表中观察到,选择随机数生成器时往往要在品质、性能、内存三者之间 作出权衡。本库中提供的大量生成器足以让程序员选择最适合自己应用领域的一个。此 外,在 Monte Carlo 模拟中使用多个有着根本性不同的随机数生成器将会提高结果的 可信度。</p>
+
+ <p>如果你不知如何选择,不妨先使用 <code>mt19937</code>:它快速、可靠。 </p>
+
+ <p><em>注意:</em>以上随机数生成器不能用于要求使用不确定随机数的应用领 域;关于不确定随机数生成器,参看 <a href="nondet_random.html">nondet_random.html</a>。</p>
+
+ <p>对于在 <a href="random-concepts.html">概念文档</a> 中已经给出定义的成 员,在下面的描述中不会详细说明。</p>

-  <h2><a name="synopsis" id="synopsis">Synopsis of the generators</a>
-  available from header <code>&lt;boost/random.hpp&gt;</code></h2>
+ <h2><code>&lt;boost/random.hpp&gt;</code> 中的生成器:<a name="synopsis" id="synopsis">概览</a></h2>
   <pre>
 namespace boost {
   namespace random {
@@ -366,10 +316,9 @@
 } // namespace boost
 </pre>

-  <h2><a name="const_mod" id="const_mod">Class template
-  <code>random::const_mod</code></a></h2>
+ <h2><a name="const_mod" id="const_mod"><code>random::const_mod</code> 类 模板</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 template&lt;class IntType, IntType m&gt;
 class random::const_mod
@@ -390,18 +339,13 @@
 };
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

-  <p>Class template <code>const_mod</code> provides functions performing
- modular arithmetic, carefully avoiding overflows. All member functions are
-  static; there shall be no objects of type
-  <code>const_mod&lt;&gt;</code>.</p>
+ <p><code>const_mod</code> 类模板提供了同余运算 (模运算) 函数;这些函数小 心设计,确保不会造成溢出。所有的成员函数都是静态 的;<code>const_mod&lt;&gt;</code> 不允许实例化。</p>

-  <p>The template parameter <code>IntType</code> shall denote an integral
-  type, <code>m</code> is the modulus.</p>
+ <p>模板参数 <code>IntType</code> 为某一整数类型,<code>m</code> 为模数 (modulus)。</p>

-  <p><em>Note:</em> For modulo multiplications with large m, a trick allows
-  fast computation under certain conditions, see</p>
+ <p><em>注记:</em>以下资料给出了一个方法,允许 m 值很大时仍能快速进行同余 乘法:</p>

   <blockquote>
     "A more portable FORTRAN random number generator", Linus Schrage, ACM
@@ -409,34 +353,33 @@
     132-138
   </blockquote>

-  <h3>Member functions</h3>
+  <h3>成员函数</h3>
   <pre>
 template&lt;IntType c&gt; static IntType add(IntType x)
 </pre>

-  <p><strong>Returns:</strong> (x+c) mod m</p>
+  <p><strong>返回:</strong> (x+c) mod m</p>
   <pre>
 template&lt;IntType a&gt; static IntType mult(IntType x)
 </pre>

-  <p><strong>Returns:</strong> (a*x) mod m</p>
+  <p><strong>返回:</strong> (a*x) mod m</p>
   <pre>
 template&lt;IntType a, IntType c&gt; static IntType
 mult_add(IntType x)
 </pre>

-  <p><strong>Returns:</strong> (a*x+c) mod m</p>
+  <p><strong>返回:</strong> (a*x+c) mod m</p>
   <pre>
 static IntType invert(IntType x)
 </pre>

-  <p><strong>Returns:</strong> i so that (a*i) mod m == 1<br>
-  <strong>Precondition:</strong> m is prime</p>
+  <p><strong>返回:</strong>  满足 (a*i) mod m == 1 的 i<br>
+  <strong>前条件</strong> m 为质数</p>

-  <h2><a name="linear_congruential" id="linear_congruential">Class template
-  <code>random::linear_congruential</code></a></h2>
+ <h2><a name="linear_congruential" id="linear_congruential"><code>random::linear_congruential</code> 类模板 </a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 
"../../boost/random/linear_congruential.hpp">boost/random/linear_congruential.hpp</a>&gt;
@@ -464,56 +407,41 @@
      399268537L&gt; minstd_rand;
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

- <p>Instantiations of class template <code>linear_congruential</code> model
-  a <a href="random-concepts.html#pseudo-rng">pseudo-random number
-  generator</a>. Linear congruential pseudo-random number generators are
-  described in:</p>
+ <p><code>linear_congruential</code> 类模板的实例是 <a href="random-concepts.html#pseudo-rng">伪随机数生成器</a> 的模型。以下资料给 出了线性同余 (linear congruential) 伪随机数生成器的描述:</p>

   <blockquote>
     "Mathematical methods in large-scale computing units", D. H. Lehmer,
Proc. 2nd Symposium on Large-Scale Digital Calculating Machines, Harvard
     University Press, 1951, pp. 141-146
-  </blockquote>Let x(n) denote the sequence of numbers returned by some
- pseudo-random number generator. Then for the linear congruential generator,
-  x(n+1) := (a * x(n) + c) mod m. Parameters for the generator are x(0), a,
- c, m. The template parameter <code>IntType</code> shall denote an integral
-  type. It must be large enough to hold values a, c, and m. The template
-  parameters a and c must be smaller than m.
+  </blockquote>
+ 令 x(n) 为伪随机数生成器的返回值序列。对于线性同余生成器,有 x(n+1) := (a * x(n) + c) mod m。生成器的参数是 x(0), a, c, m。模板参数 <code>IntType</code> 为某一整数类型,a, c, m 须在其可表示范围内。a, c 应小 于 m。

-  <p><em>Note:</em> The quality of the generator crucially depends on the
-  choice of the parameters. User code should use one of the sensibly
-  parameterized generators such as <code>minstd_rand</code> instead.<br>
-  For each choice of the parameters a, c, m, some distinct type is defined,
- so that the <code>static</code> members do not interfere with regard to the
-  one definition rule.</p>
+ <p><em>注意:</em> 此生成器的品质很大程度上取决于参数的选择。用户代码应该 使用已经选择好参数的生成器,如 <code>minstd_rand</code>。<br> +对参数 a, c, m 的每一组选择,都附带定义了一些类别,从而 <code>static</code> 成员不会违反单一定义原则。</p>

-  <h3>Members</h3>
+  <h3>成员</h3>
   <pre>
 explicit linear_congruential(IntType x0 = 1)
 </pre>

- <p><strong>Effects:</strong> Constructs a <code>linear_congruential</code>
-  generator with x(0) := <code>x0</code>.</p>
+ <p><strong>效果:</strong>构造一 <code>linear_congruential</code> 生成 器,令其 x(0) := <code>x0</code>。</p>
   <pre>
 void seed(IntType x0)
 </pre>

-  <p><strong>Effects:</strong> Changes the current value x(n) of the
-  generator to <code>x0</code>.</p>
+  <p><strong>效果:</strong>令生成器当前的 x(n) 值为 <code>x0</code>。</p>

-  <h3><a name="minstd_rand" id="minstd_rand">Specializations</a></h3>
+  <h3><a name="minstd_rand" id="minstd_rand">专门化</a></h3>

-  <p>The specialization <code>minstd_rand0</code> was originally suggested
-  in</p>
+  <p>专门化 <code>minstd_rand0</code> 来自以下资料:</p>

   <blockquote>
     A pseudo-random number generator for the System/360, P.A. Lewis, A.S.
     Goodman, J.M. Miller, IBM Systems Journal, Vol. 8, No. 2, 1969, pp.
     136-146
-  </blockquote>It is examined more closely together with
-  <code>minstd_rand</code> in
+ </blockquote>以下资料中有 <code>minstd_rand0</code> 以及 <code>minstd_rand</code> 的讨论:

   <blockquote>
     "Random Number Generators: Good ones are hard to find", Stephen K. Park
@@ -521,9 +449,9 @@
     1988, pp. 1192-1201
   </blockquote>

-  <h2><a name="rand48" id="rand48">Class <code>rand48</code></a></h2>
+  <h2><a name="rand48" id="rand48"><code>rand48</code> 类</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 
"../../boost/random/linear_congruential.hpp">boost/random/linear_congruential.hpp</a>&gt;
@@ -545,51 +473,39 @@
 };
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>
+
+ <p><code>rand48</code> 类是 <a href="random-concepts.html#pseudo-rng">伪 随机数生成器</a>的模型。它使用线性同余算法,其中参数 a = 0x5DEECE66D, c = 0xB, m = 2**48。它能产生与某些系统上的 <code>lrand48()</code> 函数相同的结 果 (假设没有调用 <code>lcong48</code>)。</p>

-  <p>Class <code>rand48</code> models a <a href=
-  "random-concepts.html#pseudo-rng">pseudo-random number generator</a>. It
- uses the linear congruential algorithm with the parameters a = 0x5DEECE66D,
-  c = 0xB, m = 2**48. It delivers identical results to the
-  <code>lrand48()</code> function available on some systems (assuming
-  <code>lcong48</code> has not been called).</p>
-
- <p>It is only available on systems where <code>uint64_t</code> is provided
-  as an integral type, so that for example static in-class constants and/or
-  enum definitions with large <code>uint64_t</code> numbers work.</p>
+ <p>该类中的常量和枚举定义等使用了 <code>uint64_t</code>;如果系统没有提供 整数类型 <code>uint64_t</code>,该类不可用。</p>

-  <h3>Constructors</h3>
+  <h3>构造函数</h3>
   <pre>
 rand48(int32_t x0)
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>rand48</code> generator
-  with x(0) := (<code>x0</code> &lt;&lt; 16) | 0x330e.</p>
+ <p><strong>效果:</strong>构造一 <code>rand48</code> 生成器,令其 x(0) := (<code>x0</code> &lt;&lt; 16) | 0x330e。</p>
   <pre>
 rand48(uint64_t x0)
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>rand48</code> generator
-  with x(0) := <code>x0</code>.</p>
+ <p><strong>效果:</strong> 构造一 <code>rand48</code> 生成器,令其 x(0) := <code>x0</code>。</p>

-  <h3>Seeding</h3>
+  <h3>赋种</h3>
   <pre>
 void seed(int32_t x0)
 </pre>

-  <p><strong>Effects:</strong> Changes the current value x(n) of the
-  generator to (<code>x0</code> &lt;&lt; 16) | 0x330e.</p>
+ <p><strong>效果:</strong> 令生成器当前的 x(n) 值为 (<code>x0</code> &lt;&lt; 16) | 0x330e。</p>
   <pre>
 void seed(uint64_t x0)
 </pre>

-  <p><strong>Effects:</strong> Changes the current value x(n) of the
-  generator to <code>x0</code>.</p>
+  <p><strong>效果:</strong> 令生成器当前的 x(n) 值为 <code>x0</code>。</p>

-  <h2><a name="additive_combine" id="additive_combine">Class template
-  <code>random::additive_combine</code></a></h2>
+ <h2><a name="additive_combine" id="additive_combine"><code>random::additive_combine</code>类模板</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 
"../../boost/random/additive_combine.hpp">boost/random/additive_combine.hpp</a>&gt;
@@ -618,52 +534,38 @@

 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

-  <p>Instatiations of class template <code>additive_combine</code> model a
-  <a href="random-concepts.html#pseudo-rng">pseudo-random number
-  generator</a>. It combines two multiplicative linear congruential number
-  generators, i.e. those with c = 0. It is described in</p>
+ <p><code>additive_combine</code> 类模板的实例是 <a href="random-concepts.html#pseudo-rng">伪随机数生成器</a> 的模型。它把两个倍 增线性同余生成器 (即 c = 0 的生成器) 组合起来。以下资料给出了其描述:</p>

   <blockquote>
     "Efficient and Portable Combined Random Number Generators", Pierre
     L'Ecuyer, Communications of the ACM, Vol. 31, No. 6, June 1988, pp.
     742-749, 774
-  </blockquote>The template parameters <code>MLCG1</code> and
-  <code>MLCG2</code> shall denote two different linear congruential number
-  generators, each with c = 0. Each invocation returns a random number X(n)
-  := (MLCG1(n) - MLCG2(n)) mod (m1 - 1), where m1 denotes the modulus of
-  <code>MLCG1</code>.
+ </blockquote>模板参数 <code>MLCG1</code> 和 <code>MLCG2</code> 应为两个不 同的线性同余生成器,且都有 c = 0。每次调用返回 X(n) := (MLCG1(n) - MLCG2(n)) mod (m1 - 1),其中 m1 为 <code>MLCG1</code> 的模数。

- <p>The template parameter <code>val</code> is the validation value checked
-  by <code>validation</code>.</p>
+ <p>模板参数 <code>val</code> 为 <code>validation</code> 检验的参考值。 </p>

-  <h3>Members</h3>
+  <h3>成员</h3>
   <pre>
 additive_combine()
 </pre>

-  <p><strong>Effects:</strong> Constructs an <code>additive_combine</code>
-  generator using the default constructors of the two base generators.</p>
+ <p><strong>效果:</strong>用两个基础生成器的默认构造函数来构造一 <code>additive_combine</code> 生成器。</p>
   <pre>
 additive_combine(typename MLCG1::result_type seed1,
                  typename MLCG2::result_type seed2)
 </pre>

-  <p><strong>Effects:</strong> Constructs an <code>additive_combine</code>
-  generator, using <code>seed1</code> and <code>seed2</code> as the
-  constructor argument to the first and second base generator,
-  respectively.</p>
+ <p><strong>效果:</strong>以 <code>seed1</code> 和 <code>seed2</code> 分 别为两基础构造函数的参数来构造一 <code>additive_combine</code> 生成器。</p>

-  <h3><a name="ecuyer1988" id="ecuyer1988">Specialization</a></h3>
+  <h3><a name="ecuyer1988" id="ecuyer1988">专门化</a></h3>

-  <p>The specialization <code>ecuyer1988</code> was suggested in the above
-  paper.</p>
+  <p>专门化 <code>ecuyer1988</code> 在上面的资料中给出。</p>

-  <h2><a name="shuffle_output" id="shuffle_output">Class template
-  <code>random::shuffle_output</code></a></h2>
+ <h2><a name="shuffle_output" id="shuffle_output"><code>random::shuffle_output</code> 类模板</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 "../../boost/random/shuffle_output.hpp">boost/random/shuffle_output.hpp</a>&gt;
@@ -689,75 +591,52 @@
 };
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

-  <p>Instatiations of class template <code>shuffle_output</code> model a
-  <a href="random-concepts.html#pseudo-rng">pseudo-random number
-  generator</a>. It mixes the output of some (usually linear congruential)
-  uniform random number generator to get better statistical properties.
-  According to Donald E. Knuth, "The Art of Computer Programming, Vol. 2",
-  the algorithm is described in</p>
+ <p><code>shuffle_output</code> 类模板的实例是 <a href="random-concepts.html#pseudo-rng">伪随机数生成器</a> 的模型。它把某种均 匀随机数生成器 (通常是线性同余生成器) 的多个输出混合起来,以获得较好的统计学 性质。据 Donald E. Knuth 在 "The Art of Computer Programming, Vol. 2" 中所 载,这一算法在以下资料中给出:</p>

   <blockquote>
"Improving a poor random number generator", Carter Bays and S.D. Durham,
     ACM Transactions on Mathematical Software, Vol. 2, 1979, pp. 59-64.
-  </blockquote>The output of the base generator is buffered in an array of
-  length k. Every output X(n) has a second role: It gives an index into the
- array where X(n+1) will be retrieved. Used array elements are replaced with
-  fresh output from the base generator.
-
- <p>Template parameters are the base generator and the array length k, which
-  should be around 100. The template parameter <code>val</code> is the
-  validation value checked by <code>validation</code>.</p>
+ </blockquote>基础生成器的输出缓冲在长度为 k 的数组中。每一个输出 X(n) 另 有一个用途:它给出了 X(n+1) 在数组中的位置。使用过的数组元素由基础生成器产生 的新输出取代。

-  <h3>Members</h3>
+ <p>模板参数为基础生成器和数组长度 k,其中 k 一般取 100 左右的值。模板参 数 <code>val</code> 为 <code>validation</code> 检验的参考值。</p>
+
+  <h3>成员</h3>
   <pre>
 shuffle_output()
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>shuffle_output</code>
-  generator by invoking the default constructor of the base generator.</p>
+ <p><strong>效果:</strong>用基础生成器的默认构造函数构造一 <code>shuffle_output</code> 生成器。</p>

-  <p><strong>Complexity:</strong> Exactly k+1 invocations of the base
-  generator.</p>
+  <p><strong>复杂度:</strong>基础生成器的 k+1 次调用。</p>
   <pre>
 template&lt;class T&gt; explicit shuffle_output(T seed)
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>shuffle_output</code>
-  generator by invoking the one-argument constructor of the base generator
-  with the parameter <code>seed</code>.</p>
+ <p><strong>效果:</strong>以 <code>seed</code> 为基础生成器单参数构造函数 的参数构造一 <code>shuffle_output</code> 生成器。</p>

-  <p><strong>Complexity:</strong> Exactly k+1 invocations of the base
-  generator.</p>
+  <p><strong>复杂度:</strong>基础生成器的 k+1 次调用。</p>
   <pre>
 explicit shuffle_output(const base_type &amp; rng)
 </pre>

-  <p><strong>Precondition:</strong> The template argument
- <code>UniformRandomNumberGenerator</code> shall denote a CopyConstructible
-  type.</p>
+ <p><strong>前条件:</strong> 模板参数 <code>UniformRandomNumberGenerator</code> 为一 CopyConstructible 类型。</p>

-  <p><strong>Effects:</strong> Constructs a <code>shuffle_output</code>
-  generator by using a copy of the provided generator.</p>
+ <p><strong>效果:</strong> 通过复制传递的生成器构造一 <code>shuffle_output</code> 生成器。</p>

-  <p><strong>Complexity:</strong> Exactly k+1 invocations of the base
-  generator.</p>
+  <p><strong>复杂度:</strong>基础生成器的 k+1 次调用。</p>
   <pre>
 template&lt;class T&gt; void seed(T s)
 </pre>

-  <p><strong>Effects:</strong> Invokes the one-argument <code>seed</code>
-  method of the base generator with the parameter <code>seed</code> and
-  re-initializes the internal buffer array.</p>
+ <p><strong>效果:</strong>用 <code>seed</code> 为参数调用基础生成器的 <code>seed</code> 方法,并对内部缓冲数组重新初始化。</p>

-  <p><strong>Complexity:</strong> Exactly k+1 invocations of the base
-  generator.</p>
+  <p><strong>复杂度:</strong>基础生成器的 k+1 次调用。</p>

-  <h3><a name="kreutzer1986" id="kreutzer1986">Specializations</a></h3>
+  <h3><a name="kreutzer1986" id="kreutzer1986">专门化</a></h3>

-  <p>According to Harry Erwin (private e-mail), the specialization
-  <code>kreutzer1986</code> was suggested in:</p>
+ <p>据 Harry Erwin 所述 (私人 e-mail),以下资料给出了专门化 <code>kreutzer1986</code> 的描述:</p>

   <blockquote>
     "System Simulation: programming Styles and Languages (International
@@ -765,10 +644,9 @@
     1986.
   </blockquote>

-  <h2><a name="inversive_congruential" id="inversive_congruential">Class
-  template <code>random::inversive_congruential</code></a></h2>
+ <h2><a name="inversive_congruential" id="inversive_congruential"><code>random::inversive_congruential</code> 类模 板</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 
"../../boost/random/inversive_congruential.hpp">boost/random/inversive_congruential.hpp</a>&gt;
@@ -792,12 +670,9 @@
typedef random::inversive_congruential&lt;int32_t, 9102, 2147483647-36884165, 2147483647&gt; hellekalek1995;
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

-  <p>Instantiations of class template <code>inversive_congruential</code>
-  model a <a href="random-concepts.html#pseudo-rng">pseudo-random number
- generator</a>. It uses the inversive congruential algorithm (ICG) described
-  in</p>
+ <p><code>inversive_congruential</code> 类模板的实例是 <a href="random-concepts.html#pseudo-rng">伪随机数生成器</a> 的模型。它使用了逆 同余算法 (inversive congruential algorithm, ICG)。以下资料给出了这一算法的描 述:</p>

   <blockquote>
"Inversive pseudorandom number generators: concepts, results and links",
@@ -805,46 +680,31 @@
     Conference", C. Alexopoulos, K. Kang, W.R. Lilegdon, and D. Goldsman
     (editors), 1995, pp. 255-262. <a href=
     
"ftp://random.mat.sbg.ac.at/pub/data/wsc95.ps";>ftp://random.mat.sbg.ac.at/pub/data/wsc95.ps</a>
-  </blockquote>The output sequence is defined by x(n+1) = (a*inv(x(n)) - b)
-  (mod p), where x(0), a, b, and the prime number p are parameters of the
- generator. The expression inv(k) denotes the multiplicative inverse of k in
-  the field of integer numbers modulo p, with inv(0) := 0.
-
-  <p>The template parameter <code>IntType</code> shall denote a signed
- integral type large enough to hold p; a, b, and p are the parameters of the
-  generators.</p>
-
- <p><em>Note:</em> The implementation currently uses the Euclidian Algorithm - to compute the multiplicative inverse. Therefore, the inversive generators
-  are about 10-20 times slower than the others (see section"<a href=
-  "#performance">performance</a>"). However, the paper talks of only 3x
-  slowdown, so the Euclidian Algorithm is probably not optimal for
-  calculating the multiplicative inverse.</p>
+ </blockquote>输出序列由 x(n+1) = (a*inv(x(n)) - b) (mod p) 定义,其中 x(0), a, b 和质数 p 是生成器的参数。inv(k) 为模 p 整数域中 k 的乘法逆元素。 特殊地,inv(0) := 0。
+
+ <p>模板参数 <code>IntType</code> 应为一带符号整数类型,p 在其可表示范围 内。a, b 和 p 是生成器的参数。</p>

-  <h3>Members</h3>
+ <p><em>注记:</em>目前的实现使用欧几里德算法 (Euclidian Algorithm) 计算乘 法逆元素。因此,逆同余生成器比其它生成器慢 10-20 倍 (参见 <a href="#performance">performance</a> 一节)。然而,上面给出的资料指出这一生成 器应当只慢 3 倍左右,因此欧几里德算法可能不是计算乘法逆元素的最优算法。</p>
+
+  <h3>成员</h3>
   <pre>
 inversive_congruential(IntType y0 = 1)
 </pre>

-  <p><strong>Effects:</strong> Constructs an
-  <code>inversive_congruential</code> generator with <code>y0</code> as the
-  initial state.</p>
+ <p><strong>效果:</strong>构造一 <code>inversive_congruential</code> 生成 器,其初始状态为 <code>y0</code>。</p>
   <pre>
 void seed(IntType y0)
 </pre>

-  <p><strong>Effects:</strong> Changes the current state to
-  <code>y0</code>.</p>
+  <p><strong>效果:</strong>令当前状态为 <code>y0</code>。</p>

-  <h3><a name="hellekalek1995" id="hellekalek1995">Specialization</a></h3>
+  <h3><a name="hellekalek1995" id="hellekalek1995">专门化</a></h3>

-  <p>The specialization <code>hellekalek1995</code> was suggested in the
-  above paper.</p>
+  <p>上面的资料给出了专门化 <code>hellekalek1995</code> 的描述。</p>

-  <h2><a name="mersenne_twister" id="mersenne_twister">Class template
-  <code>random::mersenne_twister</code></a></h2>
+ <h2><a name="mersenne_twister" id="mersenne_twister"><code>random::mersenne_twister</code> 类模板</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 
"../../boost/random/mersenne_twister.hpp">boost/random/mersenne_twister.hpp</a>&gt;
@@ -873,11 +733,9 @@
typedef mersenne_twister&lt;uint32_t,624,397,31,0x9908b0df,11,7,0x9d2c5680,15,0xefc60000,18, 3346425566U&gt; mt19937;
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

-  <p>Instantiations of class template <code>mersenne_twister</code> model a
-  <a href="random-concepts.html#pseudo-rng">pseudo-random number
-  generator</a>. It uses the algorithm described in</p>
+ <p><code>mersenne_twister</code> 的实例是 <a href="random-concepts.html#pseudo-rng">伪随机数生成器</a> 的模型。以下资料给 出了其算法的描述:</p>

   <blockquote>
     "Mersenne Twister: A 623-dimensionally equidistributed uniform
@@ -885,89 +743,61 @@
     ACM Transactions on Modeling and Computer Simulation: Special Issue on
Uniform Random Number Generation, Vol. 8, No. 1, January 1998, pp. 3-30. <!-- <a href="http://www.math.keio.ac.jp/matumoto/emt.html";>http://www.math.keio.ac.jp/matumoto/emt.html</a> -->
-  </blockquote><em>Note:</em> The boost variant has been implemented from
- scratch and does not derive from or use mt19937.c provided on the above WWW
-  site. However, it was verified that both produce identical output.<br>
- The seeding from an integer was changed in April 2005 to address a <a href=
-  
"http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html";>weakness</a>.<br>
-
-  The quality of the generator crucially depends on the choice of the
-  parameters. User code should employ one of the sensibly parameterized
-  generators such as <code>mt19937</code> instead.<br>
-  The generator requires considerable amounts of memory for the storage of
-  its state array. For example, <code>mt11213b</code> requires about 1408
-  bytes and <code>mt19937</code> requires about 2496 bytes.
+ </blockquote><em>注记:</em>boost 库中的变种是重新实现的,不派生自也不使 用以上网站提供的 mt19937.c。不过两个生成器的等价性是经过检验的。<br> + 2005 年 4 月发现算法的一个 <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html";>缺 陷</a> 后修改了用整数赋种的方法。<br>
+
+ 此生成器的品质很大程度上取决于参数的选择。用户代码应该使用已经选择好参数 的生成器,如 <code>mt19937</code>。<br> + 此生成器需要的内存是可观的。例如 <code>mt11213b</code> 需要约 1408 bytes 内存,而 <code>mt19937</code> 需要约 2496 bytes。

-  <h3>Constructors</h3>
+  <h3>构造函数</h3>
   <pre>
 mersenne_twister()
 </pre>

- <p><strong>Effects:</strong> Constructs a <code>mersenne_twister</code> and
-  calls <code>seed()</code>.</p>
+ <p><strong>效果:</strong> 构造一 <code>mersenne_twister</code> 并调用 <code>seed()</code>。</p>
   <pre>
 explicit mersenne_twister(result_type value)
 </pre>

- <p><strong>Effects:</strong> Constructs a <code>mersenne_twister</code> and
-  calls <code>seed(value)</code>.</p>
+ <p><strong>效果:</strong> 构造一 <code>mersenne_twister</code> 并调用 <code>seed(value)</code>。</p>
   <pre>
template&lt;class Generator&gt; explicit mersenne_twister(Generator &amp; gen)
 </pre>

- <p><strong>Effects:</strong> Constructs a <code>mersenne_twister</code> and
-  calls <code>seed(gen)</code>.</p>
+ <p><strong>效果:</strong> 构造一 <code>mersenne_twister</code> 并调用 <code>seed(gen)</code>。</p>

-  <p><em>Note:</em> When using direct-initialization syntax with an lvalue
-  (e.g. in the variable definition <code>Gen gen2(gen);</code>), this
-  templated constructor will be preferred over the compiler-generated copy
-  constructor. For variable definitions which should copy the state of
-  another <code>mersenne_twister</code>, use e.g. <code>Gen gen2 =
-  gen;</code>, which is copy-initialization syntax and guaranteed to invoke
-  the copy constructor.</p>
+ <p><em>注意:</em>当使用左值进行直接初始化时 (如 <code>Gen gen2(gen);</code>),编译器将选择这一构造函数,而不是复制构造函数。若要复制另 一 <code>mersenne_twister</code> 的状态,使用 <code>Gen gen2 = gen;</code>;这是复制初始化的语法,将会调用复制构造函数。</p>

-  <h3>Seeding</h3>
+  <h3>赋种</h3>
   <pre>
 void seed()
 </pre>

-  <p><strong>Effects:</strong> Calls
-  <code>seed(result_type(5489))</code>.</p>
+  <p><strong>效果:</strong>调用 <code>seed(result_type(5489))</code>。</p>
   <pre>
 void seed(result_type value)
 </pre>

-  <p><strong>Effects:</strong> Sets the state x(0) to v mod 2<sup>w</sup>.
-  Then, iteratively,<br>
- sets x(i) to (i + 1812433253 * (x(i-1) <em>xor</em> (x(i-1) <em>rshift</em>
-  w-2))) mod 2<sup>w</sup> for i = 1 .. n-1. x(n) is the first value to be
-  returned by operator().</p>
+ <p><strong>效果:</strong>令状态 x(0) 为 v mod 2<sup>w</sup>。然后迭代 地,<br> + 令 x(i) 为 (i + 1812433253 * (x(i-1) <em>xor</em> (x(i-1) <em>rshift</em> w-2))) mod 2<sup>w</sup> for i = 1 .. n-1. x(n) 为 operator() 返回的第一个值。</p>
   <pre>
 template&lt;class Generator&gt; void seed(Generator &amp; gen)
 </pre>

-  <p><strong>Effects:</strong> Sets the state of this
-  <code>mersenne_twister</code> to the values returned by <code>n</code>
-  invocations of <code>gen</code>.</p>
-
-  <p><strong>Complexity:</strong> Exactly <code>n</code> invocations of
-  <code>gen</code>.</p>
-
- <p><em>Note:</em> When invoking <code>seed</code> with an lvalue, overload
-  resolution chooses the function template unless the type of the argument
-  exactly matches <code>result_type</code>. For other integer types, you
-  should convert the argument to <code>result_type</code> explicitly.</p>
+ <p><strong>效果:</strong>令 <code>mersenne_twister</code> 的当前状态为调 用<code>gen</code> <code>n</code> 次的结果序列。</p>
+
+ <p><strong>复杂度:</strong><code>gen</code> 的 <code>n</code> 次调用。 </p>
+
+ <p><em>注意:</em>当用左值调用 <code>seed</code> 时,函数重载的规则都将选 择这一函数模板,除非参数的类型和 <code>result_type</code> 相同。如果要用其它 的整数类型作参数,你应该先把它显式转换为 <code>result_type</code>。</p>

   <h3><a name="mt11213b" id="mt11213b"></a><a name="mt19937" id=
-  "mt19937">Specializations</a></h3>
+  "mt19937">专门化</a></h3>

-  <p>The specializations <code>mt11213b</code> and <code>mt19937</code> are
-  from the paper cited above.</p>
+ <p>专门化 <code>mt11213b</code> 和 <code>mt19937</code> 来自上面引用的资 料。</p>

-  <h2><a name="lagged_fibonacci" id="lagged_fibonacci">Class template
-  <code>random::lagged_fibonacci</code></a></h2>
+ <h2><a name="lagged_fibonacci" id="lagged_fibonacci"><code>random::lagged_fibonacci</code> 类模板</a></h2>

-  <h3>Synopsis</h3>
+  <h3>概览</h3>
   <pre>
 #include &lt;<a href=
 
"../../boost/random/lagged_fibonacci.hpp">boost/random/lagged_fibonacci.hpp</a>&gt;
@@ -1004,11 +834,9 @@
typedef random::lagged_fibonacci&lt;double, 44497, 21034&gt; lagged_fibonacci44497;
 </pre>

-  <h3>Description</h3>
+  <h3>描述</h3>

-  <p>Instantiations of class template <code>lagged_fibonacci</code> model a
-  <a href="random-concepts.html#pseudo-rng">pseudo-random number
- generator</a>. It uses a lagged Fibonacci algorithm with two lags p and q, + <p><code>lagged_fibonacci</code> 类模板的实例是 <a href="random-concepts.html#pseudo-rng">伪随机数生成器</a> 的模型。It uses a lagged Fibonacci algorithm with two lags p and q, evaluated in floating-point arithmetic: x(i) = x(i-p) + x(i-q) (mod 1) with
   p &gt; q. See</p>

@@ -1027,69 +855,56 @@
about 4856 bytes and <code>lagged_fibonacci44497</code> requires about 350
   KBytes.</p>

-  <h3>Constructors</h3>
+  <h3>构造函数</h3>
   <pre>
 lagged_fibonacci()
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>lagged_fibonacci</code>
-  generator and calls <code>seed()</code>.</p>
+ <p><strong>效果:</strong>构造一 <code>lagged_fibonacci</code> 生成器并调 用 <code>seed()</code>。</p>
   <pre>
 explicit lagged_fibonacci(uint32_t value)
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>lagged_fibonacci</code>
-  generator and calls <code>seed(value)</code>.</p>
+ <p><strong>效果:</strong>构造一 <code>lagged_fibonacci</code> 生成器并调 用 <code>seed(value)</code>。</p>
   <pre>
template&lt;class Generator&gt; explicit lagged_fibonacci(Generator &amp; gen)
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>lagged_fibonacci</code>
-  generator and calls <code>seed(gen)</code>.</p>
+ <p><strong>效果:</strong>构造一 <code>lagged_fibonacci</code> 生成器并调 用 <code>seed(gen)</code>。</p>

-  <h3>Seeding</h3>
+  <h3>赋种</h3>
   <pre>
 void seed()
 </pre>

-  <p><strong>Effects:</strong> Calls <code>seed(331u)</code>.</p>
+  <p><strong>效果:</strong>调用 <code>seed(331u)</code>。</p>
   <pre>
 void seed(uint32_t value)
 </pre>

-  <p><strong>Effects:</strong> Constructs a <code>minstd_rand0</code>
-  generator with the constructor parameter <code>value</code> and calls
-  <code>seed</code> with it.</p>
+ <p><strong>效果:</strong>用 <code>value</code> 作参数构造一 <code>minstd_rand0</code>,并用它作参数调用 <code>seed</code>。</p>
   <pre>
 template&lt;class Generator&gt; void seed(Generator &amp; gen)
 </pre>

-  <p><strong>Effects:</strong> Sets the state of this
-  <code>lagged_fibonacci</code> to the values returned by <code>p</code>
-  invocations of <code>uniform_01&lt;gen, FloatType&gt;</code>.<br>
-  <strong>Complexity:</strong> Exactly <code>p</code> invocations of
-  <code>gen</code>.</p>
+ <p><strong>效果:</strong>令 <code>lagged_fibonacci</code> 的状态为对 <code>uniform_01&lt;gen, FloatType&gt;</code> 的 <code>p</code> 次调用的结果 序列。<br> + <strong>复杂度:</strong>对 <code>gen</code> 的 <code>p</code> 次调用。 </p>

   <h3><a name="lagged_fibonacci_spec" id=
-  "lagged_fibonacci_spec"></a>Specializations</h3>
+  "lagged_fibonacci_spec"></a>专门化</h3>

-  <p>The specializations <code>lagged_fibonacci607</code> ...
-  <code>lagged_fibonacci44497</code> (see above) use well tested lags.
-  (References will be added later.)</p>
-
-  <h2><a name="performance" id="performance">Performance</a></h2>
-
-  <p>The test program <a href="random_speed.cpp">random_speed.cpp</a>
-  measures the execution times of the <a href=
-  "../../boost/random.hpp">random.hpp</a> implementation of the above
- algorithms in a tight loop. The performance has been evaluated on a Pentium
-  Pro 200 MHz with gcc 2.95.2, Linux 2.2.13, glibc 2.1.2.</p>
+ <p>专门化 <code>lagged_fibonacci607</code> ... <code>lagged_fibonacci44497</code> (见上) use well tested lags.
+  (参考资料待添加)</p>
+
+  <h2><a name="performance" id="performance">性能</a></h2>
+
+ <p>测试程序 <a href="random_speed.cpp">random_speed.cpp</a> 用一个紧凑的 循环测试 <a href="../../boost/random.hpp">random.hpp</a> 中上述算法的实现的 运行速度。测试环境:Pentium Pro 200 MHz with gcc 2.95.2, Linux 2.2.13, glibc 2.1.2。</p>

   <table border="1" summary="">
     <tr>
-      <th>class</th>
+      <th>类</th>

-      <th>time per invocation [usec]</th>
+      <th>每次调用耗时 [微秒, usec]</th>
     </tr>

     <tr>
@@ -1183,7 +998,7 @@
     </tr>
   </table>

-  <p>The measurement error is estimated at +/- 10 nsec.</p>
+  <p>误差范围为 +/- 10 纳秒 (nsec)。</p>
   <hr>

<p><a href="http://validator.w3.org/check?uri=referer";><img border="0" src=
@@ -1201,5 +1016,11 @@
   accompanying file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or
   copy at <a href=
   
"http://www.boost.org/LICENSE_1_0.txt";>http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+  <p>中文版修订:2008/6/28</p>
+
+ <p><i>Copyright &copy; 2008 <a href="http://wiki.woodpecker.org.cn/moin/XiaoQi";>xiaq</a></i></p>
+
+ <p><i>在 Boost Software License, Version 1.0 的条款下发布。(参看文件 <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> 或在线副本 <a href="http://www.boost.org/LICENSE_1_0.txt";> http://www.boost.org/LICENSE_1_0.txt</a>)</i></p>
+
 </body>
 </html>

Other related posts:

  • » [boost-doc-zh commit] r202 - trunk/libs/random - codesite-noreply