/// <summary>
/// Określa rozkład zajętości na podstawie przejść w przód i wstecz
/// </summary>
/// <param name="stany"></param>
/// <param name="Y"></param>
/// <returns></returns>
protected double[,] okrRozkladBF(Rozklad stany, liczbaY Y)
{
double[] noweStany = new double[aWiazka.V + 1];
double[,] sigmy = new double[aWiazka.m, aWiazka.V + 1];
double suma = 0;
for (int i = 0; i < aWiazka.m; i++)
{
sigmy[i, 0] = aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, 0]);
}
for (int n = 0; n <= aWiazka.V; n++)
{
double licznik = 0;
double mianownik = 0;
for (int i = 0; i < aWiazka.m; i++)
{
trClass klasaTemp = aWiazka.ListaKlasRuchu[i];
sigmy[i, n] = klasaTemp.sigmaZgl(Y[i, n]);
if (klasaTemp.progiKlasy == null)
{
int t = aWiazka.ListaKlasRuchu[i].t;
int PopStan = n - t;
int NastStan = n + t;
if (PopStan >= 0)
{
double temp = stany[PopStan] * klasaTemp.PodajIntZgl(0);
temp *= sigmaProcPrzyjmZgl[i, PopStan];
temp *= klasaTemp.sigmaZgl(Y[i, PopStan]);
licznik += temp;
}
if (NastStan <= aWiazka.V)
{
double temp = Y[i, NastStan] * klasaTemp.mu * stany[NastStan];
licznik += temp;
mianownik += klasaTemp.PodajIntZgl(0) * klasaTemp.sigmaZgl(Y[i, n]) * sigmaProcPrzyjmZgl[i, n];
}
if (n >= t)
{
mianownik += klasaTemp.mu * Y[i, n];
}
}
//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]) * sigmaProcObslugi[i, PopStan]);
// }
// }
// }
//}
}
noweStany[n] = licznik / mianownik;
suma += noweStany[n];
}
for (int n = 0; n <= aWiazka.V; n++)
{
stany[n] = noweStany[n] / suma;
}
return(sigmy);
}
public void ObliczDeltaZy(Rozklad P)
{
if (oszacowana == false)
{
_delta = new double[aWiazka.V + 1];
sStruktury.obliczSigmy();
oszacowana = true;
}
if (_Y == null)
{
throw (new Exception("Brak Y"));
}
for (int n = 0; n <= aWiazka.V; n++)
{
_delta[n] = 0;
double mian = 0;
for (int i = 0; i < aWiazka.m; i++)
{
trClass klasaTemp = aWiazka.ListaKlasRuchu[i];
if (klasaTemp.progiKlasy == null)
{
int t = aWiazka.ListaKlasRuchu[i].t;
if (n - t >= 0)
{
_delta[n] += (_delta[n - t] * klasaTemp.at * klasaTemp.sigmaZgl(_Y[i, n - t]) * sStruktury[i, n - t] * P[n - t]);
mian += (klasaTemp.at * klasaTemp.sigmaZgl(_Y[i, n - t]) * P[n - t]);
}
else
{
_delta[n] += (klasaTemp.at);
mian += (klasaTemp.at);
}
}
else
{
for (int nrPrzedz = 0; nrPrzedz < klasaTemp.progiKlasy.liczbaPrzedziałow; nrPrzedz++)
{
int t = klasaTemp.progiKlasy[nrPrzedz].t;
double at = klasaTemp.atProgiPrzedzialu(nrPrzedz);
if (n - t >= 0)
{
//jeśli przedziały są różne, to dla tego przedziału nie ma przejścia
double sigma_T = klasaTemp.sigmaZgl(_Y[i, n - t]);
double sigma_S = sStruktury[i, n - t];
if (klasaTemp.progiKlasy.nrPrzedzialu(n - t) == nrPrzedz)
{
_delta[n] += (_delta[n - t] * at * sigma_T * sigma_S * P[n - t]);
}
mian += (at * P[n - t] * sigma_T);
}
else
{
if (klasaTemp.progiKlasy.nrPrzedzialu(n - t) == nrPrzedz)
{
_delta[n] += (at);
}
mian += (at);
}
}
}
}
if (mian != 0)
{
_delta[n] /= mian;
}
else
{
_delta[n] = 1;
}
}
}
public void ObliczYspl(Rozklad[] P_minusI, Rozklad[] p, Rozklad P)
{
_Y.Inicjalizacja();
_Y.ObliczWartossciZeSplotu(P_minusI, p);
if (oszacowana == false)
{
_delta = new double[aWiazka.V + 1];
sStruktury.obliczSigmy();
oszacowana = true;
}
double licznik;
double mianownik;
double sigmaZgl;
double sigmaStr;
for (int n = 0; n <= aWiazka.V; n++)
{
mianownik = 0;
licznik = 0;
for (int i = 0; i < aWiazka.m; i++)
{
trClass klasa = aWiazka.ListaKlasRuchu[i];
if (klasa.progiKlasy == null)
{
int t = klasa.t;
if (n - t > 0)
{
sigmaZgl = klasa.sigmaZgl(_Y[i, n - t]);
sigmaStr = sStruktury[i, n - t];
licznik += (_delta[n - t] * klasa.at * sigmaZgl * sigmaStr * P[n - t]);
mianownik += (aWiazka.ListaKlasRuchu[i].at * P[n - t] * sigmaZgl);
}
else
{
licznik += (aWiazka.ListaKlasRuchu[i].at);
mianownik += (aWiazka.ListaKlasRuchu[i].at);
}
}
else
{
int t = klasa.progiKlasy.Przedzial(n).t;
if (n - t > 0)
{
licznik += (_delta[n - t] * klasa.atProgi(n - t) * klasa.sigmaZgl(_Y[i, n - t]) * sStruktury[i, n - t] * P[n - t]);
mianownik += (klasa.atProgi(n - t) * P[n - t] * klasa.sigmaZgl(_Y[i, n - t]));
}
else
{
licznik += (klasa.atProgi(n - t));
mianownik += (klasa.atProgi(n - t));
}
}
}
_delta[n] = licznik / mianownik;
if (mianownik == 0)
{
_delta[n] = 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);
}