Exemplo n.º 1
0
        public void PredictionStrength_StaticData()
        {
            List <Point> data = new List <Point>();

            // 0-7
            data.Add(new Point(5, 8));  // 0
            data.Add(new Point(7, 6));  // 1
            data.Add(new Point(4, 6));  // 2
            data.Add(new Point(3, 5));  // 3
            data.Add(new Point(5, 7));  // 0
            data.Add(new Point(7, 5));  // 1
            data.Add(new Point(3, 7));  // 2
            data.Add(new Point(8, 5));  // 3

            // 8-17
            data.Add(new Point(-6, 4)); // 4
            data.Add(new Point(-4, 3)); // 5
            data.Add(new Point(-5, 4)); // 6
            data.Add(new Point(-4, 5)); // 7
            data.Add(new Point(-3, 7)); // 8
            data.Add(new Point(-6, 4)); // 4
            data.Add(new Point(-4, 7)); // 5
            data.Add(new Point(-2, 5)); // 6
            data.Add(new Point(-3, 5)); // 7
            data.Add(new Point(-4, 6)); // 8

            // 17 -
            data.Add(new Point(5, -8)); // 9
            data.Add(new Point(7, -6)); // 10
            data.Add(new Point(4, -6)); // 11
            data.Add(new Point(3, -5)); // 12
            data.Add(new Point(3, -8)); // 9
            data.Add(new Point(5, -4)); // 10
            data.Add(new Point(4, -5)); // 11
            data.Add(new Point(6, -5)); // 12

            /*
             * for (int i = 0; i < 100; i++)
             * {
             *  List<double> coords = new List<double>();
             *  coords.Add(70);
             *  coords.Add(0);
             *  data.Add(new Point(coords));
             * }
             * for (int i = 0; i < 100; i++)
             * {
             *  List<double> coords = new List<double>();
             *  coords.Add(-30);
             *  coords.Add(0);
             *  data.Add(new Point(coords));
             * }*/

            PredictionStrength ps = new PredictionStrength(data);

            ps.Compute();
        }
Exemplo n.º 2
0
        public void PredictionStrength_KCloundGenerated_BestK()
        {
            List <Point> data = new List <Point>();

            const int CLOUD_SIZE  = 500;
            const int CLOUD_COUNT = 2;
            const int DIM_SIZE    = 3;

            const double BASE_STD_DEV  = 7.5;
            const double CLOUD_STD_DEV = 0.5;

            double value = 0;

            RNG.SetSeedFromSystemTime();

            // for each point generate a cloud
            for (int i = 0; i < CLOUD_COUNT; i++)
            {
                Random rnd = new Random();
                // Get base Point
                List <double> coords = new List <double>();
                for (int l = 0; l < DIM_SIZE; l++)
                {
                    value = rnd.Next(0, 100);
                    coords.Add(value);
                }
                Point point = new Point(coords);

                // Add CLOUD_SIZE points
                for (int j = 0; j < CLOUD_SIZE; j++)
                {
                    Point newPoint = point.Copy();

                    // Add some random value to each dimension.
                    for (int l = 0; l < newPoint.DimSize(); l++)
                    {
                        value = RNG.GetNormal(0, CLOUD_STD_DEV);
                        newPoint.SetDimValue(l, value + point.GetDimValue(l));
                    }

                    // Add this point to data set.
                    data.Add(newPoint);
                }
            }

            PredictionStrength ps = new PredictionStrength(data);

            ps.Compute();
        }
Exemplo n.º 3
0
        public static void FullSolveTest(VRPParser benchmark)
        {
            /******************* DIVIDE *************************/


            // Combine coords (x, y) and time_avail (z)
            List <Point> data = new List <Point>();

            for (int i = 0; i < benchmark.Num_Visits; i++)
            {
                List <double> point_coords = new List <double>();

                // does not include depots - which is what we want
                int loc_index = benchmark.Visit_Location[i];

                point_coords.Add(benchmark.Location_Coord[loc_index][0]);
                point_coords.Add(benchmark.Location_Coord[loc_index][1]);
                point_coords.Add(benchmark.Time_Avail[loc_index - 1] + benchmark.Duration[loc_index - 1]);

                data.Add(new Point(point_coords));
            }

            // get optimal number of clusters
            PredictionStrength ps = new PredictionStrength(data);

            ps.Compute(true);
            int k = ps.BestK;

            // compute clusters
            KMeans clusters = new KMeans(data, k);

            clusters.Compute();

            // create k benchmarks for k solvers
            VRPParser[] partial_benchmarks = new VRPParser[k];
            for (int i = 0; i < k; i++)
            {
                VRPParser  partial_benchmark = new VRPParser();
                List <int> cluster_indecies  = clusters.GetCluterIndecies(i);

                /************ COMMON ****************/
                int num_depots    = benchmark.Num_Depots;
                int num_visits    = cluster_indecies.Count;
                int num_locations = cluster_indecies.Count + num_depots;

                partial_benchmark.Num_Visits     = num_visits;
                partial_benchmark.Num_Depots     = num_depots;
                partial_benchmark.Name           = benchmark.Name;
                partial_benchmark.Num_Capacities = benchmark.Num_Capacities;
                partial_benchmark.Num_Vehicles   = 1;
                partial_benchmark.Capacites      = benchmark.Capacites;

                partial_benchmark.Depots_IDs = new int[benchmark.Depots_IDs.Length];
                benchmark.Depots_IDs.CopyTo(partial_benchmark.Depots_IDs, 0);

                partial_benchmark.Depot_Location = new int[benchmark.Depot_Location.Length];
                benchmark.Depot_Location.CopyTo(partial_benchmark.Depot_Location, 0);

                partial_benchmark.Depot_Time_Window = new int[benchmark.Depot_Time_Window.Length][];
                for (int p = 0; p < partial_benchmark.Depot_Time_Window.Length; p++)
                {
                    partial_benchmark.Depot_Time_Window[p] = new int[benchmark.Depot_Time_Window[p].Length];
                    benchmark.Depot_Time_Window[p].CopyTo(partial_benchmark.Depot_Time_Window[p], 0);
                }

                /************ LOCATION_COORD ****************/
                partial_benchmark.Num_Locations = num_locations;

                int[][] location_coord = new int[num_locations][];
                // get all depots locations
                for (int j = 0; j < num_depots; j++)
                {
                    location_coord[j]    = new int[2];
                    location_coord[j][0] = benchmark.Location_Coord[j][0];
                    location_coord[j][1] = benchmark.Location_Coord[j][1];
                }

                // get all partial clients locations
                for (int j = num_depots; j < num_locations; j++)
                {
                    location_coord[j] = new int[2];
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j - num_depots]];

                    location_coord[j][0] = benchmark.Location_Coord[clientNodeIndex][0];
                    location_coord[j][1] = benchmark.Location_Coord[clientNodeIndex][1];
                }
                partial_benchmark.Location_Coord = location_coord;

                /************ DEMAND ****************/
                int[] demands = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]];
                    demands[j] = benchmark.Demands[clientNodeIndex - num_depots];
                }
                partial_benchmark.Demands = demands;

                /************ VISIT_LOCATION ****************/
                int[] visit_location = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]] - num_depots;

                    visit_location[j] = clientNodeIndex;
                    //visit_location[j] = j + num_depots;
                }
                partial_benchmark.Visit_Location = visit_location;

                /************ DURATION ****************/
                int[] duration = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]];
                    duration[j] = benchmark.Duration[clientNodeIndex - num_depots];
                }
                partial_benchmark.Duration = duration;

                /************ TIME_AVAIL ****************/
                int[] time_avail = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]];
                    time_avail[j] = benchmark.Time_Avail[clientNodeIndex - num_depots];
                }
                partial_benchmark.Time_Avail = time_avail;

                partial_benchmarks[i] = partial_benchmark;
            }

            /******************* SOLVE *************************/
            float         CUT_OFF_COEFFICIENT = 0.2f;
            List <Result> results             = new List <Result>();
            List <int>    nextDay             = new List <int>();
            float         cutOffTime          = CUT_OFF_COEFFICIENT * benchmark.Depot_Time_Window[0][1];

            for (int i = 0; i < partial_benchmarks.Length; i++)
            {
                results.Add(TSPTrianIneq.calculate(partial_benchmarks[i], cutOffTime));
            }
            /******************* MERGE *************************/

            for (int j = 0; j < results.Count; j++)
            {
                for (int i = partial_benchmarks[j].Num_Depots; i < results[j].route.Length - partial_benchmarks[j].Num_Depots; i++)
                {
                    results[j].route[i] = partial_benchmarks[j].Visit_Location[results[j].route[i] - partial_benchmarks[j].Num_Depots] + partial_benchmarks[j].Num_Depots;
                }
            }

            for (int j = 0; j < results.Count; j++)
            {
                for (int i = 0; i < results[j].nextDay.Count; i++)
                {
                    results[j].nextDay[i] = partial_benchmarks[j].Visit_Location[results[j].nextDay[i] - partial_benchmarks[j].Num_Depots] + partial_benchmarks[j].Num_Depots;
                }
            }


            Console.Write("asd");
        }
Exemplo n.º 4
0
        public byte[][] DivideProblem_Working(int threadCount)
        {
            /****************** DESERIALIZE ************************/

            BinaryFormatter formatter = new BinaryFormatter();
            VRPParser       benchmark = (VRPParser)formatter.Deserialize(new MemoryStream(_problemData));

            /******************* DIVIDE *************************/


            // Combine coords (x, y) and time_avail (z)
            List <Point> data = new List <Point>();

            for (int i = 0; i < benchmark.Num_Visits; i++)
            {
                List <double> point_coords = new List <double>();

                // does not include depots - which is what we want
                int loc_index = benchmark.Visit_Location[i];

                point_coords.Add(benchmark.Location_Coord[loc_index][0]);
                point_coords.Add(benchmark.Location_Coord[loc_index][1]);
                point_coords.Add(benchmark.Time_Avail[loc_index - 1] + benchmark.Duration[loc_index - 1]);

                data.Add(new Point(point_coords));
            }

            // get optimal number of clusters
            PredictionStrength ps = new PredictionStrength(data);

            ps.Compute(true);
            int k = ps.BestK;

            // compute clusters
            KMeans clusters = new KMeans(data, k);

            clusters.Compute();

            // create k benchmarks for k solvers
            VRPParser[] partial_benchmarks = new VRPParser[k];
            for (int i = 0; i < k; i++)
            {
                VRPParser  partial_benchmark = new VRPParser();
                List <int> cluster_indecies  = clusters.GetCluterIndecies(i);

                /************ COMMON ****************/
                int num_depots    = benchmark.Num_Depots;
                int num_visits    = cluster_indecies.Count;
                int num_locations = cluster_indecies.Count + num_depots;

                partial_benchmark.Num_Visits     = num_visits;
                partial_benchmark.Num_Depots     = num_depots;
                partial_benchmark.Name           = benchmark.Name;
                partial_benchmark.Num_Capacities = benchmark.Num_Capacities;
                partial_benchmark.Num_Vehicles   = 1;
                partial_benchmark.Capacites      = benchmark.Capacites;

                partial_benchmark.Depots_IDs = new int[benchmark.Depots_IDs.Length];
                benchmark.Depots_IDs.CopyTo(partial_benchmark.Depots_IDs, 0);

                partial_benchmark.Depot_Location = new int[benchmark.Depot_Location.Length];
                benchmark.Depot_Location.CopyTo(partial_benchmark.Depot_Location, 0);

                partial_benchmark.Depot_Time_Window = new int[benchmark.Depot_Time_Window.Length][];
                for (int p = 0; p < partial_benchmark.Depot_Time_Window.Length; p++)
                {
                    partial_benchmark.Depot_Time_Window[p] = new int[benchmark.Depot_Time_Window[p].Length];
                    benchmark.Depot_Time_Window[p].CopyTo(partial_benchmark.Depot_Time_Window[p], 0);
                }

                /************ LOCATION_COORD ****************/
                partial_benchmark.Num_Locations = num_locations;

                int[][] location_coord = new int[num_locations][];
                // get all depots locations
                for (int j = 0; j < num_depots; j++)
                {
                    location_coord[j]    = new int[2];
                    location_coord[j][0] = benchmark.Location_Coord[j][0];
                    location_coord[j][1] = benchmark.Location_Coord[j][1];
                }

                // get all partial clients locations
                for (int j = num_depots; j < num_locations; j++)
                {
                    location_coord[j] = new int[2];
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j - num_depots]];

                    location_coord[j][0] = benchmark.Location_Coord[clientNodeIndex][0];
                    location_coord[j][1] = benchmark.Location_Coord[clientNodeIndex][1];
                }
                partial_benchmark.Location_Coord = location_coord;

                /************ DEMAND ****************/
                int[] demands = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]];
                    demands[j] = benchmark.Demands[clientNodeIndex - num_depots];
                }
                partial_benchmark.Demands = demands;

                /************ VISIT_LOCATION ****************/
                int[] visit_location = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]] - num_depots;

                    visit_location[j] = clientNodeIndex;
                    //visit_location[j] = j + num_depots;
                }
                partial_benchmark.Visit_Location = visit_location;

                /************ DURATION ****************/
                int[] duration = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]];
                    duration[j] = benchmark.Duration[clientNodeIndex - num_depots];
                }
                partial_benchmark.Duration = duration;

                /************ TIME_AVAIL ****************/
                int[] time_avail = new int[num_visits];
                for (int j = 0; j < num_visits; j++)
                {
                    int clientNodeIndex = benchmark.Visit_Location[cluster_indecies[j]];
                    time_avail[j] = benchmark.Time_Avail[clientNodeIndex - num_depots];
                }
                partial_benchmark.Time_Avail = time_avail;

                partial_benchmarks[i] = partial_benchmark;
            }

            /************ SERIALIZATION ******************/
            byte[][] temporarySolution = new byte[partial_benchmarks.Count()][];
            for (int i = 0; i < partial_benchmarks.Count(); i++)
            {
                temporarySolution[i] = DataSerialization.ObjectToByteArray(partial_benchmarks[i]);
            }


            return(temporarySolution);
        }