public TravelingSalesmanSolution DoChangeMutation()
        {
            TravelingSalesmanSolution tss = new TravelingSalesmanSolution(this);
            IList list = tss.m_PlaceList;

            Permutation.DoChange(ref list);
            return(tss);
        }
Example #2
0
        public Node DoRecombination(Node father, Node mother)
        {
            TravelingSalesmanSolution tssFather = (TravelingSalesmanSolution)father.Data;
            TravelingSalesmanSolution tssMother = (TravelingSalesmanSolution)mother.Data;
            TravelingSalesmanSolution tssChild  = tssFather.DoEdgesRecombination(tssMother);
            Node node = new Node(tssChild);

            return(node);
        }
        public TravelingSalesmanSolution(TravelingSalesmanSolution solution)
        {
            if (m_Random == null)
            {
                m_Random = new Random(unchecked ((int)DateTime.Now.Ticks));
            }

            m_PlaceList = new ArrayList(solution.m_PlaceList.Count);
            foreach (int place in solution.m_PlaceList)
            {
                m_PlaceList.Add(place);
            }
        }
Example #4
0
        // Todo
        public bool CompareNodes(INode node)
        {
            TravelingSalesmanSolution tss = (TravelingSalesmanSolution)node.Data;

            System.Console.WriteLine("Distance: " + tss.ToString());

            m_Counter++;

            //if (m_Counter == 2000)
            //	return true;

            return(false);
        }
Example #5
0
        public void DoMutation(ref Node individual)
        {
            TravelingSalesmanSolution tss = (TravelingSalesmanSolution)individual.Data;

            /*if (m_Random.NextDouble() < 0.01)
             * {
             *      tssMut = tss.DoChangeMutation();
             * }
             * else*/
            {
                tss.DoInvertMutation();
            }
        }
        public TravelingSalesmanSolution DoEdgesRecombination(TravelingSalesmanSolution tssPartner)
        {
            // Das zu erzeugende Kind
            TravelingSalesmanSolution tssChild = new TravelingSalesmanSolution();

            // Eine Liste der Orte, die noch zur Verfügung stehen, wird gebraucht, wenn ein zufälliger rechtsseitiger Ort generiert werden muss
            ArrayList tempPlaceList = new ArrayList(m_PlaceList.Count);

            // Mit allen Orten füllen
            for (int i = 0; i < m_PlaceList.Count; i++)
            {
                tempPlaceList.Add(i);
            }

            // Die Hashtable, die alle AdjazenzInformationen in Form eine ArrayList von höchstens 4 Werten hält
            Hashtable adjList = new Hashtable();

            for (int i = 0; i < m_PlaceList.Count; i++)
            {
                int indexFather = i;
                int indexMother = tssPartner.GetPlaceIndex((int)m_PlaceList[i]);

                ArrayList adj = new ArrayList(4);

                // der linksseitige Ort vom Vater
                if (indexFather > 0)
                {
                    adj.Add(m_PlaceList[indexFather - 1]);
                }
                else
                {
                    adj.Add(m_PlaceList[m_PlaceList.Count - 1]);
                }

                // der rechtsseitige Ort vom Vater
                if (indexFather < m_PlaceList.Count - 1)
                {
                    adj.Add(m_PlaceList[indexFather + 1]);
                }
                else
                {
                    adj.Add(m_PlaceList[0]);
                }

                // der linksseitige Ort der Mutter, wenn noch nicht enthalten
                if (indexMother > 0)
                {
                    if (!adj.Contains(tssPartner.m_PlaceList[indexMother - 1]))
                    {
                        adj.Add(tssPartner.m_PlaceList[indexMother - 1]);
                    }
                }
                else
                {
                    if (!adj.Contains(tssPartner.m_PlaceList[m_PlaceList.Count - 1]))
                    {
                        adj.Add(tssPartner.m_PlaceList[m_PlaceList.Count - 1]);
                    }
                }

                // der rechtsseitige Ort der Mutter, wenn noch nicht enthalten
                if (indexMother < m_PlaceList.Count - 1)
                {
                    if (!adj.Contains(tssPartner.m_PlaceList[indexMother + 1]))
                    {
                        adj.Add(tssPartner.m_PlaceList[indexMother + 1]);
                    }
                }
                else
                {
                    if (!adj.Contains(tssPartner.m_PlaceList[0]))
                    {
                        adj.Add(tssPartner.m_PlaceList[0]);
                    }
                }

                adjList.Add(m_PlaceList[i], adj);
            }

            // Wähle zufällig eine AnfangsAdjazenzInformation
            int adjIndex = Convert.ToInt32(Math.Round(m_Random.NextDouble() * (m_PlaceList.Count - 1)));

            // Belege den ersten Ort des Kindes
            tssChild.m_PlaceList[0] = adjIndex;

            for (int i = 1; i < m_PlaceList.Count; i++)
            {
                // Entferne den aktuellen AdjazenzIndex (Ort) aus der Adjazenzliste und aus der temporären Ortliste
                RemovePlaceFromAdjacent(adjList.Values, adjIndex);
                tempPlaceList.Remove(adjIndex);

                int       count      = 0;
                int       countMin   = 5;
                ArrayList adjCurrent = (ArrayList)adjList[adjIndex];
                ArrayList nextAdjs   = new ArrayList();

                foreach (int place in adjCurrent)
                {
                    ArrayList adjTemp = (ArrayList)adjList[place];
                    count = adjTemp.Count;
                    if (count < countMin)
                    {
                        nextAdjs.Clear();
                        countMin = count;
                        nextAdjs.Add(place);
                    }
                    else if (count == countMin)
                    {
                        nextAdjs.Add(place);
                    }
                }

                // Wurden keine möglichen Kanten gefunden, muss ein zufällig ausgewählter Ort genutzt werden
                if (nextAdjs.Count == 0)
                {
                    int tempIndex = Convert.ToInt32(Math.Round(m_Random.NextDouble() * (tempPlaceList.Count - 1)));
                    adjIndex = (int)tempPlaceList[tempIndex];
                }
                else if (nextAdjs.Count == 1)
                {
                    adjIndex = (int)nextAdjs[0];
                }
                else
                {
                    // Bei mehreren guten nächsten Orten, wähle zufällig einen aus
                    int indexMinPlace = Convert.ToInt32(Math.Round(m_Random.NextDouble() * (nextAdjs.Count - 1)));
                    adjIndex = (int)nextAdjs[indexMinPlace];
                }

                // Nächsten Ort setzen
                tssChild.m_PlaceList[i] = adjIndex;
            }

            return(tssChild);
        }
Example #7
0
        public double GetObjectiveFunction(Node node)
        {
            TravelingSalesmanSolution tss = (TravelingSalesmanSolution)node.Data;

            return(tss.CalculateDistance());
        }