[科研日志] EWH(1)

继续快速相似文件查询的研究，用到一篇文献的思想，对其进行仿真。

文献：A Fast Approximate Nearest Neighbor Search Algorithm in the Hamming Space

下载文献

该文献的主要思想是：输入文件的哈希值（我用的是文件名）例如一个64位的哈希值，多次随机抽取若干位（例如4位）的值组成一个字串，按照字串值的不同将文件放入不同的哈希桶中。这样一个64位哈希值将被放入64/4=16个桶中，查询时把所有查询点也哈希成64位哈希值，按照相同的方式随机抽取，把所在桶中所有的字符串全部拿出来做候选集。同时，为了进一步提高查全率设定一个权重值（度量汉明距离），准备一个汉明字典将所有字串和其他汉明字串的值记录用以将权重值内的桶的字符串也做为候选集。

这个程序是用于产生汉明字典的工具类。

[java]  view plain copy print ?

1. package test;  
2. import java.io.File;  
3. import java.io.FileOutputStream;  
4. import java.io.OutputStream;  
5.   
6. import org.junit.Test;  
7. /** 
8.  * 产生二进制串字典的工具类 
9.  * @author edward 
10.  * @data 2014.8.16 8.18 
11.  * @return 输出二进制串的所有可能组合 到文件 暂时考虑4位，8位，16位（他们可以被64位整除） 
12.  * */  
13.   
14. public class GeneBinStrUtil {  
15.     int length[]={4,8,16};  
16.     int sum[]={16,256,65536};  
17.     String a[]=new String[sum[0]],  
18.             b[]=new String[sum[1]];  
19. //  String c[]=new String[length[2]];  //TODO 数组大小的限制是？  
20.     //二维数组A存放的是长度为4的二进制串的汉明距离字典   
21.     //这个矩阵的每一行对应一个二进制串和其他所有相同长度的二进制串的汉明距离。  
22.     //这个矩阵的对角线元素没有赋值为0，这是可以直接知道的。事实上计算的是一个上三角。  
23.     String A[][]=new String[sum[0]][sum[0]];  
24.     String B[][]=new String[sum[1]][sum[1]];  
25.       
26.     @Test  
27.     public void GeneTest() throws Exception{  
28.         for(int i=0;i<length.length;i++){  
29.             int t=0;  
30. //          System.out.println(String.format("%05d %s", t,Integer.toBinaryString(t)));            
31.             for(int j=0;j<sum[i];j++){  
32.                 if(i==0){  
33.                     //为了得到指定长度的字符串 做了特殊处理  
34.                     a[j]=String.format("%04d",Integer.valueOf(Integer.toBinaryString(t)));  
35. //                  System.out.println(a[j]);  
36.                 }  
37.                 else if(i==1){  
38.                     b[j]=String.format("%08d",Integer.valueOf(Integer.toBinaryString(t)));  
39. //                  System.out.println(b[j]);  
40.                 }  
41.                       
42.                 else{  
43. //                  c[j]=Integer.toBinaryString(t);  
44.                     if(i==2)break; //暂时只考虑前两组  
45.                 }  
46.                 t+=1;             
47. //              System.out.println(String.format("%05d %s", t,Integer.toBinaryString(t)));  
48.             }  
49.         }  
50.           
51.         geneHamMatrix(A,a);  
52.         for(int i=0;i<sum[0];i++)  
53.             sort(A[i]);  
54.         writeArray("dataset/dic_4bit.txt",A);  
55.           
56.         geneHamMatrix(B,b);  
57.         for(int i=0;i<sum[1];i++)  
58.             sort(B[i]);  
59.         writeArray("dataset/dic_8bit.txt",B);  
60.         /**/  
61.     }  
62.       
63.     public int hamDis(String str1, String str2) {  
64.         int tot = 0;  
65.         if(str1.length()!=str2.length()) return -1;  
66.         for(int i=0;i<str1.length();i++){  
67.             if(str1.charAt(i)!=str2.charAt(i))tot++;  
68.         }  
69. //      System.out.println(tot);  
70.         return tot;  
71.     }  
72.       
73.     public String[] sort(String str[]){  
74.         String temp=null;  
75.         for(int i=0;i<str.length-1;i++){  
76.             for(int j=i+1;j<str.length;j++){  
77.                 if(str[i].compareTo(str[j])>0){  
78.                     temp=str[i];  
79.                     str[i]=str[j];  
80.                     str[j]=temp;  
81.                 }  
82.             }  
83.         }  
84.         return str;  
85.     }  
86.       
87.     /** 
88.      *Function: calculate the hamming distance matrix,  
89.      *based on the result got with calling of "HanDis". 
90.      *@param String target[][] --the container to store the hamming distances 
91.      *@param String sc[] --the binary string that needed to be handled.   
92.      */  
93.     public void geneHamMatrix(String target[][], String sc[]){  
94.         int dis=0;  
95.         for(int i=0;i<sc.length-1;i++){  
96.             target[i][i]=sc[i];  
97.             for(int j=i+1;j<sc.length;j++){  
98.                 dis=hamDis(sc[i],sc[j]);  
99.                 target[i][j]=dis+"_"+sc[j];  
100.                 target[j][i]=dis+"_"+sc[i];  
101.             }  
102.         }  
103.         target[sc.length-1][sc.length-1]=sc[sc.length-1]; //补充填充  
104.     }  
105.   
106.     /** 
107.      *Function: write the hamming distance matrix into a file. 
108.      *@param String path-- file path. 
109.      *@param String array[][] -- the hamming distance matrix. 
110.      */  
111.     public void writeArray(String path, String array[][]) throws Exception{  
112.         File f = new File(path);  
113.         if(f.exists())f.delete();  
114.         //用FileOutputSteam包装文件，并设置文件可追加  
115.         OutputStream out = new FileOutputStream(f,true);  
116.         for(int i=0;i<array[0].length;i++)  
117.             for(int j=0;j<array[0].length;j++){  
118.                 out.write(array[i][j].getBytes()); //向文件中写入数据  
119.                 out.write('\r'); // \r\n表示换行  
120.                 out.write('\n');   
121.             }         
122.         out.close();    //关闭输出流  
123.         System.out.println("写入成功！");  
124.     }  
125. }