← Back to branch summary

~slub.team/goobi-indexserver/3.x

« back to all changes in this revision

Viewing changes to lucene/contrib/analyzers/smartcn/src/java/org/apache/lucene/analysis/cn/smart/hhmm/AbstractDictionary.java

  • Committer: Sebastian Meyer
  • Date: 2012-08-03 09:12:40 UTC
  • Revision ID: sebastian.meyer@slub-dresden.de-20120803091240-x6861b0vabq1xror
https://launchpad.net/bugs/985487
Remove Lucene and Solr source code and add patches instead
Fix Bug #985487: Auto-suggestion for the search interface

Show diffs side-by-side

added added

removed removed

Lines of Context:
lucene/contrib/analyzers/smartcn/src/java/org/apache/lucene/analysis/cn/smart/hhmm/AbstractDictionary.java
1
 
/**
2
 
 * Licensed to the Apache Software Foundation (ASF) under one or more
3
 
 * contributor license agreements.  See the NOTICE file distributed with
4
 
 * this work for additional information regarding copyright ownership.
5
 
 * The ASF licenses this file to You under the Apache License, Version 2.0
6
 
 * (the "License"); you may not use this file except in compliance with
7
 
 * the License.  You may obtain a copy of the License at
8
 
 *
9
 
 *     http://www.apache.org/licenses/LICENSE-2.0
10
 
 *
11
 
 * Unless required by applicable law or agreed to in writing, software
12
 
 * distributed under the License is distributed on an "AS IS" BASIS,
13
 
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14
 
 * See the License for the specific language governing permissions and
15
 
 * limitations under the License.
16
 
 */
17
 
 
18
 
package org.apache.lucene.analysis.cn.smart.hhmm;
19
 
 
20
 
import java.io.UnsupportedEncodingException;
21
 
 
22
 
/**
23
 
 * <p>
24
 
 * SmartChineseAnalyzer abstract dictionary implementation.
25
 
 * </p>
26
 
 * <p>
27
 
 * Contains methods for dealing with GB2312 encoding.
28
 
 * </p>
29
 
 * @lucene.experimental
30
 
 */
31
 
abstract class AbstractDictionary {
32
 
  /**
33
 
   * First Chinese Character in GB2312 (15 * 94)
34
 
   * Characters in GB2312 are arranged in a grid of 94 * 94, 0-14 are unassigned or punctuation.
35
 
   */
36
 
  public static final int GB2312_FIRST_CHAR = 1410;
37
 
 
38
 
  /**
39
 
   * Last Chinese Character in GB2312 (87 * 94). 
40
 
   * Characters in GB2312 are arranged in a grid of 94 * 94, 88-94 are unassigned.
41
 
   */
42
 
  public static final int GB2312_CHAR_NUM = 87 * 94;
43
 
 
44
 
  /**
45
 
   * Dictionary data contains 6768 Chinese characters with frequency statistics.
46
 
   */
47
 
  public static final int CHAR_NUM_IN_FILE = 6768;
48
 
 
49
 
  // =====================================================
50
 
  // code +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +A +B +C +D +E +F
51
 
  // B0A0 啊 阿 埃 挨 哎 唉 哀 皑 癌 蔼 矮 艾 碍 爱 隘
52
 
  // B0B0 鞍 氨 安 俺 按 暗 岸 胺 案 肮 昂 盎 凹 敖 熬 翱
53
 
  // B0C0 袄 傲 奥 懊 澳 芭 捌 扒 叭 吧 笆 八 疤 巴 拔 跋
54
 
  // B0D0 靶 把 耙 坝 霸 罢 爸 白 柏 百 摆 佰 败 拜 稗 斑
55
 
  // B0E0 班 搬 扳 般 颁 板 版 扮 拌 伴 瓣 半 办 绊 邦 帮
56
 
  // B0F0 梆 榜 膀 绑 棒 磅 蚌 镑 傍 谤 苞 胞 包 褒 剥
57
 
  // =====================================================
58
 
  //
59
 
  // GB2312 character set：
60
 
  // 01 94 Symbols
61
 
  // 02 72 Numbers
62
 
  // 03 94 Latin
63
 
  // 04 83 Kana
64
 
  // 05 86 Katakana
65
 
  // 06 48 Greek
66
 
  // 07 66 Cyrillic
67
 
  // 08 63 Phonetic Symbols
68
 
  // 09 76 Drawing Symbols
69
 
  // 10-15 Unassigned
70
 
  // 16-55 3755 Plane 1, in pinyin order
71
 
  // 56-87 3008 Plane 2, in radical/stroke order
72
 
  // 88-94 Unassigned
73
 
  // ======================================================
74
 
 
75
 
  /**
76
 
   * <p>
77
 
   * Transcode from GB2312 ID to Unicode
78
 
   * </p>
79
 
   * <p>
80
 
   * GB2312 is divided into a 94 * 94 grid, containing 7445 characters consisting of 6763 Chinese characters and 682 symbols.
81
 
   * Some regions are unassigned (reserved).
82
 
   * </p>
83
 
   * 
84
 
   * @param ccid GB2312 id
85
 
   * @return unicode String
86
 
   */
87
 
  public String getCCByGB2312Id(int ccid) {
88
 
    if (ccid < 0 || ccid > WordDictionary.GB2312_CHAR_NUM)
89
 
      return "";
90
 
    int cc1 = ccid / 94 + 161;
91
 
    int cc2 = ccid % 94 + 161;
92
 
    byte[] buffer = new byte[2];
93
 
    buffer[0] = (byte) cc1;
94
 
    buffer[1] = (byte) cc2;
95
 
    try {
96
 
      String cchar = new String(buffer, "GB2312");
97
 
      return cchar;
98
 
    } catch (UnsupportedEncodingException e) {
99
 
      return "";
100
 
    }
101
 
  }
102
 
 
103
 
  /**
104
 
   * Transcode from Unicode to GB2312
105
 
   * 
106
 
   * @param ch input character in Unicode, or character in Basic Latin range.
107
 
   * @return position in GB2312
108
 
   */
109
 
  public short getGB2312Id(char ch) {
110
 
    try {
111
 
      byte[] buffer = Character.toString(ch).getBytes("GB2312");
112
 
      if (buffer.length != 2) {
113
 
        // Should be a two-byte character
114
 
        return -1;
115
 
      }
116
 
      int b0 = (buffer[0] & 0x0FF) - 161; // Code starts from A1, therefore subtract 0xA1=161
117
 
      int b1 = (buffer[1] & 0x0FF) - 161; // There is no Chinese char for the first and last symbol. 
118
 
                                                                                        // Therefore, each code page only has 16*6-2=94 characters.
119
 
      return (short) (b0 * 94 + b1);
120
 
    } catch (UnsupportedEncodingException e) {
121
 
      e.printStackTrace();
122
 
    }
123
 
    return -1;
124
 
  }
125
 
 
126
 
  /**
127
 
   * 32-bit FNV Hash Function
128
 
   * 
129
 
   * @param c input character
130
 
   * @return hashcode
131
 
   */
132
 
  public long hash1(char c) {
133
 
    final long p = 1099511628211L;
134
 
    long hash = 0xcbf29ce484222325L;
135
 
    hash = (hash ^ (c & 0x00FF)) * p;
136
 
    hash = (hash ^ (c >> 8)) * p;
137
 
    hash += hash << 13;
138
 
    hash ^= hash >> 7;
139
 
    hash += hash << 3;
140
 
    hash ^= hash >> 17;
141
 
    hash += hash << 5;
142
 
    return hash;
143
 
  }
144
 
 
145
 
  /**
146
 
   * 32-bit FNV Hash Function
147
 
   * 
148
 
   * @param carray character array
149
 
   * @return hashcode
150
 
   */
151
 
  public long hash1(char carray[]) {
152
 
    final long p = 1099511628211L;
153
 
    long hash = 0xcbf29ce484222325L;
154
 
    for (int i = 0; i < carray.length; i++) {
155
 
      char d = carray[i];
156
 
      hash = (hash ^ (d & 0x00FF)) * p;
157
 
      hash = (hash ^ (d >> 8)) * p;
158
 
    }
159
 
 
160
 
    // hash += hash << 13;
161
 
    // hash ^= hash >> 7;
162
 
    // hash += hash << 3;
163
 
    // hash ^= hash >> 17;
164
 
    // hash += hash << 5;
165
 
    return hash;
166
 
  }
167
 
 
168
 
  /**
169
 
   * djb2 hash algorithm，this algorithm (k=33) was first reported by dan
170
 
   * bernstein many years ago in comp.lang.c. another version of this algorithm
171
 
   * (now favored by bernstein) uses xor: hash(i) = hash(i - 1) * 33 ^ str[i];
172
 
   * the magic of number 33 (why it works better than many other constants,
173
 
   * prime or not) has never been adequately explained.
174
 
   * 
175
 
   * @param c character
176
 
   * @return hashcode
177
 
   */
178
 
  public int hash2(char c) {
179
 
    int hash = 5381;
180
 
 
181
 
    /* hash 33 + c */
182
 
    hash = ((hash << 5) + hash) + c & 0x00FF;
183
 
    hash = ((hash << 5) + hash) + c >> 8;
184
 
 
185
 
    return hash;
186
 
  }
187
 
 
188
 
  /**
189
 
   * djb2 hash algorithm，this algorithm (k=33) was first reported by dan
190
 
   * bernstein many years ago in comp.lang.c. another version of this algorithm
191
 
   * (now favored by bernstein) uses xor: hash(i) = hash(i - 1) * 33 ^ str[i];
192
 
   * the magic of number 33 (why it works better than many other constants,
193
 
   * prime or not) has never been adequately explained.
194
 
   * 
195
 
   * @param carray character array
196
 
   * @return hashcode
197
 
   */
198
 
  public int hash2(char carray[]) {
199
 
    int hash = 5381;
200
 
 
201
 
    /* hash 33 + c */
202
 
    for (int i = 0; i < carray.length; i++) {
203
 
      char d = carray[i];
204
 
      hash = ((hash << 5) + hash) + d & 0x00FF;
205
 
      hash = ((hash << 5) + hash) + d >> 8;
206
 
    }
207
 
 
208
 
    return hash;
209
 
  }
210
 
}