nlptoolkit-morphologicalanalysis 1.0.0

package/source/MorphologicalAnalysis/Transition.ts

@@ -0,0 +1,733 @@
+import {State} from "./State";
+import {TxtWord} from "nlptoolkit-dictionary/dist/Dictionary/TxtWord";
+import {TurkishLanguage} from "nlptoolkit-dictionary/dist/Language/TurkishLanguage";
+import {FsmParse} from "./FsmParse";
+
+export class Transition {
+
+    private readonly _toState: State = undefined
+    private readonly _with: string = undefined
+    private readonly withName: string = undefined
+    private formationToCheck: string = undefined
+    private readonly _toPos: string = undefined
+
+    /**
+     * Another constructor of {@link Transition} class which takes  a {@link State}, and three {@link String}s as input. Then it
+     * initializes toState, with, withName and toPos variables with given inputs.
+     *
+     * @param toState  {@link State} input.
+     * @param _with     String input.
+     * @param withName String input.
+     * @param toPos    String input.
+     */
+    constructor(_with: string, withName?: string, toState?: State, toPos?: string) {
+        this._with = _with
+        this.withName = withName
+        this._toState = toState
+        this._toPos = toPos
+    }
+
+    /**
+     * Getter for the toState variable.
+     *
+     * @return toState variable.
+     */
+    toState(): State{
+        return this._toState
+    }
+
+    /**
+     * Getter for the toPos variable.
+     *
+     * @return toPos variable.
+     */
+    toPos(): string{
+        return this._toPos
+    }
+
+    /**
+     * The transitionPossible method takes two {@link String} as inputs; currentSurfaceForm and realSurfaceForm. If the
+     * length of the given currentSurfaceForm is greater than the given realSurfaceForm, it directly returns true. If not,
+     * it takes a substring from given realSurfaceForm with the size of currentSurfaceForm. Then checks for the characters of
+     * with variable.
+     * <p>
+     * If the character of with that makes transition is C, it returns true if the substring contains c or ç.
+     * If the character of with that makes transition is D, it returns true if the substring contains d or t.
+     * If the character of with that makes transition is A, it returns true if the substring contains a or e.
+     * If the character of with that makes transition is K, it returns true if the substring contains k, g or ğ.
+     * If the character of with that makes transition is other than the ones above, it returns true if the substring
+     * contains the same character as with.
+     *
+     * @param currentSurfaceForm {@link String} input.
+     * @param realSurfaceForm    {@link String} input.
+     * @return true when the transition is possible according to Turkish grammar, false otherwise.
+     */
+    transitionPossible(currentSurfaceForm: string, realSurfaceForm: string): boolean{
+        if (currentSurfaceForm.length == 0 || currentSurfaceForm.length >= realSurfaceForm.length) {
+            return true;
+        }
+        let searchString = realSurfaceForm.substring(currentSurfaceForm.length);
+        for (let i = 0; i < this._with.length; i++) {
+            switch (this._with.charAt(i)) {
+                case 'C':
+                    return searchString.includes("c") || searchString.includes("ç");
+                case 'D':
+                    return searchString.includes("d") || searchString.includes("t");
+                case 'c':
+                case 'e':
+                case 'r':
+                case 'p':
+                case 'l':
+                case 'b':
+                case 'g':
+                case 'o':
+                case 'm':
+                case 'v':
+                case 'i':
+                case 'ü':
+                case 'z':
+                    return searchString.includes(this._with.charAt(i));
+                case 'A':
+                    return searchString.includes("a") || searchString.includes("e");
+                case 'k':
+                    return searchString.includes("k") || searchString.includes("g") || searchString.includes("ğ");
+            }
+        }
+        return true;
+    }
+
+    /**
+     * The transitionPossible method takes a {@link FsmParse} currentFsmParse as an input. It then checks some special cases;
+     *
+     * @param currentFsmParse Parse to be checked
+     * @return true if transition is possible false otherwise
+     */
+    transitionPossibleFromParse(currentFsmParse: FsmParse): boolean{
+        if (this._with == "Ar" && currentFsmParse.getSurfaceForm().endsWith("l") &&
+            currentFsmParse.getWord().getName() != currentFsmParse.getSurfaceForm()) {
+            return false;
+        }
+        if (currentFsmParse.getVerbAgreement() != null && currentFsmParse.getPossesiveAgreement() != null &&
+            this.withName != undefined) {
+            if (currentFsmParse.getVerbAgreement() == "A3PL" && this.withName == "^DB+VERB+ZERO+PRES+A1SG") {
+                return false;
+            }
+            if (currentFsmParse.getVerbAgreement() == "A3SG" &&
+                (currentFsmParse.getPossesiveAgreement() == "P1SG" ||  currentFsmParse.getPossesiveAgreement() == "P2SG") &&
+                this.withName == "^DB+VERB+ZERO+PRES+A1PL") {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    transitionPossibleFromRoot(root: TxtWord, fromState: State){
+        if (root.isAdjective() && ((root.isNominal() && !root.isExceptional()) || root.isPronoun()) && this._toState.getName() == "NominalRoot(ADJ)" && this._with == "0") {
+            return false;
+        }
+        if (root.isAdjective() && root.isNominal() && this._with == "^DB+VERB+ZERO+PRES+A3PL" && fromState.getName() == "AdjectiveRoot") {
+            return false;
+        }
+        if (root.isAdjective() && root.isNominal() && this._with == "SH" && fromState.getName() == "AdjectiveRoot") {
+            return false;
+        }
+        if (this._with == "ki") {
+            return root.takesRelativeSuffixKi();
+        }
+        if (this._with == "kü") {
+            return root.takesRelativeSuffixKu();
+        }
+        if (this._with == "dHr") {
+            if (this._toState.getName() == "Adverb") {
+                return true;
+            } else {
+                return root.takesSuffixDIRAsFactitive();
+            }
+        }
+        if (this._with == "Hr" && (this._toState.getName() == "AdjectiveRoot(VERB)" ||
+            this._toState.getName() == "OtherTense" || this._toState.getName() == "OtherTense2")) {
+            return root.takesSuffixIRAsAorist();
+        }
+        return true;
+    }
+
+    /**
+     * The beforeLastVowel method takes a {@link String} stem as an input. It loops through the given stem and returns
+     * the second last vowel.
+     *
+     * @param stem String input.
+     * @return Vowel before the last vowel.
+     */
+    private beforeLastVowel(stem: string): string{
+        let before = 1;
+        let last = '0';
+        for (let i = stem.length - 1; i >= 0; i--) {
+            if (TurkishLanguage.isVowel(stem.charAt(i))) {
+                if (before == 1) {
+                    last = stem.charAt(i);
+                    before--;
+                    continue;
+                }
+                return stem.charAt(i);
+            }
+        }
+        return last;
+    }
+
+    /**
+     * The lastVowel method takes a {@link String} stem as an input. It loops through the given stem and returns
+     * the last vowel.
+     *
+     * @param stem String input.
+     * @return the last vowel.
+     */
+    private lastVowel(stem: string): string{
+        for (let i = stem.length - 1; i >= 0; i--) {
+            if (TurkishLanguage.isVowel(stem.charAt(i))) {
+                return stem.charAt(i);
+            }
+        }
+        for (let i = stem.length - 1; i >= 0; i--) {
+            if (stem.charAt(i) >= '0' && stem.charAt(i) <= '9') {
+                return stem.charAt(i);
+            }
+        }
+        return '0';
+    }
+
+    /**
+     * The lastPhoneme method takes a {@link String} stem as an input. It then returns the last phoneme of the given stem.
+     *
+     * @param stem String input.
+     * @return the last phoneme.
+     */
+    private lastPhoneme(stem: string): string{
+        if (stem.length == 0) {
+            return ' ';
+        }
+        if (stem.charAt(stem.length - 1) != '\'') {
+            return stem.charAt(stem.length - 1);
+        } else {
+            return stem.charAt(stem.length - 2);
+        }
+    }
+
+    /**
+     * The withFirstChar method returns the first character of the with variable.
+     *
+     * @return the first character of the with variable.
+     */
+    private withFirstChar(): string{
+        if (this._with.length == 0) {
+            return '$';
+        }
+        if (this._with.charAt(0) != '\'') {
+            return this._with.charAt(0);
+        } else {
+            if (this._with.length == 1) {
+                return this._with.charAt(0);
+            } else {
+                return this._with.charAt(1);
+            }
+        }
+    }
+
+    /**
+     * The startWithVowelorConsonantDrops method checks for some cases. If the first character of with variable is "nsy",
+     * and with variable does not equal to one of the Strings; "ylA, ysA, ymHs, yDH, yken", it returns true. If
+     * <p>
+     * Or, if the first character of with variable is 'A, H: or any other vowels, it returns true.
+     *
+     * @return true if it starts with vowel or consonant drops, false otherwise.
+     */
+    private startWithVowelorConsonantDrops(): boolean{
+        if (TurkishLanguage.isConsonantDrop(this.withFirstChar()) && this._with != "ylA" && this._with !="ysA" &&
+            this._with !="ymHs" && this._with != "yDH" && this._with != "yken") {
+            return true;
+        }
+        if (this.withFirstChar() == 'A' || this.withFirstChar() == 'H' || TurkishLanguage.isVowel(this.withFirstChar())) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * The softenDuringSuffixation method takes a {@link TxtWord} root as an input. It checks two cases; first case returns
+     * true if the given root is nominal or adjective and has one of the flags "IS_SD, IS_B_SD, IS_SDD" and with variable
+     * equals o one of the Strings "Hm, nDAn, ncA, nDA, yA, yHm, yHz, yH, nH, nA, nHn, H, sH, Hn, HnHz, HmHz".
+     * <p>
+     * And the second case returns true if the given root is verb and has the "F_SD" flag, also with variable starts with
+     * "Hyor" or equals one of the Strings "yHs, yAn, yA, yAcAk, yAsH, yHncA, yHp, yAlH, yArAk, yAdur, yHver, yAgel, yAgor,
+     * yAbil, yAyaz, yAkal, yAkoy, yAmA, yHcH, HCH, Hr, Hs, Hn, yHn", yHnHz, Ar, Hl").
+     *
+     * @param root {@link TxtWord} input.
+     * @return true if there is softening during suffixation of the given root, false otherwise.
+     */
+    softenDuringSuffixation(root: TxtWord): boolean{
+        if ((root.isNominal() || root.isAdjective()) && root.nounSoftenDuringSuffixation() &&
+            (this._with == "Hm" || this._with == "nDAn" || this._with == "ncA" || this._with == "nDA" ||
+                this._with == "yA" || this._with == "yHm" || this._with == "yHz" || this._with == "yH" ||
+                this._with == "nH" || this._with == "nA" || this._with == "nHn" || this._with == "H" ||
+                this._with == "sH" || this._with == "Hn" || this._with == "HnHz" || this._with == "HmHz")) {
+            return true;
+        }
+        if (root.isVerb() && root.verbSoftenDuringSuffixation() &&
+            (this._with.startsWith("Hyor") || this._with == "yHs" || this._with == "yAn" || this._with == "yA" ||
+            this._with.startsWith("yAcAk") || this._with == "yAsH" || this._with == "yHncA" || this._with == "yHp" ||
+                this._with == "yAlH" || this._with == "yArAk" || this._with == "yAdur" || this._with == "yHver" ||
+                this._with == "yAgel" || this._with == "yAgor" || this._with == "yAbil" || this._with == "yAyaz" ||
+                this._with == "yAkal" || this._with == "yAkoy" || this._with == "yAmA" || this._with == "yHcH" ||
+                this._with == "HCH" || this._with.startsWith("Hr") || this._with == "Hs" || this._with == "Hn" ||
+                this._with == "yHn" || this._with == "yHnHz" || this._with.startsWith("Ar") || this._with == "Hl")) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * The makeTransition method takes a {@link TxtWord} root and s {@link String} stem as inputs. If given root is a verb,
+     * it makes transition with given root and stem with the verbal root state. If given root is not verb, it makes transition
+     * with given root and stem and the nominal root state.
+     *
+     * @param root {@link TxtWord} input.
+     * @param stem String input.
+     * @param startState Start state to make the transition.
+     * @return String type output that has the transition.
+     */
+    makeTransition(root: TxtWord, stem: string, startState?: State): string{
+        if (startState == undefined){
+            if (root.isVerb()) {
+                return this.makeTransition(root, stem, new State("VerbalRoot", true, false));
+            } else {
+                return this.makeTransition(root, stem, new State("NominalRoot", true, false));
+            }
+        } else {
+            let rootWord = root.getName() == stem || (root.getName() + "'") == stem;
+            let formation = stem;
+            let i = 0;
+            if (this._with == "0") {
+                return stem;
+            }
+            if ((stem== "bu" || stem== "şu" || stem== "o") && rootWord && this._with == "ylA") {
+                return stem + "nunla";
+            }
+            if (this._with == "yA") {
+                if (stem== "ben") {
+                    return "bana";
+                }
+                if (stem== "sen") {
+                    return "sana";
+                }
+            }
+            this.formationToCheck = stem;
+            //---vowelEChangesToIDuringYSuffixation---
+            //de->d(i)yor, ye->y(i)yor
+            if (rootWord && this.withFirstChar() == 'y' && root.vowelEChangesToIDuringYSuffixation() &&
+                (this._with.charAt(1) != 'H' || root.getName()== "ye")) {
+                formation = stem.substring(0, stem.length - 1) + 'i';
+                this.formationToCheck = formation;
+            } else {
+                //---lastIdropsDuringPassiveSuffixation---
+                // yoğur->yoğrul, ayır->ayrıl, buyur->buyrul, çağır->çağrıl, çevir->çevril, devir->devril,
+                // kavur->kavrul, kayır->kayrıl, kıvır->kıvrıl, savur->savrul, sıyır->sıyrıl, yoğur->yoğrul
+                if (rootWord && (this._with == "Hl" || this._with == "Hn") && root.lastIdropsDuringPassiveSuffixation()) {
+                    formation = stem.substring(0, stem.length - 2) + stem.charAt(stem.length - 1);
+                    this.formationToCheck = stem;
+                } else {
+                    //---showsSuRegularities---
+                    //karasu->karasuyu, su->suyu, ağırsu->ağırsuyu, akarsu->akarsuyu, bengisu->bengisuyu
+                    if (rootWord && root.showsSuRegularities() && this.startWithVowelorConsonantDrops() && !this._with.startsWith("y")) {
+                        formation = stem + 'y';
+                        this.formationToCheck = formation;
+                    } else {
+                        if (rootWord && root.duplicatesDuringSuffixation() && !startState.getName().startsWith("VerbalRoot") &&
+                            TurkishLanguage.isConsonantDrop(this._with.charAt(0))) {
+                            //---duplicatesDuringSuffixation---
+                            if (this.softenDuringSuffixation(root)) {
+                                //--extra softenDuringSuffixation
+                                switch (this.lastPhoneme(stem)) {
+                                    case 'p':
+                                        //tıp->tıbbı
+                                        formation = stem.substring(0, stem.length - 1) + "bb";
+                                        break;
+                                    case 't':
+                                        //cet->ceddi, met->meddi, ret->reddi, serhat->serhaddi, zıt->zıddı, şet->şeddi
+                                        formation = stem.substring(0, stem.length - 1) + "dd";
+                                        break;
+                                }
+                            } else {
+                                //cer->cerri, emrihak->emrihakkı, fek->fekki, fen->fenni, had->haddi, hat->hattı,
+                                // haz->hazzı, his->hissi
+                                formation = stem + stem.charAt(stem.length - 1);
+                            }
+                            this.formationToCheck = formation;
+                        } else {
+                            if (rootWord && root.lastIdropsDuringSuffixation() &&
+                                !startState.getName().startsWith("VerbalRoot") && !startState.getName().startsWith("ProperRoot") &&
+                                this.startWithVowelorConsonantDrops()) {
+                                //---lastIdropsDuringSuffixation---
+                                if (this.softenDuringSuffixation(root)) {
+                                    //---softenDuringSuffixation---
+                                    switch (this.lastPhoneme(stem)) {
+                                        case 'p':
+                                            //hizip->hizbi, kayıp->kaybı, kayıt->kaydı, kutup->kutbu
+                                            formation = stem.substring(0, stem.length - 2) + 'b';
+                                            break;
+                                        case 't':
+                                            //akit->akdi, ahit->ahdi, lahit->lahdi, nakit->nakdi, vecit->vecdi
+                                            formation = stem.substring(0, stem.length - 2) + 'd';
+                                            break;
+                                        case 'ç':
+                                            //eviç->evci, nesiç->nesci
+                                            formation = stem.substring(0, stem.length - 2) + 'c';
+                                            break;
+                                    }
+                                } else {
+                                    //sarıağız->sarıağzı, zehir->zehri, zikir->zikri, nutuk->nutku, omuz->omzu, ömür->ömrü
+                                    //lütuf->lütfu, metin->metni, kavim->kavmi, kasıt->kastı
+                                    formation = stem.substring(0, stem.length - 2) + stem.charAt(stem.length - 1);
+                                }
+                                this.formationToCheck = stem;
+                            } else {
+                                switch (this.lastPhoneme(stem)) {
+                                    //---nounSoftenDuringSuffixation or verbSoftenDuringSuffixation
+                                    case 'p':
+                                        //adap->adabı, amip->amibi, azap->azabı, gazap->gazabı
+                                        if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                            formation = stem.substring(0, stem.length - 1) + 'b';
+                                        }
+                                        break;
+                                    case 't':
+                                        //adet->adedi, akort->akordu, armut->armudu
+                                        //affet->affedi, yoket->yokedi, sabret->sabredi, rakset->raksedi
+                                        if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                            formation = stem.substring(0, stem.length - 1) + 'd';
+                                        }
+                                        break;
+                                    case 'ç':
+                                        //ağaç->ağacı, almaç->almacı, akaç->akacı, avuç->avucu
+                                        if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                            formation = stem.substring(0, stem.length - 1) + 'c';
+                                        }
+                                        break;
+                                    case 'g':
+                                        //arkeolog->arkeoloğu, filolog->filoloğu, minerolog->mineroloğu
+                                        if (this.startWithVowelorConsonantDrops() && rootWord && this.softenDuringSuffixation(root)) {
+                                            formation = stem.substring(0, stem.length - 1) + 'ğ';
+                                        }
+                                        break;
+                                    case 'k':
+                                        //ahenk->ahengi, künk->küngü, renk->rengi, pelesenk->pelesengi
+                                        if (this.startWithVowelorConsonantDrops() && rootWord && root.endingKChangesIntoG() &&
+                                            (!root.isProperNoun() || startState.toString() != "ProperRoot")) {
+                                            formation = stem.substring(0, stem.length - 1) + 'g';
+                                        } else {
+                                            //ablak->ablağı, küllük->küllüğü, kitaplık->kitaplığı, evcilik->evciliği
+                                            if (this.startWithVowelorConsonantDrops() && (!rootWord ||
+                                                (this.softenDuringSuffixation(root) && (!root.isProperNoun() ||
+                                                    startState.toString() != "ProperRoot")))) {
+                                                formation = stem.substring(0, stem.length - 1) + 'ğ';
+                                            }
+                                        }
+                                        break;
+                                }
+                                this.formationToCheck = formation;
+                            }
+                        }
+                    }
+                }
+            }
+            if (TurkishLanguage.isConsonantDrop(this.withFirstChar()) &&
+                !TurkishLanguage.isVowel(stem.charAt(stem.length - 1)) &&
+                (root.isNumeral() || root.isReal() || root.isFraction() || root.isTime() || root.isDate() ||
+                    root.isPercent() || root.isRange()) && (root.getName().endsWith("1") || root.getName().endsWith("3") ||
+                    root.getName().endsWith("4") || root.getName().endsWith("5") || root.getName().endsWith("8") ||
+                    root.getName().endsWith("9") || root.getName().endsWith("10") || root.getName().endsWith("30") ||
+                    root.getName().endsWith("40") || root.getName().endsWith("60") || root.getName().endsWith("70") ||
+                    root.getName().endsWith("80") || root.getName().endsWith("90") || root.getName().endsWith("00"))) {
+                if (this._with.charAt(0) == '\'') {
+                    formation = formation + '\'';
+                    i = 2;
+                } else {
+                    i = 1;
+                }
+            } else {
+                if ((TurkishLanguage.isConsonantDrop(this.withFirstChar()) && TurkishLanguage.isConsonant(this.lastPhoneme(stem))) ||
+                    (rootWord && root.consonantSMayInsertedDuringPossesiveSuffixation())) {
+                    if (this._with.charAt(0) == '\'') {
+                        formation = formation + '\'';
+                        if (root.isAbbreviation())
+                            i = 1;
+                        else
+                            i = 2;
+                    } else {
+                        i = 1;
+                    }
+                }
+            }
+            for (; i < this._with.length; i++) {
+                switch (this._with.charAt(i)) {
+                    case 'D':
+                        formation = this.resolveD(root, formation);
+                        break;
+                    case 'A':
+                        formation = this.resolveA(root, formation, rootWord);
+                        break;
+                    case 'H':
+                        if (this._with.charAt(0) != '\'') {
+                            formation = this.resolveH(root, formation, i == 0, this._with.startsWith("Hyor"), rootWord);
+                        } else {
+                            formation = this.resolveH(root, formation, i == 1, false, rootWord);
+                        }
+                        break;
+                    case 'C':
+                        formation = this.resolveC(formation);
+                        break;
+                    case 'S':
+                        formation = this.resolveS(formation);
+                        break;
+                    case 'Ş':
+                        formation = this.resolveSh(formation);
+                        break;
+                    default:
+                        if (i == this._with.length - 1 && this._with.charAt(i) == 's') {
+                            formation += 'ş';
+                        } else {
+                            formation += this._with.charAt(i);
+                        }
+                }
+                this.formationToCheck = formation;
+            }
+            return formation;
+        }
+    }
+
+    private resolveD(root: TxtWord, formation: string): string{
+        if (root.isAbbreviation()) {
+            return formation + 'd';
+        }
+        if (this.lastPhoneme(this.formationToCheck) >= '0' && this.lastPhoneme(this.formationToCheck) <= '9') {
+            switch (this.lastPhoneme(this.formationToCheck)) {
+                case '3':
+                case '4':
+                case '5':
+                    //3->3'tü, 5->5'ti, 4->4'tü
+                    return formation + 't';
+                case '0':
+                    if (root.getName().endsWith("40") || root.getName().endsWith("60") || root.getName().endsWith("70"))
+                        //40->40'tı, 60->60'tı, 70->70'ti
+                        return formation + 't';
+                    else
+                        //30->30'du, 50->50'ydi, 80->80'di
+                        return formation + 'd';
+                default:
+                    return formation + 'd';
+            }
+        } else {
+            if (TurkishLanguage.isSertSessiz(this.lastPhoneme(this.formationToCheck))) {
+                //yap+DH->yaptı
+                return formation + 't';
+            } else {
+                //sar+DH->sardı
+                return formation + 'd';
+            }
+        }
+    }
+
+    private resolveA(root: TxtWord, formation: string, rootWord: boolean): string{
+        if (root.isAbbreviation()) {
+            return formation + 'e';
+        }
+        if (this.lastVowel(this.formationToCheck) >= '0' && this.lastVowel(this.formationToCheck) <= '9') {
+            switch (this.lastVowel(this.formationToCheck)) {
+                case '6':
+                case '9':
+                    //6'ya, 9'a
+                    return formation + 'a';
+                case '0':
+                    if (root.getName().endsWith("10") || root.getName().endsWith("30") || root.getName().endsWith("40") ||
+                        root.getName().endsWith("60") || root.getName().endsWith("90"))
+                        //10'a, 30'a, 40'a, 60'a, 90'a
+                        return formation + 'a';
+                    else
+                        //20'ye, 50'ye, 80'e, 70'e
+                        return formation + 'e';
+                default:
+                    //3'e, 8'e, 4'e, 2'ye
+                    return formation + 'e';
+            }
+        }
+        if (TurkishLanguage.isBackVowel(this.lastVowel(this.formationToCheck))) {
+            if (root.notObeysVowelHarmonyDuringAgglutination() && rootWord) {
+                //alkole, anormale
+                return formation + 'e';
+            } else {
+                //sakala, kabala
+                return formation + 'a';
+            }
+        }
+        if (TurkishLanguage.isFrontVowel(this.lastVowel(this.formationToCheck))) {
+            if (root.notObeysVowelHarmonyDuringAgglutination() && rootWord) {
+                //faika, halika
+                return formation + 'a';
+            } else {
+                //kediye, eve
+                return formation + 'e';
+            }
+        }
+        if (root.isNumeral() || root.isFraction() || root.isReal()) {
+            if (root.getName().endsWith("6") || root.getName().endsWith("9") || root.getName().endsWith("10") ||
+                root.getName().endsWith("30") || root.getName().endsWith("40") || root.getName().endsWith("60") ||
+                root.getName().endsWith("90")) {
+                return formation + 'a';
+            } else {
+                return formation + 'e';
+            }
+        }
+        return formation;
+    }
+
+    private resolveH(root: TxtWord, formation: string, beginningOfSuffix: boolean,
+                            specialCaseTenseSuffix: boolean, rootWord: boolean): string{
+        if (root.isAbbreviation())
+            return formation + 'i';
+        if (beginningOfSuffix && TurkishLanguage.isVowel(this.lastPhoneme(this.formationToCheck)) &&
+            !specialCaseTenseSuffix) {
+            return formation;
+        }
+        if (specialCaseTenseSuffix) {
+            //eğer ek Hyor eki ise,
+            if (rootWord) {
+                if (root.vowelAChangesToIDuringYSuffixation()) {
+                    if (TurkishLanguage.isFrontRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        //büyülüyor, bölümlüyor, çözümlüyor, döşüyor
+                        return formation.substring(0, formation.length - 1) + 'ü';
+                    }
+                    if (TurkishLanguage.isFrontUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        //adresliyor, alevliyor, ateşliyor, bekliyor
+                        return formation.substring(0, formation.length - 1) + 'i';
+                    }
+                    if (TurkishLanguage.isBackRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        //buğuluyor, bulguluyor, çamurluyor, aforozluyor
+                        return formation.substring(0, formation.length - 1) + 'u';
+                    }
+                    if (TurkishLanguage.isBackUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                        //açıklıyor, çalkalıyor, gazlıyor, gıcırdıyor
+                        return formation.substring(0, formation.length - 1) + 'ı';
+                    }
+                }
+            }
+            if (TurkishLanguage.isVowel(this.lastPhoneme(this.formationToCheck))) {
+                if (TurkishLanguage.isFrontRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                    return formation.substring(0, formation.length - 1) + 'ü';
+                }
+                if (TurkishLanguage.isFrontUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                    return formation.substring(0, formation.length - 1) + 'i';
+                }
+                if (TurkishLanguage.isBackRoundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                    return formation.substring(0, formation.length - 1) + 'u';
+                }
+                if (TurkishLanguage.isBackUnroundedVowel(this.beforeLastVowel(this.formationToCheck))) {
+                    return formation.substring(0, formation.length - 1) + 'ı';
+                }
+            }
+        }
+        if (TurkishLanguage.isFrontRoundedVowel(this.lastVowel(this.formationToCheck)) ||
+            (TurkishLanguage.isBackRoundedVowel(this.lastVowel(this.formationToCheck)) && root.notObeysVowelHarmonyDuringAgglutination())) {
+            return formation + 'ü';
+        }
+        if (TurkishLanguage.isFrontUnroundedVowel(this.lastVowel(this.formationToCheck)) ||
+            (this.lastVowel(this.formationToCheck) == 'a' && root.notObeysVowelHarmonyDuringAgglutination())) {
+            return formation + 'i';
+        }
+        if (TurkishLanguage.isBackRoundedVowel(this.lastVowel(this.formationToCheck))) {
+            return formation + 'u';
+        }
+        if (TurkishLanguage.isBackUnroundedVowel(this.lastVowel(this.formationToCheck))) {
+            return formation + 'ı';
+        }
+        if (root.isNumeral() || root.isFraction() || root.isReal()) {
+            if (root.getName().endsWith("6") || root.getName().endsWith("40") || root.getName().endsWith("60") ||
+                root.getName().endsWith("90")) {
+                //6'yı, 40'ı, 60'ı
+                return formation + 'ı';
+            } else {
+                if (root.getName().endsWith("3") || root.getName().endsWith("4") || root.getName().endsWith("00")) {
+                    //3'ü, 4'ü, 100'ü
+                    return formation + 'ü';
+                } else {
+                    if (root.getName().endsWith("9") || root.getName().endsWith("10") || root.getName().endsWith("30")) {
+                        //9'u, 10'u, 30'u
+                        return formation + 'u';
+                    } else {
+                        //2'yi, 5'i, 8'i
+                        return formation + 'i';
+                    }
+                }
+            }
+        }
+        return formation;
+    }
+
+    /**
+     * The resolveC method takes a {@link String} formation as an input. If the last phoneme is on of the "çfhkpsşt", it
+     * concatenates given formation with 'ç', if not it concatenates given formation with 'c'.
+     *
+     * @param formation {@link String} input.
+     * @return resolved String.
+     */
+    private resolveC(formation: string): string{
+        if (TurkishLanguage.isSertSessiz(this.lastPhoneme(this.formationToCheck))) {
+            return formation + 'ç';
+        } else {
+            return formation + 'c';
+        }
+    }
+
+    /**
+     * The resolveS method takes a {@link String} formation as an input. It then concatenates given formation with 's'.
+     *
+     * @param formation {@link String} input.
+     * @return resolved String.
+     */
+    private resolveS(formation: string): string{
+        return formation + 's';
+    }
+
+    /**
+     * The resolveSh method takes a {@link String} formation as an input. If the last character is a vowel, it concatenates
+     * given formation with ş, if the last character is not a vowel, and not 't' it directly returns given formation, but if it
+     * is equal to 't', it transforms it to 'd'.
+     *
+     * @param formation {@link String} input.
+     * @return resolved String.
+     */
+    private resolveSh(formation: string): string{
+        if (TurkishLanguage.isVowel(formation.charAt(formation.length - 1))) {
+            return formation + 'ş';
+        } else {
+            if (formation.charAt(formation.length - 1) != 't')
+                return formation;
+            else
+                return formation.substring(0, formation.length - 1) + 'd';
+        }
+    }
+
+    /**
+     * An overridden toString method which returns the with variable.
+     *
+     * @return with variable.
+     */
+    toString(): string{
+        return this._with
+    }
+
+    /**
+     * The with method returns the withName variable.
+     *
+     * @return the withName variable.
+     */
+    getWith(): string{
+        return this.withName
+    }
+}