Example #1
0
 public bool CzyRegulaZawieraReguleZListy(List <Regula> lista, Regula r)
 {
     foreach (var rlisty in lista)
     {
         if (CzyRegulaZawieraRegule(r, rlisty))
         {
             return(true);
         }
     }
     return(false);
 }
Example #2
0
        //FUNCKE //

        bool CzyObiektSpelniaRegule(Regula r, string[] obiekt)
        {
            foreach (var deskryptor in r.deskryptory)
            {
                if (obiekt[deskryptor.Key] != deskryptor.Value)
                {
                    return(false);
                }
            }
            return(true);
        }
Example #3
0
 public bool CzyRegulaZawieraRegule(Regula r1, Regula r2)
 {
     foreach (var desk in r2.deskryptory)
     {
         if (!r1.deskryptory.ContainsKey(desk.Key) || r1.deskryptory[desk.Key] != desk.Value)
         {
             return(false);
         }
     }
     return(true);
 }
Example #4
0
        static Regula UtworzRegule(string[] obiekt, int[] kombinacje)
        {
            Regula r = new Regula();

            r.decyzja = obiekt.Last();
            for (int i = 0; i < kombinacje.Length; i++)
            {
                int NumerAtrybutu = kombinacje[i];
                r.deskryptory.Add(NumerAtrybutu, obiekt[NumerAtrybutu]);
            }
            return(r);
        }
Example #5
0
        bool CzyRegulaNieSprzeczna(Regula r, string[][] obiekty)
        {
            foreach (var obiekt in obiekty)
            {
                if (CzyObiektSpelniaRegule(r, obiekt) && obiekt.Last() != r.decyzja)
                {
                    return(false);
                }
            }

            return(true);
        }
Example #6
0
 int Support(Regula r, string[][] obiekty)
 {
     r.support = 0;
     foreach (var obiekt in obiekty)
     {
         if (CzyObiektSpelniaRegule(r, obiekt))
         {
             r.support++;
         }
     }
     return(r.support);
 }
Example #7
0
        List <int> NrObiektuiSupport(Regula r, string[][] obiekty)
        {
            List <int> obiektySpelniajaceRegule = new List <int>();

            r.support = 0;
            for (int i = 0; i < obiekty.Length; i++)
            {
                if (CzyObiektSpelniaRegule(r, obiekty[i]))
                {
                    obiektySpelniajaceRegule.Add(i);
                    r.support++;
                }
            }
            return(obiektySpelniajaceRegule);
        }
Example #8
0
        static void LEM(string[][] wczytaneDane, int kolumna_decyzyjna)//wykonywanie  metody LEM
        {
            List <int>    lista_konceptow    = Generalna_lista_konceptow(wczytaneDane, kolumna_decyzyjna);
            List <int>    atrybut_pominiecia = new List <int>();
            List <int>    obiekt_pominiecia  = new List <int>();
            List <Regula> lista_regul        = new List <Regula>();

            foreach (int koncept in lista_konceptow)//przechodzenie między konceptami
            {
                bool wypelnienie = false;
                while (!wypelnienie)
                {
                    Regula nowa_regula = new Regula(koncept);//tworzenie klasa reguła
                    atrybut_pominiecia = new List <int>();
                    obiekt_pominiecia  = new List <int>();
                    while (Sprawdzanie_reguly(nowa_regula, wczytaneDane, koncept, kolumna_decyzyjna))
                    {
                        Sprawdzanie_obiektu(wczytaneDane, koncept, lista_regul, obiekt_pominiecia, nowa_regula, kolumna_decyzyjna);
                        Deskryptor czesty_deskryptor = Najczestszy_deskryptor(atrybut_pominiecia, obiekt_pominiecia, wczytaneDane); //przypisanie mu wartości
                        nowa_regula.Dodaj(czesty_deskryptor);                                                                       //dodawanie deskryptora
                        atrybut_pominiecia.Add(czesty_deskryptor.Argument);                                                         //dodawanie atrybut który do klasy deskryptora
                    }
                    nowa_regula.Obiekty = nowa_regula.Pokrywanie_obiektów(wczytaneDane);                                            //lista obiektów
                    int suma_obiektu_konceptu = 0;
                    int suma_regul            = 0;
                    lista_regul.Add(nowa_regula);                                //dodawanie do listy reguł nową regułę
                    for (int obiekt = 0; obiekt < wczytaneDane.Length; obiekt++) //przechodzenie między obiektami
                    {
                        if (StringToInt(wczytaneDane[obiekt][kolumna_decyzyjna]) == (koncept))
                        {
                            suma_obiektu_konceptu++;//dodawanie numer konceptu
                        }
                    }
                    foreach (Regula r in lista_regul)//przechodzenie między regułami w liście
                    {
                        if (r.Decyzja == koncept)
                        {
                            suma_regul += r.Support;//liczenie supportu
                        }
                    }
                    if (suma_obiektu_konceptu == suma_regul) //sprawdzenie czy pętla została prawidłowo wykonana
                    {
                        wypelnienie = true;
                    }
                }
            }
            Wypisz_reguly(lista_regul);//wypisywanie reguł
        }
Example #9
0
        static bool Sprawdzanie_reguly(Regula regula, string[][] wczytaneDane, int koncept, int kolumna_decyzyjna)
        {
            bool sprawdzenie = true;

            for (int obiekt = 0; obiekt < wczytaneDane.Length; obiekt++)//przechodznie między obiketami
            {
                sprawdzenie = true;
                foreach (Deskryptor deskryptory in regula.Deskryptory)                                  //przechodzenie między atrybutami
                {
                    if (StringToInt(wczytaneDane[obiekt][deskryptory.Argument]) != deskryptory.Wartosc) //sprawdzanie czy deskryptor nie ma takiej samej wartości
                    {
                        sprawdzenie = false;
                        break;
                    }
                }
                if (sprawdzenie && (StringToInt(wczytaneDane[obiekt][kolumna_decyzyjna]) != koncept))//sprawdzanie czy deksryptor nie jest równy wartości konceptu
                {
                    return(true);
                }
            }
            return(false);
        }
Example #10
0
        static void Main(string[] args)
        {
            string nazwaPlikuZDanymi = @"SystemDecyzyjny.txt";

            string[][] wczytaneDane = StringToTablica(nazwaPlikuZDanymi);

            Console.WriteLine("Dane systemu");
            string wynik = TablicaDoString(wczytaneDane);

            Console.Write(wynik);

            /****************** Miejsce na rozwiązanie *********************************/
            string        napis          = "";
            List <int>    NumeryObiektow = new List <int>();
            List <Regula> Lista          = new List <Regula>();
            Regula        r1             = new Regula();
            macierz       Macierz        = new macierz();

            napis += Environment.NewLine + Environment.NewLine;
            napis += "Metoda Exhaustive :";
            napis += Environment.NewLine + Environment.NewLine;
            string Exhaustive(int nrobiektu, string[][] systemdecyzyjny, int wiersz)
            {
                int[][][] macierz = Macierz.MacierzNieodroznialnosci(wczytaneDane);

                for (int i = 1; i < wczytaneDane[0].Length - 1; i++)
                {
                    for (int k = 0; k < wczytaneDane.Length; k++)
                    {
                        var mc = new Combination(wczytaneDane[k].Length - 1, picks: i);
                        foreach (Combination row in mc.GetRows())
                        {
                            Regula Tworz = UtworzRegule(wczytaneDane[k], row.ToArray());
                            if (!(Macierz.CzyKombinacjawWierszu(macierz[k], row.ToArray())) && !Macierz.CzyRegulaZawieraReguleZListy(Lista, Tworz))
                            {
                                Tworz.Support(Tworz, wczytaneDane);
                                napis += Tworz + Environment.NewLine;
                                Lista.Add(Tworz);
                            }
                        }
                    }
                }
                return(napis);
            }

            for (int wiersz = 1; wiersz < wczytaneDane.Length; wiersz++)
            {
                for (int nrobiektu = 0; nrobiektu < wczytaneDane.Length; nrobiektu++)
                {
                    if (!NumeryObiektow.Contains(nrobiektu))
                    {
                        Exhaustive(nrobiektu, wczytaneDane, wiersz);
                    }
                }
                napis += Environment.NewLine;
            }
            napis += "Koniec";
            Console.WriteLine(napis);
            /****************** Koniec miejsca na rozwiązanie ********************************/
            Console.ReadKey();
        }
Example #11
0
        static void Sprawdzanie_obiektu(string[][] wczytaneDane, int koncept, List <Regula> lista_regul, List <int> Wykluczone_obiekty, Regula Regula, int kolumna_decyzyjna)
        {
            bool czy_obiekt_spelnia_regule = true;

            for (int obiekt = 0; obiekt < wczytaneDane.Length; obiekt++)//przechodzenie między obiektami
            {
                czy_obiekt_spelnia_regule = true;
                if (czy_obiekt_spelnia_regule && (StringToInt(wczytaneDane[obiekt][kolumna_decyzyjna]) != koncept))
                {                                   //sprawdzanie warunku zawsze się wykona jak
                    Wykluczone_obiekty.Add(obiekt); //dodanie obiektu do listy
                    czy_obiekt_spelnia_regule = false;
                }
                if (czy_obiekt_spelnia_regule && Regula.Deskryptory.Count() != 0) //sprawdzanie
                {
                    foreach (Deskryptor deskryptor in Regula.Deskryptory)         //przechodzenie między deskryptoramie
                    {
                        if (StringToInt(wczytaneDane[obiekt][deskryptor.Argument]) != deskryptor.Wartosc)
                        {
                            czy_obiekt_spelnia_regule = false;
                            Wykluczone_obiekty.Add(obiekt);//dodanie obiektu do listy
                            break;
                        }
                    }
                }
                if (czy_obiekt_spelnia_regule == true)   //sprawdzanie czy obiekt spełnia regułę z listy
                {
                    foreach (Regula Item in lista_regul) //przechodzenie przez listę reguł
                    {
                        if (Item.Obiekty.Contains(obiekt))
                        {
                            Wykluczone_obiekty.Add(obiekt);//dodanie obiektu do listy
                            czy_obiekt_spelnia_regule = false;
                            break;
                        }
                    }
                }
            }
        }