public aRekBackForward(Wiazka wAlg, double epsilon, int liczbaIteracji)
: base(wAlg)
{
lIteracji = liczbaIteracji;
this.epsilon = epsilon;
utworzOpis();
}
public aSimulationType4(Wiazka wSymulowana)
: base(wSymulowana, 4, wSymulowana.bazaDanych, "względny czas na typie float, statystyki na zmiennych typu double")
{
SkrNazwaAlg = "Sym4";
NazwaAlg = "Symulacja typ 4";
_symulacja = true;
}
public aSimulationType5(Wiazka wSymulowana)
: base(wSymulowana, 5, wSymulowana.bazaDanych, "bezwzględny czas typu float, statystyki na zmiennych typu double")
{
SkrNazwaAlg = "Sym5";
NazwaAlg = "Symulacja typ 5";
_symulacja = true;
}
public aRoberts(Wiazka wAlg)
: base(wAlg)
{
NazwaAlg = "Roberts";
SkrNazwaAlg = "Rob";
sigmaProcPrzyjmowaniaZgloszen = new sigmaPrzyjmZgl(aWiazka);
}
public aSimulationType1(Wiazka wSymulowana)
: base(wSymulowana, 1, wSymulowana.bazaDanych, "względny czas, statystyki na zmiennych typu double")
{
SkrNazwaAlg = "Sym1";
NazwaAlg = "Symulacja typ 1";
_symulacja = true;
}
public aRobertsOgrDostSplotowy(Wiazka wAlg)
: base(wAlg)
{
NazwaAlg = "Rob Splotowy";
SkrNazwaAlg = "RobSpl";
sigmy = null;
}
public delta(Wiazka mWiazka)
{
aWiazka = mWiazka;
sStruktury = new sigmaPrzyjmZgl(mWiazka);
oszacowana = false;
_Y = new liczbaY(mWiazka);
}
public aRobertsIteracyjny(Wiazka wAlg, double epsilon, int liczbaIteracji)
: base(wAlg)
{
lIteracji = liczbaIteracji;
this.epsilon = epsilon;
utworzOpis();
}
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 aSplotowyUv2(Wiazka wAlg)
: base(wAlg)
{
normalizowac = true;
NazwaAlg = "Iversen v2";
SkrNazwaAlg = "Iv2";
}
public aHybrydowyY(Wiazka wAlg)
: base(wAlg)
{
NazwaAlg = "Hybrydowy Yspl";
SkrNazwaAlg = "Hybr Yspl";
delta = new delta(wAlg);
}
public aHybrydowyMISM(Wiazka wAlg, double eps, int maxLiczbaIteracji)
: base(wAlg)
{
_epsilon = eps;
if (_epsilon != 0)
{
NazwaAlg = "Hybrydowy ε " + _epsilon.ToString();
SkrNazwaAlg = "Hybr ε " + _epsilon.ToString();
}
else
{
if (maxLiczbaIteracji == 1)
{
NazwaAlg = "Hybrydowy SISM";
SkrNazwaAlg = "Hybr SISM";
}
else
{
NazwaAlg = "Hybrydowy " + maxLiczbaIteracji.ToString() + " ISM";
SkrNazwaAlg = "Hybr" + maxLiczbaIteracji.ToString() + "Ism";
}
}
delta = new delta(wAlg);
if (_epsilon != 0)
{
_maxIteracja = 10000;
}
else
{
_maxIteracja = maxLiczbaIteracji;
}
}
public aSplWogrDostLos2(Wiazka wAlg)
: base(wAlg)
{
normalizowac = false;
NazwaAlg = "Spl los 2";
SkrNazwaAlg = "Spl_los2";
}
public aPrzelHipergeometryczny(Wiazka wAlg)
: base(wAlg)
{
dwumian = new dwumianNewtona(30);
NazwaAlg = "Iversen Przel. Hipergeometr";
SkrNazwaAlg = "przel_hip";
}
public aPrzelMs2(Wiazka wAlg)
: base(wAlg)
{
dwumian = new dwumianNewtona(30);
NazwaAlg = "Kolejnosciowy2";
SkrNazwaAlg = "alg. kol2.";
}
public aSymulationTyp6(Wiazka wSymulowana)
: base(wSymulowana, 6, wSymulowana.bazaDanych, "bezwzględny czas typu float, statystyki na zmiennych typu double, dodawane bez optymalizacji")
{
SkrNazwaAlg = "Sym6";
NazwaAlg = "Symulacja typ 6";
_symulacja = true;
}
public Rozklad(Wiazka rozWiazka, trClass podstKlasa, double[] prStanow, int indV)
{
zagregowaneKlasy = new List <trClass>();
zagregowaneKlasy.Add(podstKlasa);
stany = prStanow;
_v = indV;
wiazka = rozWiazka;
}
/// <summary>
/// Tworzenie zależnego rozkładu zajętości pojedynczej klasu wraz z wyznaczaniem odpowiednich prawdopodobieństw stanów.
/// </summary>
/// <param name="Wiazka">Wiązka, której zajętość opisuje rozkład zależny.</param>
/// <param name="klasaRuchu">Klasa ruchu, której dotyczy ten rozkład zajętości.</param>
public RozkladZalezny(Wiazka Wiazka, trClass klasaRuchu)
{
this._v = Wiazka.V;
this.rWiazka = Wiazka;
zagregowaneKlasy = new List <trClass>();
zagregowaneKlasy.Add(klasaRuchu);
stany = klasaRuchu.ZaleznyRozkladStanow(Wiazka);
}
protected aSimulation(Wiazka wSymulowana, int typSymulacji, IBDwynsymulacji bazaDanych, string opis)
: base(wSymulowana)
{
this.opis = opis;
this.typSymulacji = typSymulacji;
this.bazaDanych = bazaDanych;
lWatkow = Environment.ProcessorCount;
}
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.
}
public rGamma(Wiazka wiazka)
{
klasy = new klasaUpr[0];
this.wiazka = wiazka;
p = new double[wiazka.V + 1];
q = new double[wiazka.V + 1];
p[0] = 1;
q[0] = 1;
}
public Rozklad(Wiazka rozWiazka, int V)
{
zagregowaneKlasy = new List <trClass>();
wiazka = rozWiazka;
_v = (V == 0) ? rozWiazka.V : V;
stany = new double[_v + 1];
stany[0] = 1;
for (int i = 1; i <= _v; i++)
{
stany[i] = 0;
}
}
public SimGroup(Wiazka wSymulowana)
{
_n = 0;
_K = wSymulowana.sumaK;
_V = wSymulowana.V;
totRozklZaj = new double[_V + 1];
_maxVi = wSymulowana.maxVi;
maxWolnePJP = new double[maxVi + 1];
maxWolnePJPrez = new double[maxVi + 1];
lPrzyjZglWstanieN = new int[_V + 1];
lUtrZglWstanieN = new int[_V + 1];
_q = (wSymulowana.AlgorytmRezerwacji == reservationAlgorithm.R3) ? _V : wSymulowana.q;
sPodgr = new SimSubGroup[_K];
int lP = 0;
foreach (Subgroup klPodgr in wSymulowana.ListaPodgrupLaczy)
{
int lokQ = (wSymulowana.AlgorytmRezerwacji == reservationAlgorithm.R3) ? klPodgr.v - wSymulowana.tMax : lokQ = klPodgr.v;
for (int i = 0; i < klPodgr.k; i++)
{
sPodgr[lP++] = new SimSubGroup(klPodgr.v, lokQ, this);
}
}
aRez = wSymulowana.AlgorytmRezerwacji;
switch (wSymulowana.aWybPodgr)
{
case subgroupChooseAlgorithm.sequence:
arbWybPodgr = new ChooseArbiterSequence(this);
break;
case subgroupChooseAlgorithm.RR:
arbWybPodgr = new ChooseArbiterRR(this);
break;
case subgroupChooseAlgorithm.random:
arbWybPodgr = new ChooseArbitrRandom(this);
break;
case subgroupChooseAlgorithm.randomCapacityProportional:
arbWybPodgr = new ChooseArbiterRandomProportional(this);
break;
case subgroupChooseAlgorithm.randomOccupancyProportional:
arbWybPodgr = new ChooseArbiterOccupancyProportional(this);
break;
default:
arbWybPodgr = null;
break;
}
}
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 rGamma(Wiazka wiazka, int i, double [] stany)
{
this.wiazka = wiazka;
klasy = new klasaUpr[1];
int t = wyznaczT(stany);
klasy[0].i = i;
klasy[0].t = t;
klasy[0].waga = wyznaczWage(stany);
p = new double[stany.Length];
q = new double[stany.Length];
for (int n = 0; n < stany.Length; n++)
{
p[n] = stany[n];
q[n] = (n < t) ? p[n] : p[n] * delta(n - t) * wiazka.sigmy[i, n - t];
}
}
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;
}
}
}
public RozkladZalezny(RozkladZalezny kopiowany)
{
this._v = kopiowany._v;
this.rWiazka = kopiowany.rWiazka;
zagregowaneKlasy = new List <trClass>();
foreach (trClass klasa in kopiowany.zagregowaneKlasy)
{
zagregowaneKlasy.Add(klasa);
}
stany = new double[_v + 1][];
for (int nPoz = 0; nPoz <= _v; nPoz++)
{
int ostInd = _v - nPoz;
stany[nPoz] = new double[ostInd + 1];
}
for (int nPoz = 0; nPoz <= _v; nPoz++)
{
int ostInd = _v - nPoz;
for (int n = 0; n <= ostInd; n++)
{
stany[n][nPoz] = kopiowany[n, nPoz];
}
}
}
public DebugPar(Wiazka mWiazka)
{
IterRozklad = new List <double[]>();
IterY = new List <double[, ]>();
IterBladWzgl = new List <double[, ]>();
IterSigma = new List <double[, ]>();
IterEpsilon = new List <double>();
SigmaStr = new List <double[]>();
SigmaStrat = new List <double[]>();
iteracjaNr = 0;
this.mWiazka = mWiazka;
_logIterY = true;
_logIterRozkl = true;
_logIterBladWzgl = false;
_logIterSigma = true;
_logEpsilon = true;
_logSigmaStr = true;
_logSigmaStrat = true;
}
public rGammaV3(Wiazka wiazka, int i, double[] stany) : base(wiazka, i, stany)
{
}
