mugiten/jadb
2
1
Fork 0
Code Issues 67 Pull Requests Actions Activity

lemmatizer/rules: name all rules as separate static variables

Browse Source
This commit is contained in:
Oystein Kristoffer Tveit
2026-03-01 11:34:53 +09:00
parent 1d9928ade1
commit c06fff9e5a
3 changed files with 821 additions and 697 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/util/lemmatizer/rules/godan_verbs.dart
+480 -428
View File
@@ -1,457 +1,509 @@
import 'package:jadb/util/lemmatizer/lemmatizer.dart'; import 'package:jadb/util/lemmatizer/lemmatizer.dart';
List<LemmatizationRule> godanVerbLemmatizationRules = [ final LemmatizationRule godanVerbBase = LemmatizationRule(
LemmatizationRule( name: 'Godan verb - base form',
name: 'Godan verb - base form', terminal: true,
terminal: true, pattern: AllomorphPattern(
pattern: AllomorphPattern( patterns: {
patterns: { 'う': ['う'],
'う': ['う'], 'く': ['く'],
'く': ['く'], 'ぐ': ['ぐ'],
'ぐ': ['ぐ'], 'す': ['す'],
'す': ['す'], 'つ': ['つ'],
'つ': ['つ'], 'ぬ': ['ぬ'],
'ぬ': ['ぬ'], 'ぶ': ['ぶ'],
'ぶ': ['ぶ'], 'む': ['む'],
'む': ['む'], 'る': ['る'],
'る': ['る'], },
}, type: LemmatizationRuleType.suffix,
type: LemmatizationRuleType.suffix,
),
validChildClasses: [WordClass.godanVerb],
wordClass: WordClass.godanVerb,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'わない': ['う'], final LemmatizationRule godanVerbNegative = LemmatizationRule(
'かない': ['く'], name: 'Godan verb - negative form',
'がない': ['ぐ'], pattern: AllomorphPattern(
'さない': ['す'], patterns: {
'たない': ['つ'], 'わない': ['う'],
'なない': ['ぬ'], 'かない': ['く'],
'ばない': ['ぶ'], 'がない': ['ぐ'],
'まない': ['む'], 'さない': ['す'],
'らない': ['る'], 'たない': ['つ'],
}, 'なない': ['ぬ'],
type: LemmatizationRuleType.suffix, 'ばない': ['ぶ'],
), 'まない': ['む'],
validChildClasses: [WordClass.godanVerb], 'らない': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - past form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'した': ['す'], final LemmatizationRule godanVerbPast = LemmatizationRule(
'った': ['る', 'つ', 'う'], name: 'Godan verb - past form',
'んだ': ['む', 'ぬ', 'ぶ'], pattern: AllomorphPattern(
'いだ': ['ぐ'], patterns: {
'いた': ['く'], 'した': ['す'],
}, 'った': ['る', 'つ', 'う'],
type: LemmatizationRuleType.suffix, 'んだ': ['む', 'ぬ', 'ぶ'],
), 'いだ': ['ぐ'],
validChildClasses: [WordClass.godanVerb], 'いた': ['く'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - te-form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'いて': ['く', 'ぐ'], final LemmatizationRule godanVerbTe = LemmatizationRule(
'して': ['す'], name: 'Godan verb - te-form',
'って': ['る', 'つ', 'う'], pattern: AllomorphPattern(
'んで': ['む', 'ぬ', 'ぶ'], patterns: {
}, 'いて': ['く', 'ぐ'],
type: LemmatizationRuleType.suffix, 'して': ['す'],
), 'って': ['る', 'つ', 'う'],
validChildClasses: [WordClass.godanVerb], 'んで': ['む', 'ぬ', 'ぶ'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - te-form with いる', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'いている': ['く', 'ぐ'], final LemmatizationRule godanVerbTeiru = LemmatizationRule(
'している': ['す'], name: 'Godan verb - te-form with いる',
'っている': ['る', 'つ', 'う'], pattern: AllomorphPattern(
'んでいる': ['む', 'ぬ', 'ぶ'], patterns: {
}, 'いている': ['く', 'ぐ'],
type: LemmatizationRuleType.suffix, 'している': ['す'],
), 'っている': ['る', 'つ', 'う'],
validChildClasses: [WordClass.godanVerb], 'んでいる': ['む', 'ぬ', 'ぶ'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - te-form with いた', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'いていた': ['く', 'ぐ'], final LemmatizationRule godanVerbTeita = LemmatizationRule(
'していた': ['す'], name: 'Godan verb - te-form with いた',
'っていた': ['る', 'つ', 'う'], pattern: AllomorphPattern(
'んでいた': ['む', 'ぬ', 'ぶ'], patterns: {
}, 'いていた': ['く', 'ぐ'],
type: LemmatizationRuleType.suffix, 'していた': ['す'],
), 'っていた': ['る', 'つ', 'う'],
validChildClasses: [WordClass.godanVerb], 'んでいた': ['む', 'ぬ', 'ぶ'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - conditional form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'けば': ['く'], final LemmatizationRule godanVerbConditional = LemmatizationRule(
'げば': ['ぐ'], name: 'Godan verb - conditional form',
'せば': ['す'], pattern: AllomorphPattern(
'てば': ['つ', 'る', 'う'], patterns: {
'ねば': ['ぬ'], 'けば': ['く'],
'べば': ['ぶ'], 'げば': ['ぐ'],
'めば': ['む'], 'せば': ['す'],
}, 'てば': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'ねば': ['ぬ'],
), 'べば': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'めば': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - volitional form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'おう': ['う'], final LemmatizationRule godanVerbVolitional = LemmatizationRule(
'こう': ['く'], name: 'Godan verb - volitional form',
'ごう': ['ぐ'], pattern: AllomorphPattern(
'そう': ['す'], patterns: {
'とう': ['つ', 'る', 'う'], 'おう': ['う'],
'のう': ['ぬ'], 'こう': ['く'],
'ぼう': ['ぶ'], 'ごう': ['ぐ'],
'もう': ['む'], 'そう': ['す'],
}, 'とう': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'のう': ['ぬ'],
), 'ぼう': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'もう': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - potential form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'ける': ['く'], final LemmatizationRule godanVerbPotential = LemmatizationRule(
'げる': ['ぐ'], name: 'Godan verb - potential form',
'せる': ['す'], pattern: AllomorphPattern(
'てる': ['つ', 'る', 'う'], patterns: {
'ねる': ['ぬ'], 'ける': ['く'],
'べる': ['ぶ'], 'げる': ['ぐ'],
'める': ['む'], 'せる': ['す'],
}, 'てる': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'ねる': ['ぬ'],
), 'べる': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'める': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - passive form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'かれる': ['く'], final LemmatizationRule godanVerbPassive = LemmatizationRule(
'がれる': ['ぐ'], name: 'Godan verb - passive form',
'される': ['す'], pattern: AllomorphPattern(
'たれる': ['つ', 'る', 'う'], patterns: {
'なれる': ['ぬ'], 'かれる': ['く'],
'ばれる': ['ぶ'], 'がれる': ['ぐ'],
'まれる': ['む'], 'される': ['す'],
}, 'たれる': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'なれる': ['ぬ'],
), 'ばれる': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'まれる': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - causative form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'かせる': ['く'], final LemmatizationRule godanVerbCausative = LemmatizationRule(
'がせる': ['ぐ'], name: 'Godan verb - causative form',
'させる': ['す'], pattern: AllomorphPattern(
'たせる': ['つ', 'る', 'う'], patterns: {
'なせる': ['ぬ'], 'かせる': ['く'],
'ばせる': ['ぶ'], 'がせる': ['ぐ'],
'ませる': ['む'], 'させる': ['す'],
}, 'たせる': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'なせる': ['ぬ'],
), 'ばせる': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'ませる': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - causative-passive form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'かされる': ['く'], final LemmatizationRule godanVerbCausativePassive = LemmatizationRule(
'がされる': ['ぐ'], name: 'Godan verb - causative-passive form',
'される': ['す'], pattern: AllomorphPattern(
'たされる': ['つ', 'る', 'う'], patterns: {
'なされる': ['ぬ'], 'かされる': ['く'],
'ばされる': ['ぶ'], 'がされる': ['ぐ'],
'まされる': ['む'], 'される': ['す'],
}, 'たされる': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'なされる': ['ぬ'],
), 'ばされる': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'まされる': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - imperative form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'え': ['う'], final LemmatizationRule godanVerbImperative = LemmatizationRule(
'け': ['く'], name: 'Godan verb - imperative form',
'げ': ['ぐ'], pattern: AllomorphPattern(
'せ': ['す'], patterns: {
'て': ['つ', 'る', 'う'], 'え': ['う'],
'ね': ['ぬ'], 'け': ['く'],
'べ': ['ぶ'], 'げ': ['ぐ'],
'め': ['む'], 'せ': ['す'],
}, 'て': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'ね': ['ぬ'],
), 'べ': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'め': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative past form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'わなかった': ['う'], final LemmatizationRule godanVerbNegativePast = LemmatizationRule(
'かなかった': ['く'], name: 'Godan verb - negative past form',
'がなかった': ['ぐ'], pattern: AllomorphPattern(
'さなかった': ['す'], patterns: {
'たなかった': ['つ'], 'わなかった': ['う'],
'ななかった': ['ぬ'], 'かなかった': ['く'],
'ばなかった': ['ぶ'], 'がなかった': ['ぐ'],
'まなかった': ['む'], 'さなかった': ['す'],
'らなかった': ['る'], 'たなかった': ['つ'],
}, 'ななかった': ['ぬ'],
type: LemmatizationRuleType.suffix, 'ばなかった': ['ぶ'],
), 'まなかった': ['む'],
validChildClasses: [WordClass.godanVerb], 'らなかった': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative te-form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'わなくて': ['う'], final LemmatizationRule godanVerbNegativeTe = LemmatizationRule(
'かなくて': ['く'], name: 'Godan verb - negative te-form',
'がなくて': ['ぐ'], pattern: AllomorphPattern(
'さなくて': ['す'], patterns: {
'たなくて': ['つ'], 'わなくて': ['う'],
'ななくて': ['ぬ'], 'かなくて': ['く'],
'ばなくて': ['ぶ'], 'がなくて': ['ぐ'],
'まなくて': ['む'], 'さなくて': ['す'],
'らなくて': ['る'], 'たなくて': ['つ'],
}, 'ななくて': ['ぬ'],
type: LemmatizationRuleType.suffix, 'ばなくて': ['ぶ'],
), 'まなくて': ['む'],
validChildClasses: [WordClass.godanVerb], 'らなくて': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative conditional form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'わなければ': ['う'], final LemmatizationRule godanVerbNegativeConditional = LemmatizationRule(
'かなければ': ['く'], name: 'Godan verb - negative conditional form',
'がなければ': ['ぐ'], pattern: AllomorphPattern(
'さなければ': ['す'], patterns: {
'たなければ': ['つ'], 'わなければ': ['う'],
'ななければ': ['ぬ'], 'かなければ': ['く'],
'ばなければ': ['ぶ'], 'がなければ': ['ぐ'],
'まなければ': ['む'], 'さなければ': ['す'],
'らなければ': ['る'], 'たなければ': ['つ'],
}, 'ななければ': ['ぬ'],
type: LemmatizationRuleType.suffix, 'ばなければ': ['ぶ'],
), 'まなければ': ['む'],
validChildClasses: [WordClass.godanVerb], 'らなければ': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative volitional form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'うまい': ['う'], final LemmatizationRule godanVerbNegativeVolitional = LemmatizationRule(
'くまい': ['く'], name: 'Godan verb - negative volitional form',
'ぐまい': ['ぐ'], pattern: AllomorphPattern(
'すまい': ['す'], patterns: {
'つまい': ['つ', 'る', 'う'], 'うまい': ['う'],
'ぬまい': ['ぬ'], 'くまい': ['く'],
'ぶまい': ['ぶ'], 'ぐまい': ['ぐ'],
'むまい': ['む'], 'すまい': ['す'],
}, 'つまい': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'ぬまい': ['ぬ'],
), 'ぶまい': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'むまい': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative potential form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'けない': ['く'], final LemmatizationRule godanVerbNegativePotential = LemmatizationRule(
'げない': ['ぐ'], name: 'Godan verb - negative potential form',
'せない': ['す'], pattern: AllomorphPattern(
'てない': ['つ', 'る', 'う'], patterns: {
'ねない': ['ぬ'], 'けない': ['く'],
'べない': ['ぶ'], 'げない': ['ぐ'],
'めない': ['む'], 'せない': ['す'],
}, 'てない': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'ねない': ['ぬ'],
), 'べない': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'めない': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative passive form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'かれない': ['く'], final LemmatizationRule godanVerbNegativePassive = LemmatizationRule(
'がれない': ['ぐ'], name: 'Godan verb - negative passive form',
'されない': ['す'], pattern: AllomorphPattern(
'たれない': ['つ', 'る', 'う'], patterns: {
'なれない': ['ぬ'], 'かれない': ['く'],
'ばれない': ['ぶ'], 'がれない': ['ぐ'],
'まれない': ['む'], 'されない': ['す'],
}, 'たれない': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'なれない': ['ぬ'],
), 'ばれない': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'まれない': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative causative form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'かせない': ['く'], final LemmatizationRule godanVerbNegativeCausative = LemmatizationRule(
'がせない': ['ぐ'], name: 'Godan verb - negative causative form',
'させない': ['す'], pattern: AllomorphPattern(
'たせない': ['つ', 'る', 'う'], patterns: {
'なせない': ['ぬ'], 'かせない': ['く'],
'ばせない': ['ぶ'], 'がせない': ['ぐ'],
'ませない': ['む'], 'させない': ['す'],
}, 'たせない': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'なせない': ['ぬ'],
), 'ばせない': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'ませない': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative causative-passive form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'かされない': ['く'], final LemmatizationRule godanVerbNegativeCausativePassive = LemmatizationRule(
'がされない': ['ぐ'], name: 'Godan verb - negative causative-passive form',
'されない': ['す'], pattern: AllomorphPattern(
'たされない': ['つ', 'る', 'う'], patterns: {
'なされない': ['ぬ'], 'かされない': ['く'],
'ばされない': ['ぶ'], 'がされない': ['ぐ'],
'まされない': ['む'], 'されない': ['す'],
}, 'たされない': ['つ', 'る', 'う'],
type: LemmatizationRuleType.suffix, 'なされない': ['ぬ'],
), 'ばされない': ['ぶ'],
validChildClasses: [WordClass.godanVerb], 'まされない': ['む'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative imperative form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'うな': ['う'], final LemmatizationRule godanVerbNegativeImperative = LemmatizationRule(
'くな': ['く'], name: 'Godan verb - negative imperative form',
'ぐな': ['ぐ'], pattern: AllomorphPattern(
'すな': ['す'], patterns: {
'つな': ['つ'], 'うな': ['う'],
'ぬな': ['ぬ'], 'くな': ['く'],
'ぶな': ['ぶ'], 'ぐな': ['ぐ'],
'むな': ['む'], 'すな': ['す'],
'るな': ['る'], 'つな': ['つ'],
}, 'ぬな': ['ぬ'],
type: LemmatizationRuleType.suffix, 'ぶな': ['ぶ'],
), 'むな': ['む'],
validChildClasses: [WordClass.godanVerb], 'るな': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - desire form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'きたい': ['く'], final LemmatizationRule godanVerbDesire = LemmatizationRule(
'ぎたい': ['ぐ'], name: 'Godan verb - desire form',
'したい': ['す'], pattern: AllomorphPattern(
'ちたい': ['つ'], patterns: {
'にたい': ['ぬ'], 'きたい': ['く'],
'びたい': ['ぶ'], 'ぎたい': ['ぐ'],
'みたい': ['む'], 'したい': ['す'],
'りたい': ['る'], 'ちたい': ['つ'],
}, 'にたい': ['ぬ'],
type: LemmatizationRuleType.suffix, 'びたい': ['ぶ'],
), 'みたい': ['む'],
validChildClasses: [WordClass.godanVerb], 'りたい': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative desire form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'いたくない': ['う'], final LemmatizationRule godanVerbNegativeDesire = LemmatizationRule(
'きたくない': ['く'], name: 'Godan verb - negative desire form',
'ぎたくない': ['ぐ'], pattern: AllomorphPattern(
'したくない': ['す'], patterns: {
'ちたくない': ['つ'], 'いたくない': ['う'],
'にたくない': ['ぬ'], 'きたくない': ['く'],
'びたくない': ['ぶ'], 'ぎたくない': ['ぐ'],
'みたくない': ['む'], 'したくない': ['す'],
'りたくない': ['る'], 'ちたくない': ['つ'],
}, 'にたくない': ['ぬ'],
type: LemmatizationRuleType.suffix, 'びたくない': ['ぶ'],
), 'みたくない': ['む'],
validChildClasses: [WordClass.godanVerb], 'りたくない': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - past desire form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'きたかった': ['く'], final LemmatizationRule godanVerbPastDesire = LemmatizationRule(
'ぎたかった': ['ぐ'], name: 'Godan verb - past desire form',
'したかった': ['す'], pattern: AllomorphPattern(
'ちたかった': ['つ'], patterns: {
'にたかった': ['ぬ'], 'きたかった': ['く'],
'びたかった': ['ぶ'], 'ぎたかった': ['ぐ'],
'みたかった': ['む'], 'したかった': ['す'],
'りたかった': ['る'], 'ちたかった': ['つ'],
}, 'にたかった': ['ぬ'],
type: LemmatizationRuleType.suffix, 'びたかった': ['ぶ'],
), 'みたかった': ['む'],
validChildClasses: [WordClass.godanVerb], 'りたかった': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
LemmatizationRule( validChildClasses: [WordClass.godanVerb],
name: 'Godan verb - negative past desire form', wordClass: WordClass.godanVerb,
pattern: AllomorphPattern( );
patterns: {
'いたくなかった': ['う'], final LemmatizationRule godanVerbNegativePastDesire = LemmatizationRule(
'きたくなかった': ['く'], name: 'Godan verb - negative past desire form',
'ぎたくなかった': ['ぐ'], pattern: AllomorphPattern(
'したくなかった': ['す'], patterns: {
'ちたくなかった': ['つ'], 'いたくなかった': ['う'],
'にたくなかった': ['ぬ'], 'きたくなかった': ['く'],
'びたくなかった': ['ぶ'], 'ぎたくなかった': ['ぐ'],
'みたくなかった': ['む'], 'したくなかった': ['す'],
'りたくなかった': ['る'], 'ちたくなかった': ['つ'],
}, 'にたくなかった': ['ぬ'],
type: LemmatizationRuleType.suffix, 'びたくなかった': ['ぶ'],
), 'みたくなかった': ['む'],
validChildClasses: [WordClass.godanVerb], 'りたくなかった': ['る'],
wordClass: WordClass.godanVerb, },
type: LemmatizationRuleType.suffix,
), ),
validChildClasses: [WordClass.godanVerb],
wordClass: WordClass.godanVerb,
);
final List<LemmatizationRule> godanVerbLemmatizationRules = [
godanVerbBase,
godanVerbNegative,
godanVerbPast,
godanVerbTe,
godanVerbTeiru,
godanVerbTeita,
godanVerbConditional,
godanVerbVolitional,
godanVerbPotential,
godanVerbPassive,
godanVerbCausative,
godanVerbCausativePassive,
godanVerbImperative,
godanVerbNegativePast,
godanVerbNegativeTe,
godanVerbNegativeConditional,
godanVerbNegativeVolitional,
godanVerbNegativePotential,
godanVerbNegativePassive,
godanVerbNegativeCausative,
godanVerbNegativeCausativePassive,
godanVerbNegativeImperative,
godanVerbDesire,
godanVerbNegativeDesire,
godanVerbPastDesire,
godanVerbNegativePastDesire,
]; ];
lib/util/lemmatizer/rules/i_adjectives.dart
+74 -58
View File
@@ -1,61 +1,77 @@
import 'package:jadb/util/lemmatizer/lemmatizer.dart'; import 'package:jadb/util/lemmatizer/lemmatizer.dart';
List<LemmatizationRule> iAdjectiveLemmatizationRules = [ final LemmatizationRule iAdjectiveBase = LemmatizationRule.simple(
LemmatizationRule.simple( name: 'I adjective - base form',
name: 'I adjective - base form', terminal: true,
terminal: true, pattern: 'い',
pattern: 'い', replacement: 'い',
replacement: 'い', validChildClasses: [WordClass.iAdjective],
validChildClasses: [WordClass.iAdjective], wordClass: WordClass.iAdjective,
wordClass: WordClass.iAdjective, );
),
LemmatizationRule.simple( final LemmatizationRule iAdjectiveNegative = LemmatizationRule.simple(
name: 'I adjective - negative form', name: 'I adjective - negative form',
pattern: 'くない', pattern: 'くない',
replacement: 'い', replacement: 'い',
validChildClasses: [WordClass.iAdjective], validChildClasses: [WordClass.iAdjective],
wordClass: WordClass.iAdjective, wordClass: WordClass.iAdjective,
), );
LemmatizationRule.simple(
name: 'I adjective - past form', final LemmatizationRule iAdjectivePast = LemmatizationRule.simple(
pattern: 'かった', name: 'I adjective - past form',
replacement: 'い', pattern: 'かった',
validChildClasses: [WordClass.iAdjective], replacement: 'い',
wordClass: WordClass.iAdjective, validChildClasses: [WordClass.iAdjective],
), wordClass: WordClass.iAdjective,
LemmatizationRule.simple( );
name: 'I adjective - negative past form',
pattern: 'くなかった', final LemmatizationRule iAdjectiveNegativePast = LemmatizationRule.simple(
replacement: 'い', name: 'I adjective - negative past form',
validChildClasses: [WordClass.iAdjective], pattern: 'くなかった',
wordClass: WordClass.iAdjective, replacement: 'い',
), validChildClasses: [WordClass.iAdjective],
LemmatizationRule.simple( wordClass: WordClass.iAdjective,
name: 'I adjective - te-form', );
pattern: 'くて',
replacement: 'い', final LemmatizationRule iAdjectiveTe = LemmatizationRule.simple(
validChildClasses: [WordClass.iAdjective], name: 'I adjective - te-form',
wordClass: WordClass.iAdjective, pattern: 'くて',
), replacement: 'い',
LemmatizationRule.simple( validChildClasses: [WordClass.iAdjective],
name: 'I adjective - conditional form', wordClass: WordClass.iAdjective,
pattern: 'ければ', );
replacement: 'い',
validChildClasses: [WordClass.iAdjective], final LemmatizationRule iAdjectiveConditional = LemmatizationRule.simple(
wordClass: WordClass.iAdjective, name: 'I adjective - conditional form',
), pattern: 'ければ',
LemmatizationRule.simple( replacement: 'い',
name: 'I adjective - volitional form', validChildClasses: [WordClass.iAdjective],
pattern: 'かろう', wordClass: WordClass.iAdjective,
replacement: 'い', );
validChildClasses: [WordClass.iAdjective],
wordClass: WordClass.iAdjective, final LemmatizationRule iAdjectiveVolitional = LemmatizationRule.simple(
), name: 'I adjective - volitional form',
LemmatizationRule.simple( pattern: 'かろう',
name: 'I adjective - continuative form', replacement: 'い',
pattern: 'く', validChildClasses: [WordClass.iAdjective],
replacement: 'い', wordClass: WordClass.iAdjective,
validChildClasses: [WordClass.iAdjective], );
wordClass: WordClass.iAdjective,
), final LemmatizationRule iAdjectiveContinuative = LemmatizationRule.simple(
name: 'I adjective - continuative form',
pattern: 'く',
replacement: 'い',
validChildClasses: [WordClass.iAdjective],
wordClass: WordClass.iAdjective,
);
final List<LemmatizationRule> iAdjectiveLemmatizationRules = [
iAdjectiveBase,
iAdjectiveNegative,
iAdjectivePast,
iAdjectiveNegativePast,
iAdjectiveTe,
iAdjectiveConditional,
iAdjectiveVolitional,
iAdjectiveContinuative,
]; ];
lib/util/lemmatizer/rules/ichidan_verbs.dart
+267 -211
View File
@@ -1,7 +1,7 @@
import 'package:jadb/util/lemmatizer/lemmatizer.dart'; import 'package:jadb/util/lemmatizer/lemmatizer.dart';
import 'package:jadb/util/text_filtering.dart'; import 'package:jadb/util/text_filtering.dart';
List<Pattern> lookBehinds = [ final List<Pattern> _lookBehinds = [
kanjiRegex, kanjiRegex,
'き', 'き',
'ぎ', 'ぎ',
@@ -28,214 +28,270 @@ List<Pattern> lookBehinds = [
'れ', 'れ',
]; ];
List<LemmatizationRule> ichidanVerbLemmatizationRules = [ final LemmatizationRule ichidanVerbBase = LemmatizationRule.simple(
LemmatizationRule.simple( name: 'Ichidan verb - base form',
name: 'Ichidan verb - base form', terminal: true,
terminal: true, pattern: 'る',
pattern: 'る', replacement: 'る',
replacement: 'る', lookAheadBehind: _lookBehinds,
lookAheadBehind: lookBehinds, validChildClasses: [WordClass.ichidanVerb],
validChildClasses: [WordClass.ichidanVerb], wordClass: WordClass.ichidanVerb,
wordClass: WordClass.ichidanVerb, );
),
LemmatizationRule.simple( final LemmatizationRule ichidanVerbNegative = LemmatizationRule.simple(
name: 'Ichidan verb - negative form', name: 'Ichidan verb - negative form',
pattern: 'ない', pattern: 'ない',
replacement: 'る', replacement: 'る',
lookAheadBehind: lookBehinds, lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb], validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, wordClass: WordClass.ichidanVerb,
), );
LemmatizationRule.simple( final LemmatizationRule ichidanVerbPast = LemmatizationRule.simple(
name: 'Ichidan verb - past form', name: 'Ichidan verb - past form',
pattern: 'た', pattern: 'た',
replacement: 'る', replacement: 'る',
lookAheadBehind: lookBehinds, lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb], validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, wordClass: WordClass.ichidanVerb,
), );
LemmatizationRule.simple(
name: 'Ichidan verb - te-form', final LemmatizationRule ichidanVerbTe = LemmatizationRule.simple(
pattern: 'て', name: 'Ichidan verb - te-form',
replacement: 'る', pattern: 'て',
lookAheadBehind: lookBehinds, replacement: 'る',
validChildClasses: [WordClass.ichidanVerb], lookAheadBehind: _lookBehinds,
wordClass: WordClass.ichidanVerb, validChildClasses: [WordClass.ichidanVerb],
), wordClass: WordClass.ichidanVerb,
LemmatizationRule.simple( );
name: 'Ichidan verb - te-form with いる',
pattern: 'ている', final LemmatizationRule ichidanVerbTeiru = LemmatizationRule.simple(
replacement: 'る', name: 'Ichidan verb - te-form with いる',
lookAheadBehind: lookBehinds, pattern: 'ている',
validChildClasses: [WordClass.ichidanVerb], replacement: 'る',
wordClass: WordClass.ichidanVerb, lookAheadBehind: _lookBehinds,
), validChildClasses: [WordClass.ichidanVerb],
LemmatizationRule.simple( wordClass: WordClass.ichidanVerb,
name: 'Ichidan verb - te-form with いた', );
pattern: 'ていた',
replacement: 'る', final LemmatizationRule ichidanVerbTeita = LemmatizationRule.simple(
lookAheadBehind: lookBehinds, name: 'Ichidan verb - te-form with いた',
validChildClasses: [WordClass.ichidanVerb], pattern: 'ていた',
wordClass: WordClass.ichidanVerb, replacement: 'る',
), lookAheadBehind: _lookBehinds,
LemmatizationRule.simple( validChildClasses: [WordClass.ichidanVerb],
name: 'Ichidan verb - conditional form', wordClass: WordClass.ichidanVerb,
pattern: 'れば', );
replacement: 'る',
lookAheadBehind: lookBehinds, final LemmatizationRule ichidanVerbConditional = LemmatizationRule.simple(
validChildClasses: [WordClass.ichidanVerb], name: 'Ichidan verb - conditional form',
wordClass: WordClass.ichidanVerb, pattern: 'れば',
), replacement: 'る',
LemmatizationRule.simple( lookAheadBehind: _lookBehinds,
name: 'Ichidan verb - volitional form', validChildClasses: [WordClass.ichidanVerb],
pattern: 'よう', wordClass: WordClass.ichidanVerb,
replacement: 'る', );
lookAheadBehind: lookBehinds,
validChildClasses: [WordClass.ichidanVerb], final LemmatizationRule ichidanVerbVolitional = LemmatizationRule.simple(
wordClass: WordClass.ichidanVerb, name: 'Ichidan verb - volitional form',
), pattern: 'よう',
LemmatizationRule.simple( replacement: 'る',
name: 'Ichidan verb - potential form', lookAheadBehind: _lookBehinds,
pattern: 'られる', validChildClasses: [WordClass.ichidanVerb],
replacement: 'る', wordClass: WordClass.ichidanVerb,
lookAheadBehind: lookBehinds, );
validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, final LemmatizationRule ichidanVerbPotential = LemmatizationRule.simple(
), name: 'Ichidan verb - potential form',
LemmatizationRule.simple( pattern: 'られる',
name: 'Ichidan verb - passive form', replacement: 'る',
pattern: 'られる', lookAheadBehind: _lookBehinds,
replacement: 'る', validChildClasses: [WordClass.ichidanVerb],
lookAheadBehind: lookBehinds, wordClass: WordClass.ichidanVerb,
validChildClasses: [WordClass.ichidanVerb], );
wordClass: WordClass.ichidanVerb,
), final LemmatizationRule ichidanVerbPassive = LemmatizationRule.simple(
LemmatizationRule.simple( name: 'Ichidan verb - passive form',
name: 'Ichidan verb - causative form', pattern: 'られる',
pattern: 'させる', replacement: 'る',
replacement: 'る', lookAheadBehind: _lookBehinds,
lookAheadBehind: lookBehinds, validChildClasses: [WordClass.ichidanVerb],
validChildClasses: [WordClass.ichidanVerb], wordClass: WordClass.ichidanVerb,
wordClass: WordClass.ichidanVerb, );
),
LemmatizationRule.simple( final LemmatizationRule ichidanVerbCausative = LemmatizationRule.simple(
name: 'Ichidan verb - causative passive form', name: 'Ichidan verb - causative form',
pattern: 'させられる', pattern: 'させる',
replacement: 'る', replacement: 'る',
lookAheadBehind: lookBehinds, lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb], validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, wordClass: WordClass.ichidanVerb,
), );
LemmatizationRule.simple(
name: 'Ichidan verb - imperative form', final LemmatizationRule ichidanVerbCausativePassive = LemmatizationRule.simple(
pattern: 'れ', name: 'Ichidan verb - causative passive form',
replacement: 'る', pattern: 'させられる',
lookAheadBehind: lookBehinds, replacement: 'る',
validChildClasses: [WordClass.ichidanVerb], lookAheadBehind: _lookBehinds,
wordClass: WordClass.ichidanVerb, validChildClasses: [WordClass.ichidanVerb],
), wordClass: WordClass.ichidanVerb,
LemmatizationRule.simple( );
name: 'Ichidan verb - negative past form',
pattern: 'なかった', final LemmatizationRule ichidanVerbImperative = LemmatizationRule.simple(
replacement: 'る', name: 'Ichidan verb - imperative form',
lookAheadBehind: lookBehinds, pattern: 'れ',
validChildClasses: [WordClass.ichidanVerb], replacement: 'る',
wordClass: WordClass.ichidanVerb, lookAheadBehind: _lookBehinds,
), validChildClasses: [WordClass.ichidanVerb],
LemmatizationRule.simple( wordClass: WordClass.ichidanVerb,
name: 'Ichidan verb - negative te-form', );
pattern: 'なくて',
replacement: 'る', final LemmatizationRule ichidanVerbNegativePast = LemmatizationRule.simple(
lookAheadBehind: lookBehinds, name: 'Ichidan verb - negative past form',
validChildClasses: [WordClass.ichidanVerb], pattern: 'なかった',
wordClass: WordClass.ichidanVerb, replacement: 'る',
), lookAheadBehind: _lookBehinds,
LemmatizationRule.simple( validChildClasses: [WordClass.ichidanVerb],
name: 'Ichidan verb - negative conditional form', wordClass: WordClass.ichidanVerb,
pattern: 'なければ', );
replacement: 'る',
lookAheadBehind: lookBehinds, final LemmatizationRule ichidanVerbNegativeTe = LemmatizationRule.simple(
validChildClasses: [WordClass.ichidanVerb], name: 'Ichidan verb - negative te-form',
wordClass: WordClass.ichidanVerb, pattern: 'なくて',
), replacement: 'る',
LemmatizationRule.simple( lookAheadBehind: _lookBehinds,
name: 'Ichidan verb - negative volitional form', validChildClasses: [WordClass.ichidanVerb],
pattern: 'なかろう', wordClass: WordClass.ichidanVerb,
replacement: 'る', );
lookAheadBehind: lookBehinds,
validChildClasses: [WordClass.ichidanVerb], final LemmatizationRule ichidanVerbNegativeConditional =
wordClass: WordClass.ichidanVerb, LemmatizationRule.simple(
), name: 'Ichidan verb - negative conditional form',
LemmatizationRule.simple( pattern: 'なければ',
name: 'Ichidan verb - negative potential form', replacement: 'る',
pattern: 'られない', lookAheadBehind: _lookBehinds,
replacement: 'る', validChildClasses: [WordClass.ichidanVerb],
lookAheadBehind: lookBehinds, wordClass: WordClass.ichidanVerb,
validChildClasses: [WordClass.ichidanVerb], );
wordClass: WordClass.ichidanVerb,
), final LemmatizationRule ichidanVerbNegativeVolitional =
LemmatizationRule.simple( LemmatizationRule.simple(
name: 'Ichidan verb - negative passive form', name: 'Ichidan verb - negative volitional form',
pattern: 'られない', pattern: 'なかろう',
replacement: 'る', replacement: 'る',
lookAheadBehind: lookBehinds, lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb], validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, wordClass: WordClass.ichidanVerb,
), );
LemmatizationRule.simple(
name: 'Ichidan verb - negative causative form', final LemmatizationRule ichidanVerbNegativePotential = LemmatizationRule.simple(
pattern: 'させない', name: 'Ichidan verb - negative potential form',
replacement: 'る', pattern: 'られない',
lookAheadBehind: lookBehinds, replacement: 'る',
validChildClasses: [WordClass.ichidanVerb], lookAheadBehind: _lookBehinds,
wordClass: WordClass.ichidanVerb, validChildClasses: [WordClass.ichidanVerb],
), wordClass: WordClass.ichidanVerb,
LemmatizationRule.simple( );
name: 'Ichidan verb - negative causative passive form',
pattern: 'させられない', final LemmatizationRule ichidanVerbNegativePassive = LemmatizationRule.simple(
replacement: 'る', name: 'Ichidan verb - negative passive form',
lookAheadBehind: lookBehinds, pattern: 'られない',
validChildClasses: [WordClass.ichidanVerb], replacement: 'る',
wordClass: WordClass.ichidanVerb, lookAheadBehind: _lookBehinds,
), validChildClasses: [WordClass.ichidanVerb],
LemmatizationRule.simple( wordClass: WordClass.ichidanVerb,
name: 'Ichidan verb - negative imperative form', );
pattern: 'るな',
replacement: 'る', final LemmatizationRule ichidanVerbNegativeCausative = LemmatizationRule.simple(
lookAheadBehind: lookBehinds, name: 'Ichidan verb - negative causative form',
validChildClasses: [WordClass.ichidanVerb], pattern: 'させない',
wordClass: WordClass.ichidanVerb, replacement: 'る',
), lookAheadBehind: _lookBehinds,
LemmatizationRule.simple( validChildClasses: [WordClass.ichidanVerb],
name: 'Ichidan verb - desire form', wordClass: WordClass.ichidanVerb,
pattern: 'たい', );
replacement: 'る',
lookAheadBehind: lookBehinds, final LemmatizationRule ichidanVerbNegativeCausativePassive =
validChildClasses: [WordClass.ichidanVerb], LemmatizationRule.simple(
wordClass: WordClass.ichidanVerb, name: 'Ichidan verb - negative causative passive form',
), pattern: 'させられない',
LemmatizationRule.simple( replacement: 'る',
name: 'Ichidan verb - negative desire form', lookAheadBehind: _lookBehinds,
pattern: 'たくない', validChildClasses: [WordClass.ichidanVerb],
replacement: 'る', wordClass: WordClass.ichidanVerb,
lookAheadBehind: lookBehinds, );
validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, final LemmatizationRule ichidanVerbNegativeImperative =
), LemmatizationRule.simple(
LemmatizationRule.simple( name: 'Ichidan verb - negative imperative form',
name: 'Ichidan verb - past desire form', pattern: 'るな',
pattern: 'たかった', replacement: 'る',
replacement: 'る', lookAheadBehind: _lookBehinds,
lookAheadBehind: lookBehinds, validChildClasses: [WordClass.ichidanVerb],
validChildClasses: [WordClass.ichidanVerb], wordClass: WordClass.ichidanVerb,
wordClass: WordClass.ichidanVerb, );
),
LemmatizationRule.simple( final LemmatizationRule ichidanVerbDesire = LemmatizationRule.simple(
name: 'Ichidan verb - negative past desire form', name: 'Ichidan verb - desire form',
pattern: 'たくなかった', pattern: 'たい',
replacement: 'る', replacement: 'る',
lookAheadBehind: lookBehinds, lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb], validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb, wordClass: WordClass.ichidanVerb,
), );
final LemmatizationRule ichidanVerbNegativeDesire = LemmatizationRule.simple(
name: 'Ichidan verb - negative desire form',
pattern: 'たくない',
replacement: 'る',
lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb,
);
final LemmatizationRule ichidanVerbPastDesire = LemmatizationRule.simple(
name: 'Ichidan verb - past desire form',
pattern: 'たかった',
replacement: 'る',
lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb,
);
final LemmatizationRule ichidanVerbNegativePastDesire =
LemmatizationRule.simple(
name: 'Ichidan verb - negative past desire form',
pattern: 'たくなかった',
replacement: 'る',
lookAheadBehind: _lookBehinds,
validChildClasses: [WordClass.ichidanVerb],
wordClass: WordClass.ichidanVerb,
);
final List<LemmatizationRule> ichidanVerbLemmatizationRules = [
ichidanVerbBase,
ichidanVerbNegative,
ichidanVerbPast,
ichidanVerbTe,
ichidanVerbTeiru,
ichidanVerbTeita,
ichidanVerbConditional,
ichidanVerbVolitional,
ichidanVerbPotential,
ichidanVerbPassive,
ichidanVerbCausative,
ichidanVerbCausativePassive,
ichidanVerbImperative,
ichidanVerbNegativePast,
ichidanVerbNegativeTe,
ichidanVerbNegativeConditional,
ichidanVerbNegativeVolitional,
ichidanVerbNegativePotential,
ichidanVerbNegativePassive,
ichidanVerbNegativeCausative,
ichidanVerbNegativeCausativePassive,
ichidanVerbNegativeImperative,
ichidanVerbDesire,
ichidanVerbNegativeDesire,
ichidanVerbPastDesire,
ichidanVerbNegativePastDesire,
]; ];