Example #1
0
        public static void GetSegments(PotvinTwoOptStarMove move, out List <int> segmentX1, out List <int> segmentX2)
        {
            PotvinEncoding solution = move.Individual as PotvinEncoding;

            Tour route1 = solution.Tours[move.Tour1];
            Tour route2 = solution.Tours[move.Tour2];

            int x1 = move.X1;
            int x2 = move.X2;

            int count = route1.Stops.Count - x1;

            segmentX1 = new List <int>();
            if (count > 0)
            {
                segmentX1 = route1.Stops.GetRange(x1, count);
            }

            count     = route2.Stops.Count - x2;
            segmentX2 = new List <int>();
            if (count > 0)
            {
                segmentX2 = route2.Stops.GetRange(x2, count);
            }
        }
    protected PotvinTwoOptStarMove(PotvinTwoOptStarMove original, Cloner cloner)
      : base(original, cloner) {
      this.Tour1 = original.Tour1;
      this.X1 = original.X1;
      this.Tour2 = original.Tour2;
      this.X2 = original.X2;

      this.Individual = cloner.Clone(Individual) as PotvinEncoding;
    }
Example #3
0
        protected override void PerformMove()
        {
            PotvinTwoOptStarMove move = TwoOptStarMoveParameter.ActualValue;

            PotvinEncoding newSolution = move.Individual.Clone() as PotvinEncoding;

            Apply(newSolution, move, ProblemInstance);
            newSolution.Repair();
            VRPToursParameter.ActualValue = newSolution;
        }
Example #4
0
        protected PotvinTwoOptStarMove(PotvinTwoOptStarMove original, Cloner cloner)
            : base(original, cloner)
        {
            this.Tour1 = original.Tour1;
            this.X1    = original.X1;
            this.Tour2 = original.Tour2;
            this.X2    = original.X2;

            this.Individual = cloner.Clone(Individual) as PotvinEncoding;
        }
Example #5
0
        protected override void EvaluateMove()
        {
            PotvinTwoOptStarMove move = TwoOptStarMoveParameter.ActualValue;

            PotvinEncoding newSolution = TwoOptStarMoveParameter.ActualValue.Individual.Clone() as PotvinEncoding;

            PotvinTwoOptStarMoveMaker.Apply(newSolution, move, ProblemInstance);

            UpdateEvaluation(newSolution);
        }
Example #6
0
        protected override PotvinTwoOptStarMove[] GenerateMoves(PotvinEncoding individual, IVRPProblemInstance problemInstance)
        {
            List <PotvinTwoOptStarMove> result = new List <PotvinTwoOptStarMove>();

            PotvinTwoOptStarMove move = Apply(individual, ProblemInstance, RandomParameter.ActualValue);

            if (move != null)
            {
                result.Add(move);
            }

            return(result.ToArray());
        }
    public static void Apply(PotvinEncoding solution, PotvinTwoOptStarMove move, IVRPProblemInstance problemInstance) {
      List<int> segmentX1;
      List<int> segmentX2;
      GetSegments(move, out segmentX1, out segmentX2);

      Tour route1 = solution.Tours[move.Tour1];
      Tour route2 = solution.Tours[move.Tour2];

      foreach (int stop in segmentX1)
        route1.Stops.Remove(stop);
      route1.Stops.AddRange(segmentX2);

      foreach (int stop in segmentX2)
        route2.Stops.Remove(stop);
      route2.Stops.AddRange(segmentX1);
    }
    public static void GetSegments(PotvinTwoOptStarMove move, out List<int> segmentX1, out List<int> segmentX2) {
      PotvinEncoding solution = move.Individual as PotvinEncoding;

      Tour route1 = solution.Tours[move.Tour1];
      Tour route2 = solution.Tours[move.Tour2];

      int x1 = move.X1;
      int x2 = move.X2;

      int count = route1.Stops.Count - x1;
      segmentX1 = new List<int>();
      if (count > 0) {
        segmentX1 = route1.Stops.GetRange(x1, count);
      }

      count = route2.Stops.Count - x2;
      segmentX2 = new List<int>();
      if (count > 0) {
        segmentX2 = route2.Stops.GetRange(x2, count);
      }
    }
Example #9
0
        public static void Apply(PotvinEncoding solution, PotvinTwoOptStarMove move, IVRPProblemInstance problemInstance)
        {
            List <int> segmentX1;
            List <int> segmentX2;

            GetSegments(move, out segmentX1, out segmentX2);

            Tour route1 = solution.Tours[move.Tour1];
            Tour route2 = solution.Tours[move.Tour2];

            foreach (int stop in segmentX1)
            {
                route1.Stops.Remove(stop);
            }
            route1.Stops.AddRange(segmentX2);

            foreach (int stop in segmentX2)
            {
                route2.Stops.Remove(stop);
            }
            route2.Stops.AddRange(segmentX1);
        }
Example #10
0
        public override IOperation Apply()
        {
            ItemList <IItem>     tabuList      = TabuListParameter.ActualValue;
            double               moveQuality   = MoveQualityParameter.ActualValue.Value;
            bool                 useAspiration = UseAspirationCriterion.Value;
            bool                 isTabu        = false;
            PotvinTwoOptStarMove move          = TwoOptStarMoveParameter.ActualValue;

            List <int> segmentX1;
            List <int> segmentX2;

            PotvinTwoOptStarMoveMaker.GetSegments(move, out segmentX1, out segmentX2);

            foreach (IItem tabuMove in tabuList)
            {
                PotvinTwoOptStarMoveAttribute attribute = tabuMove as PotvinTwoOptStarMoveAttribute;

                if (attribute != null)
                {
                    double distance = 0;
                    if (MoveDistanceParameter.ActualValue != null)
                    {
                        distance = MoveDistanceParameter.ActualValue.Value;
                    }

                    double overload = 0;
                    if (MoveOverloadParameter.ActualValue != null)
                    {
                        overload = MoveOverloadParameter.ActualValue.Value;
                    }

                    double tardiness = 0;
                    if (MoveTardinessParameter.ActualValue != null)
                    {
                        tardiness = MoveTardinessParameter.ActualValue.Value;
                    }

                    IVRPProblemInstance instance = ProblemInstanceParameter.ActualValue;
                    double quality = attribute.Distance * instance.DistanceFactor.Value;

                    IHomogenousCapacitatedProblemInstance cvrp = instance as IHomogenousCapacitatedProblemInstance;
                    if (cvrp != null)
                    {
                        quality += attribute.Overload * cvrp.OverloadPenalty.Value;
                    }

                    ITimeWindowedProblemInstance vrptw = instance as ITimeWindowedProblemInstance;
                    if (vrptw != null)
                    {
                        quality += attribute.Tardiness * vrptw.TardinessPenalty.Value;
                    }

                    if (!useAspiration || moveQuality >= quality)
                    {
                        if (attribute.Tour == move.Tour1 && segmentX2.Contains(attribute.City) ||
                            attribute.Tour == move.Tour2 && segmentX1.Contains(attribute.City))
                        {
                            isTabu = true;
                            break;
                        }

                        if (attribute.Distance == distance && attribute.Overload == overload && attribute.Tardiness == tardiness)
                        {
                            isTabu = true;
                            break;
                        }
                    }
                }
            }

            MoveTabuParameter.ActualValue = new BoolValue(isTabu);
            return(base.Apply());
        }
        public override IOperation Apply()
        {
            ItemList <IItem> tabuList = TabuListParameter.ActualValue;
            int tabuTenure            = TabuTenureParameter.ActualValue.Value;

            int overlength = tabuList.Count - tabuTenure;

            if (overlength >= 0)
            {
                for (int i = 0; i < tabuTenure - 1; i++)
                {
                    tabuList[i] = tabuList[i + overlength + 1];
                }
                while (tabuList.Count >= tabuTenure)
                {
                    tabuList.RemoveAt(tabuList.Count - 1);
                }
            }

            double distance = 0;

            if (DistanceParameter.ActualValue != null)
            {
                distance = DistanceParameter.ActualValue.Value;
            }

            double overload = 0;

            if (OverloadParameter.ActualValue != null)
            {
                overload = OverloadParameter.ActualValue.Value;
            }

            double tardiness = 0;

            if (TardinessParameter.ActualValue != null)
            {
                tardiness = TardinessParameter.ActualValue.Value;
            }

            PotvinTwoOptStarMove move = TwoOptStarMoveParameter.ActualValue;
            double moveQuality        = MoveQualityParameter.ActualValue.Value;
            double quality            = QualityParameter.ActualValue.Value;
            double baseQuality        = moveQuality;

            if (quality < moveQuality)
            {
                baseQuality = quality;                  // we make an uphill move, the lower bound is the solution quality
            }
            List <int> segmentX1;
            List <int> segmentX2;

            PotvinTwoOptStarMoveMaker.GetSegments(move, out segmentX1, out segmentX2);

            foreach (int city in segmentX1)
            {
                tabuList.Add(new PotvinTwoOptStarMoveAttribute(baseQuality, move.Tour1, city, distance, overload, tardiness));
            }

            foreach (int city in segmentX2)
            {
                tabuList.Add(new PotvinTwoOptStarMoveAttribute(baseQuality, move.Tour2, city, distance, overload, tardiness));
            }

            return(base.Apply());
        }