private bool IsTimeWindowsConstraintSatisfied(ToSolution solution) { bool satisfied = true; CityMapGraph solutionGraph = solution.Tour; using (var processingNodes = solutionGraph.TourPoints.GetEnumerator()) { while (satisfied && processingNodes.MoveNext()) { var node = processingNodes.Current; TimeSpan visitTime = default; if (node?.Entity.TimeVisit != null) { visitTime = node.Entity.TimeVisit.Value; } if (node == null) { continue; } DateTime nodeTime = node.ArrivalTime + node.WaitOpeningTime; foreach (var time in node.Entity.OpeningTimes) { if (time.ClosingTime.HasValue && nodeTime > (time.ClosingTime.Value - visitTime)) { satisfied = false; //continue; } } } } return(satisfied); }
internal void Validate(ToSolution solution) { foreach (var constraint in _constraintsToValidate) { bool isValid = constraint.Value.Invoke(solution); solution.ProblemConstraints.Add(constraint.Key, isValid); } }
/// <summary> /// Creates the problem contained in the configuration /// and initializes the working configuration. /// </summary> /// <param name="configuration"></param> private void InitSolver(Configuration configuration) { if (_solutionsQueue is null) { _solutionsQueue = new BlockingCollection <ToSolution>(); } ToSolution.ResetSequenceId(); WorkingConfiguration = configuration; IsMonitoringEnabled = configuration.AlgorithmMonitoring; Problem = ProblemFactory.CreateProblem(configuration.CurrentProblem); }
internal void Evaluate(ToSolution solution) { var objectiveFunc = Solver.Problem.ObjectiveFunc; solution.Cost = objectiveFunc.Invoke(solution); var penaltyFunc = Solver.Problem.PenaltyFunc; // Get the violated constraints to invoke the PenaltyFunc delegate. var violatedConstraints = solution.ProblemConstraints .Where(constraint => constraint.Value == false) .ToList(); violatedConstraints.ForEach( delegate { int penalty = penaltyFunc.Invoke(solution); solution.Cost += penalty; solution.Penalty = penalty < 0 ? -penalty : penalty; }); }
/// <summary> /// Calculates the solution cost passed as parameter using an equation of convex combination. /// </summary> /// <param name="solution"> /// Solution to evaluate. /// </param> /// <returns> /// An Evaluation Object. /// </returns> private int CalculateCost(ToSolution solution) { // Calcolo del termine del gradimento. int scoreTerm = solution.Tour.Nodes.Sum(node => node.Entity.Score.Value); // Il peso che determina l'importanza dei termini dell'equazione. double lambda = Solver.Instance.CurrentObjectiveFunctionWeight; // Calcolo del termine che da peso alla distanza tra il nodo corrente e quello precedente. // In particolare, vengono privilegati i nodi molto vicini con un peso molto alto // che darà quindi un maggior gradimento. double distanceTerm = solution.Tour.Nodes.Sum(node => { RouteWorker edge = solution.Tour.GetEdges(node.Entity.Id).FirstOrDefault(); if (edge is null) { return(0); } double distanceWeight = GetDistanceTermWeight(edge.Weight.Invoke()); return(distanceWeight * node.Entity.Score.Value); }); return((int)Math.Round(lambda * scoreTerm + (1 - lambda) * distanceTerm)); }
internal void EnqueueSolution(ToSolution solution) => _solutionsQueue.Add(solution);
private bool IsTMaxConstraintSatisfied(ToSolution solution) { return(solution.TimeSpent <= _tMax); }
private int CalculatePenalty(ToSolution solution) => PenaltyAmount;