public void AgregujR(Rozklad 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++)
{
if (lA + lB > wiazka.q + rB.tMax)
{
break;
}
noweStany[lA + lB] += (stany[lA] * rB[lB]);
}
}
for (int n = 0; n <= _v; n++)
{
stany[n] = noweStany[n];
}
foreach (trClass kRuchu in rB.zagregowaneKlasy)
{
zagregowaneKlasy.Add(kRuchu);
}
}
public override void Agreguj(Rozklad rB)
{
_v = (_v > rB.V) ? _v : rB.V;
double[] noweStany = new double[_v + 1];
for (int n = 0; n <= this.wiazka.q + 1; n++)
{
noweStany[n] = 0;
for (int l = 0; l <= n; l++)
{
noweStany[n] += this[n - l] * rB[l];
}
}
for (int n = wiazka.q + 2; n <= _v; n++)
{
noweStany[n] = 0;
for (int l = 0; l <= n; l++)
{
double wspSigma = ((n - l) * OblGamma(this, n, (n - l)) + l * OblGamma(rB, n, l)) / (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);
}
}
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);
}
}
public void dodaj(Rozklad dodawany)
{
for (int n = 0; n <= _v; n++)
{
stany[n] += dodawany[n];
}
}
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 virtual Rozklad zagregujKlase(trClass klasa)
{
if (zagregowaneKlasy.Count == 0)
{
return(new Rozklad(wiazka, klasa));
}
Rozklad wynik = new Rozklad(this);
Rozklad p = new Rozklad(wiazka, klasa);
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] * p[n - lC];
suma += tmp;
stany[n] += tmp;
}
}
for (int n = 0; n <= V; n++)
{
wynik[n] = stany[n] / suma;
}
return(wynik);
}
protected virtual void Splataj(Rozklad rA, Rozklad rB, int nowaDlugosc)
{
foreach (trClass kRuchu in rA.zagregowaneKlasy)
{
zagregowaneKlasy.Add(kRuchu);
}
foreach (trClass kRuchu in rB.zagregowaneKlasy)
{
zagregowaneKlasy.Add(kRuchu);
}
_v = nowaDlugosc;
stany = new double[_v + 1];
for (int n = 0; n <= _v; n++)
{
stany[n] = 0;
for (int l = 0; l <= n; l++)
{
if ((l <= rB.V) && (n - l <= rA.V))
{
stany[n] += rB[l] * rA[n - l];
}
}
}
wiazka = rA.wiazka;
}
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, 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);
}
}
public override double OblGamma(Rozklad zrodlo, int nStan, int lZajPJP)
{
double licznik = 0;
double mianownik = 0;
int x = nStan - zrodlo.wiazka.q;
foreach (trClass kRuchu in zrodlo.zagregowaneKlasy)
{
double UdzKlasy = kRuchu.PodajIntZgl(0) * kRuchu.t;
// double UdzKlasy = kRuchu.PodajIntZgl(lZajPJP) * kRuchu.t;
if ((lZajPJP - kRuchu.t <= zrodlo.wiazka.q) && (lZajPJP >= kRuchu.t))
{
mianownik += UdzKlasy;
if (kRuchu.t >= x)
{
licznik += UdzKlasy;
}
}
}
if (mianownik == 0)
{
return(0);
}
return(licznik / mianownik);
}
public static Rozklad operator *(Rozklad r1, Rozklad r2)
{
Rozklad wynik = new Rozklad();
int nowaDlugosc = (r1.V + r2.V > r1.wiazka.V) ? r1.wiazka.V : r1.V + r2.V;
wynik.Splataj(r1, r2, nowaDlugosc);
return(wynik);
}
/// <summary>
/// Wyznacza prawdopodobieństwo dopuszczenia warunkowej kombinacji (l_C, l_D | C)
/// dla wiązki pełnodostępnej z rezerwacją
/// </summary>
/// <param name="zrodlo">Rozkład zajętości klas ze zbioru C </param>
/// <param name="nStan">l_C + l_D</param>
/// <param name="lZajPJP">l_C</param>
/// <returns>prawdopodobieńśtwo dopuszczenia warunkowej kombinacji</returns>
public virtual double OblGamma(Rozklad zrodlo, int nStan, int lZajPJP)
{
int x = nStan - zrodlo.wiazka.q;
if (x > zrodlo.tMax)
{
return(0);
}
return(1);
}
/// <summary>
/// Wyznacza nowy zagregowany rozkład na podstawie istniejącego oraz nowej klasy zgłoszeń
/// </summary>
/// <param name="klasa">Nowa, agregowana klasa zgłoszeń</param>
/// <returns></returns>
public override Rozklad zagregujKlase(trClass klasa)
{
if (zagregowaneKlasy.Count == 0)
{
return(new rGammaYc2(wiazka, klasa));
}
rGammaYc2 wynik = new rGammaYc2(this);
Rozklad p = new Rozklad(wiazka, klasa, true);
// Wyznaczanie średniej liczby obsługiwanych zgłoszeń
liczYspl(wiazka.sigmy, wiazka.V);
//Operacja splotu
double[][] prDopKomb = rGammaYc2.wyznGamma(this, p, klasa, wiazka.sigmy, V, yi);
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] * p[n - lC] * prDopKomb[lC][n - lC];
suma += tmp;
stany[n] += tmp;
}
}
for (int n = 0; n <= V; n++)
{
wynik[n] = stany[n] / suma;
}
// Uaktualnianie rozkładów pomocniczych
wynik.pi = new Rozklad[zagregowaneKlasy.Count + 1];
for (int i = 0; i < zagregowaneKlasy.Count; i++)
{
wynik.pi[i] = this.pi[i];
}
wynik.pi[zagregowaneKlasy.Count] = p;
wynik.Pmi = new Rozklad[zagregowaneKlasy.Count + 1];
for (int i = 0; i < zagregowaneKlasy.Count; i++)
{
wynik.Pmi[i] = Pmi[i].zagregujKlase(klasa);
}
wynik.Pmi[zagregowaneKlasy.Count] = Pmi[0].zagregujKlase(wiazka.ListaKlasRuchu[0]);
wynik.zagregowaneKlasy.Add(klasa);
return(wynik);
}
public rGammaYc1(Wiazka rWiazka, trClass klasa) : base(rWiazka, klasa, true)
{
zagregowaneKlasy = new List <trClass>();
zagregowaneKlasy.Add(klasa);
this.wiazka = rWiazka;
qi = new Rozklad[1];
qi[0] = new Rozklad(rWiazka, zagregowaneKlasy[0], true);
Qmi = new rGammaYc1[1];
Qmi[0] = new rGammaYc1(rWiazka); //Ten rozkład jest pusty.
}
/// <summary>
/// Wyznacza średnią liczbę PJP zajętych przez obsługiwane zgłoszenia klas zagregowanych w rozkładzie ri dla systemu,
/// któemu oferowane są klasy zagregowane w rozkładzie rM
/// </summary>
/// <param name="rM">Zagregowany rozkład klas obsługiwany w systemie</param>
/// <param name="ri">rozkład, dla którego chcemy wyznaczyć średnie liczby zajętych PJP</param>
/// <returns></returns>
public static double[] liczYt(Rozklad rM, Rozklad ri)
{
double[] yt = new double[rM._v];
Rozklad rMi = Rozklad.Rozplot(rM, ri);
for (int n = 0; n <= rMi._v; n++)
{
for (int l = 0; l <= n; l++)
{
yt[l] += l * ri[l] * rMi[n - l];
}
}
return(yt);
}
public Rozklad(Rozklad kopiowany)
{
zagregowaneKlasy = new List <trClass>();
foreach (trClass kopiowana in kopiowany.zagregowaneKlasy)
{
zagregowaneKlasy.Add(kopiowana);
}
wiazka = kopiowany.wiazka;
_v = kopiowany.wiazka.V;
stany = new double[_v + 1];
for (int n = 0; n <= _v; n++)
{
stany[n] = kopiowany[n];
}
}
public Rozklad(Rozklad kopiowany, int V, bool normalizacja)
{
zagregowaneKlasy = new List <trClass>();
foreach (trClass kopiowana in kopiowany.zagregowaneKlasy)
{
zagregowaneKlasy.Add(kopiowana);
}
wiazka = kopiowany.wiazka;
_v = kopiowany.wiazka.V;
stany = new double[_v + 1];
for (int n = 0; n <= _v; n++)
{
stany[n] = kopiowany[n];
}
zmienDlugosc(V, normalizacja);
}
public Rozklad(Wiazka rozWiazka, trClass klZgloszen, bool procPrzyjmZglZalOdStanu)
{
zagregowaneKlasy = new List <trClass>();
wiazka = rozWiazka;
_v = rozWiazka.V;
if (klZgloszen != null)
{
zagregowaneKlasy.Add(klZgloszen);
if (klZgloszen.progiKlasy == null)
{
stany = klZgloszen.RozkladStanow(rozWiazka, procPrzyjmZglZalOdStanu);
}
else
{
Rozklad[] temp = new Rozklad[klZgloszen.progiKlasy.liczbaPrzedziałow];
for (int i = 0; i < klZgloszen.progiKlasy.liczbaPrzedziałow; i++)
{
temp[i] = new Rozklad();
temp[i].zagregowaneKlasy = this.zagregowaneKlasy;
temp[i]._v = rozWiazka.V;
temp[i].stany = klZgloszen.RozkladStanow(rozWiazka, i);
temp[i].wiazka = rozWiazka;
}
Rozklad wynik = new Rozklad(temp[0]);
for (int i = 1; i < klZgloszen.progiKlasy.liczbaPrzedziałow; i++)
{
wynik.Agreguj(temp[i]);
}
this.stany = wynik.stany;
}
}
else
{
stany = new double[_v + 1];
stany[0] = 1;
for (int i = 1; i <= _v; i++)
{
stany[i] = 0;
}
}
}
/// <summary>
/// Rozplata rozkłady. Od rozkładu rM zostanie odpleciony rozkład ri
/// </summary>
/// <param name="rM">Zagregowany rozkład M</param>
/// <param name="ri">Składowa rozkładu i</param>
/// <returns>Pozostała składowa rozkładu</returns>
public static Rozklad Rozplot(Rozklad rM, Rozklad ri)
{
Rozklad wynik = new Rozklad(rM);
foreach (trClass klasa in ri.zagregowaneKlasy)
{
wynik.zagregowaneKlasy.Remove(klasa);
}
for (int n = 0; n <= wynik.wiazka.V; n++)
{
double licznik = rM[n];
for (int l = 0; l < n; l++)
{
licznik -= (wynik[l] * ri[n - l]);
}
wynik[n] = licznik / ri[0];
}
wynik.normalizacja();
return(wynik);
}
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 rAsLambdaT(Rozklad kopiowany)
: base(kopiowany)
{
}
private Rozklad niezalezny; //Rozkład dla systemu niezależnego od stanu.
#region konstruktory
public rSigmaYt(Wiazka rozWiazka, trClass klZgloszen)
: base(rozWiazka, klZgloszen)
{
niezalezny = new Rozklad(rozWiazka, klZgloszen);
}
public rSigmaYt(Rozklad kopiowany)
: base(kopiowany)
{
niezalezny = new Rozklad(kopiowany);
}
public rAsymetryczny(Rozklad kopiowany)
: base(kopiowany)
{
}
public rAsSa3(Rozklad kopiowany)
: base(kopiowany)
{
}
public rAsYT(Rozklad kopiowany)
: base(kopiowany)
{
pomocniczy = new Rozklad(kopiowany);
}
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 rAsUogolniony(Rozklad kopiowany)
: base(kopiowany)
{
}
public rAsMax(Rozklad kopiowany)
: base(kopiowany)
{
}