public void liczYspl(sigmaPrzyjmZgl sigma, int V)
{
yi = new double[zagregowaneKlasy.Count][];
if (zagregowaneKlasy.Count == 1)
{
yi[0] = new double[V + 1];
for (int n = 0; n <= V; n += zagregowaneKlasy[0].t)
{
yi[0][n] = (double)(n) / (double)(zagregowaneKlasy[0].t);
}
return;
}
for (int i = 0; i < zagregowaneKlasy.Count; i++)
{
trClass klasa = zagregowaneKlasy[i];
yi[i] = new double[V + 1];
for (int n = 0; n <= V; n++)
{
double P_n = 0;
double Ex_n = 0;
for (int l = 0; l <= n; l += klasa.t)
{
P_n += (Pmi[i][n - l] * pi[i][l]);
Ex_n += (l / klasa.t * Pmi[i][n - l] * pi[i][l]);
}
yi[i][n] = Ex_n / P_n;
}
}
}
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);
}
public double this[trClass klasa, int nrStanu]
{
get
{
if (obliczone == false)
{
obliczSigmy();
}
if (aWiazka.ListaKlasRuchu.Contains(klasa) == false)
{
throw new InvalidCastException(string.Format("Wiazka nie zawiera takiej klasy: {0}", klasa));
}
if (nrStanu > aWiazka.V + 1)
{
return(0);
}
if (nrStanu < 0)
{
return(1);
}
return(sigmy[aWiazka.ListaKlasRuchu.IndexOf(klasa), nrStanu]);
}
set
{
throw new InvalidCastException("Nie można ustawiać sigm ręcznie");
}
}
public void liczYspl(sigmaPrzyjmZgl sigma, int V)
{
yi = new double[zagregowaneKlasy.Count][];
if (zagregowaneKlasy.Count == 1)
{
yi[0] = new double[V + 1];
for (int n = 0; n <= V; n += zagregowaneKlasy[0].t)
{
yi[0][n] = (double)(n) / (double)(zagregowaneKlasy[0].t);
}
return;
}
for (int i = 0; i < zagregowaneKlasy.Count; i++)
{
trClass klasa = zagregowaneKlasy[i];
Qmi[i].liczYspl(sigma, V); //było to już wyliczone na potrzeby splotu
double[][] prDopKomb = rGammaYc1.wyznGamma(Qmi[i], qi[i], klasa, wiazka.sigmy, V, Qmi[i].yi);
yi[i] = new double[V + 1];
for (int n = 0; n <= V; n++)
{
double P_n = 0;
double Ex_n = 0;
for (int l = 0; l <= n; l += klasa.t)
{
P_n += (Qmi[i][n - l] * qi[i][l] * prDopKomb[n - l][l]);
Ex_n += (l / klasa.t * Qmi[i][n - l] * qi[i][l] * prDopKomb[n - l][l]);
}
yi[i][n] = Ex_n / P_n;
}
}
}
public FormEditTrafficClass(FormMainWindow parent, trClass edytowana)
{
master = parent;
InitializeComponent();
klasaEdytowana = edytowana;
numericUpDownEdycjaKlasyAt.Value = (decimal)edytowana.atProp;
numericUpDownEdycjaKlasyT.Value = (decimal)edytowana.t;
numericUpDownEdycjaKlasyMu.Value = (decimal)edytowana.mu;
if (edytowana.typ == trClass.typKlasy.ENGSET)
{
labelEdycjaKlasyS.Visible = true;
numericUpDownEdycjaKlasyS.Visible = true;
trClassEngset kl = (trClassEngset)klasaEdytowana;
numericUpDownEdycjaKlasyS.Value = (decimal)kl.S;
}
if (edytowana.typ == trClass.typKlasy.PASCAL)
{
labelEdycjaKlasyS.Visible = true;
numericUpDownEdycjaKlasyS.Visible = true;
trClassPascal kl = (trClassPascal)klasaEdytowana;
numericUpDownEdycjaKlasyS.Value = (decimal)kl.S;
}
if (edytowana.typ == trClass.typKlasy.ERLANG)
{
labelEdycjaKlasyS.Visible = false;
numericUpDownEdycjaKlasyS.Visible = false;
}
}
protected override void okrRozklad()
{
base.okrRozklad();
double[] stanyY = new double[aWiazka.V + 1];
stanyY[0] = 1;
double suma = 1;
for (int n = 1; n <= aWiazka.V; n++)
{
for (int i = 0; i < aWiazka.m; i++)
{
trClass zKlasa = aWiazka.ListaKlasRuchu[i];
if (n - zKlasa.t >= 0)
{
double y = 0;
if ((n - 2 * zKlasa.t >= 0) && (stany[n - zKlasa.t] != 0))
{
y = stany[n - 2 * zKlasa.t] * zKlasa.PodajIntZgl(0)
/ (stany[n - zKlasa.t] * zKlasa.mu);
}
stanyY[n] += (zKlasa.t * zKlasa.PodajIntZgl(y) / zKlasa.mu
* stanyY[n - zKlasa.t] * pobSigma(n - zKlasa.t, i));
}
}
stanyY[n] /= n;
suma += stanyY[n];
}
for (int n = 0; n <= aWiazka.V; n++)
{
stany[n] = stanyY[n] / suma;
}
}
public SimClassErlang(trClass badana, SimGroup sWiazka, agenda listaZd, aSimulation algSym)
: base(badana, sWiazka, listaZd, algSym)
{
processSym nowy = new processErlang(listaZd, this.czNowegoZgl, this);
listaZd.DodajProces(nowy);
}
/// <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();
}
public override void BadajWiazke(int nrBad, double aOf)
{
base.BadajWiazke(nrBad, aOf);
rGammaV1[] q = new rGammaV1[aWiazka.m];
for (int i = 0; i < aWiazka.m; i++)
{
//aWiazka.ListaKlasRuchu[i].ObliczParametry(aOf, aWiazka.sumaPropAT, aWiazka.V);
q[i] = new rGammaV1(aWiazka, i, aWiazka.ListaKlasRuchu[i].RozkladStanow(aWiazka, false));
}
rGammaV1 Q = new rGammaV1(aWiazka);
for (int i = 0; i < aWiazka.m; i++)
{
Q.Agreguj(q[i]);
}
//wynikiAlg.UstawA(nrBad, aOf);
for (int i = 0; i < aWiazka.m; i++)
{
trClass pojKlasa = aWiazka.ListaKlasRuchu[i];
double E = 0;
double mianownik = 0;
for (int n = 0; n <= aWiazka.V; n++)
{
mianownik += Q.q[n];
E += (Q.q[n] * (1 - aWiazka.sigmy[i, n]));
}
wynikiAlg.UstawE(nrBad, pojKlasa, E / mianownik);
}
}
/// <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);
}
public Rozklad(Wiazka rozWiazka, trClass podstKlasa, double[] prStanow, int indV)
{
zagregowaneKlasy = new List <trClass>();
zagregowaneKlasy.Add(podstKlasa);
stany = prStanow;
_v = indV;
wiazka = rozWiazka;
}
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;
}
}
}
}
public void UstawBlE(int nrB, trClass klasa, double wartosc)
{
if ((nrB >= 0) && (nrB < _lBad))
{
int nrKlasy = SzukajNrKlasy(klasa);
if (nrKlasy < lKl)
{
_blE[nrB, nrKlasy] = wartosc;
}
}
}
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);
}
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 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 double PobE(int nrB, trClass klasa)
{
if ((nrB >= 0) && (nrB < _lBad))
{
int nrKlasy = SzukajNrKlasy(klasa);
if (nrKlasy < lKl)
{
return(_E[nrB, nrKlasy]);
}
}
return(0);
}
protected override void okrE(int nrBad)
{
for (int i = 0; i < aWiazka.m; i++)
{
trClass pojKlasa = aWiazka.ListaKlasRuchu[i];
double E = 0;
for (int n = 0; n <= aWiazka.V; n++)
{
E += (stany[n] * (1 - sigmaProcPrzyjmowaniaZgloszen[i, n]));
}
wynikiAlg.UstawE(nrBad, pojKlasa, E);
}
}
private int SzukajNrKlasy(trClass SzukanaKlasa)
{
int KlNum = 0;
foreach (trClass KlasaI in listaKlasRuchu)
{
if (KlasaI == SzukanaKlasa)
{
return(KlNum);
}
KlNum++;
}
return(lKl);
}
/// <summary>
/// Zwraca średnią liczbę obsługiwanych zgłoszeń w stanie n
/// </summary>
/// <param name="klasa">Klasa, dla któej chcemy wyznaczyć średnią liczbę obsługiwanych zgłoszeń</param>
/// <param name="n">Stan, dla którego chcemy wyznaczyć średnia liczbę obsługiwanych zgłoszeń</param>
/// <returns>Średnia liczba obsługiwanych zgłoszeń</returns>
public double y(trClass klasa, int n)
{
int t = klasa.t;
if (n < t)
{
return(0);
}
if (this[n] == 0)
{
return(0);
}
return(this[n - t] * klasa.at / this[n]);
}
protected override void okrRozklad()
{
stany[0] = 1;
for (int i = 1; i <= aWiazka.V; i++)
{
stany[i] = 0;
}
double suma = 1;
for (int n = 1; n <= aWiazka.V; n++)
{
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)
{
stany[n] += (aWiazka.ListaKlasRuchu[i].at * stany[PopStan] * sigmaProcPrzyjmowaniaZgloszen[i, n - t]);
}
}
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)
{
double at = klasaTemp.atProgi(PopStan);
stany[n] += (at * stany[PopStan] * sigmaProcPrzyjmowaniaZgloszen[i, PopStan]);
}
}
}
}
}
stany[n] /= n;
suma += stany[n];
}
for (int i = 0; i <= aWiazka.V; i++)
{
stany[i] /= suma;
}
}
public void UstawB(int nrB, trClass klasa, double wartosc)
{
if (_pstrat == false)
{
return;
}
if ((nrB >= 0) && (nrB < _lBad))
{
int nrKlasy = SzukajNrKlasy(klasa);
if (nrKlasy < lKl)
{
_B[nrB, nrKlasy] = wartosc;
}
}
}
public double PobB(int nrB, trClass klasa)
{
if (_pstrat == false)
{
return(0);
}
if ((nrB >= 0) && (nrB < _lBad))
{
int nrKlasy = SzukajNrKlasy(klasa);
if (nrKlasy < lKl)
{
return(_B[nrB, nrKlasy]);
}
}
return(0);
}
public double PobBlE(int nrB, trClass klasa)
{
if (pUfnosci == false)
{
return(0);
}
if ((nrB >= 0) && (nrB < _lBad))
{
int nrKlasy = SzukajNrKlasy(klasa);
if (nrKlasy < lKl)
{
return(_blE[nrB, nrKlasy]);
}
}
return(0);
}
public SimClass(trClass badana, SimGroup sWiazka, agenda listaZd, aSimulation algSymulacji)
{
klasaRuchu = badana;
Symulacja = algSymulacji;
this._sWiazka = sWiazka;
lZdarzen = listaZd;
generator = new Random(badana.GetHashCode());
_lambda = badana.PodajIntZgl(0);
if (badana.progiKlasy == null)
{
_mu = badana.mu;
}
_uprzyw = badana.uprzywilejowana;
lStraconychZgl = 0;
lObsluzonychZgl = 0;
}
protected override void okrE(int nrBad)
{
for (int i = 0; i < aWiazka.m; i++)
{
trClass pojKlasa = aWiazka.ListaKlasRuchu[i];
double E = 0;
int stStan = (aWiazka.q < aWiazka.V - pojKlasa.t) ? aWiazka.q : aWiazka.V - pojKlasa.t;
for (int n = 0; n <= stStan; n++)
{
E += (stany[n] * (1 - pobSigma(n, i)));
}
for (int n = stStan + 1; n <= aWiazka.V; n++)
{
E += stany[n];
}
wynikiAlg.UstawE(nrBad, pojKlasa, E);
}
}
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 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);
}
}
private double[,] obliczSigmyFAG()
{
double[,] sigmyTemp = new double[aWiazka.m, aWiazka.V + 1];
for (int i = 0; i < aWiazka.m; i++)
{
trClass klasaTemp = aWiazka.ListaKlasRuchu[i];
if (klasaTemp.progiKlasy == null)
{
for (int n = 0; n <= aWiazka.V; n++)
{
if (aWiazka.V - n >= klasaTemp.t)
{
sigmyTemp[i, n] = 1;
}
else
{
sigmyTemp[i, n] = 0;
}
}
}
else
{
for (int n = 0; n <= aWiazka.V; n++)
{
if (aWiazka.V - n >= klasaTemp.progiKlasy.Przedzial(n).t)
{
sigmyTemp[i, n] = 1;
}
else
{
sigmyTemp[i, n] = 0;
}
}
}
}
return(sigmyTemp);
}
public BDklasaZgl(int id, trClass klasa)
{
_id = id;
_klasaZgl = klasa;
}
