Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs	(revision 3544)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs	(revision 3545)
@@ -44,5 +44,5 @@
   [Creatable("Problems")]
   [StorableClass]
-  public sealed class SymbolicRegressionProblem : DataAnalysisProblem, ISingleObjectiveProblem {
+  public class SymbolicRegressionProblem : DataAnalysisProblem, ISingleObjectiveProblem {
 
     #region Parameter Properties
@@ -169,4 +169,19 @@
     public DoubleValue PunishmentFactor {
       get { return new DoubleValue(10.0); }
+    }
+    public IntValue TrainingSamplesStart {
+      get { return new IntValue(DataAnalysisProblemData.TrainingSamplesStart.Value); }
+    }
+    public IntValue TrainingSamplesEnd {
+      get {
+        return new IntValue((DataAnalysisProblemData.TrainingSamplesStart.Value +
+          DataAnalysisProblemData.TrainingSamplesEnd.Value) / 2);
+      }
+    }
+    public IntValue ValidationSamplesStart {
+      get { return TrainingSamplesEnd; }
+    }
+    public IntValue ValidationSamplesEnd {
+      get { return new IntValue(DataAnalysisProblemData.TrainingSamplesEnd.Value); }
     }
     #endregion
@@ -180,5 +195,5 @@
       var visualizer = new BestValidationSymbolicRegressionSolutionVisualizer();
       var interpreter = new SimpleArithmeticExpressionInterpreter();
-      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as the error of the regression model should be minimized.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<BoolValue>("Maximization", "Set to false as the error of the regression model should be minimized.", (BoolValue)new BoolValue(false).AsReadOnly()));
       Parameters.Add(new ValueParameter<SymbolicExpressionTreeCreator>("SolutionCreator", "The operator which should be used to create new symbolic regression solutions.", creator));
       Parameters.Add(new ValueParameter<ISymbolicExpressionTreeInterpreter>("SymbolicExpressionTreeInterpreter", "The interpreter that should be used to evaluate the symbolic expression tree.", interpreter));
@@ -190,27 +205,27 @@
       Parameters.Add(new ValueParameter<IntValue>("MaxExpressionLength", "Maximal length of the symbolic expression.", new IntValue(100)));
       Parameters.Add(new ValueParameter<IntValue>("MaxExpressionDepth", "Maximal depth of the symbolic expression.", new IntValue(10)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionDefiningBranches", "Maximal number of automatically defined functions.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionArguments", "Maximal number of arguments of automatically defined functions.", new IntValue(3)));
+      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionDefiningBranches", "Maximal number of automatically defined functions.", (IntValue)new IntValue(0).AsReadOnly()));
+      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionArguments", "Maximal number of arguments of automatically defined functions.", (IntValue)new IntValue(0).AsReadOnly()));
       Parameters.Add(new ValueParameter<ISingleObjectiveSolutionsVisualizer>("Visualizer", "The operator which should be used to visualize symbolic regression solutions.", visualizer));
 
       creator.SymbolicExpressionTreeParameter.ActualName = "SymbolicRegressionModel";
-      creator.MaxFunctionArgumentsParameter.ActualName = MaxFunctionArgumentsParameter.Name;
-      creator.MaxFunctionDefinitionsParameter.ActualName = MaxFunctionDefiningBranchesParameter.Name;
-      DataAnalysisProblemDataParameter.ValueChanged += new EventHandler(DataAnalysisProblemDataParameter_ValueChanged);
-      DataAnalysisProblemData.ProblemDataChanged += new EventHandler(DataAnalysisProblemData_Changed);
-      MaxFunctionArgumentsParameter.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
-      MaxFunctionArgumentsParameter.Value.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
-      MaxFunctionDefiningBranchesParameter.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
-      MaxFunctionDefiningBranchesParameter.Value.ValueChanged += new EventHandler(ArchitectureParameter_Changed);
+      evaluator.QualityParameter.ActualName = "TrainingMeanSquaredError";
+
       ParameterizeSolutionCreator();
       ParameterizeEvaluator();
       ParameterizeVisualizer();
 
+      UpdateGrammar();
+      UpdateEstimationLimits();
       Initialize();
     }
-
 
     [StorableConstructor]
     private SymbolicRegressionProblem(bool deserializing) : base() { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserializationHook() {
+      Initialize();
+    }
 
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -220,18 +235,121 @@
     }
 
-    #region Events
-    void DataAnalysisProblemDataParameter_ValueChanged(object sender, EventArgs e) {
-      DataAnalysisProblemData.ProblemDataChanged += new EventHandler(DataAnalysisProblemData_Changed);
-    }
-
-    void DataAnalysisProblemData_Changed(object sender, EventArgs e) {
+    private void RegisterParameterValueEvents() {
+      MaxFunctionArgumentsParameter.ValueChanged += new EventHandler(ArchitectureParameter_ValueChanged);
+      MaxFunctionDefiningBranchesParameter.ValueChanged += new EventHandler(ArchitectureParameter_ValueChanged);
+      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
+      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
+      VisualizerParameter.ValueChanged += new EventHandler(VisualizerParameter_ValueChanged);
+    }
+
+    private void RegisterParameterEvents() {
+      MaxFunctionArgumentsParameter.Value.ValueChanged += new EventHandler(ArchitectureParameter_ValueChanged);
+      MaxFunctionDefiningBranchesParameter.Value.ValueChanged += new EventHandler(ArchitectureParameter_ValueChanged);
+      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += new EventHandler(SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged);
+      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+    }
+
+    #region event handling
+    protected override void OnDataAnalysisProblemChanged(EventArgs e) {
+      base.OnDataAnalysisProblemChanged(e);
+      // paritions could be changed
+      ParameterizeEvaluator();
+      ParameterizeVisualizer();
+      // input variables could have been changed
       UpdateGrammar();
-      UpdatePartitioningParameters();
-    }
-
-    void ArchitectureParameter_Changed(object sender, EventArgs e) {
+      // estimation limits have to be recalculated
+      UpdateEstimationLimits();
+    }
+    protected virtual void OnArchitectureParameterChanged(EventArgs e) {
       var globalGrammar = FunctionTreeGrammar as GlobalSymbolicExpressionGrammar;
-      globalGrammar.MaxFunctionArguments = MaxFunctionArguments.Value;
-      globalGrammar.MaxFunctionDefinitions = MaxFunctionDefiningBranches.Value;
+      if (globalGrammar != null) {
+        globalGrammar.MaxFunctionArguments = MaxFunctionArguments.Value;
+        globalGrammar.MaxFunctionDefinitions = MaxFunctionDefiningBranches.Value;
+      }
+    }
+    protected virtual void OnGrammarChanged(EventArgs e) { }
+    protected virtual void OnOperatorsChanged(EventArgs e) { RaiseOperatorsChanged(e); }
+    protected virtual void OnSolutionCreatorChanged(EventArgs e) {
+      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += new EventHandler(SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged);
+      ParameterizeSolutionCreator();
+      OnSolutionParameterNameChanged(e);
+      RaiseSolutionCreatorChanged(e);
+    }
+
+    protected virtual void OnSolutionParameterNameChanged(EventArgs e) {
+      ParameterizeEvaluator();
+      ParameterizeVisualizer();
+      ParameterizeOperators();
+    }
+
+    protected virtual void OnEvaluatorChanged(EventArgs e) {
+      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
+      ParameterizeEvaluator();
+      ParameterizeVisualizer();
+      RaiseEvaluatorChanged(e);
+    }
+    protected virtual void OnQualityParameterNameChanged(EventArgs e) {
+      ParameterizeVisualizer();
+    }
+    protected virtual void OnVisualizerChanged(EventArgs e) {
+      ParameterizeVisualizer();
+      RaiseVisualizerChanged(e);
+    }
+    #endregion
+
+    #region event handlers
+    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
+      OnSolutionCreatorChanged(e);
+    }
+    private void SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged(object sender, EventArgs e) {
+      OnSolutionParameterNameChanged(e);
+    }
+    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
+      OnEvaluatorChanged(e);
+    }
+    private void VisualizerParameter_ValueChanged(object sender, EventArgs e) {
+      OnVisualizerChanged(e);
+    }
+    private void ArchitectureParameter_ValueChanged(object sender, EventArgs e) {
+      OnArchitectureParameterChanged(e);
+    }
+    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
+      OnQualityParameterNameChanged(e);
+    }
+    #endregion
+
+    #region events
+    public event EventHandler SolutionCreatorChanged;
+    private void RaiseSolutionCreatorChanged(EventArgs e) {
+      var changed = SolutionCreatorChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+    public event EventHandler EvaluatorChanged;
+    private void RaiseEvaluatorChanged(EventArgs e) {
+      var changed = EvaluatorChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+    public event EventHandler VisualizerChanged;
+    private void RaiseVisualizerChanged(EventArgs e) {
+      var changed = VisualizerChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+
+    public event EventHandler OperatorsChanged;
+    private void RaiseOperatorsChanged(EventArgs e) {
+      var changed = OperatorsChanged;
+      if (changed != null)
+        changed(this, e);
+    }
+    #endregion
+
+    #region Helpers
+    private void Initialize() {
+      InitializeOperators();
+      RegisterParameterEvents();
+      RegisterParameterValueEvents();
     }
 
@@ -242,19 +360,8 @@
     }
 
-    private void UpdatePartitioningParameters() {
-      int trainingStart = DataAnalysisProblemData.TrainingSamplesStart.Value;
-      int validationEnd = DataAnalysisProblemData.TrainingSamplesEnd.Value;
-      int trainingEnd = trainingStart + (validationEnd - trainingStart) / 2;
-      int validationStart = trainingEnd;
-      var solutionVisualizer = Visualizer as BestValidationSymbolicRegressionSolutionVisualizer;
-      if (solutionVisualizer != null) {
-        solutionVisualizer.ValidationSamplesStartParameter.Value = new IntValue(validationStart);
-        solutionVisualizer.ValidationSamplesEndParameter.Value = new IntValue(validationEnd);
-      }
-      Evaluator.SamplesStartParameter.Value = new IntValue(trainingStart);
-      Evaluator.SamplesEndParameter.Value = new IntValue(trainingEnd);
-
-      if (trainingEnd - trainingStart > 0 && DataAnalysisProblemData.TargetVariable.Value != string.Empty) {
-        var targetValues = DataAnalysisProblemData.Dataset.GetVariableValues(DataAnalysisProblemData.TargetVariable.Value, trainingStart, trainingEnd);
+    private void UpdateEstimationLimits() {
+      if (TrainingSamplesStart.Value < TrainingSamplesEnd.Value &&
+        DataAnalysisProblemData.Dataset.VariableNames.Contains(DataAnalysisProblemData.TargetVariable.Value)) {
+        var targetValues = DataAnalysisProblemData.Dataset.GetVariableValues(DataAnalysisProblemData.TargetVariable.Value, TrainingSamplesStart.Value, TrainingSamplesEnd.Value);
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
@@ -264,78 +371,8 @@
     }
 
-    public event EventHandler SolutionCreatorChanged;
-    private void OnSolutionCreatorChanged() {
-      var changed = SolutionCreatorChanged;
-      if (changed != null)
-        changed(this, EventArgs.Empty);
-    }
-    public event EventHandler EvaluatorChanged;
-    private void OnEvaluatorChanged() {
-      var changed = EvaluatorChanged;
-      if (changed != null)
-        changed(this, EventArgs.Empty);
-    }
-    public event EventHandler VisualizerChanged;
-    private void OnVisualizerChanged() {
-      var changed = VisualizerChanged;
-      if (changed != null)
-        changed(this, EventArgs.Empty);
-    }
-
-    public event EventHandler OperatorsChanged;
-    private void OnOperatorsChanged() {
-      var changed = OperatorsChanged;
-      if (changed != null)
-        changed(this, EventArgs.Empty);
-    }
-
-    private void SolutionCreatorParameter_ValueChanged(object sender, EventArgs e) {
-      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += new EventHandler(SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged);
-      ParameterizeSolutionCreator();
-      ParameterizeEvaluator();
-      ParameterizeVisualizer();
-      ParameterizeOperators();
-      OnSolutionCreatorChanged();
-    }
-    private void SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeEvaluator();
-      ParameterizeVisualizer();
-      ParameterizeOperators();
-    }
-    private void EvaluatorParameter_ValueChanged(object sender, EventArgs e) {
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      ParameterizeEvaluator();
-      ParameterizeVisualizer();
-      OnEvaluatorChanged();
-    }
-
-    private void VisualizerParameter_ValueChanged(object sender, EventArgs e) {
-      ParameterizeVisualizer();
-      OnVisualizerChanged();
-    }
-
-    private void Evaluator_QualityParameter_ActualNameChanged(object sender, EventArgs e) {
-      ParameterizeVisualizer();
-    }
-
-    #endregion
-
-    #region Helpers
-    [StorableHook(HookType.AfterDeserialization)]
-    private void Initialize() {
-      InitializeOperators();
-      SolutionCreatorParameter.ValueChanged += new EventHandler(SolutionCreatorParameter_ValueChanged);
-      SolutionCreator.SymbolicExpressionTreeParameter.ActualNameChanged += new EventHandler(SolutionCreator_SymbolicExpressionTreeParameter_ActualNameChanged);
-      EvaluatorParameter.ValueChanged += new EventHandler(EvaluatorParameter_ValueChanged);
-      Evaluator.QualityParameter.ActualNameChanged += new EventHandler(Evaluator_QualityParameter_ActualNameChanged);
-      VisualizerParameter.ValueChanged += new EventHandler(VisualizerParameter_ValueChanged);
-    }
-
     private void InitializeOperators() {
       operators = new List<ISymbolicExpressionTreeOperator>();
       operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>());
       ParameterizeOperators();
-      UpdateGrammar();
-      UpdatePartitioningParameters();
     }
 
@@ -344,21 +381,26 @@
       SolutionCreator.MaxTreeHeightParameter.ActualName = MaxExpressionDepthParameter.Name;
       SolutionCreator.MaxTreeSizeParameter.ActualName = MaxExpressionLengthParameter.Name;
-    }
+      SolutionCreator.MaxFunctionArgumentsParameter.ActualName = MaxFunctionArgumentsParameter.Name;
+      SolutionCreator.MaxFunctionDefinitionsParameter.ActualName = MaxFunctionDefiningBranchesParameter.Name;
+    }
+
     private void ParameterizeEvaluator() {
       Evaluator.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
       Evaluator.RegressionProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
-      Evaluator.QualityParameter.ActualName = "TrainingMeanSquaredError";
-      Evaluator.SamplesStartParameter.Value = new IntValue(DataAnalysisProblemData.TrainingSamplesStart.Value);
-      Evaluator.SamplesEndParameter.Value = new IntValue((DataAnalysisProblemData.TrainingSamplesStart.Value + DataAnalysisProblemData.TrainingSamplesEnd.Value) / 2);
-    }
+      Evaluator.SamplesStartParameter.Value = TrainingSamplesStart;
+      Evaluator.SamplesEndParameter.Value = TrainingSamplesEnd;
+    }
+
     private void ParameterizeVisualizer() {
-      if (Visualizer != null) {
-        var solutionVisualizer = Visualizer as BestValidationSymbolicRegressionSolutionVisualizer;
-        if (solutionVisualizer != null) {
-          solutionVisualizer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-          solutionVisualizer.DataAnalysisProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
-          solutionVisualizer.ValidationSamplesStartParameter.Value = new IntValue((DataAnalysisProblemData.TrainingSamplesStart.Value + DataAnalysisProblemData.TrainingSamplesEnd.Value) / 2);
-          solutionVisualizer.ValidationSamplesEndParameter.Value = new IntValue(DataAnalysisProblemData.TrainingSamplesEnd.Value);
-        }
+      var solutionVisualizer = Visualizer as BestValidationSymbolicRegressionSolutionVisualizer;
+      if (solutionVisualizer != null) {
+        solutionVisualizer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+        solutionVisualizer.DataAnalysisProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
+        solutionVisualizer.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
+        solutionVisualizer.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
+        solutionVisualizer.QualityParameter.ActualName = Evaluator.QualityParameter.Name;
+        solutionVisualizer.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
+        solutionVisualizer.ValidationSamplesStartParameter.Value = ValidationSamplesStart;
+        solutionVisualizer.ValidationSamplesEndParameter.Value = ValidationSamplesEnd;
       }
     }
@@ -370,8 +412,4 @@
         op.SymbolicExpressionGrammarParameter.ActualName = FunctionTreeGrammarParameter.Name;
       }
-      foreach (ISymbolicRegressionEvaluator op in Operators.OfType<ISymbolicRegressionEvaluator>()) {
-        op.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
-        op.RegressionProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
-      }
       foreach (ISymbolicExpressionTreeCrossover op in Operators.OfType<ISymbolicExpressionTreeCrossover>()) {
         op.ParentsParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.Designer.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.Designer.cs	(revision 3544)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.Designer.cs	(revision 3545)
@@ -24,8 +24,11 @@
     /// </summary>
     private void InitializeComponent() {
-      this.variableCollectionView = new HeuristicLab.Core.Views.VariableCollectionView();
       this.importButton = new System.Windows.Forms.Button();
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
       this.SuspendLayout();
+      // 
+      // parameterCollectionView
+      // 
+      this.parameterCollectionView.Size = new System.Drawing.Size(585, 366);
       // 
       // nameTextBox
@@ -38,17 +41,4 @@
       // 
       this.descriptionTextBox.Size = new System.Drawing.Size(513, 20);
-      // 
-      // variableCollectionView
-      // 
-      this.variableCollectionView.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-                  | System.Windows.Forms.AnchorStyles.Left)
-                  | System.Windows.Forms.AnchorStyles.Right)));
-      this.variableCollectionView.Caption = "VariableCollection";
-      this.variableCollectionView.Content = null;
-      this.variableCollectionView.Location = new System.Drawing.Point(0, 52);
-      this.variableCollectionView.Name = "variableCollectionView";
-      this.variableCollectionView.ReadOnly = false;
-      this.variableCollectionView.Size = new System.Drawing.Size(588, 366);
-      this.variableCollectionView.TabIndex = 0;
       // 
       // importButton
@@ -68,10 +58,9 @@
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
       this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.variableCollectionView);
       this.Controls.Add(this.importButton);
       this.Name = "DataAnalysisProblemDataView";
       this.Size = new System.Drawing.Size(588, 450);
+      this.Controls.SetChildIndex(this.parameterCollectionView, 0);
       this.Controls.SetChildIndex(this.importButton, 0);
-      this.Controls.SetChildIndex(this.variableCollectionView, 0);
       this.Controls.SetChildIndex(this.nameLabel, 0);
       this.Controls.SetChildIndex(this.descriptionLabel, 0);
@@ -86,5 +75,4 @@
     #endregion
 
-    private HeuristicLab.Core.Views.VariableCollectionView variableCollectionView;
     private System.Windows.Forms.Button importButton;
   }
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.cs	(revision 3544)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.3/DataAnalysisProblemDataView.cs	(revision 3545)
@@ -12,6 +12,6 @@
 namespace HeuristicLab.Problems.DataAnalysis.Views {
   [View("Data-Analysis Problem View")]
-  [Content(typeof(DataAnalysisProblemData))]
-  public partial class DataAnalysisProblemDataView : NamedItemView {
+  [Content(typeof(DataAnalysisProblemData), true)]
+  public partial class DataAnalysisProblemDataView : ParameterizedNamedItemView {
     private OpenFileDialog openFileDialog;
     public new DataAnalysisProblemData Content {
@@ -31,9 +31,4 @@
     }
 
-    protected override void OnContentChanged() {
-      base.OnContentChanged();
-      variableCollectionView.Content = Content.Variables.AsReadOnly();
-    }
-
     private void importButton_Click(object sender, EventArgs e) {
       if (openFileDialog == null) openFileDialog = new OpenFileDialog();
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblem.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblem.cs	(revision 3544)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblem.cs	(revision 3545)
@@ -50,5 +50,4 @@
     public DataAnalysisProblemData DataAnalysisProblemData {
       get { return DataAnalysisProblemDataParameter.Value; }
-      set { DataAnalysisProblemDataParameter.Value = value; }
     }
     #endregion
@@ -57,8 +56,43 @@
       : base() {
       Parameters.Add(new ValueParameter<DataAnalysisProblemData>(DataAnalysisProblemDataParameterName, "The data set, target variable and input variables of the data analysis problem.", new DataAnalysisProblemData()));
+      RegisterParameterEvents();
+      RegisterParameterValueEvents();
     }
 
     [StorableConstructor]
     private DataAnalysisProblem(bool deserializing) : base() { }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserializationHook() {
+      RegisterParameterEvents();
+      RegisterParameterValueEvents();
+    }
+
+    #region events
+    protected virtual void OnDataAnalysisProblemChanged(EventArgs e) { }
+
+    private void RegisterParameterEvents() {
+      DataAnalysisProblemDataParameter.ValueChanged += new EventHandler(DataAnalysisProblemDataParameter_ValueChanged);
+    }
+
+    private void RegisterParameterValueEvents() {
+      DataAnalysisProblemData.ProblemDataChanged += new EventHandler(DataAnalysisProblemData_ProblemDataChanged);
+    }
+
+    private void DataAnalysisProblemDataParameter_ValueChanged(object sender, EventArgs e) {
+      OnDataAnalysisProblemChanged(e);
+    }
+
+    private void DataAnalysisProblemData_ProblemDataChanged(object sender, EventArgs e) {
+      OnDataAnalysisProblemChanged(e);
+    }
+    #endregion
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      DataAnalysisProblem clone = (DataAnalysisProblem) base.Clone(cloner);
+      clone.RegisterParameterEvents();
+      clone.RegisterParameterValueEvents();
+      return clone;
+    }
   }
 }
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs	(revision 3544)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/DataAnalysisProblemData.cs	(revision 3545)
@@ -35,36 +35,30 @@
   [Item("DataAnalysisProblemData", "Represents an item containing all data defining a data analysis problem.")]
   [StorableClass]
-  public class DataAnalysisProblemData : NamedItem {
-    [Storable]
-    private VariableCollection variables;
-    public VariableCollection Variables {
-      get { return variables; }
-    }
-
-    #region variable properties
-    public IVariable DatasetVariable {
-      get { return variables["Dataset"]; }
-    }
-
-    public IVariable TargetVariableVariable {
-      get { return variables["TargetVariable"]; }
-    }
-
-    public IVariable InputVariablesVariable {
-      get { return variables["InputVariables"]; }
-    }
-
-    public IVariable TrainingSamplesStartVariable {
-      get { return variables["TrainingSamplesStart"]; }
-    }
-    public IVariable TrainingSamplesEndVariable {
-      get { return variables["TrainingSamplesEnd"]; }
-    }
-
-    public IVariable TestSamplesStartVariable {
-      get { return variables["TestSamplesStart"]; }
-    }
-    public IVariable TestSamplesEndVariable {
-      get { return variables["TestSamplesEnd"]; }
+  public class DataAnalysisProblemData : ParameterizedNamedItem {
+    private bool suppressEvents = false;
+    #region parameter properties
+    public IValueParameter<Dataset> DatasetParameter {
+      get { return (IValueParameter<Dataset>)Parameters["Dataset"]; }
+    }
+
+    public IValueParameter<StringValue> TargetVariableParameter {
+      get { return (IValueParameter<StringValue>)Parameters["TargetVariable"]; }
+    }
+
+    public IValueParameter<ItemSet<StringValue>> InputVariablesParameter {
+      get { return (IValueParameter<ItemSet<StringValue>>)Parameters["InputVariables"]; }
+    }
+
+    public IValueParameter<IntValue> TrainingSamplesStartParameter {
+      get { return (IValueParameter<IntValue>)Parameters["TrainingSamplesStart"]; }
+    }
+    public IValueParameter<IntValue> TrainingSamplesEndParameter {
+      get { return (IValueParameter<IntValue>)Parameters["TrainingSamplesEnd"]; }
+    }
+    public IValueParameter<IntValue> TestSamplesStartParameter {
+      get { return (IValueParameter<IntValue>)Parameters["TestSamplesStart"]; }
+    }
+    public IValueParameter<IntValue> TestSamplesEndParameter {
+      get { return (IValueParameter<IntValue>)Parameters["TestSamplesEnd"]; }
     }
     #endregion
@@ -72,84 +66,70 @@
     #region properties
     public Dataset Dataset {
-      get { return (Dataset)DatasetVariable.Value; }
+      get { return (Dataset)DatasetParameter.Value; }
       set {
         if (value != Dataset) {
           if (value == null) throw new ArgumentNullException();
           if (Dataset != null) DeregisterDatasetEventHandlers();
-          DatasetVariable.Value = value;
-          RegisterDatasetEventHandlers();
-          OnProblemDataChanged(EventArgs.Empty);
+          DatasetParameter.Value = value;
         }
       }
     }
     public StringValue TargetVariable {
-      get { return (StringValue)TargetVariableVariable.Value; }
-      set {
-        if (value != TargetVariableVariable) {
+      get { return (StringValue)TargetVariableParameter.Value; }
+      set {
+        if (value != TargetVariableParameter.Value) {
           if (value == null) throw new ArgumentNullException();
           if (TargetVariable != null) DeregisterStringValueEventHandlers(TargetVariable);
-          TargetVariableVariable.Value = value;
-          RegisterStringValueEventHandlers(TargetVariable);
-          OnProblemDataChanged(EventArgs.Empty);
-        }
-      }
-    }
-    public ItemList<StringValue> InputVariables {
-      get { return (ItemList<StringValue>)InputVariablesVariable.Value; }
+          TargetVariableParameter.Value = value;
+        }
+      }
+    }
+    public ItemSet<StringValue> InputVariables {
+      get { return (ItemSet<StringValue>)InputVariablesParameter.Value; }
       set {
         if (value != InputVariables) {
           if (value == null) throw new ArgumentNullException();
           if (InputVariables != null) DeregisterInputVariablesEventHandlers();
-          InputVariablesVariable.Value = value;
-          RegisterInputVariablesEventHandlers();
-          OnProblemDataChanged(EventArgs.Empty);
+          InputVariablesParameter.Value = value;
         }
       }
     }
     public IntValue TrainingSamplesStart {
-      get { return (IntValue)TrainingSamplesStartVariable.Value; }
+      get { return (IntValue)TrainingSamplesStartParameter.Value; }
       set {
         if (value != TrainingSamplesStart) {
           if (value == null) throw new ArgumentNullException();
           if (TrainingSamplesStart != null) DeregisterValueTypeEventHandlers(TrainingSamplesStart);
-          TrainingSamplesStartVariable.Value = value;
-          RegisterValueTypeEventHandlers(TrainingSamplesStart);
-          OnProblemDataChanged(EventArgs.Empty);
+          TrainingSamplesStartParameter.Value = value;
         }
       }
     }
     public IntValue TrainingSamplesEnd {
-      get { return (IntValue)TrainingSamplesEndVariable.Value; }
+      get { return (IntValue)TrainingSamplesEndParameter.Value; }
       set {
         if (value != TrainingSamplesEnd) {
           if (value == null) throw new ArgumentNullException();
           if (TrainingSamplesEnd != null) DeregisterValueTypeEventHandlers(TrainingSamplesEnd);
-          TrainingSamplesEndVariable.Value = value;
-          RegisterValueTypeEventHandlers(TrainingSamplesEnd);
-          OnProblemDataChanged(EventArgs.Empty);
+          TrainingSamplesEndParameter.Value = value;
         }
       }
     }
     public IntValue TestSamplesStart {
-      get { return (IntValue)TestSamplesStartVariable.Value; }
+      get { return (IntValue)TestSamplesStartParameter.Value; }
       set {
         if (value != TestSamplesStart) {
           if (value == null) throw new ArgumentNullException();
           if (TestSamplesStart != null) DeregisterValueTypeEventHandlers(TestSamplesStart);
-          TestSamplesStartVariable.Value = value;
-          RegisterValueTypeEventHandlers(TestSamplesStart);
-          OnProblemDataChanged(EventArgs.Empty);
+          TestSamplesStartParameter.Value = value;
         }
       }
     }
     public IntValue TestSamplesEnd {
-      get { return (IntValue)TestSamplesEndVariable.Value; }
+      get { return (IntValue)TestSamplesEndParameter.Value; }
       set {
         if (value != TestSamplesEnd) {
           if (value == null) throw new ArgumentNullException();
           if (TestSamplesEnd != null) DeregisterValueTypeEventHandlers(TestSamplesEnd);
-          TestSamplesEndVariable.Value = value;
-          RegisterValueTypeEventHandlers(TestSamplesEnd);
-          OnProblemDataChanged(EventArgs.Empty);
+          TestSamplesEndParameter.Value = value;
         }
       }
@@ -159,14 +139,15 @@
     public DataAnalysisProblemData()
       : base() {
-      variables = new VariableCollection();
-      variables.Add(new Variable("Dataset", new Dataset()));
-      variables.Add(new Variable("InputVariables", new ItemList<StringValue>()));
-      variables.Add(new Variable("TargetVariable", new StringValue()));
-      variables.Add(new Variable("TrainingSamplesStart", new IntValue()));
-      variables.Add(new Variable("TrainingSamplesEnd", new IntValue()));
-      variables.Add(new Variable("TestSamplesStart", new IntValue()));
-      variables.Add(new Variable("TestSamplesEnd", new IntValue()));
-      RegisterEventHandlers();
-    }
+      Parameters.Add(new ValueParameter<Dataset>("Dataset", new Dataset()));
+      Parameters.Add(new ValueParameter<ItemSet<StringValue>>("InputVariables", new ItemSet<StringValue>()));
+      Parameters.Add(new ConstrainedValueParameter<StringValue>("TargetVariable"));
+      Parameters.Add(new ValueParameter<IntValue>("TrainingSamplesStart", new IntValue()));
+      Parameters.Add(new ValueParameter<IntValue>("TrainingSamplesEnd", new IntValue()));
+      Parameters.Add(new ValueParameter<IntValue>("TestSamplesStart", new IntValue()));
+      Parameters.Add(new ValueParameter<IntValue>("TestSamplesEnd", new IntValue()));
+      RegisterParameterEventHandlers();
+      RegisterParameterValueEventHandlers();
+    }
+
 
     [StorableConstructor]
@@ -175,12 +156,31 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserializationHook() {
-      RegisterEventHandlers();
+      RegisterParameterEventHandlers();
+      RegisterParameterValueEventHandlers();
     }
 
     #region events
-    private void RegisterEventHandlers() {
+    public event EventHandler ProblemDataChanged;
+    protected virtual void OnProblemDataChanged(EventArgs e) {
+      if (!suppressEvents) {
+        var listeners = ProblemDataChanged;
+        if (listeners != null) listeners(this, e);
+      }
+    }
+
+    private void RegisterParameterEventHandlers() {
+      DatasetParameter.ValueChanged += new EventHandler(DatasetParameter_ValueChanged);
+      InputVariablesParameter.ValueChanged += new EventHandler(InputVariablesParameter_ValueChanged);
+      TargetVariableParameter.ValueChanged += new EventHandler(TargetVariableParameter_ValueChanged);
+      TrainingSamplesStartParameter.ValueChanged += new EventHandler(TrainingSamplesStartParameter_ValueChanged);
+      TrainingSamplesEndParameter.ValueChanged += new EventHandler(TrainingSamplesEndParameter_ValueChanged);
+      TestSamplesStartParameter.ValueChanged += new EventHandler(TestSamplesStartParameter_ValueChanged);
+      TestSamplesEndParameter.ValueChanged += new EventHandler(TestSamplesEndParameter_ValueChanged);
+    }
+
+    private void RegisterParameterValueEventHandlers() {
       RegisterDatasetEventHandlers();
       RegisterInputVariablesEventHandlers();
-      RegisterStringValueEventHandlers(TargetVariable);
+      if (TargetVariable != null) RegisterStringValueEventHandlers(TargetVariable);
       RegisterValueTypeEventHandlers(TrainingSamplesStart);
       RegisterValueTypeEventHandlers(TrainingSamplesEnd);
@@ -189,30 +189,38 @@
     }
 
-    public event EventHandler ProblemDataChanged;
-    protected virtual void OnProblemDataChanged(EventArgs e) {
-      var listeners = ProblemDataChanged;
-      if (listeners != null) listeners(this, e);
-    }
-
-
-    private void RegisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
-      value.ValueChanged += new EventHandler(value_ValueChanged);
-    }
-
-    private void DeregisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
-      value.ValueChanged -= new EventHandler(value_ValueChanged);
-    }
-
-    void value_ValueChanged(object sender, EventArgs e) {
-      OnProblemDataChanged(e);
-    }
-
-    private void RegisterStringValueEventHandlers(StringValue value) {
-      value.ValueChanged += new EventHandler(value_ValueChanged);
-    }
-
-    private void DeregisterStringValueEventHandlers(StringValue value) {
-      value.ValueChanged -= new EventHandler(value_ValueChanged);
-    }
+
+    #region parameter value changed event handlers
+    void DatasetParameter_ValueChanged(object sender, EventArgs e) {
+      RegisterDatasetEventHandlers();
+      OnProblemDataChanged(EventArgs.Empty);
+    }
+    void InputVariablesParameter_ValueChanged(object sender, EventArgs e) {
+      RegisterInputVariablesEventHandlers();
+      OnProblemDataChanged(EventArgs.Empty);
+    }
+    void TargetVariableParameter_ValueChanged(object sender, EventArgs e) {
+      if (TargetVariable != null) {
+        RegisterStringValueEventHandlers(TargetVariable);
+        OnProblemDataChanged(EventArgs.Empty);
+      } 
+    }
+    void TrainingSamplesStartParameter_ValueChanged(object sender, EventArgs e) {
+      RegisterValueTypeEventHandlers(TrainingSamplesStart);
+      OnProblemDataChanged(EventArgs.Empty);
+    }
+    void TrainingSamplesEndParameter_ValueChanged(object sender, EventArgs e) {
+      RegisterValueTypeEventHandlers(TrainingSamplesEnd);
+      OnProblemDataChanged(EventArgs.Empty);
+    }
+    void TestSamplesStartParameter_ValueChanged(object sender, EventArgs e) {
+      RegisterValueTypeEventHandlers(TestSamplesStart);
+      OnProblemDataChanged(EventArgs.Empty);
+    }
+    void TestSamplesEndParameter_ValueChanged(object sender, EventArgs e) {
+      RegisterValueTypeEventHandlers(TestSamplesEnd);
+      OnProblemDataChanged(EventArgs.Empty);
+    }
+    #endregion
+
 
     private void RegisterDatasetEventHandlers() {
@@ -241,52 +249,64 @@
 
     private void RegisterInputVariablesEventHandlers() {
-      InputVariables.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CollectionReset);
-      InputVariables.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsAdded);
-      InputVariables.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsRemoved);
-      InputVariables.ItemsReplaced += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsReplaced);
+      InputVariables.CollectionReset += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_CollectionReset);
+      InputVariables.ItemsAdded += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsAdded);
+      InputVariables.ItemsRemoved += new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsRemoved);
       foreach (var item in InputVariables)
-        item.ValueChanged += new EventHandler(InputVariables_Value_ValueChanged);
+        item.ValueChanged += new EventHandler(InputVariable_ValueChanged);
+    }
+
+    void InputVariables_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<StringValue> e) {
+      foreach (var item in e.Items)
+        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
+      OnProblemDataChanged(e);
+    }
+
+    void InputVariables_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<StringValue> e) {
+      foreach (var item in e.OldItems)
+        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
+      OnProblemDataChanged(e);
+    }
+
+    void InputVariables_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<StringValue> e) {
+      foreach (var item in e.Items)
+        item.ValueChanged += new EventHandler(InputVariable_ValueChanged);
+      OnProblemDataChanged(e);
     }
 
     private void DeregisterInputVariablesEventHandlers() {
-      InputVariables.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_CollectionReset);
-      InputVariables.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsAdded);
-      InputVariables.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsRemoved);
-      InputVariables.ItemsReplaced -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<HeuristicLab.Collections.IndexedItem<StringValue>>(InputVariables_ItemsReplaced);
+      InputVariables.CollectionReset -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_CollectionReset);
+      InputVariables.ItemsAdded -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsAdded);
+      InputVariables.ItemsRemoved -= new HeuristicLab.Collections.CollectionItemsChangedEventHandler<StringValue>(InputVariables_ItemsRemoved);
       foreach (var item in InputVariables) {
-        item.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
-      }
-    }
-
-    void InputVariables_ItemsReplaced(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
-      foreach (var indexedItem in e.OldItems)
-        indexedItem.Value.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
-      foreach (var indexedItem in e.Items)
-        indexedItem.Value.ValueChanged += new EventHandler(InputVariables_Value_ValueChanged);
-      OnProblemDataChanged(e);
-    }
-
-    void InputVariables_ItemsRemoved(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
-      foreach (var indexedItem in e.Items)
-        indexedItem.Value.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
-      OnProblemDataChanged(e);
-    }
-
-    void InputVariables_ItemsAdded(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
-      foreach (var indexedItem in e.Items)
-        indexedItem.Value.ValueChanged += new EventHandler(InputVariables_Value_ValueChanged);
-      OnProblemDataChanged(e);
-    }
-
-    void InputVariables_CollectionReset(object sender, HeuristicLab.Collections.CollectionItemsChangedEventArgs<HeuristicLab.Collections.IndexedItem<StringValue>> e) {
-      foreach (var indexedItem in e.OldItems)
-        indexedItem.Value.ValueChanged -= new EventHandler(InputVariables_Value_ValueChanged);
-
-      OnProblemDataChanged(e);
-    }
-    void InputVariables_Value_ValueChanged(object sender, EventArgs e) {
-      OnProblemDataChanged(e);
-    }
-
+        item.ValueChanged -= new EventHandler(InputVariable_ValueChanged);
+      }
+    }
+  
+    void InputVariable_ValueChanged(object sender, EventArgs e) {
+      OnProblemDataChanged(e);
+    }
+    #region helper
+
+    private void RegisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
+      value.ValueChanged += new EventHandler(value_ValueChanged);
+    }
+
+    private void DeregisterValueTypeEventHandlers<T>(ValueTypeValue<T> value) where T : struct {
+      value.ValueChanged -= new EventHandler(value_ValueChanged);
+    }
+
+    void value_ValueChanged(object sender, EventArgs e) {
+      OnProblemDataChanged(e);
+    }
+
+    private void RegisterStringValueEventHandlers(StringValue value) {
+      value.ValueChanged += new EventHandler(value_ValueChanged);
+    }
+
+    private void DeregisterStringValueEventHandlers(StringValue value) {
+      value.ValueChanged -= new EventHandler(value_ValueChanged);
+    }
+
+    #endregion
     #endregion
 
@@ -294,9 +314,14 @@
       var csvFileParser = new CsvFileParser();
       csvFileParser.Parse(fileName);
+      suppressEvents = true;
       Name = "Data imported from " + Path.GetFileName(fileName);
       Dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
       Dataset.Name = Path.GetFileName(fileName);
-      TargetVariable = new StringValue(Dataset.VariableNames.First());
-      InputVariables = new ItemList<StringValue>(Dataset.VariableNames.Skip(1).Select(s => new StringValue(s)));
+      var variableNames = Dataset.VariableNames.Select(x => new StringValue(x).AsReadOnly()).ToList();
+      ((ConstrainedValueParameter<StringValue>)TargetVariableParameter).ValidValues.Clear();
+      foreach (var variableName in variableNames)
+        ((ConstrainedValueParameter<StringValue>)TargetVariableParameter).ValidValues.Add(variableName);
+      TargetVariable = variableNames.First();
+      InputVariables = new ItemSet<StringValue>(variableNames.Skip(1));
       int middle = (int)(csvFileParser.Rows * 0.5);
       TrainingSamplesStart = new IntValue(0);
@@ -304,11 +329,12 @@
       TestSamplesStart = new IntValue(middle);
       TestSamplesEnd = new IntValue(csvFileParser.Rows);
+      suppressEvents = false;
+      OnProblemDataChanged(EventArgs.Empty);
     }
 
     public override IDeepCloneable Clone(Cloner cloner) {
       DataAnalysisProblemData clone = (DataAnalysisProblemData)base.Clone(cloner);
-      clone.variables = (VariableCollection)variables.Clone(cloner);
-
-      clone.RegisterEventHandlers();
+      clone.RegisterParameterEventHandlers();
+      clone.RegisterParameterValueEventHandlers();
       return clone;
     }
Index: trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs
===================================================================
--- trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs	(revision 3544)
+++ trunk/sources/HeuristicLab.Problems.DataAnalysis/3.3/Symbolic/SimpleArithmeticExpressionInterpreter.cs	(revision 3545)
@@ -52,4 +52,11 @@
     private Instruction[] code;
     private int pc;
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
 
     public SimpleArithmeticExpressionInterpreter()
