public void ReplaceBranchManipulationDistributionsTest() {
SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
var trees = new List<ISymbolicExpressionTree>();
var grammar = Grammars.CreateArithmeticAndAdfGrammar();
var random = new MersenneTwister(31415);
for (int i = 0; i < POPULATION_SIZE; i++) {
var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
SubroutineCreater.CreateSubroutine(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH, 3, 3);
string originalTree = formatter.Format(tree);
ReplaceBranchManipulation.ReplaceRandomBranch(random, tree, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
string manipulatedTree = formatter.Format(tree);
Assert.IsFalse(originalTree == manipulatedTree);
Util.IsValid(tree);
trees.Add(tree);
}
Console.WriteLine("ReplaceBranchManipulation: " + Environment.NewLine +
Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
Util.GetFunctionDistributionString(trees) + Environment.NewLine +
Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
Util.GetTerminalDistributionString(trees) + Environment.NewLine
);
}
public void ChangeNodeTypeManipulationDistributionsTest() {
SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
var trees = new List<ISymbolicExpressionTree>();
var grammar = Grammars.CreateArithmeticAndAdfGrammar();
var random = new MersenneTwister(31415);
int failedEvents = 0;
for (int i = 0; i < POPULATION_SIZE; i++) {
var tree = ProbabilisticTreeCreator.Create(random, grammar, MAX_TREE_LENGTH, MAX_TREE_DEPTH);
string originalTree = formatter.Format(tree);
ChangeNodeTypeManipulation.ChangeNodeType(random, tree);
string manipulatedTree = formatter.Format(tree);
if (originalTree == manipulatedTree) failedEvents++;
Util.IsValid(tree);
trees.Add(tree);
}
Console.WriteLine("ChangeNodeTypeManipulation: " + Environment.NewLine +
"Failed events: " + failedEvents * 100.0 / POPULATION_SIZE + " %" + Environment.NewLine +
Util.GetSizeDistributionString(trees, 105, 5) + Environment.NewLine +
Util.GetFunctionDistributionString(trees) + Environment.NewLine +
Util.GetNumberOfSubtreesDistributionString(trees) + Environment.NewLine +
Util.GetTerminalDistributionString(trees) + Environment.NewLine
);
Assert.IsTrue(failedEvents * 100.0 / POPULATION_SIZE < 5.0); // only max 5% failed mutations are allowed
}
protected SymbolicExpressionTreeStringFormatter(SymbolicExpressionTreeStringFormatter original, Cloner cloner)
: base(original, cloner) {
Indent = original.Indent;
}
protected SymbolicExpressionTreeStringFormatter(SymbolicExpressionTreeStringFormatter original, Cloner cloner)
: base(original, cloner)
{
Indent = original.Indent;
}
public void SimplifierAxiomsTest() {
SymbolicExpressionImporter importer = new SymbolicExpressionImporter();
SymbolicDataAnalysisExpressionTreeSimplifier simplifier = new SymbolicDataAnalysisExpressionTreeSimplifier();
SymbolicExpressionTreeStringFormatter formatter = new SymbolicExpressionTreeStringFormatter();
#region single argument arithmetics
{
var actualTree = simplifier.Simplify(importer.Import("(+ 1.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(+ (variable 2.0 a))"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(- 1.0)"));
var expectedTree = importer.Import("-1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(- (variable 2.0 a))"));
var expectedTree = importer.Import("(variable -2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(* 2.0)"));
var expectedTree = importer.Import("2.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(* (variable 2.0 a))"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(/ 2.0)"));
var expectedTree = importer.Import("0.5");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(/ (variable 2.0 a))"));
var expectedTree = importer.Import("(/ 1.0 (variable 2.0 a))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region aggregation of constants into factors
{
var actualTree = simplifier.Simplify(importer.Import("(* 2.0 (variable 2.0 a))"));
var expectedTree = importer.Import("(variable 4.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(/ (variable 2.0 a) 2.0)"));
var expectedTree = importer.Import("(variable 1.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(/ (variable 2.0 a) (* 2.0 2.0))"));
var expectedTree = importer.Import("(variable 0.5 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region constant and variable folding
{
var actualTree = simplifier.Simplify(importer.Import("(+ 1.0 2.0)"));
var expectedTree = importer.Import("3.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(+ (variable 2.0 a) (variable 2.0 a))"));
var expectedTree = importer.Import("(variable 4.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(- (variable 2.0 a) (variable 1.0 a))"));
var expectedTree = importer.Import("(variable 1.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(* (variable 2.0 a) (variable 2.0 a))"));
var expectedTree = importer.Import("(* (* (variable 1.0 a) (variable 1.0 a)) 4.0)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
var actualTree = simplifier.Simplify(importer.Import("(/ (variable 1.0 a) (variable 2.0 a))"));
var expectedTree = importer.Import("0.5");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region logarithm rules
{
// cancellation
var actualTree = simplifier.Simplify(importer.Import("(log (exp (variable 2.0 a)))"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// must not transform logs in this way as we do not know wether both variables are positive
var actualTree = simplifier.Simplify(importer.Import("(log (* (variable 1.0 a) (variable 1.0 b)))"));
var expectedTree = importer.Import("(log (* (variable 1.0 a) (variable 1.0 b)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// must not transform logs in this way as we do not know wether both variables are positive
var actualTree = simplifier.Simplify(importer.Import("(log (/ (variable 1.0 a) (variable 1.0 b)))"));
var expectedTree = importer.Import("(log (/ (variable 1.0 a) (variable 1.0 b)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region exponentiation rules
{
// cancellation
var actualTree = simplifier.Simplify(importer.Import("(exp (log (variable 2.0 a)))"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// exp transformation
var actualTree = simplifier.Simplify(importer.Import("(exp (+ (variable 2.0 a) (variable 3.0 b)))"));
var expectedTree = importer.Import("(* (exp (variable 2.0 a)) (exp (variable 3.0 b)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// exp transformation
var actualTree = simplifier.Simplify(importer.Import("(exp (- (variable 2.0 a) (variable 3.0 b)))"));
var expectedTree = importer.Import("(* (exp (variable 2.0 a)) (exp (variable -3.0 b)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// exp transformation
var actualTree = simplifier.Simplify(importer.Import("(exp (- (variable 2.0 a) (* (variable 3.0 b) (variable 4.0 c))))"));
var expectedTree = importer.Import("(* (exp (variable 2.0 a)) (exp (* (variable 1.0 b) (variable 1.0 c) -12.0)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// exp transformation
var actualTree = simplifier.Simplify(importer.Import("(exp (- (variable 2.0 a) (* (variable 3.0 b) (cos (variable 4.0 c)))))"));
var expectedTree = importer.Import("(* (exp (variable 2.0 a)) (exp (* (variable 1.0 b) (cos (variable 4.0 c)) -3.0)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region power rules
{
// cancellation
var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) 0.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// fixed point
var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) 1.0)"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// inversion fixed point
var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) -1.0)"));
var expectedTree = importer.Import("(/ 1.0 (variable 2.0 a))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// inversion
var actualTree = simplifier.Simplify(importer.Import("(pow (variable 2.0 a) -2.0)"));
var expectedTree = importer.Import("(/ 1.0 (pow (variable 2.0 a) 2.0))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// constant folding
var actualTree = simplifier.Simplify(importer.Import("(pow 3.0 2.0)"));
var expectedTree = importer.Import("9.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region root rules
{
// cancellation
var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) 0.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// fixed point
var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) 1.0)"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// inversion fixed point
var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) -1.0)"));
var expectedTree = importer.Import("(/ 1.0 (variable 2.0 a))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// inversion
var actualTree = simplifier.Simplify(importer.Import("(root (variable 2.0 a) -2.0)"));
var expectedTree = importer.Import("(/ 1.0 (root (variable 2.0 a) 2.0))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// constant folding
var actualTree = simplifier.Simplify(importer.Import("(root 9.0 2.0)"));
var expectedTree = importer.Import("3.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region boolean operations
{
// always true and
var actualTree = simplifier.Simplify(importer.Import("(and 1.0 2.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// always false and
var actualTree = simplifier.Simplify(importer.Import("(and 1.0 -2.0)"));
var expectedTree = importer.Import("-1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// always true or
var actualTree = simplifier.Simplify(importer.Import("(or -1.0 2.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// always false or
var actualTree = simplifier.Simplify(importer.Import("(or -1.0 -2.0)"));
var expectedTree = importer.Import("-1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// constant not
var actualTree = simplifier.Simplify(importer.Import("(not -2.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// constant not
var actualTree = simplifier.Simplify(importer.Import("(not 2.0)"));
var expectedTree = importer.Import("-1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// constant not
var actualTree = simplifier.Simplify(importer.Import("(not 0.0)"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// nested nots
var actualTree = simplifier.Simplify(importer.Import("(not (not 1.0))"));
var expectedTree = importer.Import("1.0");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// not of non-Boolean argument
var actualTree = simplifier.Simplify(importer.Import("(not (variable 1.0 a))"));
var expectedTree = importer.Import("(not (> (variable 1.0 a) 0.0))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// not Boolean argument
var actualTree = simplifier.Simplify(importer.Import("(not (and (> (variable 1.0 a) 0.0) (> (variable 1.0 a) 0.0)))"));
var expectedTree = importer.Import("(not (and (> (variable 1.0 a) 0.0) (> (variable 1.0 a) 0.0)))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
#region conditionals
{
// always false
var actualTree = simplifier.Simplify(importer.Import("(if -1.0 (variable 2.0 a) (variable 3.0 a))"));
var expectedTree = importer.Import("(variable 3.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// always true
var actualTree = simplifier.Simplify(importer.Import("(if 1.0 (variable 2.0 a) (variable 3.0 a))"));
var expectedTree = importer.Import("(variable 2.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// always false (0.0)
var actualTree = simplifier.Simplify(importer.Import("(if 0.0 (variable 2.0 a) (variable 3.0 a))"));
var expectedTree = importer.Import("(variable 3.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// complex constant condition (always false)
var actualTree = simplifier.Simplify(importer.Import("(if (* 1.0 -2.0) (variable 2.0 a) (variable 3.0 a))"));
var expectedTree = importer.Import("(variable 3.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// complex constant condition (always false)
var actualTree = simplifier.Simplify(importer.Import("(if (/ (variable 1.0 a) (variable -2.0 a)) (variable 2.0 a) (variable 3.0 a))"));
var expectedTree = importer.Import("(variable 3.0 a)");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
{
// insertion of relational operator
var actualTree = simplifier.Simplify(importer.Import("(if (variable 1.0 a) (variable 2.0 a) (variable 3.0 a))"));
var expectedTree = importer.Import("(if (> (variable 1.0 a) 0.0) (variable 2.0 a) (variable 3.0 a))");
Assert.AreEqual(formatter.Format(expectedTree), formatter.Format(actualTree));
}
#endregion
}
