application setup from morphilo

Morphochron/.classpath

+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-16">
+		<attributes>
+			<attribute name="module" value="true"/>
+		</attributes>
+	</classpathentry>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

Morphochron/.gitignore

+/bin/

Morphochron/.project

+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>Morphochron</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

Morphochron/.settings/org.eclipse.jdt.core.prefs

+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=16
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=16
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enablePreviewFeatures=disabled
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.reportPreviewFeatures=warning
+org.eclipse.jdt.core.compiler.release=enabled
+org.eclipse.jdt.core.compiler.source=16

Morphochron/src/AffixStripper.java

+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.HashMap;
+import java.util.TreeMap;
+
+
+public class AffixStripper {
+	
+	private int prefixNumber = 0;
+	private int suffixNumber = 0;
+	private int stemNumber = 0;
+	private String inflection = "";
+	private String lemma = "";
+	private String compoundType = "";
+	private String wordclass = "";
+	private String corpusName = "";
+	private String corpusBegin = "";
+	private String corpusEnd = "";
+	private String wordtoken = "";
+	private ArrayList<String> suffix = new ArrayList<String>();
+	private ArrayList<String> prefix = new ArrayList<String>();
+	private ArrayList<String> wordroot = new ArrayList<String>();
+	private ArrayList<String> wordbase = new ArrayList<String>();
+	private ArrayList<String> wordclassStem = new ArrayList<String>();
+	private ArrayList<String> prefixAllomorph = new ArrayList<String>();
+	private ArrayList<String> suffixAllomorph = new ArrayList<String>();
+	private Map<String, Integer> prefixMorpheme = new HashMap<String,Integer>();
+	private Map<String, Integer> suffixMorpheme = new HashMap<String,Integer>();
+	private Map<String, Integer> wordstem = new HashMap<String,Integer>();
+	
+	/*
+	 * Constructor calls analyze-method which initiates
+	 */
+	public AffixStripper(String w)
+	{
+		this.wordtoken = w;
+		analyzeWord();
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getSuffix()
+	{
+		return suffix;
+	}
+	
+	/*
+	 * 
+	 */
+	private int getPrefixNumber()
+	{
+		return prefixNumber;
+	}
+	
+	/*
+	 * 
+	 */
+	private int getSuffixNumber()
+	{
+		return suffixNumber;
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getPrefix()
+	{
+		return prefix;
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getBase()
+	{
+		return wordbase;
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getRoot()
+	{
+		return wordroot;
+	}
+	
+	/*
+	 * a word with several stems is a compound
+	 */
+	private int getStemNumber()
+	{
+		//TODO: code for guessing stemNumber
+		stemNumber = 1;
+		return stemNumber;
+	}
+	
+	/*
+	 * 
+	 */
+	private Map<String,Integer> getStem()
+	{
+		return wordstem;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getLemma()
+	{
+		//TODO: Einbinden der OED API ?
+		// bis dahin gilt Vereinfachung lemma = word - flexion
+		return lemma;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getCompositumType()
+	{
+		//TODO: derzeit noch ungeloestes Problem in NLP
+		return compoundType;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getWordClass()
+	{
+		//TODO: Einbindung eines Taggers
+		return wordclass;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getCorpusName()
+	{
+		// Wird aus Effizienzgruenden in JDOMorphilo eingefuegt
+		return corpusName;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getCorpusBegin()
+	{
+		// Wird aus Effizienzgruenden in JDOMorphilo eingefuegt
+		return corpusBegin;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getCorpusEnd()
+	{
+		// Wird aus Effizienzgruenden in JDOMorphilo eingefuegt
+		return corpusEnd;
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getWordClassStem()
+	{
+		return wordclassStem;
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getPrefixAllomorph()
+	{
+		return prefixAllomorph;
+	}
+	
+	/*
+	 * 
+	 */
+	public Map<String, Integer> getPrefixMorphem()
+	{
+		return prefixMorpheme;
+	}
+	
+	/*
+	 * 
+	 */
+	public ArrayList<String> getSuffixAllomorph()
+	{
+		return suffixAllomorph;
+	}
+	
+	/*
+	 * 
+	 */
+	public Map<String, Integer> getSuffixMorphem()
+	{
+		return suffixMorpheme;
+	}
+	
+	/*
+	 * 
+	 */
+	public String getInflection()
+	{
+		return inflection;
+	}
+	
+	/*
+	 * 
+	 */
+	private void analyzeWord()
+	{
+		//analyze inflection first because it always occurs at the end of a word
+		inflection = analyzeInflection(wordtoken);
+		lemma = analyzeLemma(wordtoken, inflection);
+		analyzePrefix(lemma);
+		analyzeSuffix(lemma);
+		getAffixPosition(sortOutAffixes(prefixMorpheme), lemma, 0, "prefix");
+		getAffixPosition(sortOutAffixes(suffixMorpheme), lemma, 0, "suffix");
+		prefixNumber = prefixMorpheme.size();
+		suffixNumber = suffixMorpheme.size();
+		wordroot = analyzeRoot(prefixMorpheme, suffixMorpheme, getStemNumber());
+	}
+	
+	/* 
+	 * 
+	 */
+	private String analyzeInflection(String wrd)
+	{
+		String infl = "";
+		for (InflectionEnum inflEnum : InflectionEnum.values()) 
+		{
+            if (wrd.endsWith(inflEnum.toString())) {
+                infl = inflEnum.toString();
+                //wordtoken = wordtoken.substring(0, wordtoken.length() - inflEnum.toString().length());
+            }
+        }
+		return infl;
+	}
+	
+	/*
+	 * Simplification: lemma = wordtoken - inflection
+	 */
+	private String analyzeLemma(String wrd, String infl)
+	{
+		wrd = wrd.substring(0, wrd.length() - infl.length());
+		return wrd;
+	}
+	
+	/*
+	 * 
+	 */
+	private ArrayList<String> analyzeRoot(Map<String, Integer> pref, Map<String, Integer> suf, int stemNumber)
+	{
+		ArrayList<String> root = new ArrayList<String>();
+		int j = 1; //one root always exists
+		// if word is a compound several roots exist
+		while (j <= stemNumber)
+		{
+			j++;
+			String rest = lemma;
+			
+			for (int i=0;i<pref.size();i++)
+			{
+				for (String s : pref.keySet())
+				{
+					//if (i == pref.get(s))
+					if (rest.length() > s.length() && s.equals(rest.substring(0, s.length())))
+					{
+						rest = rest.substring(s.length(),rest.length());
+
+					}
+				}
+			}
+			
+			for (int i=0;i<suf.size();i++)
+			{
+				for (String s : suf.keySet())
+				{
+					//if (i == suf.get(s))
+					if (s.length() < rest.length() && (s.equals(rest.substring(rest.length() - s.length(), rest.length()))))
+					{
+						rest = rest.substring(0, rest.length() - s.length());
+					}
+				}
+			}
+			root.add(rest);
+		}
+		return root;
+	}
+	
+	/*
+	 * makes reasonable assumptions on affix tokens based on length
+	 * i.e. if a substring is contained in any other substring,
+	 * it will be deleted from the hashmap
+	 */
+	private Map<String, Integer> sortOutAffixes(Map<String, Integer> affix)
+	{
+		Map<String,Integer> sortedByLengthMap = new TreeMap<String, Integer>(
+                new Comparator<String>() {
+                    @Override
+                    public int compare(String s1, String s2) {
+                        int cmp = Integer.compare(s1.length(), s2.length());
+                        return cmp != 0 ? cmp : s1.compareTo(s2);
+                    }
+                }
+        );
+		sortedByLengthMap.putAll(affix);
+		ArrayList<String> al1 = new ArrayList<String>(sortedByLengthMap.keySet());
+		ArrayList<String> al2 = al1;
+		Collections.reverse(al2);
+		for (String s2 : al1)
+		{
+			for (String s1 : al2)
+			if (s1.contains(s2) && s1.length() > s2.length())
+			{
+				affix.remove(s2);
+			}
+		}
+		return affix;
+	}
+	
+	/*
+	 * 
+	 */
+	private void getAffixPosition(Map<String, Integer> affix, String restword, int pos, String affixtype)
+	{
+		if (!restword.isEmpty()) //Abbruchbedingung fuer Rekursion
+		{
+			for (String s : affix.keySet())
+			{
+				if (restword.startsWith(s) && affixtype.equals("prefix"))
+				{
+					pos++;
+					prefixMorpheme.put(s, pos);
+					//prefixAllomorph.add(pos-1, restword.substring(s.length()));
+					getAffixPosition(affix, restword.substring(s.length()), pos, affixtype);
+				}
+				else if (restword.endsWith(s) && affixtype.equals("suffix"))
+				{
+					pos++;
+					suffixMorpheme.put(s, pos);
+					//suffixAllomorph.add(pos-1, restword.substring(s.length()));
+					getAffixPosition(affix, restword.substring(0, restword.length() - s.length()), pos, affixtype);
+				}	
+				else
+				{
+					getAffixPosition(affix, "", pos, affixtype);
+				}
+			}
+		}
+	}
+	
+	/*
+	 * 
+	 */
+	private void analyzePrefix(String restword)
+	{
+		if (!restword.isEmpty()) //Abbruchbedingung fuer Rekursion
+		{
+			for (PrefixEnum prefEnum : PrefixEnum.values())
+			{
+				String s = prefEnum.toString();
+				if (restword.startsWith(s))
+				{
+					prefixMorpheme.put(s, prefixMorpheme.size() + 1);
+					//cut off the prefix that is added to the list
+					analyzePrefix(restword.substring(s.length()));
+				}
+				else
+				{
+					analyzePrefix("");
+				}
+			}
+		}
+	}
+	
+	/*
+	 * 
+	 */
+	private void analyzeSuffix(String restword)
+	{
+		if (!restword.isEmpty()) //Abbruchbedingung fuer Rekursion
+		{
+			
+			for (SuffixEnum sufEnum : SuffixEnum.values())
+			{
+				String s = sufEnum.toString();
+				if (restword.endsWith(s))
+				{
+					suffixMorpheme.put(s, suffixMorpheme.size() + 1);
+					//suffixAllomorph.add(0, restword.substring(sufEnum.toString().length()));
+					//cut off the suffix that is added to the list
+					analyzeSuffix(restword.substring(0, restword.length() - s.length()));
+				}
+				else
+				{
+					analyzeSuffix("");
+				}
+			}
+		}	
+	}
+	
+}
+

Morphochron/src/InflectionEnum.java

+
+public enum InflectionEnum 
+{	
+	ies("Plural"), es("Plural"), en("Plural"), s("Possessiv"),
+	inde("Progressive"), ende("Progressive"), and("Progressive"), ing("Progressive"), 
+	eth("ThirdPerson"), est("Superlativ"), er("Komparativ"),
+	ed("PastTense");
+	
+	private String inflection;
+	
+    //constructor
+    InflectionEnum(String inflection) 
+    {
+        this.inflection = inflection;
+    }
+    
+    //getter Method
+    public String getInflection() 
+    {
+        return this.inflection;
+    }
+
+}
+

Morphochron/src/Init.java

+
+public class Init {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		System.out.println("Hello World!");
+		
+	}
+
+}

Morphochron/src/Measure.java

+
+public class Measure {
+
+}

Morphochron/src/PrefixEnum.java

+
+/**
+ *
+ * @author peukert
+ */
+public enum PrefixEnum {
+
+    a("a"), ab("ab"), abb("ab"), ac("ac"), ad("ad"), ae("ae"),
+    after("after"), ag("ag"), al("al"), ambi("ambi"), amphi("amphi"),
+    an("an"), ana("ana"), and("and"), ond("and"),
+    ano("ano"), ant("ant"), ante("ante"), anti("anti"), ap("ap"), aph("aph"),
+    apo("apo"), ar("ar"), arch("arch"), archi("archi"), as("as"), at("at"),
+    avaunt("avaunt"), auaunt("avaunt"), auant("avaunt"), avant("avaunt"),
+    awant("avaunt"), be("be"), bes("bes"), bi("bi"), bin("bin"), cata("cata"),
+    cat("cata"), cath("cata"), circum("circum"), cis("cis"), citra("citra"),
+    co("co"), com("com"), con("con"), contra("contra"), contre("contra"),
+    cor("cor"), counter("contra"), de("de"), demi("demi"), des("des"), di("di"),
+    dia("dia"), dif("dif"), dis("dis"), dys("dis"), disen("dis"), disem("dis"),
+    e("e"), ed("ed"), ef("ef"), em("em"), en("en"), endo("endo"), enter("enter"),
+    entre("enter"), ento("ento"), ep("ep"), epana("epana"), epi("epi"), es("es"),
+    eso("eso"), ex("ex"), exo("exo"), extra("extra"), extro("extro"), For("for"),
+    faer("for"), forr("for"), vor("for"), ver("for"), fur("for"), fore("for"),
+    gain("gain"), hemi("hemi"), semi("semi"), semy("semi"), seme("semi"), semie("semie"),
+    hyp("hyper"), hyper("hyper"), hypo("hyper"), hytero("hytero"), hyster("hytero"),
+    y("y"), i("y"), ge("y"), il("il"), im("im"), in("in"), infra("infra"), inter("inter"),
+    intra("intra"), intro("intro"), iodoso("iodoso"), ir("ir"), juxta("juxta"),
+    kata("kata"), ker("ker"), ke("ker"), ca("ker"), ka("ker"), che("ker"), male("mal"),
+    mal("mal"), meta("meta"), mis("mis"), mys("mis"), miss("mis"), mais("mis"),
+    mies("mis"), mise("mis"), mus("mis"), mes("mis"), myse("mis"), myss("mis"),
+    misse("mis"), mysse("mis"), misz("mis"), mysz("mis"), miz("mis"), mays("mis"),
+    meos("mis"), mess("mis"), messe("mis"), non("non"), nom("non"), nonn("non"),
+    nooun("non"), nown("non"), noon("non"), noun("non"), nowne("non"), none("non"),
+    nor("nor"), ob("ob"), of("of"), off("of"), af("of"), aff("of"), on("on"), o("on"),
+    onn("on"), one("on"), or("or"), ore("or"), orr("or"), out("out"), over("over"),
+    ufer("over"), ufor("over"), uferr("over"), uvver("over"), obaer("over"), ober("over)"),
+    ofaer("over"), ofere("over"), ofir("over"), ofor("over"), ofer("over"), ouer("over"),
+    oferr("over"), offerr("over"), offr("over"), aure("over"), war("over"), euer("over"),
+    oferre("over"), oouer("over"), oger("over"), ouere("over"), ouir("over"), ouire("over"),
+    ouur("over"), ouver("over"), ouyr("over"), ovar("over"), overe("over"), ovre("over"),
+    ovur("over"), owuere("over"), owver("over"), houyr("over"), ouyre("over"), ovir("over"),
+    ovyr("over"), hover("over"), auver("over"), awver("over"), ovver("over"), hauver("over"),
+    ova("over"), ove("over"), obuh("over"), ovah("over"), ovuh("over"), ofowr("over"),
+    ouuer("over"), oure("over"), owere("over"), owr("over"), owre("over"), owur("over"),
+    owyr("over"), our("over"), ower("over"), oher("over"), ooer("over"), oor("over"),
+    owwer("over"), ovr("over"), owir("over"), oar("over"), aur("over"), oer("over"),
+    ufara("over"), ufera("over"), ufere("over"), uferra("over"), ufora("over"), ufore("over"),
+    ufra("over"), ufre("over"), ufyrra("over"), yfera("over"), yfere("over"), yferra("over"),
+    uuera("over"), ufe("over"), uferre("over"), uuer("over"), uuere("over"), vfere("over"),
+    vuer("over"), vuere("over"), vver("over"), uvvor("over"), para("para"), par("para"),
+    pene("pene"), paene("pene"), pen("pene"), per("per"), pre("pre"), prae("pre"),
+    peri("peri"), post("post"), preter("preter"), praeter("preter"), pro("pro"),
+    pur("pur"), re("re"), retro("retro"), sam("sam"), se("se"), self("self"), sous("sous"),
+    south("south"), sub("sub"), subter("subter"), Super("super"), supra("supra"), sur("sur"),
+    sursum("sursum"), sym("sym"), syn("syn"), to("to"), trans("trans"), tres("tres"),
+    ultra("ultra"), um("um"), umb("umb"), umbe("umb"), ummbe("umb"), vmbe("umb"),
+    vnbe("umb"), unbe("umb"), wmbe("umb"), ombe("umb"), vnbi("umb"), vmbi("umb"),
+    vmby("umb"), unby("umb"), onby("umb"), under("under"), up("up"), ur("ur"),
+    vant("vant"), vaunt("vant"), vice("vice"), wan("wan"), with("with"), wither("wither"),
+    gae("y"), gi("y"), gie("y"), gy("y"), ie("y"), hi("y");
+
+    private String morpheme;
+
+    //constructor
+    PrefixEnum(String morpheme) {
+        this.morpheme = morpheme;
+    }
+    //getter Method
+
+    public String getMorpheme() {
+        return this.morpheme;
+    }
+}
+

Morphochron/src/StringLengthComparator.java

+
+import java.util.Comparator;
+
+public class StringLengthComparator implements Comparator<String>
+{
+
+	public int compare(String s1, String s2)
+	{
+			int i = s1.length()-s2.length();
+		    return i;
+	}
+
+}
+

Morphochron/src/SuffixEnum.java

+
+/**
+ *
+ * @author peukert
+ */
+public enum SuffixEnum {
+    //enum list contains all suffixes listed in the OED (the constant (1st) is the allomorph,
+    //the string ia the morpheme
+
+    a("a"), ability("ability"), able("able"), abelle("able"), abulle("able"), abylle("able"),
+    aibel("able"), ayble("able"), abell("able"), abil("able"), abill("able"), abille("able"),
+    abull("able"), abyl("able"), abyll("able"), abul("able"), abel("able"),
+    abile("able"), appill("able"), habel("able"), habil("able"), hable("able"),
+    ably("ably"), abily("ably"), ac("ac"), acal("acal"), acean("acean"), acious("acious"),
+    atieus("acious"), aceous("acious"), atious("acious"), acity("acity"), ad("ad"), ade("ade"),
+    adic("adic"), aemia("aemia"), age("age"), aholic("aholic"), aire("aire"), al("al"), ality("ality"),
+    ally("ally"), alty("alty"), allie("alty"), aly("alty"), allye("alty"), alye("alty"),
+    ali("alty"), alie("alty"), alliche("alty"), an("an"), ana("ana"), ance("ance"), ancy("ancy"),
+    ane("ane"), aneous("aneous"), anious("anious"), ar("ar"), ard("ard"), arian("arian"),
+    arious("arious"), arium("arium"), ary("ary"), ase("ase"), asis("asis"), at("at"), ate("ate"),
+    ated("ated"), atic("atic"), artile("artile"), ation("ation"), ative("ative"), atory("atory"),
+    ature("ature"), bility("bility"), ble("ble"), by("by"), cade("cade"), cle("cle"), cula("cula"),
+    cule("cule"), culum("culum"), culus("culus"), cy("cy"), dione("dione"), dom("dom"), dyne("dyne"),
+    ean("ean"), ee("ee"), een("een"), eer("eer"), ein("ein"), eity("eity"), el("el"), ella("ella"), elle("elle"),
+    ello("ello"), ellum("ellum"), els("els"), eme("eme"), en("en"), ence("ence"), ency("ency"), end("end"),
+    ene("ene"), ent("ent"), eous("eous"), er("er"), ergic("ergic"), erly("erly"), earn("earn"), eroo("eroo"),
+    ers("ers"), ery("ery"), esce("esce"), escence("escence"), escent("escent"), ese("ese"), esque("esque"),
+    ess("ess"), esse("ess"), est("est"), et("et"), etic("etic"), etin("etin"), etta("etta"), ette("ette"),
+    etum("etum"), ety("ety"), eur("eur"), euse("euse"), fic("fic"), fication("fication"), fied("fied"),
+    fold("fold"), ful("ful"), fy("fy"), head("head"), hod("head"), hode("head"), had("head"), hed("head"),
+    hede("head"), i("i"), ia("ia"), ial("ial"), ian("ian"), iana("iana"), iasis("iasis"), ibility("ibility"),
+    ible("ible"), ic("ic"), ical("ical"), ically("ically"), ice("ice"), ician("ician"), icidal("icidal"), icity("icity"),
+    id("ide"), idian("idian"), ide("ide"), idene("idene"), idine("idene"), idin("idene"), ie("ie"), ier("ier"),
+    iety("iety"), ification("ification"), ified("ified"), ify("ify"), il("il"), ile("il"), ild("ild"), ility("ility"),
+    illa("illa"), in("in"), ina("ina"), inae("inae"), ine("ine"), ino("ino"), ion("ion"), ior("ior"), iour("ior"), ious("ious"),
+    irane("irane"), irene("irane"), iridine("iridine"), irine("irane"), is("is"), ys("is"), ise("ise"), ish("ish"),
+    isem("ism"), ismus("ism"), ison("ison"), ist("ist"), ister("ister"), istre("ister"), istic("istic"), istical("istical"),
+    isticall("istical"), itan("itan"), itate("itate"), ite("ite"), itic("itic"), ition("ition"), itious("itious"),
+    itis("itis"), itol("itol"), itous("itous"), ity("ity"), ium("ium"), ive("ive"), ivity("ivity"), ization("ization"),
+    ize("ize"), ized("ized"), ised("ized"), izer("izer"), izing("izing"), kin("kin"), kins("kins"), laik("laik"), le("le"),
+    leche("leche"), lacan("leche"), lacean("leche"), lecan("leche"), lecean("leche"), lache("leche"), lace("leche"),
+    lachenn("leche"), leache("leche"), leage("leche"), lece("leche"), lechi("leche"), lent("lent"), less("less"),
+    let("let"), lewe("lewe"), like("like"), ling("ling"), lings("lings"), lingis("lings"), lingus("lings"), lyngs("lings"),
+    linges("lings"), lynges("lings"), lins("lings"), leens("lings"), lyngis("lings"), lynis("lings"), lyns("lings"),
+    lock("lock"), longs("long"), langes("long"), longes("long"), langis("long"), ly("ly"), lic("ly"), lich("ly"),
+    liche("ly"), lik("ly"), liz("ly"), li("ly"), lice("ly"), mans("mans"), manship("manship"), meal("meal"), maelum("meal"),
+    melum("meal"), maele("meal"), malle("meal"), meel("meal"), meele("meal"), mel("meal"), melome("meal"), male("meal"),
+    meale("meal"), mele("meal"), mente("ment"), mentt("ment"), ment("ment"), mo("mo"), mobile("mobile"), more("more"),
+    mer("more"), most("most"), mesth("most"), maest("most"), mest("most"), mst("most"), mynst("most"), mist("most"),
+    myst("most"), meste("most"), mwste("most"), myste("most"), maste("most"), muste("most"), mast("most"), moste("most"),
+    moost("most"), mooste("most"), meeast("most"), must("most"), maist("most"), mycin("mycin"), nema("nema"), neme("nema"),
+    nese("nese"), ness("ness"), nise("ness"), niss("ness"), nis("ness"), nys("ness"), nyss("ness"), nysse("ness"), nisse("ness"),
+    nes("ness"), nesse("ness"), naes("ness"), nas("ness"), nasse("ness"), nece("ness"), nesce("ness"), nesch("ness"), nessche("ness"),
+    nez("ness"), nus("ness"), nuss("ness"), nass("ness"), nss("ness"), nace("ness"), nase("ness"), nik("nik"), nic("nik"),
+    nick("nik"), oan("oan"), ock("ock"), uc("ock"), oc("ock"), ek("ock"), och("ock"), uk("ock"), oke("ock"), okke("ock"), ocke("ock"),
+    ok("ock"), uck("ock"), ecke("ock"), eck("ock"), ack("ock"), ick("ock"), ak("ock"), og("ock"), ach("ock"), acke("ock"), ag("ock"),
+    oecious("oecious"), ecious("oecious"), oid("oid"), oeid("oid"), oidal("oidal"), ol("ol"), ola("ola"), ole("ol"), olent("olent"),
+    olum("olum"), olus("olus"), on("on"), one("one"), onic("onic"), oon("own"), own("own"), owne("own"), oone("own"), oun("own"),
+    oune("own"), or("or"), orial("orial"), orious("orious"), orium("orium"), ory("ory"), ori("ory"), orye("ory"), orie("ory"), ry("ory"),
+    ore("ory"), oury("ory"), oire("ory"), arie("ory"), our("ory"), oure("ory"), ose("ose"), oside("oside"), osis("osis"), osity("osity"),
+    osytee("osity"), osite("osity"), ositee("osity"), osyte("osity"), ositye("osity"), osytye("osity"), ositie("osity"),
+    ot("ot"), ote("ot"), att("ot"), ott("ot"), otic("otic"), ous("ous"), ows("ous"), owse("ous"), es("ous"), ouse("ous"), us("ous"),
+    ois("ous"), os("ous"), oyl("oyl"), plex("plex"), red("red"), raeden("red"), hraedden("red"), hraeden("red"), raedan("red"),
+    raedden("red"), raedyn("red"), raendenne("red"), reden("red"), raedene("red"), redden("red"), raedaen("red"), raeidene("red"),
+    readden("red"), redne("red"), raddene("red"), raden("red"), radene("red"), radin("red"), radon("red"), radone("red"),
+    radyn("red"), reddene("red"), redene("red"), redin("red"), redyn("red"), redyne("red"), retin("red"), ryden("red"),
+    rydyn("red"), ratten("red"), rydden("red"), radoun("red"), rad("red"), reth("red"), rod("red"), ryde("red"), redd("red"), redde("red"),
+    rade("red"), rid("red"), rode("red"), ryd("red"), rede("red"), reed("red"), raid("red"), reade("red"), reid("red"), rit("red"), roode("red"),
+    ret("red"), ritt("red"), rait("red"), rat("red"), rayd("red"), reat("red"), rett("red"), reyd("red"), ryt("red"), rytt("red"),
+    ran("red"), rand("red"), rant("red"), reint("red"), rend("red"), rende("red"), rene("red"), rente("red"), renth("red"), rent("red"),
+    redynge("red"), rydynge("red"), ratht("red"), recht("red"), rethridge("red"), ric("ric"), rice("ric"), rige("ric"), rych("ric"), ryche("ric"),
+    erich("ric"), riche("ric"), ryke("ric"), ricke("ric"), rike("ric"), rik("ric"), rijk("ric"), ryck("ric"), rycke("ric"), ricque("ric"),
+    rig("ric"), reik("ric"), rikk("ric"), ryc("ric"), reche("ric"), reiche("ric"), right("right"), reht("right"), rythe("right"), riht("right"),
+    rihte("right"), ricte("right"), rift("right"), rihht("right"), riste("right"), ritht("right"), richt("right"), richte("right"),
+    rizht("right"), rigt("right"), rizt("right"), rigte("right"), rizte("right"), rizth("right"), riztth("right"), rith("right"),
+    rygzt("right"), ryzht("right"), ryzt("right"), ryzte("right"), ryzth("right"), ryht("right"), ryizt("right"), ryghte("right"),
+    righte("right"), ryght("right"), rite("right"), racht("right"), rycht("right"), rights("rights"), raehtes("rights"), rithes("rights"),
+    regthes("rights"), rightis("rights"), rightys("rights"), riztes("rights"), rizttes("rights"), rihtis("rights"), ryghtez("rights"),
+    ryghtis("rights"), ryghttes("rights"), ryztes("rights"), ryztis("rights"), ryztys("rights"), rythes("rights"), rythis("rights"),
+    rightes("rights"), rye("ry"), ree("ry"), rie("ry"), rey("ry"), ri("ry"), ship("ship"), skiepe("ship"), scipe("ship"), scype("ship"),
+    scip("ship"), sciop("ship"), scep("ship"), sip("ship"), sipe("ship"), schipe("ship"), schupe("ship"), schippe("ship"), shipe("ship"),
+    schyp("ship"), schepe("ship"), shep("ship"), shepe("ship"), chipe("ship"), chepe("ship"), schip("ship"), shyp("ship"), shippe("ship"),
+    schuppe("ship"), chyp("ship"), chep("ship"), shyppe("ship"), shipp("ship"), sis("sis"), ski("ski"), sky("sky"), some("some"), speak("speak"),
+    ster("ster"), istrae("ster"), estre("ster"), ystre("ster"), estir("ster"), star("ster"), stare("ster"), estere("ster"), stere("ster"),
+    sterol("sterol"), style("style"), sy("sy"), t("t"), teria("teria"), th("th"), thon("thon"), tion("tion"), tious("tious"), tress("tress"),
+    trice("trice"), trix("trix"), tron("tron"), tude("tude"), ty("ty"), type("type"), ual("ual"), ula("ula"), ular("ular"), ule("ule"),
+    ulent("ulent"), ulose("ulose"), ulum("ulum"), ulus("ulus"), uncle("uncle"), uous("uous"), up("up"), ure("ure"), uret("uret"), urient("urient"),
+    ward("ward"), wards("wards"), ware("ware"), uaeras("ware"), uaras("ware"), uaro("ware"), waeras("ware"), wara("ware"), waran("ware"),
+    waras("ware"), waru("ware"), wearan("ware"), waeren("ware"), warae("ware"), wick("wick"), y("y"), ig("y"), ye("y"), igan("y"), izen("y"),
+    ezen("y"), yen("y"), ey("y"), yl("yl"), yne("yne");
+    private String morpheme;
+
+    //constructor
+    SuffixEnum(String morpheme) {
+        this.morpheme = morpheme;
+    }
+
+    //getter Method
+    public String getMorpheme() {
+        return this.morpheme;
+    }
+}
+

Morphochron/src/TestInit.java

+
+public class TestInit {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		System.out.println("Hello World!");
+	}
+
+}

Morphochron/src/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+  <modelVersion>4.0.0</modelVersion>
+  <groupId>morphochron</groupId>
+  <artifactId>morphochron</artifactId>
+  <version>0.0.1-SNAPSHOT</version>
+</project>
\ No newline at end of file