Developers always interested to share or show off there development tools, because they want to improve there productivity.

You can see how developers care about there development machine and tools:

What is my development tools and software?

I use Ubuntu 11.04 as the main OS. There will be tons of work to do after you install the default Ubuntu.

I installed more fonts such as MSYH, Arial, then you will see the similar web page when you surfing the web.

Change the Ubuntu theme back to Ubuntu 10 style.

Soft wares installed under Ubuntu:

1. JDK (power lots of tools, support JAVA development)

2. Chromium (Main browser)

3. GIMP (Photoshop under Linux)

4. Dropbox (Sync tool for my documents)

5. Filezilla (FTP client)

6. Skype (Chatting tool)

7. IDE:

Aptana (Support PHP, Python, Ruby developement. But not used very frequently)

Eclipse (Java development)

Gvim (My main development tool)

8. Ubuntu tweak (configuration tool)

9. Chromium plugins:

Google reader notifier

Screen capture

Color pick

…

10. Vim plugins:

Vim wiki

Calander

ctags

Nerdtree

bufferexplorer

taglist

zencoding

…

11. Avant window navigator (Similar as Dock in Mac OS)

12. Mysql, PHP, Apache2, Nodejs, mongodb, git, svn, redis and lots of shell scripts to complete tasks.

N-Gram有很多应用，但是我们只用来做相似分析。基本思路来自Grzegorz Kondrak 2005年的一篇论文。http://webdocs.cs.ualberta.ca/~kondrak/papers/spire05.pdf

最近在做Translation memory的时候用到比较字符串相似度的算法。在机器翻译或者语言识别领域之所以能使用相似度算法其实是基于一种假设，相似的词具有相似的意义。

什么是N-Gram算法？
N-Gram 模型基于这样一种假设，第n个词的出现只与前面n-1个词相关，而与其它任何词都不相关，整句的概率就是各个词出现概率的乘积。在拼写检查里即是一个字母的出现概率只和前n-1个字母的出现概率相关,并且是前n-1个字母出现概率的乘积。
如何比较2个字符串的相似度？

一般情况我们会考虑用edit distance 或者LCS。前边的论文证实了这两种算法都是N-Gram的简化版本。

在搜索引擎里一般是用来做拼写检查或者提示，比如你在百度或者google输入一个词就会有相关的词提示出来。

　　我奇怪的是, A* 算法应该是算法课的基础知识了, 任何一个系统学习过算法的人都应该了解, 本不应该我在这里乱写一通, 大家随意翻本将计算机算法的书, 就应该看的到. (将 AI 的书了更是少不了) 不过既然许多朋友问起, 在各个讨论组, BBS 等地方也屡次见人提到, 特花一下午时间完成本文和附带的程序, 满足我们广大业余游戏制作爱好者的求知欲, 专业人士免看, 以免班门弄斧 ^_^ 不过如有错误一定指出哟.

　　如果您的上网时间很宝贵,请下载我注释过的源码(3k)离线研究

　　在介绍 A* 算法前,先提一下广度优先搜索,广度优先搜索就是每次将当前状态可能发展的策略逐层展开,比如一个地图中,对象允许向四个方向移动, 那么,就将地点处,对象向上下左右各移动一步, 将四个状态都保存在内存中, 然后再从这四个出发点向各自的四个方向再移动一步… (当然这里可以剔除不合理的移动方法,比如不准向回移动)实际上, 整个搜索好似一个圆形向外展开,直到到达目的地,很明显这样求解一定能找到最优解,但节点展开的数量是和距离成级数增加的, 真的用在游戏中, 玩家会抱怨内存128M 也不够用了 ^_^ 而且伴随待处理节点数的增加, 处理速度也会迅速减慢… 可以说这个算法并不实用

　　而 A* 算法实际是一种启发式搜索, 所谓启发式搜索,就是利用一个估价函数评估每次的的决策的价值, 决定先尝试哪一种方案. 这样可以极大的优化普通的广度优先搜索. 一般来说, 从出发点(A)到目的地(B)的最短距离是固定的,我们可以写一个函数 judge() 估计 A 到 B 的最短距离, 如果程序已经尝试着从出发点(A) 沿着某条路线移动到了 C 点, 那么我们认为这个方案的 A B 间的估计距离为 A 到 C 实际已经行走了的距离 H 加上用 judge() 估计出的 C 到 B 的距离. 如此, 无论我们的程序搜索展开到哪一步, 都会算出一个评估值, 每一次决策后, 将评估值和等待处理的方案一起排序, 然后挑出待处理的各个方案中最有可能是最短路线的一部分的方案展开到下一步, 一直循环到对象移动到目的地, 或所有方案都尝试过却没有找到一条通向目的地的路径则结束. (通常在游戏里还要设置超时控制的代码,当内存消耗过大或用时过久就退出搜索)

　　完了? 没有. 怎么写这个算法中的估价函数非常的重要,如何保证一定能找到最短路径呢? 充要条件是, 你的估价函数算出的两点间的距离必须小于等于实际距离. 这个可以从数学上严格证明,有兴趣可以自己去查阅相关资料. 如果你的估价函数不满足这点, 就只能叫做 A 算法, 并不能保证最后的结果是最优的,但它可能速度非常的快. 而游戏中我们也不一定非要得到最优解的. 但无疑, 满足那个条件的 A* 算法中, 估计值越接近真实值的估价函数就做的越好, 下面给出的程序,我只使用了一个相当简单的估价函数: 求出两点中,若无障碍物的情况下的最短路径. 如果您想写出快速的寻路算法, 请自己寻找好的估价函数吧,有时间的时候,我会对此另文叙述 ;-)

—————————————————————

转贴的。
启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估，得到最好的位置，再从这个位置进行搜索直到目标。这样可以省略大量无畏的搜索路径，提到了效率。在启发式搜索中，对位置的估价是十分重要的。采用了不同的估价可以有不同的效果。我们先看看估价是如何表示的。
　　启发中的估价是用估价函数表示的，如：

f(n) = g(n) + h(n) 

　　其中f(n) 是节点n的估价函数，g(n)实在状态空间中从初始节点到n节点的实际代价，h(n)是从n到目标节点最佳路径的估计代价。在这里主要是h(n)体现了搜索的启发信息，因为g(n)是已知的。如果说详细点，g(n)代表了搜索的广度的优先趋势。但是当h(n) >> g(n)时，可以省略g(n)，而提高效率。
启发式搜索其实有很多的算法，比如：局部择优搜索法、最好优先搜索法等等。当然A*也是。这些算法都使用了启发函数，但在具体的选取最佳搜索节点时的策略不同。象局部择优搜索法，就是在搜索的过程中选取“最佳节点”后舍弃其他的兄弟节点，父亲节点，而一直得搜索下去。这种搜索的结果很明显，由于舍弃了其他的节点，可能也把最好的节点都舍弃了，因为求解的最佳节点只是在该阶段的最佳并不一定是全局的最佳。最好优先就聪明多了，他在搜索时，便没有舍弃节点（除非该节点是死节点），在每一步的估价中都把当前的节点和以前的节点的估价值比较得到一个“最佳的节点”。这样可以有效的防止“最佳节点”的丢失。那么A*算法又是一种什么样的算法呢？其实A*算法也是一种最好优先的算法。只不过要加上一些约束条件罢了。由于在一些问题求解时，我们希望能够求解出状态空间搜索的最短路径，也就是用最快的方法求解问题，A*就是干这种事情的！我们先下个定义，如果一个估价函数可以找出最短的路径，我们称之为可采纳性。A*算法是一个可采纳的最好优先算法。A*算法的估价函数可表示为：

f’(n) = g’(n) + h’(n) 

　　这里，f’(n)是估价函数，g’(n)是起点到终点的最短路径值，h’(n)是n到目标的最断路经的启发值。由于这个f’(n)其实是无法预先知道的，所以我们用前面的估价函数f(n)做近似。g(n)代替g’(n)，但 g(n)>=g’(n)才可（大多数情况下都是满足的，可以不用考虑），h(n)代替h’(n)，但h(n)<=h’(n)才可（这一点特别的重要）。可以证明应用这样的估价函数是可以找到最短路径的，也就是可采纳的。我们说应用这种估价函数的最好优先算法就是A*算法。
　　举一个例子，其实广度优先算法就是A*算法的特例。其中g(n)是节点所在的层数，h(n)=0，这种h(n)肯定小于h’(n)，所以由前述可知广度优先算法是一种可采纳的。实际也是。当然它是一种最臭的A*算法。
再说一个问题，就是有关h(n)启发函数的信息性。h(n)的信息性通俗点说其实就是在估计一个节点的值时的约束条件，如果信息越多或约束条件越多则排除的节点就越多，估价函数越好或说这个算法越好。这就是为什么广度优先算法的那么臭的原因了，谁叫它的h(n)=0，一点启发信息都没有。但在游戏开发中由于实时性的问题，h(n)的信息越多，它的计算量就越大，耗费的时间就越多。就应该适当的减小h(n)的信息，即减小约束条件。但算法的准确性就差了，这里就有一个平衡的问题。

其中，W1k、W2k分别表示文本D1和D2第K个特征项的权值，1<=k<=N。
在自动归类中，我们可以利用类似的方法来计算待归类文档和某类目的相关度。例如文本D1的特征项为a，b，c，d，权值分别为30，20，20，10，类目C1的特征项为a，c，d，e，权值分别为40，30，20，10，则D1的向量表示为D1(30,20,20,10,0),C1的向量表示为C1（40，0，30，20，10），则根据上式计算出来的文本D1与类目C1相关度是0.86

在数学当中，n维向量是 V{v1, v2, v3, …, vn}
他的模： |v| = sqrt ( v1*v1 + v2*v2 + … + vn*vn )
两个向量的点击 m*n = n1*m1 + n2*m2 + …… + nn*mn
相似度 ＝ (m*n) /(|m|*|n|)
物理意义就是两个向量的空间夹角的余弦数值
对于例子
d1*c1 = 30*40 + 20*0 + 20*30 + 10*20 + 0*10 = 2000
|d1| = sqrt(30*30 +20*20 + 20*20 + 10*10 + 0*0) = sqrt(1800)
|c1| = sqrt(40*40 + 0*0 + 30*30 + 20*20 + 10*10) = sqrt(3000)
相似度 = d1*c1/(|d1|*|c1|)= 2000/sqrt(1800*3000)= 0.86066

参考： http://www.chmhome.com/technology/program-design/perl/20070527/13588.htm…
http://www.perl.com/2004/04/08/examples/Filter.pm

perl中有 Bloom::Filter 的模块 使用示例：

1 #!/usr/bin/perl -w
2
3 use strict;
4 use Bloom::Filter;
5
6 my $bf = Bloom::Filter->new( capacity => 10, error_rate => .001 );
7 my @keys = ("albert", "lee", "python", "perl", "ruby", "rebol", "java","C++");
8 $bf->add( @keys );
9
10 while ( <> ) {
11 chomp;
12 print "Found $_\n" if $bf->check( $_ );
13 }
14

{————参考资料———————–
Bloom Filter 数据结构的原理分析

Bloom Filter 数据结构广泛地应用于网络技术中，它是由 Burton Bloom 在 1970 年提出来的。
它的优点是可以有效地节省空间，缺点是不能做到精确无误，不过这个看似很郁闷的缺点却可以使用调节参数的方法有效控制，
也可以通过不同的应用手段来避免差错。Bloom Filter 数据结构有很多应用，将在下一篇文章里叙述，
而这篇文章将简要叙述这个算法的原理和分析。

问题定义：如何用简单节省的方法将一个集合中的所有元素表述出来？
原理：有一个集合 S = ( x1, x2, … , xn), 用一个 n bit 的数组把这个集合表示出来。
使用 k 个独立的哈希函数，将 S 中的每个元素 xi 映射到这个 n bit 的数组中的某一位上，
对于 S 中的每个元素要做 k 次哈希。n bit 的数组初始化每一位为 0 。

如图所示：

0 0 0 0 0 0 0 0 0 0 0 0

    x2_______________
x1________|   |   |
|   |   |   |   |
0 1 0 1 0 1 0 1 0 0 1 0

  x2′_______________
x1′______|   |   |
    | | |   |   |
0 1 0 1 0 1 0 1 0 0 1 0

从上图可见，x1 , x2 被映射到 n-bit 中，来了两个查询，x1′ 和 x2′ ，
对这两个查询也分别做 k 个哈希映射，结果 x1′ 对应的值不全是 1 ，
这说明在集合S中肯定不存在和 x1′ 相同的元素。而 x2′ 对应的 bit 都是1，这说明 x2′ 有可能存在于集合中。
但是它不存在的可能性也是有的，因为不能保证不同的元素的哈希值不同。

下面是几个关于 bloom filter 的延伸分析。
1）使用 bloom filter 可以做集合的并、交运算。只需将 n-bit 数组 OR 或 AND 就可以了。
但是结果并不精确。
2）bloom filter 有时会用在描述一个变化的集合上。
添加一个新的集合元素进入 bloom filter 很容易，而删除从集合中删除一个元素，
却不是那么简单，因为会附带着把其他元素的信息也删除掉。为了解决这个问题，
使用多个 bit 位取代使用一个 bit 位。每次映射到这个位置，就加 1 。
}

{——-Bloom Filter 个人的理解及实现方法———————————
Bloom Filter是可作为URL排重算法的一种算法.
它的基本思想来源于Hash表.但又不同.
Hash表的思想是通过散过函数快速定位的Hash桶位置.如果Hash冲突则开链表保存.
基本上一个合适的Hash函数,和合适的Hash桶大小,会使Hash冲突变得很小.
因而Hash表具有极快速的添加,查找,删除功能.也非常适合用于URL排重. 但是Hash表的实现空间效率不好.
而Bloom Filter是一种Hash表思想的延伸.它并不通过Hash表开链表的形式来解决冲突.
而是用多个Hash函数来计算数据,而取得多个Hash数组的下标,并标记,以多个Hash函数的计算结果来稀释冲突的机率.
例如用10个Hash函数分别计算同一个数据,而得到10个数组下标,通过判断这十个下标相对应的标记位的标记即可判断是否存在.

我的实现方法是这样的,申请一块大内存作为数组,数组每个单位为2个字节即16位的空间,用于保存10种不同Hash算法的标记位.
数组起始地址.
FBasePointer
那 数组第I个单位的超始位置即为 FBasePointer +2*I
}

{类设计说明:
THashFuncMan 为一个Hash函数的调用结构体,同时定义Hash函数,编号和计算结果.方便使用.

IBloomFilter为算法算法,各种不同的程序可通过实现该接口来保证接口统一.

TBloomFilterBase 自己实现了10种Hash算法的一个基类.各种存储类可通过继承它来实现.当然,也可以用组合.

TPointerBloomFilterBase -> (TBloomFilterBase,IBloomFilter) 比较完整实现了IBloomFilter算法的类. 但它操作的指针为虚拟.要子类为指针指定内容.

TMemoryBloomFilter->TPointerBloomFilterBase 内存存储方式的BloomFilter算法实现类
TMemoryFileBloomFilter->BloomFilter 内存映射文件存储方式的BloomFilter算法实现类,外存

}
unit uBloomFilter;

interface
uses
Classes, SysUtils, Windows, MD5, SyncObjs, SHA1;

const
MaxHashFuncCount = 10;
type
//计算Hash数组下标的函数形式
//备注:该定义为通用方式,而我在下面的代码应用中的散列函数的实现中并没有用到其中的参数
TGetHashIndexFunc = function(ABuffer: PChar; ALen: Integer; AMaxCount:
  Cardinal): Cardinal;
TGetHashIndexEvent = function(ABuffer: PChar; ALen: Integer; AMaxCount:
  Cardinal): Cardinal of object;

//Hash数组计算对象,关链函数和编号
THashFuncMan = record
  GetHashIndexFunc: TGetHashIndexEvent;
  Index: Integer;
  HashIndex: Cardinal;
end;

{————–BloomFilter算法接口————————}
IBloomFilter = interface
['{F8E72812-E7CD-4460-9549-7920A9C762C4}']
  function GetMaxCount: Cardinal;

  /// <summary>
  /// 查找一个字符串是否已存在
  /// </summary>
  /// <param name="AStr">要查找的字符串</param>
  /// <param name="AAutoAdd">是否自动添加</param>
  /// <returns>已存在返回True,不存在返回False</returns>
  function FilterData(AStr: string; AAutoAdd: Boolean): Boolean;

  //取得Hash数组的大小
  property MaxCount: Cardinal read GetMaxCount;

end;

{————BloomFilter 的Hash算法实现的类———————————–
  各种不同的存储或是实现可继承该类实现
  扩展的话,也可把10个散列算法做为事件开放给外部,让外部指定,而达到更灵活的使用方式
  我这里只是简单实现了十个Hash函数
—————————————————————————–}
TBloomFilterBase = class(TInterfacedObject)
private
  //备注:因对象有临界保护,故为了性能考虑,10种散列函数所须用到的MD5Digest和SHA1Digest为类全局变量.以减少计算次数.
  FMD5Digest: TMD5Digest;
  FSHADigest: TSHA1Digest;
  FLock: TCriticalSection;

  //10个取得Hash数组下标的函数
  //暂时以MD5和SHA1以四字节四字节做为单位,每个单位独立算成HashIndex.共9个
  //GetHashIndexFunc0取MD5的四个单位相加再除模的方法算HashIndex值
  function GetHashIndexFunc0(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc1(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc2(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc3(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc4(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc5(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc6(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc7(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc8(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
  function GetHashIndexFunc9(ABuffer: PChar; ALen: Integer; AMaxCount:
    Cardinal): Cardinal;
protected
  FMaxCount:Cardinal;
  HashFuncMans: array[0..MaxHashFuncCount - 1] of THashFuncMan;
  procedure CelHashIndex(AStr: string);
public
  constructor Create(AMaxCount : Cardinal);
  destructor Destroy; override;
end;

{————指针操作数组的BloomFilter实现的虚类———–}
TPointerBloomFilterBase = class(TBloomFilterBase, IBloomFilter)
private
  FLock: TCriticalSection;
protected
  //数组保存内存起始位置. 在这里采用内存指针而不是数组是为了方便内存映射文件这种外存方式和内存方式的共同使用.
  //而定义为PChar类型只是为了指针移动相加方便,实际应该是Pointer,但Pointer与整形相加得强转,麻烦一点
  FBasePointer: PChar;
 
  function GetMaxCount: Cardinal;
public
  constructor Create(AMaxCount: Integer);
  destructor Destroy; override;
  function FilterData(AStr: string; AAutoAdd: Boolean): Boolean;
  property MaxCount: Cardinal read GetMaxCount;

end;

{————使用内存数组的的BloomFilter实现的类———–}
TMemoryBloomFilter = class(TPointerBloomFilterBase)
public
  constructor Create(AMaxCount: Integer);
  destructor Destroy; override;
end;

{————使用外存文件,用内存映射文件的的BloomFilter实现的类———–}
TMemoryFileBloomFilter = class(TPointerBloomFilterBase)
private
  hFileMap: Cardinal;
  hFile: Cardinal;
public
  constructor Create(AFileName: string; AMaxCount: Integer; ACreateNew:
    Boolean);
  destructor Destroy; override;
end;

implementation

{ TBloomFilterBase }

{—————10个取得Hash数组下标的函数——————-}  
constructor TBloomFilterBase.Create(AMaxCount : Cardinal);
var
I : Integer;
begin
inherited Create;

//—-初始化计算Hash下标的函数组– 如果修改 MaxHashFuncCount 这里也要修改
HashFuncMans[0].GetHashIndexFunc := GetHashIndexFunc0;
HashFuncMans[1].GetHashIndexFunc := GetHashIndexFunc1;
HashFuncMans[2].GetHashIndexFunc := GetHashIndexFunc2;
HashFuncMans[3].GetHashIndexFunc := GetHashIndexFunc3;
HashFuncMans[4].GetHashIndexFunc := GetHashIndexFunc4;
HashFuncMans[5].GetHashIndexFunc := GetHashIndexFunc5;
HashFuncMans[6].GetHashIndexFunc := GetHashIndexFunc6;
HashFuncMans[7].GetHashIndexFunc := GetHashIndexFunc7;
HashFuncMans[8].GetHashIndexFunc := GetHashIndexFunc8;
HashFuncMans[9].GetHashIndexFunc := GetHashIndexFunc9;

for I := 0 to MaxHashFuncCount – 1 do
  HashFuncMans[I].Index := I;

FLock := TCriticalSection.Create;

FMaxCount := AMaxCount;
end;

destructor TBloomFilterBase.Destroy;
begin
FLock.Leave;
inherited;
end;

procedure TBloomFilterBase.CelHashIndex(AStr: string);
var
I: Integer;
begin
FLock.Enter;
try
  FMD5Digest := MD5Buffer(AStr[1], Length(AStr));
  FSHADigest := SHA1Buffer(AStr[1], Length(AStr));

  for I := Low(HashFuncMans) to High(HashFuncMans) do
    HashFuncMans[I].HashIndex :=
    HashFuncMans[I].GetHashIndexFunc(PChar(@AStr[1]), Length(AStr),
    FMaxCount);
finally
  FLock.Leave;
end;
end;

function TBloomFilterBase.GetHashIndexFunc0(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
var
I: Integer;
begin
//使用MD5
Result := 0;
for I := 0 to 3 do
  Result := Result + PCardinal(PChar(@FMD5Digest) + I * SizeOf(Cardinal))^;

Result := Result mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc1(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FMD5Digest.A) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc2(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FMD5Digest.B) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc3(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FMD5Digest.C) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc4(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result :=Cardinal(FMD5Digest.D) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc5(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FSHADigest.A) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc6(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FSHADigest.B) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc7(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FSHADigest.C) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc8(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FSHADigest.D) mod FMaxCount;
end;

function TBloomFilterBase.GetHashIndexFunc9(ABuffer: PChar; ALen:
Integer; AMaxCount: Cardinal):
Cardinal;
begin
Result := Cardinal(FSHADigest.E) mod FMaxCount;
end;

{ TPointerBloomFilterBase }

constructor TPointerBloomFilterBase.Create(AMaxCount: Integer);
var
I: Integer;
begin
inherited Create(AMaxCount);
//保存大小
FLock := TCriticalSection.Create;
end;

destructor TPointerBloomFilterBase.Destroy;
begin
FLock.Free;
inherited;
end;

function TPointerBloomFilterBase.FilterData(AStr: string;
AAutoAdd: Boolean): Boolean;
var
I: Integer;
begin
//临界保护读写.
FLock.Enter;
try
  Result := True; //先假定是存在

//计算Hash下标
  CelHashIndex(AStr);

  for I := 0 to MaxHashFuncCount – 1 do
  begin
    Result := Result
    and (
    (PWord(FBasePointer + HashFuncMans[I].HashIndex * SizeOf(Word))^ and ($01
    shl
    HashFuncMans[I].Index))
    <> 0);
    if not Result then Break;
  end;

  //如果不存在,且要求自动保存
  if (not Result) and AAutoAdd then
  begin
  //添加,更改标记
    for I := 0 to MaxHashFuncCount – 1 do
    begin
    PWord(FBasePointer + HashFuncMans[I].HashIndex * SizeOf(Word))^
      :=
      PWord(FBasePointer + HashFuncMans[I].HashIndex * SizeOf(Word))^ or ($01
      shl
      HashFuncMans[I].Index);
    end;
  end;
finally
  FLock.Leave;
end;
end;

function TPointerBloomFilterBase.GetMaxCount: Cardinal;
begin
Result := FMaxCount;
end;

{ TMemoryBloomFilter }

constructor TMemoryBloomFilter.Create(AMaxCount: Integer);
begin
inherited Create(AMaxCount);
GetMem(FBasePointer, FMaxCount * 2);
end;

destructor TMemoryBloomFilter.Destroy;
begin
FreeMem(FBasePointer, FMaxCount * 2 );
inherited;
end;

{ TMemoryFileBloomFilter }

constructor TMemoryFileBloomFilter.Create(AFileName: string;
AMaxCount: Integer; ACreateNew: Boolean);
begin
inherited Create(AMaxCount);

if (not ACreateNew) and (not FileExists(AFileName)) then
  ACreateNew := True;

if ACreateNew then
begin
  hFile := CreateFile(PAnsiChar(AFileName)
    , GENERIC_READ or GENERIC_WRITE, FILE_SHARE_READ, nil
    , CREATE_ALWAYS, 0, 0);
end
else
begin
  hFile := CreateFile(PAnsiChar(AFileName), GENERIC_READ or GENERIC_WRITE,
    FILE_SHARE_READ, nil, OPEN_ALWAYS, 0, 0);
  //通过已存在文件取得Hash桶的容量大小
  FMaxCount := GetFileSize(hFile, nil) div SizeOf(Word);
end;
if hFile = INVALID_HANDLE_VALUE then
  raise Exception.Create(SysErrorMessage(GetLastError));

hFileMap := CreateFileMapping(hFile, nil, PAGE_READWRITE, 0, FMaxCount *
  SizeOf(Word), nil);
if hFileMap = 0 then
  raise Exception.Create(‘CreateFileMapping Error!! ‘);

FBasePointer := MapViewOfFile(hFileMap, FILE_MAP_ALL_ACCESS, 0, 0, 0);
if not Assigned(FBasePointer) then
  raise Exception.Create(SysErrorMessage(GetLastError));
end;

destructor TMemoryFileBloomFilter.Destroy;
begin
FlushViewOfFile(FBasePointer, 0);
UnmapViewOfFile(FBasePointer);
CloseHandle(hFileMap);
CloseHandle(hFile);
inherited;
end;

end.
undefined

测试结果:
procedure TForm1.btnTestURLClick(Sender: TObject);
var
BloomFilter : IBloomFilter;
I : Integer;
Count : Integer;
SueeCount : Integer;
ErrorCount : Integer;
begin
qry1.Close;
qry1.SQL.Text := ‘Select DISTINCT Url From Song’;
qry1.Open;
Count := qry1.RecordCount;
qry1.First;
BloomFilter := TMemoryBloomFilter.Create(Count*4);
while not qry1.Eof do
begin

  If not BloomFilter.FilterData(qry1.FieldByName(‘URL’).AsString,True) then
    Inc(SueeCount)
  else
    Inc(ErrorCount);

  qry1.Next;
end;
qry1.Close;
lbledtTestCount.Text := IntToStr(Count);
lbledtSuee.Text := IntToStr(SueeCount);
lbledtError.Text := IntToStr(ErrorCount);
lbledtScal.Text := FloatToStr(ErrorCount/SueeCount);
end;

以上是测试的函数,数组大小为测试数据的4倍大小.
测试结果:
测试URL数:97301
不重复数:97300
冲突数:1
冲突比例:1.02774922918808E-5