/// <summary>
        /// Metoda konwertuje dane w pliku XML pod struktury dla C#
        /// </summary>
        /// <param name="nazwaPakietu">Nazwa pliku xml zawierającego dane</param>
        private void Inicjalizacja(string nazwaPakietu)
        {
            // pobranie pliku z danymi z dysku
            XmlDocument dokument = new XmlDocument();

            dokument.Load("./Dane/TTP/" + nazwaPakietu + ".xml");

            // pobranie danych składowych problemów optymalizacyjnych z dysku
            XmlNode przypadekTSP = dokument.DocumentElement.SelectSingleNode("/korzen/tsp");
            XmlNode przypadekKP  = dokument.DocumentElement.SelectSingleNode("/korzen/kp");

            // utworzenie instancji składowych problemów optymalizacyjnych
            problemPlecakowy    = new ProblemPlecakowy(przypadekKP.InnerText);
            problemKomiwojazera = new ProblemKomiwojazera(przypadekTSP.InnerText);

            // pobranie inforamcji o dostępnościach przedmiotów w poszczególnych miastach
            XmlNodeList rozmieszczeniePrzedmiotow = dokument.DocumentElement.SelectNodes("/korzen/dostepnePrzedmioty/miasto");

            dlugoscGenotypu = (ushort)rozmieszczeniePrzedmiotow.Count;

            dostepnePrzedmioty = new ushort[problemKomiwojazera.ZwrocDlugoscGenotypu()][];
            for (int i = 0; i < problemKomiwojazera.ZwrocDlugoscGenotypu(); i++)
            {
                // dla każdego i-tego miasta przypisanie dostępności przedmiotów
                dostepnePrzedmioty[i] = new ushort[problemPlecakowy.ZwrocDlugoscGenotypu()];
                dostepnePrzedmioty[i] = (ushort[])((new Miasto()).ZwrocPrzedmioty(
                                                       rozmieszczeniePrzedmiotow[i].InnerText,
                                                       problemPlecakowy.ZwrocDlugoscGenotypu()
                                                       ).Clone());
            }
        }
Example #2
0
        /// <summary>
        /// Metoda zwraca instancję wybranego Problemu Optymalizacyjnego
        /// </summary>
        /// <returns>Instancję Problemu Optymalizacyjnego</returns>
        private ProblemOptymalizacyjny ZwrocWybranyProblem()
        {
            if (parametry["problem"] == "Problem Plecakowy")
            {
                ProblemPlecakowy problemKP = new ProblemPlecakowy(parametry["dane"]);
                problemKP.UstawOgraniczeniaProblemu(float.Parse(parametry["maxWaga"]));

                return(problemKP);
            }
            else if (parametry["problem"] == "Problem Podróżującego Złodzieja")
            {
                ProblemPodrozujacegoZlodzieja problemTTP = new ProblemPodrozujacegoZlodzieja(parametry["dane"], parametry["modelTTP"]);
                problemTTP.UstawOgraniczeniaProblemu(new float[] { float.Parse(parametry["maxWaga"]), float.Parse(parametry["wyporzyczeniePlecaka"]) });

                return(problemTTP);
            }

            return(new ProblemKomiwojazera(parametry["dane"]));
        }
Example #3
0
        public Dictionary <string, float[]> ObliczWartoscFunkcjiCelu(float[] dlugosciTrasy, ushort[][] mapaPrzedmiotow, float[] ograniczeniaProblemu, ProblemPlecakowy problemPlecakowy)
        {
            float sumarycznaWartosc = 0,
                  sumarycznaWaga    = 0,
                  czasPodrozy       = 0;

            Dictionary <string, float[]> wynik     = new Dictionary <string, float[]>();
            Dictionary <string, float[]> wynikTTP1 = new TTP1().ObliczWartoscFunkcjiCelu(dlugosciTrasy, mapaPrzedmiotow, ograniczeniaProblemu, problemPlecakowy);

            for (int i = 0, j = -1; i < mapaPrzedmiotow.Length; i++, j++)
            {
                // zebrane przedmioty dla i-tego miasta
                IElement[] zebranePrzedmioty = problemPlecakowy.ZwrocWybraneElementy(mapaPrzedmiotow[i]);
                // obliczenie zysku z pobranych przedmiotów dla i-tego miasta
                Dictionary <string, float[]> wynikCzesciowy = problemPlecakowy.ObliczZysk(zebranePrzedmioty);

                // obliczenie prędkości złodzieja, gdzie maksymalna prędkość = 1, minimalna prękość = 0.1
                double predkosc = 1 - sumarycznaWaga * (1 - 0.1) / ograniczeniaProblemu[0];
                // jeżeli prędkość mniejsza od minimalnej, wtedy przypisz minimalną prędkość
                predkosc = (predkosc < 0.1) ? 0.1 : predkosc;

                // przy mieście nr. 1 czas podróży wynosi 0 jednostek
                if (j != -1)
                {
                    czasPodrozy += (float)(dlugosciTrasy[j] / predkosc);
                }

                sumarycznaWaga    += wynikCzesciowy["min"][0];                                                                                                    // całkowita waga
                sumarycznaWartosc += (float)(wynikCzesciowy["max"][0] * Math.Pow(ograniczeniaProblemu[1], Math.Floor((wynikTTP1["min"][1] - czasPodrozy) / 10))); // całkowita wartość
            }

            wynik["min"] = new float[] { 0, 0 };
            wynik["max"] = new float[] { 0, 0 };

            // ustawienie parametrów do minimalizacji
            wynik["min"][0] = sumarycznaWaga;
            wynik["min"][1] = czasPodrozy;
            // obliczenie funkcji zysku dla TTP
            wynik["max"][0] = sumarycznaWartosc - ograniczeniaProblemu[1] * czasPodrozy;
            wynik["max"][1] = sumarycznaWartosc;

            return(wynik);
        }