protected override void Krok2(int V, bool normalizacja) { sigmaPrzyjmZgl sigmy = new sigmaPrzyjmZgl(aWiazka); for (int i = 0; i < aWiazka.m; i++) { DoRozklZalOdStanu(p[i], sigmy); } rAsYT R = new rAsYT(p[0]); for (int i = 1; i < aWiazka.m; i++) { rAsYT Qab = new rAsYT(R); Qab.Agreguj(p[i], p[i], sigmy); Qab.przemnoz(p[i].sumaAt); rAsYT Qba = new rAsYT(p[i]); Qba.Agreguj(R, R.pomocniczy, sigmy); Qba.przemnoz(R.sumaAt); Qba.dodaj(Qab); if (normalizacja) { Qba.normalizacja(); } R = new rAsYT(Qba); } P = new Rozklad(R); if (!normalizacja) { P.normalizacja(); } }
public override void Agreguj(Rozklad rB, sigmaPrzyjmZgl sigmy) { _v = (_v > rB.V) ? _v : rB.V; double[] noweStany = new double[_v + 1]; noweStany[0] = this[0] * rB[0]; for (int n = 1; n <= _v; n++) { noweStany[n] = 0; for (int l = 0; l <= n; l++) { double sigmaA = OblGamma(this, n, (n - l), sigmy); double sigmaB = OblGamma(rB, n, l, sigmy); double wspSigma = ((n - l) * sigmaA + l * sigmaB) / (double)n; noweStany[n] += wspSigma * this[n - l] * rB[l]; } } for (int n = 0; n <= _v; n++) { stany[n] = noweStany[n]; } foreach (trClass kRuchu in rB.zagregowaneKlasy) { zagregowaneKlasy.Add(kRuchu); } }
/// <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(); }
protected override void Krok2(int V, bool normalizacja) { sigmaPrzyjmZgl sigmy = new sigmaPrzyjmZgl(aWiazka); for (int i = 0; i < aWiazka.m; i++) { DoRozklZalOdStanu(p[i], sigmy); } P = new Rozklad(p[0]); for (int i = 1; i < aWiazka.m; i++) { rAsLambdaT Qab = new rAsLambdaT(P); Qab.Agreguj(p[i], sigmy); Qab.przemnoz(p[i].sumaAt); rAsLambdaT Qba = new rAsLambdaT(p[i]); Qba.Agreguj(P, sigmy); Qba.przemnoz(P.sumaAt); Qba.dodaj(Qab); if (normalizacja) { Qba.normalizacja(); } P = new Rozklad(Qba); } if (!normalizacja) { P.normalizacja(); } }
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 aRoberts(Wiazka wAlg) : base(wAlg) { NazwaAlg = "Roberts"; SkrNazwaAlg = "Rob"; sigmaProcPrzyjmowaniaZgloszen = new sigmaPrzyjmZgl(aWiazka); }
public double OblGamma(int lC, int lD, List <trClass> zbiorD, sigmaPrzyjmZgl sigmy, Rozklad PD) { double licznik = 0; double mianownik = 0; int n = lC + lD; foreach (trClass klasa in zbiorD) { if (lD >= klasa.t) { double p_lZajPJP = PD[lD]; if (p_lZajPJP == 0) { continue; } double p_pop_lZajPJP = PD[lD - klasa.t]; double lambda = klasa.PodajIntZgl(0); double yPrim = p_pop_lZajPJP * lambda / (p_lZajPJP * klasa.mu); double y = PD[lD - klasa.t] * klasa.PodajIntZgl(yPrim) / (PD[lD] * klasa.mu); double UdzKlasy = y * klasa.t; licznik += (sigmy[klasa, n - klasa.t] * UdzKlasy); mianownik += (sigmy[klasa, lD - klasa.t] * UdzKlasy); } } if (mianownik == 0) { return(0); } return(licznik / mianownik); }
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 override double OblGamma(Rozklad zrodlo, int nStan, int lZajPJP, sigmaPrzyjmZgl sigmy) { double licznik = 0; double mianownik = 0; int x = nStan - zrodlo.wiazka.q; foreach (trClass kRuchu in zrodlo.zagregowaneKlasy) { int globNrKlasy = zrodlo.wiazka.ListaKlasRuchu.IndexOf(kRuchu); double UdzKlasy = kRuchu.PodajIntZgl(lZajPJP) * kRuchu.t; if (lZajPJP >= kRuchu.t) { licznik += (UdzKlasy * sigmy[globNrKlasy, lZajPJP - kRuchu.t] * sigmy[globNrKlasy, nStan - kRuchu.t]); } if (lZajPJP >= kRuchu.t) { mianownik += (UdzKlasy * sigmy[globNrKlasy, lZajPJP - kRuchu.t]); } } if (mianownik == 0) { return(0); } return(licznik / mianownik); }
public void Agreguj(Rozklad rB, Rozklad rPB, sigmaPrzyjmZgl sigmy) { pomocniczy.Agreguj(rB); double[] noweStany = new double[_v + 1]; for (int lA = 0; lA <= _v; lA++) { if (lA > wiazka.q + tMax) { break; } for (int lB = 0; lA + lB <= _v; lB++) { double gamma = OblGamma(lA, lB, rB.zagregowaneKlasy, sigmy, rPB); noweStany[lA + lB] += (stany[lA] * rB[lB] * gamma); } } for (int n = 0; n <= _v; n++) { stany[n] = noweStany[n]; } foreach (trClass kRuchu in rB.zagregowaneKlasy) { zagregowaneKlasy.Add(kRuchu); } }
public void Agreguj(Rozklad rB, sigmaPrzyjmZgl sigmy, int nrKlasy) { int t = wiazka.ListaKlasRuchu[nrKlasy].t; int tMaxMinusI = this.tMax; double[] noweStany = new double[_v + 1]; for (int n = 0; n <= _v; n++) { noweStany[n] = 0; { for (int l = 0; l <= n; l++) { double gamma = sigmy[nrKlasy, n - t] * sigmy[MaxInd, l - tMaxMinusI]; double tmp = gamma * stany[l] * rB[n - l]; noweStany[n] += tmp; } } } for (int n = 0; n <= _v; n++) { stany[n] = noweStany[n]; } foreach (trClass kRuchu in rB.zagregowaneKlasy) { zagregowaneKlasy.Add(kRuchu); } }
protected override void Krok2(int V, bool normalizacja) { sigmaPrzyjmZgl sigmy = new sigmaPrzyjmZgl(aWiazka); for (int i = 0; i < aWiazka.m; i++) { DoRozklZalOdStanu(p[i], sigmy); } bool odNajmlodszej = true; if (odNajmlodszej) { P = new Rozklad(p[0]); for (int i = 1; i < aWiazka.m; i++) { rAsMin Qab = new rAsMin(P); Qab.Agreguj(p[i], sigmy); Qab.przemnoz(p[i].sumaAt); rAsMin Qba = new rAsMin(p[i]); Qba.Agreguj(P, sigmy); Qba.przemnoz(P.sumaAt); Qba.dodaj(Qab); P = new Rozklad(Qba); if (normalizacja) { P.normalizacja(); } } } else { P = new Rozklad(p[aWiazka.m - 1]); for (int i = aWiazka.m - 2; i >= 0; i--) { rAsMin Qab = new rAsMin(P); Qab.Agreguj(p[i], sigmy); Qab.przemnoz(p[i].sumaAt); rAsMin Qba = new rAsMin(p[i]); Qba.Agreguj(P, sigmy); Qba.przemnoz(P.sumaAt); Qba.dodaj(Qab); P = new Rozklad(Qba); if (normalizacja) { P.normalizacja(); } } } if (!normalizacja) { P.normalizacja(); } }
protected void Krok3(int nrBad, int V) { sigmaPrzyjmZgl sigmy = new sigmaPrzyjmZgl(aWiazka); sigmy.obliczSigmy(); rAsUogolniony[] Q = new rAsUogolniony[aWiazka.m]; for (int i = 0; i < aWiazka.m; i++) { Q[i] = new rAsUogolniony(P_minusI[i]); Q[i].Agreguj(p[i], sigmy, i); //Q[i].normalizacja(); Q[i].przemnoz(aWiazka.ListaKlasRuchu[i].atProp); } Rozklad P = new Rozklad(Q[0]); for (int i = 1; i < aWiazka.m; i++) { P.dodaj(Q[i]); } P.normalizacja(); foreach (trClass klasa in aWiazka.ListaKlasRuchu) { int nrKlasy = aWiazka.ListaKlasRuchu.IndexOf(klasa); double E = 0; //for (int n = aWiazka.V - klasa.t + 1; n <= aWiazka.V; n++) // E += P[n]; for (int n = 0; n <= aWiazka.V; n++) { E += ((1 - sigmy[aWiazka.ListaKlasRuchu.IndexOf(klasa), n]) * P[n]); } wynikiAlg.UstawE(nrBad, klasa, E); } }
public void KasujWyniki() { sigmy = new sigmaPrzyjmZgl(this); foreach (Algorytm kasowany in ListaAlgorytmow) { kasowany.Obliczony = false; } }
public override void Inicjacja(int LiczbaBadan, int LiczbaSerii) { lBadan = LiczbaBadan; lSerii = LiczbaSerii; Y = new liczbaY(aWiazka); wynikiAlg = new WynikiKlas(lBadan, aWiazka.ListaKlasRuchu, true, false); sigmaProcPrzyjmZgl = new sigmaPrzyjmZgl(aWiazka); }
protected override void Krok3(int nrBad) { sigmaPrzyjmZgl sigmy = new sigmaPrzyjmZgl(aWiazka); foreach (trClass klasa in aWiazka.ListaKlasRuchu) { int nrKlasy = aWiazka.ListaKlasRuchu.IndexOf(klasa); double E = 0; //int grBlokady = aWiazka.V - klasa.t + 1; for (int n = 0; n <= P.V; n++) { E += ((1 - sigmy[nrKlasy, n]) * P[n]); } wynikiAlg.UstawE(nrBad, klasa, E); } }
/// <summary> /// Zamienia rozkład dla systemu z procesem przyjmowania zgłoszeń niezależnym od stanu /// na rozkład dla systemu z procesem przyjmowania zgłoszeń zależnym od stanu /// </summary> /// <param name="sigmy">sigmy opisujące zależność procesu przyjmowania zgłoszeń od stanu</param> /// <param name="nrKlasy">numer klasy</param> public void zamienNaZaleznyOdStanu(sigmaPrzyjmZgl sigmy, int nrKlasy) { int t = wiazka.ListaKlasRuchu[nrKlasy].t; for (int n = t; n <= this._v; n++) { double tmp = 1; for (int l = n - t; l >= 0; l -= t) { if (sigmy[nrKlasy, l] == 1) { break; } tmp *= sigmy[nrKlasy, l]; } this[n] *= tmp; } this.normalizacja(); }
public void liczYprocMarkow(sigmaPrzyjmZgl sigma, int V, int lIteracji) { yi = new double[zagregowaneKlasy.Count][]; foreach (trClass klasa in zagregowaneKlasy) { int i = zagregowaneKlasy.IndexOf(klasa); yi[i] = new double[V + 1]; for (int x = 0; x < lIteracji; x++) { for (int n = 0; n <= V; n++) { if (n >= klasa.t) { yi[i][n] = delta(n - klasa.t) * P[n - klasa.t] * klasa.sigmaZgl(yi[i][n - klasa.t]) * sigma[klasa, n - klasa.t] * klasa.a / (delta(n) * P[n]); } } } } }
protected override void Krok2(int V, bool normalizacja) { sigmaPrzyjmZgl sigmy = new sigmaPrzyjmZgl(aWiazka); //P = new rSigmaLambdaT(p[0]); rSigmaLambdaT Ps = new rSigmaLambdaT(p[0]); Ps.zamienNaZaleznyOdStanu(sigmy, 0); for (int i = 1; i < aWiazka.m; i++) { rSigmaLambdaT temp = new rSigmaLambdaT(p[i]); temp.zamienNaZaleznyOdStanu(sigmy, i); Ps.Agreguj(temp, sigmy); if (normalizacja) { Ps.normalizacja(); } } P = new Rozklad(Ps); }
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); } }
public virtual void Agreguj(Rozklad rB, sigmaPrzyjmZgl sigmy) { foreach (trClass kRuchu in rB.zagregowaneKlasy) { zagregowaneKlasy.Add(kRuchu); } _v = (_v > rB.V) ? _v : rB.V; double[] noweStany = new double[_v + 1]; for (int n = 0; n <= _v; n++) { noweStany[n] = 0; for (int l = 0; l <= n; l++) { noweStany[n] += this[n - l] * rB[l]; } } for (int n = 0; n <= _v; n++) { stany[n] = noweStany[n]; } }
public double OblGamma(int lC, int lD, List <trClass> zbiorD, sigmaPrzyjmZgl sigmy) { double licznik = 0; double mianownik = 0; int n = lC + lD; foreach (trClass klasa in zbiorD) { double UdzKlasy = klasa.PodajIntZgl(lD) * klasa.t; if (lD >= klasa.t) { licznik += (UdzKlasy * sigmy[klasa, lD - klasa.t] * sigmy[klasa, n - klasa.t]); mianownik += (UdzKlasy * sigmy[klasa, lD - klasa.t]); } } if (mianownik == 0) { return(0); } return(licznik / mianownik); }
public virtual double OblGamma(Rozklad zrodlo, int nStan, int lZajPJP, sigmaPrzyjmZgl sigmy) { return(1); }
/// <summary> /// Określa prawdopodobieństwa dopuszczenia kombinacji. /// Każdy element tablicy [lC][lD] odpowiada prawdopodobieńśtwu dopuszczenia kombinacji (lC, lD). /// </summary> /// <param name="rC">Zagregowany rozkład zajętości klas ze zbioru C dla systemu z procesem przyjmowania zgłoszeń zależnym od stanu</param> /// <param name="q">Rozkład pojedynczej klasy</param> /// <param name="sigmy">Tablica z prawdopodobieńśtwami warunkowych przejść dla wszystkich klas</param> /// <param name="V">Pojemność systemu</param> /// <returns>Dwuwymiarowa tablica z prawdopodobieńśtwami dopuszczenia kombinacji</returns> public static double[][] wyznGamma(Rozklad rC, Rozklad q, trClass klasa_q, sigmaPrzyjmZgl sigmy, int V, double[][] yC) { double[] yq = new double[V + 1]; for (int n = 0; n <= V; n += klasa_q.t) { yq[n] = n / klasa_q.t; } double[][] Gamma = new double[V + 1][]; for (int l = 0; l <= V; l++) { Gamma[l] = new double[V - l + 1]; } int lC = 0; int lD = 0; while (lD <= V) { double GammaClicznik = 0; double GammaDlicznik = 0; double GammaCmianownik = 0; double GammaDmianownik = 0; foreach (trClass klasa in rC.zagregowaneKlasy) { if (rC[lC - klasa.t] == 0) { continue; } int i = rC.zagregowaneKlasy.IndexOf(klasa); GammaClicznik += klasa.sigmaZgl(yC[i][lC]) * klasa.at * sigmy[klasa, lC + lD - klasa.t] * Gamma[lC - klasa.t][lD] * rC[lC - klasa.t]; GammaCmianownik += klasa.sigmaZgl(yC[i][lC]) * klasa.at * sigmy[klasa, lC - klasa.t] * rC[lC - klasa.t]; } if (q[lD - klasa_q.t] != 0) { GammaDlicznik += klasa_q.sigmaZgl(q[lD]) * klasa_q.at * sigmy[klasa_q, lC + lD - klasa_q.t] * Gamma[lC][lD - klasa_q.t] * q[lD - klasa_q.t]; GammaDmianownik += klasa_q.sigmaZgl(q[lD]) * klasa_q.at * sigmy[klasa_q, lD - klasa_q.t] * q[lD - klasa_q.t]; } double GammaC = (GammaCmianownik == 0) ? 0 : GammaClicznik / GammaCmianownik; double GammaD = (GammaDmianownik == 0) ? 0 : GammaDlicznik / GammaDmianownik; if (lC + lD == 0) { Gamma[0][0] = 1; } else { Gamma[lC][lD] = (lC * GammaC + lD * GammaD) / (lC + lD); } lC++; if (lC + lD > V) { lD++; lC = 0; } } return(Gamma); }
/// <summary> /// Określa prawdopodobieństwa dopuszczenia kombinacji. /// Każdy element tablicy [lC][lD] odpowiada prawdopodobieńśtwu dopuszczenia kombinacji (lC, lD). /// </summary> /// <param name="rC">Zagregowany rozkład zajętości klas ze zbioru C</param> /// <param name="rD">Zagregowany rozkład zajętości klas ze zbioru D</param> /// <param name="sigmy">Tablica z prawdopodobieńśtwami warunkowych przejść dla wszystkich klas</param> /// <param name="V">Pojemność systemu</param> /// <returns>Dwuwymiarowa tablica z prawdopodobieńśtwami dopuszczenia kombinacji</returns> public static double[][] wyznGamma(rSigmaYt rC, rSigmaYt rD, sigmaPrzyjmZgl sigmy, int V) { double[][] Gamma = new double[V + 1][]; for (int l = 0; l <= V; l++) { Gamma[l] = new double[V - l + 1]; } int lC = 0; int lD = 0; while (lD <= V) { double GammaClicznik = 0; double GammaDlicznik = 0; double GammaCmianownik = 0; double GammaDmianownik = 0; foreach (trClass klasa in rC.zagregowaneKlasy) { if (rC[lC - klasa.t] == 0) { continue; } GammaClicznik += klasa.at * sigmy[klasa, lC + lD - klasa.t] * Gamma[lC - klasa.t][lD] * rC[lC - klasa.t]; GammaCmianownik += klasa.at * sigmy[klasa, lC - klasa.t] * rC[lC - klasa.t]; } foreach (trClass klasa in rD.zagregowaneKlasy) { if (rD[lD - klasa.t] == 0) { continue; } GammaDlicznik += klasa.at * sigmy[klasa, lC + lD - klasa.t] * Gamma[lC][lD - klasa.t] * rD[lD - klasa.t]; GammaDmianownik += klasa.at * sigmy[klasa, lD - klasa.t] * rD[lD - klasa.t]; } double GammaC = (GammaCmianownik == 0) ? 0 : GammaClicznik / GammaCmianownik; double GammaD = (GammaDmianownik == 0) ? 0 : GammaDlicznik / GammaDmianownik; if (lC + lD == 0) { Gamma[0][0] = 1; } else { Gamma[lC][lD] = (lC * GammaC + lD * GammaD) / (lC + lD); } lC++; if (lC + lD > V) { lD++; lC = 0; } } return(Gamma); }