public bool CzyRegulaZawieraReguleZListy(List <Regula> lista, Regula r)
{
foreach (var rlisty in lista)
{
if (CzyRegulaZawieraRegule(r, rlisty))
{
return(true);
}
}
return(false);
}
//FUNCKE //
bool CzyObiektSpelniaRegule(Regula r, string[] obiekt)
{
foreach (var deskryptor in r.deskryptory)
{
if (obiekt[deskryptor.Key] != deskryptor.Value)
{
return(false);
}
}
return(true);
}
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);
}
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);
}
bool CzyRegulaNieSprzeczna(Regula r, string[][] obiekty)
{
foreach (var obiekt in obiekty)
{
if (CzyObiektSpelniaRegule(r, obiekt) && obiekt.Last() != r.decyzja)
{
return(false);
}
}
return(true);
}
int Support(Regula r, string[][] obiekty)
{
r.support = 0;
foreach (var obiekt in obiekty)
{
if (CzyObiektSpelniaRegule(r, obiekt))
{
r.support++;
}
}
return(r.support);
}
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);
}
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ł
}
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);
}
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();
}
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;
}
}
}
}
}