private NajsredniejszaOdleglosc TworzSrednia(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosci,
                                                     double czescMrowek, Random maszynaLosujaca)
        {
            var listaMrowek         = mrowki.ToList();
            var liczbaMrowek        = listaMrowek.Count;
            var liczbaDoWylosowania = Math.Round(czescMrowek * liczbaMrowek);

            List <Mrowka> wylosowaneMrowki = new List <Mrowka>();

            for (int i = 0; i < liczbaDoWylosowania; i++)
            {
                var indeks = maszynaLosujaca.Next(liczbaMrowek);
                var mrowka = listaMrowek[indeks];
                if (!wylosowaneMrowki.Contains(mrowka))
                {
                    wylosowaneMrowki.Add(mrowka);
                }
                else
                {
                    i--;
                }
            }

            return(new NajsredniejszaOdleglosc(wylosowaneMrowki, odleglosci));
        }
Example #2
0
 public AktywatorUwzglPodobienstwo(Sasiedztwo sasiedztwo, IOdleglosc <Mrowka> odleglosci, int minSasiadow, double progNiepodobienstwa)
 {
     this.sasiedztwo          = sasiedztwo;
     this.odleglosci          = odleglosci;
     this.minSasiadow         = minSasiadow;
     this.progNiepodobienstwa = progNiepodobienstwa;
 }
Example #3
0
 public GlobalnyPodobienstwowyOkreslaczKlas(IOdleglosc <Mrowka> odleglosc, Sasiedztwo sasiedztwo, Czas czas, bool minProgGlobalny = false)
 {
     this.odleglosc    = odleglosc;
     this.sasiedztwo   = sasiedztwo;
     this.czas         = czas;
     popIteracja       = 0;
     mrowkiKlasAktIter = new Dictionary <int, List <Mrowka> >();
     MinProgGlobalny   = minProgGlobalny;
 }
        private double obliczSredniaOdleglosc(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosci)
        {
            var uporzadkowaneMrowki = mrowki.OrderBy(mrowka => mrowka.Id).ToList();

            double sumaOdleglosci = 0.0;

            for (int i = 0; i < uporzadkowaneMrowki.Count; i++)
            {
                var m1 = uporzadkowaneMrowki[i];
                for (int j = i + 1; j < uporzadkowaneMrowki.Count; j++)
                {
                    var m2 = uporzadkowaneMrowki[j];
                    sumaOdleglosci += odleglosci.OkreslOdleglosc(m1, m2);
                }
            }

            int    liczbaOdleglosci  = (uporzadkowaneMrowki.Count * (uporzadkowaneMrowki.Count - 1)) / 2;
            double sredniaOdleglosci = sumaOdleglosci / liczbaOdleglosci;

            return(sredniaOdleglosci);
        }
Example #5
0
 public AltOceniacz(IOdleglosc <Mrowka> slownikOdleglosci, ISrednieOdleglosci srednieOdleglosci, Sasiedztwo sasiedztwo)
 {
     sloOdleglosci          = slownikOdleglosci;
     this.srednieOdleglosci = srednieOdleglosci;
     this.sasiedztwo        = sasiedztwo;
 }
Example #6
0
        private static KonfiguracjaGrupowania Konfiguracja_SA4C_2004(Random maszynaLosujaca, int liczIteracji, int zasiegWzroku,
                                                                     IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> miaraOdleglosci)
        {
            var przestrzen         = Przestrzen.StworzPrzestrzenDla(mrowki.Count());
            var sasiedztwo         = new Sasiedztwo(przestrzen, zasiegWzroku, zasiegWzroku);
            var czas               = new Czas(liczIteracji);
            var srednieDopasowania = new SrednieDopasowaniaMrowek();
            var presja             = new StalaPresja(2);
            var srednieOdleglosci  = new StalaUdajacaSrednia(0.3);

            return(new KonfiguracjaGrupowania()
            {
                MaszynaLosujaca = maszynaLosujaca,
                SrednieDopasowania = srednieDopasowania,
                Aktywator = new AltAktywator(maszynaLosujaca, presja),
                LiczbaIteracji = liczIteracji,
                Przestrzen = przestrzen,
                Sasiedztwo = sasiedztwo,
                SrednieOdleglosci = srednieOdleglosci,
                Oceniacz = new AltOceniacz(miaraOdleglosci, srednieOdleglosci, sasiedztwo),
                Czas = czas
            });
        }
Example #7
0
        private static KonfiguracjaGrupowania Konfiguracja_A4C_2007(Random maszynaLosujaca, int liczIteracji, int zasiegWzroku,
                                                                    IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> miaraOdleglosci)
        {
            var deltaT  = 50;
            var kAlfa   = 0.5;
            var kLambda = 1.0;
            var bazowePrawdopAktywacji = 0.1;

            var przestrzen         = Przestrzen.StworzPrzestrzenDla(mrowki.Count());
            var sasiedztwo         = new Sasiedztwo(przestrzen, zasiegWzroku, zasiegWzroku);
            var czas               = new Czas(liczIteracji);
            var srednieDopasowania = new SrednieDopasowaniaMrowek();
            var presja             = new PresjaZaleznaOdCzasu(czas, srednieDopasowania, kLambda);
            var srednieOdleglosci  = new SrednieOdleglosciOdCzasu(czas, srednieDopasowania, new KonfiguracjaSredniejOdlOdCzasu()
            {
                IleJednostekCzasuSpogladacWstecz           = deltaT,
                SposobOkreslaniaWartosciPrzedUaktywnieniem = new NajsredniejszaOdleglosc(mrowki, miaraOdleglosci),
                StopienWplywuRoznicySrednichNaWynikWDanejJednostceCzasu = kAlfa
            });

            return(new KonfiguracjaGrupowania()
            {
                MaszynaLosujaca = maszynaLosujaca,
                SrednieDopasowania = srednieDopasowania,
                Aktywator = new Aktywator(maszynaLosujaca, bazowePrawdopAktywacji, presja),
                LiczbaIteracji = liczIteracji,
                Przestrzen = przestrzen,
                Sasiedztwo = sasiedztwo,
                SrednieOdleglosci = srednieOdleglosci,
                Oceniacz = new Oceniacz(miaraOdleglosci, srednieOdleglosci, sasiedztwo),
                Czas = czas
            });
        }
 public PodobienstwowyOkreslaczKlas(IOdleglosc <Mrowka> odleglosciPomiedzyMrowkami, Sasiedztwo sasiedztwo)
 {
     odleglosci      = odleglosciPomiedzyMrowkami;
     this.sasiedztwo = sasiedztwo;
 }
 public SredniaPodzbioru(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosci, double czescMrowek, Random maszynaLosujaca)
 {
     srednia = TworzSrednia(mrowki, odleglosci, czescMrowek, maszynaLosujaca);
 }
 public NajsredniejszaOdleglosc(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosci)
 {
     sredniaOdleglosc = obliczSredniaOdleglosc(mrowki, odleglosci);
 }
Example #11
0
 public MrowkowaOdleglosc(IOdleglosc <double[]> odlegloscBazowa)
 {
     this.odlegloscBazowa = odlegloscBazowa;
 }
Example #12
0
 public SlownikOdleglosci(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosc)
 {
     this.odleglosc    = odleglosc;
     slownikOdleglosci = TworzSlownikOdleglosci(mrowki);
 }
Example #13
0
        private Dictionary <int, double> TworzSlownikSrednichOdleglosci(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosci)
        {
            var slownik = new Dictionary <int, double>();

            var listaMrowek = mrowki.ToList();

            for (int i = 0; i < listaMrowek.Count; i++)
            {
                var    m1 = listaMrowek[i];
                double sumaOdleglosciMrowki = 0.0;
                for (int j = 0; j < listaMrowek.Count; j++)
                {
                    if (i != j)
                    {
                        var m2 = listaMrowek[j];
                        sumaOdleglosciMrowki += odleglosci.OkreslOdleglosc(m1, m2);
                    }
                }
                var sredniaOdleglosciMrowki = sumaOdleglosciMrowki / (listaMrowek.Count - 1);
                slownik[m1.Id] = sredniaOdleglosciMrowki;
            }

            return(slownik);
        }
Example #14
0
 public SrednieOdleglosciDlaAgentow(IEnumerable <Mrowka> mrowki, IOdleglosc <Mrowka> odleglosci)
 {
     srednieOdleglosci = TworzSlownikSrednichOdleglosci(mrowki, odleglosci);
 }