programik

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
// Dodanie przestrzeni nazw z biblioteki CSL
using CSL;
using CSL.Time;
using CSL.Groups;
using CSL.Generators.Discrete;
using CSL.Statistics;
using System.Diagnostics;

namespace CSLProjects
{
    class ExampleC
    {
        Element[] zgloszenie;
        public Random random;

        public void Run()
        {

            uint maxLiczbaZgloszen = 1000;
            uint srOdstepZgloszen = 1000;
            uint srCzasObsl = 450;
            uint sumaZgloszen = 10000;

            zgloszenie = new Element[maxLiczbaZgloszen];
            for (uint i = 0; i < maxLiczbaZgloszen; i++)
            {
                zgloszenie[i] = new Element();
            }

            SetGroup wolne = new SetGroup(maxLiczbaZgloszen);
            QueueGroup kolejka = new QueueGroup(maxLiczbaZgloszen);

            Timer nadZgl = new Timer();
            Timer konObsl = new Timer();

            int stanObsl;

            NegExp genOdstZgl = new NegExp(srOdstepZgloszen);
            NegExp genCzasuObsl = new NegExp(srCzasObsl);

            StatD statCzasuPobytu = new StatD();
            StatCRect statDlKol = new StatCRect();

            uint dlKol = 0;
            Timer zegarStat = new Timer();

            Hist histLP = new Hist(7, 1, 1);

            long liczbaObs;
            long sumaLiczbObs = 1000;

            uint El = uint.MaxValue;

            random = new Random();


            wolne.Load();
            kolejka.Zero();
            zegarStat.t = 0;

            statDlKol.Clear();
            histLP.Clear();
            statCzasuPobytu.Clear();

            liczbaObs = 0;
            stanObsl = -1;
            nadZgl.t = 0;
            nadZgl.SetOn();

            while (true)
            {
                if (nadZgl.Now()) // Nadejście zgłoszenia, zerowanie liczników, wstawianie do kolejki, zebranie statystyki, ustalenie czasu nadejścia następnego zgłoszenia
                {
                    wolne.Find(ref El, FindParameters.FIRST);
                    wolne.From(El);
                    zgloszenie[El].LP = 0;
                    zgloszenie[El].t = 0;
                    kolejka.To(El);
                    dlKol++;
                    statDlKol.Add(dlKol, -zegarStat.t);
                    nadZgl.t = genOdstZgl.Get();
                }

                if(konObsl.Now()) // Zakończenie obsługi zgłoszenia
                {
                    zgloszenie[stanObsl].LP++;                          //Inkrementuj liczbe przetworzeń dla zgłoszenia, które jest na stanowisku obsługi

                    if (bRet(ref random))                               // (1/3) Wstaw do kolejki
                    {
                        kolejka.To((uint)stanObsl);                     // Wstaw zgłoszenie ze stanowiska obsługi do kolejki
                        dlKol++;                                        // Inkrementuj długość kolejki
                        statDlKol.Add(dlKol, -zegarStat.t);             // Zbierz statystykę (średnia długość kolejki)
                    }
                    else                                                // (2/3) Koniec obsługi, zbierz statystyki
                    {
                        liczbaObs++;                                    // Zwiększ liczbę obsłużonych elementów
                        statCzasuPobytu.Add(-zgloszenie[stanObsl].t);   // Zbierz statystykę (średni czas pobytu)
                        histLP.Add(zgloszenie[stanObsl].LP);            // Zbierz histogram (liczba przejść przez stanowisko)
                    }

                    stanObsl = -1;                                      // Zwolnij stanowisko obsługi
                    konObsl.SetOff();                                   // Wyłącz zegar (ustawiany przy wyborze elementu z kolejki)
                }

                if (kolejka.Find(ref El, FindParameters.FIRST)) // Pobieranie elementu z kolejki, zebranie statystyki, ustalenie czasu obsługi
                {
                    if (stanObsl == -1)
                    {
                        kolejka.From(El);
                        dlKol--;
                        statDlKol.Add(dlKol, -zegarStat.t);
                        stanObsl = (int)El;
                        konObsl.t = genCzasuObsl.Get();
                        konObsl.SetOn();
                    }
                }
                //else // Zakomentowane, obsługa wyżej
                //{
                    //konObsl.SetOff();
                //}

                if (liczbaObs >= sumaLiczbObs)
                {
                    break;
                }

                Time.TimeFlow();
            }

            double sr = 3.14;

            Console.WriteLine("Wyniki po przejsciu " + liczbaObs + " obserwacji.");
            Console.WriteLine("Czas symulacji: " + -zegarStat.t);
            statCzasuPobytu.GetStat(ref sr);
            Console.WriteLine("Sredni czas pobytu w systemie: " + sr);
            statDlKol.GetStat(ref sr, -zegarStat.t);
            Console.WriteLine("Srednia dlugosc kolejki: " + sr);

            Console.WriteLine("Histogram liczby przejsc: ");
            Console.WriteLine(histLP.Out());

            Console.ReadKey();
        }

        bool bRet(ref Random _random)
        {
            double next = _random.NextDouble() * 3;
            if (next > 2)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// klasa Element, dziedzicząca po klasie Timer, reprezentująca zgłoszenie w systemie.
        /// </summary>
        class Element : Timer
        {
            public uint LP;
        }

    }
}