public void Eval(String start, String expect)
{
EncogProgramContext context = new EncogProgramContext();
StandardExtensions.CreateNumericOperators(context);
PrgPopulation pop = new PrgPopulation(context, 1);
ICalculateScore score = new ZeroEvalScoreFunction();
TrainEA genetic = new TrainEA(pop, score);
genetic.ValidationMode = true;
genetic.CODEC = new PrgCODEC();
genetic.AddOperation(0.95, new SubtreeCrossover());
genetic.AddOperation(0.05, new SubtreeMutation(context, 4));
genetic.AddScoreAdjuster(new ComplexityAdjustedScore());
genetic.Rules.AddRewriteRule(new RewriteConstants());
genetic.Rules.AddRewriteRule(new RewriteAlgebraic());
EncogProgram expression = new EncogProgram(context);
expression.CompileExpression(start);
RenderCommonExpression render = new RenderCommonExpression();
genetic.Rules.Rewrite(expression);
Assert.AreEqual(expect, render.Render(expression));
}
public double Eval(String prg1, String prg2)
{
EncogProgram expression1 = new EncogProgram(prg1);
EncogProgram expression2 = new EncogProgram(prg2);
CompareEncogProgram comp = new CompareEncogProgram();
return comp.Compare(expression1, expression2);
}
public void Test2NegAssignment()
{
EncogProgram expression = new EncogProgram("--a");
expression.Variables.SetVariable("a", 5);
Assert.AreEqual(5, expression.Evaluate().ToFloatValue(), EncogFramework.DefaultDoubleEqual);
}
public void TestAdd()
{
Assert.AreEqual(5, EncogProgram.ParseFloat("2+3"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(3, EncogProgram.ParseFloat("5+-2"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(6, EncogProgram.ParseFloat("1+2+3"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(10, EncogProgram.ParseFloat("1+2+3+4"), EncogFramework.DefaultDoubleEqual);
}
/// <inheritdoc />
public void Generate(EncogRandom rnd, IPopulation pop)
{
// prepare population
_contents.Clear();
pop.Species.Clear();
ISpecies defaultSpecies = pop.CreateSpecies();
if (Score.RequireSingleThreaded || ThreadCount == 1)
{
for (int i = 0; i < pop.PopulationSize; i++)
{
EncogProgram prg = AttemptCreateGenome(rnd, pop);
AddPopulationMember(pop, prg);
}
}
else
{
Parallel.For(0, pop.PopulationSize, i =>
{
EncogProgram prg = AttemptCreateGenome(rnd, pop);
AddPopulationMember(pop, prg);
});
}
// just pick a leader, for the default species.
defaultSpecies.Leader = defaultSpecies.Members[0];
}
public double Eval(String prg1, String prg2)
{
EncogProgram expression1 = new EncogProgram(prg1);
EncogProgram expression2 = new EncogProgram(prg2);
CompareEncogProgram comp = new CompareEncogProgram();
return comp.Compare(expression1, expression2);
}
public void TestConcat()
{
Assert.AreEqual("test:123", EncogProgram.ParseString("\"test:\"+123.0"));
Assert.AreEqual("helloworld", EncogProgram.ParseString("\"hello\"+\"world\""));
Assert.AreEqual(4, (int)EncogProgram.ParseFloat("length(\"test\")"));
Assert.AreEqual("5.22", EncogProgram.ParseString("format(5.2222,2)"));
}
/// <inheritdoc />
public IGenome Factor(IGenome other)
{
var result = new EncogProgram(_context,
new EncogProgramVariables());
result.Copy(other);
return result;
}
/// <inheritdoc />
public IGenome Factor()
{
var result = new EncogProgram(_context,
new EncogProgramVariables());
return(result);
}
public String Render(EncogProgram theHolder)
{
this.holder = theHolder;
ProgramNode node = theHolder.RootNode;
return(RenderNode(node));
}
/// <summary>
/// Create an integer numeric constant.
/// </summary>
/// <param name="prg">The program to create the constant for.</param>
/// <param name="v">The value that the constant represents.</param>
/// <returns>The newly created node.</returns>
private ProgramNode CreateNumericConst(EncogProgram prg, int v)
{
ProgramNode result = prg.Functions.FactorProgramNode("#const",
prg, new ProgramNode[] {});
result.Data[0] = new ExpressionValue(v);
return result;
}
public void testVarComplex()
{
EncogProgram expression = new EncogProgram("(x^((1+((x^-8)-(4^x)))^(((-7/2)-(0--5.8))/x)))");
expression.Variables.SetVariable("x", 10);
Assert.IsTrue(Double.IsNaN(expression.Evaluate().ToFloatValue()));
}
public void TestRenderFunction()
{
EncogProgram expression = new EncogProgram("(sin(x)+cos(x))/2");
RenderEPL render = new RenderEPL();
String result = render.Render(expression);
Assert.AreEqual("[#var:0:0][sin:1][#var:0:0][cos:1][+:2][#const:0:2][/:2]", result);
}
public void TestRenderComplex()
{
EncogProgram expression = new EncogProgram("((a+25)^3/25)-((a*3)^4/250)");
RenderEPL render = new RenderEPL();
String result = render.Render(expression);
Assert.AreEqual("[#var:0:0][#const:0:25][+:2][#const:0:3][^:2][#const:0:25][/:2][#var:0:0][#const:0:3][*:2][#const:0:4][^:2][#const:0:250][/:2][-:2]", result);
}
public void TestRenderBasic()
{
EncogProgram expression = new EncogProgram("(2+6)");
RenderEPL render = new RenderEPL();
String result = render.Render(expression);
Assert.AreEqual("[#const:0:2][#const:0:6][+:2]", result);
}
public void TestRenderFunction()
{
EncogProgram expression = new EncogProgram("(sin(x)+cos(x))/2");
RenderRPN render = new RenderRPN();
String result = render.Render(expression);
Assert.AreEqual("x [sin] x [cos] [+] 2 [/]", result);
}
/// <summary>
/// Create an integer numeric constant.
/// </summary>
/// <param name="prg">The program to create the constant for.</param>
/// <param name="v">The value that the constant represents.</param>
/// <returns>The newly created node.</returns>
private ProgramNode CreateNumericConst(EncogProgram prg, int v)
{
ProgramNode result = prg.Functions.FactorProgramNode("#const",
prg, new ProgramNode[] {});
result.Data[0] = new ExpressionValue(v);
return(result);
}
public void TestMul()
{
Assert.AreEqual(-6, EncogProgram.ParseFloat("-2*3"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(6, EncogProgram.ParseFloat("2*3"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(6, EncogProgram.ParseFloat("-2*-3"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(24, EncogProgram.ParseFloat("2*3*4"), EncogFramework.DefaultDoubleEqual);
Assert.AreEqual(120, EncogProgram.ParseFloat("2*3*4*5"), EncogFramework.DefaultDoubleEqual);
}
public void TestKnownConst()
{
EncogProgram expression = new EncogProgram("x*2*PI");
RenderRPN render = new RenderRPN();
String result = render.Render(expression);
Assert.AreEqual("x 2 [*] PI [*]", result);
}
public void TestRenderFunction()
{
EncogProgram expression = new EncogProgram("(sin(x)+cos(x))/2");
RenderCommonExpression render = new RenderCommonExpression();
String result = render.Render(expression);
Assert.AreEqual("((sin(x)+cos(x))/2)", result);
}
public void TestKnownConst()
{
EncogProgram expression = new EncogProgram("x*2*PI");
RenderCommonExpression render = new RenderCommonExpression();
String result = render.Render(expression);
Assert.AreEqual("((x*2)*PI)", result);
}
public void TestRenderBasic()
{
EncogProgram expression = new EncogProgram("(2+6)");
RenderRPN render = new RenderRPN();
String result = render.Render(expression);
Assert.AreEqual("2 6 [+]", result);
}
public void TestRenderComplex()
{
EncogProgram expression = new EncogProgram("((a+25)^3/25)-((a*3)^4/250)");
RenderRPN render = new RenderRPN();
String result = render.Render(expression);
Assert.AreEqual("a 25 [+] 3 [^] 25 [/] a 3 [*] 4 [^] 250 [/] [-]", result);
}
public void TestLogic()
{
Assert.AreEqual(true, EncogProgram.ParseBoolean("true&true"));
Assert.AreEqual(false, EncogProgram.ParseBoolean("true&false"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("true|true"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("true|false"));
Assert.AreEqual(false, EncogProgram.ParseBoolean("false|false"));
}
public void TestRenderComplex()
{
EncogProgram expression = new EncogProgram("((a+25)^3/25)-((a*3)^4/250)");
RenderCommonExpression render = new RenderCommonExpression();
String result = render.Render(expression);
Assert.AreEqual("((((a+25)^3)/25)-(((a*3)^4)/250))", result);
}
public void TestAssignment3()
{
EncogProgram expression = new EncogProgram("v1+v2+v3");
expression.Variables.SetVariable("v1", 1);
expression.Variables.SetVariable("v2", 2);
expression.Variables.SetVariable("v3", 3);
Assert.AreEqual(6, expression.Evaluate().ToFloatValue(), EncogFramework.DefaultDoubleEqual);
}
public void TestAssignment2()
{
EncogProgram expression = new EncogProgram("cccc*(aa+bbb)");
expression.Variables.SetVariable("aa", 1);
expression.Variables.SetVariable("bbb", 2);
expression.Variables.SetVariable("cccc", 3);
Assert.AreEqual(9, expression.Evaluate().ToFloatValue(), EncogFramework.DefaultDoubleEqual);
}
public void TestCrossoverOperation()
{
RenderCommonExpression render = new RenderCommonExpression();
EncogProgram prg = new EncogProgram("1+2");
EncogProgram prg2 = new EncogProgram("4+5");
ProgramNode node = prg.FindNode(2);
prg.ReplaceNode(node, prg2.RootNode);
Assert.AreEqual("(1+(4+5))", render.Render(prg));
}
/// <inheritdoc />
public IGenome Generate(EncogRandom rnd)
{
var program = new EncogProgram(_context);
IList <EPLValueType> types = new List <EPLValueType>();
types.Add(_context.Result.VariableType);
program.RootNode = CreateNode(rnd, program, DetermineMaxDepth(rnd),
types);
return(program);
}
public void TestCompare()
{
Assert.AreEqual(false, EncogProgram.ParseBoolean("3>5"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("3<5"));
Assert.AreEqual(false, EncogProgram.ParseBoolean("3=5"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("5=5"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("3<=5"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("5<=5"));
Assert.AreEqual(false, EncogProgram.ParseBoolean("3>=5"));
Assert.AreEqual(true, EncogProgram.ParseBoolean("5>=5"));
}
/// <summary>
/// Add a population member from one of the threads.
/// </summary>
/// <param name="population">The population to add to.</param>
/// <param name="prg">The program to add.</param>
public void AddPopulationMember(IPopulation population,
EncogProgram prg)
{
lock (this)
{
ISpecies defaultSpecies = population.Species[0];
prg.Species = defaultSpecies;
defaultSpecies.Add(prg);
_contents.Add(prg.DumpAsCommonExpression());
}
}
public void TestDepth()
{
EncogProgramContext context = new EncogProgramContext();
context.DefineVariable("x");
StandardExtensions.CreateAll(context);
PrgGrowGenerator rnd = new PrgGrowGenerator(context, 2);
EncogProgram prg = (EncogProgram)rnd.Generate(new EncogRandom());
RenderCommonExpression render = new RenderCommonExpression();
}
/// <inheritdoc />
public void PerformOperation(EncogRandom rnd, IGenome[] parents,
int parentIndex, IGenome[] offspring,
int offspringIndex)
{
var program = (EncogProgram)parents[0];
EncogProgramContext context = program.Context;
EncogProgram result = context.CloneProgram(program);
MutateNode(rnd, result.RootNode);
offspring[0] = result;
}
/// <inheritdoc />
public override ProgramNode CreateNode(EncogRandom rnd, EncogProgram program,
int depthRemaining, IList<EPLValueType> types)
{
int actualDepthRemaining = depthRemaining;
if (rnd.NextDouble() > 0.5)
{
return _fullGenerator.CreateNode(rnd, program,
actualDepthRemaining, types);
}
return _growGenerator.CreateNode(rnd, program,
actualDepthRemaining, types);
}
/// <summary>
/// Create a random note according to the specified paramaters.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <param name="program">The program to generate for.</param>
/// <param name="depthRemaining">The depth remaining to generate.</param>
/// <param name="types">The types to generate.</param>
/// <param name="includeTerminal">Should we include terminal nodes.</param>
/// <param name="includeFunction">Should we include function nodes.</param>
/// <returns>The generated program node.</returns>
public ProgramNode CreateRandomNode(EncogRandom rnd,
EncogProgram program, int depthRemaining,
IList<EPLValueType> types, bool includeTerminal,
bool includeFunction)
{
// if we've hit the max depth, then create a terminal nodes, so it stops
// here
if (depthRemaining == 0)
{
return CreateTerminalNode(rnd, program, types);
}
// choose which opcode set we might create the node from
IList<IProgramExtensionTemplate> opcodeSet = Context.Functions.FindOpcodes(types, Context,
includeTerminal, includeFunction);
// choose a random opcode
IProgramExtensionTemplate temp = GenerateRandomOpcode(rnd,
opcodeSet);
if (temp == null)
{
throw new EACompileError(
"Trying to generate a random opcode when no opcodes exist.");
}
// create the child nodes
int childNodeCount = temp.ChildNodeCount;
var children = new ProgramNode[childNodeCount];
if (EncogOpcodeRegistry.IsOperator(temp.NodeType) && children.Length >= 2)
{
// for an operator of size 2 or greater make sure all children are
// the same time
IList<EPLValueType> childTypes = temp.Params[0]
.DetermineArgumentTypes(types);
EPLValueType selectedType = childTypes[rnd
.Next(childTypes.Count)];
childTypes.Clear();
childTypes.Add(selectedType);
// now create the children of a common type
for (int i = 0; i < children.Length; i++)
{
children[i] = CreateNode(rnd, program, depthRemaining - 1,
childTypes);
}
}
else
{
// otherwise, let the children have their own types
for (int i = 0; i < children.Length; i++)
{
IList<EPLValueType> childTypes = temp.Params[i]
.DetermineArgumentTypes(types);
children[i] = CreateNode(rnd, program, depthRemaining - 1,
childTypes);
}
}
// now actually create the node
var result = new ProgramNode(program, temp, children);
temp.Randomize(rnd, types, result, MinConst, MaxConst);
return result;
}
/// <inheritdoc />
public IGenome Factor()
{
var result = new EncogProgram(_context,
new EncogProgramVariables());
return result;
}
/// <inheritdoc />
public abstract ProgramNode CreateNode(EncogRandom rnd, EncogProgram program, int depthRemaining,
IList<EPLValueType> types);
/// <summary>
/// Add a population member from one of the threads.
/// </summary>
/// <param name="population">The population to add to.</param>
/// <param name="prg">The program to add.</param>
public void AddPopulationMember(IPopulation population,
EncogProgram prg)
{
lock (this)
{
ISpecies defaultSpecies = population.Species[0];
prg.Species = defaultSpecies;
defaultSpecies.Add(prg);
_contents.Add(prg.DumpAsCommonExpression());
}
}
/// <summary>
/// Factor a new program node, based on an opcode name and arguments.
/// </summary>
/// <param name="name">The name of the opcode.</param>
/// <param name="program">The program to factor for.</param>
/// <param name="args">The arguements.</param>
/// <returns>The newly created ProgramNode.</returns>
public ProgramNode FactorProgramNode(String name,
EncogProgram program, ProgramNode[] args)
{
String key = EncogOpcodeRegistry.CreateKey(name, args.Length);
if (!_templateMap.ContainsKey(key))
{
throw new EACompileError("Undefined function/operator: " + name
+ " with " + args.Length + " args.");
}
IProgramExtensionTemplate temp = _templateMap[key];
return new ProgramNode(program, temp, args);
}
/// <summary>
/// Factor a new program node, based in a template object.
/// </summary>
/// <param name="temp">The opcode.</param>
/// <param name="program">The program.</param>
/// <param name="args">The arguments for this node.</param>
/// <returns>The newly created ProgramNode.</returns>
public ProgramNode FactorProgramNode(IProgramExtensionTemplate temp,
EncogProgram program, ProgramNode[] args)
{
return new ProgramNode(program, temp, args);
}
/// <inheritdoc />
public override ProgramNode CreateNode(EncogRandom rnd, EncogProgram program,
int depthRemaining, IList<EPLValueType> types)
{
return CreateRandomNode(rnd, program, depthRemaining, types, true, true);
}
/// <summary>
/// This method is called reflexivly as we iterate downward. Once we reach
/// the desired point (when current level drops to zero), the operation is
/// performed.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <param name="result">The parent node.</param>
/// <param name="parentNode"></param>
/// <param name="types">The desired node</param>
/// <param name="globalIndex">The level holder.</param>
private void FindNode(EncogRandom rnd, EncogProgram result,
ProgramNode parentNode, IList<EPLValueType> types,
int[] globalIndex)
{
if (globalIndex[0] == 0)
{
globalIndex[0]--;
ProgramNode newInsert = Generator.CreateNode(rnd,
result, _maxDepth, types);
result.ReplaceNode(parentNode, newInsert);
}
else
{
globalIndex[0]--;
for (int i = 0; i < parentNode.Template.ChildNodeCount; i++)
{
ProgramNode childNode = parentNode.GetChildNode(i);
IList<EPLValueType> childTypes = parentNode.Template.Params[i].DetermineArgumentTypes(types);
FindNode(rnd, result, childNode, childTypes, globalIndex);
}
}
}
/// <summary>
/// Create a terminal node.
/// </summary>
/// <param name="rnd">A random number generator.</param>
/// <param name="program">The program to generate for.</param>
/// <param name="types">The types that we might generate.</param>
/// <returns>The terminal program node.</returns>
public ProgramNode CreateTerminalNode(EncogRandom rnd,
EncogProgram program, IList<EPLValueType> types)
{
IProgramExtensionTemplate temp = GenerateRandomOpcode(
rnd,
Context.Functions.FindOpcodes(types, _context,
true, false));
if (temp == null)
{
throw new EACompileError("No opcodes exist for the type: "
+ types);
}
var result = new ProgramNode(program, temp,
new ProgramNode[] {});
temp.Randomize(rnd, types, result, MinConst, MaxConst);
return result;
}
/// <summary>
/// Compare program 1 and 2 node for node. Lower values mean more similar genomes.
/// </summary>
/// <param name="prg1">The first program.</param>
/// <param name="prg2">The second program.</param>
/// <returns>The result of the compare.</returns>
public double Compare(EncogProgram prg1, EncogProgram prg2)
{
return CompareNode(0, prg1.RootNode, prg2.RootNode);
}
/// <inheritdoc />
public IGenome Generate(EncogRandom rnd)
{
var program = new EncogProgram(_context);
IList<EPLValueType> types = new List<EPLValueType>();
types.Add(_context.Result.VariableType);
program.RootNode = CreateNode(rnd, program, DetermineMaxDepth(rnd),
types);
return program;
}
