chewing 0.12.0

The Chewing (酷音) intelligent Zhuyin input method.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use crate::dictionary::{Dictionary, Phrase};

/// Estimates new user phrase frequency.
///
/// Use UserFreqEstimate to keep track of the time passed and use the original
/// frequency and time to calculate the new frequency of user phrases.
pub trait UserFreqEstimate {
    /// Increments the time passed.
    ///
    /// This should be called for every user interaction.
    fn tick(&mut self);
    /// Returns the current time in ticks.
    fn now(&self) -> u64;
    /// Returns the estimated new user phrase frequency.
    fn estimate(&self, phrase: &Phrase, max_freq: u32) -> u32;
}

/// Loosely tracks time without persisting to disk.
#[derive(Debug)]
pub struct LaxUserFreqEstimate {
    lifetime: u64,
}

impl LaxUserFreqEstimate {
    /// Initialize with the last time value from the user dictionary.
    pub fn max_from(user_dict: &dyn Dictionary) -> LaxUserFreqEstimate {
        let lifetime = user_dict
            .entries()
            .map(|it| it.1.last_used().unwrap_or_default())
            .max()
            .unwrap_or_default();
        LaxUserFreqEstimate { lifetime }
    }

    /// Creates a new LaxUserFreqEstimate from a initial epoch.
    pub fn new(initial_lifetime: u64) -> LaxUserFreqEstimate {
        LaxUserFreqEstimate {
            lifetime: initial_lifetime,
        }
    }
}

const SHORT_INCREASE_FREQ: u32 = 10;
const MEDIUM_INCREASE_FREQ: u32 = 5;
const LONG_INCREASE_FREQ: u32 = 1;
const MAX_USER_FREQ: u32 = 9999999;

impl UserFreqEstimate for LaxUserFreqEstimate {
    fn tick(&mut self) {
        self.lifetime += 1;
    }

    fn now(&self) -> u64 {
        self.lifetime
    }

    fn estimate(&self, phrase: &Phrase, max_freq: u32) -> u32 {
        let last_used = phrase.last_used().unwrap_or(self.lifetime);
        let delta_time = if self.lifetime >= last_used {
            self.lifetime - last_used
        } else {
            u64::MAX
        };

        // # New phrase
        //
        // If the phrase is added to the user dictionary the first time,
        // always bump it to the highest frequency so new phrases are prefered.
        //
        // # Seen phrase
        //
        // If the phrase was seen recently, then bump the frequency faster. Otherwise
        // use smaller increase factor to avoid rarely used phrase suddenly become
        // more preferred.
        if delta_time == 0 {
            (max_freq + SHORT_INCREASE_FREQ).min(MAX_USER_FREQ)
        } else if delta_time < 4000 {
            (phrase.freq() + SHORT_INCREASE_FREQ).min(MAX_USER_FREQ)
        } else if delta_time < 50000 {
            (phrase.freq() + MEDIUM_INCREASE_FREQ).min(MAX_USER_FREQ)
        } else {
            (phrase.freq() + LONG_INCREASE_FREQ).min(MAX_USER_FREQ)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::LaxUserFreqEstimate;
    use crate::{dictionary::TrieBuf, editor::UserFreqEstimate, syl};

    #[test]
    fn load_from_dictionary() {
        let user_dict = TrieBuf::from([
            (
                vec![syl![crate::zhuyin::Bopomofo::A]],
                vec![("A", 1, 1), ("B", 1, 2), ("C", 1, 99), ("D", 1, 3)],
            ),
            (
                vec![syl![crate::zhuyin::Bopomofo::I]],
                vec![("I", 1, 5), ("J", 1, 100), ("K", 1, 4), ("L", 1, 3)],
            ),
        ]);
        let estimate = LaxUserFreqEstimate::max_from(&user_dict);

        assert_eq!(100, estimate.lifetime);
    }

    #[test]
    fn estimate_first_use_phrase() {
        let est = LaxUserFreqEstimate::new(1000);
        let phrase = ("不", 0).into();
        assert_eq!(910, est.estimate(&phrase, 900));
    }

    #[test]
    fn estimate_second_use_phrase() {
        let est = LaxUserFreqEstimate::new(1000);
        let phrase = ("不", 50, 10).into();
        assert_eq!(60, est.estimate(&phrase, 900));
    }

    #[test]
    fn estimate_long_unused_phrase() {
        let est = LaxUserFreqEstimate::new(5000);
        let phrase = ("不", 50, 10).into();
        assert_eq!(55, est.estimate(&phrase, 900));
    }

    #[test]
    fn estimate_long_long_unused_phrase() {
        let est = LaxUserFreqEstimate::new(60000);
        let phrase = ("不", 50, 10).into();
        assert_eq!(51, est.estimate(&phrase, 900));
    }

    #[test]
    fn estimate_out_of_sync_lifetime() {
        let est = LaxUserFreqEstimate::new(100);
        let phrase = ("不", 50, 1000).into();
        assert_eq!(51, est.estimate(&phrase, 900));
    }
}