转载自https://www.cnblogs.com/leoo2sk/archive/2009/05/29/1491526.html

引言

      最近在和同学讨论研究Six Sigma（六西格玛）软件开发方法及CMMI相关问题时，遇到了需要使用Monte-Carlo算法模拟分布未知的多元一次概率密度分布问题。于是花了几天时间，通过查询相关文献资料，深入研究了一下Monte-Carlo算法，并以实际应用为背景进行了一些实验。
      在研究和实验过程中，发现Monte-Carlo算法是一个非常有用的算法，在许多实际问题中，都有用武之地。目前，这个算法已经在金融学、经济学、工程学、物理学、计算科学及计算机科学等多个领域广泛应用。而且这个算法本身并不复杂，只要掌握概率论及数理统计的基本知识，就可以学会并加以应用。由于这种算法与传统的确定性算法在解决问题的思路方面截然不同，作为计算机科学与技术相关人员以及程序员，掌握此算法，可以开阔思维，为解决问题增加一条新的思路。
      基于以上原因，我有了写这篇文章的打算，一是回顾总结这几天的研究和实验，加深印象，二是和朋友们分享此算法以及我的一些经验。
      这篇文章将首先从直观的角度，介绍Monte-Carlo算法，然后介绍算法基本原理及数理基础，最后将会和大家分享几个基于Monte-Carlo方法的有意思的实验。所以程序将使用C#实现。
      阅读本文需要有一些概率论、数理统计、微积分和计算复杂性的基本知识，不过不用太担心，我将尽量避免过多的数学描述，并在适当的地方对于用到的数学知识进行简要的说明。

Monte-Carlo算法引导

首先，我们来看一个有意思的问题：在一个1平方米的正方形木板上，随意画一个圈，求这个圈的面积。
我们知道，如果圆圈是标准的，我们可以通过测量半径r，然后用 S = pi * r^2 来求出面积。可是，我们画的圈一般是不标准的，有时还特别不规则，如下图是我画的巨难看的圆圈。

图1、不规则圆圈

显然，这个图形不太可能有面积公式可以套用，也不太可能用解析的方法给出准确解。不过，我们可以用如下方法求这个图形的面积：
假设我手里有一支飞镖，我将飞镖掷向木板。并且，我们假定每一次都能掷在木板上，不会偏出木板，但每一次掷在木板的什么地方，是完全随机的。即，每一次掷飞镖，飞镖扎进木板的任何一点的概率的相等的。这样，我们投掷多次，例如100次，然后我们统计这100次中，扎入不规则图形内部的次数，假设为k，那么，我们就可以用 k/100 * 1 近似估计不规则图形的面积，例如100次有32次掷入图形内，我们就可以估计图形的面积为0.32平方米。

      以上这个过程，就是Monte-Carlo算法直观应用例子。
      非形式化地说，Monte-Carlo算法泛指一类算法。在这些算法中，要求解的问题是某随机事件的概率或某随机变量的期望。这时，通过“实验”方法，用频率代替概率或得到随机变量的某些数字特征，以此作为问题的解。
      上述问题中，如果将“投掷一次飞镖并掷入不规则图形内部”作为事件，那么图形的面积在数学上等价于这个事件发生的概率（稍后证明），为了估计这个概率，我们用多次重复实验的方法，得到事件发生的频率 k/100 ，以此频率估计概率，从而得到问题的解。

从上述可以看出，Monte-Carlo算法区别于确定性算法，它的解不一定是准确或正确的，其准确或正确性依赖于概率和统计，但在某些问题上，当重复实验次数足够大时，可以从很大概率上（这个概率是可以在数学上证明的，但依赖于具体问题）确保解的准确或正确性，所以，我们可以根据具体的概率分析，设定实验的次数，从而将误差或错误率降到一个可容忍的程度。
上述问题中，设总面积为S，不规则图形面积为s，共投掷n次，其中掷在不规则图形内部的次数为k。根据伯努利大数定理，当试验次数增多时，k/n依概率收敛于事件的概率s/S。下面给出严格证明：

上述证明从数学上说明用频率估计不规则图形面积的合理性，进一步可以给出误差分析，从而选择合适的实验次数n，以将误差控制在可以容忍的范围内，此处从略。

从上面的分析可以看出，Monte-Carlo算法虽然不能保证解一定是准确和正确，但并不是“撞大运”，其正确性和准确性依赖概率论，有严格的数学基础，并且通过数学分析手段对实验加以控制，可以将误差和错误率降至可容忍范围。

Monte-Carlo算法的数理基础

这一节讨论Monte-Carlo算法的数理基础。
首先给出三个定义：优势，一致，偏真。这三个定义在后面会经常用到。

1) 设p为一个实数，且0.5<p<1。如果一个Monte-Carlo方法对问题任一实例的得到正确解的概率不小于p，则该算法是p正确的，且p-0.5叫做此算法的优势。

2) 如果对于同一实例，某Monte-Carlo算法不会给出不同的解，则认为该算法时一致的。

3) 如果某个解判定问题的Monte-Carlo算法，当返回true时是一定正确的。则这个算法时偏真的。注意，这里没有定义“偏假”，因为“偏假”和偏真是等价的。因为只要互换算法返回的true和false，“偏假”就变成偏真了。

下面，我们讨论Monte-Carlo算法的可靠性和误差分析。
总体来说，适用于Monte-Carlo算法的问题，比较常见的有两类。一类是问题的解等价于某事件概率，如上述求不规则图形面积的问题；另一类是判定问题，即判定某个命题是否为真，如主元素存在性判定和素数测试问题。

先来分析第一类。对于这类问题，通常的方法是通过大量重复性实验，用事件发生的频率估计概率。之所以能这样做的数学基础，是伯努利大数法则：事件发生的频率依概率收敛于事件的概率p。这个法则从数学生严格描述了频率的稳定性，直观意义就是当实验次数很大时，频率与概率偏差很大的概率非常小。此类问题的误差分析比较繁杂，此处从略。有兴趣的朋友可以参考相关资料。

接着，我们分析第二类问题。这里，我们只关心一致且偏真的判定问题。下面给出这类问题的正确率分析：

由以上分析可以看到，对于一致偏真的Monte-Carlo算法，即使调用一次得到正确解的概率非常小，通过多次调用，其正确率会迅速提高，得到的结果非常可靠。例如，对一个q为0.5的问题，假设p仅为0.01，通过调用1000次，其正确率约为0.9999784，几乎可以认为是绝对准确的。重要的是，使用Monte-Carlo算法解判定问题，其正确率不随问题规模而改变，这就使得仅需要损失微乎其微的正确性，就可以将算法复杂度降低一个数量级，在后面中可以看到具体的例子。

应用实例一：使用Monte-Carlo算法计算定积分

计算定积分是金融、经济、工程等领域实践中经常遇到的问题。通常，计算定积分的经典方法是使用Newton-Leibniz公式：

这个公式虽然能方便计算出定积分的精确值，但是有一个局限就是要首先通过不定积分得到被积函数的原函数。有的时候，求原函数是非常困难的，而有的函数，如f(x) = (sinx)/x，已经被证明不存在初等原函数，这样，就无法用Newton-Leibniz公式，只能另想办法。
下面就以f(x) = (sinx)/x为例介绍使用Monte-Carlo算法计算定积分的方法。首先需要声明，f(x) = (sinx)/x在整个实数域是可积的，但不连续，在x = 0这一点没有定义。但是，当x趋近于0其左右极限都是1。为了严格起见，我们补充定义当x = 0时f(x) = 1。另外为了需要，这里不加证明地给出f(x)的一些性质：补充x = 0定义后，f(x)在负无穷到正无穷上连续、可积，并且有界，其界为1，即|f(x)| <= 1，当且仅当x = 0时f(x) = 1。

下面开始介绍Monte-Carlo积分法。为了便于比较，在本节我们除了介绍使用Monte-Carlo方法计算定积分外，同时也探讨和实现数值计算中常用的插值积分法，并通过实验结果数据对两者的效率和精确性进行比较。

1、插值积分法

我们知道，对于连续可积函数，定积分的直观意义就是函数曲线与x轴围成的图形中，y>0的面积减掉y<0的面积。那么一种直观的数值积分方法是通过插值方法，其中最简单的是梯形法则：用以f(a)和f(b)为底，x轴和f(a)、f(b)连线为腰组成的梯形面积来近似估计积分。如下图所示。

图2、梯形插值

如图2所示，蓝色部分是x1到x2积分的精确面积，而在梯形插值中，用橙色框所示的梯形面积近似估计积分值。
显然，梯形法则的效果一般，而且某些情况下偏差很大，于是，有人提出了一种改进的方法：首先将积分区间分段，然后对每段计算梯形插值再加起来，这样精度就大大提高了。并且分段越多，精度越高。这就是复化梯形法则。

除了梯形插值外，还有许多插值积分法，比较常见的有Sinpson法则，当然对应的也有复化Sinpson法则。下面给出四种插值积分的公式：

下面是四种插值积分法的程序代码，用C#编写。

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MonteCarlo.Integration

{

/// <summary>

/// 数值法求积分

/// 被积函数为 f(x) = (sin x)/x

/// </summary>

public class NumericalIntegrator

{

/// <summary>

/// 梯形法则求积分

/// 积分公式为：((b - a) / 2) * [f(a) + f(b)]

/// </summary>

/// <param name="a">积分下限</param>

/// <param name="b">积分上限</param>

/// <returns>积分值</returns>

public static double TrapezoidalIntegrate(double a, double b)

{

return ((b - a) / 2) * (Math.Sin(a) / a + Math.Sin(b) / b);

}

/// <summary>

/// 复化梯形法则求积分

/// 积分公式为：累加((xi - xi-1) / 2) * [f(xi) + f(xi-1)] (i=1,2,...,n)

/// </summary>

/// <param name="a">积分下限</param>

/// <param name="b">积分上限</param>

/// <param name="n">分段数量</param>

/// <returns>积分值</returns>

public static double ComplexTrapezoidalIntegrate(double a, double b, int n)

{

double result = 0;

for (int i = 0; i < n; i++)

{

double xa = a + i * (b - a) / n;//区间积分下限

double xb = xa + (b - a) / n;//区间积分上限

result += ((xb - xa) / 2) * (Math.Sin(xa) / xa + Math.Sin(xb) / xb);

}

return result;

}

/// <summary>

/// Sinpson法则求积分

/// 积分公式为：((b - a) / 6) * [f(a) + 4 * f((a + b) / 2) + f(b)]

/// </summary>

/// <param name="a">积分下限</param>

/// <param name="b">积分上限</param>

/// <returns>积分值</returns>

public static double SinpsonIntegrate(double a, double b)

{

return ((b - a) / 6) * (Math.Sin(a) / a + 4 * (Math.Sin(a + b) / (2 * (a + b))) + Math.Sin(b) / b);

}

/// <summary>

/// 复化Sinpson法则求积分

/// 积分公式为：累加(h / 3) * [f(x2i-2) + 4*(f(x2i-1)) + f(x2i)] (i=1,2,...,n/2 h = (b - a) / n)

/// </summary>

/// <param name="a">积分下限</param>

/// <param name="b">积分上限</param>

/// <param name="n">分段数量(必须为偶数)</param>

/// <returns>积分值</returns>

public static double ComplexSinpsonIntegrate(double a, double b, int n)

{

double result = 0;

for (int i = 0; i < n / 2 - 1; i++)

{

double xa = a + 2 * i * (b - a) / n;//区间积分下限

double xb = xa + (b - a) / n;//区间积分限中点

double xc = xb + (b - a) / n;//区间积分上限

result += ((b - a) / (3 * n) * (Math.Sin(xa) / xa + 4 * (Math.Sin(xb) / xb) + Math.Sin(xc) / xc));

}

return result;

}

2、Monte-Carlo积分法

我们知道，求定积分的直观意义就是求面积，所以，用Monte-Carlo求积分的原理就是通过模拟统计方法求解面积。即通过向特定区域随机产生大量点，然后统计点落在函数区域内的频率，以此频率估计面积，从而得到积分值。下面给出Monte-Carlo求取积分的算法程序。

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MonteCarlo.Integration

{

/// <summary>

/// Monte-Carlo法求积分

/// 被积函数为 f(x) = (sin x)/x

/// </summary>

public class MonteCarloIntegrator

{

/// <summary>

/// 用Monte-Carlo法求解积分值

/// </summary>

/// <param name="a">积分下限</param>

/// <param name="b">积分上限</param>

/// <param name="N">模拟次数</param>

/// <returns>积分值</returns>

public static double MonteCarloIntegrate(int a, int b, int N)

{

Random random = new Random();

int positivePointCount = 0;//y >=0 区间内落入函数曲线内的点数目

int negativePointCount = 0;//y < 0区间内落入函数曲线内的点数目

//统计y >= 0区间点分布

for (int i = 0; i < N; i++)

{

double xCoordinate = random.NextDouble();//随机产生的x坐标

double yCoordinate = random.NextDouble();//随机产生的y坐标

xCoordinate = a + (b - a) * xCoordinate;//将x规格化到相应积分区间

//yCoordinate = 1 * yCoordinate;//将y规格化到相应区间

if (Math.Sin(xCoordinate) / xCoordinate >= yCoordinate)

{

positivePointCount++;

}

//统计y < 0区间点分布

for (int i = 0; i < N; i++)

{

double xCoordinate = random.NextDouble();//随机产生的x坐标

double yCoordinate = random.NextDouble();//随机产生的y坐标

xCoordinate = a + (b - a) * xCoordinate;//将x规格化到相应积分区间

yCoordinate = -1 * yCoordinate;//将y规格化到相应区间

if (Math.Sin(xCoordinate) / xCoordinate <= yCoordinate)

{

negativePointCount++;

}

double positiveFrequency = (double)positivePointCount / (double)N;//y >= 0区间内函数内点频率

double negativeFrequency = (double)negativePointCount / (double)N;//y < 0区间内函数内点频率

return (positiveFrequency - negativeFrequency) * (double)(b - a);

}

3、积分法的测试与比较

下面对各种积分方法进行测试，对sinx/x在[1,2]区间上进行定积分。其中，我们分别对复化梯形和复化Sinpson法则做分段为10，10000，和10000000的积分测试。另外，对Monte-Carlo法也投点数也分为10，10000，和10000000。测试结果如下：

图3、积分法测试结果

为了分析偏差，我们必须给出一个精确值。但是现在我手头没有这个积分的精确值，不过1000万次的梯形法则和Sinpson法则已经精确度很高了，所以这里就以0.65932985作为基本，进行误差分析。下面给出分析结果：

表1、积分方法实验结果

首先看时间效率。当频度较低时，各种方法没有太多差别，但在1000万级别上复化梯形和复化Sinpson相差不大，而Monte-Carlo算法的效率快一倍。
而从准确率分析，当频度较低时，几种方法的误差都很大，而随着频度提高，插值法要远远优于Monte-Carlo算法，特别在1000万级别时，Monte-Carlo法的相对误差是插值法的的近万倍。总体来说，在数值积分方面，Monte-Carlo方法效率高，但准确率不如插值法。

应用实例二：在O(n)复杂度内判定主元素

这次，我们看一个判定问题。问题是这样的：在一个长度为n的数组中，如果有超过[n/2]的元素具有相同的值，那么具有这个值的元素叫做数组的主元素。现在要求给出一种算法，在O(n)时间内判定给定数组是否存在主元素。

如果采用确定性算法，由于最坏情况下要搜索n/2次，而每次要比较的次数为O(n)量级，这样，算法的复杂度就是O(n^2)，不可能在O(n)时间内完成。所以我们只好换一种思路：不是要一个一定正确的结果，而只需要结果在很大概率上正确就行。我们可以这样做：

图4、Monte-Carlo法判定主元素

上述算法，就是用Monte-Carlo思想求解主元素判定问题的过程。由于阈值N是一个给定的常数，不随规模变化而变化，所以这个算法的时间复杂度为O(n)，符合题设要求。但这个算法给出的解并不是100%正确的，正确率和N有关。N设得过大，影响效率，N太小，正确率太低，那么到底N设多大合适呢。这就要对算法进行概率分析。

首先，这个算法是一致且偏真的，证明很简单，这里从略。所以，如果数组中不存在主元素，则结果一定正确，而如果存在，调用一次得到正确结果的概率不低于1/2。由于偏真，在N次调用中只要返回一次True，就可以认为得到正确结果，所以，调用N此得到正确结果的概率不低于1 – (1/2)^N，可以看到，随着N的增大，这个概率增加很快，只要调用10次，正确率就可以达到99.9%，重要的是，这个正确率和规模无关，即使数组的元素有1千万亿，只需调用10次，正确率依然是99.9%，这就体现出在数组很大时，Monte-Carlo方法的优势。

下面是使用Monte-Carlo算法进行主元素测试的C#程序示例。

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MonteCarlo.Detection

{

public class PrincipalElementDetector

{

/// <summary>

/// 使用Monte-Carlo发探测主元素

/// </summary>

/// <param name="elements">所有元素</param>

/// <param name="N">阈值</param>

/// <returns>是否存在主元素</returns>

public static bool DetectPrincipalElement(IList<int> elements,int N)

{

Random random = new Random();

bool result = false;

for (int i = 0; i <= N; i++)

{

int index = random.Next(0, elements.Count - 1);

int element = elements[index];

int count = 0;

for (int j = 0; j < elements.Count; j++)

{

if (element == elements[j])

{

count++;

}

if (count >= elements.Count / 2)

{

result = true;

break;

}

return result;

}

程序很简单，不做赘述。下面测试这个算法。我们分别将阈值设为1、3、10，并且在每个阈值下测试100次，看看这个算法的准确率如何。测试数组是[ 4, 5, 8, 1, 8, 4, 9, 2, 2, 2, 2, 2, 5, 7, 8, 2, 2, 2, 2, 2, 1, 0, 9, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 4, 7, 8, 2, 2, 2, 2, 2, 0, 1, 2, 2, 2, 2, 2 ]，其中存在主元素2。下面是测试结果：

图5、Monte-Carlo算法判定主元素实验结果

测试数组有49个元素，主元素2有29个，比率为59%。从测试结果可以看出，即使阈值为1，正确率也高达84%，而仅仅为3的阈值就使正确率升高到98%，阈值为10时，100次测试全部正确。虽然理论上来说，阈值为10时有0.41^10=0.013%的概率给出错误判断，但是笔者多次试验，还没有在阈值为10时得到错误结果。所以，Monte-Carlo方法求解判定问题，不论从理论上还是实践中，都是不错的方法。

另外一个与判定主元素类似的应用是素数判定问题，我们知道，对于寻找上百位的大素数，完全测试在时间效率上时不允许的。于是，结合费马小定理使用Monte-Carlo法进行素数判定，是广泛使用的方法。具体这里不再详述，感兴趣的朋友可以参考相关资料。

应用实例三：分布未知的概率密度函数模拟

现在我们来看看Monte-Carlo算法的第三种应用：模拟。在这种应用中，不再是用Monte-Carlo算法求解问题，而是用来模拟难以解析描述的东西。问题是这样的：

这个问题是实验室一个师兄在开发Six Sigma软件开发过程管理工具时遇到的一个实际需求，最终Y的概率密度函数将被用来计算分位点，从而进行过程控制。其中X可能是正态分布（高斯分布）、泊松分布、均匀分布或指数分布等。将多个不同分布的概率密度函数相加，得到的Y的分布式很难解析表示出来的，但如果是为了计算分位点，我们可以采取这样一个策略：对于每一个X，产生若干符合其分布的点，带入公式就得到若干符合Y分布的点，然后分段计算频率，从而模拟出Y的分布，这些模拟点也可以用于分位点计算。这就是Monte-Carlo模拟的思想。

下面我们实现这个算法，这里的X我们仅给出最常用的正态分布，如果要实现其他分布，只要编写相应的随机点发生器就可以了。由于C#中只能产生符合均匀分布的随机数，所以我们需要一种算法，将均匀分布的随机数转为正态分布随机数。这种算法很多，Marc Brysbaert在1991年发表的《Algorithms for randomness in the behavioral sciences: A tutorial》一文中，共总结了5种将均匀分布随机数转为正态分布的随机数的算法，这里笔者用到的是Knuth在1981年提出的一种算法。这个算法是将符合u(0,1)均匀分布的随机点转换为符合N(0,1)标准正态分布的随机点p，由概率知识可知，要转为符合N(e,v)的一般正态分布，只需进行p*v+e即可。下面是这个算法：

下面是根据这个算法，使用C#编写的正态分布随机点发生器：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MonteCarlo.DistributingSimulation

{

public class NormalDistributingGenerator

{

/// <summary>

/// 产生符合正态分布的随机数

/// 正态分布的期望为expectation,方差为variance

/// </summary>

/// <param name="expectation">期望</param>

/// <param name="variance">方差</param>

/// <param name="N">产生的数量</param>

/// <returns>随机数序列</returns>

public static IList<double> GenerateNDRNumber(double expectation, double variance, int N)

{

Random random = new Random();

IList<double> randomList = new List<double>();

for (int i = 0; i < N; i++)

{

double u1, u2, v, z, a;

do

{

u1 = random.NextDouble();

u2 = random.NextDouble();

v = 0.8578 * (2 * u2 - 1);

z = v / u1;

a = 0.25 * Math.Exp(2);

if (a < 1 - u1)

{

break;

}

} while (a > 0.295 / u1 + 0.35 || a > -Math.Log(u1, Math.E));

randomList.Add(z * Math.Sqrt(variance) + expectation);

}

return randomList;

}

接着是利用这个正态分布发生器获得X的随机值，并计算出Y的随机值的代码。也就是Y的随机点发生器：

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace MonteCarlo.DistributingSimulation

{

public class DistributingSimulator

{

/// <summary>

/// 模拟多个正态分布之和的分布情况，产生符合复合分布的随机点

/// y = a0 + a1*N(e1,v1) + ... + an*N(en,vn)

/// N(e,v)表示期望为e，方差为v的正态分布

/// </summary>

/// <param name="a">常数列</param>

/// <param name="e">期望列</param>

/// <param name="v">方差列</param>

/// <param name="N">产生模拟点的个数</param>

/// <returns>模拟点序列</returns>

public static IList<double> Simulate(IList<double> a,IList<double> e,IList<double> v,int N)

{

IList<double> result = new List<double>();

IList<IList<double>> randomLists = new List<IList<double>>();

int count = a.Count - 1;

//产生各个自变量的随机序列

for (int i = 1; i <= count; i++)

{

randomLists.Add(NormalDistributingGenerator.GenerateNDRNumber(e[i], v[i], N));

}

//带入公式

for (int j = 0; j < N; j++)

{

double y = 0;

for (int k = 1; k <= count; k++)

{

y += a[k] * randomLists[k - 1][j];

}

y += a[0];

result.Add(y);

}

return result;

}

这样，我们就可以产生任意多个符合Y分布的随机点，从而借此模拟Y的概率密度分布。

接着，我们测试一下这个模拟程序的效果，首先我们将初始值设为仅有一个符合标准正态分布的X，这样Y=X，我们看看直接模拟一个标准正态分布的效果。这里，我们产生100万个随机点。

图6、使用Monte-Carlo算法模拟标准正态分布

可以看到，模拟效果基本令人满意。接下来，我们实际应用这个程序模拟一个分布未知的Y，其中Y = 15 + 2*N(2,8) + 5*N(-10,9) + 7*N(0,0.5)。模拟结果如下：

图7、使用Monte-Carlo算法模拟未知分布

有了符合Y分布的大量随机点以及频率统计，就可以随心所欲绘出分布模拟图，并进行分位点计算。这样就用Monte-Carlo算法解决了本节开头提到的问题。

总结

      本文首先通过一个不规则图形面积计算的例子直观介绍了Monte-Carlo算法，然后给出了Monte-Carlo算法在应用过程中需要了解的数理基础。然后大篇幅介绍了三个应用：计算、判定和模拟。
      总体来说，当需要求解的问题依赖概率时，Monte-Carlo方法是一个不错的选择。但这个算法毕竟不是确定性算法，在应用过程中需要冒一定“风险”，这就要求不能滥用这个算法，在应用过程中，需要对其准确率或正确率进行数理分析，合理设计实验，从而得到良好的结果，并将风险控制在可容忍的范围内。
      其实，不确定性算法不只Monte-Carlo一种，Sherwood算法、Las Vegas算法和遗传算法等也是经典的不确定算法。在很多问题上，不确定性算法具有很好大的应用价值。有兴趣的朋友可以参考相关资料。

参考文献

      [1] 孙海燕，周梦等著，应用数理统计。北京航空航天大学出版社，2008.8
      [2] 盛骤，谢式千，潘承毅著，概率论与数理统计。高等教育出版社，2006.12
      [3] David Kincaid，WardCheney 著，王国荣等译，数值分析(原书第三版)。机械工业出版社，2005.9
      [4] Thomas H. Cormen等著，算法导论(第二版，影印版)。高等教育出版社，2002.5
      [5] 王晓东著，计算机算法设计与分析。电子工业出版社，2001.1
      [6] Marc Brysbaert，Algorithms for randomness in the behavioral sciences: A tutorial。Behavior Research Methods, Instruments, & Computers 1991, 23 (1) 45-60
      [7] Patrick Smacchia 著，施凡等译，C#和.NET2.0 平台、语言与框架。2008.1
      [8] Google。www.google.com
      [9] Wikipedia。www.wikipedia.org