Changeset 8331 for branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower

Timestamp:

07/26/12 09:51:13 (12 years ago)

Author:

jkarder

Message:

#1331: merged r8086:8330 from trunk

Location:

branches/ScatterSearch (trunk integration)

Files:

• . (modified) (2 props)
• HeuristicLab.Problems.LawnMower/3.3/Grammar.cs (modified) (1 diff)
• HeuristicLab.Problems.LawnMower/3.3/HeuristicLab.Problems.LawnMower.csproj (modified) (2 diffs)
• HeuristicLab.Problems.LawnMower/3.3/HeuristicLab.snk (copied) (copied from trunk/sources/HeuristicLab.Problems.LawnMower/3.3/HeuristicLab.snk)
• HeuristicLab.Problems.LawnMower/3.3/Interpreter.cs (modified) (5 diffs)
• HeuristicLab.Problems.LawnMower/3.3/Plugin.cs.frame (modified) (1 diff)
• HeuristicLab.Problems.LawnMower/3.3/Problem.cs (modified) (7 diffs)
• HeuristicLab.Problems.LawnMower/3.3/Properties/AssemblyInfo.cs.frame (modified) (1 diff)

branches/ScatterSearch (trunk integration)

@@ -21 +21 @@
 protoc.exe
 _ReSharper.HeuristicLab 3.3 Tests
+Google.ProtocolBuffers-2.4.1.473.dll

@@ -21 +21 @@
 protoc.exe
 _ReSharper.HeuristicLab 3.3 Tests
+Google.ProtocolBuffers-2.4.1.473.dll

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower/3.3/Grammar.cs

@@ -64 +64 @@
       // define grammar rules
       foreach (var s in allSymbols) {
-        AddAllowedChildSymbol(sum, s, 0);
-        AddAllowedChildSymbol(sum, s, 1);
-        AddAllowedChildSymbol(prog, s, 0);
-        AddAllowedChildSymbol(prog, s, 1);
-        AddAllowedChildSymbol(frog, s, 0);
-        AddAllowedChildSymbol(StartSymbol, s, 0);
+        AddAllowedChildSymbol(sum, s);
+        AddAllowedChildSymbol(sum, s);
+        AddAllowedChildSymbol(prog, s);
+        AddAllowedChildSymbol(prog, s);
+        AddAllowedChildSymbol(frog, s);
+        AddAllowedChildSymbol(StartSymbol, s);
       }
     }

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower/3.3/HeuristicLab.Problems.LawnMower.csproj

@@ -96 +96 @@
     <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
   </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="HeuristicLab.Common-3.3">
@@ -106 +112 @@
   <ItemGroup>
     <Compile Include="BestSolutionAnalyzer.cs" />
+    <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
     <Compile Include="Interpreter.cs" />

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower/3.3/Interpreter.cs

@@ -21 +21 @@
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
@@ -51 +53 @@
       mowerState.Energy = length * width * 2;
       lawn[mowerState.Position.Item1, mowerState.Position.Item2] = true;
-      EvaluateLawnMowerProgram(tree.Root, ref mowerState, lawn);
+      EvaluateLawnMowerProgram(tree.Root, mowerState, lawn, tree.Root.Subtrees.Skip(1).ToArray());
 
       return lawn;
@@ -57 +59 @@
 
 
-    private static Tuple<int, int> EvaluateLawnMowerProgram(ISymbolicExpressionTreeNode node, ref MowerState mowerState, bool[,] lawn) {
+    private static Tuple<int, int> EvaluateLawnMowerProgram(ISymbolicExpressionTreeNode node, MowerState mowerState, bool[,] lawn, IEnumerable<ISymbolicExpressionTreeNode> adfs) {
       if (mowerState.Energy <= 0) return new Tuple<int, int>(0, 0);
 
       if (node.Symbol is ProgramRootSymbol) {
-        return EvaluateLawnMowerProgram(node.GetSubtree(0), ref mowerState, lawn);
+        return EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
       } else if (node.Symbol is StartSymbol) {
-        return EvaluateLawnMowerProgram(node.GetSubtree(0), ref mowerState, lawn);
+        return EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
       } else if (node.Symbol is Left) {
         switch (mowerState.Heading) {
@@ -104 +106 @@
         return constNode.Value;
       } else if (node.Symbol is Sum) {
-        var p = EvaluateLawnMowerProgram(node.GetSubtree(0), ref mowerState, lawn);
-        var q = EvaluateLawnMowerProgram(node.GetSubtree(1), ref mowerState, lawn);
+        var p = EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
+        var q = EvaluateLawnMowerProgram(node.GetSubtree(1), mowerState, lawn, adfs);
         return new Tuple<int, int>(p.Item1 + q.Item1,
           p.Item2 + q.Item2);
       } else if (node.Symbol is Prog) {
-        EvaluateLawnMowerProgram(node.GetSubtree(0), ref mowerState, lawn);
-        return EvaluateLawnMowerProgram(node.GetSubtree(1), ref mowerState, lawn);
+        EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
+        return EvaluateLawnMowerProgram(node.GetSubtree(1), mowerState, lawn, adfs);
       } else if (node.Symbol is Frog) {
-        var p = EvaluateLawnMowerProgram(node.GetSubtree(0), ref mowerState, lawn);
+        var p = EvaluateLawnMowerProgram(node.GetSubtree(0), mowerState, lawn, adfs);
 
         uint newRow = (uint)((mowerState.Position.Item1 + lawn.GetLength(0) + p.Item1 % lawn.GetLength(0)) % lawn.GetLength(0));
@@ -120 +122 @@
         lawn[newRow, newCol] = true;
         return new Tuple<int, int>(0, 0);
+      } else if (node.Symbol is InvokeFunction) {
+        var invokeNode = node as InvokeFunctionTreeNode;
+
+        // find the function definition for the invoke call
+        var functionDefinition = (from adf in adfs.Cast<DefunTreeNode>()
+                                  where adf.FunctionName == invokeNode.Symbol.FunctionName
+                                  select adf).Single();
+        // clone the function definition because we are replacing the argument nodes
+        functionDefinition = (DefunTreeNode) functionDefinition.Clone();
+        // find the argument tree nodes and their parents in the original function definition
+        // toList is necessary to prevent that newly inserted branches are iterated
+        var argumentCutPoints = (from parent in functionDefinition.IterateNodesPrefix()
+                                 from subtree in parent.Subtrees
+                                 where subtree is ArgumentTreeNode
+                                 select new { Parent = parent, Argument = subtree.Symbol as Argument, ChildIndex = parent.IndexOfSubtree(subtree) })
+                                 .ToList();
+        // replace all argument tree ndoes with the matching argument of the invoke node
+        foreach (var cutPoint in argumentCutPoints) {
+          cutPoint.Parent.RemoveSubtree(cutPoint.ChildIndex);
+          cutPoint.Parent.InsertSubtree(cutPoint.ChildIndex, (SymbolicExpressionTreeNode)invokeNode.GetSubtree(cutPoint.Argument.ArgumentIndex).Clone());
+        }
+        return EvaluateLawnMowerProgram(functionDefinition.GetSubtree(0), mowerState, lawn, adfs);
       } else {
         throw new ArgumentException("Invalid symbol in the lawn mower program.");
       }
     }
-
   }
 }

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower/3.3/Plugin.cs.frame

@@ -23 +23 @@
 
 namespace HeuristicLab.Problems.LawnMower {
-  [Plugin("HeuristicLab.Problems.LawnMower", "Lawn mower demo problem for genetic programming", "3.3.0.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.LawnMower", "Lawn mower demo problem for genetic programming", "3.3.7.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.LawnMower-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Collections", "3.3")]

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower/3.3/Problem.cs

@@ -42 +42 @@
     private const string MaxLawnMowerProgramDepthParameterName = "MaxProgramDepth";
     private const string LawnMowerGrammarParameterName = "Grammar";
+    private const string MaxFunctionDefinitionsParameterName = "MaxFunctionDefinitions";
+    private const string MaxArgumentDefinitionsParameterName = "MaxArgumentDefinitions";
 
     public IFixedValueParameter<IntValue> LawnWidthParameter {
@@ -58 +60 @@
       get { return (IValueParameter<Grammar>)Parameters[LawnMowerGrammarParameterName]; }
     }
+    public IFixedValueParameter<IntValue> MaxFunctionDefinitionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaxFunctionDefinitionsParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> MaxArgumentDefinitionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[MaxArgumentDefinitionsParameterName]; }
+    }
 
     [StorableConstructor]
@@ -73 +81 @@
       Parameters.Add(new FixedValueParameter<IntValue>(MaxLawnMowerProgramDepthParameterName, "Maximal depth of the lawn mower program.", new IntValue(13)));
       Parameters.Add(new FixedValueParameter<IntValue>(MaxLawnMowerProgramLengthParameterName, "Maximal length of the lawn mower program.", new IntValue(1000)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaxFunctionDefinitionsParameterName, "Maximal number of automatically defined functions (ADF).", new IntValue(3)));
+      Parameters.Add(new FixedValueParameter<IntValue>(MaxArgumentDefinitionsParameterName, "Maximal number of automatically defined arguments.", new IntValue(3)));
       Parameters.Add(new ValueParameter<Grammar>(LawnMowerGrammarParameterName, "Grammar for the lawn mower program.",
                      new Grammar()));
@@ -105 +115 @@
       SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged +=
         SymbolicExpressionTreeParameterOnActualNameChanged;
+      MaxArgumentDefinitionsParameter.ValueChanged += ParameterizeGrammar;
+      MaxFunctionDefinitionsParameter.ValueChanged += ParameterizeGrammar;
     }
 
-
-
     protected override void OnEvaluatorChanged() {
-      base.OnEvaluatorChanged();
       Evaluator.LawnMowerProgramParameter.ActualName = LawnMowerProgramParameterName;
       Evaluator.LawnLengthParameter.ActualName = LawnLengthParameterName;
@@ -117 +126 @@
       ParameterizeAnalyzers();
       ParameterizeOperators();
+      base.OnEvaluatorChanged();
     }
 
     protected override void OnSolutionCreatorChanged() {
-      base.OnSolutionCreatorChanged();
       SolutionCreator.SymbolicExpressionTreeParameter.ActualName = LawnMowerProgramParameterName;
       SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += SymbolicExpressionTreeParameterOnActualNameChanged;
       ParameterizeAnalyzers();
       ParameterizeOperators();
+      base.OnSolutionCreatorChanged();
     }
 
@@ -135 +145 @@
       ParameterizeAnalyzers();
       ParameterizeOperators();
+    }
+
+    private void ParameterizeGrammar(object sender, EventArgs eventArgs) {
+      GrammarParameter.Value.MaximumFunctionArguments = MaxArgumentDefinitionsParameter.Value.Value;
+      GrammarParameter.Value.MaximumFunctionDefinitions = MaxFunctionDefinitionsParameter.Value.Value;
     }
 
@@ -175 +190 @@
         op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       }
+      foreach (ISymbolicExpressionTreeArchitectureAlteringOperator op in operators.OfType<ISymbolicExpressionTreeArchitectureAlteringOperator>()) {
+        op.MaximumFunctionDefinitionsParameter.ActualName = MaxFunctionDefinitionsParameter.Name;
+        op.MaximumFunctionArgumentsParameter.ActualName = MaxArgumentDefinitionsParameter.Name;
+      }
     }
   }

branches/ScatterSearch (trunk integration)/HeuristicLab.Problems.LawnMower/3.3/Properties/AssemblyInfo.cs.frame

@@ -54 +54 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.0.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.7.$WCREV$")]

@@ -21 +21 @@
 protoc.exe
 _ReSharper.HeuristicLab 3.3 Tests
+Google.ProtocolBuffers-2.4.1.473.dll