public Task <ImmutableHashSet <IChromosome <T> > > Operate(IEnumerable <IChromosome <T> > parents,
PopulationCapacity capacity, CancellationToken token = default)
{
var elite = ImmutableHashSet.CreateBuilder <IChromosome <T> >();
ImmutableArray <IChromosome <T> > lastFront;
var fronts = _sorter.Sort(parents).Select(f => f.ToArray()).ToArray();
foreach (var front in fronts)
{
if (elite.Count + front.Length > capacity.Maximum)
{
lastFront = front.ToImmutableArray();
break;
}
elite.UnionWith(front);
if (elite.Count > capacity.Minimum)
{
break;
}
}
if (elite.Count >= capacity.Minimum)
{
return(Task.FromResult(elite.ToImmutable()));
}
token.ThrowIfCancellationRequested();
var remains = capacity.Minimum - elite.Count;
var crowdingDistance = lastFront.ToDictionary(c => c, c => 0d);
var normalizedComparable = Normalize(lastFront.Union(elite));
foreach (var objective in Enum.GetValues(typeof(T)).Cast <T>())
{
var sorted = normalizedComparable.OrderBy(c => c.Value[objective]).ToArray();
if (crowdingDistance.ContainsKey(sorted[0].Key))
{
crowdingDistance[sorted[0].Key] += 1;
}
if (crowdingDistance.ContainsKey(sorted[sorted.Length - 1].Key))
{
crowdingDistance[sorted[sorted.Length - 1].Key] += 1;
}
for (var i = 1; i < sorted.Length - 1; i++)
{
if (!crowdingDistance.ContainsKey(sorted[i].Key))
{
continue;
}
var lowerValue = sorted[i - 1].Value[objective];
var upperValue = sorted[i + 1].Value[objective];
var distance = Math.Abs(upperValue - lowerValue);
crowdingDistance[sorted[i].Key] += distance;
}
}
elite.UnionWith(crowdingDistance.OrderByDescending(d => d.Value).Select(d => d.Key).Take(remains));
return(Task.FromResult(elite.ToImmutable()));
}
public override async Task <ImmutableHashSet <IChromosome <T> > > Operate(
IEnumerable <IChromosome <T> > chromosomes,
PopulationCapacity capacity,
CancellationToken token = default)
{
var parents = chromosomes.ToArray();
var offspring = (await _reproduction.Operate(parents, capacity, token)).ToList();
offspring.AddRange(parents);
await _chromosomeEvaluator.EvaluateAll(offspring, token);
var allOffspring = await _offspringSelection.Operate(offspring.ToImmutableHashSet(), capacity, token);
await _chromosomeEvaluator.EvaluateAll(allOffspring, token);
return(allOffspring);
}
public abstract Task <IEnumerable <IChromosome <T> > > Operate(
IEnumerable <IChromosome <T> > parents,
PopulationCapacity capacity,
CancellationToken token = default);
public async Task <ImmutableHashSet <IChromosome> > Operate(ImmutableHashSet <IChromosome> chromosomes, PopulationCapacity capacity, CancellationToken token = default)
{
var offspring = await Operate(chromosomes.Cast <IChromosome <T> >(), capacity, token);
return(offspring.Cast <IChromosome>().ToImmutableHashSet());
}
