Home | History | Annotate | Download | only in src 
      1 /*
      2 **
      3 ** Copyright 2010, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** 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 #ifndef LATINIME_DEFINES_H
     19 #define LATINIME_DEFINES_H
     20 
     21 #if defined(FLAG_DO_PROFILE) || defined(FLAG_DBG)
     22 #include <cutils/log.h>
     23 #define AKLOGE ALOGE
     24 #define AKLOGI ALOGI
     25 
     26 #define DUMP_WORD(word, length) do { dumpWord(word, length); } while(0)
     27 #define DUMP_WORD_INT(word, length) do { dumpWordInt(word, length); } while(0)
     28 
     29 static inline void dumpWord(const unsigned short* word, const int length) {
     30     static char charBuf[50];
     31 
     32     for (int i = 0; i < length; ++i) {
     33         charBuf[i] = word[i];
     34     }
     35     charBuf[length] = 0;
     36     AKLOGI("[ %s ]", charBuf);
     37 }
     38 
     39 static inline void dumpWordInt(const int* word, const int length) {
     40     static char charBuf[50];
     41 
     42     for (int i = 0; i < length; ++i) {
     43         charBuf[i] = word[i];
     44     }
     45     charBuf[length] = 0;
     46     AKLOGI("i[ %s ]", charBuf);
     47 }
     48 
     49 #else
     50 #define AKLOGE(fmt, ...)
     51 #define AKLOGI(fmt, ...)
     52 #define DUMP_WORD(word, length)
     53 #define DUMP_WORD_INT(word, length)
     54 #endif
     55 
     56 #ifdef FLAG_DO_PROFILE
     57 // Profiler
     58 #include <time.h>
     59 
     60 #define PROF_BUF_SIZE 100
     61 static float profile_buf[PROF_BUF_SIZE];
     62 static float profile_old[PROF_BUF_SIZE];
     63 static unsigned int profile_counter[PROF_BUF_SIZE];
     64 
     65 #define PROF_RESET               prof_reset()
     66 #define PROF_COUNT(prof_buf_id)  ++profile_counter[prof_buf_id]
     67 #define PROF_OPEN                do { PROF_RESET; PROF_START(PROF_BUF_SIZE - 1); } while(0)
     68 #define PROF_START(prof_buf_id)  do { \
     69         PROF_COUNT(prof_buf_id); profile_old[prof_buf_id] = (clock()); } while(0)
     70 #define PROF_CLOSE               do { PROF_END(PROF_BUF_SIZE - 1); PROF_OUTALL; } while(0)
     71 #define PROF_END(prof_buf_id)    profile_buf[prof_buf_id] += ((clock()) - profile_old[prof_buf_id])
     72 #define PROF_CLOCKOUT(prof_buf_id) \
     73         AKLOGI("%s : clock is %f", __FUNCTION__, (clock() - profile_old[prof_buf_id]))
     74 #define PROF_OUTALL              do { AKLOGI("--- %s ---", __FUNCTION__); prof_out(); } while(0)
     75 
     76 static inline void prof_reset(void) {
     77     for (int i = 0; i < PROF_BUF_SIZE; ++i) {
     78         profile_buf[i] = 0;
     79         profile_old[i] = 0;
     80         profile_counter[i] = 0;
     81     }
     82 }
     83 
     84 static inline void prof_out(void) {
     85     if (profile_counter[PROF_BUF_SIZE - 1] != 1) {
     86         AKLOGI("Error: You must call PROF_OPEN before PROF_CLOSE.");
     87     }
     88     AKLOGI("Total time is %6.3f ms.",
     89             profile_buf[PROF_BUF_SIZE - 1] * 1000 / (float)CLOCKS_PER_SEC);
     90     float all = 0;
     91     for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
     92         all += profile_buf[i];
     93     }
     94     if (all == 0) all = 1;
     95     for (int i = 0; i < PROF_BUF_SIZE - 1; ++i) {
     96         if (profile_buf[i] != 0) {
     97             AKLOGI("(%d): Used %4.2f%%, %8.4f ms. Called %d times.",
     98                     i, (profile_buf[i] * 100 / all),
     99                     profile_buf[i] * 1000 / (float)CLOCKS_PER_SEC, profile_counter[i]);
    100         }
    101     }
    102 }
    103 
    104 #else // FLAG_DO_PROFILE
    105 #define PROF_BUF_SIZE 0
    106 #define PROF_RESET
    107 #define PROF_COUNT(prof_buf_id)
    108 #define PROF_OPEN
    109 #define PROF_START(prof_buf_id)
    110 #define PROF_CLOSE
    111 #define PROF_END(prof_buf_id)
    112 #define PROF_CLOCK_OUT(prof_buf_id)
    113 #define PROF_CLOCKOUT(prof_buf_id)
    114 #define PROF_OUTALL
    115 
    116 #endif // FLAG_DO_PROFILE
    117 
    118 #ifdef FLAG_DBG
    119 #include <cutils/log.h>
    120 #ifndef LOG_TAG
    121 #define LOG_TAG "LatinIME: "
    122 #endif
    123 #define DEBUG_DICT true
    124 #define DEBUG_DICT_FULL false
    125 #define DEBUG_EDIT_DISTANCE false
    126 #define DEBUG_SHOW_FOUND_WORD false
    127 #define DEBUG_NODE DEBUG_DICT_FULL
    128 #define DEBUG_TRACE DEBUG_DICT_FULL
    129 #define DEBUG_PROXIMITY_INFO false
    130 #define DEBUG_PROXIMITY_CHARS false
    131 #define DEBUG_CORRECTION false
    132 #define DEBUG_CORRECTION_FREQ false
    133 #define DEBUG_WORDS_PRIORITY_QUEUE false
    134 
    135 #else // FLAG_DBG
    136 
    137 #define DEBUG_DICT false
    138 #define DEBUG_DICT_FULL false
    139 #define DEBUG_EDIT_DISTANCE false
    140 #define DEBUG_SHOW_FOUND_WORD false
    141 #define DEBUG_NODE false
    142 #define DEBUG_TRACE false
    143 #define DEBUG_PROXIMITY_INFO false
    144 #define DEBUG_PROXIMITY_CHARS false
    145 #define DEBUG_CORRECTION false
    146 #define DEBUG_CORRECTION_FREQ false
    147 #define DEBUG_WORDS_PRIORITY_QUEUE false
    148 
    149 
    150 #endif // FLAG_DBG
    151 
    152 #ifndef U_SHORT_MAX
    153 #define U_SHORT_MAX 65535    // ((1 << 16) - 1)
    154 #endif
    155 #ifndef S_INT_MAX
    156 #define S_INT_MAX 2147483647 // ((1 << 31) - 1)
    157 #endif
    158 
    159 // Define this to use mmap() for dictionary loading.  Undefine to use malloc() instead of mmap().
    160 // We measured and compared performance of both, and found mmap() is fairly good in terms of
    161 // loading time, and acceptable even for several initial lookups which involve page faults.
    162 #define USE_MMAP_FOR_DICTIONARY
    163 
    164 // 22-bit address = ~4MB dictionary size limit, which on average would be about 200k-300k words
    165 #define ADDRESS_MASK 0x3FFFFF
    166 
    167 // The bit that decides if an address follows in the next 22 bits
    168 #define FLAG_ADDRESS_MASK 0x40
    169 // The bit that decides if this is a terminal node for a word. The node could still have children,
    170 // if the word has other endings.
    171 #define FLAG_TERMINAL_MASK 0x80
    172 
    173 #define FLAG_BIGRAM_READ 0x80
    174 #define FLAG_BIGRAM_CHILDEXIST 0x40
    175 #define FLAG_BIGRAM_CONTINUED 0x80
    176 #define FLAG_BIGRAM_FREQ 0x7F
    177 
    178 #define DICTIONARY_VERSION_MIN 200
    179 #define NOT_VALID_WORD -99
    180 #define NOT_A_CHARACTER -1
    181 #define NOT_A_DISTANCE -1
    182 #define NOT_A_COORDINATE -1
    183 #define EQUIVALENT_CHAR_WITHOUT_DISTANCE_INFO -2
    184 #define PROXIMITY_CHAR_WITHOUT_DISTANCE_INFO -3
    185 #define ADDITIONAL_PROXIMITY_CHAR_DISTANCE_INFO -4
    186 #define NOT_AN_INDEX -1
    187 #define NOT_A_PROBABILITY -1
    188 
    189 #define KEYCODE_SPACE ' '
    190 
    191 #define CALIBRATE_SCORE_BY_TOUCH_COORDINATES true
    192 
    193 #define SUGGEST_WORDS_WITH_MISSING_CHARACTER true
    194 #define SUGGEST_WORDS_WITH_EXCESSIVE_CHARACTER true
    195 #define SUGGEST_WORDS_WITH_TRANSPOSED_CHARACTERS true
    196 #define SUGGEST_MULTIPLE_WORDS true
    197 
    198 // The following "rate"s are used as a multiplier before dividing by 100, so they are in percent.
    199 #define WORDS_WITH_MISSING_CHARACTER_DEMOTION_RATE 80
    200 #define WORDS_WITH_MISSING_CHARACTER_DEMOTION_START_POS_10X 12
    201 #define WORDS_WITH_MISSING_SPACE_CHARACTER_DEMOTION_RATE 58
    202 #define WORDS_WITH_MISTYPED_SPACE_DEMOTION_RATE 50
    203 #define WORDS_WITH_EXCESSIVE_CHARACTER_DEMOTION_RATE 75
    204 #define WORDS_WITH_EXCESSIVE_CHARACTER_OUT_OF_PROXIMITY_DEMOTION_RATE 75
    205 #define WORDS_WITH_TRANSPOSED_CHARACTERS_DEMOTION_RATE 70
    206 #define FULL_MATCHED_WORDS_PROMOTION_RATE 120
    207 #define WORDS_WITH_PROXIMITY_CHARACTER_DEMOTION_RATE 90
    208 #define WORDS_WITH_ADDITIONAL_PROXIMITY_CHARACTER_DEMOTION_RATE 70
    209 #define WORDS_WITH_MATCH_SKIP_PROMOTION_RATE 105
    210 #define WORDS_WITH_JUST_ONE_CORRECTION_PROMOTION_RATE 148
    211 #define WORDS_WITH_JUST_ONE_CORRECTION_PROMOTION_MULTIPLIER 3
    212 #define CORRECTION_COUNT_RATE_DEMOTION_RATE_BASE 45
    213 #define INPUT_EXCEEDS_OUTPUT_DEMOTION_RATE 70
    214 #define FIRST_CHAR_DIFFERENT_DEMOTION_RATE 96
    215 #define TWO_WORDS_CAPITALIZED_DEMOTION_RATE 50
    216 #define TWO_WORDS_CORRECTION_DEMOTION_BASE 80
    217 #define TWO_WORDS_PLUS_OTHER_ERROR_CORRECTION_DEMOTION_DIVIDER 1
    218 #define ZERO_DISTANCE_PROMOTION_RATE 110
    219 #define NEUTRAL_SCORE_SQUARED_RADIUS 8.0f
    220 #define HALF_SCORE_SQUARED_RADIUS 32.0f
    221 #define MAX_FREQ 255
    222 #define MAX_BIGRAM_FREQ 15
    223 
    224 // This must be greater than or equal to MAX_WORD_LENGTH defined in BinaryDictionary.java
    225 // This is only used for the size of array. Not to be used in c functions.
    226 #define MAX_WORD_LENGTH_INTERNAL 48
    227 
    228 // This must be equal to ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE in KeyDetector.java
    229 #define ADDITIONAL_PROXIMITY_CHAR_DELIMITER_CODE 2
    230 
    231 // Word limit for sub queues used in WordsPriorityQueuePool.  Sub queues are temporary queues used
    232 // for better performance.
    233 // Holds up to 1 candidate for each word
    234 #define SUB_QUEUE_MAX_WORDS 1
    235 #define SUB_QUEUE_MAX_COUNT 10
    236 #define SUB_QUEUE_MIN_WORD_LENGTH 4
    237 // TODO: Extend this limitation
    238 #define MULTIPLE_WORDS_SUGGESTION_MAX_WORDS 5
    239 // TODO: Remove this limitation
    240 #define MULTIPLE_WORDS_SUGGESTION_MAX_WORD_LENGTH 12
    241 // TODO: Remove this limitation
    242 #define MULTIPLE_WORDS_SUGGESTION_MAX_TOTAL_TRAVERSE_COUNT 45
    243 #define MULTIPLE_WORDS_DEMOTION_RATE 80
    244 #define MIN_INPUT_LENGTH_FOR_THREE_OR_MORE_WORDS_CORRECTION 6
    245 
    246 #define TWO_WORDS_CORRECTION_WITH_OTHER_ERROR_THRESHOLD 0.35
    247 #define START_TWO_WORDS_CORRECTION_THRESHOLD 0.185
    248 /* heuristic... This should be changed if we change the unit of the frequency. */
    249 #define SUPPRESS_SHORT_MULTIPLE_WORDS_THRESHOLD_FREQ (MAX_FREQ * 58 / 100)
    250 
    251 #define MAX_DEPTH_MULTIPLIER 3
    252 
    253 #define FIRST_WORD_INDEX 0
    254 
    255 // TODO: Reduce this constant if possible; check the maximum number of digraphs in the same
    256 // word in the dictionary for languages with digraphs, like German and French
    257 #define DEFAULT_MAX_DIGRAPH_SEARCH_DEPTH 5
    258 
    259 // Minimum suggest depth for one word for all cases except for missing space suggestions.
    260 #define MIN_SUGGEST_DEPTH 1
    261 #define MIN_USER_TYPED_LENGTH_FOR_MULTIPLE_WORD_SUGGESTION 3
    262 #define MIN_USER_TYPED_LENGTH_FOR_EXCESSIVE_CHARACTER_SUGGESTION 3
    263 
    264 // Size, in bytes, of the bloom filter index for bigrams
    265 // 128 gives us 1024 buckets. The probability of false positive is (1 - e ** (-kn/m))**k,
    266 // where k is the number of hash functions, n the number of bigrams, and m the number of
    267 // bits we can test.
    268 // At the moment 100 is the maximum number of bigrams for a word with the current
    269 // dictionaries, so n = 100. 1024 buckets give us m = 1024.
    270 // With 1 hash function, our false positive rate is about 9.3%, which should be enough for
    271 // our uses since we are only using this to increase average performance. For the record,
    272 // k = 2 gives 3.1% and k = 3 gives 1.6%. With k = 1, making m = 2048 gives 4.8%,
    273 // and m = 4096 gives 2.4%.
    274 #define BIGRAM_FILTER_BYTE_SIZE 128
    275 // Must be smaller than BIGRAM_FILTER_BYTE_SIZE * 8, and preferably prime. 1021 is the largest
    276 // prime under 128 * 8.
    277 #define BIGRAM_FILTER_MODULO 1021
    278 #if BIGRAM_FILTER_BYTE_SIZE * 8 < BIGRAM_FILTER_MODULO
    279 #error "BIGRAM_FILTER_MODULO is larger than BIGRAM_FILTER_BYTE_SIZE"
    280 #endif
    281 
    282 template<typename T> inline T min(T a, T b) { return a < b ? a : b; }
    283 template<typename T> inline T max(T a, T b) { return a > b ? a : b; }
    284 
    285 // The ratio of neutral area radius to sweet spot radius.
    286 #define NEUTRAL_AREA_RADIUS_RATIO 1.3f
    287 
    288 // DEBUG
    289 #define INPUTLENGTH_FOR_DEBUG -1
    290 #define MIN_OUTPUT_INDEX_FOR_DEBUG -1
    291 
    292 #endif // LATINIME_DEFINES_H
    293