nlptoolkit-morphologicalanalysis 1.0.0

package/source/MorphologicalAnalysis/MorphologicalParse.ts

@@ -0,0 +1,995 @@
+import {InflectionalGroup} from "./InflectionalGroup";
+import {Word} from "nlptoolkit-dictionary/dist/Dictionary/Word";
+import {MorphologicalTag} from "./MorphologicalTag";
+
+export class MorphologicalParse {
+
+    protected inflectionalGroups: Array<InflectionalGroup> = new Array<InflectionalGroup>()
+    protected root: Word
+
+    /**
+     * Another constructor of {@link MorphologicalParse} class which takes a {@link String} parse as an input. First it creates
+     * an {@link Array} as iGs for inflectional groups, and while given String contains derivational boundary (^DB+), it
+     *.pushs the substring to the iGs {@link Array} and continue to use given String from 4th index. If it does not contain ^DB+,
+     * it directly.pushs the given String to the iGs {@link Array}. Then, it creates a new {@link Array} as
+     * inflectionalGroups and checks for some cases.
+     * <p>
+     * If the first item of iGs {@link Array} is ++Punc, it creates a new root as +, and by calling
+     * {@link InflectionalGroup} method with Punc it initializes the IG {@link Array} by parsing given input
+     * String IG by + and calling the getMorphologicalTag method with these substrings. If getMorphologicalTag method returns
+     * a tag, it.pushs this tag to the IG {@link Array} and also to the inflectionalGroups {@link Array}.
+     * <p>
+     * If the first item of iGs {@link Array} has +, it creates a new word of first item's substring from index 0 to +,
+     * and assigns it to root. Then, by calling {@link InflectionalGroup} method with substring from index 0 to +,
+     * it initializes the IG {@link Array} by parsing given input String IG by + and calling the getMorphologicalTag
+     * method with these substrings. If getMorphologicalTag method returns a tag, it.pushs this tag to the IG {@link Array}
+     * and also to the inflectionalGroups {@link Array}.
+     * <p>
+     * If the first item of iGs {@link Array} does not contain +, it creates a new word with first item and assigns it as root.
+     * <p>
+     * At the end, it loops through the items of iGs and by calling {@link InflectionalGroup} method with these items
+     * it initializes the IG {@link Array} by parsing given input String IG by + and calling the getMorphologicalTag
+     * method with these substrings. If getMorphologicalTag method returns a tag, it.pushs this tag to the IG {@link Array}
+     * and also to the inflectionalGroups {@link Array}.
+     *
+     * @param parseOrInflectionalGroups String input.
+     */
+    constructor(parseOrInflectionalGroups?: any) {
+        if (parseOrInflectionalGroups != undefined){
+            if (!Array.isArray(parseOrInflectionalGroups)){
+                let iGs = new Array<string>()
+                let st = parseOrInflectionalGroups;
+                while (st.includes("^DB+")) {
+                    iGs.push(st.substring(0, st.indexOf("^DB+")));
+                    st = st.substring(st.indexOf("^DB+") + 4);
+                }
+                iGs.push(st);
+                if (iGs[0] == "++Punc") {
+                    this.root = new Word("+");
+                    this.inflectionalGroups.push(new InflectionalGroup("Punc"));
+                } else {
+                    if (iGs[0].indexOf('+') != -1) {
+                        this.root = new Word(iGs[0].substring(0, iGs[0].indexOf('+')));
+                        this.inflectionalGroups.push(new InflectionalGroup(iGs[0].substring(iGs[0].indexOf('+') + 1)));
+                    } else {
+                        this.root = new Word(iGs[0]);
+                    }
+                    for (let i = 1; i < iGs.length; i++) {
+                        this.inflectionalGroups.push(new InflectionalGroup(iGs[i]));
+                    }
+                }
+            } else {
+                let groups = parseOrInflectionalGroups
+                if (groups[0].indexOf('+') != -1) {
+                    this.root = new Word(groups[0].substring(0, groups[0].indexOf('+')));
+                    this.inflectionalGroups.push(new InflectionalGroup(groups[0].substring(groups[0].indexOf('+') + 1)));
+                }
+                for (let i = 1; i < groups.length; i++) {
+                    this.inflectionalGroups.push(new InflectionalGroup(groups[i]));
+                }
+            }
+        }
+    }
+
+    /**
+     * The no-arg getWord method returns root {@link Word}.
+     *
+     * @return root {@link Word}.
+     */
+    getWord(): Word{
+        return this.root
+    }
+
+    /**
+     * The getTransitionList method gets the first item of inflectionalGroups {@link Array} as a {@link String},
+     * then loops through the items of inflectionalGroups and concatenates them by using +.
+     *
+     * @return String that contains transition list.
+     */
+    getMorphologicalParseTransitionList(): string{
+        let result = this.inflectionalGroups[0].toString();
+        for (let i = 1; i < this.inflectionalGroups.length; i++) {
+            result = result + "+" + this.inflectionalGroups[i].toString();
+        }
+        return result;
+    }
+
+    /**
+     * The getInflectionalGroupString method takes an {@link number} index as an input and if index is 0, it directly
+     * returns the root and the first item of inflectionalGroups {@link Array}. If the index is not 0, it then returns
+     * the corresponding item of inflectionalGroups {@link Array} as a {@link String}.
+     *
+     * @param index Integer input.
+     * @return corresponding item of inflectionalGroups at given index as a {@link String}.
+     */
+    getInflectionalGroupString(index: number): string{
+        if (index == 0) {
+            return this.root.getName() + "+" + this.inflectionalGroups[0].toString();
+        } else {
+            return this.inflectionalGroups[index].toString();
+        }
+    }
+
+    /**
+     * The getInflectionalGroup method takes an {@link number} index as an input and it directly returns the
+     * {@link InflectionalGroup} at given index.
+     *
+     * @param index Integer input.
+     * @return InflectionalGroup at given index.
+     */
+    getInflectionalGroup(index?: number): InflectionalGroup{
+        if (index == undefined){
+            index = this.inflectionalGroups.length - 1
+        }
+        return this.inflectionalGroups[index];
+    }
+
+    /**
+     * The getTag method takes an {@link number} index as an input and and if the given index is 0, it directly return
+     * the root. Then, it loops through the inflectionalGroups {@link Array} it returns the MorphologicalTag of the
+     * corresponding inflectional group.
+     *
+     * @param index Integer input.
+     * @return the MorphologicalTag of the corresponding inflectional group, or null of invalid index inputs.
+     */
+    getTag(index: number): string{
+        let size = 1;
+        if (index == 0)
+            return this.root.getName();
+        for (let group of this.inflectionalGroups) {
+            if (index < size + group.size()) {
+                return InflectionalGroup.getTag(group.getTag(index - size));
+            }
+            size += group.size();
+        }
+        return undefined;
+    }
+
+    /**
+     * The tagSize method loops through the inflectionalGroups {@link Array} and accumulates the sizes of each inflectional group
+     * in the inflectionalGroups.
+     *
+     * @return total size of the inflectionalGroups {@link Array}.
+     */
+    tagSize(): number{
+        let size = 1;
+        for (let group of this.inflectionalGroups) {
+            size += group.size();
+        }
+        return size;
+    }
+
+    /**
+     * The size method returns the size of the inflectionalGroups {@link Array}.
+     *
+     * @return the size of the inflectionalGroups {@link Array}.
+     */
+    size(): number{
+        return this.inflectionalGroups.length
+    }
+
+    /**
+     * The firstInflectionalGroup method returns the first inflectional group of inflectionalGroups {@link Array}.
+     *
+     * @return the first inflectional group of inflectionalGroups {@link Array}.
+     */
+    firstInflectionalGroup(): InflectionalGroup{
+        return this.inflectionalGroups[0]
+    }
+
+    /**
+     * The lastInflectionalGroup method returns the last inflectional group of inflectionalGroups {@link Array}.
+     *
+     * @return the last inflectional group of inflectionalGroups {@link Array}.
+     */
+    lastInflectionalGroup(): InflectionalGroup{
+        return this.inflectionalGroups[this.inflectionalGroups.length - 1]
+    }
+
+    /**
+     * The getWordWithPos method returns root with the MorphologicalTag of the first inflectional as a new word.
+     *
+     * @return root with the MorphologicalTag of the first inflectional as a new word.
+     */
+    getWordWithPos(): Word{
+        return new Word(this.root.getName() + "+" + InflectionalGroup.getTag(this.firstInflectionalGroup().getTag(0)));
+    }
+
+    /**
+     * The getPos method returns the MorphologicalTag of the last inflectional group.
+     *
+     * @return the MorphologicalTag of the last inflectional group.
+     */
+    getPos(): string{
+        return InflectionalGroup.getTag(this.lastInflectionalGroup().getTag(0));
+    }
+
+    /**
+     * The getRootPos method returns the MorphologicalTag of the first inflectional group.
+     *
+     * @return the MorphologicalTag of the first inflectional group.
+     */
+    getRootPos(): string{
+        return InflectionalGroup.getTag(this.firstInflectionalGroup().getTag(0));
+    }
+
+    /**
+     * The lastIGContainsCase method returns the MorphologicalTag of last inflectional group if it is one of the NOMINATIVE,
+     * ACCUSATIVE, DATIVE, LOCATIVE or ABLATIVE cases, null otherwise.
+     *
+     * @return the MorphologicalTag of last inflectional group if it is one of the NOMINATIVE,
+     * ACCUSATIVE, DATIVE, LOCATIVE or ABLATIVE cases, null otherwise.
+     */
+    lastIGContainsCase(): string{
+        let caseTag = this.lastInflectionalGroup().containsCase();
+        if (caseTag != undefined)
+            return InflectionalGroup.getTag(caseTag);
+        else
+            return "NULL";
+    }
+
+    /**
+     * The lastIGContainsTag method takes a MorphologicalTag as an input and returns true if the last inflectional group's
+     * MorphologicalTag matches with one of the tags in the IG {@link Array}, false otherwise.
+     *
+     * @param tag {@link MorphologicalTag} type input.
+     * @return true if the last inflectional group's MorphologicalTag matches with one of the tags in the
+     * IG {@link Array}, false otherwise.
+     */
+    lastIGContainsTag(tag: MorphologicalTag): boolean{
+        return this.lastInflectionalGroup().containsTag(tag);
+    }
+
+    /**
+     * lastIGContainsPossessive method returns true if the last inflectional group contains one of the
+     * possessives: P1PL, P1SG, P2PL, P2SG, P3PL AND P3SG, false otherwise.
+     *
+     * @return true if the last inflectional group contains one of the possessives: P1PL, P1SG, P2PL, P2SG, P3PL AND P3SG, false otherwise.
+     */
+    lastIGContainsPossessive(): boolean{
+        return this.lastInflectionalGroup().containsPossessive();
+    }
+
+    /**
+     * The isCapitalWord method returns true if the character at first index o f root is an uppercase letter, false otherwise.
+     *
+     * @return true if the character at first index o f root is an uppercase letter, false otherwise.
+     */
+    isCapitalWord(): boolean{
+        let ch = this.root.getName().charAt(0)
+        return ch == ch.toLocaleUpperCase("tr")
+    }
+
+    /**
+     * The isNoun method returns true if the part of speech is NOUN, false otherwise.
+     *
+     * @return true if the part of speech is NOUN, false otherwise.
+     */
+    isNoun(): boolean{
+        return this.getPos() == "NOUN";
+    }
+
+    /**
+     * The isVerb method returns true if the part of speech is VERB, false otherwise.
+     *
+     * @return true if the part of speech is VERB, false otherwise.
+     */
+    isVerb(): boolean{
+        return this.getPos() == "VERB";
+    }
+
+    /**
+     * The isRootVerb method returns true if the part of speech of root is BERV, false otherwise.
+     *
+     * @return true if the part of speech of root is VERB, false otherwise.
+     */
+    isRootVerb(): boolean{
+        return this.getRootPos() == "VERB";
+    }
+
+    /**
+     * The isAdjective method returns true if the part of speech is ADJ, false otherwise.
+     *
+     * @return true if the part of speech is ADJ, false otherwise.
+     */
+    isAdjective(): boolean{
+        return this.getPos() == "ADJ";
+    }
+
+    /**
+     * The isProperNoun method returns true if the first inflectional group's MorphologicalTag is a PROPERNOUN, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a PROPERNOUN, false otherwise.
+     */
+    isProperNoun(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.PROPERNOUN);
+    }
+
+    /**
+     * The isPunctuation method returns true if the first inflectional group's MorphologicalTag is a PUNCTUATION, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a PUNCTUATION, false otherwise.
+     */
+    isPunctuation(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.PUNCTUATION);
+    }
+
+    /**
+     * The isCardinal method returns true if the first inflectional group's MorphologicalTag is a CARDINAL, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a CARDINAL, false otherwise.
+     */
+    isCardinal(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.CARDINAL);
+    }
+
+    /**
+     * The isOrdinal method returns true if the first inflectional group's MorphologicalTag is a ORDINAL, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a ORDINAL, false otherwise.
+     */
+    isOrdinal(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.ORDINAL);
+    }
+
+    /**
+     * The isReal method returns true if the first inflectional group's MorphologicalTag is a REAL, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a REAL, false otherwise.
+     */
+    isReal(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.REAL);
+    }
+
+    /**
+     * The isNumber method returns true if the first inflectional group's MorphologicalTag is REAL or CARDINAL, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a REAL or CARDINAL, false otherwise.
+     */
+    isNumber(): boolean{
+        return this.isReal() || this.isCardinal();
+    }
+
+    /**
+     * The isTime method returns true if the first inflectional group's MorphologicalTag is a TIME, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a TIME, false otherwise.
+     */
+    isTime(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.TIME);
+    }
+
+    /**
+     * The isDate method returns true if the first inflectional group's MorphologicalTag is a DATE, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a DATE, false otherwise.
+     */
+    isDate(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.DATE);
+    }
+
+    /**
+     * The isHashTag method returns true if the first inflectional group's MorphologicalTag is a HASHTAG, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a HASHTAG, false otherwise.
+     */
+    isHashTag(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.HASHTAG);
+    }
+
+    /**
+     * The isEmail method returns true if the first inflectional group's MorphologicalTag is a EMAIL, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a EMAIL, false otherwise.
+     */
+    isEmail(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.EMAIL);
+    }
+
+    /**
+     * The isPercent method returns true if the first inflectional group's MorphologicalTag is a PERCENT, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a PERCENT, false otherwise.
+     */
+    isPercent(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.PERCENT);
+    }
+
+    /**
+     * The isFraction method returns true if the first inflectional group's MorphologicalTag is a FRACTION, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a FRACTION, false otherwise.
+     */
+    isFraction(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.FRACTION);
+    }
+
+    /**
+     * The isRange method returns true if the first inflectional group's MorphologicalTag is a RANGE, false otherwise.
+     *
+     * @return true if the first inflectional group's MorphologicalTag is a RANGE, false otherwise.
+     */
+    isRange(): boolean{
+        return this.getInflectionalGroup(0).containsTag(MorphologicalTag.RANGE);
+    }
+
+    /**
+     * The isPlural method returns true if {@link InflectionalGroup}'s MorphologicalTags are from the agreement plural
+     * or possessive plural, i.e A1PL, A2PL, A3PL, P1PL, P2PL or P3PL, and false otherwise.
+     *
+     * @return true if {@link InflectionalGroup}'s MorphologicalTags are from the agreement plural or possessive plural.
+     */
+    isPlural(): boolean{
+        for (let inflectionalGroup of this.inflectionalGroups){
+            if (inflectionalGroup.containsPlural()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * The isAuxiliary method returns true if the root equals to the et, ol, or yap, and false otherwise.
+     *
+     * @return true if the root equals to the et, ol, or yap, and false otherwise.
+     */
+    isAuxiliary(): boolean{
+        return this.root.getName() == "et" || this.root.getName() == "ol" || this.root.getName() == "yap";
+    }
+
+    /**
+     * The containsTag method takes a MorphologicalTag as an input and loops through the inflectionalGroups {@link ArrayList},
+     * returns true if the input matches with on of the tags in the IG, false otherwise.
+     *
+     * @param tag checked tag
+     * @return true if the input matches with on of the tags in the IG, false otherwise.
+     */
+    containsTag(tag: MorphologicalTag): boolean{
+        for (let inflectionalGroup of this.inflectionalGroups) {
+            if (inflectionalGroup.containsTag(tag)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * The getTreePos method returns the tree pos tag of a morphological analysis.
+     *
+     * @return Tree pos tag of the morphological analysis in string form.
+     */
+    getTreePos(): string{
+        if (this.isProperNoun()){
+            return "NP";
+        } else {
+            if (this.root.getName() == "değil"){
+                return "NEG";
+            } else {
+                if (this.isVerb()){
+                    if (this.lastIGContainsTag(MorphologicalTag.ZERO)){
+                        return "NOMP";
+                    } else {
+                        return "VP";
+                    }
+                } else {
+                    if (this.isAdjective()){
+                        return "ADJP";
+                    } else {
+                        if (this.isNoun() || this.isPercent()){
+                            return "NP";
+                        } else {
+                            if (this.containsTag(MorphologicalTag.ADVERB)){
+                                return "ADVP";
+                            } else {
+                                if (this.isNumber() || this.isFraction()){
+                                    return "NUM";
+                                } else {
+                                    if (this.containsTag(MorphologicalTag.POSTPOSITION)){
+                                        return "PP";
+                                    } else {
+                                        if (this.containsTag(MorphologicalTag.CONJUNCTION)){
+                                            return "CONJP";
+                                        } else {
+                                            if (this.containsTag(MorphologicalTag.DETERMINER)){
+                                                return "DP";
+                                            } else {
+                                                if (this.containsTag(MorphologicalTag.INTERJECTION)){
+                                                    return "INTJP";
+                                                } else {
+                                                    if (this.containsTag(MorphologicalTag.QUESTIONPRONOUN)){
+                                                        return "WP";
+                                                    } else {
+                                                        if (this.containsTag(MorphologicalTag.PRONOUN)){
+                                                            return "NP";
+                                                        } else {
+                                                            if (this.isPunctuation()){
+                                                                switch (this.root.getName()){
+                                                                    case "!":
+                                                                    case "?":
+                                                                        return ".";
+                                                                    case ";":
+                                                                    case "-":
+                                                                    case "--":
+                                                                        return ":";
+                                                                    case "(":
+                                                                    case "-LRB-":
+                                                                    case "-lrb-":
+                                                                        return "-LRB-";
+                                                                    case ")":
+                                                                    case "-RRB-":
+                                                                    case "-rrb-":
+                                                                        return "-RRB-";
+                                                                    default:
+                                                                        return this.root.getName();
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return "-XXX-";
+    }
+
+    private getPronType(): string{
+        let lemma = this.root.getName();
+        if (this.containsTag(MorphologicalTag.DETERMINER)){
+            return "Art";
+        }
+        if (lemma == "kendi" || this.containsTag(MorphologicalTag.PERSONALPRONOUN)){
+            return "Prs";
+        }
+        if (lemma == "birbiri" || lemma == "birbirleri"){
+            return "Rcp";
+        }
+        if (lemma == "birçoğu" || lemma == "hep" || lemma == "kimse"
+            || lemma == "bazı" || lemma == "biri" || lemma == "çoğu"
+            || lemma == "hepsi" || lemma == "diğeri" || lemma == "tümü"
+            || lemma == "herkes" || lemma == "kimi" || lemma == "öbür"
+            || lemma == "öteki" || lemma == "birkaçı" || lemma == "topu"
+            || lemma == "başkası"){
+            return "Ind";
+        }
+        if (lemma == "hiçbiri"){
+            return "Neg";
+        }
+        if (lemma == "kim" || lemma == "nere" || lemma == "ne"
+            || lemma == "hangi" || lemma == "nasıl" || lemma == "kaç"
+            || lemma == "mi" || lemma == "mı" || lemma == "mu" || lemma == "mü"){
+            return "Int";
+        }
+        if (this.containsTag(MorphologicalTag.DEMONSTRATIVEPRONOUN)){
+            return "Dem";
+        }
+        return undefined;
+    }
+
+    private getNumType(): string{
+        let lemma = this.root.getName();
+        if (lemma == "%" || this.containsTag(MorphologicalTag.TIME)){
+            return "Ord";
+        }
+        if (this.containsTag(MorphologicalTag.ORDINAL) || lemma == "kaçıncı"){
+            return "Ord";
+        }
+        if (this.containsTag(MorphologicalTag.DISTRIBUTIVE)){
+            return "Dist";
+        }
+        if (this.containsTag(MorphologicalTag.CARDINAL) || this.containsTag(MorphologicalTag.NUMBER) || lemma == "kaç"){
+            return "Card";
+        }
+        return undefined;
+    }
+
+    private getReflex(): string{
+        let lemma = this.root.getName();
+        if (lemma == "kendi"){
+            return "Yes";
+        }
+        return undefined;
+    }
+
+    private getNumber(): string{
+        if (this.containsTag(MorphologicalTag.A1SG) || this.containsTag(MorphologicalTag.A2SG) ||
+            this.containsTag(MorphologicalTag.A3SG)){
+            return "Sing";
+        }
+        if (this.containsTag(MorphologicalTag.A1PL) || this.containsTag(MorphologicalTag.A2PL) ||
+            this.containsTag(MorphologicalTag.A3PL)){
+            return "Plur";
+        }
+        return undefined;
+    }
+
+    private getPossessiveNumber(): string{
+        if (this.containsTag(MorphologicalTag.P1SG) || this.containsTag(MorphologicalTag.P2SG) ||
+            this.containsTag(MorphologicalTag.P3SG)){
+            return "Sing";
+        }
+        if (this.containsTag(MorphologicalTag.P1PL) || this.containsTag(MorphologicalTag.P2PL) ||
+            this.containsTag(MorphologicalTag.P3PL)){
+            return "Plur";
+        }
+        return undefined;
+    }
+
+    private getCase(): string{
+        if (this.containsTag(MorphologicalTag.ACCUSATIVE) || this.containsTag(MorphologicalTag.PCACCUSATIVE)){
+            return "Acc";
+        }
+        if (this.containsTag(MorphologicalTag.DATIVE) || this.containsTag(MorphologicalTag.PCDATIVE)){
+            return "Dat";
+        }
+        if (this.containsTag(MorphologicalTag.GENITIVE) || this.containsTag(MorphologicalTag.PCGENITIVE)){
+            return "Gen";
+        }
+        if (this.containsTag(MorphologicalTag.LOCATIVE)){
+            return "Loc";
+        }
+        if (this.containsTag(MorphologicalTag.INSTRUMENTAL) || this.containsTag(MorphologicalTag.PCINSTRUMENTAL)){
+            return "Ins";
+        }
+        if (this.containsTag(MorphologicalTag.ABLATIVE) || this.containsTag(MorphologicalTag.PCABLATIVE)){
+            return "Abl";
+        }
+        if (this.containsTag(MorphologicalTag.NOMINATIVE) || this.containsTag(MorphologicalTag.PCNOMINATIVE)){
+            return "Nom";
+        }
+        return undefined;
+    }
+
+    private getDefinite(): string{
+        let lemma = this.root.getName();
+        if (this.containsTag(MorphologicalTag.DETERMINER)){
+            if (lemma == "bir" || lemma == "bazı" || lemma == "birkaç"){
+                return "Ind";
+            }
+            if (lemma == "her" || lemma == "bu" || lemma == "şu" || lemma == "o" || lemma == "bütün"){
+                return "Def";
+            }
+        }
+        return undefined;
+    }
+
+    private getDegree(): string{
+        let lemma = this.root.getName();
+        if (lemma == "daha"){
+            return "Cmp";
+        }
+        if (lemma == "en" && !this.isNoun()){
+            return "Sup";
+        }
+        return undefined;
+    }
+
+    private getPolarity(): string{
+        if (this.containsTag(MorphologicalTag.POSITIVE)){
+            return "Pos";
+        }
+        if (this.containsTag(MorphologicalTag.NEGATIVE)){
+            return "Neg";
+        }
+        return undefined;
+    }
+
+    private getPerson(): string{
+        if (this.containsTag(MorphologicalTag.A1SG) || this.containsTag(MorphologicalTag.A1PL)){
+            return "1";
+        }
+        if (this.containsTag(MorphologicalTag.A2SG) || this.containsTag(MorphologicalTag.A2PL)){
+            return "2";
+        }
+        if (this.containsTag(MorphologicalTag.A3SG) || this.containsTag(MorphologicalTag.A3PL)){
+            return "3";
+        }
+        return undefined;
+    }
+
+    private getPossessivePerson(): string{
+        if (this.containsTag(MorphologicalTag.P1SG) || this.containsTag(MorphologicalTag.P1PL)){
+            return "1";
+        }
+        if (this.containsTag(MorphologicalTag.P2SG) || this.containsTag(MorphologicalTag.P2PL)){
+            return "2";
+        }
+        if (this.containsTag(MorphologicalTag.P3SG) || this.containsTag(MorphologicalTag.P3PL)){
+            return "3";
+        }
+        return undefined;
+    }
+
+    private getVoice(): string{
+        if (this.containsTag(MorphologicalTag.CAUSATIVE) && this.containsTag(MorphologicalTag.PASSIVE)){
+            return "CauPass";
+        }
+        if (this.containsTag(MorphologicalTag.PASSIVE)){
+            return "Pass";
+        }
+        if (this.containsTag(MorphologicalTag.RECIPROCAL)){
+            return "Rcp";
+        }
+        if (this.containsTag(MorphologicalTag.CAUSATIVE)){
+            return "Cau";
+        }
+        if (this.containsTag(MorphologicalTag.REFLEXIVE)){
+            return "Rfl";
+        }
+        return undefined;
+    }
+
+    private getAspect(): string{
+        if (this.containsTag(MorphologicalTag.PASTTENSE) || this.containsTag(MorphologicalTag.NARRATIVE) ||
+            this.containsTag(MorphologicalTag.FUTURE)){
+            return "Perf";
+        }
+        if (this.containsTag(MorphologicalTag.PROGRESSIVE1) || this.containsTag(MorphologicalTag.PROGRESSIVE2)){
+            return "Prog";
+        }
+        if (this.containsTag(MorphologicalTag.AORIST)){
+            return "Hab";
+        }
+        if (this.containsTag(MorphologicalTag.HASTILY)){
+            return "Rapid";
+        }
+        if (this.containsTag(MorphologicalTag.START) || this.containsTag(MorphologicalTag.STAY) ||
+            this.containsTag(MorphologicalTag.REPEAT)){
+            return "Dur";
+        }
+        return undefined;
+    }
+
+    private getTense(): string{
+        if (this.containsTag(MorphologicalTag.PASTTENSE)){
+            return "Past";
+        }
+        if (this.containsTag(MorphologicalTag.FUTURE)){
+            return "Fut";
+        }
+        if (this.containsTag(MorphologicalTag.NARRATIVE) && this.containsTag(MorphologicalTag.PASTTENSE)){
+            return "Pqp";
+        }
+        if (!this.containsTag(MorphologicalTag.PASTTENSE) && !this.containsTag(MorphologicalTag.FUTURE)){
+            return "Pres";
+        }
+        return undefined;
+    }
+
+    private getMood(): string{
+        if ((this.containsTag(MorphologicalTag.COPULA) || this.containsTag(MorphologicalTag.AORIST)) &&
+            this.containsTag(MorphologicalTag.NECESSITY) && this.containsTag(MorphologicalTag.ABLE)){
+            return "GenNecPot";
+        }
+        if (this.containsTag(MorphologicalTag.CONDITIONAL) && (this.containsTag(MorphologicalTag.COPULA) ||
+            this.containsTag(MorphologicalTag.AORIST)) && this.containsTag(MorphologicalTag.ABLE)){
+            return "CndGenPot";
+        }
+        if ((this.containsTag(MorphologicalTag.COPULA) || this.containsTag(MorphologicalTag.AORIST)) &&
+            this.containsTag(MorphologicalTag.NECESSITY)){
+            return "GenNec";
+        }
+        if (this.containsTag(MorphologicalTag.NECESSITY) && this.containsTag(MorphologicalTag.ABLE)){
+            return "NecPot";
+        }
+        if ((this.containsTag(MorphologicalTag.COPULA) || this.containsTag(MorphologicalTag.AORIST)) &&
+            this.containsTag(MorphologicalTag.ABLE)){
+            return "GenPot";
+        }
+        if (this.containsTag(MorphologicalTag.DESIRE) && this.containsTag(MorphologicalTag.ABLE)){
+            return "DesPot";
+        }
+        if (this.containsTag(MorphologicalTag.CONDITIONAL) && this.containsTag(MorphologicalTag.ABLE)){
+            return "CndPot";
+        }
+        if (this.containsTag(MorphologicalTag.CONDITIONAL) && (this.containsTag(MorphologicalTag.COPULA) ||
+            this.containsTag(MorphologicalTag.AORIST))){
+            return "CndGen";
+        }
+        if (this.containsTag(MorphologicalTag.IMPERATIVE)){
+            return "Imp";
+        }
+        if (this.containsTag(MorphologicalTag.CONDITIONAL)){
+            return "Cnd";
+        }
+        if (this.containsTag(MorphologicalTag.DESIRE)){
+            return "Des";
+        }
+        if (this.containsTag(MorphologicalTag.OPTATIVE)){
+            return "Opt";
+        }
+        if (this.containsTag(MorphologicalTag.NECESSITY)){
+            return "Nec";
+        }
+        if (this.containsTag(MorphologicalTag.ABLE)){
+            return "Pot";
+        }
+        if (this.containsTag(MorphologicalTag.PASTTENSE) || this.containsTag(MorphologicalTag.NARRATIVE) ||
+            this.containsTag(MorphologicalTag.PROGRESSIVE1) || this.containsTag(MorphologicalTag.PROGRESSIVE2) ||
+            this.containsTag(MorphologicalTag.FUTURE)){
+            return "Ind";
+        }
+        if ((this.containsTag(MorphologicalTag.COPULA) || this.containsTag(MorphologicalTag.AORIST))){
+            return "Gen";
+        }
+        if (this.containsTag(MorphologicalTag.ZERO) && !this.containsTag(MorphologicalTag.A3PL)){
+            return "Gen";
+        }
+        return undefined;
+    }
+
+    private getVerbForm(): string{
+        if (this.containsTag(MorphologicalTag.PASTPARTICIPLE) || this.containsTag(MorphologicalTag.FUTUREPARTICIPLE) ||
+            this.containsTag(MorphologicalTag.PRESENTPARTICIPLE)){
+            return "Part";
+        }
+        if (this.containsTag(MorphologicalTag.INFINITIVE) || this.containsTag(MorphologicalTag.INFINITIVE2)){
+            return "Vnoun";
+        }
+        if (this.containsTag(MorphologicalTag.SINCEDOINGSO) || this.containsTag(MorphologicalTag.WITHOUTHAVINGDONESO) ||
+            this.containsTag(MorphologicalTag.WITHOUTBEINGABLETOHAVEDONESO) || this.containsTag(MorphologicalTag.BYDOINGSO) ||
+            this.containsTag(MorphologicalTag.AFTERDOINGSO) || this.containsTag(MorphologicalTag.INFINITIVE3)){
+            return "Conv";
+        }
+        if (this.containsTag(MorphologicalTag.COPULA) || this.containsTag(MorphologicalTag.ABLE) ||
+            this.containsTag(MorphologicalTag.AORIST) || this.containsTag(MorphologicalTag.PROGRESSIVE2) ||
+            this.containsTag(MorphologicalTag.DESIRE) || this.containsTag(MorphologicalTag.NECESSITY) ||
+            this.containsTag(MorphologicalTag.CONDITIONAL) || this.containsTag(MorphologicalTag.IMPERATIVE) ||
+            this.containsTag(MorphologicalTag.OPTATIVE) || this.containsTag(MorphologicalTag.PASTTENSE) ||
+            this.containsTag(MorphologicalTag.NARRATIVE) || this.containsTag(MorphologicalTag.PROGRESSIVE1) ||
+            this.containsTag(MorphologicalTag.FUTURE) || (this.containsTag(MorphologicalTag.ZERO) &&
+                !this.containsTag(MorphologicalTag.A3PL))){
+            return "Fin";
+        }
+        return undefined;
+    }
+
+    getUniversalDependencyFeatures(uPos: string): Array<string>{
+        let featureList = new Array<string>();
+        let pronType = this.getPronType();
+        if (pronType != undefined && uPos.toUpperCase() != "NOUN" && uPos.toUpperCase() != "ADJ" && uPos.toUpperCase() != "VERB" && uPos.toUpperCase() != "CCONJ" && uPos.toUpperCase() != "PROPN"){
+            featureList.push("PronType=" + pronType);
+        }
+        let numType = this.getNumType();
+        if (numType != undefined && uPos.toUpperCase() != "VERB" && uPos.toUpperCase() != "NOUN" && uPos.toUpperCase() != "ADV"){
+            featureList.push("NumType=" + numType);
+        }
+        let reflex = this.getReflex();
+        if (reflex != undefined && uPos.toUpperCase() != "ADJ" && uPos.toUpperCase() != "VERB"){
+            featureList.push("Reflex=" + reflex);
+        }
+        let degree = this.getDegree();
+        if (degree != undefined && uPos.toUpperCase() != "ADJ"){
+            featureList.push("Degree=" + degree);
+        }
+        if (this.isNoun() || this.isVerb()){
+            let number = this.getNumber();
+            if (number != undefined){
+                featureList.push("Number=" + number);
+            }
+            let possessiveNumber = this.getPossessiveNumber();
+            if (possessiveNumber != undefined){
+                featureList.push("Number[psor]=" + possessiveNumber);
+            }
+            let person = this.getPerson();
+            if (person != undefined && uPos.toUpperCase() != "PROPN"){
+                featureList.push("Person=" + person);
+            }
+            let possessivePerson = this.getPossessivePerson();
+            if (possessivePerson != undefined && uPos.toUpperCase() != "PROPN"){
+                featureList.push("Person[psor]=" + possessivePerson);
+            }
+        }
+        if (this.isNoun()) {
+            let case_ = this.getCase();
+            if (case_ != undefined){
+                featureList.push("Case=" + case_);
+            }
+        }
+        if (this.containsTag(MorphologicalTag.DETERMINER)){
+            let definite = this.getDefinite();
+            if (definite != undefined){
+                featureList.push("Definite=" + definite);
+            }
+        }
+        if (this.isVerb()){
+            let polarity = this.getPolarity();
+            if (polarity != undefined){
+                featureList.push("Polarity=" + polarity);
+            }
+            let voice = this.getVoice();
+            if (voice != undefined){
+                featureList.push("Voice=" + voice);
+            }
+            let aspect = this.getAspect();
+            if (aspect != undefined && uPos.toUpperCase() != "PROPN"){
+                featureList.push("Aspect=" + aspect);
+            }
+            let tense = this.getTense();
+            if (tense != undefined && uPos.toUpperCase() != "PROPN"){
+                featureList.push("Tense=" + tense);
+            }
+            let mood = this.getMood();
+            if (mood != undefined && uPos.toUpperCase() != "PROPN"){
+                featureList.push("Mood=" + mood);
+            }
+            let verbForm = this.getVerbForm();
+            if (verbForm != undefined && uPos.toUpperCase() != "PROPN"){
+                featureList.push("VerbForm=" + verbForm);
+            }
+        }
+        featureList.sort();
+        return featureList;
+    }
+
+    getUniversalDependencyPos(): string{
+        let lemma = this.root.getName();
+        if (lemma == "değil"){
+            return "AUX";
+        }
+        if (this.isProperNoun()){
+            return "PROPN";
+        }
+        if (this.isNoun()){
+            return "NOUN";
+        }
+        if (this.isAdjective()){
+            return "ADJ";
+        }
+        if (this.getPos() == "ADV"){
+            return "ADV";
+        }
+        if (this.containsTag(MorphologicalTag.INTERJECTION)){
+            return "INTJ";
+        }
+        if (this.isVerb()){
+            return "VERB";
+        }
+        if (this.isPunctuation() || this.isHashTag()){
+            return "PUNCT";
+        }
+        if (this.containsTag(MorphologicalTag.DETERMINER)){
+            return "DET";
+        }
+        if (this.isNumber() || this.isDate() || this.isTime() || this.isOrdinal() || this.isFraction() || lemma == "%"){
+            return "NUM";
+        }
+        if (this.getPos() == "PRON"){
+            return "PRON";
+        }
+        if (this.getPos() == "POSTP"){
+            return "ADP";
+        }
+        if (this.getPos() == "QUES"){
+            return "AUX";
+        }
+        if (this.getPos() == "CONJ"){
+            if (lemma == "ki" || lemma == "eğer" || lemma == "diye"){
+                return "SCONJ";
+            } else {
+                return "CCONJ";
+            }
+        }
+        return "X";
+    }
+
+    /**
+     * The overridden toString method gets the root and the first inflectional group as a result {@link String} then concatenates
+     * with ^DB+ and the following inflectional groups.
+     *
+     * @return result {@link String}.
+     */
+    toString(): string{
+        let result = this.root.getName() + "+" + this.inflectionalGroups[0].toString();
+        for (let i = 1; i < this.inflectionalGroups.length; i++){
+            result = result + "^DB+" + this.inflectionalGroups[i].toString();
+        }
+        return result;
+    }
+}