//inicjalizacja odbiorców public void button1_Click(object sender, EventArgs e) { //wczytanie pliku OpenFileDialog fdb = new OpenFileDialog(); fdb.Filter = "BRITE files (*.brite)|*.brite|txt files (*.txt)|*.txt|All files (*.*)|*.*"; System.Windows.Forms.DialogResult result = fdb.ShowDialog(); if (result == System.Windows.Forms.DialogResult.OK) { textBox1.Text = fdb.FileName; } //odczytanie ilości węzłów z pliku System.IO.StreamReader file = new System.IO.StreamReader(textBox1.Text); ile_node = Convert.ToInt32(file.ReadLine()); //utworzenie grafu z modelem sieci i inicjalizacja obiektu graf = new siec[ile_node]; for (int i = 0; i < ile_node; i++) graf[i] = null; siec temp3 = new siec(); //wczytanie grafu z pliku graf = temp3.wczytaj(textBox1.Text); file.Close(); ////test wczytania///// for (int i = 0; i < ile_node; i++) //wyswietla Lsonsiadow { Debug.Write("graf[" + i + "] ="); temp3 = graf[i]; while (temp3 != null) { Debug.Write(temp3.to + " "); temp3 = temp3.next; } Debug.WriteLine(""); }//////////////////////////////////koniec wyswietla odbiorcy[0] = Convert.ToInt16(textBox4.Text); ; for (int i = 1; i <= Convert.ToInt16(numericUpDown1.Value); i++) { var txtBox = this.Controls.Find("textBox" + (i + 4), true); odbiorcy[i] = Convert.ToInt16(txtBox[0].Text); } }
//metoda - wywołanie algorytmu KPP public void KPP(int nadawca, int[] odbiorcy, int ile_PC, siec[] graf, int n, int delta) { int licz = (ile_PC * (ile_PC - 1)) / 2, sc = 0; double koszt, opuzn; siec[] lista_sciezek = new siec[licz]; siec pomoc = new siec(); siec nowy2; odbiorcy[0] = nadawca; ///////////////////////////////////////// Krok 1 //////////////////////////////////////////////// #region /////////////////konstrukcja spujnego nieskierowanego grafu N' ////////////////////////// ///skladajacego sie z wszystkich odbiorcow i nadawcowi sciezek o najnizszym koszczie//// for (int i = 0; i < ile_PC; i++) { for (int j = i + 1; j < ile_PC; j++) { lista_sciezek[sc] = pomoc.sciezka(odbiorcy[i], odbiorcy[j], n, graf,"cost"); //obliczam sciezki sc++; } } /////////////////////////rozwijam graf do grafu pełnego nieskierowanego////////////////// int b = 0, c = 0; siec[] graf_kpp = new siec[n]; for (int i = 0; i < n; i++) graf_kpp[i] = null; for (int i = 0; i < licz; i++) { pomoc = lista_sciezek[i]; b = pomoc.to; koszt = 0; opuzn = 0; while (pomoc != null) { koszt = koszt + pomoc.cost; opuzn = opuzn + pomoc.delay; if (pomoc.next == null) c = pomoc.from; pomoc = pomoc.next; } siec nowy1 = new siec(koszt, opuzn, c, b, i, graf_kpp[b]); graf_kpp[b] = nowy1; } ///////////////////////////////////////////KROK 1 koniec///////////////////////////////////////// #endregion ////////////////////////////////////////// KROK 2 ////////////////////////////////////////////// #region //////////////////////obliczenie minimalnego drzewa spinajacego z grafu kpp //////////////////////metryka jest delay bool[] vis = new bool [n] ; //wierzcholek odwiedzony double[] waga = new double[n]; //delay polaczenia double[] waga_k = new double[n]; //koszt HashSet<siec>kopiec = new HashSet<siec>(); //Dictionary<siec, siec> kopiec = new Dictionary<siec,siec>(n); for(int i=0; i<n; i++) { waga_k[i]=0; waga[i]= 0; //inicjowanie tablic vis[i]= false; } int v = 0; double waga_mst = 0; siec[] mst = new siec[n]; for (int i = 0; i < n; i++) mst[i] = null; vis[0] = true; //wierzcholek startowy (nadawca) waga[odbiorcy[0]] = 0; waga_k[odbiorcy[0]] = 0; kopiec.Clear(); for (pomoc = graf_kpp[odbiorcy[0]]; pomoc != null; pomoc = pomoc.next) //dodanie nie odwiedzonych sasiadow do kopca { nowy2 = new siec(pomoc); kopiec.Add(nowy2); } while (kopiec.Count >0) //glowna petla mst { pomoc = kopiec.FirstOrDefault().ja; if (vis[pomoc.to]==false) { if (waga[pomoc.to] + pomoc.delay < delta) { vis[pomoc.to] = true; //dodaje nowa krawedz do drzewa waga[pomoc.to] = pomoc.delay; waga_k[pomoc.to] = waga_k[pomoc.to] + pomoc.cost; //nowy2 = new wezel(pomoc->koszt, pomoc->delay, pomoc->pi, pomoc->v, pomoc->id, mst[pomoc->v] ); //mst[pomoc->v]=nowy2; nowy2 = new siec(pomoc.cost, pomoc.delay, pomoc.to, pomoc.from, pomoc.id, mst[pomoc.from]); mst[pomoc.from] = nowy2; v = pomoc.to; }//else //{ //kopiec.erase(kopiec.begin()); //usowam 1 element kopca // warunek = false; //} } //if(warunek){ kopiec.Remove(kopiec.FirstOrDefault()); //kopiec.erase(kopiec.begin()); //usowam 1 element kopca for (pomoc = graf_kpp[v]; pomoc != null; pomoc = pomoc.next) //dodaje nie odwiedzonych sasiadow do kopca { if (vis[pomoc.to]==false) { nowy2 = new siec(pomoc); kopiec.Add(nowy2); } } //} //warunek=true; } ///////////////////////////////////////////KROK 2 KONIEC/////////////////////////////////////////////////////// #endregion ////////////////////////////////////////// KROK 3 ////////////////////////////////////////////// #region ///////////////Zastąp krawędzie powstałego drzewa oryginalnymi z grafu z modelem sieci///////////////////////// bool [][] kontrolka = new bool[n][]; for (int i = 0; i < n; i++) { kontrolka[i] = new bool[n]; } //zerowanie kontrolki for(int f=0; f<n; f++) { for(int h=0; h<n; h++) { kontrolka[f][h]=false; } } siec pomoc2=new siec(); siec[] mst2 = new siec[n]; int iterator; for(int i=0; i<n; i++) { mst2[i]= null; } for (int i = 0; i < n; i++) //odtwarzam pierwotne mst { for (pomoc = mst[i]; pomoc != null; pomoc = pomoc.next) //dla kazdego graf_mst { iterator = 0; b = pomoc.from; c = -1; while (lista_sciezek[iterator].to != b || pomoc.to != c) { if (lista_sciezek[iterator].to != b) { iterator++; } else { for (pomoc2 = lista_sciezek[iterator]; pomoc2 != null; pomoc2 = pomoc2.next) //wyszukiwanie krawedzi w liscie sciezek { if (pomoc2.next == null && pomoc2.from == pomoc.to) c = pomoc2.from; } if (c == -1) { iterator++; } } } for (pomoc2 = lista_sciezek[iterator]; pomoc2 != null; pomoc2 = pomoc2.next) { if (kontrolka[pomoc2.from][pomoc2.to] != true && kontrolka[pomoc2.to][pomoc2.from] != true) { nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst2[pomoc2.to]); //tworzenie nowej krawedzi mst2[pomoc2.to] = nowy2; nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst2[pomoc2.from]); mst2[pomoc2.from] = nowy2; kontrolka[pomoc2.to][pomoc2.from] = true; kontrolka[pomoc2.from][pomoc2.to] = true; } } } } //////////////////////////////////////////////////KROK 3 KONIEC////////////////////////////////////////////////////////////// #endregion ///////////////////////////////////Zapis wyniku do pliku//////////////////////////////////////// #region double delay_mst = 0; System.IO.StreamWriter plik = new System.IO.StreamWriter(@"KPP.txt"); for (int f = 0; f < n; f++) { //zerowanie kontrolki for (int h = 0; h < n; h++) { kontrolka[f][h] = false; } } for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp { pomoc = mst2[i]; if (pomoc!=null) { while (pomoc !=null) { if (kontrolka[pomoc.from][pomoc.to] != true && kontrolka[pomoc.to][pomoc.from] != true) { waga_mst = waga_mst + pomoc.cost; delay_mst = delay_mst + pomoc.delay; kontrolka[pomoc.to][pomoc.from] = true; kontrolka[pomoc.from][pomoc.to] = true; } pomoc = pomoc.next; } } } Debug.Write("\n"); Debug.Write("Koszt drzewa multicast wynosi = "); Debug.Write(waga_mst); Debug.Write("\n"); Debug.Write("\n"); Debug.Write("\n"); Debug.Write("DRZEWO MULTICAST "); Debug.Write("\n"); Debug.Write("\n"); plik.WriteLine("\n" + "delta = " + delta+ "\n"); plik.WriteLine( "\n" + "Koszt drzewa multicast wynosi = "+waga_mst + "\n"); plik.WriteLine("\n" + "Nadawca = " + odbiorcy[0] + "\n"); plik.Write("Odbiorcy = "); for (int i = 1; i < odbiorcy.Count(); i++) { plik.Write(odbiorcy[i] + ", "); } plik.WriteLine(""); plik.WriteLine(""); plik.WriteLine("\n" + "DRZEWO MULTICAST " + "\n"); for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp { pomoc = mst2[i]; if (pomoc!=null) { Debug.Write("DTM["); Debug.Write(i); Debug.Write("] ="); plik.Write("DTM[" + i + "] ->"); while (pomoc!=null) { Debug.Write(" "+ pomoc.to+" "); plik.Write(" "+pomoc.to+" "); pomoc = pomoc.next; } Debug.Write( "\n"); plik.WriteLine(""); } } Debug.Write("\n"); plik.Close(); #endregion MessageBox.Show("Koszt drzewa transmisji grupowej wynosi: " + Convert.ToString(waga_mst) + " \n " + Convert.ToString(delay_mst)); }
//metoda - wywołanie algorytmu CSPT public void CSPT(int nadawca, int[] odbiorcy, int ile_PC, siec[] graf, int n, int delta) { int sc = 0; odbiorcy[0] = nadawca; bool[] w_dodane = new bool[ile_PC]; //węzły które spełniały wymogi delta, dodane do grafu w pierwszym kroku siec[] lista_sciezek = new siec[ile_PC - 1]; //lista krok 1 siec[] lista_sciezek2 = new siec[ile_PC - 1]; //lista krok 2 siec[] lista_sciezek3 = new siec[ile_PC - 1]; //lista krok 3 siec pomoc = new siec(); siec pomoc2 = new siec(); for (int i = 0; i < ile_PC - 1; i++) { lista_sciezek[i] = null; lista_sciezek2[i] = null; lista_sciezek3[i] = null; } //////////////////////////////// KROK 1 //////////////////////////////////////////// // Obliczanie mst zawierającego ściezki do odbiorców, które spełniaja założone delta //Metryką obliczania mst jest koszt scieżki #region for (int i = 0; i < w_dodane.Length; i++) { w_dodane[i] = false; } w_dodane[0] = true; //węzeł nadawczy musi byc dodany do drzewa double delay; for (int j = 1; j < ile_PC; j++) { delay = 0; pomoc = pomoc.sciezka(odbiorcy[0], odbiorcy[j], n, graf, "cost"); for (pomoc2 = pomoc; pomoc2 != null; pomoc2 = pomoc2.next) { delay = delay + pomoc2.delay; } if (delay < delta) { lista_sciezek[sc] = pomoc; //obliczam sciezki w_dodane[j] = true; sc++; } } Debug.WriteLine(""); ///////////////////////////// KROK 1 KONIEC ///////////////////////////////////////// #endregion ///////////////////////////// KROK 2 /////////////////////////////////////////////// // Obliczanie mst zawierającego ściezki nie obliczone w kroku 1 // Metryka obliczania mst jest opóźnienie ściezki #region for (int j = 0; j < ile_PC; j++) { if (w_dodane[j] == false) { delay = 0; pomoc = pomoc.sciezka(odbiorcy[0], odbiorcy[j], n, graf, "delay"); lista_sciezek2[sc] = pomoc; //obliczam sciezki w_dodane[j] = true; sc++; } } Debug.WriteLine(""); ////////////////////////// KROK 2 KONIE //////////////////////////////////////////// #endregion ////////////////////////// KROK 3 ///////////////////////////////////////////////// //Scalanie drzew z Kroku 1 i kroku 2 #region for (int i = 0; i < ile_PC - 1; i++) { if (lista_sciezek[i] != null) lista_sciezek3[i] = lista_sciezek[i]; if (lista_sciezek2[i] != null) lista_sciezek3[i] = lista_sciezek2[i]; } ///////////////////////////////////////////////////////////////////////////////// //Rozwijanie listy sciezek do grafu nieskierowanego bool[][] kontrolka = new bool[n][]; for (int i = 0; i < n; i++) { kontrolka[i] = new bool[n]; } //zerowanie kontrolki for (int f = 0; f < n; f++) { for (int h = 0; h < n; h++) { kontrolka[f][h] = false; } } siec[] mst = new siec[n]; siec nowy2; for (int i = 0; i < n; i++) { mst[i] = null; } for (int i = 0; i < ile_PC - 1; i++) { for (pomoc2 = lista_sciezek3[i]; pomoc2 != null; pomoc2 = pomoc2.next) { if (kontrolka[pomoc2.from][pomoc2.to] != true && kontrolka[pomoc2.to][pomoc2.from] != true) { nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst[pomoc2.to]); //tworzenie nowej krawedzi mst[pomoc2.to] = nowy2; nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst[pomoc2.from]); mst[pomoc2.from] = nowy2; kontrolka[pomoc2.to][pomoc2.from] = true; kontrolka[pomoc2.from][pomoc2.to] = true; } } } /////////////////////////////////////////////////// KROK 3 KONIEC//////////////////////////////////////////////// #endregion ////////////////////////////////////////////////// Zapis wyniku do pliku///////////////////////////////////////// #region System.IO.StreamWriter plik = new System.IO.StreamWriter(@"CSPT.txt"); double waga_cspt = 0, delay_cspt=0; for (int f = 0; f < n; f++) { //zerowanie kontrolki for (int h = 0; h < n; h++) { kontrolka[f][h] = false; } } for (int i = 0; i < n; i++) //oblicza calkowity koszt drzewa multicast { pomoc = mst[i]; if (pomoc != null) { while (pomoc != null) { if (kontrolka[pomoc.from][pomoc.to] != true && kontrolka[pomoc.to][pomoc.from] != true) { waga_cspt = waga_cspt + pomoc.cost; delay_cspt = delay_cspt + pomoc.delay; kontrolka[pomoc.to][pomoc.from] = true; kontrolka[pomoc.from][pomoc.to] = true; } pomoc = pomoc.next; } } } Debug.Write("\n"); Debug.Write("Koszt drzewa multicast wynosi = "); Debug.Write(waga_cspt); Debug.Write("\n"); Debug.Write("\n"); Debug.Write("\n"); Debug.Write("DRZEWO MULTICAST "); Debug.Write("\n"); Debug.Write("\n"); plik.WriteLine("\n" + "delta = " + delta+ "\n"); plik.WriteLine("\n" + "Nadawca = " + odbiorcy[0] + "\n"); plik.Write("Odbiorcy = "); for (int i = 1; i < odbiorcy.Count(); i++) { plik.Write(odbiorcy[i] + ", "); } plik.WriteLine(""); plik.WriteLine(""); plik.WriteLine("\n" + "DRZEWO MULTICAST " + "\n"); for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp { pomoc = mst[i]; if (pomoc != null) { Debug.Write("DTM["); Debug.Write(i); Debug.Write("] ="); plik.Write("DMT[" + i + "] ->"); while (pomoc != null) { Debug.Write(" " + pomoc.to + " "); plik.Write(" " + pomoc.to + " "); pomoc = pomoc.next; } Debug.Write("\n"); plik.WriteLine(""); } } Debug.Write("\n"); plik.Close(); #endregion MessageBox.Show("Koszt drzewa transmisji grupowej wynosi: " + Convert.ToString(waga_cspt) + " \n " + Convert.ToString(delay_cspt)); }
public List<gen> Generowanie_YEN(siec[] graf, int ile_sciezek, int nadawca, int odbiorca) { List<gen> tab_r = new List<gen>(); //tablica routingu List<gen> stos = new List<gen>(); // stos z potencjalnymi najkrutszymi ściezkami List<siec> removed_node = new List<siec>(); //usuniete krawędzie siec dijkastra = new siec(); siec pomoc, pomoc2, pomoc3,pomoc4; List<int> root_path; siec total_path =null, spur_path; //suma root_path i spur_path siec spur_node; int dlugosc_sciezki, usuwanie_nadawcy; double koszt, opoznienie; gen sciezka; int sprawdzenie; siec[] kopia_graf = siec.DeepCopy(graf); koszt = 0; opoznienie = 0; pomoc4=dijkastra.sciezka(nadawca, odbiorca, graf.Count(), graf, "cost"); //obliczenie najkrutszej ścieżki for (pomoc3 = pomoc4; pomoc3 != null; pomoc3 = pomoc3.next) { koszt = koszt + pomoc3.cost; opoznienie = opoznienie + pomoc3.delay; } sciezka = new gen(pomoc4, koszt, opoznienie); tab_r.Add(sciezka); for (int k = 1; k < ile_sciezek; k++)//główny for ile sciezek trzeba wyznaczyć { dlugosc_sciezki = 0; root_path = new List<int>(); //sciezka spur_node = tab_r[k - 1].sciezka; //nowy wiezchołek startowy root_path.Add(spur_node.to); usuwanie_nadawcy = 0; removed_node.Clear(); for (pomoc = tab_r[k - 1].sciezka; pomoc != null; pomoc = pomoc.next)//liczy ilość węzłów w ścieżce { dlugosc_sciezki++; } for(int i =0; i<dlugosc_sciezki; i++)// { for (int c = 0; c < tab_r.Count(); c++) //usuwa wszystkie krawędzie należące do tab_r z węzłem startowym spur_node z graf { for (pomoc2 = tab_r[c].sciezka; pomoc2 != null; pomoc2 = pomoc2.next) { if (spur_node.to == pomoc2.to) // && pour_node.from !=pomoc2.from { for (pomoc = kopia_graf[pomoc2.from]; pomoc != null; pomoc = pomoc.next) { if (spur_node.to == pomoc.to && pomoc.from == pomoc2.from) { if (pomoc.before == null) { kopia_graf[pomoc2.from] = pomoc.next; if (kopia_graf[pomoc2.from] != null && kopia_graf[pomoc2.from].before != null) { kopia_graf[pomoc2.from].before = null; } break; } else { pomoc.before.next = pomoc.next; if (pomoc.next != null) { pomoc.next.before = pomoc.before; } break; } } } //for for (pomoc = kopia_graf[pomoc2.to]; pomoc != null; pomoc = pomoc.next) { if (pomoc2.to == pomoc.from && pomoc2.from == pomoc.to) { if (pomoc.before == null) { kopia_graf[pomoc2.to] = pomoc.next; if (kopia_graf[pomoc2.to] != null && kopia_graf[pomoc2.to].before != null) { kopia_graf[pomoc2.to].before = null; } break; } else { pomoc.before.next = pomoc.next; if (pomoc.next != null) { pomoc.next.before = pomoc.before; } break; } } } //for } if (i == 1&& usuwanie_nadawcy ==0) { int kontrolka = 0; kopia_graf[nadawca] = null; usuwanie_nadawcy = 1; while (kontrolka < kopia_graf.Count()) { for (pomoc = kopia_graf[kontrolka]; pomoc != null; pomoc = pomoc.next) { if (nadawca == pomoc.to) { if (pomoc.before == null) { kopia_graf[kontrolka] = pomoc.next; if ( kopia_graf[kontrolka]!= null && kopia_graf[kontrolka].before != null) { kopia_graf[kontrolka].before = null; } break; } else { pomoc.before.next = pomoc.next; if (pomoc.next != null) { pomoc.next.before = pomoc.before; } break; } } } kontrolka++; } } } }//koniec for usuwa koszt = 0; opoznienie = 0; if (i == 0) { sciezka = new gen(dijkastra.sciezka(spur_node.to, odbiorca, kopia_graf.Count(), kopia_graf, "cost"), 0, 0); if (sciezka.sciezka != null) { for (pomoc3 = sciezka.sciezka; pomoc3 != null; pomoc3 = pomoc3.next) { koszt = koszt + pomoc3.cost; opoznienie = opoznienie + pomoc3.delay; } sciezka.cost = koszt; sciezka.delay = opoznienie; stos.Add(sciezka); } } else { total_path = siec.DeepCopy(tab_r[k - 1].sciezka); for (spur_path=total_path; spur_path.from != spur_node.to; spur_path = spur_path.next) { } pomoc4=dijkastra.sciezka(spur_node.to, odbiorca, kopia_graf.Count(), kopia_graf, "cost"); spur_path.next = pomoc4; if (spur_path.next == null) { break; } else { for (pomoc3 = total_path; pomoc3 != null; pomoc3 = pomoc3.next) { koszt = koszt + pomoc3.cost; opoznienie = opoznienie + pomoc3.delay; } sciezka = new gen(total_path, koszt, opoznienie); stos.Add(sciezka); } } spur_node = spur_node.next; if(spur_node!=null) root_path.Add(spur_node.to); // kopia_graf = siec.DeepCopy(kopia_graf); } kopia_graf = siec.DeepCopy(graf); //przywrucenie własności grafu if (stos.Count() == 0) { break; } stos = stos.OrderBy(o => o.cost).ToList(); do { sprawdzenie = 0; for (int spr = 0; spr < tab_r.Count(); spr++) { pomoc = tab_r[spr].sciezka; if (stos.Count() != 0) { for (pomoc2 = stos.FirstOrDefault().sciezka; pomoc2 != null; pomoc2 = pomoc2.next) { if (pomoc.to == pomoc2.to && pomoc.from == pomoc2.from) { if (pomoc.next == pomoc2.next && pomoc.next == null && pomoc2.next == null) { stos.Remove(stos.FirstOrDefault()); sprawdzenie = 1; break; } }else { break; } pomoc = pomoc.next; if (pomoc == null) { break; } } } else { break; } if(sprawdzenie == 1) { break; } } } while (sprawdzenie == 1); if (stos.Count() == 0) { break; } tab_r.Add(stos.FirstOrDefault()); stos.Remove(stos.FirstOrDefault()); }//for główny return tab_r; }
public List<gen> Generowanie_BFS(siec[] graf, int ile_sciezek, int nadawca, int odbiorca) { List<siec> tab = new List<siec>(); List<gen> tab_r = new List<gen>(); //tablica routingu bool[] vis = new bool[graf.Count()]; //kontrolka List<int> kolejka = new List<int>(); //kolejka List<int> gen = new List<int>(); //scieżka siec node =new siec(); //krawędź siec nw ; int random = 0; int koniec = nadawca; int wczesniej = nadawca; siec kopia; int licz = 0, licz2=0; while(licz2 <ile_sciezek) { kolejka.Clear(); tab.Add(null); gen.Clear(); gen.Add(nadawca); for (int i = 0; i < graf.Count(); i++) { vis[i] = false; } //zerowanie kontrolki vis[nadawca] = true; //odwiedzony for (node = graf[nadawca]; node != null; node = node.next) //dodanie sasiadow startu { if (vis[node.to] != true) { kolejka.Add(node.to); } } //for do { while (kolejka.Count == 0 && koniec != odbiorca) //jak wejdzie w slepy zaulek { //cout<<gen.back(); gen.RemoveAt(gen.Count() - 1); for (node = graf[gen[gen.Count - 1]]; node != null; node = node.next) //dodanie sasiadow startu { if (vis[node.to] != true) { kolejka.Add(node.to); } } //for } random = Multi.Form1.x.Next(0, kolejka.Count); //wylosowanie kolejnego allelu node = graf[kolejka[random]]; koniec = kolejka[random]; gen.Add(kolejka[random]); //dodaj wylosowany wierzcholek do genu vis[kolejka[random]] = true; kolejka.Clear(); for (; node != null; node = node.next) //dodanie sasiadow wylosowanego wierzcholka { if (!vis[node.to]) { kolejka.Add(node.to); } } //for } while (koniec != odbiorca); //do while int j = 0; for (j = 1; j < gen.Count();j++ ) { for (nw = graf[gen[j]]; nw != null; nw = nw.next) { if (nw.from == gen[j] && nw.to == gen[j - 1]) { kopia = new siec(nw); node = kopia; node.next = tab[licz]; tab[licz] = node; } } } if (licz != 0) { for (int i = 0; i < tab.Count(); i++) { nw = tab[licz]; if (i != licz && nw !=null ) { kopia = tab[i]; if (kopia != null) { while (kopia != null && nw !=null && kopia.to == nw.to ) { nw = nw.next; kopia = kopia.next; if (nw == null && kopia == null) { tab.RemoveAt(licz); licz--; break; } } } } } } licz++; licz2++; }//while główny /* Debug.WriteLine(""); for (int i = 0; i < tab_r.Count(); i++) { for (node = tab_r[i]; node != null; node = node.next) { Debug.Write(node.from + " -> "); } Debug.Write(nadawca); Debug.WriteLine(""); } */ double koszt, opoznienie ; siec pomoc; gen sciezka; for (int k = 0; k < tab.Count();k++ ) { koszt = 0; opoznienie = 0; kopia = siec.DeepCopy(tab[k]); for (pomoc = kopia; pomoc != null; pomoc = pomoc.next) { koszt = koszt + pomoc.cost; opoznienie = opoznienie + pomoc.delay; } sciezka = new gen(kopia, koszt, opoznienie); tab_r.Add(sciezka); } return tab_r; }
public bool algorytm_genetyczny(int p_pocz, Int16 m_generowania, Int16 m_selekcji, Int16 m_krzyzowania, double p_mutacji, siec[] graf, int[] odbiorcy, int ile_sciezek, int ile_pokolen, int delta ) { System.IO.StreamWriter plik = System.IO.File.AppendText(@"AG.txt"); System.IO.StreamWriter plikcsv = System.IO.File.AppendText(@"AG.csv"); List<List<gen>> l_tab_r = new List<List<gen>>(); //lista tablic routingu (baza genów) List<gen> drzewo ; //drzewo transmisji multicas List<osobnik> populacja = new List<osobnik>(); //populacja osobników osobnik chromosom; //chromosom (drzewo transmisji) List<int> wylosowani = new List<int>(); //lista wybranych do krzyżowania osobników List<osobnik> dzieci = new List<osobnik>(); //lista dzieci List<osobnik> dzieci_nowe = new List<osobnik>(); dzieci.Clear(); l_tab_r.Clear(); dzieci_nowe.Clear(); ////////////////////////////// 1 Generowanie populacji poczatkowej////////////////////////////////// #region switch (m_generowania) { case 1://generuje tablice routingu przeszukując grf w szerz int rand1 = 0; populacja.Clear(); for (int i = 1; i < odbiorcy.Count(); i++) { l_tab_r.Add(Generowanie_BFS(graf, ile_sciezek, odbiorcy[0], odbiorcy[i])); } for (int j = 0; j < p_pocz; j++) { drzewo = new List<gen>(odbiorcy.Count()-1); for (int i = 0; i < odbiorcy.Count() - 1; i++) { rand1 = Multi.Form1.x.Next(0, l_tab_r[i].Count()); drzewo.Add(siec.DeepCopy(l_tab_r[i][rand1])); } chromosom = new osobnik(drzewo, -1); populacja.Add(chromosom); } /* siec node; for (int k = 0; k < populacja.Count(); k++) { Debug.WriteLine(""); Debug.WriteLine("Osobnik ("+k+")"); for (int i = 0; i < populacja[k].chromosom.Count(); i++) { for (node = populacja[k].chromosom[i].sciezka; node != null; node = node.next) { Debug.Write(node.from + " -> "); } Debug.Write(odbiorcy[0] + " " + populacja[k].chromosom[i].cost + " " + populacja[k].chromosom[i].delay); Debug.WriteLine(""); } } Debug.WriteLine("Koniec_inicjacji");*/ break; case 2: populacja.Clear(); int rand2 = 0; for (int i = 1; i < odbiorcy.Count(); i++) { l_tab_r.Add(Generowanie_YEN(graf, ile_sciezek, odbiorcy[0], odbiorcy[i])); } for (int j = 0; j < p_pocz; j++) { drzewo = new List<gen>(odbiorcy.Count()-1); for (int i = 0; i < odbiorcy.Count() - 1; i++) { rand2 = Multi.Form1.x.Next(0, l_tab_r[i].Count()); drzewo.Add(siec.DeepCopy(l_tab_r[i][rand2])); } chromosom = new osobnik(drzewo, -1); populacja.Add(chromosom); } /* siec node1; for (int k = 0; k < populacja.Count(); k++) { Debug.WriteLine(""); Debug.WriteLine("Osobnik ("+k+")"); for (int i = 0; i < populacja[k].chromosom.Count(); i++) { for (node1 = populacja[k].chromosom[i].sciezka; node1 != null; node1 = node1.next) { Debug.Write(node1.to + " -> "); if (node1.next == null) { Debug.Write(node1.from); } } Debug.Write(" " + populacja[k].chromosom[i].cost + " " + populacja[k].chromosom[i].delay); Debug.WriteLine(""); } } Debug.WriteLine("Koniec_inicjacji"); */ break; }//Gen_populacji #endregion// ///////////////////////////////////2 ocena populacji /////////////////////////////////////////////// ocena_przyst(populacja, delta); // for (int i = 0; i < populacja.Count(); i++) { Debug.WriteLine(populacja[i].przystosowanie); } ///////////////////////////////// 3 selekcja osobnikow/////////////////////////////////////////////// for (int ile_pok = 0; ile_pok < ile_pokolen; ile_pok++) { #region switch (m_selekcji) { case 1: wylosowani = selekcja_ruletka(populacja); break; case 2: wylosowani = selekcja_turniej(populacja); break; case 3: wylosowani = selekcja_ranking(populacja); break; }//selekcja #endregion /////////////////////////////////// 4 krzyżowanie /////////////////////////////////////////////////// #region switch (m_krzyzowania) { case 1: dzieci.Clear(); dzieci = krzyzowanie_jednop(populacja, wylosowani, p_mutacji, l_tab_r); break; case 2: dzieci.Clear(); dzieci = krzyzowanie_dwup(populacja, wylosowani, p_mutacji, l_tab_r); break; case 3: dzieci.Clear(); dzieci = krzyzowanie_rownomierne(populacja, wylosowani, p_mutacji, l_tab_r); break; }//krzyżowanie //sukcesja #endregion /////////////////////////////// 5 redukcja duplikatów ////////////////////////////////////////////// dzieci = redukcja_duplikatów(dzieci, l_tab_r); populacja = sukcesja(dzieci, populacja); ocena_przyst(populacja, delta); }/////główna pętla iteracja pokoleń populacja = populacja.OrderByDescending(o => o.przystosowanie).ToList(); /////////////////////////////////////6 zapis wyniku ///////////////////////////////////////////////// #region begin: double koszt = 0, opoznienie = 0; ; siec pomoc = new siec(); siec pomoc2 = new siec(); int n = Convert.ToInt16(graf.Count()); siec[] lista_sciezek = new siec[odbiorcy.Count() - 1]; bool[][] kontrolka1 = new bool[n][]; for (int i = 0; i < n; i++) { kontrolka1[i] = new bool[n]; } //zerowanie kontrolki for (int f = 0; f < n; f++) { for (int h = 0; h < n; h++) { kontrolka1[f][h] = false; } } siec[] mst = new siec[n]; siec nowy2; for (int i = 0; i < n; i++) { mst[i] = null; } for (int i = 0; i < odbiorcy.Count() - 1; i++) { for (pomoc2 = populacja[0].chromosom[i].sciezka; pomoc2 != null; pomoc2 = pomoc2.next) { if (kontrolka1[pomoc2.from][pomoc2.to] != true && kontrolka1[pomoc2.to][pomoc2.from] != true) { nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst[pomoc2.to]); //tworzenie nowej krawedzi mst[pomoc2.to] = nowy2; nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst[pomoc2.from]); mst[pomoc2.from] = nowy2; kontrolka1[pomoc2.to][pomoc2.from] = true; kontrolka1[pomoc2.from][pomoc2.to] = true; } } } int sc = 0; for (int j = 1; j < odbiorcy.Count(); j++) { lista_sciezek[sc] = pomoc.sciezka(odbiorcy[0], odbiorcy[j], n, mst, "cost"); //obliczam sciezk if (lista_sciezek[sc] == null) { plikcsv.WriteLine("zly wynik " + odbiorcy[j]); populacja.RemoveAt(0); goto begin; } sc++; } for (int i = 0; i < n; i++) { kontrolka1[i] = new bool[n]; } siec[] mst2 = new siec[n]; for (int i = 0; i < n; i++) { mst2[i] = null; } for (int i = 0; i < lista_sciezek.Count(); i++) { for (pomoc2 = lista_sciezek[i]; pomoc2 != null; pomoc2 = pomoc2.next) { if (kontrolka1[pomoc2.from][pomoc2.to] != true && kontrolka1[pomoc2.to][pomoc2.from] != true) { nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.from, pomoc2.to, pomoc2.id, mst2[pomoc2.to]); //tworzenie nowej krawedzi mst2[pomoc2.to] = nowy2; nowy2 = new siec(pomoc2.cost, pomoc2.delay, pomoc2.to, pomoc2.from, pomoc2.id, mst2[pomoc2.from]); mst2[pomoc2.from] = nowy2; kontrolka1[pomoc2.to][pomoc2.from] = true; kontrolka1[pomoc2.from][pomoc2.to] = true; } } } for (int f = 0; f < n; f++) { //zerowanie kontrolki for (int h = 0; h < n; h++) { kontrolka1[f][h] = false; } } for (int i = 0; i < n; i++) //oblicza calkowity koszt drzewa multicast { pomoc = mst2[i]; if (pomoc != null) { while (pomoc != null) { if (kontrolka1[pomoc.from][pomoc.to] != true && kontrolka1[pomoc.to][pomoc.from] != true) { koszt = koszt + pomoc.cost; opoznienie = opoznienie + pomoc.delay; kontrolka1[pomoc.to][pomoc.from] = true; kontrolka1[pomoc.from][pomoc.to] = true; } pomoc = pomoc.next; } } } Debug.Write("\n"); Debug.Write("Koszt drzewa multicast wynosi = "); Debug.Write(koszt); Debug.Write("\n"); Debug.Write("\n"); Debug.Write("\n"); Debug.Write("DRZEWO MULTICAST "); Debug.Write("\n"); Debug.Write("\n"); plik.WriteLine("\n" + "delta = " + delta + "\n"); plik.WriteLine("\n" + "Koszt drzewa multicast wynosi = " + koszt + "\n"); plikcsv.WriteLine(koszt); plik.WriteLine("\n" + "Nadawca = " + odbiorcy[0] + "\n"); plik.Write("Odbiorcy = "); for (int i = 1; i < odbiorcy.Count(); i++) { plik.Write(odbiorcy[i] + ", "); } plik.WriteLine(""); plik.WriteLine(""); plik.WriteLine("\n" + "DRZEWO MULTICAST " + "\n"); for (int i = 0; i < n; i++) //wyswietla Lsonsiadow graf_kpp { pomoc = mst2[i]; if (pomoc != null) { Debug.Write("DMT["); Debug.Write(i); Debug.Write("] ="); plik.Write("DMT[" + i + "] ->"); while (pomoc != null) { Debug.Write(" " + pomoc.to + " "); plik.Write(" " + pomoc.to + " "); pomoc = pomoc.next; } Debug.Write("\n"); plik.WriteLine(""); } } Debug.Write("\n"); #endregion Debug.WriteLine(koszt); plik.Close(); plikcsv.Close(); return true; // MessageBox.Show("Koszt drzewa transmisji grupowej wynosi: " + Convert.ToString(koszt) + " \n " + Convert.ToString(opoznienie)); }
public gen(siec sciezka, double koszt, double opoznienie) { this.sciezka = sciezka; this.cost = koszt; this.delay = opoznienie; }