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;
}
}
