private void button2_Click(object sender, EventArgs e)
        {
            GRAMCLASS gramclass = new GRAMCLASS();

            if (MemoryClass.Instance.IsEmptyBigramList())
            {
                gramclass.BiGram2(MemoryClass.Instance.Get_Sentences_From_OldCorpus() == ""?Regex_Patterns.Instance.Get_Corpus():MemoryClass.Instance.Get_Sentences_From_OldCorpus(), true);
            }

            GRAMCLASS gc = new GRAMCLASS();

            string currentSentence = string.Empty;

            //dataGridView1.Columns.Clear();
            DataTable mytable = new DataTable();

            mytable.Columns.Add("Sentence", typeof(string));
            mytable.Columns.Add("Probability", typeof(double));

            DataRow row;
            double  SumProbability = 0;

            for (int index_gridview_row = 0; index_gridview_row < dataGridView1.Rows.Count - 1; index_gridview_row++)
            {
                //foreach (string sentence in )

                currentSentence = dataGridView1[0, index_gridview_row].Value.ToString();
                ArrayList         SS         = gc.Seperator_Phase4(currentSentence, false);
                double            PDF        = 1;
                StructData_BiGram dataBigram = new StructData_BiGram();
                for (int i = 1; i < SS.Count; i++)
                {
                    dataBigram.CurrentToken = (string)SS[i].ToString().ToLower();
                    dataBigram.PrevToken    = (string)SS[i - 1].ToString().ToLower();
                    if (MemoryClass.Instance.GetListBigram.Exists(s => s.CurrentToken == dataBigram.CurrentToken && s.PrevToken == dataBigram.PrevToken))
                    {
                        StructData_BiGram bigrm = MemoryClass.Instance.GetListBigram[MemoryClass.Instance.GetListBigram.FindIndex(s => s.CurrentToken == dataBigram.CurrentToken && s.PrevToken == dataBigram.PrevToken)];

                        PDF *= Math.Pow(bigrm.Probability, (double)1 / SS.Count);
                    }
                    else
                    {
                        PDF = 0;
                    }
                }

                row             = mytable.NewRow();
                row[0]          = currentSentence;
                row[1]          = PDF; //*((double)currentSentence.Length/Max_Index);
                SumProbability += PDF; // *((double)currentSentence.Length / Max_Index);
                mytable.Rows.Add(row);
            }


            DataSet ds = new DataSet();

            ds.Tables.Add(mytable);
            dataGridView1.DataSource = ds.Tables[0].AsDataView();
            lblAverageResult.Text    = ((double)SumProbability / Regex_Patterns.Instance.GetSentenceList.Count).ToString();
        }
        private void button3_Click_1(object sender, EventArgs e)
        {
            GRAMCLASS gc = new GRAMCLASS();

            if (MemoryClass.Instance.isEmptyTrigramList())
            {
                gc.TriGram2(MemoryClass.Instance.Get_Sentences_From_OldCorpus(), true);
            }


            string currentSentence = string.Empty;

            DataTable mytable = new DataTable();

            mytable.Columns.Add("Sentence", typeof(string));
            mytable.Columns.Add("Probability", typeof(double));

            DataRow row;

            double SumProbability = 0;

            for (int rowIndex = 0; rowIndex < (dataGridView1.Rows.Count - 1); rowIndex++)
            {
                currentSentence = dataGridView1[0, rowIndex].Value.ToString();
                ArrayList          SS          = gc.Seperator_Phase4(currentSentence, false);
                double             PDF         = 1;
                StructData_TriGram dataTrigram = new StructData_TriGram();
                for (int i = 2; i < SS.Count; i++)
                {
                    dataTrigram.CurrentToken  = ((string)SS[i]).ToLower();
                    dataTrigram.PrevToken     = ((string)SS[i - 1]).ToLower();
                    dataTrigram.PrevPrevToken = ((string)SS[i - 2]).ToLower();
                    if (MemoryClass.Instance.GetListTrigram.Exists(s => s.CurrentToken == dataTrigram.CurrentToken && s.PrevToken == dataTrigram.PrevToken && s.PrevPrevToken == dataTrigram.PrevPrevToken))
                    {
                        StructData_TriGram trigrm = MemoryClass.Instance.GetListTrigram[gc.ListTrigram.FindIndex(s => s.CurrentToken == dataTrigram.CurrentToken &&
                                                                                                                 s.PrevToken == dataTrigram.PrevToken && s.PrevPrevToken == dataTrigram.PrevPrevToken)];

                        int root = (trigrm.Probability != 1) ? trigrm.Probability.ToString().Remove(0, 2).Length : 1;
                        PDF *= Math.Pow(trigrm.Probability, (double)1 / SS.Count);
                    }
                    else
                    {
                        PDF = 0;
                    }
                }

                row             = mytable.NewRow();
                row[0]          = currentSentence;
                row[1]          = (PDF); // *((double)currentSentence.Length / Max_Index);
                SumProbability += (PDF); // *((double)currentSentence.Length / Max_Index);
                mytable.Rows.Add(row);
            }
            DataSet ds = new DataSet();

            ds.Tables.Add(mytable);
            dataGridView1.DataSource = ds.Tables[0].AsDataView();
            lblAverageResult.Text    = ((double)SumProbability / Regex_Patterns.Instance.GetSentenceList.Count).ToString();
        }
        private void button4_Click_1(object sender, EventArgs e)
        {
            GRAMCLASS gramclass = new GRAMCLASS();

            DataTable table = new DataTable();

            table.Columns.Add("sentence", typeof(string));
            table.Columns.Add("Probability", typeof(double));
            DataRow row;

            double SumProbability     = 0;
            int    CountOfTotalTokens = MemoryClass.Instance.Get_CountOfTotalTokens();

            string sentence = string.Empty;

            //foreach (string sentence in Regex_Patterns.Instance.GetSentenceList)
            for (int index_row = 0; index_row < dataGridView1.Rows.Count - 1; index_row++)
            {
                sentence = dataGridView1.Rows[index_row].Cells[0].Value.ToString();

                ArrayList al  = gramclass.Seperator_Phase4(sentence, false);
                double    PDF = 1;

                foreach (string token in al)
                {
                    int Count = MemoryClass.Instance.Get_CountOfSpecialToken_Unigram(token);
                    if (Count != -1)
                    {
                        PDF *= (double)MemoryClass.Instance.Get_CountOfSpecialToken_Unigram(token) / CountOfTotalTokens;
                    }
                    else
                    {
                        PDF = 0;
                        break;
                    }
                }
                row             = table.NewRow();
                row[0]          = sentence;
                row[1]          = PDF;
                SumProbability += (PDF);
                table.Rows.Add(row);
            }
            DataSet ds = new DataSet();

            ds.Tables.Add(table);
            dataGridView1.DataSource = ds.Tables[0].AsDataView();
            lblAverageResult.Text    = ((double)SumProbability / Regex_Patterns.Instance.GetSentenceList.Count).ToString();
        }
        private void Show_Phase4_TO_GridView(Form f, DataSet ds, bool isTrigram)
        {
            DataTable table1 = new DataTable();

            table1.Columns.Add("Setntence", typeof(string));
            table1.Columns.Add("Probability", typeof(double));
            DataRow      r;
            DataGridView dg2 = ((DataGridView)f.Controls[f.Controls.IndexOfKey("grid_sentences")]);

            GRAMCLASS gl = new GRAMCLASS();
            List <StructData_BiGram>  bigram  = new List <StructData_BiGram>();//= gl.BiGram(Regex_Patterns.Instance.Tape);
            List <StructData_TriGram> trigram = new List <StructData_TriGram>();
            string sentences = string.Empty;

            foreach (string sentence in Regex_Patterns.Instance.GetSentenceList)
            {
                sentences += sentence;
            }
            if (isTrigram)
            {
                trigram = gl.TriGram(sentences.ToLower());
            }
            else
            {
                bigram = gl.BiGram(sentences.ToLower());
            }

            //bool isFirst = true;
            double Avg = 0;

            foreach (DataGridViewRow row in dg2.Rows)
            {
                if (row.Cells[0].Value != null)
                {
                    string sentence = string.Empty;

                    sentence = row.Cells[0].Value.ToString();

                    ArrayList new_SeperatedSentence = gl.Seperator_Phase4(sentence, isTrigram);// BiGram

                    r    = table1.NewRow();
                    r[0] = row.Cells[0].Value.ToString();
                    double currentProbability;
                    if (isTrigram)
                    {
                        currentProbability = gl.Verify_Sentence(new_SeperatedSentence, trigram, isTrigram);
                    }
                    else
                    {
                        currentProbability = gl.Verify_Sentence(new_SeperatedSentence, bigram, isTrigram);
                    }

                    r[1] = currentProbability;
                    Avg += currentProbability;

                    table1.Rows.Add(r);
                }
            }
            ds.Tables.Add(table1);
            DataView dv = new DataView();

            dv      = ds.Tables[1].AsDataView();
            dv.Sort = "Probability ASC";
            dataGridView1.DataSource = dv;
            lblAverageResult.Text    = ((double)Avg / (dataGridView1.Rows.Count - 1)).ToString();
        }