blob: 31dd61e300025f8cb3a269092909b7eafba1d91e [file] [log] [blame]
satoke808e432010-12-02 14:53:24 +09001/*
Ken Wakasa5460ea32012-07-30 16:27:44 +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 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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
satok827ced82011-07-14 09:01:09 +090020#if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
Ken Wakasae3f26dd2012-07-27 18:06:06 +090021#include <android/log.h>
22#ifndef LOG_TAG
23#define LOG_TAG "LatinIME: "
24#endif
25#define AKLOGE(fmt, ...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, fmt, ##__VA_ARGS__)
26#define AKLOGI(fmt, ...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, fmt, ##__VA_ARGS__)
satok6ad15fc2012-01-16 16:21:21 +090027
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090028#define DUMP_RESULT(words, frequencies, maxWordCount, maxWordLength) do { \
29 dumpResult(words, frequencies, maxWordCount, maxWordLength); } while(0)
satok6ad15fc2012-01-16 16:21:21 +090030#define DUMP_WORD(word, length) do { dumpWord(word, length); } while(0)
Satoshi Kataoka6cbe2042012-05-30 17:28:34 +090031#define DUMP_WORD_INT(word, length) do { dumpWordInt(word, length); } while(0)
satok6ad15fc2012-01-16 16:21:21 +090032
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090033static inline void dumpWordInfo(const unsigned short *word, const int length,
34 const int rank, const int frequency) {
35 static char charBuf[50];
36 int i = 0;
37 for (; i < length; ++i) {
38 const unsigned short c = word[i];
39 if (c == 0) {
40 break;
41 }
42 charBuf[i] = c;
43 }
44 charBuf[i] = 0;
45 if (i > 1) {
46 AKLOGI("%2d [ %s ] (%d)", rank, charBuf, frequency);
47 }
48}
49
50static inline void dumpResult(
51 const unsigned short *outWords, const int *frequencies, const int maxWordCounts,
52 const int maxWordLength) {
53 AKLOGI("--- DUMP RESULT ---------");
54 for (int i = 0; i < maxWordCounts; ++i) {
55 dumpWordInfo(&outWords[i * maxWordLength], maxWordLength, i, frequencies[i]);
56 }
57 AKLOGI("-------------------------");
58}
59
Ken Wakasa0bbb9172012-07-25 17:51:43 +090060static inline void dumpWord(const unsigned short *word, const int length) {
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +090061 static char charBuf[50];
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090062 int i = 0;
63 for (; i < length; ++i) {
64 const unsigned short c = word[i];
65 if (c == 0) {
66 break;
67 }
68 charBuf[i] = c;
satok6ad15fc2012-01-16 16:21:21 +090069 }
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090070 charBuf[i] = 0;
71 if (i > 1) {
72 AKLOGI("[ %s ]", charBuf);
73 }
satok6ad15fc2012-01-16 16:21:21 +090074}
75
Ken Wakasa0bbb9172012-07-25 17:51:43 +090076static inline void dumpWordInt(const int *word, const int length) {
Satoshi Kataoka6cbe2042012-05-30 17:28:34 +090077 static char charBuf[50];
78
79 for (int i = 0; i < length; ++i) {
80 charBuf[i] = word[i];
81 }
82 charBuf[length] = 0;
83 AKLOGI("i[ %s ]", charBuf);
84}
85
satok827ced82011-07-14 09:01:09 +090086#else
satok9fb6f472012-01-13 18:01:22 +090087#define AKLOGE(fmt, ...)
88#define AKLOGI(fmt, ...)
Satoshi Kataoka586b0ca2012-08-06 11:20:54 +090089#define DUMP_RESULT(words, frequencies, maxWordCount, maxWordLength)
satok6ad15fc2012-01-16 16:21:21 +090090#define DUMP_WORD(word, length)
Satoshi Kataoka6cbe2042012-05-30 17:28:34 +090091#define DUMP_WORD_INT(word, length)
satok827ced82011-07-14 09:01:09 +090092#endif
93
satok20d9fda2011-07-13 14:40:30 +090094#ifdef FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +090095// Profiler
96#include <time.h>
satok9fb6f472012-01-13 18:01:22 +090097
satok61e2f852011-01-05 14:13:07 +090098#define PROF_BUF_SIZE 100
satok0028ed32012-05-16 20:42:12 +090099static float profile_buf[PROF_BUF_SIZE];
100static float profile_old[PROF_BUF_SIZE];
satok61e2f852011-01-05 14:13:07 +0900101static unsigned int profile_counter[PROF_BUF_SIZE];
102
Ken Wakasae90b3332011-01-07 15:01:51 +0900103#define PROF_RESET prof_reset()
104#define PROF_COUNT(prof_buf_id) ++profile_counter[prof_buf_id]
105#define PROF_OPEN do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while(0)
106#define PROF_START(prof_buf_id) do { \
107 PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while(0)
108#define PROF_CLOSE do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while(0)
109#define PROF_END(prof_buf_id) profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
110#define PROF_CLOCKOUT(prof_buf_id) \
satok9fb6f472012-01-13 18:01:22 +0900111 AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
112#define PROF_OUTALL do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while(0)
satok61e2f852011-01-05 14:13:07 +0900113
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900114static inline void prof_reset(void) {
Ken Wakasae90b3332011-01-07 15:01:51 +0900115 for (int i = 0; i < PROF_BUF_SIZE; ++i) {
satok61e2f852011-01-05 14:13:07 +0900116 profile_buf[i] = 0;
117 profile_old[i] = 0;
118 profile_counter[i] = 0;
119 }
120}
121
Tadashi G. Takaokad1dbdb62012-03-06 15:35:46 +0900122static inline void prof_out(void) {
satok61e2f852011-01-05 14:13:07 +0900123 if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
satok9fb6f472012-01-13 18:01:22 +0900124 AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
satok61e2f852011-01-05 14:13:07 +0900125 }
satok9fb6f472012-01-13 18:01:22 +0900126 AKLOGI("Total time is %6.3f ms.",
Ken Wakasa77e8e812012-08-02 19:48:08 +0900127 profile_buf[PROF_BUF_SIZE - 1] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC));
satok0028ed32012-05-16 20:42:12 +0900128 float all = 0;
Ken Wakasae90b3332011-01-07 15:01:51 +0900129 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
satok61e2f852011-01-05 14:13:07 +0900130 all += profile_buf[i];
131 }
Ken Wakasae90b3332011-01-07 15:01:51 +0900132 if (all == 0) all = 1;
133 for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
Ken Wakasa5460ea32012-07-30 16:27:44 +0900134 if (profile_buf[i]) {
satok9fb6f472012-01-13 18:01:22 +0900135 AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
Ken Wakasae90b3332011-01-07 15:01:51 +0900136 i, (profile_buf[i] * 100 / all),
Ken Wakasa77e8e812012-08-02 19:48:08 +0900137 profile_buf[i] * 1000.0f / static_cast<float>(CLOCKS_PER_SEC),
138 profile_counter[i]);
Ken Wakasae90b3332011-01-07 15:01:51 +0900139 }
satok61e2f852011-01-05 14:13:07 +0900140 }
141}
142
satok20d9fda2011-07-13 14:40:30 +0900143#else // FLAG_DO_PROFILE
satok61e2f852011-01-05 14:13:07 +0900144#define PROF_BUF_SIZE 0
145#define PROF_RESET
146#define PROF_COUNT(prof_buf_id)
147#define PROF_OPEN
148#define PROF_START(prof_buf_id)
149#define PROF_CLOSE
150#define PROF_END(prof_buf_id)
151#define PROF_CLOCK_OUT(prof_buf_id)
152#define PROF_CLOCKOUT(prof_buf_id)
153#define PROF_OUTALL
154
satok20d9fda2011-07-13 14:40:30 +0900155#endif // FLAG_DO_PROFILE
156
157#ifdef FLAG_DBG
satok20d9fda2011-07-13 14:40:30 +0900158#define DEBUG_DICT true
159#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900160#define DEBUG_EDIT_DISTANCE false
satok10266c02011-08-19 22:05:59 +0900161#define DEBUG_SHOW_FOUND_WORD false
satok20d9fda2011-07-13 14:40:30 +0900162#define DEBUG_NODE DEBUG_DICT_FULL
163#define DEBUG_TRACE DEBUG_DICT_FULL
satok1a6da632011-12-16 23:15:06 +0900164#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900165#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900166#define DEBUG_CORRECTION false
satok29dc8062012-01-17 15:59:15 +0900167#define DEBUG_CORRECTION_FREQ false
168#define DEBUG_WORDS_PRIORITY_QUEUE false
satok20d9fda2011-07-13 14:40:30 +0900169
170#else // FLAG_DBG
satok827ced82011-07-14 09:01:09 +0900171
satok20d9fda2011-07-13 14:40:30 +0900172#define DEBUG_DICT false
173#define DEBUG_DICT_FULL false
satok0cedd2b2011-08-12 01:05:27 +0900174#define DEBUG_EDIT_DISTANCE false
satok20d9fda2011-07-13 14:40:30 +0900175#define DEBUG_SHOW_FOUND_WORD false
176#define DEBUG_NODE false
177#define DEBUG_TRACE false
178#define DEBUG_PROXIMITY_INFO false
satok0cb20972012-03-13 22:07:56 +0900179#define DEBUG_PROXIMITY_CHARS false
satok10266c02011-08-19 22:05:59 +0900180#define DEBUG_CORRECTION false
181#define DEBUG_CORRECTION_FREQ false
satok16379df2011-12-12 20:53:22 +0900182#define DEBUG_WORDS_PRIORITY_QUEUE false
satok20d9fda2011-07-13 14:40:30 +0900183
satoke808e432010-12-02 14:53:24 +0900184#endif // FLAG_DBG
185
satok662fe692010-12-08 17:05:39 +0900186#ifndef U_SHORT_MAX
Yusuke Nojima63095932011-09-20 14:03:42 +0900187#define U_SHORT_MAX 65535 // ((1 << 16) - 1)
satok662fe692010-12-08 17:05:39 +0900188#endif
Jean Chalarda5d58492011-02-18 17:50:58 +0900189#ifndef S_INT_MAX
satok3c4bb772011-03-04 22:50:19 -0800190#define S_INT_MAX 2147483647 // ((1 << 31) - 1)
Jean Chalarda5d58492011-02-18 17:50:58 +0900191#endif
satok662fe692010-12-08 17:05:39 +0900192
Ken Wakasae90b3332011-01-07 15:01:51 +0900193// Define this to use mmap() for dictionary loading. Undefine to use malloc() instead of mmap().
194// We measured and compared performance of both, and found mmap() is fairly good in terms of
195// loading time, and acceptable even for several initial lookups which involve page faults.
196#define USE_MMAP_FOR_DICTIONARY
197
satoke808e432010-12-02 14:53:24 +0900198// 22-bit address = ~4MB dictionary size limit, which on average would be about 200k-300k words
199#define ADDRESS_MASK 0x3FFFFF
200
201// The bit that decides if an address follows in the next 22 bits
202#define FLAG_ADDRESS_MASK 0x40
203// The bit that decides if this is a terminal node for a word. The node could still have children,
204// if the word has other endings.
205#define FLAG_TERMINAL_MASK 0x80
206
207#define FLAG_BIGRAM_READ 0x80
208#define FLAG_BIGRAM_CHILDEXIST 0x40
209#define FLAG_BIGRAM_CONTINUED 0x80
210#define FLAG_BIGRAM_FREQ 0x7F
211
212#define DICTIONARY_VERSION_MIN 200
satoke808e432010-12-02 14:53:24 +0900213#define NOT_VALID_WORD -99
Jean Chalard1059f272011-06-28 20:45:05 +0900214#define NOT_A_CHARACTER -1
Yusuke Nojimae4ba8222011-10-05 14:55:07 +0900215#define NOT_A_DISTANCE -1
Jean Chalard0bfe3592012-01-25 18:11:26 +0900216#define NOT_A_COORDINATE -1
Yusuke Nojimaa4c1f1c2011-10-06 19:12:20 +0900217#define EQUIVALENT_CHAR_WITHOUT_DISTANCE_INFO -2
218#define PROXIMITY_CHAR_WITHOUT_DISTANCE_INFO -3
satoke05b3f42012-01-31 17:15:43 +0900219#define ADDITIONAL_PROXIMITY_CHAR_DISTANCE_INFO -4
Jean Chalardbbc25602012-03-23 17:05:03 +0900220#define NOT_AN_INDEX -1
Jean Chalard171d1802012-04-23 18:51:00 +0900221#define NOT_A_PROBABILITY -1
satoke808e432010-12-02 14:53:24 +0900222
satok817e5172011-03-04 06:06:45 -0800223#define KEYCODE_SPACE ' '
224
Yusuke Nojimaafb90762011-10-05 18:11:42 +0900225#define CALIBRATE_SCORE_BY_TOUCH_COORDINATES true
Yusuke Nojima258bfe62011-09-28 12:59:43 +0900226
satok662fe692010-12-08 17:05:39 +0900227#define SUGGEST_WORDS_WITH_MISSING_CHARACTER true
satok662fe692010-12-08 17:05:39 +0900228#define SUGGEST_WORDS_WITH_EXCESSIVE_CHARACTER true
satoka3d78f62010-12-09 22:08:33 +0900229#define SUGGEST_WORDS_WITH_TRANSPOSED_CHARACTERS true
satok99557162012-01-26 22:49:13 +0900230#define SUGGEST_MULTIPLE_WORDS true
satoka3d78f62010-12-09 22:08:33 +0900231
Jean Chalard8dc754a2011-01-27 14:20:22 +0900232// The following "rate"s are used as a multiplier before dividing by 100, so they are in percent.
satok72bc17e2011-04-13 17:23:27 +0900233#define WORDS_WITH_MISSING_CHARACTER_DEMOTION_RATE 80
satokdc5301e2011-04-11 16:14:45 +0900234#define WORDS_WITH_MISSING_CHARACTER_DEMOTION_START_POS_10X 12
satok54af64a2012-01-17 15:58:23 +0900235#define WORDS_WITH_MISSING_SPACE_CHARACTER_DEMOTION_RATE 58
satok8330b482012-01-23 16:52:37 +0900236#define WORDS_WITH_MISTYPED_SPACE_DEMOTION_RATE 50
satoka3d78f62010-12-09 22:08:33 +0900237#define WORDS_WITH_EXCESSIVE_CHARACTER_DEMOTION_RATE 75
satok54fe9e02010-12-13 14:42:35 +0900238#define WORDS_WITH_EXCESSIVE_CHARACTER_OUT_OF_PROXIMITY_DEMOTION_RATE 75
satoka161a4a2012-01-16 18:38:32 +0900239#define WORDS_WITH_TRANSPOSED_CHARACTERS_DEMOTION_RATE 70
satok58c49b92011-01-27 03:23:39 +0900240#define FULL_MATCHED_WORDS_PROMOTION_RATE 120
satok9d2a3022011-04-14 19:13:34 +0900241#define WORDS_WITH_PROXIMITY_CHARACTER_DEMOTION_RATE 90
satok1b9fa942012-02-02 18:49:22 +0900242#define WORDS_WITH_ADDITIONAL_PROXIMITY_CHARACTER_DEMOTION_RATE 70
satok635f68e2011-08-10 22:19:33 +0900243#define WORDS_WITH_MATCH_SKIP_PROMOTION_RATE 105
satok1b9fa942012-02-02 18:49:22 +0900244#define WORDS_WITH_JUST_ONE_CORRECTION_PROMOTION_RATE 148
245#define WORDS_WITH_JUST_ONE_CORRECTION_PROMOTION_MULTIPLIER 3
satok10266c02011-08-19 22:05:59 +0900246#define CORRECTION_COUNT_RATE_DEMOTION_RATE_BASE 45
247#define INPUT_EXCEEDS_OUTPUT_DEMOTION_RATE 70
248#define FIRST_CHAR_DIFFERENT_DEMOTION_RATE 96
satokeb050fc2011-10-03 19:21:13 +0900249#define TWO_WORDS_CAPITALIZED_DEMOTION_RATE 50
satok54af64a2012-01-17 15:58:23 +0900250#define TWO_WORDS_CORRECTION_DEMOTION_BASE 80
251#define TWO_WORDS_PLUS_OTHER_ERROR_CORRECTION_DEMOTION_DIVIDER 1
Yusuke Nojimaa4c1f1c2011-10-06 19:12:20 +0900252#define ZERO_DISTANCE_PROMOTION_RATE 110
253#define NEUTRAL_SCORE_SQUARED_RADIUS 8.0f
254#define HALF_SCORE_SQUARED_RADIUS 32.0f
satoka85f4922012-01-30 18:18:30 +0900255#define MAX_FREQ 255
Jean Chalard9416c812012-05-15 19:24:47 +0900256#define MAX_BIGRAM_FREQ 15
satoke808e432010-12-02 14:53:24 +0900257
satok1147c7b2011-12-14 15:04:58 +0900258// This must be greater than or equal to MAX_WORD_LENGTH defined in BinaryDictionary.java
satokf5cded12010-12-06 21:28:24 +0900259// This is only used for the size of array. Not to be used in c functions.
260#define MAX_WORD_LENGTH_INTERNAL 48
satok715514d2010-12-02 20:19:59 +0900261
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900262// This must be the same as ProximityInfo#MAX_PROXIMITY_CHARS_SIZE, currently it's 16.
263#define MAX_PROXIMITY_CHARS_SIZE_INTERNAL 16
264
satoke05b3f42012-01-31 17:15:43 +0900265// This must be equal to ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE in KeyDetector.java
266#define ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE 2
267
satoka7e5a5a2011-12-15 16:49:12 +0900268// Word limit for sub queues used in WordsPriorityQueuePool. Sub queues are temporary queues used
269// for better performance.
satok6ad15fc2012-01-16 16:21:21 +0900270// Holds up to 1 candidate for each word
271#define SUB_QUEUE_MAX_WORDS 1
satokb9604772012-01-13 15:41:17 +0900272#define SUB_QUEUE_MAX_COUNT 10
satok54af64a2012-01-17 15:58:23 +0900273#define SUB_QUEUE_MIN_WORD_LENGTH 4
Satoshi Kataoka67e3cc82012-05-31 15:04:58 +0900274// TODO: Extend this limitation
275#define MULTIPLE_WORDS_SUGGESTION_MAX_WORDS 5
Satoshi Kataoka6cbe2042012-05-30 17:28:34 +0900276// TODO: Remove this limitation
277#define MULTIPLE_WORDS_SUGGESTION_MAX_WORD_LENGTH 12
278// TODO: Remove this limitation
Satoshi Kataoka67e3cc82012-05-31 15:04:58 +0900279#define MULTIPLE_WORDS_SUGGESTION_MAX_TOTAL_TRAVERSE_COUNT 45
satoka85f4922012-01-30 18:18:30 +0900280#define MULTIPLE_WORDS_DEMOTION_RATE 80
281#define MIN_INPUT_LENGTH_FOR_THREE_OR_MORE_WORDS_CORRECTION 6
satoka7e5a5a2011-12-15 16:49:12 +0900282
Jean Chalard9416c812012-05-15 19:24:47 +0900283#define TWO_WORDS_CORRECTION_WITH_OTHER_ERROR_THRESHOLD 0.35
284#define START_TWO_WORDS_CORRECTION_THRESHOLD 0.185
satoka0ac31f2012-05-23 19:55:27 +0900285/* heuristic... This should be changed if we change the unit of the frequency. */
286#define SUPPRESS_SHORT_MULTIPLE_WORDS_THRESHOLD_FREQ (MAX_FREQ * 58 / 100)
satok29dc8062012-01-17 15:59:15 +0900287
satok68319262010-12-03 19:38:08 +0900288#define MAX_DEPTH_MULTIPLIER 3
289
satok1f6b52e2012-01-30 13:53:58 +0900290#define FIRST_WORD_INDEX 0
satok8330b482012-01-23 16:52:37 +0900291
Satoshi Kataoka712e02f2012-06-28 15:13:57 +0900292#define MAX_SPACES_INTERNAL 16
293
Jean Chalard6c300612012-03-06 19:54:03 +0900294// TODO: Reduce this constant if possible; check the maximum number of digraphs in the same
295// word in the dictionary for languages with digraphs, like German and French
296#define DEFAULT_MAX_DIGRAPH_SEARCH_DEPTH 5
Jean Chalarda787dba2011-03-04 12:17:48 +0900297
satok54fe9e02010-12-13 14:42:35 +0900298// Minimum suggest depth for one word for all cases except for missing space suggestions.
299#define MIN_SUGGEST_DEPTH 1
satok99557162012-01-26 22:49:13 +0900300#define MIN_USER_TYPED_LENGTH_FOR_MULTIPLE_WORD_SUGGESTION 3
satok54fe9e02010-12-13 14:42:35 +0900301#define MIN_USER_TYPED_LENGTH_FOR_EXCESSIVE_CHARACTER_SUGGESTION 3
satok662fe692010-12-08 17:05:39 +0900302
Jean Chalardf1634c82012-05-02 19:05:27 +0900303// Size, in bytes, of the bloom filter index for bigrams
304// 128 gives us 1024 buckets. The probability of false positive is (1 - e ** (-kn/m))**k,
305// where k is the number of hash functions, n the number of bigrams, and m the number of
306// bits we can test.
307// At the moment 100 is the maximum number of bigrams for a word with the current
308// dictionaries, so n = 100. 1024 buckets give us m = 1024.
309// With 1 hash function, our false positive rate is about 9.3%, which should be enough for
310// our uses since we are only using this to increase average performance. For the record,
311// k = 2 gives 3.1% and k = 3 gives 1.6%. With k = 1, making m = 2048 gives 4.8%,
312// and m = 4096 gives 2.4%.
313#define BIGRAM_FILTER_BYTE_SIZE 128
314// Must be smaller than BIGRAM_FILTER_BYTE_SIZE * 8, and preferably prime. 1021 is the largest
315// prime under 128 * 8.
316#define BIGRAM_FILTER_MODULO 1021
317#if BIGRAM_FILTER_BYTE_SIZE * 8 < BIGRAM_FILTER_MODULO
318#error "BIGRAM_FILTER_MODULO is larger than BIGRAM_FILTER_BYTE_SIZE"
319#endif
320
Tadashi G. Takaoka09baa362012-02-03 21:24:53 +0900321template<typename T> inline T min(T a, T b) { return a < b ? a : b; }
322template<typename T> inline T max(T a, T b) { return a > b ? a : b; }
satokf5cded12010-12-06 21:28:24 +0900323
Yusuke Nojima258bfe62011-09-28 12:59:43 +0900324// The ratio of neutral area radius to sweet spot radius.
325#define NEUTRAL_AREA_RADIUS_RATIO 1.3f
326
satoke05b3f42012-01-31 17:15:43 +0900327// DEBUG
satoka85f4922012-01-30 18:18:30 +0900328#define INPUTLENGTH_FOR_DEBUG -1
satoke05b3f42012-01-31 17:15:43 +0900329#define MIN_OUTPUT_INDEX_FOR_DEBUG -1
330
satok1bc038c2012-06-14 11:25:50 -0700331#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
332 TypeName(const TypeName&); \
333 void operator=(const TypeName&)
334
335#define DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
336 TypeName(); \
337 DISALLOW_COPY_AND_ASSIGN(TypeName)
338
Satoshi Kataoka3e8c58f2012-06-05 17:55:52 +0900339// Used as a return value for character comparison
340typedef enum {
341 // Same char, possibly with different case or accent
342 EQUIVALENT_CHAR,
343 // It is a char located nearby on the keyboard
344 NEAR_PROXIMITY_CHAR,
345 // It is an unrelated char
346 UNRELATED_CHAR,
347 // Additional proximity char which can differ by language.
348 ADDITIONAL_PROXIMITY_CHAR
349} ProximityType;
satoke808e432010-12-02 14:53:24 +0900350#endif // LATINIME_DEFINES_H