public override double[] RozkladStanow(Wiazka WiazkaKlasy, bool procPrzyjmZal)
{
double[] stany = new double[WiazkaKlasy.V + 1];
double suma = 1;
stany[0] = 1;
for (int n = 1; n < stany.Length; n++)
{
stany[n] = 0;
}
for (int n = t; n < stany.Length; n += t)
{
if (procPrzyjmZal == true)
{
stany[n] = stany[n - t] * a * WiazkaKlasy.sigmy[this, n - t] / (n / t);
}
else
{
stany[n] = stany[n - t] * a / (n / t);
}
suma += stany[n];
}
for (int n = 0; n < stany.Length; n += t)
{
stany[n] /= suma;
}
return(stany);
}
public override double[] RozkladStanow(Wiazka WiazkaKlasy, int nrProgu)
{
double gamma2 = _gamma * progiKlasy[nrProgu].mnoznikIntensywnosci;
double[] stany = new double[WiazkaKlasy.V + 1];
double suma = 1;
stany[0] = 1;
for (int n = 1; n < stany.Length; n++)
{
stany[n] = 0;
}
int lZajPJP = 0;
for (int n = progiKlasy[nrProgu].t; n < stany.Length; n += progiKlasy[nrProgu].t)
{
stany[n] = stany[n - progiKlasy[nrProgu].t] * gamma2 * (_S + lZajPJP) / (progiKlasy[nrProgu]._mu * (lZajPJP + 1));
suma += stany[n];
lZajPJP++;
}
for (int n = 0; n < stany.Length; n += progiKlasy[nrProgu].t)
{
stany[n] /= suma;
}
return(stany);
}
public override double[][] ZaleznyRozkladStanow(Wiazka WiazkaKlasy)
{
double[][] stany = new double[WiazkaKlasy.V + 1][];
for (int nPoz = 0; nPoz <= WiazkaKlasy.V; nPoz++)
{
int ostInd = WiazkaKlasy.V - nPoz;
stany[nPoz] = new double[ostInd + 1];
stany[0][nPoz] = 1;
double suma = 1;
for (int n = 1; n <= ostInd; n++)
{
stany[n][nPoz] = 0;
}
int lZajPJP = 0;
for (int n = t; n <= ostInd; n += t)
{
stany[n][nPoz] = stany[n - t][nPoz] * _gamma / _mu * (_S + lZajPJP) / (lZajPJP + 1) * WiazkaKlasy.sigmy[this, n - t + nPoz];
suma += stany[n][nPoz];
lZajPJP++;
}
for (int n = 0; n <= ostInd; n += t)
{
stany[n][nPoz] /= suma;
}
}
return(stany);
}
public override double[] RozkladStanow(Wiazka WiazkaKlasy, bool procPrzyjmZal)
{
double[] stany = new double[WiazkaKlasy.V + 1];
double suma = 1;
stany[0] = 1;
for (int n = 1; n < stany.Length; n++)
{
stany[n] = 0;
}
int lZajPJP = 0;
for (int n = t; n < stany.Length; n += t)
{
if (procPrzyjmZal == true)
{
stany[n] = stany[n - t] * _gamma / _mu * WiazkaKlasy.sigmy[this, n - t] * (_S + lZajPJP) / (lZajPJP + 1);
}
else
{
stany[n] = stany[n - t] * _gamma / _mu * (_S + lZajPJP) / (lZajPJP + 1);
}
suma += stany[n];
lZajPJP++;
}
for (int n = 0; n < stany.Length; n += t)
{
stany[n] /= suma;
}
return(stany);
}
public override double[][] ZaleznyRozkladStanow(Wiazka WiazkaKlasy)
{
double[][] stany = new double[WiazkaKlasy.V + 1][];
for (int nPoz = 0; nPoz < WiazkaKlasy.V; nPoz++)
{
int OstInd = WiazkaKlasy.V - nPoz;
stany[nPoz] = new double[OstInd + 1];
double suma = 1;
stany[0][nPoz] = 1;
for (int n = 1; n <= OstInd; n++)
{
stany[n][nPoz] = 0;
}
for (int n = t; n <= OstInd; n += t)
{
if ((int)(S - (n / t)) >= 0)
{
stany[n][nPoz] = stany[n - t][nPoz] * _gamma / _mu * (S + 1 - (n / t)) / (n / t) * WiazkaKlasy.sigmy[this, n - t + nPoz];
suma += stany[n][nPoz];
}
else
{
stany[n][nPoz] = 0;
}
}
for (int n = 0; n <= OstInd; n += t)
{
stany[n][nPoz] /= suma;
}
}
return(stany);
}
public override double[] RozkladStanow(Wiazka WiazkaKlasy, bool procPrzyjmZal)
{
double[] stany = new double[WiazkaKlasy.V + 1];
double suma = 1;
stany[0] = 1;
for (int n = 1; n <= WiazkaKlasy.V; n++)
{
stany[n] = 0;
}
for (int n = t; n <= WiazkaKlasy.V; n += t)
{
if ((int)(S - (n / t)) >= 0)
{
if (procPrzyjmZal == true)
{
stany[n] = stany[n - t] * _gamma / _mu * WiazkaKlasy.sigmy[this, n - t] * (S + 1 - (n / t)) / (n / t);
}
else
{
stany[n] = stany[n - t] * _gamma / _mu * (S + 1 - (n / t)) / (n / t);
} suma += stany[n];
}
else
{
stany[n] = 0;
}
}
for (int n = 0; n <= WiazkaKlasy.V; n += t)
{
stany[n] /= suma;
}
return(stany);
}
/// <summary>
/// Konstruktor klasy ruchu
/// </summary>
/// <param name="wiazkaKlasy">Wiązka, której oferowana jest ta klasa ruchu</param>
/// <param name="at">Udział w proporcjach ruchu a_it_i oferowanych klas</param>
/// <param name="t">Liczba żądanych PJP na obsługę zgłoszenia</param>
/// <param name="mi">Intensywność obsługi zgłoszeń</param>
/// <param name="uprzyw">Określa uprzywilejowanie lub nie klasy</param>
public trClass(Wiazka wiazkaKlasy, int at, int t, double mi, bool uprzyw)
{
uprzywilejowana = uprzyw;
_wiazkaObsl = wiazkaKlasy;
atProp = at;
this._t = t;
this._mu = mi;
this.wybrana = false;
}
public override double[][] ZaleznyRozkladStanow(Wiazka WiazkaKlasy)
{
double[][] stany = new double[WiazkaKlasy.V + 1][];
for (int nPoz = 0; nPoz <= WiazkaKlasy.V; nPoz++)
{
int ostInd = WiazkaKlasy.V - nPoz;
stany[nPoz] = new double[ostInd + 1];
}
stany[0][0] = 1;
double suma = 1;
for (int n = 1; n <= WiazkaKlasy.V; n++)
{
stany[n][0] = 0;
}
for (int n = t; n <= WiazkaKlasy.V; n += t)
{
stany[n][0] = stany[n - t][0] * a / (n / t) * WiazkaKlasy.sigmy[this, n - t];
suma += stany[n][0];
}
for (int n = 0; n <= WiazkaKlasy.V; n += t)
{
stany[n][0] /= suma;
}
for (int nPoz = 1; nPoz <= WiazkaKlasy.V; nPoz++)
{
int ostInd = WiazkaKlasy.V - nPoz;
stany[0][nPoz] = 1 / suma;
for (int n = 1; n <= ostInd; n++)
{
stany[n][nPoz] = 0;
}
for (int n = t; n <= ostInd; n += t)
{
stany[n][nPoz] = stany[n - t][nPoz] * a / (n / t) * WiazkaKlasy.sigmy[this, n - t + nPoz];
}
}
return(stany);
}
public override double[] RozkladStanow(Wiazka WiazkaKlasy, int nrProgu)
{
double[] stany = new double[WiazkaKlasy.V + 1];
double suma = 1;
stany[0] = 1;
for (int n = 1; n < stany.Length; n++)
{
stany[n] = 0;
}
for (int n = progiKlasy[nrProgu].t; n < stany.Length; n += progiKlasy[nrProgu].t)
{
stany[n] = stany[n - progiKlasy[nrProgu].t] * (_lambdaZero * progiKlasy[nrProgu].mnoznikIntensywnosci / progiKlasy[nrProgu]._mu) / (n / progiKlasy[nrProgu].t);
suma += stany[n];
}
for (int n = 0; n < stany.Length; n++)
{
stany[n] /= suma;
}
return(stany);
}
public trClassEngset(Wiazka wiazkaKlasy, int at, int t, double mi, bool uprzyw, int S)
: base(wiazkaKlasy, at, t, mi, uprzyw)
{
this._S = S;
typ = typKlasy.ENGSET;
}
public trClassErlang(Wiazka wiazkaKlasy, int at, int t, double mi, bool uprzyw)
: base(wiazkaKlasy, at, t, mi, uprzyw)
{
typ = typKlasy.ERLANG;
}
/// <summary> /// Wyznacza rozkład klasy, który jest zależny od zajętości systemu przez pozostałe klasy zgłoszeń. /// Taki rozkład ma sens gdy rozważamy system z procesem przyjmowania zgłoszeń zależnym od stanu. /// Prawdopodobieństwa tego rozkłądu są składowymi iloczynu prawdopodobieńśtw mikrostanów, w których /// suma indeksów pozostałych wymiarów stanowi zależność rozkładu. /// </summary> /// <param name="WiazkaKlasy">Wiązka, dla któej jest budowany rozkład</param> /// <param name="[]warPrzejscia">Prawdopodobieńśtwa warunkowych przejść</param> /// <returns></returns> public abstract double[][] ZaleznyRozkladStanow(Wiazka WiazkaKlasy);
/// <summary> /// Wyznacza rozkład stanów /// </summary> /// <param name="WiazkaKlasy">System dla którego wyznaczany jest rozkład</param> /// <param name="nrProgu">Numer progu, dla któego wyznaczany jest rozkład. Zależy on od całkowitej liczby zajętych PJP</param> /// <returns>Rozkład zajętości systemu</returns> public abstract double[] RozkladStanow(Wiazka WiazkaKlasy, int nrProgu);
/// <summary>
/// Podaje średnią liczbę obsługiwanych zgłoszeń
/// </summary>
/// <param name="popY">Średnia liczba obsługiwanych zgłoszeń w poprzedzającym stanie</param>
/// <param name="prPopStanu">Prawdopodobieństwo poprzedzającego stanu</param>
/// <param name="prStanu">Prawdopodobieństwo stanu, dla którego wyznaczamy średnią liczbę obsługiwanych zgłoszeń</param>
/// <param name="sigmaPrzyjmZgloszen">Prawdopodobieństwo przyjęcia zgłoszenia w stanie poprzedzającym aktualny stan</param>
/// <returns>Średnia liczba obsługiwanych zgłoszeń w aktualnym stanie</returns>
//public abstract double podajY(double popY, double prPopStanu, double prStanu, double sigmaPrzyjmZgloszen);
#endregion Zależność od liczby obsługiwanych zgłoszeń
#region Obliczanie rozkładów
/// <summary>
/// Wyznacza rozkład stanów
/// </summary>
/// <param name="WiazkaKlasy">System dla którego wyznaczany jest rozkład</param>
/// <param name="procPrzyjmZal">Określa czy proces przyjmowania zgłoszeń ma być zależny od stanu</param>
/// <returns>Rozkład zajętości systemu</returns>
public abstract double[] RozkladStanow(Wiazka WiazkaKlasy, bool procPrzyjmZal);
public trClassPascal(Wiazka wiazkaKlasy, int at, int t, double mi, bool uprzyw, int S)
: base(wiazkaKlasy, at, t, mi, uprzyw)
{
typ = typKlasy.PASCAL;
this._S = S;
}