public void liczYspl(sigmaPrzyjmZgl sigma, int V) { yi = new double[zagregowaneKlasy.Count][]; if (zagregowaneKlasy.Count == 1) { yi[0] = new double[V + 1]; for (int n = 0; n <= V; n += zagregowaneKlasy[0].t) { yi[0][n] = (double)(n) / (double)(zagregowaneKlasy[0].t); } return; } for (int i = 0; i < zagregowaneKlasy.Count; i++) { trClass klasa = zagregowaneKlasy[i]; yi[i] = new double[V + 1]; for (int n = 0; n <= V; n++) { double P_n = 0; double Ex_n = 0; for (int l = 0; l <= n; l += klasa.t) { P_n += (Pmi[i][n - l] * pi[i][l]); Ex_n += (l / klasa.t * Pmi[i][n - l] * pi[i][l]); } yi[i][n] = Ex_n / P_n; } } }
public virtual Rozklad zagregujKlase(trClass klasa) { if (zagregowaneKlasy.Count == 0) { return(new Rozklad(wiazka, klasa)); } Rozklad wynik = new Rozklad(this); Rozklad p = new Rozklad(wiazka, klasa); double[] stany = new double[V + 1]; double suma = 0; for (int n = 0; n <= V; n++) { for (int lC = 0; lC <= n; lC++) { double tmp = this[lC] * p[n - lC]; suma += tmp; stany[n] += tmp; } } for (int n = 0; n <= V; n++) { wynik[n] = stany[n] / suma; } return(wynik); }
public double this[trClass klasa, int nrStanu] { get { if (obliczone == false) { obliczSigmy(); } if (aWiazka.ListaKlasRuchu.Contains(klasa) == false) { throw new InvalidCastException(string.Format("Wiazka nie zawiera takiej klasy: {0}", klasa)); } if (nrStanu > aWiazka.V + 1) { return(0); } if (nrStanu < 0) { return(1); } return(sigmy[aWiazka.ListaKlasRuchu.IndexOf(klasa), nrStanu]); } set { throw new InvalidCastException("Nie można ustawiać sigm ręcznie"); } }
public void liczYspl(sigmaPrzyjmZgl sigma, int V) { yi = new double[zagregowaneKlasy.Count][]; if (zagregowaneKlasy.Count == 1) { yi[0] = new double[V + 1]; for (int n = 0; n <= V; n += zagregowaneKlasy[0].t) { yi[0][n] = (double)(n) / (double)(zagregowaneKlasy[0].t); } return; } for (int i = 0; i < zagregowaneKlasy.Count; i++) { trClass klasa = zagregowaneKlasy[i]; Qmi[i].liczYspl(sigma, V); //było to już wyliczone na potrzeby splotu double[][] prDopKomb = rGammaYc1.wyznGamma(Qmi[i], qi[i], klasa, wiazka.sigmy, V, Qmi[i].yi); yi[i] = new double[V + 1]; for (int n = 0; n <= V; n++) { double P_n = 0; double Ex_n = 0; for (int l = 0; l <= n; l += klasa.t) { P_n += (Qmi[i][n - l] * qi[i][l] * prDopKomb[n - l][l]); Ex_n += (l / klasa.t * Qmi[i][n - l] * qi[i][l] * prDopKomb[n - l][l]); } yi[i][n] = Ex_n / P_n; } } }
public FormEditTrafficClass(FormMainWindow parent, trClass edytowana) { master = parent; InitializeComponent(); klasaEdytowana = edytowana; numericUpDownEdycjaKlasyAt.Value = (decimal)edytowana.atProp; numericUpDownEdycjaKlasyT.Value = (decimal)edytowana.t; numericUpDownEdycjaKlasyMu.Value = (decimal)edytowana.mu; if (edytowana.typ == trClass.typKlasy.ENGSET) { labelEdycjaKlasyS.Visible = true; numericUpDownEdycjaKlasyS.Visible = true; trClassEngset kl = (trClassEngset)klasaEdytowana; numericUpDownEdycjaKlasyS.Value = (decimal)kl.S; } if (edytowana.typ == trClass.typKlasy.PASCAL) { labelEdycjaKlasyS.Visible = true; numericUpDownEdycjaKlasyS.Visible = true; trClassPascal kl = (trClassPascal)klasaEdytowana; numericUpDownEdycjaKlasyS.Value = (decimal)kl.S; } if (edytowana.typ == trClass.typKlasy.ERLANG) { labelEdycjaKlasyS.Visible = false; numericUpDownEdycjaKlasyS.Visible = false; } }
protected override void okrRozklad() { base.okrRozklad(); double[] stanyY = new double[aWiazka.V + 1]; stanyY[0] = 1; double suma = 1; for (int n = 1; n <= aWiazka.V; n++) { for (int i = 0; i < aWiazka.m; i++) { trClass zKlasa = aWiazka.ListaKlasRuchu[i]; if (n - zKlasa.t >= 0) { double y = 0; if ((n - 2 * zKlasa.t >= 0) && (stany[n - zKlasa.t] != 0)) { y = stany[n - 2 * zKlasa.t] * zKlasa.PodajIntZgl(0) / (stany[n - zKlasa.t] * zKlasa.mu); } stanyY[n] += (zKlasa.t * zKlasa.PodajIntZgl(y) / zKlasa.mu * stanyY[n - zKlasa.t] * pobSigma(n - zKlasa.t, i)); } } stanyY[n] /= n; suma += stanyY[n]; } for (int n = 0; n <= aWiazka.V; n++) { stany[n] = stanyY[n] / suma; } }
public SimClassErlang(trClass badana, SimGroup sWiazka, agenda listaZd, aSimulation algSym) : base(badana, sWiazka, listaZd, algSym) { processSym nowy = new processErlang(listaZd, this.czNowegoZgl, this); listaZd.DodajProces(nowy); }
/// <summary> /// Zamienia rozklad pojedynczej klasy z procesem przyjmowania /// zgloszen niezaleznym od stanu na rozklad z procesem przyjmowania /// zgloszen zaleznym od stanu /// </summary> /// <param name="P">Rozklad pojedynczej klasy z procesem przyjmowania zgloszen niezaleznym od stanu</param> /// <param name="sigmy">Sprolczynniki warunkowych przejsc dla wszystkich klas</param> protected void DoRozklZalOdStanu(Rozklad P, sigmaPrzyjmZgl sigmy) { if (P.zagregowaneKlasy.Count != 1) { throw new Exception("Rozklad moze miec zagregowana tylko jedna klase ruchu"); } trClass klasa = P.zagregowaneKlasy[0]; int nrKlasy = aWiazka.ListaKlasRuchu.IndexOf(klasa); for (int n = klasa.t; n <= P.V; n++) { double modyfikator = 1; for (int l = n - klasa.t; l >= 0; l -= klasa.t) { modyfikator *= sigmy[nrKlasy, l]; if (sigmy[nrKlasy, l] == 1) { break; } } if (modyfikator != 1) { P[n] *= modyfikator; } } P.normalizacja(); }
public override void BadajWiazke(int nrBad, double aOf) { base.BadajWiazke(nrBad, aOf); rGammaV1[] q = new rGammaV1[aWiazka.m]; for (int i = 0; i < aWiazka.m; i++) { //aWiazka.ListaKlasRuchu[i].ObliczParametry(aOf, aWiazka.sumaPropAT, aWiazka.V); q[i] = new rGammaV1(aWiazka, i, aWiazka.ListaKlasRuchu[i].RozkladStanow(aWiazka, false)); } rGammaV1 Q = new rGammaV1(aWiazka); for (int i = 0; i < aWiazka.m; i++) { Q.Agreguj(q[i]); } //wynikiAlg.UstawA(nrBad, aOf); for (int i = 0; i < aWiazka.m; i++) { trClass pojKlasa = aWiazka.ListaKlasRuchu[i]; double E = 0; double mianownik = 0; for (int n = 0; n <= aWiazka.V; n++) { mianownik += Q.q[n]; E += (Q.q[n] * (1 - aWiazka.sigmy[i, n])); } wynikiAlg.UstawE(nrBad, pojKlasa, E / mianownik); } }
/// <summary> /// Tworzenie zależnego rozkładu zajętości pojedynczej klasu wraz z wyznaczaniem odpowiednich prawdopodobieństw stanów. /// </summary> /// <param name="Wiazka">Wiązka, której zajętość opisuje rozkład zależny.</param> /// <param name="klasaRuchu">Klasa ruchu, której dotyczy ten rozkład zajętości.</param> public RozkladZalezny(Wiazka Wiazka, trClass klasaRuchu) { this._v = Wiazka.V; this.rWiazka = Wiazka; zagregowaneKlasy = new List <trClass>(); zagregowaneKlasy.Add(klasaRuchu); stany = klasaRuchu.ZaleznyRozkladStanow(Wiazka); }
public Rozklad(Wiazka rozWiazka, trClass podstKlasa, double[] prStanow, int indV) { zagregowaneKlasy = new List <trClass>(); zagregowaneKlasy.Add(podstKlasa); stany = prStanow; _v = indV; wiazka = rozWiazka; }
public void ObliczWartosciBF(Rozklad R, sigmaPrzyjmZgl sigmyStruktury) { maksBladY = 0; double staryY; for (int i = 0; i < aWiazka.m; i++) { trClass tempKlasa = aWiazka.ListaKlasRuchu[i]; int tStart = (tempKlasa.progiKlasy == null) ? tempKlasa.t : tempKlasa.progiKlasy[0].t; //for (int n = aWiazka.V; n >= tStart; n--) for (int n = tStart; n <= aWiazka.V; n++) { staryY = y[i, n]; y[i, n] = 0; if (tempKlasa.progiKlasy == null) { int t = tempKlasa.t; double a = aWiazka.ListaKlasRuchu[i].a; switch (tempKlasa.typ) { case trClass.typKlasy.ERLANG: y[i, n] = R[n - t] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, n - t]) * sigmyStruktury[i, n - t]; break; case trClass.typKlasy.ENGSET: y[i, n] = R[n - t] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, n - t]) * sigmyStruktury[i, n - t]; break; case trClass.typKlasy.PASCAL: y[i, n] = R[n - t] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, n - t]) * sigmyStruktury[i, n - t]; break; } } else { for (int prNr = 0; prNr < tempKlasa.progiKlasy.liczbaPrzedziałow; prNr++) { int t = tempKlasa.progiKlasy[prNr].t; int popStan = n - t; if (tempKlasa.progiKlasy.nrPrzedzialu(popStan) == prNr) { double a = tempKlasa.atProgi(popStan) / t; y[i, n] += R[popStan] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, popStan]) * sigmyStruktury[i, popStan]; } } } double bladY = Math.Abs((y[i, n] - staryY) / y[i, n]); if (bladY > maksBladY) { maksBladY = bladY; } } } }
public void UstawBlE(int nrB, trClass klasa, double wartosc) { if ((nrB >= 0) && (nrB < _lBad)) { int nrKlasy = SzukajNrKlasy(klasa); if (nrKlasy < lKl) { _blE[nrB, nrKlasy] = wartosc; } } }
protected double[,] okrRozklad(Rozklad stany, liczbaY Y) { double[,] sigmy = new double[aWiazka.m, aWiazka.V + 1]; stany[0] = 1; double suma = 1; for (int n = 1; n <= aWiazka.V; n++) { stany[n] = 0; for (int i = 0; i < aWiazka.m; i++) { trClass klasaTemp = aWiazka.ListaKlasRuchu[i]; if (klasaTemp.progiKlasy == null) { int t = aWiazka.ListaKlasRuchu[i].t; int PopStan = n - t; if (PopStan >= 0) { sigmy[i, PopStan] = aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, PopStan]); double temp = stany[PopStan] * klasaTemp.at; temp *= sigmaProcPrzyjmZgl[i, PopStan]; temp *= aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, PopStan]); stany[n] += temp; } } else { for (int nrPrzedz = 0; nrPrzedz < klasaTemp.progiKlasy.liczbaPrzedziałow; nrPrzedz++) { int t = aWiazka.ListaKlasRuchu[i].progiKlasy[nrPrzedz].t; int PopStan = n - t; if (PopStan >= 0) { if (klasaTemp.progiKlasy.nrPrzedzialu(PopStan) == nrPrzedz) { sigmy[i, PopStan] = aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, PopStan]); double at = klasaTemp.atProgi(PopStan); stany[n] += (at * stany[PopStan] * aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, PopStan]) * sigmaProcPrzyjmZgl[i, PopStan]); } } } } } stany[n] /= n; suma += stany[n]; } for (int n = 0; n <= aWiazka.V; n++) { stany[n] = stany[n] / suma; } return(sigmy); }
public rGammaYc1(Wiazka rWiazka, trClass klasa) : base(rWiazka, klasa, true) { zagregowaneKlasy = new List <trClass>(); zagregowaneKlasy.Add(klasa); this.wiazka = rWiazka; qi = new Rozklad[1]; qi[0] = new Rozklad(rWiazka, zagregowaneKlasy[0], true); Qmi = new rGammaYc1[1]; Qmi[0] = new rGammaYc1(rWiazka); //Ten rozkład jest pusty. }
/// <summary> /// Wyznacza nowy zagregowany rozkład na podstawie istniejącego oraz nowej klasy zgłoszeń /// </summary> /// <param name="klasa">Nowa, agregowana klasa zgłoszeń</param> /// <returns></returns> public override Rozklad zagregujKlase(trClass klasa) { if (zagregowaneKlasy.Count == 0) { return(new rGammaYc2(wiazka, klasa)); } rGammaYc2 wynik = new rGammaYc2(this); Rozklad p = new Rozklad(wiazka, klasa, true); // Wyznaczanie średniej liczby obsługiwanych zgłoszeń liczYspl(wiazka.sigmy, wiazka.V); //Operacja splotu double[][] prDopKomb = rGammaYc2.wyznGamma(this, p, klasa, wiazka.sigmy, V, yi); double[] stany = new double[V + 1]; double suma = 0; for (int n = 0; n <= V; n++) { for (int lC = 0; lC <= n; lC++) { double tmp = this[lC] * p[n - lC] * prDopKomb[lC][n - lC]; suma += tmp; stany[n] += tmp; } } for (int n = 0; n <= V; n++) { wynik[n] = stany[n] / suma; } // Uaktualnianie rozkładów pomocniczych wynik.pi = new Rozklad[zagregowaneKlasy.Count + 1]; for (int i = 0; i < zagregowaneKlasy.Count; i++) { wynik.pi[i] = this.pi[i]; } wynik.pi[zagregowaneKlasy.Count] = p; wynik.Pmi = new Rozklad[zagregowaneKlasy.Count + 1]; for (int i = 0; i < zagregowaneKlasy.Count; i++) { wynik.Pmi[i] = Pmi[i].zagregujKlase(klasa); } wynik.Pmi[zagregowaneKlasy.Count] = Pmi[0].zagregujKlase(wiazka.ListaKlasRuchu[0]); wynik.zagregowaneKlasy.Add(klasa); return(wynik); }
public double PobE(int nrB, trClass klasa) { if ((nrB >= 0) && (nrB < _lBad)) { int nrKlasy = SzukajNrKlasy(klasa); if (nrKlasy < lKl) { return(_E[nrB, nrKlasy]); } } return(0); }
protected override void okrE(int nrBad) { for (int i = 0; i < aWiazka.m; i++) { trClass pojKlasa = aWiazka.ListaKlasRuchu[i]; double E = 0; for (int n = 0; n <= aWiazka.V; n++) { E += (stany[n] * (1 - sigmaProcPrzyjmowaniaZgloszen[i, n])); } wynikiAlg.UstawE(nrBad, pojKlasa, E); } }
private int SzukajNrKlasy(trClass SzukanaKlasa) { int KlNum = 0; foreach (trClass KlasaI in listaKlasRuchu) { if (KlasaI == SzukanaKlasa) { return(KlNum); } KlNum++; } return(lKl); }
/// <summary> /// Zwraca średnią liczbę obsługiwanych zgłoszeń w stanie n /// </summary> /// <param name="klasa">Klasa, dla któej chcemy wyznaczyć średnią liczbę obsługiwanych zgłoszeń</param> /// <param name="n">Stan, dla którego chcemy wyznaczyć średnia liczbę obsługiwanych zgłoszeń</param> /// <returns>Średnia liczba obsługiwanych zgłoszeń</returns> public double y(trClass klasa, int n) { int t = klasa.t; if (n < t) { return(0); } if (this[n] == 0) { return(0); } return(this[n - t] * klasa.at / this[n]); }
protected override void okrRozklad() { stany[0] = 1; for (int i = 1; i <= aWiazka.V; i++) { stany[i] = 0; } double suma = 1; for (int n = 1; n <= aWiazka.V; n++) { for (int i = 0; i < aWiazka.m; i++) { trClass klasaTemp = aWiazka.ListaKlasRuchu[i]; if (klasaTemp.progiKlasy == null) { int t = aWiazka.ListaKlasRuchu[i].t; int PopStan = n - t; if (PopStan >= 0) { stany[n] += (aWiazka.ListaKlasRuchu[i].at * stany[PopStan] * sigmaProcPrzyjmowaniaZgloszen[i, n - t]); } } else { for (int nrPrzedz = 0; nrPrzedz < klasaTemp.progiKlasy.liczbaPrzedziałow; nrPrzedz++) { int t = aWiazka.ListaKlasRuchu[i].progiKlasy[nrPrzedz].t; int PopStan = n - t; if (PopStan >= 0) { if (klasaTemp.progiKlasy.nrPrzedzialu(PopStan) == nrPrzedz) { double at = klasaTemp.atProgi(PopStan); stany[n] += (at * stany[PopStan] * sigmaProcPrzyjmowaniaZgloszen[i, PopStan]); } } } } } stany[n] /= n; suma += stany[n]; } for (int i = 0; i <= aWiazka.V; i++) { stany[i] /= suma; } }
public void UstawB(int nrB, trClass klasa, double wartosc) { if (_pstrat == false) { return; } if ((nrB >= 0) && (nrB < _lBad)) { int nrKlasy = SzukajNrKlasy(klasa); if (nrKlasy < lKl) { _B[nrB, nrKlasy] = wartosc; } } }
public double PobB(int nrB, trClass klasa) { if (_pstrat == false) { return(0); } if ((nrB >= 0) && (nrB < _lBad)) { int nrKlasy = SzukajNrKlasy(klasa); if (nrKlasy < lKl) { return(_B[nrB, nrKlasy]); } } return(0); }
public double PobBlE(int nrB, trClass klasa) { if (pUfnosci == false) { return(0); } if ((nrB >= 0) && (nrB < _lBad)) { int nrKlasy = SzukajNrKlasy(klasa); if (nrKlasy < lKl) { return(_blE[nrB, nrKlasy]); } } return(0); }
public SimClass(trClass badana, SimGroup sWiazka, agenda listaZd, aSimulation algSymulacji) { klasaRuchu = badana; Symulacja = algSymulacji; this._sWiazka = sWiazka; lZdarzen = listaZd; generator = new Random(badana.GetHashCode()); _lambda = badana.PodajIntZgl(0); if (badana.progiKlasy == null) { _mu = badana.mu; } _uprzyw = badana.uprzywilejowana; lStraconychZgl = 0; lObsluzonychZgl = 0; }
protected override void okrE(int nrBad) { for (int i = 0; i < aWiazka.m; i++) { trClass pojKlasa = aWiazka.ListaKlasRuchu[i]; double E = 0; int stStan = (aWiazka.q < aWiazka.V - pojKlasa.t) ? aWiazka.q : aWiazka.V - pojKlasa.t; for (int n = 0; n <= stStan; n++) { E += (stany[n] * (1 - pobSigma(n, i))); } for (int n = stStan + 1; n <= aWiazka.V; n++) { E += stany[n]; } wynikiAlg.UstawE(nrBad, pojKlasa, E); } }
public Rozklad(Wiazka rozWiazka, trClass klZgloszen, bool procPrzyjmZglZalOdStanu) { zagregowaneKlasy = new List <trClass>(); wiazka = rozWiazka; _v = rozWiazka.V; if (klZgloszen != null) { zagregowaneKlasy.Add(klZgloszen); if (klZgloszen.progiKlasy == null) { stany = klZgloszen.RozkladStanow(rozWiazka, procPrzyjmZglZalOdStanu); } else { Rozklad[] temp = new Rozklad[klZgloszen.progiKlasy.liczbaPrzedziałow]; for (int i = 0; i < klZgloszen.progiKlasy.liczbaPrzedziałow; i++) { temp[i] = new Rozklad(); temp[i].zagregowaneKlasy = this.zagregowaneKlasy; temp[i]._v = rozWiazka.V; temp[i].stany = klZgloszen.RozkladStanow(rozWiazka, i); temp[i].wiazka = rozWiazka; } Rozklad wynik = new Rozklad(temp[0]); for (int i = 1; i < klZgloszen.progiKlasy.liczbaPrzedziałow; i++) { wynik.Agreguj(temp[i]); } this.stany = wynik.stany; } } else { stany = new double[_v + 1]; stany[0] = 1; for (int i = 1; i <= _v; i++) { stany[i] = 0; } } }
public override void Agreguj(Rozklad rB, sigmaPrzyjmZgl sigmy) { double[] noweStany = new double[_v + 1]; for (int n = 0; n <= _v; n++) { double maxSigma = 0; for (int i = 0; i < rB.zagregowaneKlasy.Count; i++) { int nrKlasy = wiazka.ListaKlasRuchu.IndexOf(rB.zagregowaneKlasy[i]); trClass klasa = wiazka.ListaKlasRuchu[nrKlasy]; if (n >= klasa.t) { if (sigmy[nrKlasy, n - klasa.t] > maxSigma) { maxSigma = sigmy[nrKlasy, n - klasa.t]; } } else { maxSigma = 1; } } noweStany[n] = 0; { for (int l = 0; l <= n; l++) { noweStany[n] += (stany[n - l] * rB[l]); } } noweStany[n] *= maxSigma; } for (int n = 0; n <= _v; n++) { stany[n] = noweStany[n]; } foreach (trClass kRuchu in rB.zagregowaneKlasy) { zagregowaneKlasy.Add(kRuchu); } }
private double[,] obliczSigmyFAG() { double[,] sigmyTemp = new double[aWiazka.m, aWiazka.V + 1]; for (int i = 0; i < aWiazka.m; i++) { trClass klasaTemp = aWiazka.ListaKlasRuchu[i]; if (klasaTemp.progiKlasy == null) { for (int n = 0; n <= aWiazka.V; n++) { if (aWiazka.V - n >= klasaTemp.t) { sigmyTemp[i, n] = 1; } else { sigmyTemp[i, n] = 0; } } } else { for (int n = 0; n <= aWiazka.V; n++) { if (aWiazka.V - n >= klasaTemp.progiKlasy.Przedzial(n).t) { sigmyTemp[i, n] = 1; } else { sigmyTemp[i, n] = 0; } } } } return(sigmyTemp); }
public BDklasaZgl(int id, trClass klasa) { _id = id; _klasaZgl = klasa; }