public override void FromStorage(Storage.Storage storage, Storage.Records.Optimizer optimizer)
{
base.FromStorage(storage, optimizer);
// Deduce proxies
d_solutions.Clear();
for (int i = 0; i < Population.Count / 2; ++i)
{
Optimization.Solution first = Population[i * 2];
Optimization.Solution second = Population[i * 2 + 1];
Solution sol = CreateProxySolution((uint)i);
sol.Parameters = Parameters;
for (int p = 0; p < first.Parameters.Count; ++p)
{
Parameter p1 = first.Parameters[p];
Parameter p2 = first.Parameters[p];
sol.Parameters[p].Value = (p1.Value + p2.Value) / 2;
}
sol.Solutions = new Optimization.Solution[] { first, second };
d_solutions.Add(sol);
}
}
public override void Copy(Optimization.Solution other)
{
base.Copy(other);
Particle particle = other as Particle;
d_velocity = new List <double>(particle.d_velocity);
d_personalBest = particle.d_personalBest;
}
public override void FromStorage(Storage.Storage storage, Storage.Records.Optimizer optimizer, Storage.Records.Solution solution, Optimization.Solution sol)
{
base.FromStorage(storage, optimizer, solution, sol);
if (d_loadingFromStorage)
{
return;
}
// Add some protection because we don't want to recursively load the best particle
d_loadingFromStorage = true;
Storage.Records.Solution best = storage.ReadSolution(-1, (int)sol.Id);
Particle particle = (Particle)sol;
if (best != null)
{
Solution b = CreateSolution((uint)best.Index);
FromStorage(storage, optimizer, best, b);
particle.PersonalBest = (Particle)b;
}
else
{
particle.PersonalBest = null;
}
d_loadingFromStorage = false;
}
public bool Progress(Job job)
{
if (!d_client.Connected)
{
return(false);
}
Communication communication = new Communication();
communication.Type = Communication.CommunicationType.Progress;
Progress pgs = new Progress();
pgs.Tick = job.Optimizer.CurrentIteration + 1;
int num = d_unknowns.Count + d_variables.Count + 1;
pgs.Terms = new Progress.Term[num];
FitnessForIndex fitfunc = delegate(Fitness fitness, int i)
{
if (i == 0)
{
return(fitness.Value);
}
else if (i <= d_unknowns.Count)
{
string key = d_unknowns[i - 1];
if (fitness.Values.ContainsKey(key))
{
return(fitness.Values[key]);
}
else
{
return(0);
}
}
else
{
string key = d_variables[i - d_unknowns.Count - 1];
if (fitness.Variables.ContainsKey(key))
{
return(fitness.Variables[key].Expression.Evaluate(Biorob.Math.Constants.Context, fitness.Context));
}
else
{
return(0);
}
}
};
// Compute best here manually because it's not yet updated in the optimizer
Fitness best = null;
// Setup the means
for (int s = 0; s < job.Optimizer.Population.Count; ++s)
{
Solution solution = job.Optimizer.Population[s];
if (best == null || solution.Fitness > best)
{
best = solution.Fitness;
}
for (int i = 0; i < num; ++i)
{
if (s == 0)
{
pgs.Terms[i] = new Progress.Term();
}
pgs.Terms[i].Mean += fitfunc(solution.Fitness, i);
}
}
// Setup the bests
for (int i = 0; i < num; ++i)
{
pgs.Terms[i].Best = fitfunc(best, i);
pgs.Terms[i].Mean /= job.Optimizer.Population.Count;
}
communication.Progress = pgs;
return(Send(communication));
}
