Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 17572)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.csproj	(revision 17573)
@@ -47,4 +47,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
@@ -57,4 +58,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
@@ -67,4 +69,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
@@ -77,4 +80,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
@@ -87,4 +91,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
@@ -97,4 +102,5 @@
     <CodeAnalysisRuleSet>AllRules.ruleset</CodeAnalysisRuleSet>
     <Prefer32Bit>false</Prefer32Bit>
+    <LangVersion>latest</LangVersion>
   </PropertyGroup>
   <ItemGroup>
@@ -128,4 +134,10 @@
     </Compile>
     <Compile Include="Plugin.cs" />
+    <Compile Include="Symbols\WindowedSymbolView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Symbols\WindowedSymbolView.Designer.cs">
+      <DependentUpon>WindowedSymbolView.cs</DependentUpon>
+    </Compile>
     <Compile Include="TextualSymbolicDataAnalysisModelView.cs">
       <SubType>UserControl</SubType>
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/WindowedSymbolView.Designer.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/WindowedSymbolView.Designer.cs	(revision 17573)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/WindowedSymbolView.Designer.cs	(revision 17573)
@@ -0,0 +1,324 @@
+﻿#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
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
+  partial class WindowedSymbolView {
+    /// <summary> 
+    /// Required designer variable.
+    /// </summary>
+    private System.ComponentModel.IContainer components = null;
+
+    /// <summary> 
+    /// Clean up any resources being used.
+    /// </summary>
+    /// <param name="disposing">true if managed resources should be disposed; otherwise, false.</param>
+    protected override void Dispose(bool disposing) {
+      if (disposing && (components != null)) {
+        components.Dispose();
+      }
+      base.Dispose(disposing);
+    }
+
+    #region Component Designer generated code
+
+    /// <summary> 
+    /// Required method for Designer support - do not modify 
+    /// the contents of this method with the code editor.
+    /// </summary>
+    private void InitializeComponent() {
+      this.initOffsetLabel = new System.Windows.Forms.Label();
+      this.initOffsetSigTextBox = new System.Windows.Forms.TextBox();
+      this.initializationGroupBox = new System.Windows.Forms.GroupBox();
+      this.initLengthMuTextBox = new System.Windows.Forms.TextBox();
+      this.initOffsetMuTextBox = new System.Windows.Forms.TextBox();
+      this.initLengthLabel = new System.Windows.Forms.Label();
+      this.initLengthSigTextBox = new System.Windows.Forms.TextBox();
+      this.mutationGroupBox = new System.Windows.Forms.GroupBox();
+      this.mutLengthMuTextBox = new System.Windows.Forms.TextBox();
+      this.mutOffsetMuTextBox = new System.Windows.Forms.TextBox();
+      this.mutLengthLabel = new System.Windows.Forms.Label();
+      this.mutLengthSigTextBox = new System.Windows.Forms.TextBox();
+      this.mutOffsetLabel = new System.Windows.Forms.Label();
+      this.mutOffsetSigTextBox = new System.Windows.Forms.TextBox();
+      this.enableWindowedCheckBox = new System.Windows.Forms.CheckBox();
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.initializationGroupBox.SuspendLayout();
+      this.mutationGroupBox.SuspendLayout();
+      this.SuspendLayout();
+      // 
+      // initialFrequencyLabel
+      // 
+      this.toolTip.SetToolTip(this.initialFrequencyLabel, "Relative frequency of the symbol in randomly created trees");
+      // 
+      // initialFrequencyTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.initialFrequencyTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.initialFrequencyTextBox.Size = new System.Drawing.Size(280, 26);
+      // 
+      // minimumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.minimumArityLabel, "The minimum arity of the symbol");
+      // 
+      // maximumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.maximumArityLabel, "The maximum arity of the symbol");
+      // 
+      // minimumArityTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.minimumArityTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.minimumArityTextBox.Size = new System.Drawing.Size(280, 26);
+      // 
+      // maximumArityTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.maximumArityTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.maximumArityTextBox.Size = new System.Drawing.Size(280, 26);
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Size = new System.Drawing.Size(280, 26);
+      // 
+      // infoLabel
+      // 
+      this.infoLabel.Location = new System.Drawing.Point(379, 3);
+      // 
+      // initOffsetLabel
+      // 
+      this.initOffsetLabel.AutoSize = true;
+      this.initOffsetLabel.Location = new System.Drawing.Point(6, 22);
+      this.initOffsetLabel.Name = "initOffsetLabel";
+      this.initOffsetLabel.Size = new System.Drawing.Size(121, 20);
+      this.initOffsetLabel.TabIndex = 0;
+      this.initOffsetLabel.Text = "Offset (mu, sig):";
+      this.toolTip.SetToolTip(this.initOffsetLabel, "The minimal value to use for random initialization of constants.");
+      // 
+      // initOffsetSigTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.initOffsetSigTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.initOffsetSigTextBox.Location = new System.Drawing.Point(268, 19);
+      this.initOffsetSigTextBox.Name = "initOffsetSigTextBox";
+      this.initOffsetSigTextBox.Size = new System.Drawing.Size(124, 26);
+      this.initOffsetSigTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.initOffsetSigTextBox, "The minimal value to use for random initialization of constants.");
+      this.initOffsetSigTextBox.TextChanged += new System.EventHandler(this.initOffsetSigTextBox_TextChanged);
+      // 
+      // initializationGroupBox
+      // 
+      this.initializationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.initializationGroupBox.Controls.Add(this.initLengthMuTextBox);
+      this.initializationGroupBox.Controls.Add(this.initOffsetMuTextBox);
+      this.initializationGroupBox.Controls.Add(this.initLengthLabel);
+      this.initializationGroupBox.Controls.Add(this.initLengthSigTextBox);
+      this.initializationGroupBox.Controls.Add(this.initOffsetLabel);
+      this.initializationGroupBox.Controls.Add(this.initOffsetSigTextBox);
+      this.initializationGroupBox.Location = new System.Drawing.Point(0, 164);
+      this.initializationGroupBox.Name = "initializationGroupBox";
+      this.initializationGroupBox.Size = new System.Drawing.Size(398, 84);
+      this.initializationGroupBox.TabIndex = 5;
+      this.initializationGroupBox.TabStop = false;
+      this.initializationGroupBox.Text = "Initialization";
+      // 
+      // initLengthMuTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.initLengthMuTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.initLengthMuTextBox.Location = new System.Drawing.Point(138, 45);
+      this.initLengthMuTextBox.Name = "initLengthMuTextBox";
+      this.initLengthMuTextBox.Size = new System.Drawing.Size(124, 26);
+      this.initLengthMuTextBox.TabIndex = 5;
+      this.toolTip.SetToolTip(this.initLengthMuTextBox, "The maximal value to use for random initialization of constants.");
+      this.initLengthMuTextBox.TextChanged += new System.EventHandler(this.initLengthMuTextBox_TextChanged);
+      // 
+      // initOffsetMuTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.initOffsetMuTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.initOffsetMuTextBox.Location = new System.Drawing.Point(138, 19);
+      this.initOffsetMuTextBox.Name = "initOffsetMuTextBox";
+      this.initOffsetMuTextBox.Size = new System.Drawing.Size(124, 26);
+      this.initOffsetMuTextBox.TabIndex = 4;
+      this.toolTip.SetToolTip(this.initOffsetMuTextBox, "The minimal value to use for random initialization of constants.");
+      this.initOffsetMuTextBox.TextChanged += new System.EventHandler(this.initOffsetMuTextBox_TextChanged);
+      // 
+      // initLengthLabel
+      // 
+      this.initLengthLabel.AutoSize = true;
+      this.initLengthLabel.Location = new System.Drawing.Point(6, 48);
+      this.initLengthLabel.Name = "initLengthLabel";
+      this.initLengthLabel.Size = new System.Drawing.Size(127, 20);
+      this.initLengthLabel.TabIndex = 2;
+      this.initLengthLabel.Text = "Length (mu, sig):";
+      this.toolTip.SetToolTip(this.initLengthLabel, "The maximal value to use for random initialization of constants.");
+      // 
+      // initLengthSigTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.initLengthSigTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.initLengthSigTextBox.Location = new System.Drawing.Point(268, 45);
+      this.initLengthSigTextBox.Name = "initLengthSigTextBox";
+      this.initLengthSigTextBox.Size = new System.Drawing.Size(124, 26);
+      this.initLengthSigTextBox.TabIndex = 3;
+      this.toolTip.SetToolTip(this.initLengthSigTextBox, "The maximal value to use for random initialization of constants.");
+      this.initLengthSigTextBox.TextChanged += new System.EventHandler(this.initLengthSigTextBox_TextChanged);
+      // 
+      // mutationGroupBox
+      // 
+      this.mutationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left) 
+            | System.Windows.Forms.AnchorStyles.Right)));
+      this.mutationGroupBox.Controls.Add(this.mutLengthMuTextBox);
+      this.mutationGroupBox.Controls.Add(this.mutOffsetMuTextBox);
+      this.mutationGroupBox.Controls.Add(this.mutLengthLabel);
+      this.mutationGroupBox.Controls.Add(this.mutLengthSigTextBox);
+      this.mutationGroupBox.Controls.Add(this.mutOffsetLabel);
+      this.mutationGroupBox.Controls.Add(this.mutOffsetSigTextBox);
+      this.mutationGroupBox.Location = new System.Drawing.Point(0, 254);
+      this.mutationGroupBox.Name = "mutationGroupBox";
+      this.mutationGroupBox.Size = new System.Drawing.Size(398, 82);
+      this.mutationGroupBox.TabIndex = 6;
+      this.mutationGroupBox.TabStop = false;
+      this.mutationGroupBox.Text = "Mutation";
+      // 
+      // mutLengthMuTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.mutLengthMuTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.mutLengthMuTextBox.Location = new System.Drawing.Point(138, 45);
+      this.mutLengthMuTextBox.Name = "mutLengthMuTextBox";
+      this.mutLengthMuTextBox.Size = new System.Drawing.Size(124, 26);
+      this.mutLengthMuTextBox.TabIndex = 5;
+      this.toolTip.SetToolTip(this.mutLengthMuTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample a mu" +
+        "ltiplicative change.");
+      this.mutLengthMuTextBox.TextChanged += new System.EventHandler(this.mutLengthMuTextBox_TextChanged);
+      // 
+      // mutOffsetMuTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.mutOffsetMuTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.mutOffsetMuTextBox.Location = new System.Drawing.Point(138, 19);
+      this.mutOffsetMuTextBox.Name = "mutOffsetMuTextBox";
+      this.mutOffsetMuTextBox.Size = new System.Drawing.Size(124, 26);
+      this.mutOffsetMuTextBox.TabIndex = 4;
+      this.toolTip.SetToolTip(this.mutOffsetMuTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample an a" +
+        "dditive change.");
+      this.mutOffsetMuTextBox.TextChanged += new System.EventHandler(this.mutOffsetMuTextBox_TextChanged);
+      // 
+      // mutLengthLabel
+      // 
+      this.mutLengthLabel.AutoSize = true;
+      this.mutLengthLabel.Location = new System.Drawing.Point(6, 48);
+      this.mutLengthLabel.Name = "mutLengthLabel";
+      this.mutLengthLabel.Size = new System.Drawing.Size(127, 20);
+      this.mutLengthLabel.TabIndex = 2;
+      this.mutLengthLabel.Text = "Length (mu, sig):";
+      this.toolTip.SetToolTip(this.mutLengthLabel, "The sigma (std. dev.) parameter for the normal distribution to use to sample the " +
+        "multiplicative change.");
+      // 
+      // mutLengthSigTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.mutLengthSigTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.mutLengthSigTextBox.Location = new System.Drawing.Point(268, 45);
+      this.mutLengthSigTextBox.Name = "mutLengthSigTextBox";
+      this.mutLengthSigTextBox.Size = new System.Drawing.Size(124, 26);
+      this.mutLengthSigTextBox.TabIndex = 3;
+      this.toolTip.SetToolTip(this.mutLengthSigTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample a mu" +
+        "ltiplicative change.");
+      this.mutLengthSigTextBox.TextChanged += new System.EventHandler(this.mutLengthSigTextBox_TextChanged);
+      // 
+      // mutOffsetLabel
+      // 
+      this.mutOffsetLabel.AutoSize = true;
+      this.mutOffsetLabel.Location = new System.Drawing.Point(6, 22);
+      this.mutOffsetLabel.Name = "mutOffsetLabel";
+      this.mutOffsetLabel.Size = new System.Drawing.Size(121, 20);
+      this.mutOffsetLabel.TabIndex = 0;
+      this.mutOffsetLabel.Text = "Offset (mu, sig):";
+      this.toolTip.SetToolTip(this.mutOffsetLabel, "The sigma (std. dev.) parameter for the normal distribution to sample the additiv" +
+        "e change.");
+      // 
+      // mutOffsetSigTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.mutOffsetSigTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.mutOffsetSigTextBox.Location = new System.Drawing.Point(268, 19);
+      this.mutOffsetSigTextBox.Name = "mutOffsetSigTextBox";
+      this.mutOffsetSigTextBox.Size = new System.Drawing.Size(124, 26);
+      this.mutOffsetSigTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.mutOffsetSigTextBox, "The sigma (std. dev.) parameter for the normal distribution to use to sample an a" +
+        "dditive change.");
+      this.mutOffsetSigTextBox.TextChanged += new System.EventHandler(this.mutOffsetSigTextBox_TextChanged);
+      // 
+      // enableWindowedCheckBox
+      // 
+      this.enableWindowedCheckBox.AutoSize = true;
+      this.enableWindowedCheckBox.Location = new System.Drawing.Point(3, 134);
+      this.enableWindowedCheckBox.Name = "enableWindowedCheckBox";
+      this.enableWindowedCheckBox.Size = new System.Drawing.Size(175, 24);
+      this.enableWindowedCheckBox.TabIndex = 10;
+      this.enableWindowedCheckBox.Text = "Windowing Enabled";
+      this.enableWindowedCheckBox.UseVisualStyleBackColor = true;
+      this.enableWindowedCheckBox.CheckedChanged += new System.EventHandler(this.enableWindowedCheckBox_CheckedChanged);
+      // 
+      // WindowedSymbolView
+      // 
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.enableWindowedCheckBox);
+      this.Controls.Add(this.mutationGroupBox);
+      this.Controls.Add(this.initializationGroupBox);
+      this.Name = "WindowedSymbolView";
+      this.Size = new System.Drawing.Size(398, 340);
+      this.Controls.SetChildIndex(this.enabledCheckBox, 0);
+      this.Controls.SetChildIndex(this.maximumArityLabel, 0);
+      this.Controls.SetChildIndex(this.maximumArityTextBox, 0);
+      this.Controls.SetChildIndex(this.minimumArityLabel, 0);
+      this.Controls.SetChildIndex(this.minimumArityTextBox, 0);
+      this.Controls.SetChildIndex(this.infoLabel, 0);
+      this.Controls.SetChildIndex(this.initializationGroupBox, 0);
+      this.Controls.SetChildIndex(this.initialFrequencyTextBox, 0);
+      this.Controls.SetChildIndex(this.initialFrequencyLabel, 0);
+      this.Controls.SetChildIndex(this.nameLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.mutationGroupBox, 0);
+      this.Controls.SetChildIndex(this.enableWindowedCheckBox, 0);
+      ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.initializationGroupBox.ResumeLayout(false);
+      this.initializationGroupBox.PerformLayout();
+      this.mutationGroupBox.ResumeLayout(false);
+      this.mutationGroupBox.PerformLayout();
+      this.ResumeLayout(false);
+      this.PerformLayout();
+
+    }
+
+    #endregion
+
+    private System.Windows.Forms.Label initOffsetLabel;
+    private System.Windows.Forms.TextBox initOffsetSigTextBox;
+    protected System.Windows.Forms.GroupBox initializationGroupBox;
+    private System.Windows.Forms.Label initLengthLabel;
+    private System.Windows.Forms.TextBox initLengthSigTextBox;
+    protected System.Windows.Forms.GroupBox mutationGroupBox;
+    private System.Windows.Forms.Label mutLengthLabel;
+    private System.Windows.Forms.TextBox mutLengthSigTextBox;
+    private System.Windows.Forms.Label mutOffsetLabel;
+    private System.Windows.Forms.TextBox mutOffsetSigTextBox;
+    private System.Windows.Forms.TextBox initLengthMuTextBox;
+    private System.Windows.Forms.TextBox initOffsetMuTextBox;
+    private System.Windows.Forms.TextBox mutLengthMuTextBox;
+    private System.Windows.Forms.TextBox mutOffsetMuTextBox;
+    private System.Windows.Forms.CheckBox enableWindowedCheckBox;
+  }
+}
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/WindowedSymbolView.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/WindowedSymbolView.cs	(revision 17573)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/WindowedSymbolView.cs	(revision 17573)
@@ -0,0 +1,177 @@
+﻿#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 System.Windows.Forms;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
+using HeuristicLab.MainForm;
+using HeuristicLab.MainForm.WindowsForms;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
+  [View("WindowedSymbol View")]
+  [Content(typeof(WindowedSymbol), true)]
+  public partial class WindowedSymbolView : SymbolView {
+    public new WindowedSymbol Content {
+      get { return (WindowedSymbol)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public WindowedSymbolView() {
+      InitializeComponent();
+    }
+
+    protected override void RegisterContentEvents() {
+      base.RegisterContentEvents();
+      Content.Changed += new EventHandler(Content_Changed);
+    }
+
+    protected override void DeregisterContentEvents() {
+      base.DeregisterContentEvents();
+      Content.Changed -= new EventHandler(Content_Changed);
+    }
+
+    protected override void OnContentChanged() {
+      base.OnContentChanged();
+      UpdateControl();
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+
+      initializationGroupBox.Enabled = Content != null && Content.EnableWindowing;
+      mutationGroupBox.Enabled = Content != null && Content.EnableWindowing;
+
+      initOffsetMuTextBox.ReadOnly = ReadOnly;
+      initOffsetSigTextBox.ReadOnly = ReadOnly;
+      initLengthMuTextBox.ReadOnly = ReadOnly;
+      initLengthSigTextBox.ReadOnly = ReadOnly;
+      mutOffsetMuTextBox.ReadOnly = ReadOnly;
+      mutOffsetSigTextBox.ReadOnly = ReadOnly;
+      mutLengthMuTextBox.ReadOnly = ReadOnly;
+      mutLengthSigTextBox.ReadOnly = ReadOnly;
+    }
+
+    #region content event handlers
+    private void Content_Changed(object sender, EventArgs e) {
+      UpdateControl();
+    }
+    #endregion
+
+    #region control event handlers
+    private void enableWindowedCheckBox_CheckedChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      Content.EnableWindowing = enableWindowedCheckBox.Checked;
+    }
+
+    private void initOffsetMuTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(initOffsetMuTextBox.Text, out double initOffsetMu)) {
+        Content.OffsetMu = initOffsetMu;
+        errorProvider.SetError(initOffsetMuTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(initOffsetMuTextBox, "Invalid value");
+      }
+    }
+    private void initOffsetSigTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(initOffsetSigTextBox.Text, out double initOffsetSig)) {
+        Content.OffsetSigma = initOffsetSig;
+        errorProvider.SetError(initOffsetSigTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(initOffsetSigTextBox, "Invalid value");
+      }
+    }
+    private void initLengthMuTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(initLengthMuTextBox.Text, out double initLengthMu)) {
+        Content.LengthMu = initLengthMu;
+        errorProvider.SetError(initLengthMuTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(initLengthMuTextBox, "Invalid value");
+      }
+    }
+    private void initLengthSigTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(initLengthSigTextBox.Text, out double initLengthSig)) {
+        Content.LengthSigma = initLengthSig;
+        errorProvider.SetError(initLengthSigTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(initLengthSigTextBox, "Invalid value");
+      }
+    }
+
+    private void mutOffsetMuTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(mutOffsetMuTextBox.Text, out double mutOffsetMu)) {
+        Content.ManipulatorOffsetMu = mutOffsetMu;
+        errorProvider.SetError(mutOffsetMuTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(mutOffsetMuTextBox, "Invalid value");
+      }
+    }
+    private void mutOffsetSigTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(mutOffsetSigTextBox.Text, out double mutOffsetSig)) {
+        Content.ManipulatorOffsetSigma = mutOffsetSig;
+        errorProvider.SetError(mutOffsetSigTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(mutOffsetSigTextBox, "Invalid value");
+      }
+    }
+    private void mutLengthMuTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(mutLengthMuTextBox.Text, out double mutLengthMu)) {
+        Content.ManipulatorLengthMu = mutLengthMu;
+        errorProvider.SetError(mutLengthMuTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(mutLengthMuTextBox, "Invalid value");
+      }
+    }
+    private void mutLengthSigTextBox_TextChanged(object sender, EventArgs e) {
+      if (Content == null) return;
+      if (double.TryParse(mutLengthSigTextBox.Text, out double mutLengthSig)) {
+        Content.ManipulatorLengthSigma = mutLengthSig;
+        errorProvider.SetError(mutLengthSigTextBox, string.Empty);
+      } else {
+        errorProvider.SetError(mutLengthSigTextBox, "Invalid value");
+      }
+    }
+    #endregion
+
+    #region helpers
+    private void UpdateControl() {
+      enableWindowedCheckBox.Checked = Content?.EnableWindowing ?? false;
+
+      initOffsetMuTextBox.Text = Content?.OffsetMu.ToString() ?? string.Empty;
+      initOffsetSigTextBox.Text = Content?.OffsetSigma.ToString() ?? string.Empty;
+      initLengthMuTextBox.Text = Content?.LengthMu.ToString() ?? string.Empty;
+      initLengthSigTextBox.Text = Content?.LengthSigma.ToString() ?? string.Empty;
+
+      mutOffsetMuTextBox.Text = Content?.ManipulatorOffsetMu.ToString() ?? string.Empty;
+      mutOffsetSigTextBox.Text = Content?.ManipulatorOffsetSigma.ToString() ?? string.Empty;
+      mutLengthMuTextBox.Text = Content?.ManipulatorLengthMu.ToString() ?? string.Empty;
+      mutLengthSigTextBox.Text = Content?.ManipulatorLengthSigma.ToString() ?? string.Empty;
+    
+      SetEnabledStateOfControls();
+    }
+    #endregion
+  }
+}
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 17572)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 17573)
@@ -181,4 +181,6 @@
     <Compile Include="Importer\Token.cs" />
     <Compile Include="Interfaces\IModelBacktransformator.cs" />
+    <Compile Include="Interfaces\IWindowedSymbolTreeNode.cs" />
+    <Compile Include="Interfaces\IWindowedSymbol.cs" />
     <Compile Include="Interfaces\IVariableTreeNode.cs" />
     <Compile Include="Interfaces\IVariableSymbol.cs" />
@@ -250,4 +252,6 @@
     <Compile Include="Symbols\Kurtosis.cs" />
     <Compile Include="Symbols\Skewness.cs" />
+    <Compile Include="Symbols\WindowedSymbolTreeNode.cs" />
+    <Compile Include="Symbols\WindowedSymbol.cs" />
     <Compile Include="Symbols\Variance.cs" />
     <Compile Include="Symbols\StandardDeviation.cs" />
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbol.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbol.cs	(revision 17573)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbol.cs	(revision 17573)
@@ -0,0 +1,32 @@
+#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 HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HEAL.Attic;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("BB96C8EF-4DB8-4892-B3A3-358F34C06AD6")]
+  /// <summary>
+  /// Any symbol that can use a window (e.g. partial aggregation of a vector)
+  /// </summary>
+  public interface IWindowedSymbol : ISymbol {
+  }
+}
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbolTreeNode.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbolTreeNode.cs	(revision 17573)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IWindowedSymbolTreeNode.cs	(revision 17573)
@@ -0,0 +1,34 @@
+#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 HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HEAL.Attic;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableType("7EF181F5-6595-41D4-8D40-94B1DA0BC28A")]
+  /// <summary>
+  /// Any tree node that references a windowed function
+  /// </summary>
+  public interface IWindowedSymbolTreeNode : ISymbolicExpressionTreeNode {
+    double Offset { get; }
+    double Length { get; }
+  }
+}
Index: branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs
===================================================================
--- branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs	(revision 17572)
+++ branches/3040_VectorBasedGP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeVectorInterpreter.cs	(revision 17573)
@@ -22,4 +22,5 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -41,4 +42,5 @@
       Median,
       Sum,
+      First,
       NaN,
       Exception
@@ -127,4 +129,5 @@
           else if (FinalAggregation == Aggregation.Median) yield return Statistics.Median(result.Vector);
           else if (FinalAggregation == Aggregation.Sum) yield return result.Vector.Sum();
+          else if (FinalAggregation == Aggregation.First) yield return result.Vector.First();
           else if (FinalAggregation == Aggregation.Exception) throw new InvalidOperationException("Result of the tree is not a scalar.");
           else yield return double.NaN;
@@ -221,4 +224,22 @@
       return EvaluationResult.NaN;
     }
+
+    private static EvaluationResult AggregateApply(EvaluationResult val, WindowedSymbolTreeNode node,
+      Func<double, double> sFunc = null,
+      Func<DoubleVector, double> vFunc = null) {
+
+      var offset = node.Offset;
+      var length = node.Length;
+
+      DoubleVector SubVector(DoubleVector v) {
+        int index = (int)(offset * v.Count);
+        int count = (int)(length * (v.Count - index));
+        return v.SubVector(index, count);
+      };
+
+      if (val.IsScalar && sFunc != null) return new EvaluationResult(sFunc(val.Scalar));
+      if (val.IsVector && vFunc != null) return new EvaluationResult(vFunc(SubVector(val.Vector)));
+      return EvaluationResult.NaN;
+    }
     private static EvaluationResult AggregateMultipleApply(EvaluationResult lhs, EvaluationResult rhs,
       Func<double, double, double> ssFunc = null,
@@ -360,5 +381,5 @@
         case OpCodes.Sum: {
             var cur = Evaluate(dataset, ref row, state);
-            return AggregateApply(cur,
+            return AggregateApply(cur, (WindowedSymbolTreeNode)currentInstr.dynamicNode,
               s => s,
               v => v.Sum());
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 17572)
+++ 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();
+    }
+  }
+}
