Example #1
0
 public void Dodaj(Deskryptor deskryptor)
 {
     deskryptory.Add(deskryptor);
 }
Example #2
0
        static void GenerujRegulyLema(int[,] aSystemDecyzyjny)
        {
            List <int>    listaDecyzji = GenerujListeDecyzji(aSystemDecyzyjny);
            List <Regula> listaRegol   = new List <Regula>();

            // Przechodzimy przez wszystkie koncepty
            foreach (int koncept in listaDecyzji)
            {
                bool lPokrytyKoncept = false;

                // petla bedze przebiegac az pokryjemy caly koncept, czyli az wygenerujemy reguly dla kazdego obiektu rozpatrywanego konceptu
                do
                {
                    bool       lRegSprzeczna = false;
                    Regula     regula        = new Regula(koncept);
                    List <int> listaWyklArg  = new List <int>();            // lista argumentow na ktorych mamy deskryptory
                    List <int> listaWyklObj  = new List <int>();            // lista obiektow ktore sa wykluczone (sprawdzanie sprzecznosci)

                    Deskryptor NajczestszyDesc;
                    Deskryptor PorownywanyDesc;

                    do           // rzezbimy regule dopoki nie jest sprzeczna
                    {
                        // zerujemy na start
                        NajczestszyDesc = null;
                        PorownywanyDesc = null;

                        lRegSprzeczna = false;

                        //generujemy ktore obiekty sa do wykluczenia
                        listaWyklObj = new List <int>();     // resetujemy - sprzecznosc
                        for (int obiekt = 0; obiekt < aSystemDecyzyjny.GetLength(0); obiekt++)
                        {
                            bool lPasuje = true;

                            // inny koncept
                            if (lPasuje && aSystemDecyzyjny[obiekt, aSystemDecyzyjny.GetLength(1) - 1] != koncept)
                            {
                                listaWyklObj.Add(obiekt);
                                lPasuje = false;
                            }

                            // wykluczamy obiekty ktorych nie dotyczy sprzeczna regula jezeli jest
                            if (lPasuje && regula.deskryptory.Count() > 0)
                            {
                                foreach (Deskryptor deskryptor in regula.deskryptory)
                                {
                                    if (aSystemDecyzyjny[obiekt, deskryptor.argument] != deskryptor.wartosc)
                                    {
                                        lPasuje = false;
                                        listaWyklObj.Add(obiekt);
                                        break;
                                    }
                                }
                            }

                            // obiekty z ktorych sa juz zbudowane reguly
                            if (lPasuje)
                            {
                                foreach (Regula Item in listaRegol)
                                {
                                    if (Item.obiekty.Contains(obiekt))
                                    {
                                        listaWyklObj.Add(obiekt);
                                        lPasuje = false;
                                        break;
                                    }
                                }
                            }

                            //wyjscie
                            if (!lPasuje)
                            {
                                continue;
                            }
                        }

                        for (int argument = 0; argument < aSystemDecyzyjny.GetLength(1) - 1; argument++)
                        {
                            // wykluczamy argumenty na ktory juz sa wybrane deskryptory
                            if (listaWyklArg.Contains(argument))
                            {
                                continue;
                            }

                            for (int obiekt = 0; obiekt < aSystemDecyzyjny.GetLength(0); obiekt++)
                            {
                                // wykluczamy obiekty nalezace do listy obiektow wykluczonych
                                if (listaWyklObj.Contains(obiekt))
                                {
                                    continue;
                                }

                                int nPokrycie = 0;          // ilosc wystapien
                                int wartosc   = aSystemDecyzyjny[obiekt, argument];

                                //liczymy liczbe wystapien w kolumnie
                                for (int wiersz = 0; wiersz < aSystemDecyzyjny.GetLength(0); wiersz++)
                                {
                                    if (listaWyklObj.Contains(wiersz))
                                    {
                                        continue;
                                    }

                                    if (aSystemDecyzyjny[wiersz, argument] == wartosc)
                                    {
                                        nPokrycie++;
                                    }
                                }

                                if (NajczestszyDesc == null)
                                {
                                    NajczestszyDesc = new Deskryptor(obiekt, argument, wartosc, nPokrycie);
                                }
                                else
                                {
                                    PorownywanyDesc = new Deskryptor(obiekt, argument, wartosc, nPokrycie);

                                    if (NajczestszyDesc.pokrycie < PorownywanyDesc.pokrycie)
                                    {
                                        NajczestszyDesc.obiekt   = PorownywanyDesc.obiekt;
                                        NajczestszyDesc.argument = PorownywanyDesc.argument;
                                        NajczestszyDesc.wartosc  = PorownywanyDesc.wartosc;
                                        NajczestszyDesc.pokrycie = PorownywanyDesc.pokrycie;
                                    }
                                }
                            }
                        }

                        // Dodajemy deskryptor do reguĊ‚y
                        regula.Dodaj(NajczestszyDesc);
                        listaWyklArg.Add(NajczestszyDesc.argument);

                        // Sprawdzanie sprzecznosci reguly
                        bool lDotyczy;

                        for (int obiekt = 0; obiekt < aSystemDecyzyjny.GetLength(0); obiekt++)
                        {
                            lDotyczy = true;

                            foreach (Deskryptor deskryptor in regula.deskryptory)
                            {
                                if (aSystemDecyzyjny[obiekt, deskryptor.argument] != deskryptor.wartosc)
                                {
                                    lDotyczy = false;
                                    break;
                                }
                            }

                            //regula w obiekcie i decyzja rozna to sprzeczne
                            if (lDotyczy && aSystemDecyzyjny[obiekt, aSystemDecyzyjny.GetLength(1) - 1] != koncept)
                            {
                                lRegSprzeczna = true;
                                break;
                            }
                        }
                    } while (lRegSprzeczna);

                    //wyliczenie pokrycia reguly i dodanie reguly
                    regula.PokrycieObj(aSystemDecyzyjny);
                    listaRegol.Add(regula);

                    //czy caly koncept
                    int sumaObjKonceptu = 0;    // ile mamy obiektow na koncepcie
                    int sumaIleRegul    = 0;    // ile mamy obiektow z ktorych zbudowalismy reguly w koncepcie

                    for (int wiersz = 0; wiersz < aSystemDecyzyjny.GetLength(0); wiersz++)
                    {
                        if (aSystemDecyzyjny[wiersz, aSystemDecyzyjny.GetLength(1) - 1] == koncept)
                        {
                            sumaObjKonceptu++;
                        }
                    }

                    foreach (Regula item in listaRegol)
                    {
                        if (item.decyzja == koncept)
                        {
                            sumaIleRegul += item.pokrycie;
                        }
                    }

                    if (sumaObjKonceptu == sumaIleRegul)
                    {
                        lPokrytyKoncept = true;
                    }
                } while (!lPokrytyKoncept);
            }

            //Wypis Regul
            foreach (Regula item in listaRegol)
            {
                Console.WriteLine(item);
            }

            return;
        }