public static void BreedingSelf(GraphicsDevice g, GameWindow w)
{
const int TEST_SIZE = 500;
Random r = new Random();
var results = new List <float>(1024);
Console.WriteLine("start opt test");
for (int i = 0; i < TEST_SIZE; i++)
{
Console.WriteLine(i);
var treeA = AptNode.GenerateTree(r.Next(1, 20), r, true);
var childTree = treeA.BreedWith(treeA, r, true);
var machine = new StackMachine(childTree);
var stack = new float[machine.nodeCount];
for (float y = -1.0f; y <= 1.0f; y += .005f)
{
for (float x = -1.0f; x <= 1.0f; x += .005f)
{
results.Add(machine.Execute(x, y, stack));
}
}
Console.WriteLine("result[2]" + results[2]);
results.Clear();
}
Console.WriteLine("done breed test");
}
public static float Evaluate(AptNode node, float x, float y, float t)
{
StackMachine m = new StackMachine(node);
var stack = new float[m.nodeCount];
return(m.Execute(x, y, t, stack));
}
public void Optimize()
{
for (int i = 0; i < Trees.Length; i++)
{
Trees[i] = AptNode.ConstantFolding(Trees[i]);
Machines[i] = new StackMachine(Trees[i]);
}
}
public static void Optimizing(GraphicsDevice g, GameWindow w)
{
const int TEST_SIZE = 10000;
Random r = new Random();
Console.WriteLine("start opt test");
for (int i = 0; i < TEST_SIZE; i++)
{
Console.WriteLine(i);
var tree = AptNode.GenerateTree(r.Next(1, 20), r, true);
var machine = new StackMachine(tree);
var optTree = AptNode.ConstantFolding(tree);
var optMachine = new StackMachine(optTree);
var stack = new float[machine.nodeCount];
var optStack = new float[optMachine.nodeCount];
for (float y = -1.0f; y <= 1.0f; y += .01f)
{
for (float x = -1.0f; x <= 1.0f; x += .01f)
{
float result = machine.Execute(x, y, stack);
float optResult = optMachine.Execute(x, y, optStack);
if (Math.Abs(optResult - result) > .01f)
{
Console.WriteLine("result:" + result);
Console.WriteLine("optResult:" + optResult);
Console.WriteLine("x:" + x + "y:" + y);
Console.WriteLine("--- tree --");
Console.WriteLine(tree.ToLisp());
Console.WriteLine("--- optTree --");
Console.WriteLine(optTree.ToLisp());
throw new Exception("opt fail");
}
}
}
}
Console.WriteLine("done opt test");
}
public Pic(PicType type, Random rand, int min, int max, GraphicsDevice g, GameWindow w, bool video, GameState state)
{
this.video = video;
SharedConstructor(type, g, w, state);
for (int i = 0; i < Trees.Length; i++)
{
Trees[i] = AptNode.GenerateTree(rand.Next(min, max), rand, video);
Machines[i] = new StackMachine(Trees[i]);
}
if (type == PicType.GRADIENT)
{
var enum_size = Enum.GetNames(typeof(GradientType)).Length;
var gradType = (GradientType)rand.Next(0, enum_size);
float[] hues;
switch (gradType)
{
case GradientType.ANALOGOUS:
{
hues = new float[3];
(hues[0], hues[1], hues[2]) = GetAnalogousHues((float)rand.NextDouble());
break;
}
case GradientType.COMPLEMENTARY:
{
hues = new float[2];
(hues[0], hues[1]) = GetComplementaryHues((float)rand.NextDouble());
break;
}
case GradientType.SPLIT_COMPLEMENTARY:
{
hues = new float[3];
(hues[0], hues[1], hues[2]) = GetSplitComplementaryHues((float)rand.NextDouble());
break;
}
case GradientType.SQUARE:
{
hues = new float[4];
(hues[0], hues[1], hues[2], hues[3]) = GetSquareHues((float)rand.NextDouble());
break;
}
case GradientType.TETRADIC:
{
hues = new float[4];
(hues[0], hues[1], hues[2], hues[3]) = GetTetradicHues((float)rand.NextDouble());
break;
}
case GradientType.TRIADIC:
{
hues = new float[3];
(hues[0], hues[1], hues[2]) = GetTriadicHues((float)rand.NextDouble());
break;
}
case GradientType.RANDOM:
{
hues = new float[rand.Next(Settings.MIN_GRADIENTS, Settings.MAX_GRADIENTS)];
for (int i = 0; i < hues.Length; i++)
{
hues[i] = (float)rand.NextDouble();
}
break;
}
case GradientType.DOUBLE_COMPLEMENT:
{
hues = new float[4];
(hues[0], hues[1], hues[2], hues[3]) = GetTetradicHues((float)rand.NextDouble());
break;
}
case GradientType.DIAD:
{
hues = new float[2];
(hues[0], hues[1]) = GetComplementaryHues((float)rand.NextDouble());
break;
}
default:
throw new Exception("hues broke");
}
colors = hues.SelectF(h =>
{
float s = (float)rand.NextDouble();
float v = (float)rand.NextDouble();
var(red, green, blue) = HSV2RGB(h, s, v);
return(new Color(red, green, blue));
});
pos = new float[colors.Length];
int chance = Settings.STOP_GRADIENT_CHANCE * pos.Length;
for (int i = 0; i < colors.Length; i++)
{
if (i > 0 && rand.Next(0, chance) == 0)
{
pos[i] = pos[i - 1];
}
else
{
pos[i] = (float)(rand.NextDouble() * 2.0 - 1.0);
}
}
Array.Sort(pos);
}
SetupTextbox();
}
public Pic BreedWith(Pic partner, Random r, GameState state)
{
var result = Clone(state);
var partnerClone = partner.Clone(state);
if (result.type != partner.type && r.Next(0, Settings.CROSSOVER_ROOT_CHANCE) == 0)
{
//Not gradient -> gradient
if (partner.type == PicType.GRADIENT)
{
result.pos = new float[partner.pos.Length];
Array.Copy(partner.pos, result.pos, partner.pos.Length);
result.colors = new Color[partner.colors.Length];
Array.Copy(partner.colors, result.colors, partner.colors.Length);
var newMachines = new StackMachine[1];
var newTrees = new AptNode[1];
var(tree, machine) = result.GetRandomTree(r);
newTrees[0] = tree.Clone();
newMachines[0] = new StackMachine(newTrees[0]);
result.Machines = newMachines;
result.Trees = newTrees;
}
//Gradient -> not gradient
else if (result.type == PicType.GRADIENT)
{
result.pos = null;
result.colors = null;
var newMachines = new StackMachine[3];
var newTrees = new AptNode[3];
var i = r.Next(0, newTrees.Length);
newTrees[i] = result.Trees[0].Clone();
newMachines[i] = new StackMachine(newTrees[i]);
for (i = 0; i < newTrees.Length; i++)
{
if (newTrees[i] == null)
{
newTrees[i] = AptNode.GetRandomLeaf(r, video);
newMachines[i] = new StackMachine(newTrees[i]);
}
}
result.Trees = newTrees;
result.Machines = newMachines;
}
result.type = partner.type;
return(result);
}
else
{
var(ft, fs) = result.GetRandomTree(r);
var(st, ss) = partnerClone.GetRandomTree(r);
var rootBred = ft.BreedWith(st, r, video);
if (rootBred != null)
{
for (int i = 0; i < result.Trees.Length; i++)
{
if (result.Trees[i] == ft)
{
result.Trees[i] = rootBred;
}
}
}
return(result);
}
}
