de-compromise 0.0.10 → 0.1.0

package/src/01-one/lexicon/methods/nouns/toSingular.js

@@ -0,0 +1,46 @@
+import { convert, reverse } from 'suffix-thumb'
+import model from '../models.js'
+
+let pluralRev = model.nouns && model.nouns.plural ? reverse(model.nouns.plural) : null
+
+// fallback rules, when no trained model is available
+const leave = [
+  'tion',
+  'sion',
+  'tent',
+  'rant',
+  'hine',
+  'ppen',
+  'ene',
+  'nne',
+  'zen',
+  'in',
+  'an',
+  'is',
+]
+
+const suffixes = [
+  'ns',
+  'ne',
+  'n',
+  's',
+]
+
+const toSingular = function (str) {
+  if (pluralRev) {
+    return convert(str, pluralRev)
+  }
+  for (let i = 0; i < leave.length; i += 1) {
+    if (str.endsWith(leave[i])) {
+      return str
+    }
+  }
+  for (let i = 0; i < suffixes.length; i += 1) {
+    let suff = suffixes[i]
+    if (str.endsWith(suff)) {
+      return str.substring(0, str.length - suff.length)
+    }
+  }
+  return str
+}
+export default toSingular

package/src/01-one/lexicon/methods/verbs/conjugate.js

@@ -0,0 +1,87 @@
+import { convert } from 'suffix-thumb'
+import model from '../models.js'
+import getIrregular from './irregulars.js'
+import ppRules from './custom/toPastParticiple.js'
+let { presentTense, pastTense, subjunctive1, subjunctive2, imperative, presentParticiple, pastParticiple } = model
+
+const doEach = function (str, m, tense) {
+  let irr = getIrregular(str, tense)
+  if (irr) {
+    return {
+      first: irr[0],
+      second: irr[1],
+      third: irr[2],
+      firstPlural: irr[3],
+      secondPlural: irr[4],
+      thirdPlural: irr[5],
+    }
+  }
+  return {
+    first: convert(str, m.first),
+    second: convert(str, m.second),
+    third: convert(str, m.third),
+    firstPlural: convert(str, m.firstPlural),
+    secondPlural: convert(str, m.secondPlural),
+    thirdPlural: convert(str, m.thirdPlural),
+  }
+}
+
+const toPresent = (str) => doEach(str, presentTense, 'present')
+const toPast = (str) => doEach(str, pastTense, 'past')
+const toSubjunctive1 = (str) => doEach(str, subjunctive1, 'subj1')
+const toSubjunctive2 = (str) => doEach(str, subjunctive2, 'subj2')
+
+const toPresentParticiple = (str) => {
+  return getIrregular(str, 'presentParticiple') || convert(str, presentParticiple.presentParticiple)
+}
+const toPastParticiple = (str) => {
+  let irr = getIrregular(str, 'pastParticiple')
+  if (irr) {
+    return irr
+  }
+  if (pastParticiple) {
+    return convert(str, pastParticiple.pastParticiple)
+  }
+  return ppRules(str)
+}
+const toImperative = (str) => {
+  let irr = getIrregular(str, 'imperative')
+  if (irr) {
+    return { secondSingular: irr[0], secondPlural: irr[1] }
+  }
+  return {
+    secondSingular: convert(str, imperative.singular),
+    secondPlural: convert(str, imperative.plural),
+  }
+}
+
+// an array of every inflection, for '{inf}' syntax
+const all = function (str) {
+  let res = [str].concat(
+    Object.values(toPresent(str)),
+    Object.values(toPast(str)),
+    Object.values(toSubjunctive1(str)),
+    Object.values(toSubjunctive2(str)),
+    Object.values(toImperative(str)),
+    toPresentParticiple(str),
+    toPastParticiple(str),
+  ).filter(s => s)
+  res = new Set(res)
+  return Array.from(res)
+}
+
+
+
+export {
+  all,
+  toPresent,
+  toPast,
+  toSubjunctive1,
+  toSubjunctive2,
+  toImperative,
+  toPresentParticiple,
+  toPastParticiple
+}
+
+// console.log(toImperative('schwimmen'))
+// console.log(all('tanzen'))

package/src/01-one/lexicon/methods/verbs/custom/_test-from.js

@@ -0,0 +1,53 @@
+/* eslint-disable no-console */
+import pairs from '/Users/spencer/mountain/de-compromise/data/models/verbs/past-participle.js'
+import fromPastParticiple from './fromPastParticiple.js'
+// import fs from 'fs'
+
+const inspect = ''
+
+const topk = function (arr) {
+  let obj = {}
+  arr.forEach(a => {
+    obj[a] = obj[a] || 0
+    obj[a] += 1
+  })
+  let res = Object.keys(obj).map(k => [k, obj[k]])
+  return res.sort((a, b) => (a[1] > b[1] ? -1 : 0))
+}
+
+const percent = (part, total) => {
+  let num = (part / total) * 100;
+  num = Math.round(num * 10) / 10;
+  return num;
+};
+
+// collect errors to look at
+let right = 0
+let bads = []
+pairs.forEach(a => {
+  let [inf, prt] = a
+  let have = fromPastParticiple(prt)
+  if (have === inf) {
+    right += 1
+  } else {
+    // if (prt.endsWith(inspect)) {
+    bads.push([a[0], a[1], have])
+    // }
+  }
+})
+
+// let suffs = bads.map(a => a[1].substring(a[1].length - inspect.length, a[1].length))
+let suffs = bads.map(a => a[1].substring(a[1].length - inspect.length - 4, a[1].length))
+// bads = bads.filter(a => a[2].startsWith('ge') && !a[1].startsWith('ge'))
+// let suffs = bads.map(a => a[0].substring(0, 3))
+console.log(topk(suffs))
+// console.log(bads.filter(a => a[0].startsWith('au')))
+// console.log(bads.filter(a => a[0].endsWith('ren')))
+// console.log(bads.filter(a => a[1].endsWith('gen')))
+// fs.writeFileSync('./tmp.json', JSON.stringify(bads, null, 2))
+
+console.log(bads.length, 'errors')
+console.log(percent(right, pairs.length) + '%')
+// console.log('\n\n', toPastParticiple("enthalten"))
+// console.log(bads)
+// 85.8%

package/src/01-one/lexicon/methods/verbs/custom/_test-to.js

@@ -0,0 +1,50 @@
+/* eslint-disable no-console, no-unused-vars */
+import pairs from '/Users/spencer/mountain/de-compromise/data/models/verbs/past-participle.js'
+import toPastParticiple from './toPastParticiple.js'
+import fs from 'fs'
+
+const inspect = ''
+
+const topk = function (arr) {
+  let obj = {}
+  arr.forEach(a => {
+    obj[a] = obj[a] || 0
+    obj[a] += 1
+  })
+  let res = Object.keys(obj).map(k => [k, obj[k]])
+  return res.sort((a, b) => (a[1] > b[1] ? -1 : 0))
+}
+
+const percent = (part, total) => {
+  let num = (part / total) * 100;
+  num = Math.round(num * 10) / 10;
+  return num;
+};
+
+// collect errors to look at
+let right = 0
+let bads = []
+pairs.forEach(a => {
+  let [inf, prt] = a
+  let have = toPastParticiple(inf)
+  if (have === prt) {
+    right += 1
+  } else {
+    if (prt.endsWith(inspect)) {
+      bads.push([a[0], a[1], have])
+    }
+  }
+})
+
+// let suffs = bads.map(a => a[1].substring(a[1].length - inspect.length, a[1].length))
+let suffs = bads.map(a => a[2].substring(a[2].length - inspect.length - 4, a[2].length))
+bads = bads.filter(a => a[2].match(/ssen$/) && !a[1].match(/ssen$/))
+// let suffs = bads.map(a => a[0].substring(0, 4))
+// console.log(bads)
+// console.log(topk(suffs))
+fs.writeFileSync('./tmp.json', JSON.stringify(bads, null, 2))
+
+console.log(bads.length, 'errors')
+console.log(percent(right, pairs.length) + '%')
+console.log('\n\n', toPastParticiple("schwimmen"), "geschwommen")
+// 82%

package/src/01-one/lexicon/methods/verbs/custom/fromPastParticiple.js

@@ -0,0 +1,37 @@
+import { prefixes, suffixes } from './rules.js'
+
+const doSuffix = function (str) {
+  for (let i = 0; i < suffixes.length; i += 1) {
+    let [inf, prt] = suffixes[i]
+    if (str.endsWith(prt)) {
+      return str.substring(0, str.length - prt.length) + inf
+    }
+  }
+  str = str.replace(/t$/, 'en')
+  return str
+}
+
+const doPrefix = function (str) {
+  // remove 'ge-' off the front
+  for (let i = 0; i < prefixes.length; i += 1) {
+    if (str.startsWith(prefixes[i] + 'ge')) {
+      return prefixes[i] + str.substring(prefixes[i].length + 2)
+    }
+  }
+  str = str.replace(/^ge/, '')
+  return str
+}
+
+const fromPastParticiple = function (str) {
+  // always weak - ieren
+  if (str.endsWith('iert')) {
+    str = str.replace(/iert$/, 'ieren')
+    return str //no 'ge-'
+  }
+  str = doSuffix(str)
+  str = doPrefix(str)
+  return str
+}
+export default fromPastParticiple
+
+// console.log(fromPastParticiple('ereifert'))

package/src/01-one/lexicon/methods/verbs/custom/rules.js

@@ -0,0 +1,182 @@
+let prefixes = [
+  'dazwischen',
+  'zusammen',
+  'entgegen',
+  'zwangsum',
+  'daneben',
+  'dagegen',
+  'schwarz',
+  'hierher',
+  'kaputt',
+  'hinein',
+  'zurück',
+  'weiter',
+  'gleich',
+  'allein',
+  'wieder',
+  'schief',
+  'fertig',
+  'hinter',
+  'hängen',
+  'kleben',
+  'nieder',
+  'herbei',
+  'hervor',
+  'falsch',
+  'gesund',
+  'wider',
+  'breit',
+  'krumm',
+  'heran',
+  'herab',
+  'herum',
+  'unter',
+  'offen',
+  'drauf',
+  'dahin',
+  'klein',
+  'durch',
+  'davon',
+  'daher',
+  'dahin',
+  'dahin',
+  'flach',
+  'dabei',
+  'drein',
+  'davor',
+  'krank',
+  'knapp',
+  'dafür',
+  'glatt',
+  'nach',
+  'rück',
+  'dazu',
+  'bloß',
+  'wahr',
+  'weis',
+  'hohn',
+  'lieb',
+  'acht',
+  'groß',
+  'wach',
+  'drin',
+  'hoch',
+  'voll',
+  'hier',
+  'hops',
+  'lahm',
+  'quer',
+  'klar',
+  'fern',
+  'fein',
+  'fehl',
+  'nach',
+  'blau',
+  'dran',
+  'fest',
+  'fort',
+  'heim',
+  'nahe',
+  'rein',
+  'leer',
+  'hops',
+  'kurz',
+  'kahl',
+  'frei',
+  'dar',
+  'auf',
+  'bei',
+  'ein',
+  'her',
+  'tot',
+  'alt',
+  'eis',
+  'aus',
+  'hin',
+  'los',
+  'mit',
+  'vor',
+  'weg',
+  'zu',
+  'um',
+  'ab',
+  'an'
+]
+
+let suffixes = [
+  'bringen|bracht',
+  'leichen|lichen',
+  'riechen|rochen',
+  'lassen|lassen',
+  'teigen|tiegen',
+  'chauen|chaut',
+  'fahren|fahren',
+  'färben|färbt',
+  'hängen|hangen',
+  'sitzen|sessen',
+  'riegen|riegt',
+  'laufen|laufen',
+  'neiden|nitten',
+  'fallen|fallen',
+  'tragen|tragen',
+  'saufen|soffen',
+  'braten|braten',
+  'auchen|aucht',
+  'mieren|miert',
+  'reiten|ritten',
+  'gehen|gangen',
+  'alten|alten',
+  'raten|raten',
+  'ennen|annt',
+  'eißen|issen',
+  'ulden|uldet',
+  'chnen|chnet',
+  'chsen|chsen',
+  'chten|chtet',
+  'echen|ochen',
+  'immen|ommen',
+  'ehmen|ommen',
+  'eiben|ieben',
+  'eißen|issen',
+  'elzen|olzen',
+  'elfen|olfen',
+  'rufen|rufen',
+  'erben|orben',
+  'hauen|hauen',
+  'ießen|ossen',
+  'ilden|ildet',
+  'inden|unden',
+  'ingen|ungen',
+  'inken|unken',
+  'innen|onnen',
+  'lagen|lagen',
+  'ommen|ommen',
+  'achen|acht',
+  'annen|annt',
+  'assen|asst',
+  'mühen|müht',
+  'reien|rien',
+  'ählen|ählt',
+  'enden|andt',
+  'tehen|tanden',
+  'enken|acht',
+  'iegen|ogen',
+  'iehen|ogen',
+  'reden|redet',
+  'rehen|reht',
+  'reten|reten',
+  'schen|scht',
+  'sehen|sehen',
+  'toßen|toßen',
+  'ünden|ündet',
+  'ssen|ssen',
+  'tten|ttet',
+  'ören|ört',
+  'ehen|anden',
+  'dnen|dnet',
+  'eln|elt',
+  'ten|tet',
+  'ern|ert',
+].map(s => s.split('|'))
+
+export { prefixes, suffixes }

package/src/01-one/lexicon/methods/verbs/custom/toPastParticiple.js

@@ -0,0 +1,54 @@
+import { prefixes, suffixes } from './rules.js'
+const inseperable = /^(be|emp|ent|er|ge|miss|ver|zer|wiederer)/
+
+const doPrefix = function (str) {
+  if (/^auss/.test(str)) {
+    str = str.replace(/^auss/, 'ausges')
+    return str
+  }
+  if (/^ansch/.test(str)) {
+    str = str.replace(/^ansch/, 'angesch')
+    return str
+  }
+  // put a 'ge' somewhere
+  for (let i = 0; i < prefixes.length; i += 1) {
+    if (str.startsWith(prefixes[i])) {
+      return prefixes[i] + 'ge' + str.substring(prefixes[i].length)
+    }
+  }
+  if (inseperable.test(str)) {
+    // str = str.replace(/en$/, 't')
+    return str
+  }
+  // otherwse, add 'ge-'
+  if (!str.match(/^(über|unt|v|au|miß)/)) {
+    str = 'ge' + str
+  }
+  return str
+}
+
+const doSuffix = function (str) {
+  for (let i = 0; i < suffixes.length; i += 1) {
+    let [from, to] = suffixes[i]
+    if (str.endsWith(from)) {
+      return str.substring(0, str.length - from.length) + to
+    }
+  }
+  str = str.replace(/en$/, 't')
+  return str
+}
+
+// this one is strange, and doesn't compress well
+const toPastParticiple = function (str) {
+  // always weak
+  if (str.endsWith('ieren')) {
+    str = str.replace(/en$/, 't')
+    return str //no 'ge-'
+  }
+  str = doSuffix(str)
+  str = doPrefix(str)
+  return str
+}
+export default toPastParticiple
+
+// console.log( toPastParticiple("schwimmen"), "geschwommen")