Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblemBase.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblemBase.cs	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblemBase.cs	(revision 5060)
@@ -284,4 +284,7 @@
         varSymbol.VariableNames = DataAnalysisProblemData.InputVariables.CheckedItems.Select(x => x.Value.Value);
       }
+      foreach (var varSymbol in FunctionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols.VariableCondition>()) {
+        varSymbol.VariableNames = DataAnalysisProblemData.InputVariables.CheckedItems.Select(x => x.Value.Value);
+      }
       var globalGrammar = FunctionTreeGrammar as GlobalSymbolicExpressionGrammar;
       if (globalGrammar != null) {
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/HeuristicLab.Problems.DataAnalysis.Views-3.3.csproj
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/HeuristicLab.Problems.DataAnalysis.Views-3.3.csproj	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/HeuristicLab.Problems.DataAnalysis.Views-3.3.csproj	(revision 5060)
@@ -250,4 +250,10 @@
     <Compile Include="Symbolic\Symbols\ConstantView.Designer.cs">
       <DependentUpon>ConstantView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Symbolic\Symbols\VariableConditionView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Symbolic\Symbols\VariableConditionView.Designer.cs">
+      <DependentUpon>VariableConditionView.cs</DependentUpon>
     </Compile>
     <Compile Include="Symbolic\Symbols\LaggedVariableView.cs">
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/Symbols/VariableConditionView.Designer.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/Symbols/VariableConditionView.Designer.cs	(revision 5060)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/Symbols/VariableConditionView.Designer.cs	(revision 5060)
@@ -0,0 +1,356 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Views.Symbolic.Symbols {
+  partial class VariableConditionView {
+    /// <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.thresholdInitializationMuLabel = new System.Windows.Forms.Label();
+      this.thresholdInitializationMuTextBox = new System.Windows.Forms.TextBox();
+      this.initializationGroupBox = new System.Windows.Forms.GroupBox();
+      this.slopeInitializationSigmaLabel = new System.Windows.Forms.Label();
+      this.slopeInitializationSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.slopeInitializationMuLabel = new System.Windows.Forms.Label();
+      this.slopeInitializationMuTextBox = new System.Windows.Forms.TextBox();
+      this.thresholdInitializationSigmaLabel = new System.Windows.Forms.Label();
+      this.thresholdInitializationSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.mutationGroupBox = new System.Windows.Forms.GroupBox();
+      this.slopeChangeSigmaLabel = new System.Windows.Forms.Label();
+      this.slopeChangeSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.slopeChangeMuLabel = new System.Windows.Forms.Label();
+      this.slopeChangeMuTextBox = new System.Windows.Forms.TextBox();
+      this.thresholdChangeSigmaLabel = new System.Windows.Forms.Label();
+      this.thresholdChangeSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.ThresholdChangeMuLabel = new System.Windows.Forms.Label();
+      this.thresholdChangeMuTextBox = new System.Windows.Forms.TextBox();
+      ((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(203, 20);
+      // 
+      // nameTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.errorProvider.SetIconPadding(this.nameTextBox, 2);
+      this.nameTextBox.Size = new System.Drawing.Size(203, 20);
+      // 
+      // descriptionTextBox
+      // 
+      this.errorProvider.SetIconAlignment(this.descriptionTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.descriptionTextBox.Size = new System.Drawing.Size(203, 20);
+      // 
+      // thresholdInitializationMuLabel
+      // 
+      this.thresholdInitializationMuLabel.AutoSize = true;
+      this.thresholdInitializationMuLabel.Location = new System.Drawing.Point(6, 18);
+      this.thresholdInitializationMuLabel.Name = "thresholdInitializationMuLabel";
+      this.thresholdInitializationMuLabel.Size = new System.Drawing.Size(80, 13);
+      this.thresholdInitializationMuLabel.TabIndex = 6;
+      this.thresholdInitializationMuLabel.Text = "Threshold (mu):";
+      this.toolTip.SetToolTip(this.thresholdInitializationMuLabel, "The mu (mean) parameter of the normal distribution to use for initial weights.");
+      // 
+      // thresholdInitializationMuTextBox
+      // 
+      this.thresholdInitializationMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdInitializationMuTextBox.Location = new System.Drawing.Point(114, 15);
+      this.thresholdInitializationMuTextBox.Name = "thresholdInitializationMuTextBox";
+      this.thresholdInitializationMuTextBox.Size = new System.Drawing.Size(197, 20);
+      this.thresholdInitializationMuTextBox.TabIndex = 7;
+      this.toolTip.SetToolTip(this.thresholdInitializationMuTextBox, "The mu (mean) parameter of the normal distribution from which to sample the initi" +
+              "al thresholds.");
+      this.thresholdInitializationMuTextBox.TextChanged += new System.EventHandler(this.thresholdMuTextBox_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.slopeInitializationSigmaLabel);
+      this.initializationGroupBox.Controls.Add(this.slopeInitializationSigmaTextBox);
+      this.initializationGroupBox.Controls.Add(this.slopeInitializationMuLabel);
+      this.initializationGroupBox.Controls.Add(this.slopeInitializationMuTextBox);
+      this.initializationGroupBox.Controls.Add(this.thresholdInitializationSigmaLabel);
+      this.initializationGroupBox.Controls.Add(this.thresholdInitializationSigmaTextBox);
+      this.initializationGroupBox.Controls.Add(this.thresholdInitializationMuLabel);
+      this.initializationGroupBox.Controls.Add(this.thresholdInitializationMuTextBox);
+      this.initializationGroupBox.Location = new System.Drawing.Point(3, 79);
+      this.initializationGroupBox.Name = "initializationGroupBox";
+      this.initializationGroupBox.Size = new System.Drawing.Size(320, 127);
+      this.initializationGroupBox.TabIndex = 8;
+      this.initializationGroupBox.TabStop = false;
+      this.initializationGroupBox.Text = "Initialization";
+      // 
+      // slopeInitializationSigmaLabel
+      // 
+      this.slopeInitializationSigmaLabel.AutoSize = true;
+      this.slopeInitializationSigmaLabel.Location = new System.Drawing.Point(6, 105);
+      this.slopeInitializationSigmaLabel.Name = "slopeInitializationSigmaLabel";
+      this.slopeInitializationSigmaLabel.Size = new System.Drawing.Size(73, 13);
+      this.slopeInitializationSigmaLabel.TabIndex = 12;
+      this.slopeInitializationSigmaLabel.Text = "Slope (sigma):";
+      this.toolTip.SetToolTip(this.slopeInitializationSigmaLabel, "The sigma parameter for the normal distribution to use for the initial slopes.");
+      // 
+      // slopeInitializationSigmaTextBox
+      // 
+      this.slopeInitializationSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.slopeInitializationSigmaTextBox.Location = new System.Drawing.Point(114, 102);
+      this.slopeInitializationSigmaTextBox.Name = "slopeInitializationSigmaTextBox";
+      this.slopeInitializationSigmaTextBox.Size = new System.Drawing.Size(197, 20);
+      this.slopeInitializationSigmaTextBox.TabIndex = 13;
+      this.toolTip.SetToolTip(this.slopeInitializationSigmaTextBox, "The sigma parameter for the normal distribution from which to sample the initial " +
+              "slopes.");
+      this.slopeInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.slopeInitializationSigmaTextBox_TextChanged);
+      // 
+      // slopeInitializationMuLabel
+      // 
+      this.slopeInitializationMuLabel.AutoSize = true;
+      this.slopeInitializationMuLabel.Location = new System.Drawing.Point(6, 79);
+      this.slopeInitializationMuLabel.Name = "slopeInitializationMuLabel";
+      this.slopeInitializationMuLabel.Size = new System.Drawing.Size(60, 13);
+      this.slopeInitializationMuLabel.TabIndex = 10;
+      this.slopeInitializationMuLabel.Text = "Slope (mu):";
+      this.toolTip.SetToolTip(this.slopeInitializationMuLabel, "The mu (mean) parameter of the normal distribution to use for initial slopes.");
+      // 
+      // slopeInitializationMuTextBox
+      // 
+      this.slopeInitializationMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.slopeInitializationMuTextBox.Location = new System.Drawing.Point(114, 76);
+      this.slopeInitializationMuTextBox.Name = "slopeInitializationMuTextBox";
+      this.slopeInitializationMuTextBox.Size = new System.Drawing.Size(197, 20);
+      this.slopeInitializationMuTextBox.TabIndex = 11;
+      this.toolTip.SetToolTip(this.slopeInitializationMuTextBox, "The mu (mean) parameter of the normal distribution from which to sample the initi" +
+              "al slopes.");
+      this.slopeInitializationMuTextBox.TextChanged += new System.EventHandler(this.slopeInitializationMuTextBox_TextChanged);
+      // 
+      // thresholdInitializationSigmaLabel
+      // 
+      this.thresholdInitializationSigmaLabel.AutoSize = true;
+      this.thresholdInitializationSigmaLabel.Location = new System.Drawing.Point(6, 44);
+      this.thresholdInitializationSigmaLabel.Name = "thresholdInitializationSigmaLabel";
+      this.thresholdInitializationSigmaLabel.Size = new System.Drawing.Size(93, 13);
+      this.thresholdInitializationSigmaLabel.TabIndex = 8;
+      this.thresholdInitializationSigmaLabel.Text = "Threshold (sigma):";
+      this.toolTip.SetToolTip(this.thresholdInitializationSigmaLabel, "The sigma parameter for the normal distribution to use for the initial weights.");
+      // 
+      // thresholdInitializationSigmaTextBox
+      // 
+      this.thresholdInitializationSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdInitializationSigmaTextBox.Location = new System.Drawing.Point(114, 41);
+      this.thresholdInitializationSigmaTextBox.Name = "thresholdInitializationSigmaTextBox";
+      this.thresholdInitializationSigmaTextBox.Size = new System.Drawing.Size(197, 20);
+      this.thresholdInitializationSigmaTextBox.TabIndex = 9;
+      this.toolTip.SetToolTip(this.thresholdInitializationSigmaTextBox, "The sigma parameter for the normal distribution from which to sample the initial " +
+              "thresholds.");
+      this.thresholdInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.thresholdInitializationSigmaTextBox_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.slopeChangeSigmaLabel);
+      this.mutationGroupBox.Controls.Add(this.slopeChangeSigmaTextBox);
+      this.mutationGroupBox.Controls.Add(this.slopeChangeMuLabel);
+      this.mutationGroupBox.Controls.Add(this.slopeChangeMuTextBox);
+      this.mutationGroupBox.Controls.Add(this.thresholdChangeSigmaLabel);
+      this.mutationGroupBox.Controls.Add(this.thresholdChangeSigmaTextBox);
+      this.mutationGroupBox.Controls.Add(this.ThresholdChangeMuLabel);
+      this.mutationGroupBox.Controls.Add(this.thresholdChangeMuTextBox);
+      this.mutationGroupBox.Location = new System.Drawing.Point(3, 212);
+      this.mutationGroupBox.Name = "mutationGroupBox";
+      this.mutationGroupBox.Size = new System.Drawing.Size(320, 127);
+      this.mutationGroupBox.TabIndex = 9;
+      this.mutationGroupBox.TabStop = false;
+      this.mutationGroupBox.Text = "Mutation";
+      // 
+      // slopeChangeSigmaLabel
+      // 
+      this.slopeChangeSigmaLabel.AutoSize = true;
+      this.slopeChangeSigmaLabel.Location = new System.Drawing.Point(6, 102);
+      this.slopeChangeSigmaLabel.Name = "slopeChangeSigmaLabel";
+      this.slopeChangeSigmaLabel.Size = new System.Drawing.Size(112, 13);
+      this.slopeChangeSigmaLabel.TabIndex = 12;
+      this.slopeChangeSigmaLabel.Text = "Slope change (sigma):";
+      this.toolTip.SetToolTip(this.slopeChangeSigmaLabel, "The sigma parameter for the normal distribution to use to sample the change in sl" +
+              "ope.");
+      // 
+      // slopeChangeSigmaTextBox
+      // 
+      this.slopeChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.slopeChangeSigmaTextBox.Location = new System.Drawing.Point(149, 99);
+      this.slopeChangeSigmaTextBox.Name = "slopeChangeSigmaTextBox";
+      this.slopeChangeSigmaTextBox.Size = new System.Drawing.Size(162, 20);
+      this.slopeChangeSigmaTextBox.TabIndex = 13;
+      this.toolTip.SetToolTip(this.slopeChangeSigmaTextBox, "The sigma parameter for the normal distribution to use to sample the change in sl" +
+              "ope.");
+      this.slopeChangeSigmaTextBox.TextChanged += new System.EventHandler(this.slopeChangeSigmaTextBox_TextChanged);
+      // 
+      // slopeChangeMuLabel
+      // 
+      this.slopeChangeMuLabel.AutoSize = true;
+      this.slopeChangeMuLabel.Location = new System.Drawing.Point(6, 76);
+      this.slopeChangeMuLabel.Name = "slopeChangeMuLabel";
+      this.slopeChangeMuLabel.Size = new System.Drawing.Size(99, 13);
+      this.slopeChangeMuLabel.TabIndex = 10;
+      this.slopeChangeMuLabel.Text = "Slope change (mu):";
+      this.toolTip.SetToolTip(this.slopeChangeMuLabel, "The nu (mean) parameter for the normal distribution to sample the change in slope" +
+              ".");
+      // 
+      // slopeChangeMuTextBox
+      // 
+      this.slopeChangeMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.slopeChangeMuTextBox.Location = new System.Drawing.Point(149, 73);
+      this.slopeChangeMuTextBox.Name = "slopeChangeMuTextBox";
+      this.slopeChangeMuTextBox.Size = new System.Drawing.Size(162, 20);
+      this.slopeChangeMuTextBox.TabIndex = 11;
+      this.toolTip.SetToolTip(this.slopeChangeMuTextBox, "The mu (mean) parameter for the normal distribution to sample the change in slope" +
+              ".");
+      this.slopeChangeMuTextBox.TextChanged += new System.EventHandler(this.slopeChangeMuTextBox_TextChanged);
+      // 
+      // thresholdChangeSigmaLabel
+      // 
+      this.thresholdChangeSigmaLabel.AutoSize = true;
+      this.thresholdChangeSigmaLabel.Location = new System.Drawing.Point(6, 44);
+      this.thresholdChangeSigmaLabel.Name = "thresholdChangeSigmaLabel";
+      this.thresholdChangeSigmaLabel.Size = new System.Drawing.Size(132, 13);
+      this.thresholdChangeSigmaLabel.TabIndex = 8;
+      this.thresholdChangeSigmaLabel.Text = "Threshold change (sigma):";
+      this.toolTip.SetToolTip(this.thresholdChangeSigmaLabel, "The sigma parameter for the normal distribution to use to sample the change in th" +
+              "reshold.");
+      // 
+      // thresholdChangeSigmaTextBox
+      // 
+      this.thresholdChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdChangeSigmaTextBox.Location = new System.Drawing.Point(149, 41);
+      this.thresholdChangeSigmaTextBox.Name = "thresholdChangeSigmaTextBox";
+      this.thresholdChangeSigmaTextBox.Size = new System.Drawing.Size(162, 20);
+      this.thresholdChangeSigmaTextBox.TabIndex = 9;
+      this.toolTip.SetToolTip(this.thresholdChangeSigmaTextBox, "The sigma parameter for the normal distribution to use to sample the change in th" +
+              "reshold.");
+      this.thresholdChangeSigmaTextBox.TextChanged += new System.EventHandler(this.thresholdChangeSigmaTextBox_TextChanged);
+      // 
+      // ThresholdChangeMuLabel
+      // 
+      this.ThresholdChangeMuLabel.AutoSize = true;
+      this.ThresholdChangeMuLabel.Location = new System.Drawing.Point(6, 18);
+      this.ThresholdChangeMuLabel.Name = "ThresholdChangeMuLabel";
+      this.ThresholdChangeMuLabel.Size = new System.Drawing.Size(119, 13);
+      this.ThresholdChangeMuLabel.TabIndex = 6;
+      this.ThresholdChangeMuLabel.Text = "Threshold change (mu):";
+      this.toolTip.SetToolTip(this.ThresholdChangeMuLabel, "The nu (mean) parameter for the normal distribution to sample the change in thres" +
+              "hold.");
+      // 
+      // thresholdChangeMuTextBox
+      // 
+      this.thresholdChangeMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdChangeMuTextBox.Location = new System.Drawing.Point(149, 15);
+      this.thresholdChangeMuTextBox.Name = "thresholdChangeMuTextBox";
+      this.thresholdChangeMuTextBox.Size = new System.Drawing.Size(162, 20);
+      this.thresholdChangeMuTextBox.TabIndex = 7;
+      this.toolTip.SetToolTip(this.thresholdChangeMuTextBox, "The mu (mean) parameter for the normal distribution to sample the change in thres" +
+              "hold.");
+      this.thresholdChangeMuTextBox.TextChanged += new System.EventHandler(this.thresholdChangeMuTextBox_TextChanged);
+      // 
+      // VariableConditionView
+      // 
+      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.Controls.Add(this.mutationGroupBox);
+      this.Controls.Add(this.initializationGroupBox);
+      this.Name = "VariableConditionView";
+      this.Size = new System.Drawing.Size(326, 344);
+      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.descriptionLabel, 0);
+      this.Controls.SetChildIndex(this.nameTextBox, 0);
+      this.Controls.SetChildIndex(this.descriptionTextBox, 0);
+      this.Controls.SetChildIndex(this.mutationGroupBox, 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 thresholdInitializationMuLabel;
+    private System.Windows.Forms.TextBox thresholdInitializationMuTextBox;
+    protected System.Windows.Forms.GroupBox initializationGroupBox;
+    private System.Windows.Forms.Label thresholdInitializationSigmaLabel;
+    private System.Windows.Forms.TextBox thresholdInitializationSigmaTextBox;
+    protected System.Windows.Forms.GroupBox mutationGroupBox;
+    private System.Windows.Forms.Label thresholdChangeSigmaLabel;
+    private System.Windows.Forms.TextBox thresholdChangeSigmaTextBox;
+    private System.Windows.Forms.Label ThresholdChangeMuLabel;
+    private System.Windows.Forms.TextBox thresholdChangeMuTextBox;
+    private System.Windows.Forms.Label slopeInitializationSigmaLabel;
+    private System.Windows.Forms.TextBox slopeInitializationSigmaTextBox;
+    private System.Windows.Forms.Label slopeInitializationMuLabel;
+    private System.Windows.Forms.TextBox slopeInitializationMuTextBox;
+    private System.Windows.Forms.Label slopeChangeSigmaLabel;
+    private System.Windows.Forms.TextBox slopeChangeSigmaTextBox;
+    private System.Windows.Forms.Label slopeChangeMuLabel;
+    private System.Windows.Forms.TextBox slopeChangeMuTextBox;
+
+  }
+}
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/Symbols/VariableConditionView.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/Symbols/VariableConditionView.cs	(revision 5060)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis.Views/3.3/Symbolic/Symbols/VariableConditionView.cs	(revision 5060)
@@ -0,0 +1,167 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
+
+namespace HeuristicLab.Problems.DataAnalysis.Views.Symbolic.Symbols {
+  [View("Variable View")]
+  [Content(typeof(VariableCondition), true)]
+  public partial class VariableConditionView : SymbolView {
+    public new VariableCondition Content {
+      get { return (VariableCondition)base.Content; }
+      set { base.Content = value; }
+    }
+
+    public VariableConditionView() {
+      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();
+    }
+    private void Content_Changed(object sender, EventArgs e) {
+      UpdateControl();
+    }
+
+    protected override void SetEnabledStateOfControls() {
+      base.SetEnabledStateOfControls();
+      thresholdInitializationMuTextBox.Enabled = Content != null;
+      thresholdInitializationMuTextBox.ReadOnly = ReadOnly;
+      thresholdInitializationSigmaTextBox.Enabled = Content != null;
+      thresholdInitializationSigmaTextBox.ReadOnly = ReadOnly;
+      slopeInitializationMuTextBox.Enabled = Content != null;
+      slopeInitializationMuTextBox.ReadOnly = ReadOnly;
+      slopeInitializationSigmaTextBox.Enabled = Content != null;
+      slopeInitializationSigmaTextBox.ReadOnly = ReadOnly;
+
+      thresholdChangeMuTextBox.Enabled = Content != null;
+      thresholdChangeMuTextBox.ReadOnly = ReadOnly;
+      thresholdChangeSigmaTextBox.Enabled = Content != null;
+      thresholdChangeSigmaTextBox.ReadOnly = ReadOnly;
+      slopeChangeMuTextBox.Enabled = Content != null;
+      slopeChangeMuTextBox.ReadOnly = ReadOnly;
+      slopeChangeSigmaTextBox.Enabled = Content != null;
+      slopeChangeSigmaTextBox.ReadOnly = ReadOnly;
+    }
+
+
+
+    private void UpdateControl() {
+      if (Content == null) {
+        thresholdInitializationMuTextBox.Text = string.Empty;
+        thresholdInitializationSigmaTextBox.Text = string.Empty;
+        slopeInitializationMuTextBox.Text = string.Empty;
+        slopeInitializationSigmaTextBox.Text = string.Empty;
+        thresholdChangeMuTextBox.Text = string.Empty;
+        thresholdChangeSigmaTextBox.Text = string.Empty;
+        slopeChangeMuTextBox.Text = string.Empty;
+        slopeChangeSigmaTextBox.Text = string.Empty;
+      } else {
+        thresholdInitializationMuTextBox.Text = Content.ThresholdInitializerMu.ToString();
+        thresholdInitializationSigmaTextBox.Text = Content.ThresholdInitializerSigma.ToString();
+        slopeInitializationMuTextBox.Text = Content.SlopeInitializerMu.ToString();
+        slopeInitializationSigmaTextBox.Text = Content.SlopeInitializerSigma.ToString();
+        thresholdChangeMuTextBox.Text = Content.ThresholdManipulatorMu.ToString();
+        thresholdChangeSigmaTextBox.Text = Content.ThresholdManipulatorSigma.ToString();
+        slopeChangeMuTextBox.Text = Content.SlopeManipulatorMu.ToString();
+        slopeChangeSigmaTextBox.Text = Content.SlopeManipulatorSigma.ToString();
+      }
+      SetEnabledStateOfControls();
+    }
+
+    #region control events
+    private void thresholdMuTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(thresholdInitializationMuTextBox.Text, out value)) {
+        Content.ThresholdInitializerMu = value;
+        errorProvider.SetError(thresholdInitializationMuTextBox, string.Empty);
+      } else errorProvider.SetError(thresholdInitializationMuTextBox, "Invalid value");
+    }
+    private void thresholdInitializationSigmaTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(thresholdInitializationSigmaTextBox.Text, out value)) {
+        Content.ThresholdInitializerSigma = value;
+        errorProvider.SetError(thresholdInitializationSigmaTextBox, string.Empty);
+      } else errorProvider.SetError(thresholdInitializationSigmaTextBox, "Invalid value");
+    }
+    private void slopeInitializationMuTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(slopeInitializationMuTextBox.Text, out value)) {
+        Content.SlopeInitializerMu = value;
+        errorProvider.SetError(slopeInitializationMuTextBox, string.Empty);
+      } else errorProvider.SetError(slopeInitializationMuTextBox, "Invalid value");
+    }
+    private void slopeInitializationSigmaTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(slopeInitializationSigmaTextBox.Text, out value)) {
+        Content.SlopeInitializerSigma = value;
+        errorProvider.SetError(slopeInitializationSigmaTextBox, string.Empty);
+      } else errorProvider.SetError(slopeInitializationSigmaTextBox, "Invalid value");
+    }
+
+    private void thresholdChangeMuTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(thresholdChangeMuTextBox.Text, out value)) {
+        Content.ThresholdManipulatorMu = value;
+        errorProvider.SetError(thresholdChangeMuTextBox, string.Empty);
+      } else errorProvider.SetError(thresholdChangeMuTextBox, "Invalid value");
+    }
+
+    private void thresholdChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(thresholdChangeSigmaTextBox.Text, out value)) {
+        Content.ThresholdManipulatorSigma = value;
+        errorProvider.SetError(thresholdChangeSigmaTextBox, string.Empty);
+      } else errorProvider.SetError(thresholdChangeSigmaTextBox, "Invalid value");
+    }
+    private void slopeChangeMuTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(slopeChangeMuTextBox.Text, out value)) {
+        Content.SlopeManipulatorMu = value;
+        errorProvider.SetError(slopeChangeMuTextBox, string.Empty);
+      } else errorProvider.SetError(slopeChangeMuTextBox, "Invalid value");
+    }
+
+    private void slopeChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+      double value;
+      if (double.TryParse(slopeChangeSigmaTextBox.Text, out value)) {
+        Content.SlopeManipulatorSigma = value;
+        errorProvider.SetError(slopeChangeSigmaTextBox, string.Empty);
+      } else errorProvider.SetError(slopeChangeSigmaTextBox, "Invalid value");
+    }
+    #endregion
+
+  }
+}
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/HeuristicLab.Problems.DataAnalysis-3.3.csproj
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/HeuristicLab.Problems.DataAnalysis-3.3.csproj	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/HeuristicLab.Problems.DataAnalysis-3.3.csproj	(revision 5060)
@@ -156,4 +156,6 @@
     <Compile Include="Symbolic\Symbols\Derivative.cs" />
     <Compile Include="Symbolic\Symbols\Integral.cs" />
+    <Compile Include="Symbolic\Symbols\VariableCondition.cs" />
+    <Compile Include="Symbolic\Symbols\VariableConditionTreeNode.cs" />
     <Compile Include="TableFileParser.cs" />
     <None Include="HeuristicLab.snk" />
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/FullFunctionalExpressionGrammar.cs	(revision 5060)
@@ -60,10 +60,14 @@
       var or = new Or();
       var not = new Not();
+
       var timeLag = new TimeLag();
       timeLag.InitialFrequency = 0.0;
       var integral = new Integral();
       integral.InitialFrequency = 0.0;
-      var derivativ = new Derivative();
-      derivativ.InitialFrequency = 0.0;
+      var derivative = new Derivative();
+      derivative.InitialFrequency = 0.0;
+
+      var variableCondition = new VariableCondition();
+      variableCondition.InitialFrequency = 0.0;
 
       var constant = new Constant();
@@ -74,7 +78,8 @@
       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, timeLag, integral, derivativ, constant, variableSymbol, laggedVariable };
-      var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not, timeLag, integral, derivativ };
-      var binaryFunctionSymbols = new List<Symbol>() { gt, lt };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, exp, @if, gt, lt,
+        and, or, not, timeLag, integral, derivative, variableCondition, constant, variableSymbol, laggedVariable };
+      var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not, timeLag, integral, derivative };
+      var binaryFunctionSymbols = new List<Symbol>() { gt, lt, variableCondition };
       var functionSymbols = new List<Symbol>() { add, sub, mul, div, mean, and, or };
       var terminalSymbols = new List<Symbol>() { variableSymbol, constant, laggedVariable };
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs	(revision 5060)
@@ -71,4 +71,6 @@
       public const byte Integral = 23;
       public const byte Derivative = 24;
+
+      public const byte VariableCondition = 25;
     }
 
@@ -97,5 +99,6 @@
       { typeof(TimeLag), OpCodes.TimeLag},
       { typeof(Integral), OpCodes.Integral},
-      { typeof(Derivative), OpCodes.Derivative}
+      { typeof(Derivative), OpCodes.Derivative},
+      { typeof(VariableCondition),OpCodes.VariableCondition}
     };
     private const int ARGUMENT_STACK_SIZE = 1024;
@@ -147,4 +150,7 @@
         var variableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
         instr.iArg0 = (ushort)dataset.GetVariableIndex(variableTreeNode.VariableName);
+      } else if (instr.opCode == OpCodes.VariableCondition) {
+        var variableConditionTreeNode = instr.dynamicNode as VariableConditionTreeNode;
+        instr.iArg0 = (ushort)dataset.GetVariableIndex(variableConditionTreeNode.VariableName);
       }
       return instr;
@@ -344,4 +350,18 @@
             return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
           }
+
+        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
+        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
+        case OpCodes.VariableCondition: {
+            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
+            double variableValue = dataset[row, currentInstr.iArg0];
+            double x = variableValue - variableConditionTreeNode.Threshold;
+            double p = 1 / (1 + Math.Exp(-variableConditionTreeNode.Slope * x));
+
+            double trueBranch = Evaluate();
+            double falseBranch = Evaluate();
+
+            return trueBranch * p + falseBranch * (1 - p);
+          }
         default: throw new NotSupportedException();
       }
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/Variable.cs	(revision 5060)
@@ -91,5 +91,6 @@
     #endregion
     [StorableConstructor]
-    protected Variable(bool deserializing) : base(deserializing) {
+    protected Variable(bool deserializing)
+      : base(deserializing) {
       variableNames = new List<string>();
     }
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableCondition.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableCondition.cs	(revision 5060)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableCondition.cs	(revision 5060)
@@ -0,0 +1,186 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
+  [StorableClass]
+  [Item("Variable Condition", "Represents a condition that tests a given variable.")]
+  public sealed class VariableCondition : Symbol {
+    #region properties
+    [Storable]
+    private double thresholdInitializerMu;
+    public double ThresholdInitializerMu {
+      get { return thresholdInitializerMu; }
+      set {
+        if (value != thresholdInitializerMu) {
+          thresholdInitializerMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double thresholdInitializerSigma;
+    public double ThresholdInitializerSigma {
+      get { return thresholdInitializerSigma; }
+      set {
+        if (thresholdInitializerSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != thresholdInitializerSigma) {
+          thresholdInitializerSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+
+    [Storable]
+    private double thresholdManipulatorMu;
+    public double ThresholdManipulatorMu {
+      get { return thresholdManipulatorMu; }
+      set {
+        if (value != thresholdManipulatorMu) {
+          thresholdManipulatorMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double thresholdManipulatorSigma;
+    public double ThresholdManipulatorSigma {
+      get { return thresholdManipulatorSigma; }
+      set {
+        if (thresholdManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != thresholdManipulatorSigma) {
+          thresholdManipulatorSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+
+    private List<string> variableNames;
+    [Storable]
+    public IEnumerable<string> VariableNames {
+      get { return variableNames; }
+      set {
+        if (value == null) throw new ArgumentNullException();
+        variableNames.Clear();
+        variableNames.AddRange(value);
+        OnChanged(EventArgs.Empty);
+      }
+    }
+
+    [Storable]
+    private double slopeInitializerMu;
+    public double SlopeInitializerMu {
+      get { return slopeInitializerMu; }
+      set {
+        if (value != slopeInitializerMu) {
+          slopeInitializerMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double slopeInitializerSigma;
+    public double SlopeInitializerSigma {
+      get { return slopeInitializerSigma; }
+      set {
+        if (slopeInitializerSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != slopeInitializerSigma) {
+          slopeInitializerSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+
+    [Storable]
+    private double slopeManipulatorMu;
+    public double SlopeManipulatorMu {
+      get { return slopeManipulatorMu; }
+      set {
+        if (value != slopeManipulatorMu) {
+          slopeManipulatorMu = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    [Storable]
+    private double slopeManipulatorSigma;
+    public double SlopeManipulatorSigma {
+      get { return slopeManipulatorSigma; }
+      set {
+        if (slopeManipulatorSigma < 0.0) throw new ArgumentException("Negative sigma is not allowed.");
+        if (value != slopeManipulatorSigma) {
+          slopeManipulatorSigma = value;
+          OnChanged(EventArgs.Empty);
+        }
+      }
+    }
+    #endregion
+
+    #region persistence and cloning
+    [StorableConstructor]
+    protected VariableCondition(bool deserializing) : base(deserializing) { }
+    protected VariableCondition(VariableCondition original, Cloner cloner)
+      : base(original, cloner) {
+      thresholdInitializerMu = original.thresholdInitializerMu;
+      thresholdInitializerSigma = original.thresholdInitializerSigma;
+      thresholdManipulatorMu = original.thresholdManipulatorMu;
+      thresholdManipulatorSigma = original.thresholdManipulatorSigma;
+
+      variableNames = new List<string>(original.variableNames);
+
+      slopeInitializerMu = original.slopeInitializerMu;
+      slopeInitializerSigma = original.slopeInitializerSigma;
+      slopeManipulatorMu = original.slopeManipulatorMu;
+      slopeManipulatorSigma = original.slopeManipulatorSigma;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableCondition(this, cloner);
+    }
+    #endregion
+
+    public VariableCondition() : this("Variable Condition", "Represents a condition that tests a given variable.") { }
+    public VariableCondition(string name, string description)
+      : base(name, description) {
+      thresholdInitializerMu = 0.0;
+      thresholdInitializerSigma = 1.0;
+      thresholdManipulatorMu = 0.0;
+      thresholdManipulatorSigma = 1.0;
+
+      variableNames = new List<string>();
+
+      slopeInitializerMu = 1.0;
+      slopeInitializerSigma = 0.5;
+      slopeManipulatorMu = 0.0;
+      slopeManipulatorSigma = 0.5;
+    }
+
+    public override SymbolicExpressionTreeNode CreateTreeNode() {
+      return new VariableConditionTreeNode(this);
+    }
+  }
+}
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableConditionTreeNode.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableConditionTreeNode.cs	(revision 5060)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableConditionTreeNode.cs	(revision 5060)
@@ -0,0 +1,94 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2010 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 HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols {
+  [StorableClass]
+  public sealed class VariableConditionTreeNode : SymbolicExpressionTreeNode {
+    #region properties
+    public new VariableCondition Symbol {
+      get { return (VariableCondition)base.Symbol; }
+    }
+    [Storable]
+    private double threshold;
+    public double Threshold {
+      get { return threshold; }
+      set { threshold = value; }
+    }
+    [Storable]
+    private string variableName;
+    public string VariableName {
+      get { return variableName; }
+      set { variableName = value; }
+    }
+    [Storable]
+    private double slope;
+    public double Slope {
+      get { return slope; }
+      set { slope = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private VariableConditionTreeNode(bool deserializing) : base(deserializing) { }
+    private VariableConditionTreeNode(VariableConditionTreeNode original, Cloner cloner)
+      : base(original, cloner) {
+      threshold = original.threshold;
+      variableName = original.variableName;
+      slope = original.slope;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableConditionTreeNode(this, cloner);
+    }
+
+    public VariableConditionTreeNode(VariableCondition variableConditionSymbol) : base(variableConditionSymbol) { }
+    public override bool HasLocalParameters {
+      get { return true; }
+    }
+
+    public override void ResetLocalParameters(IRandom random) {
+      base.ResetLocalParameters(random);
+      threshold = NormalDistributedRandom.NextDouble(random, Symbol.ThresholdInitializerMu, Symbol.ThresholdInitializerSigma);
+      variableName = Symbol.VariableNames.SelectRandom(random);
+      slope = NormalDistributedRandom.NextDouble(random, Symbol.SlopeInitializerMu, Symbol.SlopeInitializerSigma);
+    }
+
+    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
+      base.ShakeLocalParameters(random, shakingFactor);
+      double x = NormalDistributedRandom.NextDouble(random, Symbol.ThresholdManipulatorMu, Symbol.ThresholdManipulatorSigma);
+      threshold = threshold + x * shakingFactor;
+      variableName = Symbol.VariableNames.SelectRandom(random);
+      x = NormalDistributedRandom.NextDouble(random, Symbol.SlopeManipulatorMu, Symbol.SlopeManipulatorSigma);
+      slope = slope + x * shakingFactor;
+    }
+
+    public override string ToString() {
+      return variableName + " > " + threshold.ToString("E4") + Environment.NewLine +
+        "slope: " + slope.ToString("E4");
+    }
+  }
+}
Index: branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs
===================================================================
--- branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs	(revision 5059)
+++ branches/GP.Symbols (TimeLag, Diff, Integral)/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/Symbols/VariableTreeNode.cs	(revision 5060)
@@ -55,7 +55,5 @@
 
     public override bool HasLocalParameters {
-      get {
-        return true;
-      }
+      get { return true; }
     }
 
