Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs	(revision 17554)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sum.cs	(revision 17573)
@@ -28,5 +28,5 @@
   [StorableType("C6C245BF-C44A-4207-A268-55641483F27F")]
   [Item("Sum", "Symbol that represents the sum function.")]
-  public sealed class Sum : Symbol {
+  public sealed class Sum : WindowedSymbol {
     private const int minimumArity = 1;
     private const int maximumArity = 1;
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbol.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbol.cs	(revision 17573)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbol.cs	(revision 17573)
@@ -0,0 +1,174 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HEAL.Attic;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("2E342E38-BE2F-4E49-A9C3-2E833B83FDBC")]
+  public abstract class WindowedSymbol : Symbol, IWindowedSymbol {
+    #region Properties
+    [Storable]
+    private bool enableWindowing;
+    public bool EnableWindowing {
+      get { return enableWindowing; }
+      set {
+        if (value != enableWindowing) {
+          enableWindowing = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+
+    [Storable]
+    private double offsetMu;
+    public double OffsetMu {
+      get { return offsetMu; }
+      set {
+        if (value != offsetMu) {
+          offsetMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double offsetSigma;
+    public double OffsetSigma {
+      get { return offsetSigma; }
+      set {
+        if (offsetSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != offsetSigma) {
+          offsetSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double lengthMu;
+    public double LengthMu {
+      get { return lengthMu; }
+      set {
+        if (value != lengthMu) {
+          lengthMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double lengthSigma;
+    public double LengthSigma {
+      get { return lengthSigma; }
+      set {
+        if (lengthSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != lengthSigma) {
+          lengthSigma = value;
+          OnChanged(EventArgs.Empty); ;
+        }
+      }
+    }
+
+    [Storable]
+    private double manipulatorOffsetMu;
+    public double ManipulatorOffsetMu {
+      get { return manipulatorOffsetMu; }
+      set {
+        if (value != manipulatorOffsetMu) {
+          manipulatorOffsetMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double manipulatorOffsetSigma;
+    public double ManipulatorOffsetSigma {
+      get { return manipulatorOffsetSigma; }
+      set {
+        if (manipulatorOffsetSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != manipulatorOffsetSigma) {
+          manipulatorOffsetSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double manipulatorLengthMu;
+    public double ManipulatorLengthMu {
+      get { return manipulatorLengthMu; }
+      set {
+        if (value != manipulatorLengthMu) {
+          manipulatorLengthMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double manipulatorLengthSigma;
+    public double ManipulatorLengthSigma {
+      get { return manipulatorLengthSigma; }
+      set {
+        if (manipulatorLengthSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != manipulatorLengthSigma) {
+          manipulatorLengthSigma = value;
+          OnChanged(EventArgs.Empty);;
+        }
+      }
+    }
+    #endregion
+
+    [StorableConstructor]
+    protected WindowedSymbol(StorableConstructorFlag _) : base(_) {
+    }
+    protected WindowedSymbol(WindowedSymbol original, Cloner cloner)
+      : base(original, cloner) {
+      enableWindowing = original.enableWindowing;
+
+      offsetMu = original.offsetMu;
+      offsetSigma = original.offsetSigma;
+      lengthMu = original.lengthMu;
+      lengthSigma = original.lengthSigma;
+
+      manipulatorOffsetMu = original.manipulatorOffsetMu;
+      manipulatorOffsetSigma = original.manipulatorOffsetSigma;
+      manipulatorLengthMu = original.manipulatorLengthMu;
+      manipulatorLengthSigma = original.manipulatorLengthSigma;
+    }
+    protected WindowedSymbol(string name, string description)
+      : base(name, description) {
+      enableWindowing = false;
+
+      offsetMu = 0.0;
+      offsetSigma = 0.05;
+      lengthMu = 1.0;
+      lengthSigma = 0.05;
+
+      manipulatorOffsetMu = 0.0;
+      manipulatorOffsetSigma = 0.05;
+      manipulatorLengthMu = 0.0;
+      manipulatorLengthSigma = 0.05;
+    }
+
+    public override ISymbolicExpressionTreeNode CreateTreeNode() {
+      return new WindowedSymbolTreeNode(this);
+    }
+  }
+}
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbolTreeNode.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbolTreeNode.cs	(revision 17573)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/WindowedSymbolTreeNode.cs	(revision 17573)
@@ -0,0 +1,94 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HEAL.Attic;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("E79432BB-414D-4535-8751-D0139AF048E1")]
+  public class WindowedSymbolTreeNode : SymbolicExpressionTreeNode, IWindowedSymbolTreeNode {
+    public new WindowedSymbol Symbol {
+      get { return (WindowedSymbol)base.Symbol; }
+    }
+    [Storable]
+    private double offset;
+    public double Offset {
+      get { return offset; }
+      set { offset = Math.Min(Math.Max(value, 0.0), 1.0); }     
+    }
+    [Storable]
+    private double length;
+    public double Length {
+      get { return length; }
+      set { length = Math.Min(Math.Max(value, 0.0), 1.0); }
+    }
+
+    [StorableConstructor]
+    protected WindowedSymbolTreeNode(StorableConstructorFlag _) : base(_) { }
+    protected WindowedSymbolTreeNode(WindowedSymbolTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      offset = original.offset;
+      length = original.length;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new WindowedSymbolTreeNode(this, cloner);
+    }
+
+    public WindowedSymbolTreeNode(WindowedSymbol windowedSymbol) : base(windowedSymbol) {
+      if (!windowedSymbol.EnableWindowing) {
+        Offset = 0.0;
+        Length = 1.0;
+      }
+    }
+
+    public override bool HasLocalParameters {
+      get { return Symbol.EnableWindowing; }
+    }
+
+    public override void ResetLocalParameters(IRandom random) {
+      base.ResetLocalParameters(random);
+
+      if (Symbol.EnableWindowing) {
+        Offset = NormalDistributedRandom.NextDouble(random, Symbol.OffsetMu, Symbol.OffsetSigma);
+        Length = NormalDistributedRandom.NextDouble(random, Symbol.LengthMu, Symbol.LengthSigma);
+      }
+    }
+
+    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
+      base.ShakeLocalParameters(random, shakingFactor);
+
+      if (Symbol.EnableWindowing) { 
+        Offset += NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorOffsetMu, Symbol.ManipulatorOffsetSigma) * shakingFactor;
+        Length += NormalDistributedRandom.NextDouble(random, Symbol.ManipulatorLengthMu, Symbol.ManipulatorLengthSigma) * shakingFactor;
+      }
+    }
+
+    public override string ToString() {
+      return Symbol.EnableWindowing 
+        ? base.ToString() + $"[{Offset} : {Length}]" 
+        : base.ToString();
+    }
+  }
+}
