private Solution <double> CreateAntSolution(double[] vector) { Solution <double> solution = new Solution <double>(); if (vector.Length == this._problemSize) { for (int index = 0; index < this._problemSize; index++) { double value = RandomUtility.Gaussian(vector[index], this._stdv[index]); solution.Components.Add(new DecisionComponent <double>(index, value)); } } else { AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; for (int index = 0; index < this._problemSize; index++) { double value = RandomUtility.Random(evaluator.MinimumVariableValue, evaluator.MinimumVariableValue); solution.Components.Add(new DecisionComponent <double>(index, value)); } } return(solution); }
public override void UpdatePheromoneLevels() { AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; double mean = (evaluator.MaximumVariableValue + evaluator.MinimumVariableValue) / 2; double initialStdv = (evaluator.MaximumVariableValue - mean) / 3; double finalStdv = 0.0001;// * (function.MaximumVariableValue - function.MinimumVariableValue) / 2; List <double> iterationBest = this._iterationBestSolution.ToList(); List <double> best = this._iterationBestSolution.ToList(); for (int index = 0; index < this._problemSize; index++) { double value = this._pheromone[this._currentVectorIndex][index]; double factor1 = (this._iterationBestSolution.Quality - this._qualityArray[this._currentVectorIndex]) / this._iterationBestSolution.Quality + this._qualityArray[this._currentVectorIndex]; double factor2 = (this._bestSolution.Quality - this._qualityArray[this._currentVectorIndex]) / this._bestSolution.Quality + this._qualityArray[this._currentVectorIndex]; double step1 = (iterationBest[index] - this._pheromone[this._currentVectorIndex][index]) * factor1; double step2 = (best[index] - this._pheromone[this._currentVectorIndex][index]) * factor2; this._pheromone[this._currentVectorIndex][index] = iterationBest[index];//value + step1 + step2; this._inverse[this._currentVectorIndex][index] = -this._pheromone[this._currentVectorIndex][index]; double ratio = Math.Pow((finalStdv / initialStdv), (1.0 / (this.MaxIterations))); this._stdv[index] *= ratio; } }
public PSOIB(int problemSize, int swarmSize, int maxIterations, int convergenceIterations, AbstractContinousOptimizationEvaluator evaluator) { this._problemSize = problemSize; this._swarmSize = swarmSize; this._maxIterations = maxIterations; this._solutionQualityEvaluator = evaluator; this._convergenceIterations = convergenceIterations; }
public override void CreateSolution() { AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; this._iterationBest = null; for (int i = 0; i < this._colonySize; i++) { int selectIndex = ProbablisticallySelectSolution(); double std = 0; double value = 0; Solution <double> solution = new Solution <double>(); for (int index = 0; index < this._problemSize; index++) { std = 0; for (int solutionIndex = 0; solutionIndex < this._archiveSize; solutionIndex++) { std += (Math.Abs(_solutionArchive[solutionIndex].Components[index].Element - _solutionArchive[selectIndex].Components[index].Element) / (this._archiveSize - 1)); } std *= this._segma; value = RandomUtility.Gaussian(_solutionArchive[selectIndex].Components[index].Element, std); if (value < evaluator.MinimumVariableValue) { value = evaluator.MinimumVariableValue; } else if (value > evaluator.MaximumVariableValue) { value = evaluator.MaximumVariableValue; } solution.Components.Add(new DecisionComponent <double>(index, value)); } EvaluateSolutionQuality(solution); if (this._iterationBest == null || solution.Quality > this._iterationBest.Quality) { this._iterationBest = solution; } } if (this.OnPostAntSolutionContruction != null) { this.OnPostAntSolutionContruction(this, null); } }
public override void Initialize() { AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; double mean = (evaluator.MaximumVariableValue + evaluator.MinimumVariableValue) / 2; double initialStdv = (evaluator.MaximumVariableValue - mean) / 3; for (int index = 0; index < this._problemSize; index++) { this._pheromone[index] = RandomUtility.Random(evaluator.MinimumVariableValue, evaluator.MaximumVariableValue); this._pheromoneInverse[index] = this._pheromone[index] * -1; this._stdv[index] = initialStdv; } }
public override void Initialize() { AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; double sum = 0; double dominator; double expo; for (int solutionIndex = 0; solutionIndex < this._archiveSize; solutionIndex++) { _solutionArchive[solutionIndex] = new Solution <double>(); if (solutionIndex == 0) { for (int index = 0; index < this._problemSize; index++) { _solutionArchive[solutionIndex].Components.Add(new DecisionComponent <double>(index, 1)); } } else { for (int index = 0; index < this._problemSize; index++) { double value = RandomUtility.Random(evaluator.MinimumVariableValue, evaluator.MaximumVariableValue); _solutionArchive[solutionIndex].Components.Add(new DecisionComponent <double>(index, value)); } } dominator = 1 / ((this._q * this._archiveSize) * Math.Sqrt(2 * Math.PI)); expo = Math.Pow(solutionIndex, 2) / (2 * Math.Pow(this._q, 2) * Math.Pow(this._archiveSize, 2)); _weightProbability[solutionIndex] = (dominator) * Math.Exp(-expo); sum += _weightProbability[solutionIndex]; EvaluateSolutionQuality(_solutionArchive[solutionIndex]); } this._solutionArchive = this._solutionArchive.OrderByDescending(x => x.Quality).ToArray(); for (int solutionIndex = 0; solutionIndex < this._archiveSize; solutionIndex++) { _weightProbability[solutionIndex] = _weightProbability[solutionIndex] / sum; } }
public override void EvaluateSolutionQuality(ACO.Solution <double> solution) { if (solution.Components.Count != this._problemSize) { return; } AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; evaluator.EvaluateSolutionQuality(solution); this.EvaluationCounter++; double fitness = evaluator.CurrentFitness; if (this._bestFitness > fitness) { this._bestFitness = fitness; } }
public override void Initialize() { AbstractContinousOptimizationEvaluator evaluator = this._problem.SolutionQualityEvaluator as AbstractContinousOptimizationEvaluator; double mean = (evaluator.MaximumVariableValue + evaluator.MinimumVariableValue) / 2; double initialStdv = (evaluator.MaximumVariableValue - mean) / 3; for (int vectorIndex = 0; vectorIndex < this._colonySize; vectorIndex++) { this._pheromone[vectorIndex] = new double[this._problemSize]; this._inverse[vectorIndex] = new double[this._problemSize]; for (int variableIndex = 0; variableIndex < this._problemSize; variableIndex++) { this._pheromone[vectorIndex][variableIndex] = RandomUtility.Random(evaluator.MinimumVariableValue, evaluator.MaximumVariableValue); this._inverse[vectorIndex][variableIndex] = -this._pheromone[vectorIndex][variableIndex]; this._stdv[variableIndex] = initialStdv; } Solution <double> solution = Solution <double> .FromList(this._pheromone[vectorIndex].ToList()); this.EvaluateSolutionQuality(solution); this._qualityArray[vectorIndex] = solution.Quality; } }