public static double Solve(int population_size, int dimension_count, CostEvaluationMethod evaluator, CreateParticleMethod generator, out Particle global_best_solution, double[] lower_bounds = null, double[] upper_bounds = null, object constraints = null, double tolerance = 0.000001, int maxIterations = 100000)
{
ParticleSwarm <Particle> solver = new ParticleSwarm <Particle>(population_size, dimension_count, evaluator, generator);
solver.LowerBounds = lower_bounds;
solver.UpperBounds = upper_bounds;
solver.Initialize(constraints);
int iteration = 0;
double cost_reduction = tolerance;
double global_best_solution_cost = solver.GlobalBestSolutionCost;
double prev_global_best_solution_cost = global_best_solution_cost;
while (cost_reduction >= tolerance && iteration < maxIterations)
{
prev_global_best_solution_cost = global_best_solution_cost;
solver.Iterate();
global_best_solution_cost = solver.GlobalBestSolutionCost;
cost_reduction = prev_global_best_solution_cost - global_best_solution_cost;
iteration++;
}
global_best_solution = solver.GlobalBestSolution.Clone() as Particle;
return(global_best_solution_cost);
}
public override ContinuousSolution Minimize(CostEvaluationMethod evaluate, GradientEvaluationMethod calc_grad, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
if (mLocalSearch == null)
{
throw new ArgumentNullException();
}
mLocalSearch.LowerBounds = mLowerBounds;
mLocalSearch.UpperBounds = mUpperBounds;
int problem_size = mDimension;
ContinuousSolution best_solution = new ContinuousSolution();
while (!should_terminate(improvement, iteration))
{
double[] x = GreedyConstructRandomSolution(evaluate, constraints, problem_size);
ContinuousSolution x_pi_refined = mLocalSearch.Minimize(x, evaluate, calc_grad, mLocalSearchShouldTerminate, constraints);
if (best_solution.TryUpdateSolution(x_pi_refined.Values, x_pi_refined.Cost, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public static double SolveByAntSystem(int population_size, int state_count, CostEvaluationMethod evaluator,
HeuristicValueEvaluationMethod heuristicEvaluator, int displayEvery, out Ant global_best_solution, CreateAntMethod generator = null, int maxIterations = 100000)
{
AntSystem <Ant> solver = new AntSystem <Ant>(population_size, state_count, evaluator, generator);
solver.HeuristicValueEvaluator = heuristicEvaluator;
solver.Initialize();
int iteration = 0;
double global_best_solution_cost = solver.GlobalBestSolutionCost;
double prev_global_best_solution_cost = global_best_solution_cost;
while (iteration < maxIterations)
{
prev_global_best_solution_cost = global_best_solution_cost;
solver.Iterate();
global_best_solution_cost = solver.GlobalBestSolutionCost;
iteration++;
if (iteration % displayEvery == 0)
{
Console.WriteLine("Iteration: {0} Cost: {1}", iteration, global_best_solution_cost);
}
}
global_best_solution = solver.GlobalBestSolution.Clone() as Ant;
return(global_best_solution_cost);
}
public static double Solve(int population_size, int dimension_count, CostEvaluationMethod evaluator, CreateBeeMethod generator, out Bee global_best_solution, double[] lower_bounds = null, double[] upper_bounds = null, object constraints = null, double tolerance = 0.000001, int maxIterations = 100000)
{
BeeSwarm <Bee> solver = new BeeSwarm <Bee>(60, 15, 30, 20, 10, evaluator, generator);
solver.LowerBounds = lower_bounds;
solver.UpperBounds = upper_bounds;
solver.Constraints = constraints;
solver.LocalSearchRegion = new double[dimension_count];
for (int i = 0; i < dimension_count; ++i)
{
solver.LocalSearchRegion[i] = (upper_bounds[i] - lower_bounds[i]) / 1000;
}
solver.Initialize();
int iteration = 0;
double cost_reduction = tolerance;
double global_best_solution_cost = solver.GlobalBestSolutionCost;
double prev_global_best_solution_cost = global_best_solution_cost;
while (cost_reduction >= tolerance && iteration < maxIterations)
{
prev_global_best_solution_cost = global_best_solution_cost;
solver.Iterate();
global_best_solution_cost = solver.GlobalBestSolutionCost;
cost_reduction = prev_global_best_solution_cost - global_best_solution_cost;
iteration++;
}
global_best_solution = solver.GlobalBestSolution.Clone() as Bee;
return(global_best_solution_cost);
}
public static double Solve(int population_size, int dimension_count, CostEvaluationMethod evaluator, double[] lower_bounds, double[] upper_bounds, out Particle global_best_solution, int maxIterations = 100000, int displayEvery = 100)
{
ParticleSwarm <Particle> solver = new ParticleSwarm <Particle>(population_size, dimension_count, evaluator, lower_bounds, upper_bounds);
solver.Initialize();
int iteration = 0;
double global_best_solution_cost = solver.GlobalBestSolutionCost;
double prev_global_best_soution_cost = global_best_solution_cost;
while (iteration < maxIterations)
{
prev_global_best_soution_cost = global_best_solution_cost;
solver.Iterate();
global_best_solution_cost = solver.GlobalBestSolutionCost;
//cost_reduction = prev_global_best_soution_cost - global_best_solution_cost;
if (iteration % displayEvery == 0)
{
Console.WriteLine("Generation: {0}, Best Cost: {1}", iteration, global_best_solution_cost);
}
iteration++;
}
global_best_solution = solver.GlobalBestSolution.Clone() as Particle;
return(global_best_solution_cost);
}
public ParticleSwarm(int population_size, int dimension_count, CostEvaluationMethod evaluator, double[] lower_bounds, double[] upper_bounds)
{
mDimensionCount = dimension_count;
mLowerBounds = lower_bounds;
mUpperBounds = upper_bounds;
mParticleGenerator = (constraints) =>
{
SimpleParticle p = new SimpleParticle(this, mDimensionCount, constraints);
double lower_bound;
double upper_bound;
double range;
for (int d = 0; d < mDimensionCount; ++d)
{
lower_bound = lower_bounds[d];
upper_bound = upper_bounds[d];
range = upper_bound - lower_bound;
p[d, ParticleVectorType.Position] = lower_bound + range * RandomEngine.NextDouble();
p[d, ParticleVectorType.Velocity] = 0;
}
Particle cast_p = p as Particle;
return(cast_p);
};
mParticles = new Particle[population_size];
mLocalBestParticles = new Particle[population_size];
mEvaluator = evaluator;
}
public ParticleSwarm(int population_size, int dimension_count, CostEvaluationMethod evaluator, CreateParticleMethod generater = null)
{
mDimensionCount = dimension_count;
mParticleGenerator = generater;
mEvaluator = evaluator;
mParticles = new Particle[population_size];
mLocalBestParticles = new Particle[population_size];
mEvaluator = evaluator;
}
protected ContinuousSolution DoLocalSearch(double[] x, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, object constraints)
{
if (mLocalSearch != null)
{
return(mLocalSearch.Minimize(x, evaluate, calc_gradient, mLocalSearchTerminationCondition, constraints));
}
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
return(new ContinuousSolution(x, fx));
}
public BeeSwarm(int _n, int _n1, int _n2, int _m, int _e, CostEvaluationMethod evaluator, CreateBeeMethod generator)
{
mScoutBeeCount = _n;
mBeeCount_BestPatches = _n1;
mBeeCount_ElitePatches = _n2;
mBestPatchCount = _m;
mElitePatchCount = _e;
mBeeGenerator = generator;
mEvaluator = evaluator;
}
//calculate gradient
public static void CalcGradient(double[] solution, double[] gradf, CostEvaluationMethod evaluate)
{
double xi, delta;
double udelta = 0.0;
int dimension_count = solution.Length;
double rteps = Math.Sqrt(small());
for (int i = 0; i < dimension_count; i++)
{
xi = solution[i];
double tmp = 1.0e0;
if (1.0e0 > Math.Abs(xi))
{
tmp = 1.0e0;
}
else
{
tmp = Math.Abs(xi);
}
if (udelta > rteps * tmp)
{
delta = udelta;
}
else
{
delta = rteps * tmp;
}
if (xi < 0.0)
{
delta = -delta;
}
solution[i] = xi + delta;
double f2 = evaluate(solution);
solution[i] = xi;
double f1 = evaluate(solution);
if (double.IsInfinity(f1) && double.IsInfinity(f2))
{
gradf[i] = 0;
}
else
{
gradf[i] = (f2 - f1) / delta;
}
}
return;
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_grad, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
double fx_0 = evaluate(x_0, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution best_solution = new ContinuousSolution(x_0, fx_0);
int dimension = x_0.Length;
while (!should_terminate(improvement, iteration))
{
double[] best_x_in_neighborhood = null;
double best_x_in_neighborhood_fx = double.MaxValue;
int move_id = -1;
for (int i = 0; i < dimension; ++i)
{
if (!IsMoveTabu(i))
{
double[] x_pi = GetNeighbor(best_solution.Values, i, constraints);
double fx_pi = evaluate(x_pi, mLowerBounds, mUpperBounds, constraints);
if (fx_pi < best_x_in_neighborhood_fx)
{
best_x_in_neighborhood = x_pi;
best_x_in_neighborhood_fx = fx_pi;
move_id = i;
}
}
}
if (best_x_in_neighborhood != null)
{
if (best_solution.TryUpdateSolution(best_x_in_neighborhood, best_x_in_neighborhood_fx, out improvement))
{
TabuMove(move_id);
OnSolutionUpdated(best_solution, iteration);
}
}
LowerTabuList();
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_grad, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
if (mNeighborhoods.Count == 0)
{
throw new ArgumentNullException();
}
mNeighborhoods.LowerBounds = mLowerBounds;
mNeighborhoods.UpperBounds = mUpperBounds;
double[] x = (double[])x_0.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution best_solution = new ContinuousSolution(x, fx);
int neighborhood_count = mNeighborhoods.Count;
ContinuousSolution current_best = null;
while (!should_terminate(improvement, iteration))
{
for (int l = 0; l < neighborhood_count; ++l)
{
SingleTrajectoryContinuousSolver local_search = mNeighborhoods.GetLocalSearchAt(l);
SingleTrajectoryContinuousSolver.TerminationEvaluationMethod termination_condition = mNeighborhoods.GetTerminationConditionAt(l);
current_best = local_search.Minimize(x, evaluate, calc_grad, termination_condition, constraints);
x = current_best.Values;
fx = current_best.Cost;
if (best_solution.TryUpdateSolution(x, fx, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(best_solution, iteration);
iteration++;
}
}
return(best_solution);
}
public BeeSwarm(int _n, int _n1, int _n2, int _m, int _e, CostEvaluationMethod evaluator)
{
mScoutBeeCount = _n;
mBeeCount_BestPatches = _n1;
mBeeCount_ElitePatches = _n2;
mBestPatchCount = _m;
mElitePatchCount = _e;
mBeeGenerator = () =>
{
SimpleBee p = new SimpleBee(this, mLowerBounds.Length, mLowerBounds, mUpperBounds);
p.Initialize(Constraints);
return(p as Bee);
};
mEvaluator = evaluator;
}
public AntSystem(int population_size, int state_count, CostEvaluationMethod evaluator, CreateAntMethod generator = null)
{
mEvaluator = evaluator;
mStateCount = state_count;
if (generator == null)
{
mAntGenerator = (info) =>
{
SimpleAnt p = new SimpleAnt(this, info);
Ant cast_p = p as Ant;
return(cast_p);
};
}
mAnts = new Ant[population_size];
mPheromones = new double[mStateCount, mStateCount];
mTau0 = 1.0 / state_count;
}
protected bool ExploreSubsets(ref ContinuousSolution[] ref_set, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_grad, object constraints)
{
bool is_improved = false;
List <ContinuousSolution[]> subsets = SelectSubsets(ref_set);
for (int i = 0; i < ref_set.Length; ++i)
{
ref_set[i].SetIsNew(false);
}
for (int i = 0; i < subsets.Count; ++i)
{
ContinuousSolution[] subset = subsets[i];
ContinuousSolution[] candidate_solutions = Recombine(subset, constraints);
ContinuousSolution[] improvements = new ContinuousSolution[candidate_solutions.Length];
for (int j = 0; j < improvements.Length; ++j)
{
//double fx = evaluate(candidate_solutions[j].Values, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution s = mLocalSearch.Minimize(candidate_solutions[j].Values, evaluate, calc_grad, mLocalSearchTerminationCondition, constraints);
//double improvement = fx - s.Cost;
improvements[j] = s;
}
for (int j = 0; j < improvements.Length; ++j)
{
if (ref_set.ContainsItem(improvements[j]))
{
improvements[j].SetIsNew(false);
}
else
{
improvements[j].SetIsNew(true);
ref_set = ref_set.OrderBy(s => s.Cost).ToArray();
if (ref_set[mReferenceSetSize - 1].Cost > improvements[j].Cost)
{
ref_set[mReferenceSetSize - 1] = improvements[j];
is_improved = true;
}
}
}
}
return(is_improved);
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
double fx_0 = evaluate(x_0, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution best_solution = new ContinuousSolution(x_0, fx_0);
if (mSearchSpaceSize == -1)
{
mSearchSpaceSize = x_0.Length;
}
while (!should_terminate(improvement, iteration))
{
double[] best_x_in_neighborhood = null;
double best_x_in_neighborhood_fx = double.MaxValue;
for (int i = 0; i < mSearchSpaceSize; ++i)
{
double[] x_pi = CreateRandomSolution(mSolutionGenerator, i, constraints);
double fx_pi = evaluate(x_pi, mLowerBounds, mUpperBounds, constraints);
if (fx_pi < best_x_in_neighborhood_fx)
{
best_x_in_neighborhood = x_pi;
best_x_in_neighborhood_fx = fx_pi;
}
}
if (best_x_in_neighborhood != null)
{
if (best_solution.TryUpdateSolution(best_x_in_neighborhood, best_x_in_neighborhood_fx, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
}
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
if (mLocalSearch == null)
{
throw new ArgumentNullException();
}
mLocalSearch.LowerBounds = mLowerBounds;
mLocalSearch.UpperBounds = mUpperBounds;
double[] x = (double[])x_0.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution best_solution = new ContinuousSolution(x, fx);
while (!should_terminate(improvement, iteration))
{
int r_index = (int)(RandomEngine.NextDouble() * x.Length);
double[] x_pi = GetNeighbor(x, r_index, constraints);
double fx_pi = evaluate(x_pi, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution x_pi_refined = mLocalSearch.Minimize(x_pi, evaluate, calc_gradient, mLocalSearchTerminationCondition, constraints);
if (best_solution.TryUpdateSolution(x_pi_refined.Values, x_pi_refined.Cost, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
x = best_solution.Values;
fx = best_solution.Cost;
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(CostEvaluationMethod evaluate, GradientEvaluationMethod calc_grad, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
mLocalSearch.LowerBounds = mLowerBounds;
mLocalSearch.UpperBounds = mUpperBounds;
List <ContinuousSolution> diverse_set = ConstructDiverseSet(evaluate, calc_grad, constraints);
diverse_set = diverse_set.OrderBy(s => s.Cost).ToList();
ContinuousSolution[] ref_set = Diversify(diverse_set);
foreach (ContinuousSolution s in ref_set)
{
s.SetIsNew(true);
}
ContinuousSolution best_solution = ref_set[0].Clone() as ContinuousSolution;
while (!should_terminate(improvement, iteration))
{
bool was_changed = ExploreSubsets(ref ref_set, evaluate, calc_grad, constraints);
if (!was_changed)
{
break;
}
if (best_solution.TryUpdateSolution(ref_set[0].Values, ref_set[0].Cost, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
int dimension = x_0.Length;
double[] x = (double[])x_0.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
double[] Vfx = new double[dimension];
ContinuousSolution best_solution = new ContinuousSolution(x, fx);
double?improvement = null;
int iteration = 0;
while (!should_terminate(improvement, iteration))
{
calc_gradient(x, Vfx, mLowerBounds, mUpperBounds, constraints);
for (int d = 0; d < dimension; ++d)
{
x[d] = x[d] - mAlpha * Vfx[d];
}
fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
if (best_solution.TryUpdateSolution(x, fx, out improvement))
{
//Console.WriteLine("called");
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(new ContinuousSolution(x, fx), iteration);
iteration++;
}
return(best_solution);
}
public static double Solve(int dimension_count, CostEvaluationMethod evaluator, out Bee global_best_solution, double[] lower_bounds = null, double[] upper_bounds = null, int maxIterations = 100000, int displayEvery = 100, object constraints = null)
{
int scoutBeeCount = 60;
int bestPatch = 15;
int elitePatch = 30;
BeeSwarm <Bee> solver = new BeeSwarm <Bee>(scoutBeeCount, bestPatch, elitePatch, 20, 10, evaluator);
solver.LowerBounds = lower_bounds;
solver.UpperBounds = upper_bounds;
solver.Constraints = constraints;
solver.LocalSearchRegion = new double[dimension_count];
for (int i = 0; i < dimension_count; ++i)
{
solver.LocalSearchRegion[i] = (upper_bounds[i] - lower_bounds[i]) / bestPatch;
}
solver.Initialize();
int iteration = 0;
double global_best_solution_cost = solver.GlobalBestSolutionCost;
double prev_global_best_solution_cost = global_best_solution_cost;
while (iteration < maxIterations)
{
prev_global_best_solution_cost = global_best_solution_cost;
solver.Iterate();
global_best_solution_cost = solver.GlobalBestSolutionCost;
if (iteration % displayEvery == 0)
{
Console.WriteLine("Generation: {0}, Best Cost: {1}", iteration, global_best_solution_cost);
}
iteration++;
}
global_best_solution = solver.GlobalBestSolution.Clone() as Bee;
return(global_best_solution_cost);
}
protected List <ContinuousSolution> ConstructDiverseSet(CostEvaluationMethod evaluate, GradientEvaluationMethod calc_grad, object constraints)
{
double[] x = null;
ContinuousSolution best_solution = new ContinuousSolution();
double?improvement2 = null;
List <ContinuousSolution> diverse_set = new List <ContinuousSolution>();
while (diverse_set.Count < mReferenceSetSize)
{
x = CreateRandomSolution(evaluate, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution xs = DoLocalSearch(x, evaluate, calc_grad, constraints);
double minDistanceSq = double.MaxValue;
double distanceSq = 0;
bool contains_item = false;
foreach (ContinuousSolution s in diverse_set)
{
distanceSq = s.GetDistanceSq2(xs);
if (distanceSq.Equals(minDistanceSq))
{
contains_item = true;
break;
}
}
if (!contains_item)
{
diverse_set.Add(xs);
}
best_solution.TryUpdateSolution(xs.Values, xs.Cost, out improvement2);
}
return(diverse_set);
}
public abstract ContinuousSolution Minimize(CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null);
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
double[] x = (double[])x_0.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution best_solution = new ContinuousSolution(x, fx);
double current_step_size = 0;
double step_size_large = 0;
int no_change_count = 0;
while (!should_terminate(improvement, iteration))
{
double[] x1 = TakeStep(mSolutionGenerator, x, current_step_size, constraints);
double fx1 = evaluate(x1, mLowerBounds, mUpperBounds, constraints);
step_size_large = CalcStepSizeLarge(current_step_size, iteration);
double[] x2 = TakeStep(mSolutionGenerator, x, current_step_size, constraints);
double fx2 = evaluate(x1, mLowerBounds, mUpperBounds, constraints);
if (fx1 < fx || fx2 < fx)
{
if (fx1 < fx2)
{
x = x1;
fx = fx1;
current_step_size = step_size_large;
}
else
{
x = x2;
fx = fx2;
}
no_change_count = 0;
if (best_solution.TryUpdateSolution(x, fx, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
}
else
{
no_change_count++;
if (no_change_count > mMaxNoChangeIterationCount)
{
no_change_count = 0;
current_step_size = current_step_size / mStepSizeFactor_Small;
}
}
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public AntColonySystem(int population_size, int state_count, CostEvaluationMethod evaluator, CreateAntMethod generator = null)
: base(population_size, state_count, evaluator, generator)
{
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
ContinuousSolution best_solution = new ContinuousSolution();
int dimension = x_0.Length;
double[] x = (double[])x_0.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
double?improvement = null;
int iteration = 0;
while (!should_terminate(improvement, iteration))
{
double[] fx_candidate = new double[dimension];
double[] h = new double[dimension];
for (int d = 0; d < dimension; ++d)
{
x[d] += mDeltaX;
fx_candidate[d] = evaluate(x, mLowerBounds, mUpperBounds, constraints);
h[d] = fx - fx_candidate[d];
x[d] -= mDeltaX;
}
int max_d = -1;
double h_max = 0;
for (int d = 0; d < dimension; ++d)
{
if (h_max < h[d])
{
h_max = h[d];
max_d = d;
}
}
if (max_d != -1)
{
fx = fx_candidate[max_d];
x[max_d] += mDeltaX;
}
else
{
if (mDeltaX > ZERO)
{
mDeltaX *= (-BETA);
}
else
{
break;
}
}
if (best_solution.TryUpdateSolution(x, fx, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(new ContinuousSolution(x, fx), iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
ContinuousSolution best_solution = new ContinuousSolution();
int dimension = x_0.Length;
double[] x = (double[])x_0.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
double[] Vfx = new double[dimension];
calc_gradient(x, Vfx, mLowerBounds, mUpperBounds, constraints);
double[] deltaX = new double[dimension];
double[] deltaX_prev = new double[dimension];
for (int d = 0; d < dimension; ++d)
{
deltaX[d] = -Vfx[d];
}
double alpha;
double[] x_next;
double fx_next;
LineSearch(x, fx, deltaX, out x_next, out fx_next, out alpha, evaluate, calc_gradient, mLowerBounds, mUpperBounds, constraints);
double beta = 0;
double[] s = new double[dimension];
for (int d = 0; d < dimension; ++d)
{
s[d] = deltaX[d];
}
double?improvement = null;
int iteration = 0;
while (!should_terminate(improvement, iteration))
{
for (int d = 0; d < dimension; ++d)
{
deltaX_prev[d] = deltaX[d];
x[d] = x_next[d];
}
calc_gradient(x, Vfx, mLowerBounds, mUpperBounds, constraints);
for (int d = 0; d < dimension; ++d)
{
deltaX[d] = -Vfx[d];
}
beta = ComputeBeta(deltaX, deltaX_prev, s);
for (int d = 0; d < dimension; ++d)
{
s[d] = deltaX[d] + beta * s[d];
}
LineSearch(x, fx, s, out x_next, out fx_next, out alpha, evaluate, calc_gradient, mLowerBounds, mUpperBounds, constraints);
if (best_solution.TryUpdateSolution(x_next, fx_next, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(new ContinuousSolution(x_next, fx_next), iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(double[] x_0, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
int dimension = x_0.Length;
double[] x = (double[])x_0.Clone();
double[] x_prev = (double[])x.Clone();
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution best_solution = new ContinuousSolution(x, fx);
double[] Vfx = new double[dimension];
double[] Vfx_prev = new double[dimension];
double[] y = new double[dimension];
double[] p = new double[dimension];
double[] s = new double[dimension];
double[] x_out;
double fx_out = 0;
double alpha = 1;
calc_gradient(x, Vfx, mLowerBounds, mUpperBounds, constraints);
Matrix <double> B_matrix = SparseMatrix.Identity(dimension);
ContinuousSolution solution = new ContinuousSolution(x, fx);
int iteration = 0;
double?improvement = null;
while (!should_terminate(improvement, iteration))
{
Matrix <double> Vfx_matrix = new SparseMatrix(dimension, 1, 0);
for (int d = 0; d < dimension; ++d)
{
Vfx_matrix[d, 0] = -Vfx[d];
}
Matrix <double> p_matrix = B_matrix.Inverse().Multiply(Vfx_matrix);
for (int d = 0; d < dimension; ++d)
{
p[d] = p_matrix[d, 0];
}
fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
//Console.WriteLine("before");
SingleTrajectoryContinuousSolver.LineSearch(x, fx, p, out x_out, out fx_out, out alpha, evaluate, calc_gradient, mLowerBounds, mUpperBounds, constraints);
//Console.WriteLine("after");
if (best_solution.TryUpdateSolution(x, fx, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
for (int d = 0; d < dimension; ++d)
{
s[d] = alpha * p[d];
}
Matrix <double> s_matrix = new SparseMatrix(dimension, 1, s);
Matrix <double> s_matrix_t = s_matrix.Transpose();
for (int d = 0; d < dimension; ++d)
{
x_prev[d] = x[d];
}
for (int d = 0; d < dimension; ++d)
{
Vfx_prev[d] = Vfx[d];
}
for (int d = 0; d < dimension; ++d)
{
x[d] += alpha * p[d];
}
calc_gradient(x, Vfx, mLowerBounds, mUpperBounds, constraints);
for (int d = 0; d < dimension; ++d)
{
y[d] = Vfx[d] - Vfx_prev[d];
}
Matrix <double> y_matrix = new SparseMatrix(dimension, 1, y);
Matrix <double> y_matrix_t = y_matrix.Transpose();
Matrix <double> yts_matrix = y_matrix_t.Multiply(s_matrix);
double yts = yts_matrix[0, 0];
Matrix <double> sBs_matrix = s_matrix_t.Multiply(B_matrix).Multiply(s_matrix);
double sBs = sBs_matrix[0, 0];
B_matrix = B_matrix + y_matrix.Multiply(y_matrix_t).Divide(yts) - B_matrix.Multiply(s_matrix).Multiply(s_matrix_t).Multiply(B_matrix).Divide(sBs);
OnStepped(new ContinuousSolution(x, fx), iteration);
iteration++;
}
return(best_solution);
}
public override ContinuousSolution Minimize(CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
ContinuousSolution[] pop = new ContinuousSolution[mPopSize];
double[] lower_bounds = null;
double[] upper_bounds = null;
if (mLowerBounds == null || mUpperBounds == null)
{
if (constraints is Tuple <double[], double[]> )
{
Tuple <double[], double[]> bounds = constraints as Tuple <double[], double[]>;
lower_bounds = bounds.Item1;
upper_bounds = bounds.Item2;
}
else
{
throw new InvalidCastException();
}
}
else
{
lower_bounds = mLowerBounds;
upper_bounds = mUpperBounds;
}
if (lower_bounds.Length < mDimension)
{
throw new IndexOutOfRangeException();
}
if (upper_bounds.Length < mDimension)
{
throw new IndexOutOfRangeException();
}
double[,] init_strategy_bounds = new double[mDimension, 2];
for (int j = 0; j < mDimension; ++j)
{
init_strategy_bounds[j, 0] = 0;
init_strategy_bounds[j, 1] = (upper_bounds[j] - lower_bounds[j]) * 0.05;
}
ContinuousSolution best_solution = null;
for (int i = 0; i < mPopSize; ++i)
{
double[] x = mSolutionGenerator(mDimension, constraints);
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution s = new ContinuousSolution(x, fx);
double[] strategy = new double[mDimension];
for (int j = 0; j < mDimension; ++j)
{
strategy[j] = init_strategy_bounds[j, 0] + (init_strategy_bounds[j, 1] - init_strategy_bounds[j, 0]) * RandomEngine.NextDouble();
}
s.SetMutationStrategy(strategy);
pop[i] = s;
}
pop = pop.OrderBy(s => s.Cost).ToArray();
best_solution = pop[0].Clone() as ContinuousSolution;
ContinuousSolution[] children = new ContinuousSolution[mPopSize];
ContinuousSolution[] generation = new ContinuousSolution[mPopSize * 2];
while (!should_terminate(improvement, iteration))
{
for (int i = 0; i < mPopSize; ++i)
{
children[i] = Mutate(pop[i], lower_bounds, upper_bounds, constraints);
children[i].Cost = evaluate(children[i].Values, mLowerBounds, mUpperBounds, constraints);
}
children = children.OrderBy(s => s.Cost).ToArray();
if (best_solution.TryUpdateSolution(children[0].Values, children[0].Cost, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
for (int i = 0; i < mPopSize; ++i)
{
generation[i] = pop[i];
}
for (int i = 0; i < mPopSize; ++i)
{
generation[i + mPopSize] = children[i];
}
for (int i = 0; i < generation.Length; ++i)
{
int wins = 0;
ContinuousSolution si = generation[i];
for (int j = 0; j < mBoutSize; ++j)
{
ContinuousSolution sj = generation[RandomEngine.NextInt(generation.Length)];
if (si.Cost < sj.Cost)
{
wins++;
}
}
si.SetWins(wins);
}
generation = generation.OrderByDescending(s => s.GetWins()).ToArray();
for (int i = 0; i < mPopSize; ++i)
{
pop[i] = generation[i];
}
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}
public static bool LineSearch(double[] x_0, double fx_0, double[] direction, out double[] x_out, out double fx_out, out double alpha, CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, double[] lower_bounds, double[] upper_bounds, object constraints = null)
{
int dimension = x_0.Length;
double[] Vfx = new double[dimension];
x_out = new double[dimension];
alpha = 1.0;
fx_out = double.MaxValue;
calc_gradient(x_0, Vfx, lower_bounds, upper_bounds, constraints);
double direction_length = 0;
for (int d = 0; d < dimension; ++d)
{
direction_length += direction[d] * direction[d];
}
direction_length = Math.Sqrt(direction_length);
if (direction_length > 0)
{
for (int d = 0; d < dimension; ++d)
{
direction[d] /= direction_length;
}
}
double p = 0.0;
for (int d = 0; d < dimension; ++d)
{
p += (direction[d] * Vfx[d]);
}
//Console.WriteLine("p: {0}", p);
if (double.IsNaN(p))
{
return(false);
}
if (p >= 0.0) // not in the descending direction return false;
{
return(false);
}
for (int k = 0; ; ++k)
{
for (int d = 0; d < dimension; ++d)
{
x_out[d] = x_0[d] + alpha * direction[d];
}
fx_out = evaluate(x_out, lower_bounds, upper_bounds, constraints);
if (fx_out < fx_0 + SIGMA * alpha * p)
{
return(true);
}
else
{
if (k == 0)
{
double enumerator = (p + fx_0 - fx_out);
if (enumerator == 0)
{
alpha = 0.5 * p / enumerator;
}
else
{
alpha = 0.5 * p;
}
//Console.WriteLine("alpha: {0}", alpha);
}
else
{
alpha *= BETA;
}
}
//Console.WriteLine("alpha: {0}", alpha);
if (alpha < ZERO)
{
if (fx_out > fx_0)
{
for (int d = 0; d < dimension; ++d)
{
x_out[d] = x_0[d];
}
fx_out = fx_0;
return(true);
}
else
{
return(true);
}
}
}
}
public override ContinuousSolution Minimize(CostEvaluationMethod evaluate, GradientEvaluationMethod calc_gradient, TerminationEvaluationMethod should_terminate, object constraints = null)
{
double?improvement = null;
int iteration = 0;
ContinuousSolution[] pop = new ContinuousSolution[mPopSize];
ContinuousSolution[] children = new ContinuousSolution[mPopSize];
double[] lower_bounds = null;
double[] upper_bounds = null;
if (mLowerBounds == null || mUpperBounds == null)
{
if (constraints is Tuple <double[], double[]> )
{
Tuple <double[], double[]> bounds = constraints as Tuple <double[], double[]>;
lower_bounds = bounds.Item1;
upper_bounds = bounds.Item2;
}
else
{
throw new InvalidCastException();
}
}
else
{
lower_bounds = mLowerBounds;
upper_bounds = mUpperBounds;
}
if (lower_bounds.Length < mDimension)
{
throw new IndexOutOfRangeException();
}
if (upper_bounds.Length < mDimension)
{
throw new IndexOutOfRangeException();
}
double[] best_x0 = null;
double best_fx0 = double.MaxValue;
for (int i = 0; i < mPopSize; ++i)
{
double[] x = mSolutionGenerator(mDimension, constraints);
double fx = evaluate(x, mLowerBounds, mUpperBounds, constraints);
ContinuousSolution s = new ContinuousSolution(x, fx);
pop[i] = s;
if (fx < best_fx0)
{
best_fx0 = fx;
best_x0 = x;
}
}
pop = pop.OrderBy(s => s.Cost).ToArray();
ContinuousSolution best_solution = new ContinuousSolution(best_x0, best_fx0);
while (!should_terminate(improvement, iteration))
{
for (int i = 0; i < mPopSize; ++i)
{
ContinuousSolution child = Reproduce(pop, pop[i], lower_bounds, upper_bounds);
child.Cost = evaluate(child.Values, mLowerBounds, mUpperBounds, constraints);
children[i] = child;
}
for (int i = 0; i < mPopSize; ++i)
{
if (pop[i].Cost > children[i].Cost)
{
pop[i] = children[i];
}
}
pop = pop.OrderBy(s => s.Cost).ToArray();
if (best_solution.TryUpdateSolution(pop[0].Values, pop[0].Cost, out improvement))
{
OnSolutionUpdated(best_solution, iteration);
}
OnStepped(best_solution, iteration);
iteration++;
}
return(best_solution);
}