protected override void Krok3(int nrBad)
{
rAsSa3[] Q = new rAsSa3[aWiazka.m];
for (int i = 0; i < aWiazka.m; i++)
{
Q[i] = new rAsSa3(P_minusI[i]);
Q[i].AgregujR(p[i]);
Q[i].przemnoz(aWiazka.ListaKlasRuchu[i].at);
}
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)
{
double E = 0;
int grBlokady = aWiazka.V - klasa.t + 1;
if (aWiazka.AlgorytmRezerwacji != reservationAlgorithm.none)
{
grBlokady = aWiazka.q + 1;
}
for (int n = grBlokady; n <= aWiazka.V; n++)
{
E += P[n];
}
wynikiAlg.UstawE(nrBad, klasa, E);
}
}
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 override void BadajWiazke(int nrBad, double aOf)
{
base.BadajWiazke(nrBad, aOf);
Krok1();
p[0].normalizacja();
Rozklad [] Ppodgr = new Rozklad[aWiazka.sumaK];
for (int nrPodgr = 1; nrPodgr <= aWiazka.sumaK; nrPodgr++)
{
Krok2(aWiazka.pojOdPodgrupy(nrPodgr), true);
Ppodgr[nrPodgr - 1] = P_minusI[0] * p[0];
Ppodgr[nrPodgr - 1].zmienDlugosc(aWiazka.PojPodgr(nrPodgr), true);
if (nrPodgr != aWiazka.sumaK) //przy ostatniej iteracji jest to zbędne
{
Krok2b(aWiazka.PojPodgr(nrPodgr));
}
}
foreach (trClass i in aWiazka.ListaKlasRuchu)
{
double B_i = 0;
int f_j = aWiazka.PojPodgr(aWiazka.sumaK);
for (int n = f_j - i.t + 1; n <= f_j; n++)
{
B_i += Ppodgr[aWiazka.sumaK - 1][n];
}
wynikiAlg.UstawE(nrBad, i, B_i);
}
// Krok3(nrBad, aWiazka.pojOdPodgrupy(aWiazka.sumaK));
}
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();
}
}
/// <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();
}
}
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 override void Krok3(int nrBad)
{
Rozklad P = p[0] * P_minusI[0];
P.normalizacja();
delta.kasujSigmy();
delta.ObliczYspl(P_minusI, p, P);
for (int i = 0; i < aWiazka.m; i++)
{
aWiazka.wypDeb(string.Format("rozkład $[p]^{{\\{{{0}\\}}}}$\t{1}\n", i, p[i]));
}
for (int i = 0; i < aWiazka.m; i++)
{
aWiazka.wypDeb(string.Format("rozkład $[P]^{{\\setminus \\{{{0}\\}}}}$\t{1}\n", i, P_minusI[i]));
}
aWiazka.wypDeb(string.Format("Rozkład P\t{0}\n", P.ToString()));
for (int i = 0; i < aWiazka.m; i++)
{
aWiazka.wypDeb(string.Format("n_{{{0}}}\t", i));
for (int n = 0; n <= aWiazka.V; n++)
{
aWiazka.wypDeb(string.Format("{0}\t", delta.Y[i, n]));
}
aWiazka.wypDeb("\n");
}
aWiazka.wypDeb("delta\t");
for (int n = 0; n <= aWiazka.V; n++)
{
aWiazka.wypDeb(string.Format("{0}\t", delta[n]));
}
aWiazka.wypDeb("\n");
double[] R = new double[aWiazka.V + 1];
for (int n = 0; n <= aWiazka.V; n++)
{
R[n] = P[n] * delta[n];
}
aWiazka.wypDeb("Rozkład R\t");
for (int n = 0; n <= aWiazka.V; n++)
{
aWiazka.wypDeb(string.Format("{0}\t", R[n]));
}
aWiazka.wypDeb("\n");
for (int i = 0; i < aWiazka.m; i++)
{
double licznikE = 0;
double mianownikE = 0;
for (int n = 0; n <= aWiazka.V; n++)
{
mianownikE += R[n];
licznikE += (R[n] * (1 - delta.sigmaStruktury[i, n]));
}
wynikiAlg.UstawE(nrBad, aWiazka.ListaKlasRuchu[i], licznikE / mianownikE);
}
}
protected override void Krok3(int nrBad)
{
delta.kasujSigmy();
delta.Oblicz(P);
Rozklad R = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[0], new double[aWiazka.V + 1], aWiazka.V);
for (int i = 0; i < aWiazka.m; i++)
{
R.zagregowaneKlasy.Add(aWiazka.ListaKlasRuchu[i]);
}
for (int n = 0; n <= aWiazka.V; n++)
{
R[n] = P[n] * delta[n];
}
R.normalizacja();
//aWiazka.wypDeb("Y:\n" + delta.Y.ToString()); TODO
//aWiazka.wypDeb(string.Format("R=\t {0}\n", R));
_iteracja = 1;
double blad;
while ((blad = delta.ObliczY(R)) > _epsilon)
{
if (_iteracja > _maxIteracja)
{
break;
}
delta.ObliczDeltaZy(P);
for (int n = 0; n <= aWiazka.V; n++)
{
R[n] = P[n] * delta[n];
}
R.normalizacja();
//aWiazka.wypDeb(_iteracja.ToString() + "\t" + blad.ToString() + "\r\n");
//aWiazka.wypDeb("Y:\n"+delta.Y.ToString());
//aWiazka.wypDeb(string.Format("R= {0}\n", R)); TODO
_iteracja++;
}
//aWiazka.wypDeb(string.Format("Maksymalny błąd względny Y {0}\n", blad.ToString())); TODO
for (int i = 0; i < aWiazka.m; i++)
{
double licznikE = 0;
for (int n = 0; n <= aWiazka.V; n++)
{
licznikE += (R[n] * (1 - delta.sigmaStruktury[i, n]));
}
wynikiAlg.UstawE(nrBad, aWiazka.ListaKlasRuchu[i], licznikE);
}
}
public void ObliczWartosciBF(Rozklad R, sigmaPrzyjmZgl sigmyStruktury)
{
maksBladY = 0;
double staryY;
for (int i = 0; i < aWiazka.m; i++)
{
trClass tempKlasa = aWiazka.ListaKlasRuchu[i];
int tStart = (tempKlasa.progiKlasy == null) ? tempKlasa.t : tempKlasa.progiKlasy[0].t;
//for (int n = aWiazka.V; n >= tStart; n--)
for (int n = tStart; n <= aWiazka.V; n++)
{
staryY = y[i, n];
y[i, n] = 0;
if (tempKlasa.progiKlasy == null)
{
int t = tempKlasa.t;
double a = aWiazka.ListaKlasRuchu[i].a;
switch (tempKlasa.typ)
{
case trClass.typKlasy.ERLANG:
y[i, n] = R[n - t] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, n - t]) * sigmyStruktury[i, n - t];
break;
case trClass.typKlasy.ENGSET:
y[i, n] = R[n - t] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, n - t]) * sigmyStruktury[i, n - t];
break;
case trClass.typKlasy.PASCAL:
y[i, n] = R[n - t] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, n - t]) * sigmyStruktury[i, n - t];
break;
}
}
else
{
for (int prNr = 0; prNr < tempKlasa.progiKlasy.liczbaPrzedziałow; prNr++)
{
int t = tempKlasa.progiKlasy[prNr].t;
int popStan = n - t;
if (tempKlasa.progiKlasy.nrPrzedzialu(popStan) == prNr)
{
double a = tempKlasa.atProgi(popStan) / t;
y[i, n] += R[popStan] / R[n] * a * aWiazka.ListaKlasRuchu[i].sigmaZgl(y[i, popStan]) * sigmyStruktury[i, popStan];
}
}
}
double bladY = Math.Abs((y[i, n] - staryY) / y[i, n]);
if (bladY > maksBladY)
{
maksBladY = bladY;
}
}
}
}
protected override Rozklad OkrRozklNiewPJPwszystkichPodgr(Rozklad pojRozkl)
{
Rozklad wynik = new Rozklad(pojRozkl);
for (int k = 1; k < aWiazka.sumaK - 1; k++)
{
wynik = wynik * pojRozkl;
}
return(wynik);
}
/// <summary>
/// Wyznaczanie rozkładów zajętości pojedynczych klas 1, 2, ..., m
/// </summary>
protected void Krok1()
{
p = new Rozklad[aWiazka.m];
for (int i = 0; i < aWiazka.m; i++)
{
p[i] = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[i]);
p[i].normalizacja();
}
}
protected override void Krok2(int V, bool normalizacja)
{
rGammaSigma rC = new rGammaSigma(p[0]);
for (int i = 1; i < aWiazka.m; i++)
{
rGammaSigma rD = new rGammaSigma(p[i]);
rC.Agreguj(rD, aWiazka.V);
}
P = new Rozklad(rC);
}
public double ObliczY(Rozklad R)
{
if (oszacowana == false)
{
_delta = new double[aWiazka.V + 1];
sStruktury.obliczSigmy();
oszacowana = true;
}
_Y.ObliczWartosciHybr(R, sStruktury);
return(_Y.epsilon);
}
protected double[,] okrRozklad(Rozklad stany, liczbaY Y)
{
double[,] sigmy = new double[aWiazka.m, aWiazka.V + 1];
stany[0] = 1;
double suma = 1;
for (int n = 1; n <= aWiazka.V; n++)
{
stany[n] = 0;
for (int i = 0; i < aWiazka.m; i++)
{
trClass klasaTemp = aWiazka.ListaKlasRuchu[i];
if (klasaTemp.progiKlasy == null)
{
int t = aWiazka.ListaKlasRuchu[i].t;
int PopStan = n - t;
if (PopStan >= 0)
{
sigmy[i, PopStan] = aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, PopStan]);
double temp = stany[PopStan] * klasaTemp.at;
temp *= sigmaProcPrzyjmZgl[i, PopStan];
temp *= aWiazka.ListaKlasRuchu[i].sigmaZgl(Y[i, PopStan]);
stany[n] += temp;
}
}
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]) * sigmaProcPrzyjmZgl[i, PopStan]);
}
}
}
}
}
stany[n] /= n;
suma += stany[n];
}
for (int n = 0; n <= aWiazka.V; n++)
{
stany[n] = stany[n] / suma;
}
return(sigmy);
}
/// <summary>
/// Oblicza prawdopodobieństwo pojawienia się zgłoszenia klasy i względem pozostałych klas
/// </summary>
/// <param name="p">rozkład zajętości klasy i oferowany wiązce pierwotnej</param>
/// <param name="P">rozkład zajętości wszystkich klas (łącznie z klasą i) oferowany wiązce pierwotnej</param>
/// <param name="V_j">pojemność wiązki pierwotnej</param>
/// <returns>Prawdopodobieństwo pojawienia się zgłoszenia klasy i</returns>
private double obliczP(Rozklad p, Rozklad P, int V_j)
{
double exp_i = 0;
double exp = 0;
for (int i = 1; i <= V_j; i++)
{
exp_i += i * p[i];
exp += i * P[i];
}
return(exp_i / exp);
}
protected override void Krok2(int V, bool normalizacja)
{
rGammaYc2[] Q = new rGammaYc2[aWiazka.m];
Q[0] = new rGammaYc2(aWiazka, aWiazka.ListaKlasRuchu[0]);
for (int i = 1; i < aWiazka.m; i++)
{
Q[i] = Q[i - 1].zagregujKlase(aWiazka.ListaKlasRuchu[i]) as rGammaYc2;
}
P = new Rozklad(Q[aWiazka.m - 1]);
}
public override void BadajWiazke(int nrBad, double aOf)
{
aWiazka.debug.logIterAlgorytm(this, nrBad);
base.BadajWiazke(nrBad, aOf);
stany = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[0], new double[aWiazka.V + 1], aWiazka.V);
for (int i = 1; i < aWiazka.m; i++)
{
stany.zagregowaneKlasy.Add(aWiazka.ListaKlasRuchu[i]);
}
Y.Inicjalizacja();
// aWiazka.debug.logIterY(Y.y);
// aWiazka.debug.logIterEpsilon(-1);
// aWiazka.debug.logIterSigma(null);
// aWiazka.debug.logIterRozklad(null);
// aWiazka.debug.nowaIteracja();
double[,] sigmy = okrRozklad(stany, Y);
stany.normalizacja();
// aWiazka.debug.logIterSigma(sigmy);
// aWiazka.debug.logIterRozklad(stany.stany);
Y.ObliczWartosciKR(stany, sigmaProcPrzyjmZgl);
// aWiazka.debug.logIterY(Y.y);
// aWiazka.debug.logIterEpsilon(Y.epsilon);
_iteracja = 1;
do
{
// aWiazka.debug.nowaIteracja();
sigmy = okrRozkladBF(stany, Y);
stany.normalizacja();
// aWiazka.debug.logIterSigma(sigmy);
// aWiazka.debug.logIterRozklad(stany.stany);
Y.ObliczWartosciBF(stany, sigmaProcPrzyjmZgl);
// aWiazka.debug.logIterY(Y.y);
// aWiazka.debug.logIterEpsilon(Y.epsilon);
}while (iterowac);
okrE(nrBad, Y);
okrB(nrBad, Y);
// aWiazka.debug.logIteracje(this, aOf, true);
}
public Rozklad OblRozklRuchSpl(Rozklad pojKlasa, Rozklad P, int f_j, int V_j)
{
int t = pojKlasa.zagregowaneKlasy[0].t;
P.normalizacja(V_j);
int nrKlasy = aWiazka.ListaKlasRuchu.IndexOf(pojKlasa.zagregowaneKlasy[0]);
double Pi = prKlas[nrKlasy];
int tmp_n_j = (int)(Math.Ceiling(Pi * f_j));
int lProb = f_j / t;
double[] Rn_j = new double[lProb + 1];
for (int x = 0; x <= lProb; x++)
{
Rn_j[x] = rozkladDwumianowy(x, lProb, Pi);
}
double[] stany = new double[V_j - f_j + 1];
// for (int nTot = 0; nTot <= V_j; nTot += t)
// {
// for (int x = 0; x <= lProb; x++)
// {
// int n = nTot - x * t;
// if (n < 0)
// n = 0;
// if ((n <= V_j - f_j) && (n >= 0))
// stany[n] += pojKlasa[nTot] * Rn_j[x];
// }
// }
for (int n = 0; n <= V_j; n++)
{
int x = n - tmp_n_j;
if (x < 0)
{
x = 0;
}
if (x < V_j - f_j)
{
stany[x] = pojKlasa[n];
}
}
Rozklad wynik = new Rozklad(pojKlasa.wiazka, pojKlasa.zagregowaneKlasy[0], stany, stany.Length - 1);
wynik.normalizacja();
return(wynik);
}
protected override Rozklad OkrRozklNiewPJPpojPodgr(int nrKlasy)
{
int t = aWiazka.ListaKlasRuchu[nrKlasy].t;
double[] stany = new double[t];
for (int n = 0; n < t; n++)
{
stany[n] = 1;
}
Rozklad wynik = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[nrKlasy], stany, t - 1);
wynik.normalizacja();
return(wynik);
}
protected override void Krok2(int V, bool normalizacja)
{
xSuma = new int[aWiazka.m];
double[] prStanow = new double[V + 1];
for (int n = 0; n <= V; n++)
{
prStanow[n] = PrMikrostanu(n, n, 0);
}
P = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[0], prStanow, V);
for (int i = 1; i <= aWiazka.m - 1; i++)
{
P.zagregowaneKlasy.Add(aWiazka.ListaKlasRuchu[i]);
}
P.normalizacja();
}
/// <summary>
/// Drugi krok kanonicznej postaci algortmu Iversena: Wyznaczanie m zagregowanych
/// rozkładów zajętości wszystkich klas za wyjątkiem klasy 1,2, ..., m
/// </summary>
/// <param name="V">Pojemność wiązki (długość rozkładu V+1)</param>
/// <param name="normalizacja">Zagregowany rozkład jest znormalizowany</param>
protected virtual void Krok2(int V, bool normalizacja)
{
if (V == 0)
{
V = aWiazka.V;
}
if (aWiazka.m == 1)
{
P_minusI = new Rozklad[1];
P_minusI[0] = new Rozklad(aWiazka, V);
return;
}
if (aWiazka.m == 2)
{
P_minusI = new Rozklad[2];
P_minusI[0] = new Rozklad(p[1], V, normalizacja);
P_minusI[1] = new Rozklad(p[0], V, normalizacja);
return;
}
Rozklad[] lewy = new Rozklad[aWiazka.m];
Rozklad[] prawy = new Rozklad[aWiazka.m];
lewy[1] = new Rozklad(p[0], V, normalizacja);
for (int i = 2; i < aWiazka.m; i++)
{
lewy[i] = lewy[i - 1] * p[i - 1];
lewy[i].zmienDlugosc(V, normalizacja);
}
prawy[aWiazka.m - 2] = new Rozklad(p[aWiazka.m - 1], V, normalizacja);
for (int i = aWiazka.m - 3; i >= 0; i--)
{
prawy[i] = prawy[i + 1] * p[i + 1];
prawy[i].zmienDlugosc(V, normalizacja);
}
P_minusI = new Rozklad[aWiazka.m];
P_minusI[0] = prawy[0];
for (int i = 1; i < aWiazka.m - 1; i++)
{
P_minusI[i] = prawy[i] * lewy[i];
P_minusI[i].zmienDlugosc(V, normalizacja);
}
P_minusI[aWiazka.m - 1] = lewy[aWiazka.m - 1];
}
protected override void Krok2(int V, bool normalizacja)
{
if (V == 0)
{
V = aWiazka.V;
}
P = p[0];
for (int i = 1; i < aWiazka.m; i++)
{
P = P * p[i];
if (normalizacja)
{
P.normalizacja(V);
}
}
}
private double[,] obliczSigmyOgrDostUogolniony()
{
double[,] sigmyTemp = new double[aWiazka.m, aWiazka.V + 1];
dwumianNewtona dwumian = new dwumianNewtona(1);
for (int i = 0; i < aWiazka.m; i++)
{
int t = aWiazka.ListaKlasRuchu[i].t;
Rozklad[] rozkladyAlfa = new Rozklad[aWiazka.ListaPodgrupLaczy.Count];
Rozklad[] rozkladyBeta = new Rozklad[aWiazka.ListaPodgrupLaczy.Count];
for (int nrPodgr = 0; nrPodgr < aWiazka.ListaPodgrupLaczy.Count; nrPodgr++)
{
int v = aWiazka.ListaPodgrupLaczy[nrPodgr].v;
int k = aWiazka.ListaPodgrupLaczy[nrPodgr].k;
double[] stanyAlfa = new double[v + 1];
double[] stanyBeta = new double[v + 1];
for (int l = 0; l <= v; l++)
{
stanyAlfa[l] = dwumian.F(l, k, v, 0);
stanyBeta[l] = dwumian.F(l, k, t - 1, 0);
}
rozkladyAlfa[nrPodgr] = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[0], stanyAlfa, v);
rozkladyBeta[nrPodgr] = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[0], stanyBeta, v);
}
Rozklad rAlfa = new Rozklad(rozkladyAlfa[0]);
Rozklad rBeta = new Rozklad(rozkladyBeta[0]);
for (int j = 1; j < aWiazka.ListaPodgrupLaczy.Count; j++)
{
rAlfa = rAlfa * rozkladyAlfa[j];
rBeta = rBeta * rozkladyBeta[j];
}
for (int n = 0; n <= aWiazka.V; n++)
{
if ((aWiazka.V - aWiazka.sumaK * (aWiazka.tMax - 1) > n) || (rAlfa[aWiazka.V - n] == 0))
{
sigmyTemp[i, n] = 1;
}
else
{
sigmyTemp[i, n] = (rAlfa[aWiazka.V - n] - rBeta[aWiazka.V - n]) / rAlfa[aWiazka.V - n];
}
}
}
return(sigmyTemp);
}
protected override void Krok3(int nrBad)
{
Rozklad[] Pj = new Rozklad[aWiazka.sumaK];
int stan = 0;
for (int j = 0; j < aWiazka.sumaK; j++)
{
int f_j = aWiazka.PojPodgr(j + 1);
Pj[j] = new Rozklad(aWiazka, f_j);
Pj[j][0] = 0;
for (int l = 0; l <= stan; l++)
{
Pj[j][0] += P[l];
}
for (int l = 1; l <= f_j; l++)
{
Pj[j][l] = P[stan + l];
}
stan += f_j;
Pj[j].normalizacja();
}
Rozklad P2 = new Rozklad(Pj[0]);
for (int j = 1; j < aWiazka.sumaK; j++)
{
P2.Agreguj(Pj[j]);
}
// int f = aWiazka.pojOdPodgrupy(aWiazka.sumaK);
// P2.zmienDlugosc(f, true);
P2.normalizacja(aWiazka.V);
for (int i = 0; i < aWiazka.m; i++)
{
int t = aWiazka.ListaKlasRuchu[i].t;
double E = 0;
int poczatek = aWiazka.V - aWiazka.sumaK * (t - 1);
for (int n = poczatek; n <= aWiazka.V; n++)
{
E += P2[n];
}
wynikiAlg.UstawE(nrBad, aWiazka.ListaKlasRuchu[i], E);
}
}
protected virtual Rozklad OkrRozklBonusPJPpojPodgr(int maxT)
{
Rozklad wynik = new Rozklad(aWiazka, maxT);// (aWiazka, aWiazka.ListaKlasRuchu[nrKlasy], stany, t - 1);
foreach (trClass klasa in aWiazka.ListaKlasRuchu)
{
for (int i = 1; i <= klasa.t - maxT; i++)
{
if (klasa.t > maxT)
{
//wynik[i] += klasa.atProp;
wynik[i] += klasa.aProp;
}
}
}
wynik.normalizacja();
return(wynik);
}
protected override void Krok3(int nrBad)
{
Rozklad P = new Rozklad(P_minusI[0]);
P.Agreguj(p[0]);
P.normalizacja(aWiazka.V);
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 = aWiazka.V - klasa.t + 1; n <= aWiazka.V; n++)
{
E += P[n];
}
wynikiAlg.UstawE(nrBad, klasa, E);
}
}
protected override void okrRozklad()
{
sigmy = new double[aWiazka.m, aWiazka.V + 1];
for (int i = 0; i < aWiazka.m; i++)
{
int t = aWiazka.ListaKlasRuchu[i].t;
double[] stany = new double[t];
foreach (trClass kl in aWiazka.ListaKlasRuchu)
{
int zakres = kl.t;
for (int n = 0; n < zakres; n++)
{
stany[n % t] += (kl.aProp);
}
}
// for (int n = 0; n < t; n++)
// stany[n] /= aWiazka.sumaPropAT;
Rozklad x = new Rozklad(aWiazka, aWiazka.ListaKlasRuchu[i], stany, t - 1);
x.normalizacja();
Rozklad X = new Rozklad(x);
for (int k = 1; k < aWiazka.sumaK - 1; k++)
{
X = X * x;
}
for (int n = aWiazka.V; n >= 0; n--)
{
if (aWiazka.V - n - t < 0)
{
sigmy[i, n] = 0;
}
else
{
sigmy[i, n] = sigmy[i, n + 1] + X[aWiazka.V - n - t];
}
}
}
base.okrRozklad();
}
protected override void Krok3(int nrBad)
{
Rozklad[] Pj = new Rozklad[2];
int fK = aWiazka.pojOdPodgrupy(aWiazka.sumaK);
int stan = aWiazka.V - fK;
Pj[0] = new Rozklad(aWiazka, stan);
Pj[1] = new Rozklad(aWiazka, fK);
double suma = 0;
for (int n = 0; n <= stan; n++)
{
Pj[0][n] = P[n];
suma += P[n];
}
Pj[1][0] = suma;
for (int l = 1; l <= fK; l++)
{
Pj[1][l] += P[l + stan];
}
Rozklad P2 = new Rozklad(Pj[0]);
P2.Agreguj(Pj[1]);
P2.normalizacja();
// int f = aWiazka.pojOdPodgrupy(aWiazka.sumaK);
// P2.zmienDlugosc(f, true);
for (int i = 0; i < aWiazka.m; i++)
{
int t = aWiazka.ListaKlasRuchu[i].t;
double E = 0;
for (int n = P2.V - t + 1; n <= P2.V; n++)
{
E += P2[n];
}
wynikiAlg.UstawE(nrBad, aWiazka.ListaKlasRuchu[i], E);
}
}
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);
}
