void DebugGetFitness(Genetic genetic)
{
(double score, string scores) = genetic.GetFitness();
GD.Print(score);
GD.Print("======");
//GD.Print(scores);
}
public GeneticParams GetParams(Genetic gen)
{
var hist = gen.History.ToArray();
if (hist.Length > 1)
{
var varietyHist = hist.Select(gs => gs.Variety).ToArray();
var lastVariety = varietyHist.Last();
if (VarietyTooLow(lastVariety))
{
if (varietyHist[hist.Length - 2] >= varietyHist[hist.Length - 1]) //Variety is falling
{
var ctLtDesired = varietyHist.Reverse().TakeWhile(VarietyTooLow).Count(); //Number of iterations variety has been < desired
MutationFraction *= (float)Math.Pow(1 + BaseChangeFrac, ctLtDesired);
}
}
else if (VarietyTooHigh(lastVariety))
{
if (varietyHist[hist.Length - 2] <= varietyHist[hist.Length - 1]) //Variety is rising
{
var ctGtDesired = varietyHist.Reverse().TakeWhile(VarietyTooHigh).Count(); //Number of iterations variety has been > desired
MutationFraction *= (float)Math.Pow(1 - BaseChangeFrac, ctGtDesired);
}
}
}
return(new GeneticParams(EletismFraction, MutationFraction));
}
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 StartGenetic(Grid gameGrid)
{
List <Unit> emptyPlaces = GetEmptyPlaces();
Genetic gen = new Genetic(units: emptyPlaces, size: fillSize);
SetFillominoGrid();
}
void Awake()
{
signalControl = new ControlSignal();
path = "Save/DroneSession/" + "Task-" + task + "/Seed-" + fromSeed + "/";
rndGenerator = new SystemRandomSource(fromSeed);
taskObject = (DroneTask)Activator.CreateInstance(Type.GetType("Lexmou.MachineLearning.Drone" + task), rndGenerator, task);
mlp = new MultiLayerMathsNet(fromSeed, null, taskObject.shapes, 1, 0);
float[] floatArr = new float[taskObject.individualSize];
//float[] floatArr = new float[] {0,-0.33f,0,0,-0.33f,0,0,0,0,0,0.5f,0,0,-1,0,0,-1,0,0,0.5f,0,1,0,0,0,0,0,0,0,0,0,-1,0,0,0,0,0,0,0,0.5f};
Genetic.LoadBest(path, fromGeneration, floatArr);
BuildCustomWeights(mlp.weights, taskObject.shapes, Vector <float> .Build.DenseOfArray(floatArr));
//Debug.Log(mlp.weights[0]);
/*if (stabilizationGeneration != 0)
* {
* Debug.Log("Gene Move");
* gene = new Genetic(stabilizationSeed, null, 100, 40, 1.0f, 0.1f, 0.1f, 0.1f, 0.1f, "Save/DroneSession/Task-stabilization/", false);
* }
* if (moveGeneration != 0)
* {
* Debug.Log("Gene Move");
* gene = new Genetic(moveSeed, null, 100, 52, 1.0f, 0.1f, 0.1f, 0.1f, 0.1f, "Save/DroneSession/Task-move/", false);
* }
* deltaDistribution = new ContinuousUniform(-2, 2);
* tmpBuildCustomWeights = new List<Matrix<float>>();*/
Restart();
}
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);
}
public override void Build()
{
if (save)
{
writerEnv = UIO.CreateStreamWriter(GeneratePath(task, true), "GeneSessionResults.csv", false);
UIO.WriteLine(writerEnv, "Generation;Angle Random Rotation;Wind");
}
Debug.Log("Build DroneSession");
signal = new ControlSignal();
tsignal = new ThrustSignal();
tmpBuildCustomWeights = new List <Matrix <float> >();
externalEvaluations = Vector <float> .Build.Dense(populationSize);
//Debug.Log(fromTask);
taskObject = (DroneTask)Activator.CreateInstance(Type.GetType("Lexmou.MachineLearning.Drone" + task), rndGenerator, fromTask);
//Debug.Log(taskObject.fromTask);
dronePopulation = new GameObject[populationSize];
droneRigid = new Rigidbody[populationSize];
targetPosition = new Vector3[populationSize];
mlpPopulation = new MultiLayerMathsNet[populationSize];
gene = new Genetic(seed, rndGenerator, populationSize, taskObject.individualSize, initialValueWeights, mutationRate, randomIndividualsRate, bestIndividualsRate, emptyRate, GeneratePath(task, false), save);
if (loadGeneration != 0)
{
float[,] floatArr = new float[taskObject.individualSize - taskObject.rowIndex, populationSize];
Debug.Log(taskObject.fromTask);
//Debug.Log(taskObject.individualSize);
gene.LoadGeneration(GeneratePath(taskObject.fromTask, true), loadGeneration, floatArr, taskObject.rowIndex);
gene.generation = loadGeneration;
}
}
// Called when a collision happens
void OnCollisionEnter2D(Collision2D coll)
{
if (coll.gameObject.name.StartsWith("cactus"))
{
GameObject.Find("Canvas").GetComponent <Canvas> ().enabled = true;
Time.timeScale = 0;
Genome genome = new Genome {
fitness = Genetic.calculateFitness(jumps, cactus),
jumps = jumps
};
Utils.persistInJson(genome, genomeBasePath);
jumps.Clear();
if (!isLearning)
{
SceneManager.LoadScene(SceneManager.GetActiveScene().name);
Time.timeScale = 1;
Utils.actualGenome++;
}
}
else if (coll.gameObject.name.StartsWith("Ground"))
{
isGrounded = true;
}
}
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);
}
void Start()
{
columnSpawn = GetComponent <ColumnSpawn>();
InstantiateBirds();
genetic = new Genetic(numOfUnitsInGeneration, topUnitsPercentage, randomUnitsPercentage, CreateNetwork);
Restart();
}
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);
}
// Start is called before the first frame update
void Awake()
{
annualGrowth = new Vector3(annualWidthGrowth, annualLengthGrowth, annualWidthGrowth);
setup = GameObject.Find("Setup").GetComponent <SetupScene>();
timeManager = GameObject.Find("Time Manager").GetComponent <TimeManager>();
currentLenght = 0f;
currentWidth = 0f;
geneticInfo = new Genetic(1);
}
/// <summary>
/// Perform one training iteration.
/// </summary>
///
public override sealed void Iteration()
{
EncogLogging.Log(EncogLogging.LevelInfo,
"Performing Genetic iteration.");
PreIteration();
Genetic.Iteration();
Error = Genetic.Error;
PostIteration();
}
public void CreateNextGenerationAndKillPrevious() // Tady probíhá iterace jednotlivých generací
{
DrawBrain.Instance.HideBrain();
var newEntityBrainList = Genetic.ChildrenBrainList(Functions.EntitiesToBrainDictionary(entityList), GA_MutationRateInPercent01, globalSeed + seedIterator);
destroyAllEntities();
GenerateFromBrains(newEntityBrainList);
}
public void Regenerate()
{
netDisplayManager.ClearScreen();
net = new Net(10, 600, 400, netDisplayManager);
analyzer = new FindShortestWay4PacketInNetCromosomeAnalyzer(net.GetContainerLink());
rankingSelection = new RankingSelectionHandler();
genetic = new Genetic(rankingSelection, net.GetGeneticNodeValues(), analyzer);
}
// Tady probíhá iterace jednotlivých generací
public void NextGeneration()
{
// Get the average fitness
PrintGenerationInfo();
var newEntityBrainList = Genetic.ChildrenBrainList(Functions.EntitiesToBrainDictionary(entityList),
GA_MutationRateInPercent01, globalSeed + seedIterator);
CleanScene();
GenerateFromBrains(newEntityBrainList);
}
public void SetUp()
{
seed = 65;
geneSeed = new Genetic(seed, null, 2, 10, initialValueWeights, 0.1f, 0.05f, 0.05f, 0, "", false);
initialValueWeights = 1.0f;
//Debug.Log(geneSeed.ToString());
//System.Threading.Thread.Sleep(10000);
SystemRandomSource rndGenerator = new SystemRandomSource(seed);
geneRndGenerator = new Genetic(seed, rndGenerator, 2, 10, initialValueWeights, 0.1f, 0.05f, 0.05f, 0, "", false);
}
public void GenerateParentTest()
{
int FitnessFun(IReadOnlyList <int> guess) => 86;
var geneSet = new[] { 1, 3, 5, 7, 9 };
var parent = Genetic <int, int> .GenerateParent(10, geneSet, FitnessFun);
Assert.IsInstanceOfType(parent, typeof(Chromosome <int, int>));
Assert.AreEqual(86, parent.Fitness);
Assert.IsTrue(geneSet.All(c => parent.Genes.Contains(c)));
}
public void MutateTest()
{
int FitnessFun(IReadOnlyList <int> guess) => 86;
var geneSet = new[] { 0, 1, 2, 3, 4, 5, 6, 7 };
var genes = new[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
var parent = new Chromosome <int, int>(genes, 0);
var child = Genetic <int, int> .Mutate(parent, geneSet, FitnessFun);
Assert.IsTrue(parent.Genes.All(x => x == 0));
Assert.IsFalse(child.Genes.All(x => x == 0));
}
public static void Genetic()
{
Func <List <bool>, double> score = list => (list[0] == true ? 1 : 0) + (list[1] == false ? 1 : 0);
var gene = new Genetic(
100,
7,
score);
Console.WriteLine(
String.Join(",", gene.NaturalSelection().Select(a => a.ToString())));
}
public static void Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("You need to give file path to data!");
return;
}
String filePath = "";
if (args.Length > 0)
{
filePath = args[0];
}
Graph.Graph graph = new Graph.Graph();
ReadData.Read(filePath, graph);
Place startPlace;
if (args.Length == 2)
{
startPlace = graph.ChosenPlaces.Find(item => item.Id.Equals(args[1]));
if (startPlace == null)
{
Console.WriteLine("You cannot choose start place that not exist");
return;
}
}
else
{
startPlace = graph.ChosenPlaces[0];
}
Finder.IFinder finder;
if (graph.ChosenPlaces.Count > 10)
{
finder = new Genetic(2000, 1000, graph);
}
else
{
finder = new Permutation(graph);
}
Path.Path?path = finder.FindPath(startPlace);
if (path != null)
{
SaveFile.Save(graph, path);
Console.WriteLine("Check the result");
}
else
{
Console.WriteLine("Path do not exist");
}
}
static public void RunParameterTest(Cities cities, int time, int populationSize, int matingPoolSize,
int tournamentSize, int mutationProbability, int mutationType,
string path)
{
float bestDistance = (float)cities.BestDistance;
float distance = (float)Genetic.AnalyzeWeight(cities, time, populationSize, matingPoolSize, tournamentSize, mutationProbability, mutationType);
string relativeError = (((distance - bestDistance) / bestDistance) * 100.0f).ToString();
path += cities.AdjacencyMatrix.GetLength(0) + "_Genetic_" + time + "s_" + populationSize + "os_" + matingPoolSize + "mat_" + tournamentSize +
"trnm_" + mutationProbability + "%_" + (mutationType == 0 ? "invert" : "swap") + ".txt";
WriteOutputToFile(path, relativeError);
}
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);
}
public static Genetic GetRandomizedGene()
{
Genetic genetic = new Genetic();
genetic.sex = (byte)UnityEngine.Random.Range(0, 2);
genetic.vision = (byte)UnityEngine.Random.Range(0, GeneticDataManager.Instance.vision.Length);
genetic.speed = (byte)UnityEngine.Random.Range(0, GeneticDataManager.Instance.speed.Length);
genetic.fertility = (byte)UnityEngine.Random.Range(0, GeneticDataManager.Instance.fertility.Length);
genetic.memory = (byte)UnityEngine.Random.Range(0, GeneticDataManager.Instance.memory.Length);
genetic.scale = (byte)UnityEngine.Random.Range(0, GeneticDataManager.Instance.scale.Length);
return(genetic);
}
private void GeneratePopulation(bool isFirst = false)
{
Generation++;
if (isFirst /* || (!isFirst && GameObject.FindObjectOfType<UIManager>().bestFitLocal == 0) */)
{
for (int i = 0; i < CellsStartCount; i++)
{
var neuralNetwork = new NeuralNetwork(5, 2, new int[] { 5, 4 }, 4);
neuralNetwork.InitializeWeight();
AddCell().Initialize(neuralNetwork);
}
}
else
{
IEnumerable <KeyValuePair <NeuralNetwork, float> > arr = dictionary.OrderByDescending(t => t.Value);
var arr2 = arr.ToList();
arr2.RemoveRange(CellsSelectionCount, arr2.Count - CellsSelectionCount);
List <NeuralNetwork> neuralNetworks = new List <NeuralNetwork>();
foreach (var x in arr2)
{
neuralNetworks.Add(x.Key);
}
for (int i = 0; i < neuralNetworks.Count; i++)
{
for (int j = 0; j < neuralNetworks.Count; j++)
{
NeuralNetwork child = Genetic.CrossOver(neuralNetworks[i], neuralNetworks[j]);
var save = child.Save();
Genetic.Mutate(ref save.dna);
child = new NeuralNetwork(save);
AddCell().Initialize(child);
}
}
dictionary.Clear();
for (int i = 0; i < CellsToDestroy.Count; i++)
{
Destroy(CellsToDestroy[i].gameObject);
}
CellsToDestroy.Clear();
}
GameObject.FindObjectOfType <UIManager>().resetBestFitLocal();
}
static void Main(string[] args)
{
var prop = new ArifmeticProperty();
var generic = new Genetic <Arifmetic>(1000);
generic.SetProperties(new Arifmetic(1, 2, 3, 4), prop);
Console.WriteLine("for first iteration {0}", generic.GetAge(1).GetMeasure);
var res = generic.GetAge(100);
Console.WriteLine("for result {0}", res.GetMeasure);
Console.WriteLine("Hello World!");
Console.ReadLine();
}
private void Form1_Load(object sender, EventArgs e)
{
genetic = new Genetic(7);
double max = genetic.LivingCycle(FitnessFunc);
for (int i = 0; i < 10000; i++)
{
var a = genetic.LivingCycle(FitnessFunc);
if (max < a)
{
max = a;
}
}
MessageBox.Show("" + Math.Round(max, 4));
}
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);
}
public void TestGenetic()
{
genetic = new Genetic();
genetic.graph = graph;
genetic.GenerateChromosomes(100);
genetic.mutationRate = (int)0.047 * genetic.chromosomes.Count;
genetic.crossingRate = genetic.chromosomes.Count;
foreach (var v in genetic.GeneticOptimization(100))
{
System.Diagnostics.Debug.Write(v.index + " ");
}
System.Diagnostics.Debug.WriteLine($"{genetic.chromosomes[0].genes[0].index}\n Distance: {genetic.chromosomes[0].rating}");
}
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);
}
static void Main(string[] args)
{
using (var p = Process.GetCurrentProcess())
p.PriorityClass = ProcessPriorityClass.High;
Genetic []g = new Genetic[21];
for (int i = 0; i < 21; i++)
{
g[i] = MakeGenetic();
}
g[0].MutationPercentage = 0.1f;
g[2].MutationPercentage = 0.3f;
g[3].MutationPercentage = 0.4f;
g[4].CrossPercentage = 0.1f;
g[5].CrossPercentage = 0.2f;
g[6].CrossPercentage = 0.3f;
g[7].CrossPercentage = 0.4f;
g[8].SelectionPercentage = 0.3f;
g[9].SelectionPercentage = 0.4f;
g[10].SelectionPercentage = 0.5f;
g[11].SelectionPercentage = 0.6f;
g[12].SelectionPercentage = 0.7f;
g[13].EntityCount = 300;
g[14].EntityCount = 600;
g[15].EntityCount = 900;
g[16].EntityCount = 1200;
g[17].IterationCount = 100;
g[18].IterationCount = 200;
g[19].IterationCount = 300;
g[20].IterationCount = 400;
var algorithms = new List<Algorithm>
{
//new BBRecursiveBruteforce(),
//new Heurestic(),
//new CostDecomposition(),
/*new CostFPTAS(0.04),
new CostFPTAS(0.1),
new CostFPTAS(0.125),
new CostFPTAS(0.175),*/
//new CostFPTAS(0.225),
/*new CostFPTAS(0.275),
new CostFPTAS(0.325),
new CostFPTAS(0.375),*/
//new IterativeBruteforce(),
//new RecursiveBruteforce(),
};
/*for (int i = 0; i < 21; i++)
{
algorithms.Add(g[i]);
}*/
algorithms.Add(g[16]);
algorithms.Add(g[17]);
// Preheat(algorithms);
RunTests(algorithms);
//RunGeneratedTests(algorithms);
Console.WriteLine("[DONE] Press any key to exit.");
Console.ReadKey();
}
