/// <inheritdoc/>
public int PerformSelection(IGenerateRandom rnd, ISpecies species)
{
int bestIndex = rnd.NextInt(species.Members.Count);
IGenome best = species.Members[bestIndex];
BasicEA.CalculateScoreAdjustment(best, Trainer.ScoreAdjusters);
for (int i = 0; i < Rounds; i++)
{
int competitorIndex = rnd.NextInt(species.Members.Count);
IGenome competitor = species.Members[competitorIndex];
// only evaluate valid genomes
if (!double.IsInfinity(competitor.AdjustedScore) &&
!double.IsNaN(competitor.AdjustedScore))
{
BasicEA.CalculateScoreAdjustment(competitor,
Trainer.ScoreAdjusters);
if (Trainer.SelectionComparer.IsBetterThan(
competitor, best))
{
best = competitor;
bestIndex = competitorIndex;
}
}
}
return(bestIndex);
}
/// <inheritdoc/>
public int PerformAntiSelection(IGenerateRandom rnd, ISpecies species)
{
int worstIndex = rnd.NextInt(species.Members.Count);
IGenome worst = species.Members[worstIndex];
BasicEA.CalculateScoreAdjustment(worst,
Trainer.ScoreAdjusters);
for (int i = 0; i < this.Rounds; i++)
{
int competitorIndex = rnd.NextInt(species.Members.Count);
IGenome competitor = species.Members[competitorIndex];
// force an invalid genome to lose
if (double.IsInfinity(competitor.AdjustedScore)
|| double.IsNaN(competitor.AdjustedScore))
{
return competitorIndex;
}
BasicEA.CalculateScoreAdjustment(competitor,
Trainer.ScoreAdjusters);
if (!Trainer.SelectionComparer.IsBetterThan(competitor,
worst))
{
worst = competitor;
worstIndex = competitorIndex;
}
}
return worstIndex;
}
/// <inheritdoc/>
public int PerformAntiSelection(IGenerateRandom rnd, ISpecies species)
{
int worstIndex = rnd.NextInt(species.Members.Count);
IGenome worst = species.Members[worstIndex];
BasicEA.CalculateScoreAdjustment(worst,
Trainer.ScoreAdjusters);
for (int i = 0; i < this.Rounds; i++)
{
int competitorIndex = rnd.NextInt(species.Members.Count);
IGenome competitor = species.Members[competitorIndex];
// force an invalid genome to lose
if (double.IsInfinity(competitor.AdjustedScore) ||
double.IsNaN(competitor.AdjustedScore))
{
return(competitorIndex);
}
BasicEA.CalculateScoreAdjustment(competitor,
Trainer.ScoreAdjusters);
if (!Trainer.SelectionComparer.IsBetterThan(competitor,
worst))
{
worst = competitor;
worstIndex = competitorIndex;
}
}
return(worstIndex);
}
/// <summary>
/// Perform a Fisher-Yates shuffle.
/// http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
/// </summary>
/// <param name="dataDivisionList">The division list.</param>
/// <param name="totalCount">Total count across divisions.</param>
private void PerformShuffle(IList <DataDivision> dataDivisionList,
int totalCount)
{
for (int i = totalCount - 1; i > 0; i--)
{
int n = _rnd.NextInt(i + 1);
VirtualSwap(dataDivisionList, i, n);
}
}
/// <summary>
/// Place the cities in random locations.
/// </summary>
/// <param name="rnd">Random number.</param>
private void InitCities(IGenerateRandom rnd)
{
_cities = new City[Cities];
for (int i = 0; i < _cities.Length; i++)
{
int xPos = rnd.NextInt(0, MapSize);
int yPos = rnd.NextInt(0, MapSize);
_cities[i] = new City(xPos, yPos);
}
}
/// <summary>
/// Run the example.
/// </summary>
public void Run()
{
_cities = new double[CityCount][];
_currentPath = new int[CityCount];
_backupPath = new int[CityCount];
_bestPath = new int[CityCount];
// place the cities in a circle
double ratio = (2 * Math.PI) / _cities.Length;
for (int cityNumber = 0; cityNumber < _cities.Length; cityNumber++)
{
_cities[cityNumber] = new double[2];
_cities[cityNumber][0] = (int)(Math.Cos(ratio * cityNumber) * (MapSize / 2) + (MapSize / 2));
_cities[cityNumber][1] = (int)(Math.Sin(ratio * cityNumber) * (MapSize / 2) + (MapSize / 2));
}
// pick a random city order
_currentPath = new int[CityCount];
for (int i = 0; i < _currentPath.Length; i++)
{
int city;
bool foundCity;
do
{
city = _rnd.NextInt(CityCount);
foundCity = false;
for (int j = 0; j < i; j++)
{
if (city == _currentPath[j])
{
foundCity = true;
}
}
} while (foundCity);
_currentPath[i] = city;
}
// now begin main loop, and find a minimum
while (!Done)
{
Iteration();
Console.WriteLine("Iteration #" + K + ", Best Score=" + BestScore + "," + Status);
}
foreach (var item in _bestPath)
{
Console.Write(item + " ");
}
Console.WriteLine();
}
/// <summary>
/// Generate a random path through cities.
/// </summary>
/// <param name="rnd">Random number generator.</param>
/// <returns>A genome.</returns>
private IntegerArrayGenome RandomGenome(IGenerateRandom rnd)
{
var result = new IntegerArrayGenome(_cities.Length);
int[] organism = result.Data;
var taken = new bool[_cities.Length];
for (int i = 0; i < organism.Length - 1; i++)
{
int icandidate;
do
{
icandidate = rnd.NextInt(0, organism.Length);
} while (taken[icandidate]);
organism[i] = icandidate;
taken[icandidate] = true;
if (i == organism.Length - 2)
{
icandidate = 0;
while (taken[icandidate])
{
icandidate++;
}
organism[i + 1] = icandidate;
}
}
return(result);
}
/// <inheritdoc/>
public int PerformSelection(IGenerateRandom rnd, ISpecies species)
{
int top = Math.Max((int)(species.Members.Count * _percent),
1);
return(rnd.NextInt(top));
}
/// <summary>
/// Choose the next node for an ant to visit. This is based on probability.
/// </summary>
/// <param name="currentIndex">The step we are at in the path.</param>
/// <param name="ant">The ant being evaluated.</param>
/// <returns>The node we will move into.</returns>
private int PickNextNode(int currentIndex, DiscreteAnt ant)
{
if (currentIndex == 0 || Random.NextDouble() < PR)
{
int index;
do
{
index = Random.NextInt(0, _graph.Count);
} while (ant.WasVisited(index));
return(index);
}
double[] prob = CalculateProbability(currentIndex, ant);
double r = Random.NextDouble();
double sum = 0;
for (int i = 0; i < _graph.Count; i++)
{
sum += prob[i];
if (sum >= r)
{
return(i);
}
}
// should not happen!
return(-1);
}
/// <summary>
/// Generate a random sample.
/// </summary>
private void GeneraterandomSample()
{
for (int i = 0; i < _batchSize; i++)
{
bool uniqueFound = true;
int t;
// Generate a unique index
do
{
t = _random.NextInt(0, _dataset.Count);
for (int j = 0; j < i; j++)
{
if (_randomSample[j] == t)
{
uniqueFound = false;
break;
}
}
} while (!uniqueFound);
// Record it
_randomSample[i] = t;
}
}
/// <summary>
/// Init the observations to random clusters. Use the "Init Random" algorithm. The Random Partition method first
/// randomly assigns a cluster to each observation and then proceeds to the update step, thus computing the initial mean to be the centroid of the cluster's randomly assigned points.
///
/// </summary>
/// <param name="theObservations">The observations to cluster.</param>
public void InitRandom(IList <BasicData> theObservations)
{
int dimensions = FindDimensions(theObservations);
// create the clusters
for (int i = 0; i < _k; i++)
{
_clusters.Add(new Cluster(dimensions));
}
// assign each observation to a random cluster
foreach (BasicData observation in theObservations)
{
int clusterIndex = _randomGeneration.NextInt(_k);
Cluster cluster = _clusters[clusterIndex];
cluster.Observations.Add(observation);
}
// handle any empty clusters
foreach (Cluster cluster in _clusters)
{
if (cluster.Observations.Count == 0)
{
bool done = false;
while (!done)
{
int sourceIndex = _randomGeneration.NextInt(_k);
Cluster source = _clusters[sourceIndex];
if (source != cluster && source.Observations.Count > 1)
{
int sourceObservationIndex = _randomGeneration.NextInt(source.Observations.Count);
BasicData sourceObservation = source.Observations[sourceObservationIndex];
source.Observations.RemoveAt(sourceObservationIndex);
cluster.Observations.Add(sourceObservation);
done = true;
}
}
}
}
// calculate initial centers
UpdateStep();
}
public override void MoveToNeighbor()
{
// pick the first point to swap
int pt1 = _rnd.NextInt(_currentHolder.Length);
// pick the second point to swap, can't be the same as the first
int pt2;
do
{
pt2 = _rnd.NextInt(_currentHolder.Length);
} while (pt1 == pt2);
// swap them
double temp = _currentHolder[pt1];
_currentHolder[pt1] = _currentHolder[pt2];
_currentHolder[pt2] = temp;
}
/// <summary>
/// Run the example.
/// </summary>
public void Run()
{
// Generate a random set of items.
for (int n = 0; n < NumItemsToChoose; n++)
{
_profit[n] = _rnd.NextInt(ItemMaxValue);
_weight[n] = _rnd.NextInt(ItemMaxWeight);
}
// now begin main loop, and find a minimum
while (!Done)
{
Iteration();
Console.WriteLine("Iteration #" + K + ", Best Score=" + BestScore + "," + Status);
}
// print results
Console.WriteLine("item" + "\t" + "profit" + "\t" + "weight" + "\t" + "take");
for (int n = 0; n < NumItemsToChoose; n++)
{
Console.WriteLine((n + 1) + "\t" + _profit[n] + "\t" + _weight[n] + "\t" + _bestTaken[n]);
}
}
private void updateTimer_Tick(object sender, EventArgs e)
{
iteration++;
if (iteration > 100)
{
updateTimer.Enabled = false;
}
var idx = (int)rnd.NextInt(samples.Length);
var c = samples[idx];
train.TrainPattern(c);
train.AutoDecay();
DrawMap();
//System.out.println("Iteration " + i + ","+ this.train.toString());
}
/// <inheritdoc />
public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex,
IGenome[] offspring, int offspringIndex)
{
var mother = (IntegerArrayGenome)parents[parentIndex];
var father = (IntegerArrayGenome)parents[parentIndex + 1];
var offspring1 = (IntegerArrayGenome)_owner.Population.GenomeFactory.Factor();
var offspring2 = (IntegerArrayGenome)_owner.Population.GenomeFactory.Factor();
offspring[offspringIndex] = offspring1;
offspring[offspringIndex + 1] = offspring2;
int geneLength = mother.Count;
// the chromosome must be cut at two positions, determine them
int cutpoint1 = rnd.NextInt(geneLength - _cutLength);
int cutpoint2 = cutpoint1 + _cutLength;
// keep track of which genes have been taken in each of the two
// offspring, defaults to false.
var taken1 = new HashSet <int>();
var taken2 = new HashSet <int>();
// handle cut section
for (int i = 0; i < geneLength; i++)
{
if (!((i < cutpoint1) || (i > cutpoint2)))
{
offspring1.Copy(father, i, i);
offspring2.Copy(mother, i, i);
taken1.Add(father.Data[i]);
taken2.Add(mother.Data[i]);
}
}
// handle outer sections
for (int i = 0; i < geneLength; i++)
{
if ((i < cutpoint1) || (i > cutpoint2))
{
offspring1.Data[i] = GetNotTaken(mother, taken1);
offspring2.Data[i] = GetNotTaken(father, taken2);
}
}
}
/// <inheritdoc />
public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex,
IGenome[] offspring, int offspringIndex)
{
var mother = (IntegerArrayGenome) parents[parentIndex];
var father = (IntegerArrayGenome) parents[parentIndex + 1];
var offspring1 = (IntegerArrayGenome) _owner.Population.GenomeFactory.Factor();
var offspring2 = (IntegerArrayGenome) _owner.Population.GenomeFactory.Factor();
offspring[offspringIndex] = offspring1;
offspring[offspringIndex + 1] = offspring2;
int geneLength = mother.Count;
// the chromosome must be cut at two positions, determine them
int cutpoint1 = rnd.NextInt(geneLength - _cutLength);
int cutpoint2 = cutpoint1 + _cutLength;
// keep track of which genes have been taken in each of the two
// offspring, defaults to false.
var taken1 = new HashSet<int>();
var taken2 = new HashSet<int>();
// handle cut section
for (int i = 0; i < geneLength; i++)
{
if (!((i < cutpoint1) || (i > cutpoint2)))
{
offspring1.Copy(father, i, i);
offspring2.Copy(mother, i, i);
taken1.Add(father.Data[i]);
taken2.Add(mother.Data[i]);
}
}
// handle outer sections
for (int i = 0; i < geneLength; i++)
{
if ((i < cutpoint1) || (i > cutpoint2))
{
offspring1.Data[i] = GetNotTaken(mother, taken1);
offspring2.Data[i] = GetNotTaken(father, taken2);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="rnd"></param>
/// <param name="parent"></param>
/// <param name="current"></param>
/// <param name="index"></param>
/// <param name="reservoir"></param>
private void InternalSampleRandomNode(IGenerateRandom rnd, TreeGenomeNode parent, TreeGenomeNode current,
int[] index, RandomNodeResult reservoir)
{
int currentIndex = index[0];
index[0]++;
// determine if we replace the reservoir
int j = rnd.NextInt(0, currentIndex + 1);
if (j == 0)
{
reservoir.Parent = parent;
reservoir.Child = current;
}
// traverse on to the children
foreach (TreeGenomeNode child in current.Children)
{
InternalSampleRandomNode(rnd, current, child, index, reservoir);
}
}
/// <summary>
///
/// </summary>
/// <param name="rnd"></param>
/// <param name="parent"></param>
/// <param name="current"></param>
/// <param name="index"></param>
/// <param name="reservoir"></param>
private void InternalSampleRandomNode(IGenerateRandom rnd, TreeGenomeNode parent, TreeGenomeNode current,
int[] index, RandomNodeResult reservoir)
{
int currentIndex = index[0];
index[0]++;
// determine if we replace the reservoir
int j = rnd.NextInt(0, currentIndex + 1);
if (j == 0)
{
reservoir.Parent = parent;
reservoir.Child = current;
}
// traverse on to the children
foreach (TreeGenomeNode child in current.Children)
{
InternalSampleRandomNode(rnd, current, child, index, reservoir);
}
}
/// <summary>
/// Split a list into two sublists by randomly shuffling the values (without replacement).
/// </summary>
/// <typeparam name="T">The type that the lists contain.</typeparam>
/// <param name="list">The list to split/shuffle.</param>
/// <param name="ratio">The size of the first retuerned list.</param>
/// <param name="rnd">A random number generator to split the lists.</param>
/// <returns>A list containing the two split lists.</returns>
public static IList <IList <T> > Split <T>(IList <T> list, double ratio, IGenerateRandom rnd)
{
IList <IList <T> > result = new List <IList <T> >();
var aCount = (int)(list.Count * ratio);
var a = new List <T>();
var b = new List <T>();
result.Add(a);
result.Add(b);
b.AddRange(list);
for (var i = 0; i < aCount; i++)
{
var idx = rnd.NextInt(0, b.Count);
a.Add(b[idx]);
b.RemoveAt(idx);
}
return(result);
}
/// <inheritdoc />
public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex, IGenome[] offspring,
int offspringIndex)
{
var parent1 = (TreeGenome)parents[parentIndex];
EvaluateTree eval = parent1.Evaluator;
var off1 = (TreeGenome)_owner.Population.GenomeFactory.Factor(parent1);
RandomNodeResult off1Point = eval.SampleRandomNode(rnd, off1.Root);
int len = rnd.NextInt(1, _maxGraftLength + 1);
TreeGenomeNode randomSequence = eval.Grow(rnd, len);
if (off1Point.Parent == null)
{
off1.Root = randomSequence;
}
else
{
int idx = off1Point.Parent.Children.IndexOf(off1Point.Child);
off1Point.Parent.Children[idx] = randomSequence;
}
offspring[0] = off1;
}
/// <inheritdoc />
public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex,
IGenome[] offspring, int offspringIndex)
{
var mother = (IArrayGenome) parents[parentIndex];
var father = (IArrayGenome) parents[parentIndex + 1];
var offspring1 = (IArrayGenome) _owner.Population.GenomeFactory.Factor();
var offspring2 = (IArrayGenome) _owner.Population.GenomeFactory.Factor();
offspring[offspringIndex] = offspring1;
offspring[offspringIndex + 1] = offspring2;
int geneLength = mother.Count;
// the chromosome must be cut at two positions, determine them
int cutpoint1 = rnd.NextInt(geneLength - _cutLength);
int cutpoint2 = cutpoint1 + _cutLength;
// handle cut section
for (int i = 0; i < geneLength; i++)
{
if (!((i < cutpoint1) || (i > cutpoint2)))
{
offspring1.Copy(father, i, i);
offspring2.Copy(mother, i, i);
}
}
// handle outer sections
for (int i = 0; i < geneLength; i++)
{
if ((i < cutpoint1) || (i > cutpoint2))
{
offspring1.Copy(mother, i, i);
offspring2.Copy(father, i, i);
}
}
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="k">The number of folds.</param>
/// <param name="training">The training set.</param>
/// <param name="rnd">A random number generator.</param>
public CrossValidate(int k, IEnumerable <BasicData> training, IGenerateRandom rnd)
{
IList <BasicData> temp = new List <BasicData>();
temp = temp.Union(training).ToList();
// Setup k validation sets.
for (int i = 0; i < k; i++)
{
_folds.Add(new CrossValidateFold());
}
// Divide over the k sets.
int leaveOutSet = 0;
while (temp.Count > 0)
{
int idx = rnd.NextInt(temp.Count);
BasicData item = temp[idx];
temp.RemoveAt(idx);
_folds[leaveOutSet].ValidationSet.Add(item);
for (int includeSet = 0; includeSet < _folds.Count; includeSet++)
{
if (includeSet != leaveOutSet)
{
_folds[includeSet].TrainingSet.Add(item);
}
}
leaveOutSet++;
if (leaveOutSet >= k)
{
leaveOutSet = 0;
}
}
}
/// <inheritdoc />
public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex,
IGenome[] offspring, int offspringIndex)
{
var mother = (IArrayGenome)parents[parentIndex];
var father = (IArrayGenome)parents[parentIndex + 1];
var offspring1 = (IArrayGenome)_owner.Population.GenomeFactory.Factor();
var offspring2 = (IArrayGenome)_owner.Population.GenomeFactory.Factor();
offspring[offspringIndex] = offspring1;
offspring[offspringIndex + 1] = offspring2;
int geneLength = mother.Count;
// the chromosome must be cut at two positions, determine them
int cutpoint1 = rnd.NextInt(geneLength - _cutLength);
int cutpoint2 = cutpoint1 + _cutLength;
// handle cut section
for (int i = 0; i < geneLength; i++)
{
if (!((i < cutpoint1) || (i > cutpoint2)))
{
offspring1.Copy(father, i, i);
offspring2.Copy(mother, i, i);
}
}
// handle outer sections
for (int i = 0; i < geneLength; i++)
{
if ((i < cutpoint1) || (i > cutpoint2))
{
offspring1.Copy(mother, i, i);
offspring2.Copy(father, i, i);
}
}
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="k">The number of folds.</param>
/// <param name="training">The training set.</param>
/// <param name="rnd">A random number generator.</param>
public CrossValidate(int k, IEnumerable<BasicData> training, IGenerateRandom rnd)
{
IList<BasicData> temp = new List<BasicData>();
temp = temp.Union(training).ToList();
// Setup k validation sets.
for (int i = 0; i < k; i++)
{
_folds.Add(new CrossValidateFold());
}
// Divide over the k sets.
int leaveOutSet = 0;
while (temp.Count > 0)
{
int idx = rnd.NextInt(temp.Count);
BasicData item = temp[idx];
temp.RemoveAt(idx);
_folds[leaveOutSet].ValidationSet.Add(item);
for (int includeSet = 0; includeSet < _folds.Count; includeSet++)
{
if (includeSet != leaveOutSet)
{
_folds[includeSet].TrainingSet.Add(item);
}
}
leaveOutSet++;
if (leaveOutSet >= k)
{
leaveOutSet = 0;
}
}
}
/// <inheritdoc />
public void PerformOperation(IGenerateRandom rnd, IGenome[] parents, int parentIndex, IGenome[] offspring,
int offspringIndex)
{
var parent1 = (TreeGenome) parents[parentIndex];
EvaluateTree eval = parent1.Evaluator;
var off1 = (TreeGenome) _owner.Population.GenomeFactory.Factor(parent1);
RandomNodeResult off1Point = eval.SampleRandomNode(rnd, off1.Root);
int len = rnd.NextInt(1, _maxGraftLength + 1);
TreeGenomeNode randomSequence = eval.Grow(rnd, len);
if (off1Point.Parent == null)
{
off1.Root = randomSequence;
}
else
{
int idx = off1Point.Parent.Children.IndexOf(off1Point.Child);
off1Point.Parent.Children[idx] = randomSequence;
}
offspring[0] = off1;
}
/// <inheritdoc/>
public int PerformSelection(IGenerateRandom rnd, ISpecies species)
{
int top = Math.Max((int)(species.Members.Count * _percent),
1);
return rnd.NextInt(top);
}
/// <summary>
/// Choose a random opcode, choose between only nodes.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <returns>A random opcode.</returns>
public int ChooseRandomNodeOpcode(IGenerateRandom rnd)
{
return rnd.NextInt(VarConstOpcode);
}
/// <summary>
/// Choose a random opcode, choose between only leafs.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <returns>A random opcode.</returns>
public int ChooseRandomLeafOpcode(IGenerateRandom rnd)
{
return VarConstOpcode + rnd.NextInt(NumVar + NumConst);
}
/// <summary>
/// Choose a random opcode, choose between only leafs.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <returns>A random opcode.</returns>
public int ChooseRandomLeafOpcode(IGenerateRandom rnd)
{
return(VarConstOpcode + rnd.NextInt(NumVar + NumConst));
}
/// <summary>
/// Choose a random opcode, choose between only nodes.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <returns>A random opcode.</returns>
public int ChooseRandomNodeOpcode(IGenerateRandom rnd)
{
return(rnd.NextInt(VarConstOpcode));
}
/// <summary>
/// Choose a random opcode, choose between both leafs and nodes.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <returns>A random opcode.</returns>
public int ChooseRandomOpcode(IGenerateRandom rnd)
{
return(rnd.NextInt(0, OpcodeCount));
}
/// <summary>
/// Generate a random path through cities.
/// </summary>
/// <param name="rnd">Random number generator.</param>
/// <returns>A genome.</returns>
private IntegerArrayGenome RandomGenome(IGenerateRandom rnd)
{
var result = new IntegerArrayGenome(_cities.Length);
int[] organism = result.Data;
var taken = new bool[_cities.Length];
for (int i = 0; i < organism.Length - 1; i++)
{
int icandidate;
do
{
icandidate = rnd.NextInt(0, organism.Length);
} while (taken[icandidate]);
organism[i] = icandidate;
taken[icandidate] = true;
if (i == organism.Length - 2)
{
icandidate = 0;
while (taken[icandidate])
{
icandidate++;
}
organism[i + 1] = icandidate;
}
}
return result;
}
/// <summary>
/// Place the cities in random locations.
/// </summary>
/// <param name="rnd">Random number.</param>
private void InitCities(IGenerateRandom rnd)
{
_cities = new City[Cities];
for (int i = 0; i < _cities.Length; i++)
{
int xPos = rnd.NextInt(0, MapSize);
int yPos = rnd.NextInt(0, MapSize);
_cities[i] = new City(xPos, yPos);
}
}
/// <inheritdoc />
public object Sample(IGenerateRandom rnd)
{
return(_categories[rnd.NextInt(_categories.Count)]);
}
/// <inheritdoc/>
public int PerformSelection(IGenerateRandom rnd, ISpecies species)
{
int bestIndex = rnd.NextInt(species.Members.Count);
IGenome best = species.Members[bestIndex];
BasicEA.CalculateScoreAdjustment(best, Trainer.ScoreAdjusters);
for (int i = 0; i < Rounds; i++)
{
int competitorIndex = rnd.NextInt(species.Members.Count);
IGenome competitor = species.Members[competitorIndex];
// only evaluate valid genomes
if (!double.IsInfinity(competitor.AdjustedScore)
&& !double.IsNaN(competitor.AdjustedScore))
{
BasicEA.CalculateScoreAdjustment(competitor,
Trainer.ScoreAdjusters);
if (Trainer.SelectionComparer.IsBetterThan(
competitor, best))
{
best = competitor;
bestIndex = competitorIndex;
}
}
}
return bestIndex;
}
/// <inheritdoc />
public object Sample(IGenerateRandom rnd)
{
return _categories[rnd.NextInt(_categories.Count)];
}
/// <summary>
/// Choose a random opcode, choose between both leafs and nodes.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <returns>A random opcode.</returns>
public int ChooseRandomOpcode(IGenerateRandom rnd)
{
return rnd.NextInt(0, OpcodeCount);
}
