Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveMeanSquaredErrorTreeSizeEvaluator.cs	(revision 5586)
@@ -53,5 +53,5 @@
     public static double[] Calculate(ISymbolicDataAnalysisTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IRegressionProblemData problemData, IEnumerable<int> rows) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
+      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable.Value, rows);
       IEnumerable<double> boundedEstimationValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       double mse = OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues);
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectivePearsonRSquaredTreeSizeEvaluator.cs	(revision 5586)
@@ -53,5 +53,5 @@
     public static double[] Calculate(ISymbolicDataAnalysisTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IRegressionProblemData problemData, IEnumerable<int> rows) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
+      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable.Value, rows);
       double r2 = OnlinePearsonsRSquaredEvaluator.Calculate(originalValues, estimatedValues);
       return new double[2] { r2, solution.Length };
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveMeanSquaredErrorEvaluator.cs	(revision 5586)
@@ -53,5 +53,5 @@
     public static double Calculate(ISymbolicDataAnalysisTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IRegressionProblemData problemData, IEnumerable<int> rows) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
+      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable.Value, rows);
       IEnumerable<double> boundedEstimationValues = estimatedValues.LimitToRange(lowerEstimationLimit, upperEstimationLimit);
       return OnlineMeanSquaredErrorEvaluator.Calculate(originalValues, boundedEstimationValues);
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectivePearsonRSquaredEvaluator.cs	(revision 5586)
@@ -53,5 +53,5 @@
     public static double Calculate(ISymbolicDataAnalysisTreeInterpreter interpreter, ISymbolicExpressionTree solution, double lowerEstimationLimit, double upperEstimationLimit, IRegressionProblemData problemData, IEnumerable<int> rows) {
       IEnumerable<double> estimatedValues = interpreter.GetSymbolicExpressionTreeValues(solution, problemData.Dataset, rows);
-      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable, rows);
+      IEnumerable<double> originalValues = problemData.Dataset.GetEnumeratedVariableValues(problemData.TargetVariable.Value, rows);
       return OnlinePearsonsRSquaredEvaluator.Calculate(originalValues, estimatedValues);
     }
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Evaluators/SymbolicDataAnalysisEvaluator.cs	(revision 5586)
@@ -125,5 +125,5 @@
       if (count == 0) count = 1;
       return RandomEnumerable.SampleRandomNumbers(seed, SamplesEnd.Value, SamplesStart.Value, count)
-        .Where(i => i < ProblemDataParameter.ActualValue.TestPartitionStart || ProblemDataParameter.ActualValue.TestPartitionEnd <= i);
+        .Where(i => i < ProblemDataParameter.ActualValue.TestPartitionStart.Value || ProblemDataParameter.ActualValue.TestPartitionEnd.Value <= i);
     }
   }
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/DataAnalysisProblemData.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/DataAnalysisProblemData.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/DataAnalysisProblemData.cs	(revision 5586)
@@ -23,87 +23,76 @@
 using System.Collections.Generic;
 using System.Linq;
+using HeuristicLab.Collections;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Problems.DataAnalysis {
   [StorableClass]
-  public abstract class DataAnalysisProblemData : NamedItem, IDataAnalysisProblemData {
+  public abstract class DataAnalysisProblemData : ParameterizedNamedItem, IDataAnalysisProblemData {
+    private const string DatasetParameterName = "Dataset";
+    private const string InputVariablesParameterName = "InputVariables";
+    private const string TrainingPartitionStartParameterName = "TrainingPartitionStart";
+    private const string TrainingPartitionEndParameterName = "TrainingPartitionEnd";
+    private const string TestPartitionStartParameterName = "TestPartitionStart";
+    private const string TestPartitionEndParameterName = "TestPartitionEnd";
+
+    #region parameter properites
+    public IValueParameter<Dataset> DatasetParameter {
+      get { return (IValueParameter<Dataset>)Parameters[DatasetParameterName]; }
+    }
+    public IFixedValueParameter<ICheckedItemCollection<StringValue>> InputVariablesParameter {
+      get { return (IFixedValueParameter<ICheckedItemCollection<StringValue>>)Parameters[InputVariablesParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> TrainingPartitionStartParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[TrainingPartitionStartParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> TrainingPartitionEndParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[TrainingPartitionEndParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> TestPartitionStartParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[TestPartitionStartParameterName]; }
+    }
+    public IFixedValueParameter<IntValue> TestPartitionEndParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[TestPartitionEndParameterName]; }
+    }
+    #endregion
+
     #region propeties
-    [Storable]
-    private Dataset dataset;
     public Dataset Dataset {
-      get { return dataset; }
+      get { return DatasetParameter.Value; }
+      set { DatasetParameter.Value = value; }
+    }
+    public ICheckedItemCollection<StringValue> InputVariables {
+      get { return InputVariablesParameter.Value; }
+    }
+    public IEnumerable<string> AllowedInputVariables {
+      get { return InputVariables.CheckedItems.Select(x => x.Value); }
     }
 
-    [Storable]
-    private HashSet<string> allowedInputVariables;
-    public IEnumerable<string> AllowedInputVariables {
-      get { return allowedInputVariables; }
+    public IntValue TrainingPartitionStart {
+      get { return TrainingPartitionStartParameter.Value; }
     }
-
-    [Storable]
-    private int trainingPartitionStart;
-    public int TrainingPartitionStart {
-      get { return trainingPartitionStart; }
-      set {
-        if (0 < value || value > dataset.Rows)
-          throw new ArgumentException(string.Format("The training partition start must be between 0 and the number of rows of the dataset ({0})", dataset.Rows));
-        if (trainingPartitionStart != value) {
-          trainingPartitionStart = value;
-          OnChanged();
-        }
-      }
+    public IntValue TrainingPartitionEnd {
+      get { return TrainingPartitionEndParameter.Value; }
     }
-    [Storable]
-    private int trainingPartitionEnd;
-    public int TrainingPartitionEnd {
-      get { return trainingPartitionEnd; }
-      set {
-        if (0 < value || value > dataset.Rows)
-          throw new ArgumentException(string.Format("The training partition end must be between 0 and the number of rows of the dataset ({0})", dataset.Rows));
-        if (trainingPartitionEnd != value) {
-          trainingPartitionEnd = value;
-          OnChanged();
-        }
-      }
+    public IntValue TestPartitionStart {
+      get { return TestPartitionStartParameter.Value; }
     }
-
-    [Storable]
-    private int testPartitionStart;
-    public int TestPartitionStart {
-      get { return testPartitionStart; }
-      set {
-        if (0 < value || value > dataset.Rows)
-          throw new ArgumentException(string.Format("The test partition start must be between 0 and the number of rows of the dataset ({0})", dataset.Rows));
-        if (testPartitionStart != value) {
-          testPartitionStart = value;
-          OnChanged();
-        }
-      }
-    }
-    [Storable]
-    private int testPartitionEnd;
-    public int TestPartitionEnd {
-      get { return testPartitionEnd; }
-      set {
-        if (0 < value || value > dataset.Rows)
-          throw new ArgumentException(string.Format("The test partition end must be between 0 and the number of rows of the dataset ({0})", dataset.Rows));
-        if (testPartitionEnd != value) {
-          testPartitionEnd = value;
-          OnChanged();
-        }
-      }
+    public IntValue TestPartitionEnd {
+      get { return TestPartitionEndParameter.Value; }
     }
 
     public IEnumerable<int> TrainingIndizes {
       get {
-        return Enumerable.Range(TrainingPartitionStart, TrainingPartitionEnd - TrainingPartitionStart)
-                         .Where(i => i >= 0 && i < Dataset.Rows && (i < TestPartitionStart || TestPartitionEnd <= i));
+        return Enumerable.Range(TrainingPartitionStart.Value, TrainingPartitionEnd.Value - TrainingPartitionStart.Value)
+                         .Where(i => i >= 0 && i < Dataset.Rows && (i < TestPartitionStart.Value || TestPartitionEnd.Value <= i));
       }
     }
     public IEnumerable<int> TestIndizes {
       get {
-        return Enumerable.Range(TestPartitionStart, TestPartitionEnd - TestPartitionStart)
+        return Enumerable.Range(TestPartitionStart.Value, TestPartitionEnd.Value - TestPartitionStart.Value)
            .Where(i => i >= 0 && i < Dataset.Rows);
       }
@@ -122,27 +111,37 @@
         throw new ArgumentException("All allowed input variables must be present in the dataset.");
 
-      this.dataset = dataset;
-      this.allowedInputVariables = new HashSet<string>(allowedInputVariables);
-      trainingPartitionStart = 0;
-      trainingPartitionEnd = dataset.Rows / 2;
-      testPartitionStart = dataset.Rows / 2;
-      testPartitionEnd = dataset.Rows;
+      var inputVariables = new CheckedItemCollection<StringValue>(dataset.VariableNames.Select(x => new StringValue(x)));
+      foreach (StringValue x in inputVariables)
+        inputVariables.SetItemCheckedState(x, allowedInputVariables.Contains(x.Value));
+
+      int trainingPartitionStart = 0;
+      int trainingPartitionEnd = dataset.Rows / 2;
+      int testPartitionStart = dataset.Rows / 2;
+      int testPartitionEnd = dataset.Rows;
+
+      Parameters.Add(new ValueParameter<Dataset>(DatasetParameterName, "", dataset));
+      Parameters.Add(new FixedValueParameter<ICheckedItemCollection<StringValue>>(InputVariablesParameterName, "", inputVariables.AsReadOnly()));
+      Parameters.Add(new FixedValueParameter<IntValue>(TrainingPartitionStartParameterName, "", new IntValue(trainingPartitionStart)));
+      Parameters.Add(new FixedValueParameter<IntValue>(TrainingPartitionEndParameterName, "", new IntValue(trainingPartitionEnd)));
+      Parameters.Add(new FixedValueParameter<IntValue>(TestPartitionStartParameterName, "", new IntValue(testPartitionStart)));
+      Parameters.Add(new FixedValueParameter<IntValue>(TestPartitionEndParameterName, "", new IntValue(testPartitionEnd)));
+
+      RegisterEventHandlers();
     }
 
-    public bool AddAllowedInputVariable(string inputVariable) {
-      if (!Dataset.VariableNames.Contains(inputVariable))
-        throw new ArgumentException("The allowed input variable must be present in the dataset.");
-      if (allowedInputVariables.Contains(inputVariable)) return false;
+    private void RegisterEventHandlers() {
+      DatasetParameter.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      InputVariables.CheckedItemsChanged += new CollectionItemsChangedEventHandler<StringValue>(InputVariables_CheckedItemsChanged);
+      TrainingPartitionStart.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      TrainingPartitionEnd.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      TestPartitionStart.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      TestPartitionEnd.ValueChanged += new EventHandler(Parameter_ValueChanged);
+    }
 
-      allowedInputVariables.Add(inputVariable);
-      return true;
+    private void InputVariables_CheckedItemsChanged(object sender, CollectionItemsChangedEventArgs<StringValue> e) {
+      OnChanged();
     }
-    public bool RemoveAllowedInputVariable(string inputVariable) {
-      if (!Dataset.VariableNames.Contains(inputVariable))
-        throw new ArgumentException("The allowed input variable must be present in the dataset.");
-      if (!allowedInputVariables.Contains(inputVariable)) return false;
-
-      allowedInputVariables.Remove(inputVariable);
-      return true;
+    private void Parameter_ValueChanged(object sender, EventArgs e) {
+      OnChanged();
     }
 
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 5586)
@@ -23,17 +23,16 @@
 using System.Collections.Generic;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis {
-  public interface IDataAnalysisProblemData : INamedItem {
-    Dataset Dataset { get; }
+  public interface IDataAnalysisProblemData : IParameterizedNamedItem {
+    Dataset Dataset { get; set; }
+    ICheckedItemCollection<StringValue> InputVariables { get; }
     IEnumerable<string> AllowedInputVariables { get; }
 
-    bool AddAllowedInputVariable(string inputVariable);
-    bool RemoveAllowedInputVariable(string inputVariable);
-
-    int TrainingPartitionStart { get; set; }
-    int TrainingPartitionEnd { get; set; }
-    int TestPartitionStart { get; set; }
-    int TestPartitionEnd { get; set; }
+    IntValue TrainingPartitionStart { get; }
+    IntValue TrainingPartitionEnd { get; }
+    IntValue TestPartitionStart { get; }
+    IntValue TestPartitionEnd { get; }
 
     IEnumerable<int> TrainingIndizes { get; }
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs	(revision 5586)
@@ -20,7 +20,8 @@
 #endregion
 
+using HeuristicLab.Data;
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface IRegressionProblemData : IDataAnalysisProblemData {
-    string TargetVariable { get; set; }
+    StringValue TargetVariable { get; }
   }
 }
Index: branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/RegressionProblemData.cs
===================================================================
--- branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/RegressionProblemData.cs	(revision 5585)
+++ branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis/3.4/RegressionProblemData.cs	(revision 5586)
@@ -20,9 +20,11 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
@@ -30,4 +32,5 @@
   [StorableClass]
   public sealed class RegressionProblemData : DataAnalysisProblemData, IRegressionProblemData {
+    private const string TargetVariableParameterName = "TargetVariable";
 
     #region default data
@@ -72,19 +75,11 @@
     #endregion
 
-    #region propeties
-    [Storable]
-    private string targetVariable;
-    public string TargetVariable {
-      get { return targetVariable; }
-      set {
-        if (!Dataset.VariableNames.Contains(value))
-          throw new ArgumentException(string.Format("The target variable {0} is not present in the dataset", value));
-        if (targetVariable != value) {
-          targetVariable = value;
-          OnChanged();
-        }
-      }
+    public IValueParameter<StringValue> TargetVariableParameter {
+      get { return (IValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     }
-    #endregion
+    public StringValue TargetVariable {
+      get { return TargetVariableParameter.Value; }
+    }
+
 
     [StorableConstructor]
@@ -99,5 +94,5 @@
     public RegressionProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable)
       : base(dataset, allowedInputVariables) {
-      TargetVariable = targetVariable;
+      Parameters.Add(new ConstrainedValueParameter<StringValue>("TargetVariable", new ItemSet<StringValue>(InputVariables), InputVariables.Where(x => x.Value == targetVariable).First()));
     }
 
