blob: 4e0c57043e12c035cdff82b8a469a461c4623761 [file] [log] [blame]
satoke808e432010-12-02 14:53:24 +09001/*
Ken Wakasaa10b1a82013-01-08 17:23:43 +09002 * Copyright (C) 2010 The Android Open Source Project
Ken Wakasa0bbb9172012-07-25 17:51:43 +09003 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
Ken Wakasaa10b1a82013-01-08 17:23:43 +09008 * http://www.apache.org/licenses/LICENSE-2.0
Ken Wakasa0bbb9172012-07-25 17:51:43 +09009 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
satoke808e432010-12-02 14:53:24 +090016
17#ifndef LATINIME_DEFINES_H
18#define LATINIME_DEFINES_H
19
Ken Wakasa1ce96fe2012-11-15 19:09:11 +090020#ifdef __GNUC__
21#define AK_FORCE_INLINE __attribute__((always_inline)) __inline__
22#else // __GNUC__
23#define AK_FORCE_INLINE inline
24#endif // __GNUC__
25
Ken Wakasa5db594a2013-01-12 01:18:00 +090026// Must be identical to Constants.Dictionary.MAX_WORD_LENGTH in Java
27#define MAX_WORD_LENGTH 48
28// Must be identical to BinaryDictionary.MAX_RESULTS in Java
29#define MAX_RESULTS 18
Satoshi Kataoka42217382012-12-17 23:28:17 +090030
satok827ced82011-07-14 09:01:09 +090031#if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
Ken Wakasae3f26dd2012-07-27 18:06:06 +090032#include <android/log.h>
33#ifndef LOG_TAG
34#define LOG_TAG "LatinIME: "
35#endif
36#define AKLOGE(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##__VA_ARGS__)
37#define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
satok6ad15fc2012-01-16 16:21:21 +090038
Ken Wakasa5db594a2013-01-12 01:18:00 +090039#define DUMP_RESULT(words, frequencies) do { dumpResult(words, frequencies); } while (0)
Ken Wakasaf2789812012-09-04 12:49:46 +090040#define DUMP_WORD(word, length) do { dumpWord(word, length); } while (0)
Ken Wakasa1e614932012-10-29 18:06:22 +090041#define INTS_TO_CHARS(input, length, output) do { \
42 intArrayToCharArray(input, length, output); } while (0)
satok6ad15fc2012-01-16 16:21:21 +090043
Satoshi Kataoka42217382012-12-17 23:28:17 +090044// TODO: Support full UTF-8 conversion
45AK_FORCE_INLINE static int intArrayToCharArray(const int *source, const int sourceSize,
46 char *dest) {
47 int si = 0;
48 int di = 0;
Ken Wakasa5db594a2013-01-12 01:18:00 +090049 while (si < sourceSize && di < MAX_WORD_LENGTH - 1 && 0 != source[si]) {
Satoshi Kataoka42217382012-12-17 23:28:17 +090050 const int codePoint = source[si++];
51 if (codePoint < 0x7F) {
52 dest[di++] = codePoint;
53 } else if (codePoint < 0x7FF) {
54 dest[di++] = 0xC0 + (codePoint >> 6);
55 dest[di++] = 0x80 + (codePoint & 0x3F);
56 } else if (codePoint < 0xFFFF) {
57 dest[di++] = 0xE0 + (codePoint >> 12);
58 dest[di++] = 0x80 + ((codePoint & 0xFC0) >> 6);
59 dest[di++] = 0x80 + (codePoint & 0x3F);
60 }
61 }
62 dest[di] = 0;
63 return di;
64}
65
Ken Wakasa1e614932012-10-29 18:06:22 +090066static inline void dumpWordInfo(const int *word, const int length, const int rank,
67 const int frequency) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090068 static char charBuf[50];
Satoshi Kataoka42217382012-12-17 23:28:17 +090069 const int N = intArrayToCharArray(word, length, charBuf);
70 if (N > 1) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090071 AKLOGI("%2d [ %s ] (%d)", rank, charBuf, frequency);
72 }
73}
74
Ken Wakasa5db594a2013-01-12 01:18:00 +090075static inline void dumpResult(const int *outWords, const int *frequencies) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090076 AKLOGI("--- DUMP RESULT ---------");
Ken Wakasa5db594a2013-01-12 01:18:00 +090077 for (int i = 0; i < MAX_RESULTS; ++i) {
78 dumpWordInfo(&outWords[i * MAX_WORD_LENGTH], MAX_WORD_LENGTH, i, frequencies[i]);
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090079 }
80 AKLOGI("-------------------------");
81}
82
Ken Wakasa1ce96fe2012-11-15 19:09:11 +090083static AK_FORCE_INLINE void dumpWord(const int *word, const int length) {
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +090084 static char charBuf[50];
Satoshi Kataoka42217382012-12-17 23:28:17 +090085 const int N = intArrayToCharArray(word, length, charBuf);
86 if (N > 1) {
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090087 AKLOGI("[ %s ]", charBuf);
88 }
satok6ad15fc2012-01-16 16:21:21 +090089}
90
Satoshi Kataoka5540acb2012-09-03 18:35:32 +090091#ifndef __ANDROID__
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +090092#include <cassert>
Satoshi Kataoka5540acb2012-09-03 18:35:32 +090093#include <execinfo.h>
94#include <stdlib.h>
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +090095
Satoshi Kataokadd4d9382013-01-09 12:54:39 +090096#define DO_ASSERT_TEST
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +090097#define ASSERT(success) do { if (!(success)) { showStackTrace(); assert(success);} } while (0)
98#define SHOW_STACK_TRACE do { showStackTrace(); } while (0)
99
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900100static inline void showStackTrace() {
101 void *callstack[128];
102 int i, frames = backtrace(callstack, 128);
103 char **strs = backtrace_symbols(callstack, frames);
104 for (i = 0; i < frames; ++i) {
105 if (i == 0) {
106 AKLOGI("=== Trace ===");
107 continue;
108 }
109 AKLOGI("%s", strs[i]);
110 }
111 free(strs);
112}
113#else
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900114#include <cassert>
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900115#define DO_ASSERT_TEST
Satoshi Kataoka1c8fc832012-09-06 21:31:54 +0900116#define ASSERT(success) assert(success)
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900117#define SHOW_STACK_TRACE
118#endif
119
satok827ced82011-07-14 09:01:09 +0900120#else
satok9fb6f472012-01-13 18:01:22 +0900121#define AKLOGE(fmt, ...)
122#define AKLOGI(fmt, ...)
Ken Wakasa5db594a2013-01-12 01:18:00 +0900123#define DUMP_RESULT(words, frequencies)
satok6ad15fc2012-01-16 16:21:21 +0900124#define DUMP_WORD(word, length)
Satoshi Kataokadd4d9382013-01-09 12:54:39 +0900125#undef DO_ASSERT_TEST
Satoshi Kataoka5540acb2012-09-03 18:35:32 +0900126#define ASSERT(success)
127#define SHOW_STACK_TRACE
Ken Wakasa1e614932012-10-29 18:06:22 +0900128#define INTS_TO_CHARS(input, length, output)
satok827ced82011-07-14 09:01:09 +0900129#endif
130
satok20d9fda2011-07-13 14:40:30 +0900131#ifdef FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900132// Profiler
133#include <time.h>
satok9fb6f472012-01-13 18:01:22 +0900134
satok61e2f852011-01-05 14:13:07 +0900135#define PROF_BUF_SIZE 100
satok0028ed32012-05-16 20:42:12 +0900136static float profile_buf[PROF_BUF_SIZE];
137static float profile_old[PROF_BUF_SIZE];
satok61e2f852011-01-05 14:13:07 +0900138static unsigned int profile_counter[PROF_BUF_SIZE];
139
Ken Wakasae90b3332011-01-07 15:01:51 +0900140#define PROF_RESET prof_reset()
141#define PROF_COUNT(prof_buf_id) ++profile_counter[prof_buf_id]
Ken Wakasaf2789812012-09-04 12:49:46 +0900142#define PROF_OPEN do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while (0)
Ken Wakasae90b3332011-01-07 15:01:51 +0900143#define PROF_START(prof_buf_id) do { \
Ken Wakasaf2789812012-09-04 12:49:46 +0900144 PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while (0)
145#define PROF_CLOSE do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while (0)
Ken Wakasae90b3332011-01-07 15:01:51 +0900146#define PROF_END(prof_buf_id) profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
147#define PROF_CLOCKOUT(prof_buf_id) \
satok9fb6f472012-01-13 18:01:22 +0900148 AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
Ken Wakasaf2789812012-09-04 12:49:46 +0900149#define PROF_OUTALL do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while (0)
satok61e2f852011-01-05 14:13:07 +0900150
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900151static inline void prof_reset(void) {
Ken Wakasae90b3332011-01-07 15:01:51 +0900152 for (int i = 0; i < PROF_BUF_SIZE; ++i) {
satok61e2f852011-01-05 14:13:07 +0900153 profile_buf[i] = 0;
154 profile_old[i] = 0;
155 profile_counter[i] = 0;
156 }
157}
158
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900159static inline void prof_out(void) {
satok61e2f852011-01-05 14:13:07 +0900160 if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
satok9fb6f472012-01-13 18:01:22 +0900161 AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
satok61e2f852011-01-05 14:13:07 +0900162 }
satok9fb6f472012-01-13 18:01:22 +0900163 AKLOGI("Total time is %6.3f ms.",
Ken Wakasa77e8e812012-08-02 19:48:08 +0900164 profile_buf[PROF_BUF_SIZE - 1] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC));
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900165 float all = 0.0f;
Ken Wakasae90b3332011-01-07 15:01:51 +0900166 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
satok61e2f852011-01-05 14:13:07 +0900167 all += profile_buf[i];
168 }
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900169 if (all < 1.0f) all = 1.0f;
Ken Wakasae90b3332011-01-07 15:01:51 +0900170 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900171 if (profile_buf[i] > 0.0f) {
satok9fb6f472012-01-13 18:01:22 +0900172 AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
Ken Wakasa2a6f58d2012-11-27 19:40:38 +0900173 i, (profile_buf[i] * 100.0f / all),
Ken Wakasa77e8e812012-08-02 19:48:08 +0900174 profile_buf[i] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC),
175 profile_counter[i]);
Ken Wakasae90b3332011-01-07 15:01:51 +0900176 }
satok61e2f852011-01-05 14:13:07 +0900177 }
178}
179
satok20d9fda2011-07-13 14:40:30 +0900180#else // FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900181#define PROF_BUF_SIZE 0
182#define PROF_RESET
183#define PROF_COUNT(prof_buf_id)
184#define PROF_OPEN
185#define PROF_START(prof_buf_id)
186#define PROF_CLOSE
187#define PROF_END(prof_buf_id)
188#define PROF_CLOCK_OUT(prof_buf_id)
189#define PROF_CLOCKOUT(prof_buf_id)
190#define PROF_OUTALL
191
satok20d9fda2011-07-13 14:40:30 +0900192#endif // FLAG_DO_PROFILE
193
194#ifdef FLAG_DBG
satok20d9fda2011-07-13 14:40:30 +0900195#define DEBUG_DICT true
196#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900197#define DEBUG_EDIT_DISTANCE false
satok10266c02011-08-19 22:05:59 +0900198#define DEBUG_SHOW_FOUND_WORD false
satok20d9fda2011-07-13 14:40:30 +0900199#define DEBUG_NODE DEBUG_DICT_FULL
200#define DEBUG_TRACE DEBUG_DICT_FULL
satok1a6da632011-12-16 23:15:06 +0900201#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900202#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900203#define DEBUG_CORRECTION false
satok29dc8062012-01-17 15:59:15 +0900204#define DEBUG_CORRECTION_FREQ false
205#define DEBUG_WORDS_PRIORITY_QUEUE false
Satoshi Kataoka0ed8c6e2012-12-04 16:28:06 +0900206#define DEBUG_SAMPLING_POINTS false
207#define DEBUG_POINTS_PROBABILITY false
208#define DEBUG_DOUBLE_LETTER false
satok20d9fda2011-07-13 14:40:30 +0900209
Satoshi Kataoka952ec492012-09-11 15:51:38 +0900210#ifdef FLAG_FULL_DBG
211#define DEBUG_GEO_FULL true
212#else
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900213#define DEBUG_GEO_FULL false
Satoshi Kataoka952ec492012-09-11 15:51:38 +0900214#endif
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900215
satok20d9fda2011-07-13 14:40:30 +0900216#else // FLAG_DBG
satok827ced82011-07-14 09:01:09 +0900217
satok20d9fda2011-07-13 14:40:30 +0900218#define DEBUG_DICT false
219#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900220#define DEBUG_EDIT_DISTANCE false
satok20d9fda2011-07-13 14:40:30 +0900221#define DEBUG_SHOW_FOUND_WORD false
222#define DEBUG_NODE false
223#define DEBUG_TRACE false
224#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900225#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900226#define DEBUG_CORRECTION false
227#define DEBUG_CORRECTION_FREQ false
satok16379df2011-12-12 20:53:22 +0900228#define DEBUG_WORDS_PRIORITY_QUEUE false
Keisuke Kuroyanagi806eba42012-10-09 19:57:08 +0900229#define DEBUG_SAMPLING_POINTS false
230#define DEBUG_POINTS_PROBABILITY false
Satoshi Kataoka9af53352012-11-16 23:06:41 +0900231#define DEBUG_DOUBLE_LETTER false
satok20d9fda2011-07-13 14:40:30 +0900232
Satoshi Kataoka23a57ea2012-09-10 17:59:17 +0900233#define DEBUG_GEO_FULL false
234
satoke808e432010-12-02 14:53:24 +0900235#endif // FLAG_DBG
236
Jean Chalarda5d58492011-02-18 17:50:58 +0900237#ifndef S_INT_MAX
satok3c4bb772011-03-04 22:50:19 -0800238#define S_INT_MAX 2147483647 // ((1 << 31) - 1)
Jean Chalarda5d58492011-02-18 17:50:58 +0900239#endif
Jean Chalard592f2b32012-11-20 21:19:26 +0900240#ifndef S_INT_MIN
241// The literal constant -2147483648 does not work in C prior C90, because
242// the compiler tries to fit the positive number into an int and then negate it.
243// GCC warns about this.
244#define S_INT_MIN (-2147483647 - 1) // -(1 << 31)
245#endif
Jean Chalard22025c62012-11-29 17:33:53 +0900246// Number of base-10 digits in the largest integer + 1 to leave room for a zero terminator.
247// As such, this is the maximum number of characters will be needed to represent an int as a
248// string, including the terminator; this is used as the size of a string buffer large enough to
249// hold any value that is intended to fit in an integer, e.g. in the code that reads the header
250// of the binary dictionary where a {key,value} string pair scheme is used.
251#define LARGEST_INT_DIGIT_COUNT 11
satok662fe692010-12-08 17:05:39 +0900252
Ken Wakasae90b3332011-01-07 15:01:51 +0900253// Define this to use mmap() for dictionary loading. Undefine to use malloc() instead of mmap().
254// We measured and compared performance of both, and found mmap() is fairly good in terms of
255// loading time, and acceptable even for several initial lookups which involve page faults.
256#define USE_MMAP_FOR_DICTIONARY
257
satoke808e432010-12-02 14:53:24 +0900258// 22-bit address = ~4MB dictionary size limit, which on average would be about 200k-300k words
259#define ADDRESS_MASK 0x3FFFFF
260
261// The bit that decides if an address follows in the next 22 bits
262#define FLAG_ADDRESS_MASK 0x40
263// The bit that decides if this is a terminal node for a word. The node could still have children,
264// if the word has other endings.
265#define FLAG_TERMINAL_MASK 0x80
266
267#define FLAG_BIGRAM_READ 0x80
268#define FLAG_BIGRAM_CHILDEXIST 0x40
269#define FLAG_BIGRAM_CONTINUED 0x80
270#define FLAG_BIGRAM_FREQ 0x7F
271
272#define DICTIONARY_VERSION_MIN 200
Ken Wakasaf2789812012-09-04 12:49:46 +0900273#define NOT_VALID_WORD (-99)
274#define NOT_A_CODE_POINT (-1)
275#define NOT_A_DISTANCE (-1)
276#define NOT_A_COORDINATE (-1)
277#define EQUIVALENT_CHAR_WITHOUT_DISTANCE_INFO (-2)
278#define PROXIMITY_CHAR_WITHOUT_DISTANCE_INFO (-3)
279#define ADDITIONAL_PROXIMITY_CHAR_DISTANCE_INFO (-4)
280#define NOT_AN_INDEX (-1)
281#define NOT_A_PROBABILITY (-1)
satoke808e432010-12-02 14:53:24 +0900282
satok817e5172011-03-04 06:06:45 -0800283#define KEYCODE_SPACE ' '
Ken Wakasa1e614932012-10-29 18:06:22 +0900284#define KEYCODE_SINGLE_QUOTE '\''
285#define KEYCODE_HYPHEN_MINUS '-'
satok817e5172011-03-04 06:06:45 -0800286
Yusuke Nojimaafb90762011-10-05 18:11:42 +0900287#define CALIBRATE_SCORE_BY_TOUCH_COORDINATES true
Yusuke Nojima258bfe62011-09-28 12:59:43 +0900288
satok662fe692010-12-08 17:05:39 +0900289#define SUGGEST_WORDS_WITH_MISSING_CHARACTER true
satok662fe692010-12-08 17:05:39 +0900290#define SUGGEST_WORDS_WITH_EXCESSIVE_CHARACTER true
satoka3d78f62010-12-09 22:08:33 +0900291#define SUGGEST_WORDS_WITH_TRANSPOSED_CHARACTERS true
satok99557162012-01-26 22:49:13 +0900292#define SUGGEST_MULTIPLE_WORDS true
satoka3d78f62010-12-09 22:08:33 +0900293
Jean Chalard8dc754a2011-01-27 14:20:22 +0900294// The following "rate"s are used as a multiplier before dividing by 100, so they are in percent.
satok72bc17e2011-04-13 17:23:27 +0900295#define WORDS_WITH_MISSING_CHARACTER_DEMOTION_RATE 80
satokdc5301e2011-04-11 16:14:45 +0900296#define WORDS_WITH_MISSING_CHARACTER_DEMOTION_START_POS_10X 12
satok54af64a2012-01-17 15:58:23 +0900297#define WORDS_WITH_MISSING_SPACE_CHARACTER_DEMOTION_RATE 58
satok8330b482012-01-23 16:52:37 +0900298#define WORDS_WITH_MISTYPED_SPACE_DEMOTION_RATE 50
satoka3d78f62010-12-09 22:08:33 +0900299#define WORDS_WITH_EXCESSIVE_CHARACTER_DEMOTION_RATE 75
satok54fe9e02010-12-13 14:42:35 +0900300#define WORDS_WITH_EXCESSIVE_CHARACTER_OUT_OF_PROXIMITY_DEMOTION_RATE 75
satoka161a4a2012-01-16 18:38:32 +0900301#define WORDS_WITH_TRANSPOSED_CHARACTERS_DEMOTION_RATE 70
satok58c49b92011-01-27 03:23:39 +0900302#define FULL_MATCHED_WORDS_PROMOTION_RATE 120
satok9d2a3022011-04-14 19:13:34 +0900303#define WORDS_WITH_PROXIMITY_CHARACTER_DEMOTION_RATE 90
satok1b9fa942012-02-02 18:49:22 +0900304#define WORDS_WITH_ADDITIONAL_PROXIMITY_CHARACTER_DEMOTION_RATE 70
satok635f68e2011-08-10 22:19:33 +0900305#define WORDS_WITH_MATCH_SKIP_PROMOTION_RATE 105
satok1b9fa942012-02-02 18:49:22 +0900306#define WORDS_WITH_JUST_ONE_CORRECTION_PROMOTION_RATE 148
307#define WORDS_WITH_JUST_ONE_CORRECTION_PROMOTION_MULTIPLIER 3
satok10266c02011-08-19 22:05:59 +0900308#define CORRECTION_COUNT_RATE_DEMOTION_RATE_BASE 45
309#define INPUT_EXCEEDS_OUTPUT_DEMOTION_RATE 70
310#define FIRST_CHAR_DIFFERENT_DEMOTION_RATE 96
satokeb050fc2011-10-03 19:21:13 +0900311#define TWO_WORDS_CAPITALIZED_DEMOTION_RATE 50
satok54af64a2012-01-17 15:58:23 +0900312#define TWO_WORDS_CORRECTION_DEMOTION_BASE 80
313#define TWO_WORDS_PLUS_OTHER_ERROR_CORRECTION_DEMOTION_DIVIDER 1
Yusuke Nojimaa4c1f1c2011-10-06 19:12:20 +0900314#define ZERO_DISTANCE_PROMOTION_RATE 110
315#define NEUTRAL_SCORE_SQUARED_RADIUS 8.0f
316#define HALF_SCORE_SQUARED_RADIUS 32.0f
satoka85f4922012-01-30 18:18:30 +0900317#define MAX_FREQ 255
Jean Chalard9416c812012-05-15 19:24:47 +0900318#define MAX_BIGRAM_FREQ 15
satoke808e432010-12-02 14:53:24 +0900319
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900320// This must be the same as ProximityInfo#MAX_PROXIMITY_CHARS_SIZE, currently it's 16.
321#define MAX_PROXIMITY_CHARS_SIZE_INTERNAL 16
322
satoke05b3f42012-01-31 17:15:43 +0900323// This must be equal to ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE in KeyDetector.java
324#define ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE 2
325
Ken Wakasa9e0c7112012-08-09 22:26:58 +0900326// Assuming locale strings such as en_US, sr-Latn etc.
327#define MAX_LOCALE_STRING_LENGTH 10
328
satoka7e5a5a2011-12-15 16:49:12 +0900329// Word limit for sub queues used in WordsPriorityQueuePool. Sub queues are temporary queues used
330// for better performance.
satok6ad15fc2012-01-16 16:21:21 +0900331// Holds up to 1 candidate for each word
332#define SUB_QUEUE_MAX_WORDS 1
satokb9604772012-01-13 15:41:17 +0900333#define SUB_QUEUE_MAX_COUNT 10
satok54af64a2012-01-17 15:58:23 +0900334#define SUB_QUEUE_MIN_WORD_LENGTH 4
Satoshi Kataoka67e3cc82012-05-31 15:04:58 +0900335// TODO: Extend this limitation
336#define MULTIPLE_WORDS_SUGGESTION_MAX_WORDS 5
Satoshi Kataoka6cbe2042012-05-30 17:28:34 +0900337// TODO: Remove this limitation
338#define MULTIPLE_WORDS_SUGGESTION_MAX_WORD_LENGTH 12
339// TODO: Remove this limitation
Satoshi Kataoka67e3cc82012-05-31 15:04:58 +0900340#define MULTIPLE_WORDS_SUGGESTION_MAX_TOTAL_TRAVERSE_COUNT 45
satoka85f4922012-01-30 18:18:30 +0900341#define MULTIPLE_WORDS_DEMOTION_RATE 80
342#define MIN_INPUT_LENGTH_FOR_THREE_OR_MORE_WORDS_CORRECTION 6
satoka7e5a5a2011-12-15 16:49:12 +0900343
Ken Wakasab02ee3d2012-10-08 11:46:14 +0900344#define TWO_WORDS_CORRECTION_WITH_OTHER_ERROR_THRESHOLD 0.35f
345#define START_TWO_WORDS_CORRECTION_THRESHOLD 0.185f
satoka0ac31f2012-05-23 19:55:27 +0900346/* heuristic... This should be changed if we change the unit of the frequency. */
347#define SUPPRESS_SHORT_MULTIPLE_WORDS_THRESHOLD_FREQ (MAX_FREQ * 58 / 100)
satok29dc8062012-01-17 15:59:15 +0900348
satok68319262010-12-03 19:38:08 +0900349#define MAX_DEPTH_MULTIPLIER 3
satok1f6b52e2012-01-30 13:53:58 +0900350#define FIRST_WORD_INDEX 0
Satoshi Kataoka5817b6b2013-01-09 20:05:26 +0900351
Satoshi Kataoka687a2442012-08-23 15:46:43 +0900352// Max Distance between point to key
353#define MAX_POINT_TO_KEY_LENGTH 10000000
354
Keisuke Kuroyanagi95a49a52012-09-04 17:00:24 +0900355// The max number of the keys in one keyboard layout
356#define MAX_KEY_COUNT_IN_A_KEYBOARD 64
357
Jean Chalard6c300612012-03-06 19:54:03 +0900358// TODO: Reduce this constant if possible; check the maximum number of digraphs in the same
359// word in the dictionary for languages with digraphs, like German and French
360#define DEFAULT_MAX_DIGRAPH_SEARCH_DEPTH 5
Jean Chalarda787dba2011-03-04 12:17:48 +0900361
satok99557162012-01-26 22:49:13 +0900362#define MIN_USER_TYPED_LENGTH_FOR_MULTIPLE_WORD_SUGGESTION 3
satok54fe9e02010-12-13 14:42:35 +0900363#define MIN_USER_TYPED_LENGTH_FOR_EXCESSIVE_CHARACTER_SUGGESTION 3
satok662fe692010-12-08 17:05:39 +0900364
Ken Wakasa5150e152012-09-27 19:21:25 +0900365// TODO: Remove
Satoshi Kataokafe4f1ce2012-12-10 17:17:52 +0900366#define MAX_POINTER_COUNT 1
Ken Wakasa5150e152012-09-27 19:21:25 +0900367#define MAX_POINTER_COUNT_FOR_G 2
368
Jean Chalardf1634c82012-05-02 19:05:27 +0900369// Size, in bytes, of the bloom filter index for bigrams
370// 128 gives us 1024 buckets. The probability of false positive is (1 - e ** (-kn/m))**k,
371// where k is the number of hash functions, n the number of bigrams, and m the number of
372// bits we can test.
373// At the moment 100 is the maximum number of bigrams for a word with the current
374// dictionaries, so n = 100. 1024 buckets give us m = 1024.
375// With 1 hash function, our false positive rate is about 9.3%, which should be enough for
376// our uses since we are only using this to increase average performance. For the record,
377// k = 2 gives 3.1% and k = 3 gives 1.6%. With k = 1, making m = 2048 gives 4.8%,
378// and m = 4096 gives 2.4%.
379#define BIGRAM_FILTER_BYTE_SIZE 128
380// Must be smaller than BIGRAM_FILTER_BYTE_SIZE * 8, and preferably prime. 1021 is the largest
381// prime under 128 * 8.
382#define BIGRAM_FILTER_MODULO 1021
383#if BIGRAM_FILTER_BYTE_SIZE * 8 < BIGRAM_FILTER_MODULO
384#error "BIGRAM_FILTER_MODULO is larger than BIGRAM_FILTER_BYTE_SIZE"
385#endif
386
Tadashi G. Takaoka09baa362012-02-03 21:24:53 +0900387template<typename T> inline T min(T a, T b) { return a < b ? a : b; }
388template<typename T> inline T max(T a, T b) { return a > b ? a : b; }
satokf5cded12010-12-06 21:28:24 +0900389
Ken Wakasab02ee3d2012-10-08 11:46:14 +0900390#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
391
Yusuke Nojima258bfe62011-09-28 12:59:43 +0900392// The ratio of neutral area radius to sweet spot radius.
393#define NEUTRAL_AREA_RADIUS_RATIO 1.3f
394
satoke05b3f42012-01-31 17:15:43 +0900395// DEBUG
Ken Wakasaf2789812012-09-04 12:49:46 +0900396#define INPUTLENGTH_FOR_DEBUG (-1)
397#define MIN_OUTPUT_INDEX_FOR_DEBUG (-1)
satoke05b3f42012-01-31 17:15:43 +0900398
satok1bc038c2012-06-14 11:25:50 -0700399#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
400 TypeName(const TypeName&); \
401 void operator=(const TypeName&)
402
403#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
404 TypeName(); \
405 DISALLOW_COPY_AND_ASSIGN(TypeName)
406
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900407// Used as a return value for character comparison
408typedef enum {
409 // Same char, possibly with different case or accent
410 EQUIVALENT_CHAR,
411 // It is a char located nearby on the keyboard
412 NEAR_PROXIMITY_CHAR,
413 // It is an unrelated char
414 UNRELATED_CHAR,
415 // Additional proximity char which can differ by language.
416 ADDITIONAL_PROXIMITY_CHAR
417} ProximityType;
Satoshi Kataoka6ae8dd42012-11-22 20:15:40 +0900418
419typedef enum {
420 NOT_A_DOUBLE_LETTER,
421 A_DOUBLE_LETTER,
422 A_STRONG_DOUBLE_LETTER
423} DoubleLetterLevel;
satoke808e432010-12-02 14:53:24 +0900424#endif // LATINIME_DEFINES_H