public void SimpleFitnessWriteAndRead()
{
var rand = new MersenneTwisterFast(0);
var f = new SimpleFitness();
f.SetFitness(null, float.MaxValue, true);
// Set up some random Trials just to check that they get transmitted
const int n = 10;
f.Trials = new List <double>(n);
for (var i = 0; i < n; i++)
{
f.Trials.Add(rand.NextDouble());
}
using (var ms = new MemoryStream())
{
var writer = new BinaryWriter(ms);
f.WriteFitness(null, writer); // Write
ms.Position = 0;
var reader = new BinaryReader(ms);
var f2 = new SimpleFitness();
f2.ReadFitness(null, reader); // Read
// Compare
Assert.AreEqual(f.Value, f2.Value); // Value is same
Assert.IsTrue(f2.IsIdeal); // Fitness is ideal
Assert.AreEqual(f2.Trials.Count, f.Trials.Count); // Number of trials is the same
for (var i = 0; i < f.Trials.Count; i++)
{
Assert.AreEqual((double)f.Trials[i], (double)f2.Trials[i]); // Trial values are all the same
}
}
}
protected SimpleStrategyBase(SimpleFitness fitness)
{
if (fitness == null) throw new ArgumentNullException("fitness");
CurrentPrediction = null;
Fitness = fitness;
}
public void Evaluate(IEvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
if (!ind.Evaluated) // don't bother reevaluating
{
// trees[0].Child is the root
ArrayList output = GetSemanticOutput(((GPIndividual)ind).Trees[0]);
double score = 0.0;
for (int i = 0; i < output.Count; i++)
{
SemanticNode n = (SemanticNode)output[i];
if (n.Value == 'X')
{
score += 1;
}
}
SimpleFitness f = (SimpleFitness)ind.Fitness;
f.SetFitness(state, score, false);
ind.Evaluated = true;
}
}
public void Evaluate(IEvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
if (!ind.Evaluated) // don't bother reevaluating
{
// trees[0].child is the root
// Note ECJ GPNode counts the root as being depth
// 1. Daida et al count it as depth 0 (p. 1669).
actualDepth = ((GPIndividual)ind).Trees[0].Child.Depth - 1;
actualTerminals = ((GPIndividual)ind).Trees[0].Child.NumNodes(GPNode.NODESEARCH_TERMINALS);
double scoreDepth = weightDepth * (1.0 - Math.Abs(targetDepth - actualDepth) / (double)targetDepth);
double scoreTerminals = 0.0;
if (targetDepth == actualDepth)
{
scoreTerminals = weightTerminals *
(1.0 - Math.Abs(targetTerminals - actualTerminals) / (double)targetTerminals);
}
double score = scoreTerminals + scoreDepth;
SimpleFitness f = (SimpleFitness)ind.Fitness;
f.SetFitness(state, (float)score, false);
ind.Evaluated = true;
}
}
public void CopyIndividualsForwardAndBack()
{
var state = new SimpleEvolutionState();
var job = new Job();
var ind = new FloatVectorIndividual {
Fitness = new SimpleFitness()
};
var genome = new float[1] {
1.1f
};
ind.Genome = genome;
job.Inds = new Individual[] { ind };
job.CopyIndividualsForward();
var newFit = new SimpleFitness {
Trials = new List <double>(10)
};
for (var i = 0; i < 10; i++)
{
newFit.Trials.Add(i * 100.0);
}
newFit.SetFitness(state, float.MaxValue, true);
job.NewInds[0].Fitness = newFit;
job.CopyIndividualsBack(state);
Assert.IsTrue(job.Inds[0].Fitness.Value == newFit.Value); // Fitness has been updated
for (var i = 0; i < job.Inds[0].Fitness.Trials.Count; i++)
{
Assert.AreEqual(job.Inds[0].Fitness.Trials[i], i * 100.0); // Trials have been merged into original instance
}
}
public RandomStrategy(IRandomNumber randomNumber, SimpleFitness fitness)
: base(fitness)
{
if (randomNumber == null) throw new ArgumentNullException("randomNumber");
if (fitness == null) throw new ArgumentNullException("fitness");
_randomNumber = randomNumber;
}
public void Fitness_Default_To_One()
{
var fitness = new SimpleFitness();
var res = fitness.GetFitness();
Assert.Equal(1, res);
}
public void Fitness_Zero_After_One_Wrong_Prediction()
{
var fitness = new SimpleFitness();
fitness.LogOpponentMove(Moves.Rock, Moves.Paper);
var res = fitness.GetFitness();
Assert.Equal(0, res);
}
public void Fitness_Fifty_After_One_Wrong_And_One_Right_Prediction()
{
var fitness = new SimpleFitness();
fitness.LogOpponentMove(Moves.Rock, Moves.Paper);
fitness.LogOpponentMove(Moves.Scissors, Moves.Scissors);
var res = fitness.GetFitness();
Assert.Equal(.50, res);
}
public void Evaluate(IEvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
if (_ca == null)
{
_ca = new CA(CA_WIDTH, NEIGHBORHOOD);
}
// we always reevaluate
//if (!ind.evaluated) // don't bother reevaluating
{
MajorityData input = (MajorityData)(this.Input);
int sum = 0;
// extract the rule
((GPIndividual)ind).Trees[0].Child.Eval(
state, threadnum, input, Stack, (GPIndividual)ind, this);
int[] rule = _ca.GetRule();
for (int i = 0; i < 64; i++)
{
rule[i] = (int)(((input.Data0) >> i) & 0x1);
}
for (int i = 64; i < 128; i++)
{
rule[i] = (int)(((input.Data1) >> (i - 64)) & 0x1);
}
_ca.SetRule(rule); // for good measure though it doesn't matter
for (int i = 0; i < NUM_TRIALS; i++)
{
// set up and run the CA
_ca.SetVals(_trials[i]);
_ca.Step(STEPS, true);
// extract the fitness
if (All(_ca.GetVals(), _majorities[i]))
{
sum++;
}
}
SimpleFitness f = (SimpleFitness)ind.Fitness;
f.SetFitness(state, sum / (double)NUM_TRIALS, sum == NUM_TRIALS);
ind.Evaluated = true;
}
}
public void Evaluate(
IEvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
if (!ind.Evaluated)
{
double score = Fitness(((GPIndividual)ind).Trees[0].Child);
SimpleFitness f = (SimpleFitness)ind.Fitness;
f.SetFitness(state, (float)score, score == 1.0);
ind.Evaluated = true;
}
}
public void ShortVectorIndividualWriteAndRead()
{
// First we'll set up a Fitness for the Individual
var rand = new MersenneTwisterFast(0);
var f = new SimpleFitness();
f.SetFitness(null, float.MaxValue, true);
const int n = 10;
f.Trials = new List <double>(n);
for (var i = 0; i < n; i++)
{
f.Trials.Add(rand.NextDouble());
}
// Now we can create and initialize the Individual
var ind = new ShortVectorIndividual();
var ind2 = new ShortVectorIndividual(); // We'll read back into this instance
ind.Genome = new short[10]; // This is the set of genes
for (var i = 0; i < 10; i++)
{
ind.genome[i] = (short)rand.NextInt(short.MaxValue); // Some random genes
}
ind.Fitness = f;
ind.Evaluated = true;
using (var ms = new MemoryStream())
{
var writer = new BinaryWriter(ms);
ind.WriteIndividual(null, writer);
ms.Position = 0;
var reader = new BinaryReader(ms);
ind2.Fitness = new SimpleFitness();
ind2.ReadIndividual(null, reader);
Assert.IsTrue(ind.Fitness.EquivalentTo(ind2.Fitness));
Assert.IsTrue(ind2.Fitness.IsIdeal);
Assert.IsTrue(ind.Equals(ind2)); // Genetically equivalent
for (var i = 0; i < 10; i++)
{
Assert.AreEqual(ind.genome[i], ind2.genome[i]); // check each gene
}
}
}
public void Evaluate(IEvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
if (!ind.Evaluated) // don't bother reevaluating
{
// trees[0].child is the root
_fitness = 0.0;
NodeCal(((GPIndividual)ind).Trees[0].Child, state);
SimpleFitness f = (SimpleFitness)ind.Fitness;
f.SetFitness(state, _fitness, false);
ind.Evaluated = true;
}
}
public void Evaluate(IEvolutionState state,
Individual ind,
int subpopulation,
int threadnum)
{
if (_ca == null)
{
_ca = new CA(CA_WIDTH, NEIGHBORHOOD);
}
// we always reevaluate
//if (!ind.evaluated) // don't bother reevaluating
{
int sum = 0;
bool[] genome = ((BitVectorIndividual)ind).genome;
// extract the rule
int[] rule = _ca.GetRule();
for (int i = 0; i < 128; i++)
{
rule[i] = (genome[i] ? 1 : 0);
}
_ca.SetRule(rule); // for good measure though it doesn't matter
for (int i = 0; i < NUM_TRIALS; i++)
{
// set up and run the CA
_ca.SetVals(_trials[i]);
_ca.Step(STEPS, true);
// extract the fitness
if (All(_ca.GetVals(), _majorities[i]))
{
sum++;
}
}
SimpleFitness f = (SimpleFitness)ind.Fitness;
f.SetFitness(state, sum / (double)NUM_TRIALS, false);
ind.Evaluated = true;
}
}
protected RuleStrategyBase(int antecedentCount, SimpleFitness fitness)
: base(fitness)
{
AntecedentCount = antecedentCount;
Table = new RuleTable(antecedentCount);
}
public OpponentRulesStrategy(int opponentMovesToTrack, SimpleFitness fitness)
: base(opponentMovesToTrack, fitness)
{
}
public MyRulesStrategy(int myMovesToTrack, SimpleFitness fitness)
: base(myMovesToTrack, fitness)
{
}
