Changeset 2216 for branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3

Timestamp:

07/30/09 19:41:58 (15 years ago)

Author:

gkronber

Message:

GP Refactoring #713

• cleaned code
• reintegrated GP.Boolean and GP.SantaFe
• worked on serialization of function trees

Location:

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3

Files:

• FunctionLibraryInjector.cs (modified) (6 diffs)
• ModelAnalyzerExporter.cs (modified) (3 diffs)
• SymbolicExpressionExporter.cs (modified) (2 diffs)
• Symbols/Constant.cs (modified) (1 diff)
• Symbols/ConstantFunctionTree.cs (modified) (1 diff)
• Symbols/VariableFunctionTree.cs (modified) (2 diffs)

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjector.cs

@@ -24 +24 @@
 using HeuristicLab.Data;
 using HeuristicLab.GP.Interfaces;
+using HeuristicLab.GP.SantaFe;
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class FunctionLibraryInjector : OperatorBase {
-    private const string FUNCTIONLIBRARY = "FunctionLibrary";
-    private const string TARGETVARIABLE = "TargetVariable";
+  public class FunctionLibraryInjector : FunctionLibraryInjectorBase {
     private const string MINTIMEOFFSET = "MinTimeOffset";
     private const string MAXTIMEOFFSET = "MaxTimeOffset";
@@ -57 +56 @@
     private const string XOR_ALLOWED = "Xor";
 
+    private int minTimeOffset;
+    private int maxTimeOffset;
 
     public override string Description {
@@ -64 +65 @@
     public FunctionLibraryInjector()
       : base() {
-      AddVariableInfo(new VariableInfo(TARGETVARIABLE, "The target variable", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo(FUNCTIONLIBRARY, "Preconfigured default function library", typeof(FunctionLibrary), VariableKind.New));
 
       AddVariable(DIFFERENTIALS_ALLOWED, false);
@@ -102 +101 @@
 
     public override IOperation Apply(IScope scope) {
-      FunctionLibrary functionLibrary = new FunctionLibrary();
-      int targetVariable = GetVariableValue<IntData>(TARGETVARIABLE, scope, true).Data;
-
       // try to get minTimeOffset (use 0 as default if not available)
       IItem minTimeOffsetItem = GetVariableValue(MINTIMEOFFSET, scope, true, false);
-      int minTimeOffset = minTimeOffsetItem == null ? 0 : ((IntData)minTimeOffsetItem).Data;
+      minTimeOffset = minTimeOffsetItem == null ? 0 : ((IntData)minTimeOffsetItem).Data;
       // try to get maxTimeOffset (use 0 as default if not available)
       IItem maxTimeOffsetItem = GetVariableValue(MAXTIMEOFFSET, scope, true, false);
-      int maxTimeOffset = maxTimeOffsetItem == null ? 0 : ((IntData)maxTimeOffsetItem).Data;
+      maxTimeOffset = maxTimeOffsetItem == null ? 0 : ((IntData)maxTimeOffsetItem).Data;
+
+      return base.Apply(scope);
+    }
+
+    protected override FunctionLibrary CreateFunctionLibrary() {
+      FunctionLibrary functionLibrary = new FunctionLibrary();
 
       Variable variable = new Variable();
@@ -218 +220 @@
       differential.SetConstraints(minTimeOffset, maxTimeOffset);
 
-      scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName(FUNCTIONLIBRARY), functionLibrary));
-
-      return null;
+      return functionLibrary;
     }
 
@@ -230 +230 @@
       if (GetVariableValue<BoolData>(condName, null, false).Data) functionLib.AddFunction(op);
     }
-
-    private void SetAllowedSubOperators(IFunction f, List<IFunction> gs) {
-      for (int i = 0; i < f.MaxSubTrees; i++) {
-        SetAllowedSubOperators(f, i, gs);
-      }
-    }
-
-    private void SetAllowedSubOperators(IFunction f, int i, List<IFunction> gs) {
-      gs.ForEach((g) => f.AddAllowedSubFunction(g, i));
-    }
   }
 }

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/ModelAnalyzerExporter.cs

@@ -21 +21 @@
 
 using HeuristicLab.GP.Interfaces;
+using System;
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class ModelAnalyzerExporter : IFunctionTreeExporter, IFunctionTreeNameGenerator {
+  public class ModelAnalyzerExporter : IFunctionTreeSerializer, IFunctionTreeNameGenerator {
     #region IFunctionTreeExporter Members
 
@@ -53 +54 @@
       if(tree.SubTrees.Count > 0) result += ")";
       return result;
+    }
+
+    public IFunctionTree Import(string tree) {
+      throw new UnknownFunctionException(tree);
+    }
+
+    public bool TryImport(string tree, out IFunctionTree importedTree) {
+      try {
+        importedTree = Import(tree);
+        return true;
+      }
+      catch (UnknownFunctionException) {
+        importedTree = null;
+        return false;
+      }
     }
 
@@ -104 +120 @@
 
     #endregion
+
+
   }
 

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/SymbolicExpressionExporter.cs

@@ -22 +22 @@
 using System.Text;
 using HeuristicLab.GP.Interfaces;
+using System;
+using System.Collections.Generic;
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class SymbolicExpressionExporter : IFunctionTreeExporter, IFunctionTreeNameGenerator {
+  public class SymbolicExpressionExporter : IFunctionTreeSerializer, IFunctionTreeNameGenerator {
     private StringBuilder builder;
     private string currentIndent;
@@ -48 +50 @@
       } catch(UnknownFunctionException) {
         exported = "";
+        return false;
+      }
+    }
+
+    public IFunctionTree Import(string tree) {
+      Queue<string> tokens = new Queue<string>(tree.Split(' ', '\n', '\t'));
+      return ParseTree(tokens);
+    }
+
+    private IFunctionTree ParseTree(Queue<string> tokens) {
+      Expect("(", tokens);
+      string funSymb = tokens.Peek();
+      double constValue;
+      if (double.TryParse(funSymb, out constValue)) {
+        throw new UnknownFunctionException(funSymb);
+      }
+      switch (funSymb) {
+        case "variable": return ParseVariable(tokens);
+        case "differential": return ParseDifferential(tokens);
+        default: 
+          IFunctionTree fNode = ParseFunction(tokens);
+          Expect(")", tokens);
+          return fNode;
+      }
+
+    }
+
+    private IFunctionTree ParseFunction(Queue<string> tokens) {
+      throw new UnknownFunctionException(tokens.Dequeue());
+    }
+
+    private IFunctionTree ParseDifferential(Queue<string> tokens) {
+      throw new UnknownFunctionException(tokens.Dequeue());
+    }
+
+    private IFunctionTree ParseVariable(Queue<string> tokens) {
+      throw new UnknownFunctionException(tokens.Dequeue());
+    }
+
+    private void Expect(string p, Queue<string> tokens) {
+      throw new NotImplementedException();
+    }
+
+    public bool TryImport(string tree, out IFunctionTree importedTree) {
+      try {
+        importedTree = Import(tree);
+        return true;
+      }
+      catch (UnknownFunctionException) {
+        importedTree = null;
         return false;
       }

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/Symbols/Constant.cs

@@ -31 +31 @@
     public override string Description {
       get { return "Returns the value of local variable 'Value'."; }
-    }
-
-    public override IEnumerable<string> LocalParameterNames {
-      get {
-        return new string[] { VALUE };
-      }
     }
 

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/Symbols/ConstantFunctionTree.cs

@@ -26 +26 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class ConstantFunctionTree : FunctionTreeBase {
-    private static readonly IList<IFunctionTree> subTrees = new List<IFunctionTree>().AsReadOnly();
+  public class ConstantFunctionTree : TerminalTreeNode {
     public double Value { get; set; }
 
-    public ConstantFunctionTree(Constant constant) {
-      Function = constant;
+    public ConstantFunctionTree(Constant constant) : base(constant){
     }
 
-    protected ConstantFunctionTree(ConstantFunctionTree original) {
-      Function = original.Function;
+    protected ConstantFunctionTree(ConstantFunctionTree original) : base(original){
       Value = original.Value;
-    }
-
-    public override IList<IFunctionTree> SubTrees {
-      get {
-        return subTrees;
-      }
     }
 

branches/GP-Refactoring-713/sources/HeuristicLab.GP.StructureIdentification/3.3/Symbols/VariableFunctionTree.cs

@@ -26 +26 @@
 
 namespace HeuristicLab.GP.StructureIdentification {
-  public class VariableFunctionTree : FunctionTreeBase {
-    private static readonly IList<IFunctionTree> subTrees = new List<IFunctionTree>().AsReadOnly();
+  public class VariableFunctionTree : TerminalTreeNode {
     public double Weight { get; set; }
     public string VariableName { get; set; }
     public int SampleOffset { get; set; }
 
-    public VariableFunctionTree(Variable variable) {
-      Function = variable;
+    public VariableFunctionTree(Variable variable)
+      : base(variable) {
     }
 
-    protected VariableFunctionTree(VariableFunctionTree original) {
-      Function = original.Function;
+    protected VariableFunctionTree(VariableFunctionTree original)
+      : base(original) {
       Weight = original.Weight;
       VariableName = original.VariableName;
       SampleOffset = original.SampleOffset;
-    }
-
-    public override IList<IFunctionTree> SubTrees {
-      get {
-        return subTrees;
-      }
     }
 
@@ -66 +59 @@
     public override IOperation CreateInitOperation(IScope scope) {
       Scope myVariableScope = new Scope();
-      scope.AddSubScope(myVariableScope); 
+      scope.AddSubScope(myVariableScope);
       myVariableScope.AddVariable(CreateWeightVariable());
       myVariableScope.AddVariable(CreateVariableNameVariable());