public void Agreguj(rGammaSigma agregowany, int V)
{
double[][] prDopKomb = rGammaSigma.wyznGamma(this, agregowany, wiazka.sigmy, V);
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] * agregowany[n - lC] * prDopKomb[lC][n - lC];
suma += tmp;
stany[n] += tmp;
}
}
foreach (trClass klasaR in agregowany.zagregowaneKlasy)
{
zagregowaneKlasy.Add(klasaR);
}
if (this.V != V)
{
zmienDlugosc(V, false);
}
for (int n = 0; n <= V; n++)
{
this[n] = stany[n] / suma;
}
}
/// <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(rGammaSigma rC, rGammaSigma 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);
}