private static void Solve(string[] operations, Dictionary <string, OperationDelegate> prioritizedOperations,
List <string> optimalLengthSolution)
{
var numbers = new List <string> {
"1", "2", "3", "4", "5", "6", "7"
};
var expectedTotal = Evaluate(optimalLengthSolution, prioritizedOperations);
var minNumbers = (1 + optimalLengthSolution.Count) / 2;
var maxNumbers = 6 * minNumbers;
var watch = Stopwatch.StartNew();
void FnDisplay(Chromosome <string, int> candidate) =>
Display(candidate, watch);
int FnEvaluate(IReadOnlyList <string> genes) =>
Evaluate(genes, prioritizedOperations);
int FnGetFitness(IReadOnlyList <string> genes) =>
GetFitness(genes, expectedTotal, FnEvaluate);
List <string> FnCreate() =>
Create(numbers, operations, minNumbers, maxNumbers);
void FnMutate(List <string> child) =>
Mutate(child, numbers, operations, minNumbers, maxNumbers, FnGetFitness);
var optimalFitness = FnGetFitness(optimalLengthSolution);
var best = Genetic <string, int> .GetBest(FnGetFitness, 0, optimalFitness, null, FnDisplay, FnMutate, FnCreate, 50);
Assert.IsTrue(optimalFitness.CompareTo(best.Fitness) <= 0);
}
private static void Color(string file, string[] colors)
{
var data = LoadData(file);
var rules = data.Item1;
var nodes = data.Item2;
var optimalValue = rules.Count;
var colorLookup = colors.ToDictionary(k => k[0], v => v);
var geneSet = colorLookup.Keys.ToArray();
var watch = Stopwatch.StartNew();
var count = 0;
var nodeIndexLookup = nodes.OrderBy(s => s).ToDictionary(k => k, v => count++);
void FnDisplay(Chromosome <char, int> candidate) => Display(candidate, watch);
int FnGetFitness(IReadOnlyList <char> genes) => GetFitness(genes, rules, nodeIndexLookup);
var best = Genetic <char, int> .GetBest(FnGetFitness, nodes.Count, optimalValue, geneSet, FnDisplay);
Assert.IsTrue(optimalValue.CompareTo(best.Fitness) <= 0);
var keys = nodes.OrderBy(c => c).ToArray();
for (var index = 0; index < nodes.Count; index++)
{
Console.WriteLine("{0} is {1}", keys[index], colorLookup[best.Genes[index]]);
}
}
public void SudokuTest()
{
var geneSet = Enumerable.Range(1, 9).ToArray();
var watch = Stopwatch.StartNew();
var optimalValue = 100;
void FnDisplay(Chromosome <int, int> candidate) =>
Display(candidate, watch);
var validationRules = BuildValidationRules();
int FnGetFitness(IReadOnlyList <int> genes) =>
GetFitness(genes, validationRules);
List <int> FnCreate() =>
Rand.RandomSample(geneSet, 81);
void FnMutate(List <int> genes) =>
Mutate(genes, validationRules);
var best = Genetic <int, int> .GetBest(FnGetFitness, 0, optimalValue, null, FnDisplay, FnMutate, FnCreate,
50);
Assert.AreEqual(optimalValue, best.Fitness);
}
private static Chromosome <string, Fitness> FindRegex(string[] wanted, string[] unwanted, int expectedLength,
FnMutateDelegate[] customOperators = null)
{
var watch = Stopwatch.StartNew();
// var set = new HashSet<char>(wanted.SelectMany(mo => mo.ToCharArray()));
var set = wanted.SelectMany(s => s.ToCharArray()).Distinct().Select(cp => cp.ToString());
var textGenes = wanted.ToList().Concat(set).ToArray();
var fullGeneSet = AllMetas.Concat(textGenes).ToArray();
void FnDisplay(Chromosome <string, Fitness> candidate, int?length) =>
Display(candidate, watch);
Fitness FnGetFitness(List <string> genes) =>
GetFitness(genes, wanted.ToList(), unwanted.ToList());
var mutationRoundCounts = new List <int> {
1
};
var mutationOperators = new List <FnMutateDelegate>
{
genes => MutateAdd(genes, fullGeneSet),
genes => MutateReplace(genes, fullGeneSet),
MutateRemove,
MutateSwap,
MutateMove,
};
if (customOperators != null)
{
mutationOperators.AddRange(customOperators);
}
void FnMutate(List <string> genes) => Mutate(genes, FnGetFitness, mutationOperators, mutationRoundCounts);
var optimalFitness = new Fitness(wanted.Length, wanted.Length, 0, expectedLength);
var best = Genetic <string, Fitness> .GetBest(FnGetFitness, textGenes.Max(i => i.Length), optimalFitness,
fullGeneSet, FnDisplay, FnMutate, null, null, 10);
Assert.IsTrue(optimalFitness.CompareTo(best.Fitness) <= 0);
if (!RegexErrorsSeen.Any())
{
return(best);
}
Console.WriteLine();
Console.WriteLine("Errors:");
foreach (var error in RegexErrorsSeen)
{
Console.WriteLine(" {0}", error.Message);
}
return(best);
}
private static void Test(int size)
{
var geneSet = Enumerable.Range(0, size).ToArray();
var watch = Stopwatch.StartNew();
void DisplayFun(Chromosome <int, Fitness> candidate) => Display(candidate, watch, geneSet.Length);
Fitness FitnessFun(IReadOnlyList <int> genes) => Fitness(genes, size);
var optimalFitness = new Fitness(0);
var best = Genetic <int, Fitness> .GetBest(FitnessFun, 2 *size, optimalFitness, geneSet, DisplayFun);
Assert.IsTrue(optimalFitness.CompareTo(best.Fitness) <= 0);
}
private static void FillKnapsack(IReadOnlyCollection <Resource> items, double maxWeight,
double maxVolume, Fitness optimalFitness)
{
var watch = Stopwatch.StartNew();
var window = new Window(1, Math.Max(1, items.Count / 3), items.Count / 2);
var sortedItems = items.OrderBy(i => i.Value).ToList();
void FnDisplay(Chromosome <ItemQuantity, Fitness> candidate) => Display(candidate, watch);
Fitness FnGetFitness(IReadOnlyList <ItemQuantity> genes) => GetFitness(genes);
List <ItemQuantity> FnCreate() => Create(items, maxWeight, maxVolume);
void FnMutate(List <ItemQuantity> genes) => Mutate(genes, sortedItems, maxWeight, maxVolume, window);
var best = Genetic <ItemQuantity, Fitness> .GetBest(FnGetFitness, 0, optimalFitness, null, FnDisplay, FnMutate, FnCreate, 50);
Assert.IsTrue(optimalFitness.CompareTo(best.Fitness) <= 0);
}
private static void RunWith(FnCreateGeneDelegate[] geneSet, int width, int height, int minGenes, int maxGenes,
int expectedNumberOfInstructions, int maxMutationRounds, FnCreateFieldDelegate fnCreateField,
int expectedNumberOfSteps)
{
var mowerStartLocation = new Location(width / 2, height / 2);
var mowerStartDirection = Directions.South;
List <INode> FnCreate() =>
Create(geneSet, 1, height);
Tuple <Field, Mower, Program> FnEvaluate(IReadOnlyList <INode> instructions)
{
var program = new Program(instructions);
var mower = new Mower(mowerStartLocation, mowerStartDirection);
var field = fnCreateField();
try
{
program.Evaluate(mower, field, 0);
}
catch (Exception)
{
// pass
}
return(new Tuple <Field, Mower, Program>(field, mower, program));
}
Fitness FnGetFitness(IReadOnlyList <INode> genes) =>
GetFitness(genes, FnEvaluate);
var watch = Stopwatch.StartNew();
void FnDisplay(Chromosome <INode, Fitness> candidate) =>
Display(candidate, watch, FnEvaluate);
void FnMutate(List <INode> child) =>
Mutate(child, geneSet, minGenes, maxGenes, FnGetFitness, maxMutationRounds);
var optimalFitness = new Fitness(width * height, expectedNumberOfInstructions, expectedNumberOfSteps);
var best = Genetic <INode, Fitness> .GetBest(FnGetFitness, 0, optimalFitness, null, FnDisplay, FnMutate,
FnCreate, null, 10, Crossover);
Assert.IsTrue(optimalFitness.CompareTo(best.Fitness) <= 0);
}
private static void SolveUnknown(int numUnknowns, Fraction[] geneSet, FnEquationDelegate[] equations,
FnGenesToImputsDelegate fnGenesToImputs)
{
var watch = Stopwatch.StartNew();
var maxAge = 50;
var window = new Window(Math.Max(1, geneSet.Length / (2 * maxAge)),
Math.Max(1, geneSet.Length / 3),
geneSet.Length / 2);
var geneIndexes = Enumerable.Range(0, numUnknowns).ToArray();
var sortedGeneSet = geneSet.OrderBy(gene => gene).ToList();
void FnDispaly(Chromosome <Fraction, Fitness> candidate) => Display(candidate, watch, fnGenesToImputs);
Fitness FnGetFitness(IReadOnlyList <Fraction> genes) => GetFitness(genes, equations);
void FnMutate(List <Fraction> genes) => Mutate(genes, sortedGeneSet, window, geneIndexes);
var optimalFitness = new Fitness(new Fraction(0));
var best = Genetic <Fraction, Fitness> .GetBest(FnGetFitness, numUnknowns, optimalFitness, geneSet, FnDispaly, FnMutate,
null, maxAge);
Assert.IsTrue(optimalFitness.CompareTo(best.Fitness) <= 0);
Assert.AreEqual(0.0, (float)best.Fitness.TotalDifference, 0.0001);
}
