Grammalecte  Check-in [ae2968927f]

Overview
Comment:[core][js] ibdawg: suggestion mechanism for the spellchecker
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | core
Files: files | file ages | folders
SHA3-256: ae2968927f9b084650478305dfe10dc4665381b122972fa82657033f978acba5
User & Date: olr on 2017-09-14 06:42:03
Other Links: manifest | tags
Context
2017-09-15
08:16
[core][fx] ibdawg: fix bugs, WebExt: retrieve spelling suggestion check-in: d7eb5a15ee user: olr tags: trunk, core, fx
2017-09-14
06:42
[core][js] ibdawg: suggestion mechanism for the spellchecker check-in: ae2968927f user: olr tags: trunk, core
2017-09-13
14:56
[core] ibdawg: suggestions according to input capitalisation + maximum number of suggestions check-in: e06584ba4a user: olr tags: trunk, core
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Added gc_core/js/char_player.js version [1e04a37ec5]. 




































































































































































































































































































































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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

// list of similar chars
// useful for suggestion mechanism

${map}


function distanceDamerauLevenshtein (s1, s2) {
    // distance of Damerau-Levenshtein between <s1> and <s2>
    // https://fr.wikipedia.org/wiki/Distance_de_Damerau-Levenshtein
    let d = new Map();
    let nLen1 = s1.length;
    let nLen2 = s2.length;
    for (let i = -1;  i <= nLen1;  i++) {
        d.set([i, -1], i + 1);
    }
    for (let j = -1;  i <= nLen2;  i++) {
        d.set([-1, j], j + 1);
    }
    for (let i = 0;  i < nLen1;  i++) {
        for (let j =0;  j < nLen2;  i++) {
            let nCost = (s1[i] === s2[j]) ? 0 : 1;
            d.set([i, j], Math.min(
                d.get([i-1, j]) + 1,        // Deletion
                d.get([i,   j-1]) + 1,      // Insertion
                d.get([i-1, j-1]) + nCost,  // Substitution
            ));
            if (i && j && s1[i] == s2[j-1] && s1[i-1] == s2[j]) {
                d.set([i, j], Math.min(d.get([i, j]), d.get([i-2, j-2]) + nCost));  // Transposition
            }
        }
    }
    return d.get([nLen1-1, nLen2-1]);
}


// Method: Remove Useless Chars

const aVovels = new Set([
    'a', 'e', 'i', 'o', 'u', 'y',
    'à', 'é', 'î', 'ô', 'û', 'ÿ',
    'â', 'è', 'ï', 'ö', 'ù', 'ŷ',
    'ä', 'ê', 'í', 'ó', 'ü', 'ý',
    'á', 'ë', 'ì', 'ò', 'ú', 'ỳ',
    'ā', 'ē', 'ī', 'ō', 'ū', 'ȳ',
    'h', 'œ', 'æ'
]);


function clearWord (sWord) {
    // remove vovels and h
    let sRes = "";
    for (let cChar of sWord.slice(1)) {
        if (!aVovels.has(cChar)) {
            sRes += cChar;
        }
    }
    return sWord.slice(0, 1).replace("h", "") + sRes;
}


// Similar chars

const d1to1 = new Map([
    ["1", "liîLIÎ"],
    ["2", "zZ"],
    ["3", "eéèêEÉÈÊ"],
    ["4", "aàâAÀÂ"],
    ["5", "sgSG"],
    ["6", "bdgBDG"],
    ["7", "ltLT"],
    ["8", "bB"],
    ["9", "gbdGBD"],
    ["0", "oôOÔ"],

    ["a", "aàâáäæ"],
    ["A", "AÀÂÁÄÆ"],
    ["à", "aàâáäæ"],
    ["À", "AÀÂÁÄÆ"],
    ["â", "aàâáäæ"],
    ["Â", "AÀÂÁÄÆ"],
    ["á", "aàâáäæ"],
    ["Á", "AÀÂÁÄÆ"],
    ["ä", "aàâáäæ"],
    ["Ä", "AÀÂÁÄÆ"],

    ["æ", "æéa"],
    ["Æ", "ÆÉA"],

    ["c", "cçskqśŝ"],
    ["C", "CÇSKQŚŜ"],
    ["ç", "cçskqśŝ"],
    ["Ç", "CÇSKQŚŜ"],

    ["e", "eéèêëœ"],
    ["E", "EÉÈÊËŒ"],
    ["é", "eéèêëœ"],
    ["É", "EÉÈÊËŒ"],
    ["ê", "eéèêëœ"],
    ["Ê", "EÉÈÊËŒ"],
    ["è", "eéèêëœ"],
    ["È", "EÉÈÊËŒ"],
    ["ë", "eéèêëœ"],
    ["Ë", "EÉÈÊËŒ"],

    ["g", "gj"],
    ["G", "GJ"],
    
    ["i", "iîïyíìÿ"],
    ["I", "IÎÏYÍÌŸ"],
    ["î", "iîïyíìÿ"],
    ["Î", "IÎÏYÍÌŸ"],
    ["ï", "iîïyíìÿ"],
    ["Ï", "IÎÏYÍÌŸ"],
    ["í", "iîïyíìÿ"],
    ["Í", "IÎÏYÍÌŸ"],
    ["ì", "iîïyíìÿ"],
    ["Ì", "IÎÏYÍÌŸ"],

    ["j", "jg"],
    ["J", "JG"],

    ["k", "kcq"],
    ["K", "KCQ"],

    ["n", "nñ"],
    ["N", "NÑ"],

    ["o", "oôóòöœ"],
    ["O", "OÔÓÒÖŒ"],
    ["ô", "oôóòöœ"],
    ["Ô", "OÔÓÒÖŒ"],
    ["ó", "oôóòöœ"],
    ["Ó", "OÔÓÒÖŒ"],
    ["ò", "oôóòöœ"],
    ["Ò", "OÔÓÒÖŒ"],
    ["ö", "oôóòöœ"],
    ["Ö", "OÔÓÒÖŒ"],

    ["œ", "œoôeéèêë"],
    ["Œ", "ŒOÔEÉÈÊË"],

    ["q", "qck"],
    ["Q", "QCK"],

    ["s", "sśŝcç"],
    ["S", "SŚŜCÇ"],
    ["ś", "sśŝcç"],
    ["Ś", "SŚŜCÇ"],
    ["ŝ", "sśŝcç"],
    ["Ŝ", "SŚŜCÇ"],

    ["u", "uûùüú"],
    ["U", "UÛÙÜÚ"],
    ["û", "uûùüú"],
    ["Û", "UÛÙÜÚ"],
    ["ù", "uûùüú"],
    ["Ù", "UÛÙÜÚ"],
    ["ü", "uûùüú"],
    ["Ü", "UÛÙÜÚ"],
    ["ú", "uûùüú"],
    ["Ú", "UÛÙÜÚ"],

    ["v", "vw"],
    ["V", "VW"],

    ["w", "wv"],
    ["W", "WV"],

    ["x", "xck"],
    ["X", "XCK"],

    ["y", "yÿiîŷýỳ"],
    ["Y", "YŸIÎŶÝỲ"],
    ["ÿ", "yÿiîŷýỳ"],
    ["Ÿ", "YŸIÎŶÝỲ"],
    ["ŷ", "yÿiîŷýỳ"],
    ["Ŷ", "YŸIÎŶÝỲ"],
    ["ý", "yÿiîŷýỳ"],
    ["Ý", "YŸIÎŶÝỲ"],
    ["ỳ", "yÿiîŷýỳ"],
    ["Ỳ", "YŸIÎŶÝỲ"],

    ["z", "zs"],
    ["Z", "ZS"],
]);

const d1toX = new Map([
    ["æ", ["ae",]],
    ["Æ", ["AE",]],
    ["b", ["bb",]],
    ["B", ["BB",]],
    ["c", ["cc", "ss", "qu", "ch"]],
    ["C", ["CC", "SS", "QU", "CH"]],
    ["ç", ["ss", "cc", "qh", "ch"]],
    ["Ç", ["SS", "CC", "QH", "CH"]],
    ["d", ["dd",]],
    ["D", ["DD",]],
    ["f", ["ff", "ph"]],
    ["F", ["FF", "PH"]],
    ["g", ["gu", "ge", "gg", "gh"]],
    ["G", ["GU", "GE", "GG", "GH"]],
    ["i", ["ii",]],
    ["I", ["II",]],
    ["j", ["jj", "dj"]],
    ["J", ["JJ", "DJ"]],
    ["k", ["qu", "ck", "ch", "cu", "kk", "kh"]],
    ["K", ["QU", "CK", "CH", "CU", "KK", "KH"]],
    ["l", ["ll",]],
    ["L", ["LL",]],
    ["m", ["mm", "mn"]],
    ["M", ["MM", "MN"]],
    ["n", ["nn", "nm", "mn"]],
    ["N", ["NN", "NM", "MN"]],
    ["o", ["au", "eau", "aut"]],
    ["O", ["AU", "EAU", "AUT"]],
    ["œ", ["oe", "eu"]],
    ["Œ", ["OE", "EU"]],
    ["p", ["pp", "ph"]],
    ["P", ["PP", "PH"]],
    ["q", ["qu", "ch", "cq", "ck", "kk"]],
    ["Q", ["QU", "CH", "CQ", "CK", "KK"]],
    ["r", ["rr",]],
    ["R", ["RR",]],
    ["s", ["ss", "sh"]],
    ["S", ["SS", "SH"]],
    ["t", ["tt", "th"]],
    ["T", ["TT", "TH"]],
    ["x", ["cc", "ct", "xx"]],
    ["X", ["CC", "CT", "XX"]],
    ["z", ["ss", "zh"]],
    ["Z", ["SS", "ZH"]],
]);

const d2toX = new Map([
    ["an", ["en",]],
    ["AN", ["EN",]],
    ["en", ["an",]],
    ["EN", ["AN",]],
    ["ai", ["ei", "é", "è", "ê", "ë"]],
    ["AI", ["EI", "É", "È", "Ê", "Ë"]],
    ["ei", ["ai", "é", "è", "ê", "ë"]],
    ["EI", ["AI", "É", "È", "Ê", "Ë"]],
    ["ch", ["sh", "c", "ss"]],
    ["CH", ["SH", "C", "SS"]],
    ["ct", ["x", "cc"]],
    ["CT", ["X", "CC"]],
    ["oa", ["oi",]],
    ["OA", ["OI",]],
    ["oi", ["oa", "oie"]],
    ["OI", ["OA", "OIE"]],
    ["qu", ["q", "cq", "ck", "c", "k"]],
    ["QU", ["Q", "CQ", "CK", "C", "K"]],
    ["ss", ["c", "ç"]],
    ["SS", ["C", "Ç"]],
]);


// End of word

const dFinal1 = new Map([
    ["a", ["as", "at", "ant", "ah"]],
    ["A", ["AS", "AT", "ANT", "AH"]],
    ["c", ["ch",]],
    ["C", ["CH",]],
    ["e", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait", "ent", "eh"]],
    ["E", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT", "ENT", "EH"]],
    ["é", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["É", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["è", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["È", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["ê", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["Ê", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["ë", ["et", "er", "ets", "ée", "ez", "ai", "ais", "ait"]],
    ["Ë", ["ET", "ER", "ETS", "ÉE", "EZ", "AI", "AIS", "AIT"]],
    ["g", ["gh",]],
    ["G", ["GH",]],
    ["i", ["is", "it", "ie", "in"]],
    ["I", ["IS", "IT", "IE", "IN"]],
    ["n", ["nt", "nd", "ns", "nh"]],
    ["N", ["NT", "ND", "NS", "NH"]],
    ["o", ["aut", "ot", "os"]],
    ["O", ["AUT", "OT", "OS"]],
    ["ô", ["aut", "ot", "os"]],
    ["Ô", ["AUT", "OT", "OS"]],
    ["ö", ["aut", "ot", "os"]],
    ["Ö", ["AUT", "OT", "OS"]],
    ["p", ["ph",]],
    ["P", ["PH",]],
    ["s", ["sh",]],
    ["S", ["SH",]],
    ["t", ["th",]],
    ["T", ["TH",]],
    ["u", ["ut", "us", "uh"]],
    ["U", ["UT", "US", "UH"]],
]);

const dFinal2 = new Map([
    ["ai", ["aient", "ais", "et"]],
    ["AI", ["AIENT", "AIS", "ET"]],
    ["an", ["ant", "ent"]],
    ["AN", ["ANT", "ENT"]],
    ["en", ["ent", "ant"]],
    ["EN", ["ENT", "ANT"]],
    ["ei", ["ait", "ais"]],
    ["EI", ["AIT", "AIS"]],
    ["on", ["ons", "ont"]],
    ["ON", ["ONS", "ONT"]],
    ["oi", ["ois", "oit", "oix"]],
    ["OI", ["OIS", "OIT", "OIX"]],
]);


// Préfixes

aPfx1 = new Set([
    "anti", "archi", "contre", "hyper", "mé", "méta", "im", "in", "ir", "par", "proto",
    "pseudo", "pré", "re", "ré", "sans", "sous", "supra", "sur", "ultra"
]);

aPfx2 = new Set([
    "belgo", "franco", "génito", "gynéco", "médico", "russo"
]);








Modified gc_core/js/ibdawg.js
from [4cc6e3ad82]
to [1659cd7549].



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

16
17


18
19
20
21
22
23
24

1
2
3
4
5
6
7
8
9
10
11
12
13


14
15

16
17
18
19
20
21
22
23
24














-
-
+

-
+
+








//// IBDAWG
/*jslint esversion: 6*/
/*global console,require,exports*/

"use strict";


if (typeof(require) !== 'undefined') {
    var str_transform = require("resource://grammalecte/str_transform.js");
    var helpers = require("resource://grammalecte/helpers.js");
}


// String
// Don’t remove. Necessary in TB.
// Don’t remove <string>. Necessary in TB.
${string}

${map}
${set}


class IBDAWG {
    // INDEXABLE BINARY DIRECT ACYCLIC WORD GRAPH

    constructor (sDicName, sPath="") {
        try {




︙


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

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








+






+






+









        // Configuring DAWG functions according to nVersion
        switch (this.nVersion) {
            case 1:
                this.morph = this._morph1;
                this.stem = this._stem1;
                this._lookupArcNode = this._lookupArcNode1;
                this._getArcs = this._getArcs1;
                this._writeNodes = this._writeNodes1;
                break;
            case 2:
                this.morph = this._morph2;
                this.stem = this._stem2;
                this._lookupArcNode = this._lookupArcNode2;
                this._getArcs = this._getArcs2;
                this._writeNodes = this._writeNodes2;
                break;
            case 3:
                this.morph = this._morph3;
                this.stem = this._stem3;
                this._lookupArcNode = this._lookupArcNode3;
                this._getArcs = this._getArcs3;
                this._writeNodes = this._writeNodes3;
                break;
            default:
                throw ValueError("# Error: unknown code: " + this.nVersion);
        }
        //console.log(this.getInfo());
        this.bOptNumSigle = true;




︙


164
165
166
167
168
169
170































































































































171
172
173
174
175
176
177

167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307








+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+








            l = l.concat(this.morph(sWord.toLowerCase()));
            if (sWord.gl_isUpperCase() && sWord.length > 1) {
                l = l.concat(this.morph(sWord.gl_toCapitalize()));
            }
        }
        return l;
    }

    suggest (sWord, nMaxSugg=10) {
        // returns a set of suggestions for <sWord>
        let aSugg = this._suggest(sWord, nMaxDel=Math.floor(sWord.length / 5));
        if (sWord.gl_isTitle()) {
            aSugg.gl_update(this._suggest(sWord.lower(), nMaxDel=Math.floor(sWord.length / 5)));
            aSugg = new Set(aSugg.map((sSugg) => { return sSugg.title(); }));
        }
        else if (sWord.gl_isLowerCase()) {
            aSugg.gl_update(this._suggest(sWord.title(), nMaxDel=Math.floor(sWord.length / 5)));
        }
        if (aSugg.size == 0) {
            aSugg.gl_update(this._suggestWithCrushedUselessChars(cp.clearWord(sWord)));
        }
        aSugg = aSugg.filter((sSugg) => { return !sSugg.endsWith("è") && !sSugg.endsWith("È"); }); // fr language 
        return aSugg.sort((sSugg) => { return cp.distanceDamerauLevenshtein(sWord, sSugg); }).slice(0, nMaxSugg);
    }

    _suggest (sRemain, nMaxDel=0, nDeep=0, iAddr=0, sNewWord="", bAvoidLoop=False) {
        // returns a set of suggestions
        // recursive function
        //show(nDeep, sNewWord + ":" + sRemain)
        let aSugg = new Set();
        if (sRemain == "") {
            if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
                //show(nDeep, "___" + sNewWord + "___");
                aSugg.add(sNewWord);
            }
            for (let sTail of this._getTails(iAddr)) {
                aSugg.add(sNewWord+sTail);
            }
            return aSugg;
        }
        let cCurrent = sRemain.slice(0, 1);
        for (let [cChar, jAddr] of this._getSimilarArcs(cCurrent, iAddr)) {
            aSugg.gl_update(this._suggest(sRemain.slice(1), nMaxDel, nDeep+1, jAddr, sNewWord+cChar));
        }
        if (!bAvoidLoop) { // avoid infinite loop
            if (cCurrent == sRemain.slice(1, 2)) {
                // same char, we remove 1 char without adding 1 to <sNewWord>
                aSugg.gl_update(this._suggest(sRemain.slice(1), nMaxDel, nDeep+1, iAddr, sNewWord));
            }
            else {
                // switching chars
                aSugg.gl_update(this._suggest(sRemain.slice(1, 2)+sRemain.slice(0, 1)+sRemain.slice(2), nMaxDel, nDeep+1, iAddr, sNewWord, true));
                // delete char
                if (nMaxDel > 0) {
                    aSugg.gl_update(this._suggest(sRemain.slice(1), nMaxDel-1, nDeep+1, iAddr, sNewWord, true));
                }
            }
            // Replacements
            for (let sRepl of cp.d1toX.gl_get(cCurrent, [])) {
                aSugg.gl_update(this._suggest(sRepl + sRemain.slice(1), nMaxDel, nDeep+1, iAddr, sNewWord, true));
            }
            for (let sRepl of cp.d2toX.gl_get(sRemain[0:2], [])) {
                aSugg.gl_update(this._suggest(sRepl + sRemain.slice(2), nMaxDel, nDeep+1, iAddr, sNewWord, true));
            }
            // end of word
            if (sRemain.length == 2) {
                for (let sRepl of cp.dFinal2.gl_get(sRemain, [])) {
                    aSugg.gl_update(this._suggest(sRepl, nMaxDel, nDeep+1, iAddr, sNewWord, true));
                }
            }
            else if (sRemain.length == 1) {
                aSugg.gl_update(this._suggest("", nMaxDel, nDeep+1, iAddr, sNewWord, true)); // remove last char and go on
                for (let sRepl of cp.dFinal1.gl_get(sRemain, [])) {
                    aSugg.gl_update(this._suggest(sRepl, nMaxDel, nDeep+1, iAddr, sNewWord, true));
                }
            }
        }
        return aSugg;
    }

    * _getSimilarArcs (cChar, iAddr) {
        // generator: yield similar char of <cChar> and address of the following node
        for (let c of cp.d1to1.gl_get(cChar, [cChar])) {
            if (this.dChar.has(c)) {
                let jAddr = this._lookupArcNode(this.dChar.get(c), iAddr);
                if (jAddr) {
                    yield [c, jAddr];
                }
            }
        }
    }

    _getTails (iAddr, sTail="", n=2) {
        // return a list of suffixes ending at a distance of <n> from <iAddr>
        let aTails = new Set();
        for (let [nVal, jAddr] of this._getArcs(iAddr)) {
            if (nVal < this.nChar) {
                if (this._convBytesToInteger(this.byDic.slice(jAddr, jAddr+this.nBytesArc)) & this._finalNodeMask) {
                    aTails.add(sTail + this.dCharVal.get(nVal));
                }
                if (n && aTails.size == 0) {
                    aTails.update(this._getTails(jAddr, sTail+this.dCharVal.get(nVal), n-1));
                }
            }
        }
        return aTails;
    }

    _suggestWithCrushedUselessChars (sWord, nDeep=0, iAddr=0, sNewWord="", bAvoidLoop=False) {
        let aSugg = new Set();
        if (sWord.length == 0) {
            if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
                show(nDeep, "!!! " + sNewWord + " !!!");
                aSugg.add(sNewWord);
            }
            return aSugg;
        }
        let cCurrent = sWord.slice(0, 1);
        for (let [cChar, jAddr] of this._getSimilarArcsAndCrushedChars(cCurrent, iAddr)) {
            show(nDeep, cChar);
            aSugg.gl_update(this._suggestWithCrushedUselessChars(sWord[1:], nDeep+1, jAddr, sNewWord+cChar));
        }
        return aSugg;
    }

    * _getSimilarArcsAndCrushedChars (cChar, iAddr) {
        // generator: yield similar char of <cChar> and address of the following node
        for (let [nVal, jAddr] of this._getArcs(iAddr)) {
            if (this.dCharVal.get(nVal, null) in cp.aVovels) {
                yield [this.dCharVal[nVal], jAddr];
            }
        }
        yield* this._getSimilarArcs(cChar, iAddr);
    }

    // morph (sWord) {
    //     is defined in constructor
    // }
    
    // VERSION 1
    _morph1 (sWord) {




︙


186
187
188
189
190
191
192
193

194
195

196
197
198

199
200
201


202
203

204
205
206
207
208
209
210

316
317
318
319
320
321
322

323
324

325
326
327

328
329


330
331
332

333
334
335
336
337
338
339
340








-
+

-
+


-
+

-
-
+
+

-
+








                return [];
            }
        }
        if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
            let l = [];
            let nRawArc = 0;
            while (!(nRawArc & this._lastArcMask)) {
                var iEndArcAddr = iAddr + this.nBytesArc;
                let iEndArcAddr = iAddr + this.nBytesArc;
                nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr));
                var nArc = nRawArc & this._arcMask;
                let nArc = nRawArc & this._arcMask;
                if (nArc >= this.nChar) {
                    // This value is not a char, this is a stemming code 
                    var sStem = ">" + this.funcStemming(sWord, this.lArcVal[nArc]);
                    let sStem = ">" + this.funcStemming(sWord, this.lArcVal[nArc]);
                    // Now , we go to the next node and retrieve all following arcs values, all of them are tags
                    var iAddr2 = this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress));
                    var nRawArc2 = 0;
                    let iAddr2 = this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress));
                    let nRawArc2 = 0;
                    while (!(nRawArc2 & this._lastArcMask)) {
                        var iEndArcAddr2 = iAddr2 + this.nBytesArc;
                        let iEndArcAddr2 = iAddr2 + this.nBytesArc;
                        nRawArc2 = this._convBytesToInteger(this.byDic.slice(iAddr2, iEndArcAddr2));
                        l.push(sStem + " " + this.lArcVal[nRawArc2 & this._arcMask]);
                        iAddr2 = iEndArcAddr2+this.nBytesNodeAddress;
                    }
                }
                iAddr = iEndArcAddr + this.nBytesNodeAddress;
            }




︙


225
226
227
228
229
230
231
232

233
234

235
236
237
238
239
240
241

355
356
357
358
359
360
361

362
363

364
365
366
367
368
369
370
371








-
+

-
+








                return [];
            }
        }
        if (this._convBytesToInteger(this.byDic.slice(iAddr, iAddr+this.nBytesArc)) & this._finalNodeMask) {
            let l = [];
            let nRawArc = 0;
            while (!(nRawArc & this._lastArcMask)) {
                var iEndArcAddr = iAddr + this.nBytesArc;
                let iEndArcAddr = iAddr + this.nBytesArc;
                nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr));
                var nArc = nRawArc & this._arcMask;
                let nArc = nRawArc & this._arcMask;
                if (nArc >= this.nChar) {
                    // This value is not a char, this is a stemming code 
                    l.push(this.funcStemming(sWord, this.lArcVal[nArc]));
                }
                iAddr = iEndArcAddr + this.nBytesNodeAddress;
            }
            return l;




︙


258
259
260
261
262
263
264













265
266
267
268
269
270
271

388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414








+
+
+
+
+
+
+
+
+
+
+
+
+








                if (nRawArc & this._lastArcMask) {
                    return null;
                }
                iAddr = iEndArcAddr + this.nBytesNodeAddress;
            }
        }
    }

    _getArcs1 (iAddr) {
        "generator: return all arcs at <iAddr> as tuples of (nVal, iAddr)"
        while (true) {
            let iEndArcAddr = iAddr+this.nBytesArc;
            let nRawArc = this._convBytesToInteger(this.byDic.slice(iAddr, iEndArcAddr));
            yield [nRawArc & this._arcMask, this._convBytesToInteger(this.byDic.slice(iEndArcAddr, iEndArcAddr+this.nBytesNodeAddress))];
            if (nRawArc & this._lastArcMask) {
                break;
            }
            iAddr = iEndArcAddr+this.nBytesNodeAddress;
        }
    }

    // VERSION 2
    _morph2 (sWord) {
        // to do
    }

    _stem2 (sWord) {




︙







Added gc_core/js/jsex_set.js version [c1ba86ddef].

















1
2
3
4
5
6
7
8
9
10
11
12
13

+
+
+
+
+
+
+
+
+
+
+
+
+


// Set
/*jslint esversion: 6*/

if (Set.prototype.grammalecte === undefined) {
    Set.prototype.gl_update = function (aSet) {
        for (let elem of aSet) {
            this.add(elem);
        }
    };

    Set.prototype.grammalecte = true;
}








Modified gc_core/py/ibdawg.py
from [7e76b3fddf]
to [8aac99b428].




︙


81
82
83
84
85
86
87
88
89

90
91
92
93
94
95
96

81
82
83
84
85
86
87

88
89
90
91
92
93
94
95
96








-

+








            self.stem = self._stem2
            self._lookupArcNode = self._lookupArcNode2
            self._getArcs = self._getArcs2
            self._writeNodes = self._writeNodes2
        elif self.nVersion == 3:
            self.morph = self._morph3
            self.stem = self._stem3
            self._getArcs = self._getArcs3
            self._lookupArcNode = self._lookupArcNode3
            self._getArcs = self._getArcs3
            self._writeNodes = self._writeNodes3
        else:
            raise ValueError("  # Error: unknown code: {}".format(self.nVersion))

        self.bOptNumSigle = False
        self.bOptNumAtLast = False





︙


182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

182
183
184
185
186
187
188

189
190
191
192
193
194
195








-








            l.extend(self.morph(sWord.lower()))
            if sWord.isupper() and len(sWord) > 1:
                l.extend(self.morph(sWord.capitalize()))
        return l

    def suggest (self, sWord, nMaxSugg=10):
        "returns a set of suggestions for <sWord>"
        #return self._suggestWithCrushedUselessChars(cp.clearWord(sWord))
        aSugg = set()
        if sWord.istitle():
            aSugg.update(self._suggest(sWord, nMaxDel=len(sWord) // 5))
            aSugg.update(self._suggest(sWord.lower(), nMaxDel=len(sWord) // 5))
            aSugg = set(map(lambda sSugg: sSugg.title(), aSugg))
        elif sWord.islower():
            aSugg.update(self._suggest(sWord, nMaxDel=len(sWord) // 5))




︙










  
  
 

 


  

    

      Fossil 2.24 [8be0372c10] 2024-04-23 13:25:26
    

    This page was generated in about 0.009s