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);
}
