public string Lemmatize(string sWord, bool ignoreCase, string sMsd)
        {
            if (sWord.Length >= iSimilarity && dictSubNodes != null)
            {
                //try first correct casing
                char chChar = sWord.Length > iSimilarity ? sWord[sWord.Length - 1 - iSimilarity] : '\0';
                if (dictSubNodes.ContainsKey(chChar) && dictSubNodes[chChar].ConditionSatisfied(sWord, ignoreCase, sMsd))
                {
                    return(dictSubNodes[chChar].Lemmatize(sWord, ignoreCase, sMsd));
                }

                //try also inversed casing
                if (ignoreCase && char.IsLetter(chChar))
                {
                    char chCharInvert = char.IsLower(chChar) ? char.ToUpper(chChar) : char.ToLower(chChar);
                    if (dictSubNodes.ContainsKey(chCharInvert) && dictSubNodes[chCharInvert].ConditionSatisfied(sWord, ignoreCase, sMsd))
                    {
                        return(dictSubNodes[chCharInvert].Lemmatize(sWord, ignoreCase, sMsd));
                    }
                }
            }
            if (lsett.eMsdConsider == LemmatizerSettings.MsdConsideration.Distinct && sMsd != null)
            {
                LemmaRule     lrBestValid = null;
                LemmaTreeNode ltnValid    = this;

                bool useNoMsd = false;
                while (lrBestValid == null && useNoMsd == false)
                {
                    if (ltnValid.dictMsdBestRules.ContainsKey(sMsd))
                    {
                        lrBestValid = ltnValid.dictMsdBestRules[sMsd][0].Rule;
                    }
                    else
                    {
                        if (ltnValid.ltnParentNode != null)
                        {
                            ltnValid = ltnValid.ltnParentNode;
                        }
                        else
                        {
                            useNoMsd = true;
                        }
                    }
                }

                if (useNoMsd)
                {
                    return(ltnValid.lrBestRule.Lemmatize(sWord));
                }
                else
                {
                    return(lrBestValid.Lemmatize(sWord));
                }
            }
            else
            {
                return(lrBestRule.Lemmatize(sWord));
            }
        }
        public string Lemmatize(string sWord)
        {
            if (sWord.Length >= iSimilarity && dictSubNodes != null)
            {
                char chChar = sWord.Length > iSimilarity ? sWord[sWord.Length - 1 - iSimilarity] : '\0';
                if (dictSubNodes.ContainsKey(chChar) && dictSubNodes[chChar].ConditionSatisfied(sWord))
                {
                    return(dictSubNodes[chChar].Lemmatize(sWord));
                }
            }

            return(lrBestRule.Lemmatize(sWord));
        }
Exemple #3
0
        public string Lemmatize(string sWord)
        {
            if (sWord.Length >= iSimilarity && dictSubNodes != null)
            {
                // to lower in case the word is uppercase
                char chChar = char.ToLower(sWord.Length > iSimilarity ? sWord[sWord.Length - 1 - iSimilarity] : '\0');
                if (dictSubNodes.ContainsKey(chChar) && dictSubNodes[chChar].ConditionSatisfied(sWord))
                {
                    return(dictSubNodes[chChar].Lemmatize(sWord));
                }
            }

            return(lrBestRule.Lemmatize(sWord));
        }