コード例 #1
0
        static List <WordInfo> RecallCorrections(ArabicWord Word, List <WordInfo> CurrentWordInfo)
        {
            OleDbCommand com = new OleDbCommand();

            com.Connection  = con;
            com.CommandText = "Select * from corrections where word = '" + Word.word + "' order by Occured asc";
            OleDbDataReader dread = com.ExecuteReader();

            if (dread.Read())
            {
                Word.Corrected = true;
                Corrections++;
                do
                {
                    for (int W = 0; W < CurrentWordInfo.Count; W++)
                    {
                        if (CurrentWordInfo[W].Diacritics == dread["Diacritics"].ToString() && CurrentWordInfo[W].CompleteMeaning == dread["Meaning"].ToString())
                        {
                            WordInfo Temp;
                            for (int prev = W; prev > 0; prev--)
                            {
                                Temp = CurrentWordInfo[prev];
                                CurrentWordInfo[prev]     = CurrentWordInfo[prev - 1];
                                CurrentWordInfo[prev - 1] = Temp;
                            }
                        }
                    }
                } while (dread.Read());
            }
            dread.Close();
            return(CurrentWordInfo);
        }
コード例 #2
0
        //استخراج الكلمات العربية المحتوية على الأحرف العربية المعتادة
        public static List <ArabicWord> ExtractArabicWords(string EntireText, out int NumberOfSentences)
        {
            NumberOfSentences = 0;
            int WordStartAt = -1;
            int WordEndAt   = -1;
            int Unicode;
            List <ArabicWord> ArabicWords = new List <ArabicWord>();

            for (int i = 0; i < EntireText.Length; i++)
            {
                Unicode = EntireText[i];
                if (Unicode >= 1569 && Unicode <= 1618) //إذا كان الحرف من الحروف العربية المعتادة
                {
                    if (WordStartAt == -1)
                    {
                        WordStartAt = i;
                    }
                    if (i + 1 == EntireText.Length)
                    {
                        WordEndAt = i;
                    }
                }
                else //حرف غير عربي
                {
                    if (WordStartAt >= 0)
                    {
                        WordEndAt = i - 1;
                    }
                }

                if (WordStartAt >= 0 && WordEndAt >= 0) //كلمة عربية كاملة
                {
                    ArabicWord NewWord = new ArabicWord();
                    NewWord.Start    = WordStartAt;
                    NewWord.End      = WordEndAt;
                    NewWord.Original = EntireText.Substring(WordStartAt, WordEndAt - WordStartAt + 1);
                    ArabicWords.Add(NewWord);
                    WordStartAt = -1;
                    WordEndAt   = -1;
                }

                //هل يحدد نهاية جملة
                if (i > 0 && ArabicWords.Count > 0 && ArabicWords[ArabicWords.Count - 1].word != "EOS")
                {
                    if (i + 1 == EntireText.Length || Unicode == '\n' || (Unicode == '.' && (i + 1 == EntireText.Length || !char.IsDigit(EntireText[i + 1]))) || Unicode == '؛')
                    {
                        ArabicWord NewWord = new ArabicWord();
                        NewWord.Original = "EOS";
                        ArabicWords.Add(NewWord);
                        NumberOfSentences++;
                    }
                }
            }
            return(ArabicWords);
        }
コード例 #3
0
ファイル: Morphology.cs プロジェクト: marwa-khald/marwa
        public static void CheckForPronoun(ArabicWord WordToProcess, ref List <WordInfo> Possibilities)
        {
            WordInfo     NewInfo;
            OleDbCommand com = new OleDbCommand("Select * from ProperNouns where Word='" + WordToProcess.word + "'");

            com.Connection = Analyzer.con;
            OleDbDataReader dread = com.ExecuteReader();

            while (dread.Read())
            {
                NewInfo              = new WordInfo();
                NewInfo.Meaning      = dread["meaning"].ToString();
                NewInfo.SpecialClass = "PN";
                NewInfo.Word         = WordToProcess.word;
                NewInfo.Diacritics   = dread["Diacritics"].ToString();
                Possibilities.Add(NewInfo);
            }
            dread.Close();
        }
コード例 #4
0
        private static List <WordInfo> ProcessWord(ArabicWord WordToProcess)
        {
            List <WordInfo> CurrentWordInfo = new List <WordInfo>();
            WordInfo        NewInfo;

            Morphology.CheckForSpecialWord(WordToProcess, ref CurrentWordInfo);
            Morphology.CheckForPronoun(WordToProcess, ref CurrentWordInfo);
            if (FastAnalysis && CurrentWordInfo.Count > 0) //للاكتفاء باحتمالات الكلمات الخاصة وعدم البحث عن تحليل صرفي لأسماء أو أفعال
            {
                return(CurrentWordInfo);
            }
            List <WordPrefix> ValidPrefixes = WordPrefix.CheckPrefix(WordToProcess.word);
            List <WordSuffix> ValidSuffixes = WordSuffix.CheckSuffixes(WordToProcess.word);

            //المعاني الافتراضية عند عدم وجود إضافات
            ValidPrefixes.Add(new WordPrefix()
            {
                WordClass = "N1"
            });                                                      //الأسماء نكرة
            ValidPrefixes.Add(new WordPrefix()
            {
                WordClass = "V1"
            });                                                      //فعل ماض
            ValidPrefixes.Add(new WordPrefix()
            {
                WordClass = "V3"
            });                                                      //فعل أمر

            ValidSuffixes.Add(new WordSuffix()
            {
                WordClass = "N0001"
            });                                                         //اسم مذكر
            ValidSuffixes.Add(new WordSuffix()
            {
                WordClass = "V10311"
            });                                                          //فعل ماض غائب مفرد مذكر
            ValidSuffixes.Add(new WordSuffix()
            {
                WordClass = "V20211"
            });                                                          //فعل مضارع مخاطب مفرد مذكر
            ValidSuffixes.Add(new WordSuffix()
            {
                WordClass = "V201"
            });                                                        //فعل مضارع متكلم
            ValidSuffixes.Add(new WordSuffix()
            {
                WordClass = "V2031"
            });                                                         //فعل مضارع غائب مفرد
            ValidSuffixes.Add(new WordSuffix()
            {
                WordClass = "V30011"
            });                                                          //فعل أمر مفرد مذكر
            List <string[]> Result = new List <string[]>();
            string          Stem;

            for (int i = 0; i < ValidPrefixes.Count; i++)
            {
                for (int j = 0; j < ValidSuffixes.Count; j++)
                {
                    Result = new List <string[]>();

                    if (WordToProcess.word.Length <= (ValidSuffixes[j].Text.Length + ValidPrefixes[i].Text.Length))
                    {   //طول الإضافات يغطي طول الكلمة بأكملها
                        continue;
                    }
                    List <string> CompatibleAdditions = Morphology.CheckAdditionsCompatibility(ValidPrefixes[i].WordClass, ValidSuffixes[j].WordClass);
                    if (CompatibleAdditions.Count == 0)
                    {   //إضافات غير متوافقة
                        continue;
                    }
                    Stem = WordToProcess.word.Substring(ValidPrefixes[i].Text.Length, WordToProcess.word.Length - (ValidPrefixes[i].Text.Length + ValidSuffixes[j].Text.Length));
                    //ابحث عن الأوزان المتوافقة مع الإضافات المحددة
                    Result = Morphology.LookForTemplate(Stem, CompatibleAdditions, Result);
                    if (Result.Count == 0)
                    {
                        continue;
                    }

                    /* اختبار وجود جذر للكلمة متوافق مع الوزن المحدد
                     * واختبار توافق الجذر الموجود مع هذا الوزن
                     * يمكن الاستغناء عن بعض هذه الخطوات عند إكمال قاعدة البيانات
                     *
                     */

                    #region اختبار توافق الوزن والجذر
                    string[]          CurrentResult;
                    ArabicRoot        CurrentRoot      = new ArabicRoot();
                    List <ArabicRoot> CheckRootResults = new List <ArabicRoot>();
                    for (int R = 0; R < Result.Count; R++)
                    {
                        CurrentResult = Result[R];
                        bool RootResult = Morphology.CheckRoot(Stem, CurrentResult[2], CurrentResult[4], CurrentResult[5], CurrentResult[6], CurrentResult[7], ref CurrentResult[3], ref CurrentRoot);
                        if (!RootResult) //اختبار وجود الجذر حسب الوزن
                        {
                            Result.RemoveAt(R);
                            R--;
                        }
                        else
                        {
                            if (CurrentRoot.IsCompatible)
                            {
                                for (int prev = 0; prev < R; prev++)
                                {
                                    //عثر على جذر متوافق احذف كل الأوزان السابقة التي ليس لها جذور متوافقة
                                    if (!CheckRootResults[prev].IsCompatible)
                                    {
                                        Result.RemoveAt(prev);
                                        CheckRootResults.RemoveAt(prev);
                                        R--;
                                        prev--;
                                    }
                                }
                                CheckRootResults.Add(CurrentRoot);
                            }
                            else
                            {
                                bool AddThisOne = true;
                                for (int prev = 0; prev < R; prev++)
                                {
                                    if (CheckRootResults[prev].IsCompatible)
                                    {
                                        AddThisOne = false; //عثر من قبل على جذور متوافقة لها أولوية
                                        Result.RemoveAt(R--);
                                        break;
                                    }
                                    //مفاضلة الأوزان من نفس قاعدة الاشتقاق
                                    byte CompareResult = Morphology.CompareRules(CurrentResult[7], Result[prev][7]);
                                    if (CompareResult == 1)
                                    {
                                        CheckRootResults.RemoveAt(prev);
                                        Result.RemoveAt(prev--);
                                        R--;
                                    }
                                    else if (CompareResult == 2)//الوزن المضاف مسبقا أولى
                                    {
                                        AddThisOne = false;
                                        Result.RemoveAt(R--);
                                        break;
                                    }
                                }
                                if (AddThisOne)
                                {
                                    CheckRootResults.Add(CurrentRoot);
                                }
                            }
                        }
                    }
                    #endregion

                    for (int R = 0; R < Result.Count; R++)
                    {
                        NewInfo            = new WordInfo();
                        NewInfo.Word       = Stem;
                        NewInfo.Diacritics = Result[R][1];
                        NewInfo.Prefix     = ValidPrefixes[i];
                        NewInfo.Suffix     = ValidSuffixes[j];
                        Tashkeel.DiacritizeWord(NewInfo);
                        if (!IgnoreExistingDiacritics && !CheckOriginalDiacritics(WordToProcess.Original, NewInfo.FullDiacritics))
                        {
                            continue;
                        }

                        NewInfo.Template = Result[R][0];
                        NewInfo.Meaning  = Result[R][3];
                        NewInfo.Root     = CheckRootResults[R];
                        CurrentWordInfo.Add(NewInfo);
                    }
                }
            }

            for (int W = 0; W < CurrentWordInfo.Count; W++)
            {
                if (CurrentWordInfo[W].Root.IsCompatible)
                {
                    WordInfo Temp;
                    for (int prev = W; prev > 0; prev--)
                    {
                        Temp = CurrentWordInfo[prev];
                        CurrentWordInfo[prev]     = CurrentWordInfo[prev - 1];
                        CurrentWordInfo[prev - 1] = Temp;
                    }
                }
            }
            CurrentWordInfo = RecallCorrections(WordToProcess, CurrentWordInfo);
            return(CurrentWordInfo);
        }