コード例 #1
0
        public void Agreguj(rSigmaYt agregowany, int V)
        {
            double[][] prDopKomb = rSigmaYt.wyznGamma(this, agregowany, wiazka.sigmy, V);
            niezalezny.Agreguj(agregowany.niezalezny);
            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] * agregowany[n - lC] * prDopKomb[lC][n - lC];
                    suma     += tmp;
                    stany[n] += tmp;
                }
            }
            foreach (trClass klasaR in agregowany.zagregowaneKlasy)
            {
                zagregowaneKlasy.Add(klasaR);
            }
            if (this.V != V)
            {
                zmienDlugosc(V, false);
            }
            for (int n = 0; n <= V; n++)
            {
                this[n] = stany[n] / suma;
            }
        }
コード例 #2
0
        /// <summary>
        /// Określa prawdopodobieństwa dopuszczenia kombinacji.
        /// Każdy element tablicy [lC][lD] odpowiada prawdopodobieńśtwu dopuszczenia kombinacji (lC, lD).
        /// </summary>
        /// <param name="rC">Zagregowany rozkład zajętości klas ze zbioru C</param>
        /// <param name="rD">Zagregowany rozkład zajętości klas ze zbioru D</param>
        /// <param name="sigmy">Tablica z prawdopodobieńśtwami warunkowych przejść dla wszystkich klas</param>
        /// <param name="V">Pojemność systemu</param>
        /// <returns>Dwuwymiarowa tablica z prawdopodobieńśtwami dopuszczenia kombinacji</returns>
        public static double[][] wyznGamma(rSigmaYt rC, rSigmaYt rD, sigmaPrzyjmZgl sigmy, int V)
        {
            double[][] Gamma = new double[V + 1][];
            for (int l = 0; l <= V; l++)
            {
                Gamma[l] = new double[V - l + 1];
            }

            int lC = 0;
            int lD = 0;

            while (lD <= V)
            {
                double GammaClicznik = 0;
                double GammaDlicznik = 0;

                double GammaCmianownik = 0;
                double GammaDmianownik = 0;

                foreach (trClass klasa in rC.zagregowaneKlasy)
                {
                    if (rC[lC - klasa.t] == 0)
                    {
                        continue;
                    }

                    GammaClicznik   += klasa.at * sigmy[klasa, lC + lD - klasa.t] * Gamma[lC - klasa.t][lD] * rC[lC - klasa.t];
                    GammaCmianownik += klasa.at * sigmy[klasa, lC - klasa.t] * rC[lC - klasa.t];
                }
                foreach (trClass klasa in rD.zagregowaneKlasy)
                {
                    if (rD[lD - klasa.t] == 0)
                    {
                        continue;
                    }

                    GammaDlicznik   += klasa.at * sigmy[klasa, lC + lD - klasa.t] * Gamma[lC][lD - klasa.t] * rD[lD - klasa.t];
                    GammaDmianownik += klasa.at * sigmy[klasa, lD - klasa.t] * rD[lD - klasa.t];
                }

                double GammaC = (GammaCmianownik == 0) ? 0 : GammaClicznik / GammaCmianownik;
                double GammaD = (GammaDmianownik == 0) ? 0 : GammaDlicznik / GammaDmianownik;

                if (lC + lD == 0)
                {
                    Gamma[0][0] = 1;
                }
                else
                {
                    Gamma[lC][lD] = (lC * GammaC + lD * GammaD) / (lC + lD);
                }

                lC++;
                if (lC + lD > V)
                {
                    lD++;
                    lC = 0;
                }
            }
            return(Gamma);
        }