Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/Generator/RegressionBenchmark.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/Generator/RegressionBenchmark.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/Generator/RegressionBenchmark.cs	(revision 6991)
@@ -20,5 +20,4 @@
 #endregion
 
-using System;
 using System.Collections;
 using System.Collections.Generic;
@@ -26,7 +25,15 @@
 using HeuristicLab.Common;
 using HeuristicLab.Data;
+using HeuristicLab.Random;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
   public abstract class RegressionBenchmark : Benchmark, IRegressionBenchmarkProblemDataGenerator {
+
+    #region properties
+    public abstract List<string> InputVariable { get; }
+    public abstract string TargetVariable { get; }
+    public abstract IntRange TrainingPartition { get; }
+    public abstract IntRange TestPartition { get; }
+    #endregion
 
     protected RegressionBenchmark() { }
@@ -35,23 +42,16 @@
     }
 
-    #region properties
-    public string TargetVariable { get; protected set; }
-    public Dictionary<string, IntRange> Inputvariables { get; protected set; }
-    public int AmountOfPoints { get; protected set; }
-    public IntRange TrainingPartition { get; protected set; }
-    public IntRange TestPartition { get; protected set; }
-    #endregion
+    protected abstract List<double> CalculateFunction(Dictionary<string, IList<double>> data);
 
-    protected abstract double CalculateFunction(Dictionary<string, IList<double>> data, List<string> vars);
+    protected abstract Dictionary<string, IList<double>> GenerateInput(Dictionary<string, IList<double>> data);
 
     public IDataAnalysisProblemData GenerateProblemData() {
-      //prepare dictionary
       Dictionary<string, IList<double>> data = new Dictionary<string, IList<double>>();
-      data.Add(TargetVariable, new List<double>());
-      foreach (var variable in Inputvariables.Keys) {
+      data.Add(this.TargetVariable, new List<double>());
+      foreach (var variable in this.InputVariable) {
         data.Add(variable, new List<double>());
       }
 
-      data = CalculateValues(data);
+      data = GenerateInput(data);
 
       List<IList> values = new List<IList>();
@@ -65,39 +65,82 @@
       RegressionProblemData problemData = new RegressionProblemData(dataset, dataset.DoubleVariables.Skip(1), dataset.DoubleVariables.First());
 
-      #region set ProblemData specific parameters
       problemData.Name = "Data generated for benchmark problem \"" + this.Name + "\"";
 
-      problemData.TargetVariableParameter.Value =
-        problemData.TargetVariableParameter.ValidValues.First(v => v.Value == TargetVariable);
-      problemData.InputVariables.SetItemCheckedState(
-        problemData.InputVariables.Single(x => x.Value == TargetVariable), false);
-
-      foreach (var variable in this.Inputvariables) {
-        problemData.InputVariables.SetItemCheckedState(
-          problemData.InputVariables.Single(x => x.Value == variable.Key), true);
-      }
 
       problemData.TestPartition.Start = this.TestPartition.Start;
       problemData.TestPartition.End = this.TestPartition.End;
+
       problemData.TrainingPartition.Start = this.TrainingPartition.Start;
       problemData.TrainingPartition.End = this.TrainingPartition.End;
-      #endregion
 
       return problemData;
     }
 
-    private Dictionary<string, IList<double>> CalculateValues(Dictionary<string, IList<double>> data) {
-      Random rand = new Random();
-      List<string> vars = new List<string>(Inputvariables.Keys);
-      for (int i = 0; i < AmountOfPoints; i++) {
-        foreach (var variable in vars) {
-          data[variable].Add(rand.NextDouble() *
-            (Inputvariables[variable].End - Inputvariables[variable].Start) +
-            Inputvariables[variable].Start);
-        }
+    //private Dictionary<string, IList<double>> CalculateValues(Dictionary<string, IList<double>> data, DatasetDefinition dataDef) {
+    //  Random rand = new Random();
+    //  var combinationDataSet = AllCombinationsOf(dataDef.RangeVariables.Values.Select(range => range.Values).ToList());
+    //  int index = 0;
+    //  var help = dataDef.RangeVariables.Keys;
+    //  foreach (var dataSet in combinationDataSet) {
+    //    data[help.ElementAt(index)] = dataSet;
+    //    index++;
+    //  }
+    //  List<string> vars = new List<string>(dataDef.RandomVariables.Keys);
+    //  for (int i = 0; i < dataDef.AmountOfPoints; i++) {
+    //    foreach (var variable in vars) {
+    //      data[variable].Add(dataDef.RandomVariables[variable].Next());
+    //    }
+    //    //  data[TargetVariable].Add(CalculateFunction(data, vars));
+    //  }
+    //  int bla = 0;
+    //  var test = data.Values.Select((ind) => (ind.ElementAt(bla)));
 
-        data[TargetVariable].Add(CalculateFunction(data, vars));
+    //  return data;
+    //}
+
+    public static List<double> generateSteps(DoubleRange range, double stepWidth) {
+      return Enumerable.Range(0, (int)((range.End - range.Start) / stepWidth) + 1)
+                                      .Select(i => (range.Start + i * stepWidth))
+                                      .ToList<double>();
+    }
+
+    public static List<double> generateUniformDistributedValues(int amount, DoubleRange range) {
+      List<double> values = new List<double>();
+      System.Random rand = new System.Random();
+      for (int i = 0; i < amount; i++) {
+        values.Add(rand.NextDouble() * (range.End - range.Start) + range.Start);
       }
-      return data;
+      return values;
+    }
+
+    public static List<double> generateNormalDistributedValues(int amount, double mu, double sigma) {
+      List<double> values = new List<double>();
+      FastRandom rand = new FastRandom();
+      for (int i = 0; i < amount; i++) {
+        values.Add(NormalDistributedRandom.NextDouble(rand, mu, sigma));
+      }
+      return values;
+    }
+
+    public static List<List<double>> AllCombinationsOf(List<List<double>> sets) {
+
+      var combinations = new List<List<double>>();
+
+      foreach (var value in sets[0])
+        combinations.Add(new List<double> { value });
+
+      foreach (var set in sets.Skip(1))
+        combinations = AddExtraSet(combinations, set);
+
+      return combinations;
+    }
+
+    private static List<List<double>> AddExtraSet
+         (List<List<double>> combinations, List<double> set) {
+      var newCombinations = from value in set
+                            from combination in combinations
+                            select new List<double>(combination) { value };
+
+      return newCombinations.ToList();
     }
   }
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/HeuristicLab.Problems.DataAnalysis.Benchmarks-3.4.csproj
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/HeuristicLab.Problems.DataAnalysis.Benchmarks-3.4.csproj	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/HeuristicLab.Problems.DataAnalysis.Benchmarks-3.4.csproj	(revision 6991)
@@ -49,21 +49,8 @@
   <ItemGroup>
     <Compile Include="Benchmark.cs" />
-    <Compile Include="DistributionGenerator\Distribution.cs" />
-    <Compile Include="DistributionGenerator\DistributionGenerator.cs" />
-    <Compile Include="DistributionGenerator\NormalDistribution.cs" />
-    <Compile Include="DistributionGenerator\RandomDistribution.cs" />
-    <Compile Include="DistributionGenerator\StepsDistribution.cs" />
-    <Compile Include="DistributionGenerator\UniformalDistribution.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
-    <Compile Include="RegressionBenchmarks\RationalPolynomial.cs" />
-    <Compile Include="RegressionBenchmarks\RationalPolynomialTwo.cs" />
-    <Compile Include="RegressionBenchmarks\RippleFunction.cs" />
-    <Compile Include="RegressionBenchmarks\SalustowiczFunctionTwoDimensional.cs" />
     <Compile Include="RegressionBenchmarks\KotanchekFunction.cs" />
     <Compile Include="Generator\RegressionBenchmark.cs" />
-    <Compile Include="RegressionBenchmarks\SalustowiczFunctionOneDimensional.cs" />
-    <Compile Include="RegressionBenchmarks\SineCosineFunction.cs" />
-    <Compile Include="RegressionBenchmarks\UnwrappedBallFunction.cs" />
   </ItemGroup>
   <ItemGroup>
@@ -96,4 +83,8 @@
       <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Random\3.3\HeuristicLab.Random-3.3.csproj">
+      <Project>{F4539FB6-4708-40C9-BE64-0A1390AEA197}</Project>
+      <Name>HeuristicLab.Random-3.3</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/KotanchekFunction.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/KotanchekFunction.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/KotanchekFunction.cs	(revision 6991)
@@ -31,14 +31,27 @@
   public class KotanchekFunction : RegressionBenchmark {
 
+    private const string targetVariable = "Y";
+    private static readonly List<string> inputVariables = new List<string>() { "X1", "X2" };
+    private static readonly IntRange trainingPartition = new IntRange(0, 1000);
+    private static readonly IntRange testPartition = new IntRange(1001, 2000);
+
+    public override List<string> InputVariable {
+      get { return inputVariables; }
+    }
+
+    public override string TargetVariable {
+      get { return targetVariable; }
+    }
+
+    public override IntRange TrainingPartition {
+      get { return trainingPartition; }
+    }
+
+    public override IntRange TestPartition {
+      get { return testPartition; }
+    }
+
     public KotanchekFunction() {
       Name = "Kotanchek function (2d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(0, 4)},
-        {"x2", new IntRange(0, 4)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
@@ -53,8 +66,21 @@
     #endregion
 
-    protected override double CalculateFunction(Dictionary<string, IList<double>> data, List<string> vars) {
-      double x1 = data[vars.ElementAt(0)].Last();
-      double x2 = data[vars.ElementAt(1)].Last();
-      return Math.Exp(-Math.Pow(x1 - 1, 2)) / (Math.Pow(x2 - 2.5, 2) + 3.2);
+    protected override List<double> CalculateFunction(Dictionary<string, IList<double>> data) {
+      double x1, x2;
+      List<double> results = new List<double>();
+      for (int i = 0; i < TestPartition.End; i++) {
+        x1 = data[InputVariable.ElementAt(0)].ElementAt(i);
+        x2 = data[InputVariable.ElementAt(1)].ElementAt(i);
+        results.Add(Math.Exp(-Math.Pow(x1 - 1, 2)) / (Math.Pow(x2 - 2.5, 2) + 3.2));
+      }
+      return results;
+    }
+
+    protected override Dictionary<string, IList<double>> GenerateInput(Dictionary<string, IList<double>> data) {
+      foreach (var variable in InputVariable) {
+        data[variable] = RegressionBenchmark.generateUniformDistributedValues(TestPartition.End, new DoubleRange(0, 4));
+      }
+      data[TargetVariable] = CalculateFunction(data);
+      return data;
     }
   }
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RationalPolynomial.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RationalPolynomial.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RationalPolynomial.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -32,14 +31,15 @@
 
     public RationalPolynomial() {
-      Name = "Rational polynomial (3d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(0, 2)},
-        {"x2", new IntRange(1, 2)},
-        {"x3", new IntRange(1, 2)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //Name = "Rational polynomial (3d)";
+      //TargetVariable = "y";
+
+      //var inputVariables = new Dictionary<string, RandomDistribution>() {
+      //  {"x1", new UniformalDistribution(0, 2)},
+      //  {"x2", new UniformalDistribution(1, 2)},
+      //  {"x3", new UniformalDistribution(1, 2)}
+      //};
+
+      //TestData = new DatasetDefinition(2667, inputVariables);
+      //TrainingData = new DatasetDefinition(1333, inputVariables);
     }
 
@@ -54,5 +54,5 @@
     #endregion
 
-    protected override double CalculateFunction(Dictionary<string, IList<double>> data, List<string> vars) {
+    protected override double CalculateFunction(Dictionary<string, IList<double>> data) {
       double x1 = data[vars.ElementAt(0)].Last();
       double x2 = data[vars.ElementAt(1)].Last();
@@ -60,4 +60,24 @@
       return (30 * (x1 - 1) * (x3 - 1)) / ((x1 - 10) * Math.Pow(x2, 2));
     }
+
+    public override List<string> InputVariable {
+      get { throw new NotImplementedException(); }
+    }
+
+    public override string TargetVariable {
+      get { throw new NotImplementedException(); }
+    }
+
+    public override Data.IntRange TrainingPartition {
+      get { throw new NotImplementedException(); }
+    }
+
+    public override Data.IntRange TestPartition {
+      get { throw new NotImplementedException(); }
+    }
+
+    protected override Dictionary<string, IList<double>> GenerateInput(Dictionary<string, IList<double>> data) {
+      throw new NotImplementedException();
+    }
   }
 }
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RationalPolynomialTwo.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RationalPolynomialTwo.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RationalPolynomialTwo.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -33,12 +32,12 @@
     public RationalPolynomialTwo() {
       Name = "RationalPolynomial2 (2d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(0, 6)},
-        {"x2", new IntRange(0, 6)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //TargetVariable = "y";
+      //Inputvariables = new Dictionary<string, IntRange>() {
+      //  {"x1", new IntRange(0, 6)},
+      //  {"x2", new IntRange(0, 6)}
+      //};
+      //AmountOfPoints = 4000;
+      //TrainingPartition = new IntRange(0, 2667);
+      //TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RippleFunction.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RippleFunction.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/RippleFunction.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -33,12 +32,12 @@
     public RippleFunction() {
       Name = "Ripple function (2d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(0, 6)},
-        {"x2", new IntRange(0, 6)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //TargetVariable = "y";
+      //Inputvariables = new Dictionary<string, IntRange>() {
+      //  {"x1", new IntRange(0, 6)},
+      //  {"x2", new IntRange(0, 6)}
+      //};
+      //AmountOfPoints = 4000;
+      //TrainingPartition = new IntRange(0, 2667);
+      //TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SalustowiczFunctionOneDimensional.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SalustowiczFunctionOneDimensional.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SalustowiczFunctionOneDimensional.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -33,11 +32,11 @@
     public SalustowiczFunctionOneDimensional() {
       Name = "Salustowicz function (1d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x", new IntRange(0, 10)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //TargetVariable = "y";
+      //Inputvariables = new Dictionary<string, IntRange>() {
+      //  {"x", new IntRange(0, 10)}
+      //};
+      //AmountOfPoints = 4000;
+      //TrainingPartition = new IntRange(0, 2667);
+      //TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SalustowiczFunctionTwoDimensional.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SalustowiczFunctionTwoDimensional.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SalustowiczFunctionTwoDimensional.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -33,12 +32,12 @@
     public SalustowiczFunctionTwoDimensional() {
       Name = "Salustowicz function (2d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(0, 10)},
-        {"x2", new IntRange(0, 10)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //TargetVariable = "y";
+      //Inputvariables = new Dictionary<string, IntRange>() {
+      //  {"x1", new IntRange(0, 10)},
+      //  {"x2", new IntRange(0, 10)}
+      //};
+      //AmountOfPoints = 4000;
+      //TrainingPartition = new IntRange(0, 2667);
+      //TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SineCosineFunction.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SineCosineFunction.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/SineCosineFunction.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -33,12 +32,12 @@
     public SineCosineFunction() {
       Name = "SineCosine function (2d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(0, 6)},
-        {"x2", new IntRange(0, 6)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //TargetVariable = "y";
+      //Inputvariables = new Dictionary<string, IntRange>() {
+      //  {"x1", new IntRange(0, 6)},
+      //  {"x2", new IntRange(0, 6)}
+      //};
+      //AmountOfPoints = 4000;
+      //TrainingPartition = new IntRange(0, 2667);
+      //TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
Index: branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/UnwrappedBallFunction.cs
===================================================================
--- branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/UnwrappedBallFunction.cs	(revision 6973)
+++ branches/RegressionBenchmarks/HeuristicLab.Problems.DataAnalysis.Benchmarks/3.4/RegressionBenchmarks/UnwrappedBallFunction.cs	(revision 6991)
@@ -25,5 +25,4 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 
 namespace HeuristicLab.Problems.DataAnalysis.Benchmarks {
@@ -33,11 +32,11 @@
     public UnwrappedBallFunction() {
       Name = "UnwrappedBall function (1d)";
-      TargetVariable = "y";
-      Inputvariables = new Dictionary<string, IntRange>() {
-        {"x1", new IntRange(-2, 8)}
-      };
-      AmountOfPoints = 4000;
-      TrainingPartition = new IntRange(0, 2667);
-      TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
+      //TargetVariable = "y";
+      //Inputvariables = new Dictionary<string, IntRange>() {
+      //  {"x1", new IntRange(-2, 8)}
+      //};
+      //AmountOfPoints = 4000;
+      //TrainingPartition = new IntRange(0, 2667);
+      //TestPartition = new IntRange(TrainingPartition.End, AmountOfPoints);
     }
 
