protected override double gammaX(rGamma rX, int lX, int n)
{
double gammaX = 0;
double mianownik = 0;
for (int i = 0; i < rX.klasy.Length; i++)
{
int t = rX.klasy[i].t;
if (t > lX)
{
continue;
}
if (rX.q[lX - t] == 0)
{
continue;
}
double mu = rX.wiazka.ListaKlasRuchu[rX.klasy[i].i].mu;
double x = rX.klasy[i].waga * mu; // / rX.delta(lX - t);
//Licznik
gammaX += (x * rX.wiazka.sigmy[rX.klasy[i].i, n - t]);
mianownik += (x * rX.wiazka.sigmy[rX.klasy[i].i, lX - t]);
}
gammaX = (mianownik == 0) ? 0 : gammaX / mianownik;
return(gammaX);
}
protected virtual double gammaX(rGamma rX, int lX, int n)
{
double gammaX = 0;
double mianownik = 0;
for (int i = 0; i < rX.klasy.Length; i++)
{
int t = rX.klasy[i].t;
if (t > lX)
{
continue;
}
if (rX.q[lX - t] == 0)
{
continue;
}
double x = rX.q[lX - t] * rX.klasy[i].waga / rX.delta(lX - t);
mianownik += x;
gammaX += (x * rX.wiazka.sigmy[rX.klasy[i].i, n - t]);
}
gammaX = (mianownik == 0) ? 0 : gammaX / mianownik;
return(gammaX);
}
public void Agreguj(rGamma agregowany)
{
int V = p.Length - 1;
double[] pNowy = new double[V + 1];
double[] qNowy = new double[V + 1];
int m = klasy.Length + agregowany.klasy.Length;
int m1 = klasy.Length;
int m2 = agregowany.klasy.Length;
klasaUpr [] klasyNowe = new klasaUpr[m];
for (int i = 0; i < m1; i++)
{
klasyNowe[i] = klasy[i];
}
for (int i = 0; i < m2; i++)
{
klasyNowe[i + m1] = agregowany.klasy[i];
}
for (int n = 0; n <= V; n++)
{
for (int l = 0; l <= n; l++)
{
pNowy[n] += p[l] * agregowany.p[n - l];
qNowy[n] += q[l] * agregowany.q[n - l] * gamma(this, l, agregowany, n - l);
}
}
p = pNowy;
q = qNowy;
klasy = klasyNowe;
}
/// <summary>
/// Współczynnik warunkowego dopuszczenia kombinacji
/// </summary>
/// <param name="rC">Rozkład zajętości przez zgłoszenia klas ze zbioru C</param>
/// <param name="lC">Liczba zajętych PJP przez zgłoszenia klas ze zbioru C</param>
/// <param name="rD">Rozkład zajętości przez zgłoszenia klas ze zbioru C</param>
/// <param name="lD">Liczba zajętych PJP przez zgłoszenia klas ze zbioru C</param>
/// <returns>Prawdopodobieńśtwo dopuszczenia kombinacji</returns>
protected double gamma(rGamma rC, int lC, rGamma rD, int lD)
{
if (lC + lD == 0)
{
return(1);
}
double gammaC = gammaX(rC, lC, lC + lD);
double gammaD = gammaX(rD, lD, lC + lD);
return((lC * gammaC + lD * gammaD) / (lC + lD));
}
