Example #1
0
        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);
        }
Example #2
0
        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);
            }
        }