Changeset 5026 for branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic

Timestamp:

12/06/10 10:28:34 (14 years ago)

Author:

mkommend

Message:

Added branched projects for new GP symbols (ticket #1256).

Location:

branches/GP.Symbols (TimeLag, Diff, Integral)

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis (copied) (copied from trunk/sources/HeuristicLab.Problems.DataAnalysis)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedSymbol.cs (added)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedTreeNode.cs (copied) (copied from trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/TimeLag.cs (added)

branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs

@@ -60 +60 @@
       var or = new Or();
       var not = new Not();
+      var timeLag = new TimeLag();
+      timeLag.InitialFrequency = 0.0;
       var constant = new Constant();
       constant.MinValue = -20;
@@ -67 +69 @@
       laggedVariable.InitialFrequency = 0.0;
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, exp, @if, gt, lt, and, or, not, constant, variableSymbol, laggedVariable };
-      var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, exp, @if, gt, lt, and, or, not, timeLag, constant, variableSymbol, laggedVariable };
+      var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not, timeLag };
       var binaryFunctionSymbols = new List<Symbol>() { gt, lt };
       var functionSymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or };

branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs

@@ -66 +66 @@
       public const byte Constant = 20;
       public const byte Arg = 21;
+
+      public const byte TimeLag = 22;
     }
 
@@ -90 +92 @@
       { typeof(Constant), OpCodes.Constant },
       { typeof(Argument), OpCodes.Arg },
+      { typeof(TimeLag), OpCodes.TimeLag},
     };
     private const int ARGUMENT_STACK_SIZE = 1024;
@@ -290 +293 @@
             return constTreeNode.Value;
           }
+        case OpCodes.TimeLag: {
+            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
+            row += timeLagTreeNode.Lag;
+            if (row < 0 || row >= dataset.Rows) {
+              row -= timeLagTreeNode.Lag;
+              return double.NaN;
+            }
+            double result = Evaluate();
+            row -= timeLagTreeNode.Lag;
+            return result;
+          }
         default: throw new NotSupportedException();
       }

branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedTreeNode.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Random;
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
   [StorableClass]
-  public class VariableTreeNode : SymbolicExpressionTreeTerminalNode {
-    public new Variable Symbol {
-      get { return (Variable)base.Symbol; }
+  public class LaggedTreeNode : SymbolicExpressionTreeNode, ILaggedTreeNode {
+    public new LaggedSymbol Symbol {
+      get { return (LaggedSymbol)base.Symbol; }
     }
     [Storable]
-    private double weight;
-    public double Weight {
-      get { return weight; }
-      set { weight = value; }
-    }
-    [Storable]
-    private string variableName;
-    public string VariableName {
-      get { return variableName; }
-      set { variableName = value; }
+    private int lag;
+    public int Lag {
+      get { return lag; }
+      set { lag = value; }
     }
 
     [StorableConstructor]
-    protected VariableTreeNode(bool deserializing) : base(deserializing) { }
-    protected VariableTreeNode(VariableTreeNode original, Cloner cloner)
+    protected LaggedTreeNode(bool deserializing) : base(deserializing) { }
+    protected LaggedTreeNode(LaggedTreeNode original, Cloner cloner)
       : base(original, cloner) {
-      weight = original.weight;
-      variableName = original.variableName;
+      lag = original.lag;
     }
-    protected VariableTreeNode() { }
-    public VariableTreeNode(Variable variableSymbol) : base(variableSymbol) { }
+    public LaggedTreeNode(LaggedSymbol timeLagSymbol) : base(timeLagSymbol) { }
 
     public override bool HasLocalParameters {
-      get {
-        return true;
-      }
+      get { return true; }
     }
 
     public override void ResetLocalParameters(IRandom random) {
       base.ResetLocalParameters(random);
-      weight = NormalDistributedRandom.NextDouble(random, Symbol.WeightMu, Symbol.WeightSigma);
-      variableName = Symbol.VariableNames.SelectRandom(random);
+      lag = random.Next(Symbol.MinLag, Symbol.MaxLag + 1);
     }
 
     public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
       base.ShakeLocalParameters(random, shakingFactor);
-      double x = NormalDistributedRandom.NextDouble(random, Symbol.WeightManipulatorMu, Symbol.WeightManipulatorSigma);
-      weight = weight + x * shakingFactor;
-      variableName = Symbol.VariableNames.SelectRandom(random);
+      lag = Math.Min(Symbol.MaxLag, Math.Max(Symbol.MinLag, lag + random.Next(-1, 2)));
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
-      return new VariableTreeNode(this, cloner);
+      return new LaggedTreeNode(this, cloner);
     }
 
     public override string ToString() {
-      if (weight.IsAlmost(1.0)) return variableName;
-      else return weight.ToString("E4") + " " + variableName;
+      return base.ToString() + " " + lag.ToString();
     }
   }

branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/LaggedVariableTreeNode.cs

@@ -26 +26 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
   [StorableClass]
-  public sealed class LaggedVariableTreeNode : VariableTreeNode {
+  public sealed class LaggedVariableTreeNode : VariableTreeNode, ILaggedTreeNode {
     public new LaggedVariable Symbol {
       get { return (LaggedVariable)base.Symbol; }