public void MatlabHeap()
        {
            int a;
            int m=1000;
            int n=1000;
            int b=1000;
            string danet = "";

            DateTime sh, eh;

            for (a = 10; a <= 1000; a ++)
            {

                sh = DateTime.Now;

                Heap heapt = new Heap();

                for (int x = 0; x < a; x++)
                {
                    Event e1 = new Event();
                    e1.time = randomNumber.Next(1, m);       // dodawanie a elementów do listy
                    heapt.Insert(e1);
                }
                for (int x = 0; x < b; x++)
                {
                    heapt.DeleteMax();                       // usuwanie elementów ze stogu
                    Event e2 = new Event();
                    e2.time = randomNumber.Next(1, n);
                    heapt.Insert(e2);                       // dodawanie nowego elementu do listy

                }

                eh = DateTime.Now;                          // zakończenie testu dla listy

                time_h = eh - sh; // obliczenie czasu wykonywania operacji na liście
                danet += (time_h.TotalMilliseconds.ToString() + ";");
            }
            System.IO.File.WriteAllText(@"E:\MatlabStog.txt", danet);
        }
        public static void Simulation(Central central, double total_time)
        {
            double current_time = 0;

            Heap events = new Heap();
            //MList events = new MList();
            double[] czasy_wiazka = new double[10000000]; //time in , time out
            double[] czasy_kolejka = new double[10000000]; // time in, time in2
            double[] czasy_system = new double[10000000];  // time in2, time out || time in, time out
            int w = 0, k = 0, s = 0;
            IList<double> timel = new List<double>();

            //for (int i = 0; i < central.CStream.Count; i++) //iteruje po kazdym strumieniu
            //{
            //    double timeIn = current_time + central.CStream[i].getTime("space time"); //dodajem do czasu aktualnego czas odstepu kazdego strumienia
            //    events.InsertEvent(EventType.arrival, timeIn, i);
            //    central.CStream[i].licznik_pakietow++;
            //}

            while ((current_time < total_time) && (events.HeapSize !=0))
            {

                for (int i = 0; i < central.CStream.Count; i++) //iteruje po kazdym strumieniu
                {
                    double timeIn = current_time + central.CStream[i].getTime("space time"); //dodajem do czasu aktualnego czas odstepu kazdego strumienia
                    events.InsertEvent(EventType.arrival, timeIn, i);
                    central.CStream[i].licznik_pakietow++;
                }

                Event e = events.GetEvent();

                if(e.time>current_time)
                {
                current_time = e.time;
                //timel.Add(current_time);

                    if (central.Queue.IsEmpty() == false) //odpali sie gdy kolejka nie jest pusta
                    {
                        central.CheckQueue(current_time); // sprawdza czy nie ma elementów które czekają za długo, jeśli tak to usuwa je
                    }

                    switch (e.etype)
                    {
                        case EventType.arrival:

                            Element element = new Element(e.stream_number, central.CStream[e.stream_number].getSize(), current_time, current_time + central.CStream[e.stream_number].getTime("duration time"));
                            central.CStream[element.stream_number].licznik_pakietow += 1;

                            bool CanWe1 = central.CanBundle(element); // sprawdzamy czy jest miejsce w wiązce

                            if (CanWe1 == true)
                            {
                                central.AddToBundle(element);
                                events.InsertEvent(EventType.departure, element.timeOut, e.stream_number);
                                czasy_wiazka[w] = element.timeOut - element.timeIn;
                                w++;
                                czasy_system[s] = element.timeOut - element.timeIn;
                                s++;

                            }
                            else
                            {

                                bool CanWe2 = central.CanQueue(element); // sprawdzamy czy jest miejsce w kolejce oczekiwań

                                if (CanWe2 == true)
                                {
                                    element.timeIn2 = element.timeIn;
                                    element.timeIn = current_time + central.CStream[e.stream_number].getTime("waiting time");
                                    central.AddToQueue(element);
                                    events.InsertEvent(EventType.arrival, element.timeIn, e.stream_number);

                                }
                                else
                                {
                                    central.CStream[e.stream_number].licznik_odrzuconych_pakietow++;
                                }
                            }

                            break;

                        case EventType.departure:

                            central.EndElement(current_time);

                            if (central.Queue.IsEmpty() == false)
                            {
                                Element el = central.Queue.GetElement();
                                el.timeIn = current_time;
                                el.timeOut = current_time + el.timeOut;

                                if (central.CanBundle(el))
                                {
                                    central.AddToBundle(el);
                                    events.InsertEvent(EventType.departure, el.timeOut, el.stream_number);
                                    czasy_kolejka[k] = el.timeIn - el.timeIn2;
                                    k++;
                                    czasy_system[s] = el.timeOut - el.timeIn2;
                                    s++;
                                }

                            }
                            break;

                    }

                }
            }

            string pstwo_odrzucenia = "";
            string czas_sredni_kolejka = "";
            string czas_sredni_wiazka = "";
            string czas_sredni_system = "";
            string tekst = "";
            double suma_system = 0, suma_kolejka = 0, suma_wiazka = 0;

            for (int i = 0; i < s; i++) suma_system = czasy_system[i] + suma_system;
            for (int i = 0; i < k; i++) suma_kolejka = czasy_kolejka[i] + suma_kolejka;
            for (int i = 0; i < w; i++) suma_wiazka = czasy_wiazka[i] + suma_wiazka;

            double srednia_kolejka = 0;
            double srednia_wiazka = 0;
            double srednia_system=0;

            if (k == 0) srednia_kolejka = 0;
            else srednia_kolejka = suma_kolejka / k;
            if (w == 0) srednia_wiazka = 0;
            else srednia_wiazka = suma_wiazka / w;
            if (s == 0) srednia_system = 0;
            else srednia_system = suma_system / s;

            //for (int i = 0; i < timel.Count; i++)
            //{
            //    Console.WriteLine(timel[i]);
            //}

            for (int i = 0; i < central.CStream.Count; i++)
            {
                pstwo_odrzucenia += "Prawdopodobienstwo odrzucenia dla strumienia " + i + "\r\n" + ((double)central.CStream[i].licznik_odrzuconych_pakietow / (double)central.CStream[i].licznik_pakietow) * 100 + "%\r\n";
            }
            czas_sredni_kolejka = "Czas średni oczekiwania w KOLEJCE \r\n" + srednia_kolejka + "ms\r\n";
            czas_sredni_wiazka = "Czas średni oczekiwania w WIAZCE \r\n" + srednia_wiazka  + "ms\r\n";
            czas_sredni_system = "Czas średni oczekiwania w SYSTEMIE \r\n" + srednia_system  + "ms\r\n";

            tekst = pstwo_odrzucenia + czas_sredni_kolejka + czas_sredni_wiazka + czas_sredni_system;

            System.IO.File.WriteAllText(@"E:\Centrala-wynik.txt", tekst);
        }
        public void Start()
        {
            Settings();

            DateTime sl, el, sh, eh;

            /*sl - czas rozpoczęcia testu dla listy
             *el - czas zakoczenia testu dla listy
             *sh - czas rozpoczecia testu dla stogu
             *eh - czas zakoczenia testu dla stogu
             */

            sl = DateTime.Now;                          // rozpoczęcie testu listy

            MList list = new MList();    // inicjalizacja listy

            for (int i = 0; i < a; i++)
            {
                Event e1 = new Event();
                e1.time = randomNumber.Next(1, m);       // dodawanie a elementów do listy
                list.Insert(e1);
            }

            for (int i = 0; i < b; i++)
            {
                list.DeleteMax();                           // usuwanie b elemetów z listy
                Event e2 = new Event();
                e2.time = randomNumber.Next(1, n);
                list.Insert(e2);                            // dodawanie nowego elementu do listy
            }

            el = DateTime.Now;                          // zakończenie testu dla listy

            time_l = el - sl;                           // obliczenie czasu wykonywania operacji na liście

            sh = DateTime.Now;                          // rozpoczęcie testu dla stogu

            Heap heap = new Heap();                     // inicjalizacja stogu

            for (int i = 0; i < a; i++)
            {
                Event e1 = new Event();
                e1.time = randomNumber.Next(1, m);       //dodawanie elementów do stogu
                heap.Insert(e1);
            }

            for (int i = 0; i < b; i++)
            {
                heap.DeleteMax();                       // usuwanie elementów ze stogu
                Event e3 = new Event();
                e3.time = randomNumber.Next(1, n);
                heap.Insert(e3);                            // dodawnie nowego elemetu do stogu
            }

            eh = DateTime.Now;                          // zakończenie testu dla stogu

            time_h = eh - sh;                           // obliczenie czasu wykonywania operacji na stogu

            Console.WriteLine("Czas wykonanego testu dla listy uporządkowanej:" + time_l.TotalMilliseconds.ToString() + " ms");
            Console.WriteLine("Czas wykonanego testu dla stogu:" + time_h.TotalMilliseconds.ToString() + " ms");

            Console.ReadLine();
        }