Esempio n. 1
0
        public Hive(int totalNumberBees, int numberInactive, int numberActive, int numberScout, int maxNumberVisits,
                    int maxNumberCycles, CitiesData citiesData)
        {
            random = new Random(0);

            this.totalNumberBees = totalNumberBees;
            this.numberInactive  = numberInactive;
            this.numberActive    = numberActive;
            this.numberScout     = numberScout;
            this.maxNumberVisits = maxNumberVisits;
            this.maxNumberCycles = maxNumberCycles;
            //this.maxCyclesWithNoImprovement = maxCyclesWithNoImprovement;

            //this.citiesData = new CitiesData(citiesData.cities.Length); // hive's copy of problem-specific data
            this.citiesData = citiesData; // reference to CityData

            // this.probPersuasion & this.probMistake are hard-coded in class definition

            this.bees                 = new Bee[totalNumberBees];
            this.bestMemoryMatrix     = citiesData.GenerateRandomMemoryMatrix(); // alternative initializations are possible
            this.bestMeasureOfQuality = citiesData.PathLength(this.bestMemoryMatrix);

            this.indexesOfInactiveBees = new int[numberInactive]; // indexes of bees which are currently inactive

            for (int i = 0; i < totalNumberBees; ++i)             // initialize each bee, and best solution
            {
                int currStatus;                                   // depends on i. need status before we can initialize Bee
                if (i < numberInactive)
                {
                    currStatus = 0;               // inactive
                    indexesOfInactiveBees[i] = i; // curr bee is inactive
                }
                else if (i < numberInactive + numberScout)
                {
                    currStatus = 2; // scout
                }
                else
                {
                    currStatus = 1; // active
                }

                int[]  randomMemoryMatrix = citiesData.GenerateRandomMemoryMatrix();
                double mq             = citiesData.PathLength(randomMemoryMatrix);
                int    numberOfVisits = 0;

                bees[i] = new Bee(currStatus, randomMemoryMatrix, mq, numberOfVisits); // instantiate current bee

                // does this bee have best solution?
                if (bees[i].measureOfQuality < bestMeasureOfQuality) // curr bee is better (< because smaller is better)
                {
                    Array.Copy(bees[i].memoryMatrix, this.bestMemoryMatrix, bees[i].memoryMatrix.Length);
                    this.bestMeasureOfQuality = bees[i].measureOfQuality;
                }
            } // each bee
        }     // TravelingSalesmanHive ctor
Esempio n. 2
0
        private void ShortPathInsideCluster(Cluster c)
        {
            int totalNumberBees = 6;
            int numberInactive  = 1;
            int numberActive    = 3;
            int numberScout     = 2;

            int maxNumberVisits = 3;
            int maxNumberCycles = 10;



            CitiesData ncdc = new CitiesData(citiesData.citiesDistance, citiesData.coordinates, true, c.inputPathTo, c.outputPathFrom, c.cities);
            Hive       hive = new Hive(totalNumberBees, numberInactive, numberActive, numberScout, maxNumberVisits, maxNumberCycles, ncdc);

            hive.Solve(false);
            c.path = hive.bestMemoryMatrix;
        }
Esempio n. 3
0
        public static void Main(string[] args)
        {
            //try
            //{
            //    Console.WriteLine("");
            string filename;

            Console.WriteLine("Enter filename: ");
            filename = Console.ReadLine();

            double[,] citycoordinates = ReadFileCoordinatesCity(filename);
            double[,] citymatrix      = CoordinatesToDistanceMatrix(citycoordinates);
            //int [,] citymatrix= ReadFileCityToMatrix("1.txt");
            CitiesData citiesData = new CitiesData(citymatrix, citycoordinates);

            Console.WriteLine("Number of cities = " + citiesData.citiesDistance.GetLength(0));
            ClasterFogel cl        = new ClasterFogel(5, citiesData);
            Stopwatch    stopWatch = new Stopwatch();

            stopWatch.Start();

            cl.Clustering();
            Console.WriteLine("\n===================\nCLASTER ALGORITHM:");
            Console.WriteLine(cl.ToString());
            stopWatch.Stop();
            // Get the elapsed time as a TimeSpan value.
            TimeSpan ts = stopWatch.Elapsed;

            // Format and display the TimeSpan value.
            string elapsedTime = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
                                               ts.Hours, ts.Minutes, ts.Seconds,
                                               ts.Milliseconds / 10);

            Console.WriteLine("RunTime " + elapsedTime);

            int totalNumberBees = 6;
            int numberInactive  = 1;
            int numberActive    = 3;
            int numberScout     = 2;

            int maxNumberVisits = 3;
            int maxNumberCycles = 10;


            Hive hive = new Hive(totalNumberBees, numberInactive, numberActive, numberScout, maxNumberVisits, maxNumberCycles, citiesData);


            bool      doProgressBar = false;
            Stopwatch stopWatch1    = new Stopwatch();

            stopWatch1.Start();


            hive.Solve(doProgressBar);

            Console.WriteLine("\n===================\nBee ALGORITHM:");
            Console.WriteLine(hive);
            stopWatch1.Stop();
            // Get the elapsed time as a TimeSpan value.
            TimeSpan ts1 = stopWatch1.Elapsed;

            // Format and display the TimeSpan value.
            string elapsedTime1 = String.Format("{0:00}:{1:00}:{2:00}.{3:00}",
                                                ts1.Hours, ts1.Minutes, ts1.Seconds,
                                                ts1.Milliseconds / 10);

            Console.WriteLine("RunTime " + elapsedTime1);
            Console.ReadKey();
        } // Main()
Esempio n. 4
0
        public void Clustering()
        {
            Random rand = new Random();
            //bool[] Pool = new bool[citiedata.citiesDistance.GetLength(0)];
            List <int> poolCities = new List <int>();

            for (int i = 0; i < citiesData.citiesDistance.GetLength(0); i++)
            {
                poolCities.Add(i);
            }

            List <Cluster> Clusters = new List <Cluster>();

            do
            {
                double[] centerCluster = new double[2];
                int      city          = poolCities[rand.Next(poolCities.Count)];
                centerCluster[0] = citiesData.coordinates[city, 0];
                centerCluster[1] = citiesData.coordinates[city, 1];
                double[]   newcenterCluster  = new double[2];
                List <int> citiesFromCluster = new List <int>();
                do
                {
                    citiesFromCluster.Clear();
                    newcenterCluster = centerCluster;
                    foreach (int i in poolCities)
                    {
                        if (Program.Distance(centerCluster[0], centerCluster[1], citiesData.coordinates[i, 0], citiesData.coordinates[i, 1]) <= R)
                        {
                            citiesFromCluster.Add(i);
                        }
                    }
                    centerCluster = CenterMass(citiesFromCluster);
                } while (!(newcenterCluster[0] == centerCluster[0] && newcenterCluster[1] == centerCluster[1]));
                foreach (int i in citiesFromCluster)
                {
                    poolCities.Remove(i);
                }
                Clusters.Add(new Cluster()
                {
                    cities = citiesFromCluster.ToArray(), center = newcenterCluster
                });
            } while (poolCities.Count != 0);
            //Clustering
            //Start SearchWay
            int totalNumberBees = 6;
            int numberInactive  = 1;
            int numberActive    = 3;
            int numberScout     = 2;

            int maxNumberVisits = 3;
            int maxNumberCycles = 10;


            double[,] ncitiesCenters = new double[Clusters.Count, 2];
            for (int i = 0; i < Clusters.Count; i++)
            {
                ncitiesCenters[i, 0] = Clusters[i].center[0];
                ncitiesCenters[i, 1] = Clusters[i].center[1];
            }
            CitiesData ncd  = new CitiesData(Program.CoordinatesToDistanceMatrix(ncitiesCenters), ncitiesCenters);
            Hive       hive = new Hive(totalNumberBees, numberInactive, numberActive, numberScout, maxNumberVisits, maxNumberCycles, ncd);


            bool doProgressBar = false;

            hive.Solve(doProgressBar);

            for (int i = 0; i < Clusters.Count - 1; i++)
            {
                ShortPathClusters(Clusters[hive.bestMemoryMatrix[i]], Clusters[hive.bestMemoryMatrix[i + 1]]);
            }
            ShortPathClusters(Clusters[Clusters.Count - 1], Clusters[0]);

            foreach (Cluster c in Clusters)
            {
                ShortPathInsideCluster(c);
            }
            int[] result = ResultPath(Clusters, hive);
            resultPath    = result;
            this.clasters = Clusters;
        }
Esempio n. 5
0
 public ClasterFogel(int R, CitiesData citiedata)
 {
     this.citiesData = citiedata;
     this.R          = R;
 }