de-compromise 0.0.10 → 0.1.0

package/src/01-one/lexicon/methods/adjectives/_test-back.js

@@ -0,0 +1,29 @@
+/* eslint-disable no-console */
+import toRoot from './toRoot.js'
+import model from '/Users/spencer/mountain/de-compromise/data/models/adjectives/adjectives.js'
+
+// let all = []
+// let suff = ''
+
+
+const percent = (part, total) => {
+  let num = (part / total) * 100;
+  num = Math.round(num * 10) / 10;
+  return num;
+};
+
+
+let correct = 0
+let total = 0
+Object.keys(model).forEach(inf => {
+  model[inf].forEach(str => {
+    let have = toRoot(str)
+    total += 1
+    if (have === inf) {
+      correct += 1
+    } else {
+      console.log(inf, have)
+    }
+  })
+})
+console.log(percent(correct, total))

package/src/01-one/lexicon/methods/adjectives/_test.js

@@ -0,0 +1,49 @@
+/* eslint-disable no-console */
+import model from '/Users/spencer/mountain/de-compromise/data/models/adjectives/adjectives.js'
+import convert from './inflect.js'
+
+let all = []
+let suff = ''
+
+
+const percent = (part, total) => {
+  let num = (part / total) * 100;
+  num = Math.round(num * 10) / 10;
+  return num;
+};
+
+// 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))
+// }
+
+
+
+let tests = [
+  { prop: 'one', n: 0 },
+  { prop: 'two', n: 1 },
+  { prop: 'three', n: 2 },
+  { prop: 'four', n: 3 },
+]
+tests.forEach(obj => {
+  let good = 0
+  Object.keys(model).forEach(inf => {
+    let have = convert(inf)[obj.prop]
+    if (have === model[inf][obj.n]) {
+      good += 1
+    } else {
+      if (inf.endsWith(suff)) {
+        all.push(inf.substring(inf.length - (suff.length + 1)))
+        // console.log(inf.padEnd(12), model[inf][n])
+        //   console.log(inf, model[inf][0], have,)
+      }
+    }
+  })
+  console.log(obj.prop, percent(good, Object.keys(model).length))
+})
+// console.log(topk(all))

package/src/01-one/lexicon/methods/adjectives/inflect.js

@@ -0,0 +1,27 @@
+import model from './model.js'
+
+const inflectAdj = function (inf) {
+  const keys = Object.keys(model)
+  for (let i = 0; i < keys.length; i += 1) {
+    let suff = keys[i]
+    if (inf.endsWith(suff)) {
+      return {
+        one: inf + model[suff][0],
+        two: inf + model[suff][1],
+        three: inf + model[suff][2],
+        four: inf + model[suff][3],
+      }
+    }
+  }
+  return {
+    one: inf + 'er',
+    two: inf + 'en',
+    three: inf + 'e',
+    four: inf + 'es',
+  }
+}
+export default inflectAdj
+
+// console.log(inflectAdj('skandalös'))
+
+

package/src/01-one/lexicon/methods/adjectives/model.js

@@ -0,0 +1,126 @@
+// greedy adjective suffixes 
+// learned from spencermountain/suffix-thumb @ March 2023
+const r = 'ster'
+const n = 'sten'
+const e = 'ste'
+const s = 'stes'
+
+export default {
+  'böse': [r, n, e, s],
+  chener: ['erer', 'eren', 'ere', 'eres'],
+  agisch: [r, n, e, s],
+  ppisch: [r, n, e, s],
+  ragend: [r, n, e, s],
+  idisch: [r, n, e, s],
+  ichbar: [r, n, e, s],
+  eladen: [r, n, e, s],
+  ietend: [r, n, e, s],
+  orativ: [r, n, e, s],
+  ankbar: [r, n, e, s],
+  'übisch': [r, n, e, s],
+  lgisch: [r, n, e, s],
+  fangen: [r, n, e, s],
+  yrisch: [r, n, e, s],
+  nkisch: [r, n, e, s],
+  rrisch: [r, n, e, s],
+  llisch: [r, n, e, s],
+  ichend: [r, n, e, s],
+  gerade: ['r', 'n', '', 's'],
+  ragbar: [r, n, e, s],
+  ellbar: [r, n, e, s],
+  assend: [r, n, e, s],
+  ypisch: [r, n, e, s],
+  otisch: [r, n, e, s],
+  thisch: [r, n, e, s],
+  iebend: [r, n, e, s],
+  tional: [r, n, e, s],
+  regend: [r, n, e, s],
+  erisch: [r, n, e, s],
+  hener: ['erer', 'eren', 'ere', 'eres'],
+  ocken: [r, n, e, s],
+  iisch: [r, n, e, s],
+  htern: [r, n, e, s],
+  stern: [r, n, e, s],
+  egial: [r, n, e, s],
+  abend: [r, n, e, s],
+  ifend: [r, n, e, s],
+  efend: [r, n, e, s],
+  nitiv: [r, n, e, s],
+  nnend: [r, n, e, s],
+  vativ: [r, n, e, s],
+  erade: ['r', 'n', '', 's'],
+  igend: [r, n, e, s],
+  iden: [r, n, e, s],
+  stiv: [r, n, e, s],
+  mein: [r, n, e, s],
+  ubar: [r, n, e, s],
+  ikal: [r, n, e, s],
+  zend: [r, n, e, s],
+  rade: ['r', 'n', '', 's'],
+  gnet: [r, n, e, s],
+  tral: [r, n, e, s],
+  fbar: [r, n, e, s],
+  rmal: [r, n, e, s],
+  eden: [r, n, e, s],
+  hren: [r, n, e, s],
+  'ßbar': [r, n, e, s],
+  zbar: [r, n, e, s],
+  chen: [r, n, e, s],
+  ogen: [r, n, e, s],
+  nbar: [r, n, e, s],
+  egen: [r, n, e, s],
+  rsch: [r, n, e, s],
+  tbar: [r, n, e, s],
+  rbar: [r, n, e, s],
+  ktiv: [r, n, e, s],
+  'öse': [r, n, e, s],
+  eal: [r, n, e, s],
+  ade: ['r', 'n', '', 's'],
+  men: [r, n, e, s],
+  ten: [r, n, e, s],
+  sen: [r, n, e, s],
+  siv: [r, n, e, s],
+  ich: [r, n, e, s],
+  'üm': [r, n, e, s],
+  'än': [r, n, e, s],
+  xy: [r, n, e, s],
+  'ül': [r, n, e, s],
+  uh: [r, n, e, s],
+  be: [r, n, e, s],
+  pf: [r, n, e, s],
+  of: [r, n, e, s],
+  ic: [r, n, e, s],
+  he: ['r', 'n', '', 's'],
+  om: [r, n, e, s],
+  ik: [r, n, e, s],
+  ym: [r, n, e, s],
+  ff: [r, n, e, s],
+  'üb': [r, n, e, s],
+  hn: [r, n, e, s],
+  pp: [r, n, e, s],
+  ir: [r, n, e, s],
+  av: [r, n, e, s],
+  im: [r, n, e, s],
+  rb: [r, n, e, s],
+  ge: [r, n, e, s],
+  ul: [r, n, e, s],
+  rr: [r, n, e, s],
+  em: [r, n, e, s],
+  ck: [r, n, e, s],
+  'ön': [r, n, e, s],
+  hm: [r, n, e, s],
+  te: ['r', 'n', '', 's'],
+  hl: [r, n, e, s],
+  mm: [r, n, e, s],
+  au: [r, n, e, s],
+  if: [r, n, e, s],
+  eu: [r, n, e, s],
+  de: [r, n, e, s],
+  il: [r, n, e, s],
+  se: ['r', 'n', '', 's'],
+  'är': [r, n, e, s],
+  am: [r, n, e, s],
+  er: [r, n, e, s],
+  ll: [r, n, e, s],
+  ig: [r, n, e, s]
+}

package/src/01-one/lexicon/methods/adjectives/new/adjective.js

@@ -0,0 +1,8 @@
+/* eslint-disable no-unused-vars */
+let models = [
+  { fallback: 'er', rules: [['e', 'er']] },
+  { fallback: 'en', rules: [['e', 'en']] },
+  { fallback: 'e', rules: [['e', 'e']] },
+  { fallback: 'es', rules: [['e', 'es']] }
+
+]

package/src/01-one/lexicon/methods/adjectives/new/comparative.js

@@ -0,0 +1,7 @@
+/* eslint-disable no-unused-vars */
+let models = [
+  { fallback: 'erer', rules: [['e', 'erer']] },
+  { fallback: 'eren', rules: [['e', 'eren']] },
+  { fallback: 'ere', rules: [['e', 'ere']] },
+  { fallback: 'eres', rules: [['e', 'eres']] }
+]

package/src/01-one/lexicon/methods/adjectives/new/superlative.js

@@ -0,0 +1,159 @@
+/* eslint-disable no-unused-vars */
+let models = [
+  {
+    fallback: 'ster',
+    rules: [
+      ['eerend', 'eerendester'],
+      ['morsch', 'morschester'],
+      ['öchern', 'öchernester'],
+      ['behend', 'behendester'],
+      ['sscheu', 'sscheuester'],
+      ['elend', 'elendester'],
+      ['tsch', 'tschester'],
+      ['grau', 'grauester'],
+      ['lsch', 'lschester'],
+      ['pur', 'purester'],
+      ['ind', 'indester'],
+      ['änd', 'ändester'],
+      ['ond', 'ondester'],
+      ['und', 'undester'],
+      ['äh', 'ähester'],
+      ['mp', 'mpester'],
+      ['sk', 'skester'],
+      ['üh', 'ühester'],
+      ['ad', 'adester'],
+      ['rd', 'rdester'],
+      ['äß', 'äßester'],
+      ['öd', 'ödester'],
+      ['üß', 'üßester'],
+      ['md', 'mdester'],
+      ['ld', 'ldester'],
+      ['iß', 'ißester'],
+      ['oh', 'ohester'],
+      ['id', 'idester'],
+      ['nk', 'nkester'],
+      ['z', 'zester'],
+      ['x', 'xester'],
+      ['i', 'iester'],
+      ['s', 'sester'],
+      ['t', 'tester']
+    ]
+  },
+  {
+    fallback: 'sten',
+    rules: [
+      ['eerend', 'eerendesten'],
+      ['morsch', 'morschesten'],
+      ['öchern', 'öchernesten'],
+      ['behend', 'behendesten'],
+      ['sscheu', 'sscheuesten'],
+      ['elend', 'elendesten'],
+      ['tsch', 'tschesten'],
+      ['grau', 'grauesten'],
+      ['lsch', 'lschesten'],
+      ['pur', 'puresten'],
+      ['ind', 'indesten'],
+      ['änd', 'ändesten'],
+      ['ond', 'ondesten'],
+      ['und', 'undesten'],
+      ['äh', 'ähesten'],
+      ['mp', 'mpesten'],
+      ['sk', 'skesten'],
+      ['üh', 'ühesten'],
+      ['ad', 'adesten'],
+      ['rd', 'rdesten'],
+      ['äß', 'äßesten'],
+      ['öd', 'ödesten'],
+      ['üß', 'üßesten'],
+      ['md', 'mdesten'],
+      ['ld', 'ldesten'],
+      ['iß', 'ißesten'],
+      ['oh', 'ohesten'],
+      ['id', 'idesten'],
+      ['nk', 'nkesten'],
+      ['z', 'zesten'],
+      ['x', 'xesten'],
+      ['i', 'iesten'],
+      ['s', 'sesten'],
+      ['t', 'testen']
+    ]
+  },
+  {
+    fallback: 'ste',
+    rules: [
+      ['eerend', 'eerendeste'],
+      ['morsch', 'morscheste'],
+      ['öchern', 'öcherneste'],
+      ['behend', 'behendeste'],
+      ['sscheu', 'sscheueste'],
+      ['elend', 'elendeste'],
+      ['tsch', 'tscheste'],
+      ['grau', 'graueste'],
+      ['lsch', 'lscheste'],
+      ['pur', 'pureste'],
+      ['ind', 'indeste'],
+      ['änd', 'ändeste'],
+      ['ond', 'ondeste'],
+      ['und', 'undeste'],
+      ['äh', 'äheste'],
+      ['mp', 'mpeste'],
+      ['sk', 'skeste'],
+      ['üh', 'üheste'],
+      ['ad', 'adeste'],
+      ['rd', 'rdeste'],
+      ['äß', 'äßeste'],
+      ['öd', 'ödeste'],
+      ['üß', 'üßeste'],
+      ['md', 'mdeste'],
+      ['ld', 'ldeste'],
+      ['iß', 'ißeste'],
+      ['oh', 'oheste'],
+      ['id', 'ideste'],
+      ['nk', 'nkeste'],
+      ['z', 'zeste'],
+      ['x', 'xeste'],
+      ['i', 'ieste'],
+      ['s', 'seste'],
+      ['t', 'teste']
+    ]
+  },
+  {
+    fallback: 'stes',
+    rules: [
+      ['eerend', 'eerendestes'],
+      ['morsch', 'morschestes'],
+      ['öchern', 'öchernestes'],
+      ['behend', 'behendestes'],
+      ['sscheu', 'sscheuestes'],
+      ['elend', 'elendestes'],
+      ['tsch', 'tschestes'],
+      ['grau', 'grauestes'],
+      ['lsch', 'lschestes'],
+      ['pur', 'purestes'],
+      ['ind', 'indestes'],
+      ['änd', 'ändestes'],
+      ['ond', 'ondestes'],
+      ['und', 'undestes'],
+      ['äh', 'ähestes'],
+      ['mp', 'mpestes'],
+      ['sk', 'skestes'],
+      ['üh', 'ühestes'],
+      ['ad', 'adestes'],
+      ['rd', 'rdestes'],
+      ['äß', 'äßestes'],
+      ['öd', 'ödestes'],
+      ['üß', 'üßestes'],
+      ['md', 'mdestes'],
+      ['ld', 'ldestes'],
+      ['iß', 'ißestes'],
+      ['oh', 'ohestes'],
+      ['id', 'idestes'],
+      ['nk', 'nkestes'],
+      ['z', 'zestes'],
+      ['x', 'xestes'],
+      ['i', 'iestes'],
+      ['s', 'sestes'],
+      ['t', 'testes']
+    ]
+  }
+]

package/src/01-one/lexicon/methods/adjectives/toRoot.js

@@ -0,0 +1,47 @@
+const abel = /able[rns]$/
+const auer = /aure[rns]$/
+const usst = /sste[rns]$/
+const wisse = /wisse[rns]$/
+const weise = /weise[rns]$/
+
+const suffixes = [
+  'ester',
+  'esten',
+  'estes',
+  'este',
+  'ster',
+  'sten',
+  'stes',
+  'ste',
+  'er',
+  'en',
+  'es',
+  'e',
+]
+
+const toRoot = function (str) {
+  if (abel.test(str)) {
+    return str.replace(abel, 'abel')
+  }
+  if (auer.test(str)) {
+    return str.replace(auer, 'auer')
+  }
+  if (usst.test(str)) {
+    return str.replace(usst, 'usst')
+  }
+  if (wisse.test(str)) {
+    return str.replace(wisse, 'wiß')
+  }
+  if (weise.test(str)) {
+    return str.replace(weise, 'weise')
+  }
+  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 toRoot
+// console.log(toRoot('saurerer'))

package/src/01-one/lexicon/methods/index.js

@@ -0,0 +1,56 @@
+import {
+  all,
+  toPresent,
+  toPast,
+  toSubjunctive1,
+  toSubjunctive2,
+  toImperative,
+  toPastParticiple,
+  toPresentParticiple
+} from './verbs/conjugate.js'
+import {
+  fromPresent,
+  fromPast,
+  fromSubjunctive1,
+  fromSubjunctive2,
+  fromImperative,
+  fromPresentParticiple,
+  fromPastParticiple
+} from './verbs/toRoot.js'
+import inflectAdj from './adjectives/inflect.js'
+import adjToRoot from './adjectives/toRoot.js'
+import toPlural from './nouns/toPlural.js'
+import toSingular from './nouns/toSingular.js'
+
+const allAdj = (inf) => Object.values(inflectAdj(inf))
+const allNoun = (sing) => [sing, toPlural(sing).one]
+
+export default {
+  verb: {
+    all,
+    toPresent,
+    toPast,
+    toSubjunctive1,
+    toSubjunctive2,
+    toImperative,
+    toPastParticiple,
+    toPresentParticiple,
+    fromPresent,
+    fromPast,
+    fromSubjunctive1,
+    fromSubjunctive2,
+    fromImperative,
+    fromPresentParticiple,
+    fromPastParticiple
+  },
+  adjective: {
+    inflect: inflectAdj,
+    toRoot: adjToRoot,
+    all: allAdj
+  },
+  noun: {
+    toPlural,
+    toSingular,
+    all: allNoun
+  }
+}

package/src/01-one/lexicon/methods/models.js

@@ -0,0 +1,10 @@
+import { uncompress } from 'suffix-thumb'
+import model from './_data.js'
+
+// uncompress them
+Object.keys(model).forEach(k => {
+  Object.keys(model[k]).forEach(form => {
+    model[k][form] = uncompress(model[k][form])
+  })
+})
+export default model

package/src/01-one/lexicon/methods/nouns/_test-back.js

@@ -0,0 +1,45 @@
+/* eslint-disable no-console, no-unused-vars */
+import toRoot from './toRoot.js'
+import model from '/Users/spencer/mountain/de-compromise/data/models/nouns.js'
+
+let all = []
+let suff = ''
+
+
+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;
+};
+
+
+let ends = []
+let correct = 0
+let total = 0
+Object.keys(model).forEach(inf => {
+  model[inf].s.forEach(str => {
+    let have = toRoot(str)
+    total += 1
+    if (have === inf) {
+      correct += 1
+    } else {
+      ends.push(str.substring(str.length - 4, str.length))
+      if (str.endsWith('ist')) {
+
+        console.log(inf, str, have)
+      }
+    }
+  })
+})
+console.log(percent(correct, total))
+console.log(topk(ends))

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

@@ -0,0 +1,56 @@
+/* eslint-disable no-unused-vars */
+let models = [
+  {
+    fallback: 'n',
+    rules: [
+      ['en', 'en'], ['é', 'és'],
+      ['c', 'cs'], ['w', 'ws'],
+      ['v', 've'], ['y', 'ys'],
+      ['u', 'uen'], ['b', 'be'],
+      ['p', 'ps'], ['z', 'zen'],
+      ['o', 'os'], ['a', 'as'],
+      ['f', 'fe'], ['s', 'se'],
+      ['i', 'ien'], ['m', 'me'],
+      ['k', 'ke'], ['h', 'he'],
+      ['d', 'de'], ['l', 'l'],
+      ['g', 'gen'], ['t', 'ten'],
+      ['r', 'r'], ['n', 'nnen']
+    ]
+  },
+  {
+    fallback: 'n',
+    rules: [
+      ['en', 'ens'], ['é', 'és'],
+      ['c', 'cs'], ['w', 'ws'],
+      ['x', 'x'], ['v', 'vs'],
+      ['y', 'ys'], ['u', 'u'],
+      ['b', 'bs'], ['p', 'ps'],
+      ['z', 'z'], ['o', 'os'],
+      ['a', 'a'], ['f', 'fs'],
+      ['s', 's'], ['i', 'i'],
+      ['m', 'ms'], ['k', 'ks'],
+      ['h', 'hs'], ['d', 'ds'],
+      ['l', 'ls'], ['g', 'g'],
+      ['t', 'ts'], ['r', 'rs'],
+      ['n', 'n']
+    ]
+  },
+  {
+    fallback: 'n',
+    rules: [
+      ['nt', 'nten'], ['é', 'é'],
+      ['c', 'c'], ['w', 'w'],
+      ['x', 'x'], ['v', 've'],
+      ['y', 'y'], ['u', 'u'],
+      ['b', 'be'], ['p', 'p'],
+      ['ß', 'ß'], ['z', 'z'],
+      ['o', 'o'], ['a', 'a'],
+      ['f', 'fe'], ['s', 's'],
+      ['i', 'i'], ['m', 'me'],
+      ['k', 'ke'], ['h', 'he'],
+      ['d', 'de'], ['l', 'l'],
+      ['g', 'g'], ['t', 'te'],
+      ['r', 'r'], ['n', 'n']
+    ]
+  },
+]

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

@@ -0,0 +1,49 @@
+import { convert } from 'suffix-thumb'
+import model from '../models.js'
+
+// fallback rules, when no trained model is available
+let rules = [
+  ['ein', ''],
+  ['cht', 'e'],
+  ['ll', 'e'],
+  ['is', 'se'],
+  ['kt', 'e'],
+  ['tt', 'e'],
+  ['rt', 'e'],
+  ['ur', 'en'],
+  ['ck', 'e'],
+  ['at', 'e'],
+  ['ft', 'en'],
+  ['nd', 'e'],
+  ['ei', 'en'],
+  ['or', 'en'],
+  ['ch', 'e'],
+  ['it', 'en'],
+  ['st', 'en'],
+  ['nt', 'en'],
+  ['el', ''],
+  ['on', 'en'],
+  ['en', ''],
+  ['ng', 'en'],
+  ['in', 'nen'],
+  ['er', '']
+]
+
+const firstForm = function (str) {
+  if (model.nouns && model.nouns.plural) {
+    return convert(str, model.nouns.plural)
+  }
+  for (let i = 0; i < rules.length; i += 1) {
+    let [from, to] = rules[i]
+    if (str.endsWith(from)) {
+      return str + to
+    }
+  }
+  return str + 'n'
+}
+const toPlural = function (str) {
+  return {
+    one: firstForm(str)
+  }
+}
+export default toPlural