Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj	(revision 17681)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj	(revision 17682)
@@ -157,4 +157,126 @@
     <Compile Include="Regression\FeatureSelection\FeatureSelection.cs" />
     <Compile Include="Regression\FeatureSelection\FeatureSelectionInstanceProvider.cs" />
+    <Compile Include="Regression\Feynman\Feynman1.cs" />
+    <Compile Include="Regression\Feynman\Feynman10.cs" />
+    <Compile Include="Regression\Feynman\Feynman100.cs" />
+    <Compile Include="Regression\Feynman\Feynman11.cs" />
+    <Compile Include="Regression\Feynman\Feynman12.cs" />
+    <Compile Include="Regression\Feynman\Feynman13.cs" />
+    <Compile Include="Regression\Feynman\Feynman14.cs" />
+    <Compile Include="Regression\Feynman\Feynman15.cs" />
+    <Compile Include="Regression\Feynman\Feynman16.cs" />
+    <Compile Include="Regression\Feynman\Feynman17.cs" />
+    <Compile Include="Regression\Feynman\Feynman18.cs" />
+    <Compile Include="Regression\Feynman\Feynman19.cs" />
+    <Compile Include="Regression\Feynman\Feynman2.cs" />
+    <Compile Include="Regression\Feynman\Feynman20.cs" />
+    <Compile Include="Regression\Feynman\Feynman21.cs" />
+    <Compile Include="Regression\Feynman\Feynman22.cs" />
+    <Compile Include="Regression\Feynman\Feynman23.cs" />
+    <Compile Include="Regression\Feynman\Feynman24.cs" />
+    <Compile Include="Regression\Feynman\Feynman25.cs" />
+    <Compile Include="Regression\Feynman\Feynman26.cs" />
+    <Compile Include="Regression\Feynman\Feynman27.cs" />
+    <Compile Include="Regression\Feynman\Feynman28.cs" />
+    <Compile Include="Regression\Feynman\Feynman29.cs" />
+    <Compile Include="Regression\Feynman\Feynman3.cs" />
+    <Compile Include="Regression\Feynman\Feynman30.cs" />
+    <Compile Include="Regression\Feynman\Feynman31.cs" />
+    <Compile Include="Regression\Feynman\Feynman32.cs" />
+    <Compile Include="Regression\Feynman\Feynman33.cs" />
+    <Compile Include="Regression\Feynman\Feynman34.cs" />
+    <Compile Include="Regression\Feynman\Feynman35.cs" />
+    <Compile Include="Regression\Feynman\Feynman36.cs" />
+    <Compile Include="Regression\Feynman\Feynman37.cs" />
+    <Compile Include="Regression\Feynman\Feynman38.cs" />
+    <Compile Include="Regression\Feynman\Feynman39.cs" />
+    <Compile Include="Regression\Feynman\Feynman4.cs" />
+    <Compile Include="Regression\Feynman\Feynman40.cs" />
+    <Compile Include="Regression\Feynman\Feynman41.cs" />
+    <Compile Include="Regression\Feynman\Feynman42.cs" />
+    <Compile Include="Regression\Feynman\Feynman43.cs" />
+    <Compile Include="Regression\Feynman\Feynman44.cs" />
+    <Compile Include="Regression\Feynman\Feynman45.cs" />
+    <Compile Include="Regression\Feynman\Feynman46.cs" />
+    <Compile Include="Regression\Feynman\Feynman47.cs" />
+    <Compile Include="Regression\Feynman\Feynman48.cs" />
+    <Compile Include="Regression\Feynman\Feynman49.cs" />
+    <Compile Include="Regression\Feynman\Feynman5.cs" />
+    <Compile Include="Regression\Feynman\Feynman50.cs" />
+    <Compile Include="Regression\Feynman\Feynman51.cs" />
+    <Compile Include="Regression\Feynman\Feynman52.cs" />
+    <Compile Include="Regression\Feynman\Feynman53.cs" />
+    <Compile Include="Regression\Feynman\Feynman54.cs" />
+    <Compile Include="Regression\Feynman\Feynman55.cs" />
+    <Compile Include="Regression\Feynman\Feynman56.cs" />
+    <Compile Include="Regression\Feynman\Feynman57.cs" />
+    <Compile Include="Regression\Feynman\Feynman58.cs" />
+    <Compile Include="Regression\Feynman\Feynman59.cs" />
+    <Compile Include="Regression\Feynman\Feynman6.cs" />
+    <Compile Include="Regression\Feynman\Feynman60.cs" />
+    <Compile Include="Regression\Feynman\Feynman61.cs" />
+    <Compile Include="Regression\Feynman\Feynman62.cs" />
+    <Compile Include="Regression\Feynman\Feynman63.cs" />
+    <Compile Include="Regression\Feynman\Feynman64.cs" />
+    <Compile Include="Regression\Feynman\Feynman65.cs" />
+    <Compile Include="Regression\Feynman\Feynman66.cs" />
+    <Compile Include="Regression\Feynman\Feynman67.cs" />
+    <Compile Include="Regression\Feynman\Feynman68.cs" />
+    <Compile Include="Regression\Feynman\Feynman69.cs" />
+    <Compile Include="Regression\Feynman\Feynman7.cs" />
+    <Compile Include="Regression\Feynman\Feynman70.cs" />
+    <Compile Include="Regression\Feynman\Feynman71.cs" />
+    <Compile Include="Regression\Feynman\Feynman72.cs" />
+    <Compile Include="Regression\Feynman\Feynman73.cs" />
+    <Compile Include="Regression\Feynman\Feynman74.cs" />
+    <Compile Include="Regression\Feynman\Feynman75.cs" />
+    <Compile Include="Regression\Feynman\Feynman76.cs" />
+    <Compile Include="Regression\Feynman\Feynman77.cs" />
+    <Compile Include="Regression\Feynman\Feynman78.cs" />
+    <Compile Include="Regression\Feynman\Feynman79.cs" />
+    <Compile Include="Regression\Feynman\Feynman8.cs" />
+    <Compile Include="Regression\Feynman\Feynman80.cs" />
+    <Compile Include="Regression\Feynman\Feynman81.cs" />
+    <Compile Include="Regression\Feynman\Feynman82.cs" />
+    <Compile Include="Regression\Feynman\Feynman83.cs" />
+    <Compile Include="Regression\Feynman\Feynman84.cs" />
+    <Compile Include="Regression\Feynman\Feynman85.cs" />
+    <Compile Include="Regression\Feynman\Feynman86.cs" />
+    <Compile Include="Regression\Feynman\Feynman87.cs" />
+    <Compile Include="Regression\Feynman\Feynman88.cs" />
+    <Compile Include="Regression\Feynman\Feynman89.cs" />
+    <Compile Include="Regression\Feynman\Feynman9.cs" />
+    <Compile Include="Regression\Feynman\Feynman90.cs" />
+    <Compile Include="Regression\Feynman\Feynman91.cs" />
+    <Compile Include="Regression\Feynman\Feynman92.cs" />
+    <Compile Include="Regression\Feynman\Feynman93.cs" />
+    <Compile Include="Regression\Feynman\Feynman94.cs" />
+    <Compile Include="Regression\Feynman\Feynman95.cs" />
+    <Compile Include="Regression\Feynman\Feynman96.cs" />
+    <Compile Include="Regression\Feynman\Feynman97.cs" />
+    <Compile Include="Regression\Feynman\Feynman98.cs" />
+    <Compile Include="Regression\Feynman\Feynman99.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus1.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus10.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus11.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus12.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus13.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus14.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus15.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus16.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus17.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus18.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus19.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus2.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus20.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus3.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus4.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus5.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus6.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus7.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus8.cs" />
+    <Compile Include="Regression\Feynman\FeynmanBonus9.cs" />
+    <Compile Include="Regression\Feynman\FeynmanDescriptor.cs" />
+    <Compile Include="Regression\Feynman\FeynmanInstanceProvider.cs" />
     <Compile Include="Regression\MibaFriction\CF3.cs" />
     <Compile Include="Regression\MibaFriction\Wear1.cs" />
@@ -323,4 +445,5 @@
     </Reference>
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman1.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman1.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman1.cs	(revision 17682)
@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman1 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman1() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman1(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman1(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.6.20a exp(-theta**2/2)/sqrt(2*pi) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "f" : "f_noise"; } }
+    protected override string[] VariableNames { get { return new[] {"theta", noiseRatio == null ? "f" : "f_noise"}; } }
+    protected override string[] AllowedInputVariables { get { return new[] {"theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var f = new List<double>();
+
+      data.Add(theta);
+      data.Add(f);
+
+      for (var i = 0; i < theta.Count; i++) {
+        var res = Math.Exp(Math.Pow(-theta[i], 2) / 2) / Math.Sqrt(2 * Math.PI);
+        f.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var f_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * f.StandardDeviationPop();
+        f_noise.AddRange(f.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(f);
+        data.Add(f_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman10.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman10.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman10.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman10 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman10() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman10(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman10(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.12.4 q1/(4*pi*epsilon*r**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Ef" : "Ef_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q1", "epsilon", "r", noiseRatio == null ? "Ef" : "Ef_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q1", "epsilon", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q1      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Ef = new List<double>();
+
+      data.Add(q1);
+      data.Add(epsilon);
+      data.Add(r);
+      data.Add(Ef);
+
+      for (var i = 0; i < q1.Count; i++) {
+        var res = q1[i] / (4 * Math.PI * epsilon[i] * Math.Pow(r[i], 2));
+        Ef.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Ef_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * Ef.StandardDeviationPop();
+        Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Ef);
+        data.Add(Ef_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman100.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman100.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman100.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman100 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman100() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman100(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman100(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.21.20 -rho_c_0*q*A_vec/m | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "j" : "j_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"rho_c_0", "q", "A_vec", "m", noiseRatio == null ? "j" : "j_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"rho_c_0", "q", "A_vec", "m"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var rho_c_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var A_vec   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var j = new List<double>();
+
+      data.Add(rho_c_0);
+      data.Add(q);
+      data.Add(A_vec);
+      data.Add(m);
+      data.Add(j);
+
+      for (var i = 0; i < rho_c_0.Count; i++) {
+        var res = -rho_c_0[i] * q[i] * A_vec[i] / m[i];
+        j.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var j_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * j.StandardDeviationPop();
+        j_noise.AddRange(j.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(j);
+        data.Add(j_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman11.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman11.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman11.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman11 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman11() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman11(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman11(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.12.5 q2*Ef | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q2", "Ef", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q2", "Ef"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var q2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var F = new List<double>();
+
+      data.Add(q2);
+      data.Add(Ef);
+      data.Add(F);
+
+      for (var i = 0; i < q2.Count; i++) {
+        var res = q2[i] * Ef[i];
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman12.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman12.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman12.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman12 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman12() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman12(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman12(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.12.11 q*(Ef + B*v*sin(theta)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "Ef", "B", "v", "theta", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "Ef", "B", "v", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var q     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var F = new List<double>();
+
+      data.Add(q);
+      data.Add(Ef);
+      data.Add(B);
+      data.Add(v);
+      data.Add(theta);
+      data.Add(F);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] * (Ef[i] + B[i] * v[i] * Math.Sin(theta[i]));
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman13.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman13.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman13.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman13 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman13() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman13(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman13(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.13.4 1/2*m*(v**2+u**2+w**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "K" : "K_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "v", "u", "w", noiseRatio == null ? "K" : "K_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "v", "u", "w"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var u    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var w    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var K = new List<double>();
+
+      data.Add(m);
+      data.Add(v);
+      data.Add(u);
+      data.Add(w);
+      data.Add(K);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = 1.0 / 2 * m[i] * (Math.Pow(v[i], 2) + Math.Pow(u[i], 2) + Math.Pow(w[i], 2));
+        K.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var K_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * K.StandardDeviationPop();
+        K_noise.AddRange(K.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(K);
+        data.Add(K_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman14.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman14.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman14.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman14 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman14() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman14(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman14(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.13.12 G*m1*m2*(1/r2-1/r1) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "U" : "U_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m1", "m2", "r1", "r2", "G", noiseRatio == null ? "U" : "U_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m1", "m2", "r1", "r2", "G"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var G    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var U = new List<double>();
+
+      data.Add(m1);
+      data.Add(m2);
+      data.Add(r1);
+      data.Add(r2);
+      data.Add(G);
+      data.Add(U);
+
+      for (var i = 0; i < m1.Count; i++) {
+        var res = G[i] * m1[i] * m2[i] * (1 / r2[i] - 1 / r1[i]);
+        U.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var U_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * U.StandardDeviationPop();
+        U_noise.AddRange(U.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(U);
+        data.Add(U_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman15.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman15.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman15.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman15 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman15() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman15(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman15(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.14.3 m*g*z | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "U" : "U_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "g", "z", noiseRatio == null ? "U" : "U_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "g", "z"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var g    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var z    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var U = new List<double>();
+
+      data.Add(m);
+      data.Add(g);
+      data.Add(z);
+      data.Add(U);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = m[i] * g[i] * z[i];
+        U.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var U_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * U.StandardDeviationPop();
+        U_noise.AddRange(U.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(U);
+        data.Add(U_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman16.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman16.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman16.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman16 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman16() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman16(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman16(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.14.4 1/2*k_spring*x**2 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "U" : "U_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"k_spring", "x", noiseRatio == null ? "U" : "U_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"k_spring", "x"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data     = new List<List<double>>();
+      var k_spring = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x        = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var U = new List<double>();
+
+      data.Add(k_spring);
+      data.Add(x);
+      data.Add(U);
+
+      for (var i = 0; i < k_spring.Count; i++) {
+        var res = 1.0 / 2 * k_spring[i] * Math.Pow(x[i], 2);
+        U.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var U_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * U.StandardDeviationPop();
+        U_noise.AddRange(U.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(U);
+        data.Add(U_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman17.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman17.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman17.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman17 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman17() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman17(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman17(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.15.3x (x-u*t)/sqrt(1-u**2/c**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "x1" : "x1_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"x", "u", "c", "t", noiseRatio == null ? "x1" : "x1_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"x", "u", "c", "t"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var x    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5, 10).ToList();
+      var u    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 20).ToList();
+      var t    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var x1 = new List<double>();
+
+      data.Add(x);
+      data.Add(u);
+      data.Add(c);
+      data.Add(t);
+      data.Add(x1);
+
+      for (var i = 0; i < x.Count; i++) {
+        var res = (x[i] - u[i] * t[i]) / Math.Sqrt(1 - Math.Pow(u[i], 2) / Math.Pow(c[i], 2));
+        x1.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var x1_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * x1.StandardDeviationPop();
+        x1_noise.AddRange(x1.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(x1);
+        data.Add(x1_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman18.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman18.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman18.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman18 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman18() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman18(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman18(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.15.3t (t-u*x/c**2)/sqrt(1-u**2/c**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "t1" : "t1_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"x", "c", "u", "t", noiseRatio == null ? "t1" : "t1_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"x", "c", "u", "t"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var x    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+      var u    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var t    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var t1 = new List<double>();
+
+      data.Add(x);
+      data.Add(c);
+      data.Add(u);
+      data.Add(t);
+      data.Add(t1);
+
+      for (var i = 0; i < x.Count; i++) {
+        var res = (t[i] - u[i] * x[i] / Math.Pow(c[i], 2)) / Math.Sqrt(1 - Math.Pow(u[i], 2) / Math.Pow(c[i], 2));
+        t1.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var t1_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * t1.StandardDeviationPop();
+        t1_noise.AddRange(t1.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(t1);
+        data.Add(t1_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman19.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman19.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman19.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman19 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman19() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman19(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman19(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.15.10 m_0*v/sqrt(1-v**2/c**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "p" : "p_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m_0", "v", "c", noiseRatio == null ? "p" : "p_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m_0", "v", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m_0  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+
+      var p = new List<double>();
+
+      data.Add(m_0);
+      data.Add(v);
+      data.Add(c);
+      data.Add(p);
+
+      for (var i = 0; i < m_0.Count; i++) {
+        var res = m_0[i] * v[i] / Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2));
+        p.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var p_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * p.StandardDeviationPop();
+        p_noise.AddRange(p.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(p);
+        data.Add(p_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman2.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman2.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman2.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman2 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman2() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman2(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman2(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.6.20 exp(-(theta/sigma)**2/2)/(sqrt(2*pi)*sigma) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "f" : "f_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"sigma", "theta", noiseRatio == null ? "f" : "f_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"sigma", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var sigma = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var f = new List<double>();
+
+      data.Add(sigma);
+      data.Add(theta);
+      data.Add(f);
+
+      for (var i = 0; i < sigma.Count; i++) {
+        var res = Math.Exp(-Math.Pow(theta[i] / sigma[i], 2) / 2) / (Math.Sqrt(2 * Math.PI) * sigma[i]);
+        f.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var f_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * f.StandardDeviationPop();
+        f_noise.AddRange(f.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(f);
+        data.Add(f_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman20.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman20.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman20.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman20 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman20() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman20(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman20(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.16.6 (u+v)/(1+u*v/c**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "v1" : "v1_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"c", "v", "u", noiseRatio == null ? "v1" : "v1_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"c", "v", "u"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var u    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var v1 = new List<double>();
+
+      data.Add(c);
+      data.Add(v);
+      data.Add(u);
+      data.Add(v1);
+
+      for (var i = 0; i < c.Count; i++) {
+        var res = (u[i] + v[i]) / (1 + u[i] * v[i] / Math.Pow(c[i], 2));
+        v1.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var v1_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * v1.StandardDeviationPop();
+        v1_noise.AddRange(v1.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(v1);
+        data.Add(v1_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman21.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman21.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman21.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman21 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman21() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman21(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman21(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.18.4 (m1*r1 + m2*r2)/(m1 + m2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "r" : "r_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m1", "m2", "r1", "r2", noiseRatio == null ? "r" : "r_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m1", "m2", "r1", "r2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var r = new List<double>();
+
+      data.Add(m1);
+      data.Add(m2);
+      data.Add(r1);
+      data.Add(r2);
+      data.Add(r);
+
+      for (var i = 0; i < m1.Count; i++) {
+        var res = (m1[i] * r1[i] + m2[i] * r2[i]) / (m1[i] + m2[i]);
+        r.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var r_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * r.StandardDeviationPop();
+        r_noise.AddRange(r.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(r);
+        data.Add(r_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman22.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman22.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman22.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman22 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman22() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman22(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman22(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.18.12 r*F*sin(theta) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "tau" : "tau_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"r", "F", "theta", noiseRatio == null ? "tau" : "tau_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"r", "F", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var r     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var F     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 5).ToList();
+
+      var tau = new List<double>();
+
+      data.Add(r);
+      data.Add(F);
+      data.Add(theta);
+      data.Add(tau);
+
+      for (var i = 0; i < r.Count; i++) {
+        var res = r[i] * F[i] * Math.Sin(theta[i]);
+        tau.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var tau_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * tau.StandardDeviationPop();
+        tau_noise.AddRange(tau.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(tau);
+        data.Add(tau_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman23.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman23.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman23.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman23 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman23() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman23(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman23(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.18.16 m*r*v*sin(theta) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "L" : "L_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "r", "v", "theta", noiseRatio == null ? "L" : "L_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "r", "v", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var m     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var L = new List<double>();
+
+      data.Add(m);
+      data.Add(r);
+      data.Add(v);
+      data.Add(theta);
+      data.Add(L);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = m[i] * r[i] * v[i] * Math.Sin(theta[i]);
+        L.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var L_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * L.StandardDeviationPop();
+        L_noise.AddRange(L.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(L);
+        data.Add(L_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman24.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman24.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman24.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman24 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman24() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman24(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman24(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.24.6 1/4*m*(omega**2 + omega_0**2)*x**2 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "omega", "omega_0", "x", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "omega", "omega_0", "x"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var omega   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var x       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(m);
+      data.Add(omega);
+      data.Add(omega_0);
+      data.Add(x);
+      data.Add(E_n);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = 1.0 / 4 * m[i] * (Math.Pow(omega[i], 2) + Math.Pow(omega_0[i], 2)) * Math.Pow(x[i], 2);
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman25.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman25.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman25.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman25 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman25() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman25(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman25(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.25.13 q/C | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Volt" : "Volt_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "C", noiseRatio == null ? "Volt" : "Volt_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "C"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var C    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Volt = new List<double>();
+
+      data.Add(q);
+      data.Add(C);
+      data.Add(Volt);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] / C[i];
+        Volt.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Volt_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * Volt.StandardDeviationPop();
+        Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Volt);
+        data.Add(Volt_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman26.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman26.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman26.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman26 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman26() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman26(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman26(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.26.2 arcsin(n*sin(theta2)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "theta1" : "theta1_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n", "theta2", noiseRatio == null ? "theta1" : "theta1_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n", "theta2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data   = new List<List<double>>();
+      var n      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 1).ToList();
+      var theta2 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var theta1 = new List<double>();
+
+      data.Add(n);
+      data.Add(theta2);
+      data.Add(theta1);
+
+      for (var i = 0; i < n.Count; i++) {
+        var res = Math.Asin(n[i] * Math.Sin(theta2[i]));
+        theta1.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var theta1_noise = new List<double>();
+        var sigma_noise  = (double) noiseRatio * theta1.StandardDeviationPop();
+        theta1_noise.AddRange(theta1.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(theta1);
+        data.Add(theta1_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman27.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman27.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman27.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman27 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman27() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman27(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman27(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.27.6 1/(1/d1+n/d2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "foc" : "foc_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"d1", "d2", "n", noiseRatio == null ? "foc" : "foc_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"d1", "d2", "n"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var d1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var n    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var foc = new List<double>();
+
+      data.Add(d1);
+      data.Add(d2);
+      data.Add(n);
+      data.Add(foc);
+
+      for (var i = 0; i < d1.Count; i++) {
+        var res = 1.0 / (1.0 / d1[i] + n[i] / d2[i]);
+        foc.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var foc_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * foc.StandardDeviationPop();
+        foc_noise.AddRange(foc.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(foc);
+        data.Add(foc_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman28.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman28.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman28.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman28 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman28() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman28(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman28(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.29.4 omega/c | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "k" : "k_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"omega", "c", noiseRatio == null ? "k" : "k_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"omega", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 10).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 10).ToList();
+
+      var k = new List<double>();
+
+      data.Add(omega);
+      data.Add(c);
+      data.Add(k);
+
+      for (var i = 0; i < omega.Count; i++) {
+        var res = omega[i] / c[i];
+        k.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var k_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * k.StandardDeviationPop();
+        k_noise.AddRange(k.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(k);
+        data.Add(k_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman29.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman29.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman29.cs	(revision 17682)
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman29 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman29() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman29(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman29(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.29.16 sqrt(x1**2+x2**2 - 2*x1*x2*cos(theta1 - theta2)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "x" : "x_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"x1", "x2", "theta1", "theta2", noiseRatio == null ? "x" : "x_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"x1", "x2", "theta1", "theta2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data   = new List<List<double>>();
+      var x1     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x2     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta1 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta2 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var x = new List<double>();
+
+      data.Add(x1);
+      data.Add(x2);
+      data.Add(theta1);
+      data.Add(theta2);
+      data.Add(x);
+
+      for (var i = 0; i < x1.Count; i++) {
+        var res = Math.Sqrt(Math.Pow(x1[i], 2) + Math.Pow(x2[i], 2) -
+                            2 * x1[i] * x2[i] * Math.Cos(theta1[i] - theta2[i]));
+        x.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var x_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * x.StandardDeviationPop();
+        x_noise.AddRange(x.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(x);
+        data.Add(x_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman3.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman3.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman3.cs	(revision 17682)
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman3 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman3() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman3(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman3(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "I.6.20b exp(-((theta-theta1)/sigma)**2/2)/(sqrt(2*pi)*sigma) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "f" : "f_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"sigma", "theta", "theta1", noiseRatio == null ? "f" : "f_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"sigma", "theta", "theta1"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data   = new List<List<double>>();
+      var sigma  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta1 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var f = new List<double>();
+
+      data.Add(sigma);
+      data.Add(theta);
+      data.Add(theta1);
+      data.Add(f);
+
+      for (var i = 0; i < sigma.Count; i++) {
+        var res = Math.Exp(-Math.Pow((theta[i] - theta1[i]) / sigma[i], 2) / 2) / (Math.Sqrt(2 * Math.PI) * sigma[i]);
+        f.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var f_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * f.StandardDeviationPop();
+        f_noise.AddRange(f.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(f);
+        data.Add(f_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman30.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman30.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman30.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman30 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman30() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman30(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman30(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.30.3 Int_0*sin(n*theta/2)**2/sin(theta/2)**2 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Int" : "Int_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"Int_0", "theta", "n", noiseRatio == null ? "Int" : "Int_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"Int_0", "theta", "n"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var Int_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var n     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Int = new List<double>();
+
+      data.Add(Int_0);
+      data.Add(theta);
+      data.Add(n);
+      data.Add(Int);
+
+      for (var i = 0; i < Int_0.Count; i++) {
+        var res = Int_0[i] * Math.Pow(Math.Sin(n[i] * theta[i] / 2), 2) / Math.Pow(Math.Sin(theta[i] / 2), 2);
+        Int.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Int_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Int.StandardDeviationPop();
+        Int_noise.AddRange(Int.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Int);
+        data.Add(Int_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman31.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman31.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman31.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman31 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman31() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman31(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman31(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.30.5 arcsin(lambd/(n*d)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "theta" : "theta_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"lambd", "d", "n", noiseRatio == null ? "theta" : "theta_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"lambd", "d", "n"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var lambd = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2, 5).ToList();
+      var n     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var theta = new List<double>();
+
+      data.Add(lambd);
+      data.Add(d);
+      data.Add(n);
+      data.Add(theta);
+
+      for (var i = 0; i < lambd.Count; i++) {
+        var res = Math.Asin(lambd[i] / (n[i] * d[i]));
+        theta.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var theta_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * theta.StandardDeviationPop();
+        theta_noise.AddRange(theta.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(theta);
+        data.Add(theta_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman32.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman32.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman32.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman32 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman32() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman32(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman32(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.32.5 q**2*a**2/(6*pi*epsilon*c**3) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Pwr" : "Pwr_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "a", "epsilon", "c", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "a", "epsilon", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var a       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Pwr = new List<double>();
+
+      data.Add(q);
+      data.Add(a);
+      data.Add(epsilon);
+      data.Add(c);
+      data.Add(Pwr);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = Math.Pow(q[i], 2) * Math.Pow(a[i], 2) / (6 * Math.PI * epsilon[i] * Math.Pow(c[i], 3));
+        Pwr.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Pwr_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Pwr.StandardDeviationPop();
+        Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Pwr);
+        data.Add(Pwr_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman33.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman33.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman33.cs	(revision 17682)
@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman33 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman33() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman33(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman33(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "I.32.17 (1/2*epsilon*c*Ef**2)*(8*pi*r**2/3)*(omega**4/(omega**2-omega_0**2)**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Pwr" : "Pwr_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "c", "Ef", "r", "omega", "omega_0", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"epsilon", "c", "Ef", "r", "omega", "omega_0"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var omega   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 5).ToList();
+
+      var Pwr = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(c);
+      data.Add(Ef);
+      data.Add(r);
+      data.Add(omega);
+      data.Add(omega_0);
+      data.Add(Pwr);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = 1.0 / 2 * epsilon[i] * c[i] * Math.Pow(Ef[i], 2) * (8 * Math.PI * Math.Pow(r[i], 2) / 3) *
+                  (Math.Pow(omega[i], 4) / Math.Pow(Math.Pow(omega[i], 2) - Math.Pow(omega_0[i], 2), 2));
+        Pwr.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Pwr_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Pwr.StandardDeviationPop();
+        Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Pwr);
+        data.Add(Pwr_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman34.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman34.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman34.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman34 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman34() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman34(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman34(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.34.8 q*v*B/p | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "omega" : "omega_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "v", "B", "p", noiseRatio == null ? "omega" : "omega_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "v", "B", "p"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var p    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var omega = new List<double>();
+
+      data.Add(q);
+      data.Add(v);
+      data.Add(B);
+      data.Add(p);
+      data.Add(omega);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] * v[i] * B[i] / p[i];
+        omega.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var omega_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * omega.StandardDeviationPop();
+        omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(omega);
+        data.Add(omega_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman35.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman35.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman35.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman35 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman35() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman35(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman35(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.34.10 omega_0/(1-v/c) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "omega" : "omega_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"c", "v", "omega_0", noiseRatio == null ? "omega" : "omega_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"c", "v", "omega_0"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+      var v       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var omega = new List<double>();
+
+      data.Add(c);
+      data.Add(v);
+      data.Add(omega_0);
+      data.Add(omega);
+
+      for (var i = 0; i < c.Count; i++) {
+        var res = omega_0[i] / (1 - v[i] / c[i]);
+        omega.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var omega_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * omega.StandardDeviationPop();
+        omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(omega);
+        data.Add(omega_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman36.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman36.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman36.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman36 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman36() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman36(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman36(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.34.14 (1+v/c)/sqrt(1-v**2/c**2)*omega_0 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "omega" : "omega_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"c", "v", "omega_0", noiseRatio == null ? "omega" : "omega_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"c", "v", "omega_0"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+      var v       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var omega = new List<double>();
+
+      data.Add(c);
+      data.Add(v);
+      data.Add(omega_0);
+      data.Add(omega);
+
+      for (var i = 0; i < c.Count; i++) {
+        var res = (1 + v[i] / c[i]) / Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2)) * omega_0[i];
+        omega.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var omega_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * omega.StandardDeviationPop();
+        omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(omega);
+        data.Add(omega_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman37.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman37.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman37.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman37 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman37() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman37(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman37(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.34.27 h*omega | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"omega", "h", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"omega", "h"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(omega);
+      data.Add(h);
+      data.Add(E_n);
+
+      for (var i = 0; i < omega.Count; i++) {
+        var res = h[i] * omega[i];
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman38.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman38.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman38.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman38 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman38() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman38(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman38(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.37.4 I1 + I2 + 2*sqrt(I1*I2)*cos(delta) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Int" : "Int_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"I1", "I2", "delta", noiseRatio == null ? "Int" : "Int_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"I1", "I2", "delta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var I1    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var I2    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var delta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Int = new List<double>();
+
+      data.Add(I1);
+      data.Add(I2);
+      data.Add(delta);
+      data.Add(Int);
+
+      for (var i = 0; i < I1.Count; i++) {
+        var res = I1[i] + I2[i] + 2 * Math.Sqrt(I1[i] * I2[i]) * Math.Cos(delta[i]);
+        Int.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Int_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Int.StandardDeviationPop();
+        Int_noise.AddRange(Int.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Int);
+        data.Add(Int_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman39.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman39.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman39.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman39 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman39() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman39(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman39(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.38.12 4*pi*epsilon*h**2/(m*q**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "r" : "r_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "q", "h", "epsilon", noiseRatio == null ? "r" : "r_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "q", "h", "epsilon"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var r = new List<double>();
+
+      data.Add(m);
+      data.Add(q);
+      data.Add(h);
+      data.Add(epsilon);
+      data.Add(r);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = 4 * Math.PI * epsilon[i] * Math.Pow(h[i], 2) / (m[i] * Math.Pow(q[i], 2));
+        r.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var r_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * r.StandardDeviationPop();
+        r_noise.AddRange(r.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(r);
+        data.Add(r_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman4.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman4.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman4.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman4 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman4() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman4(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman4(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.8.14 sqrt((x2-x1)**2+(y2-y1)**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "d" : "d_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"x1", "x2", "y1", "y2", noiseRatio == null ? "d" : "d_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"x1", "x2", "y1", "y2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var x1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var d = new List<double>();
+
+      data.Add(x1);
+      data.Add(x2);
+      data.Add(y1);
+      data.Add(y2);
+      data.Add(d);
+
+      for (var i = 0; i < x1.Count; i++) {
+        var res = Math.Sqrt(Math.Pow(x2[i] - x1[i], 2) + Math.Pow(y2[i] - y1[i], 2));
+        d.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var d_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * d.StandardDeviationPop();
+        d_noise.AddRange(d.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(d);
+        data.Add(d_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman40.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman40.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman40.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman40 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman40() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman40(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman40(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.39.10 3/2*pF*V | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"pF", "V", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"pF", "V"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var pF   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var V    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(pF);
+      data.Add(V);
+      data.Add(E_n);
+
+      for (var i = 0; i < pF.Count; i++) {
+        var res = 3.0 / 2 * pF[i] * V[i];
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman41.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman41.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman41.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman41 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman41() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman41(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman41(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.39.11 1/(gamma-1)*pF*V | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"gamma", "pF", "V", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"gamma", "pF", "V"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var gamma = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2, 5).ToList();
+      var pF    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var V     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(gamma);
+      data.Add(pF);
+      data.Add(V);
+      data.Add(E_n);
+
+      for (var i = 0; i < gamma.Count; i++) {
+        var res = 1.0 / (gamma[i] - 1) * pF[i] * V[i];
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman42.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman42.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman42.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman42 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman42() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman42(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman42(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.39.22 n*kb*T/V | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "pr" : "pr_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n", "T", "V", "kb", noiseRatio == null ? "pr" : "pr_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n", "T", "V", "kb"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var n    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var V    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var pr = new List<double>();
+
+      data.Add(n);
+      data.Add(T);
+      data.Add(V);
+      data.Add(kb);
+      data.Add(pr);
+
+      for (var i = 0; i < n.Count; i++) {
+        var res = n[i] * kb[i] * T[i] / V[i];
+        pr.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var pr_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * pr.StandardDeviationPop();
+        pr_noise.AddRange(pr.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(pr);
+        data.Add(pr_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman43.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman43.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman43.cs	(revision 17682)
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman43 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman43() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman43(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman43(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.40.1 n_0*exp(-m*g*x/(kb*T)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "n" : "n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n_0", "m", "x", "T", "g", "kb", noiseRatio == null ? "n" : "n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n_0", "m", "x", "T", "g", "kb"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var n_0  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var g    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var n = new List<double>();
+
+      data.Add(n_0);
+      data.Add(m);
+      data.Add(x);
+      data.Add(T);
+      data.Add(g);
+      data.Add(kb);
+      data.Add(n);
+
+      for (var i = 0; i < n_0.Count; i++) {
+        var res = n_0[i] * Math.Exp(-m[i] * g[i] * x[i] / (kb[i] * T[i]));
+        n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var n_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * n.StandardDeviationPop();
+        n_noise.AddRange(n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(n);
+        data.Add(n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman44.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman44.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman44.cs	(revision 17682)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman44 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman44() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman44(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman44(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "I.41.16 h*omega**3/(pi**2 * c**2 * (exp(h*omega/(kb*T))-1)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "L_rad" : "L_rad_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"omega", "T", "h", "kb", "c", noiseRatio == null ? "L_rad" : "L_rad_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"omega", "T", "h", "kb", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var L_rad = new List<double>();
+
+      data.Add(omega);
+      data.Add(T);
+      data.Add(h);
+      data.Add(kb);
+      data.Add(c);
+      data.Add(L_rad);
+
+      for (var i = 0; i < omega.Count; i++) {
+        var res = h[i] * Math.Pow(omega[i], 3) /
+                  (Math.Pow(Math.PI, 2) * Math.Pow(c[i], 2) *
+                   (Math.Exp(h[i] * omega[i] / (kb[i] * T[i])) - 1));
+        L_rad.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var L_rad_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * L_rad.StandardDeviationPop();
+        L_rad_noise.AddRange(L_rad.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(L_rad);
+        data.Add(L_rad_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman45.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman45.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman45.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman45 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman45() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman45(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman45(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.43.16 mu_drift*q*Volt/d | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "v" : "v_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mu_drift", "q", "Volt", "d", noiseRatio == null ? "v" : "v_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mu_drift", "q", "Volt", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data     = new List<List<double>>();
+      var mu_drift = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q        = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Volt     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d        = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var v = new List<double>();
+
+      data.Add(mu_drift);
+      data.Add(q);
+      data.Add(Volt);
+      data.Add(d);
+      data.Add(v);
+
+      for (var i = 0; i < mu_drift.Count; i++) {
+        var res = mu_drift[i] * q[i] * Volt[i] / d[i];
+        v.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var v_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * v.StandardDeviationPop();
+        v_noise.AddRange(v.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(v);
+        data.Add(v_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman46.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman46.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman46.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman46 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman46() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman46(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman46(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.43.31 mob*kb*T | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "D" : "D_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mob", "T", "kb", noiseRatio == null ? "D" : "D_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mob", "T", "kb"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var mob  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var D = new List<double>();
+
+      data.Add(mob);
+      data.Add(T);
+      data.Add(kb);
+      data.Add(D);
+
+      for (var i = 0; i < mob.Count; i++) {
+        var res = mob[i] * kb[i] * T[i];
+        D.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var D_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * D.StandardDeviationPop();
+        D_noise.AddRange(D.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(D);
+        data.Add(D_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman47.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman47.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman47.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman47 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman47() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman47(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman47(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.43.43 1/(gamma-1)*kb*v/A | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "kappa" : "kappa_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"gamma", "kb", "A", "v", noiseRatio == null ? "kappa" : "kappa_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"gamma", "kb", "A", "v"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var gamma = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2, 5).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var A     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var kappa = new List<double>();
+
+      data.Add(gamma);
+      data.Add(kb);
+      data.Add(A);
+      data.Add(v);
+      data.Add(kappa);
+
+      for (var i = 0; i < gamma.Count; i++) {
+        var res = 1.0 / (gamma[i] - 1) * kb[i] * v[i] / A[i];
+        kappa.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var kappa_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * kappa.StandardDeviationPop();
+        kappa_noise.AddRange(kappa.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(kappa);
+        data.Add(kappa_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman48.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman48.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman48.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman48 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman48() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman48(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman48(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.44.4 n*kb*T*ln(V2/V1) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n", "kb", "T", "V1", "V2", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n", "kb", "T", "V1", "V2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var n    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var V1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var V2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(n);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(V1);
+      data.Add(V2);
+      data.Add(E_n);
+
+      for (var i = 0; i < n.Count; i++) {
+        var res = n[i] * kb[i] * T[i] * Math.Log(V2[i] / V1[i]);
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman49.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman49.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman49.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman49 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman49() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman49(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman49(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.47.23 sqrt(gamma*pr/rho) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "c" : "c_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"gamma", "pr", "rho", noiseRatio == null ? "c" : "c_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"gamma", "pr", "rho"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var gamma = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var pr    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var rho   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var c = new List<double>();
+
+      data.Add(gamma);
+      data.Add(pr);
+      data.Add(rho);
+      data.Add(c);
+
+      for (var i = 0; i < gamma.Count; i++) {
+        var res = Math.Sqrt(gamma[i] * pr[i] / rho[i]);
+        c.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var c_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * c.StandardDeviationPop();
+        c_noise.AddRange(c.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(c);
+        data.Add(c_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman5.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman5.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman5.cs	(revision 17682)
@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman5 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman5() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman5(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman5(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.9.18 G*m1*m2/((x2-x1)**2+(y2-y1)**2+(z2-z1)**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m1", "m2", "G", "x1", "x2", "y1", "y2", "z1", "z2", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"m1", "m2", "G", "x1", "x2", "y1", "y2", "z1", "z2"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var m2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var G    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var x1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 4).ToList();
+      var x2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var y1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 4).ToList();
+      var y2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var z1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 4).ToList();
+      var z2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var F = new List<double>();
+
+      data.Add(m1);
+      data.Add(m2);
+      data.Add(G);
+      data.Add(x1);
+      data.Add(x2);
+      data.Add(y1);
+      data.Add(y2);
+      data.Add(z1);
+      data.Add(z2);
+      data.Add(F);
+
+      for (var i = 0; i < m1.Count; i++) {
+        var res = G[i] * m1[i] * m2[i] /
+                  (Math.Pow(x2[i] - x1[i], 2) + Math.Pow(y2[i] - y1[i], 2) + Math.Pow(z2[i] - z1[i], 2));
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman50.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman50.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman50.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman50 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman50() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman50(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman50(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.48.2 m*c**2/sqrt(1-v**2/c**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "v", "c", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "v", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(m);
+      data.Add(v);
+      data.Add(c);
+      data.Add(E_n);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = m[i] * Math.Pow(c[i], 2) / Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2));
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman51.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman51.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman51.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman51 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman51() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman51(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman51(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.50.26 x1*(cos(omega*t)+alpha*cos(omega*t)**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "x" : "x_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"x1", "omega", "t", "alpha", noiseRatio == null ? "x" : "x_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"x1", "omega", "t", "alpha"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var x1    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var t     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var x = new List<double>();
+
+      data.Add(x1);
+      data.Add(omega);
+      data.Add(t);
+      data.Add(alpha);
+      data.Add(x);
+
+      for (var i = 0; i < x1.Count; i++) {
+        var res = x1[i] * (Math.Cos(omega[i] * t[i]) + alpha[i] * Math.Pow(Math.Cos(omega[i] * t[i]), 2));
+        x.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var x_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * x.StandardDeviationPop();
+        x_noise.AddRange(x.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(x);
+        data.Add(x_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman52.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman52.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman52.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman52 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman52() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman52(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman52(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.2.42 kappa*(T2-T1)*A/d | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Pwr" : "Pwr_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"kappa", "T1", "T2", "A", "d", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"kappa", "T1", "T2", "A", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var kappa = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T1    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T2    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var A     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Pwr = new List<double>();
+
+      data.Add(kappa);
+      data.Add(T1);
+      data.Add(T2);
+      data.Add(A);
+      data.Add(d);
+      data.Add(Pwr);
+
+      for (var i = 0; i < kappa.Count; i++) {
+        var res = kappa[i] * (T2[i] - T1[i]) * A[i] / d[i];
+        Pwr.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Pwr_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Pwr.StandardDeviationPop();
+        Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Pwr);
+        data.Add(Pwr_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman53.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman53.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman53.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman53 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman53() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman53(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman53(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.3.24 Pwr/(4*pi*r**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "flux" : "flux_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"Pwr", "r", noiseRatio == null ? "flux" : "flux_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"Pwr", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var Pwr  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var flux = new List<double>();
+
+      data.Add(Pwr);
+      data.Add(r);
+      data.Add(flux);
+
+      for (var i = 0; i < Pwr.Count; i++) {
+        var res = Pwr[i] / (4 * Math.PI * Math.Pow(r[i], 2));
+        flux.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var flux_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * flux.StandardDeviationPop();
+        flux_noise.AddRange(flux.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(flux);
+        data.Add(flux_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman54.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman54.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman54.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman54 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman54() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman54(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman54(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.4.23 q/(4*pi*epsilon*r) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Volt" : "Volt_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "epsilon", "r", noiseRatio == null ? "Volt" : "Volt_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "epsilon", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Volt = new List<double>();
+
+      data.Add(q);
+      data.Add(epsilon);
+      data.Add(r);
+      data.Add(Volt);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] / (4 * Math.PI * epsilon[i] * r[i]);
+        Volt.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Volt_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * Volt.StandardDeviationPop();
+        Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Volt);
+        data.Add(Volt_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman55.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman55.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman55.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman55 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman55() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman55(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman55(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.6.11 1/(4*pi*epsilon)*p_d*cos(theta)/r**2 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Volt" : "Volt_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "p_d", "theta", "r", noiseRatio == null ? "Volt" : "Volt_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "p_d", "theta", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var p_d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var Volt = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(p_d);
+      data.Add(theta);
+      data.Add(r);
+      data.Add(Volt);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = 1.0 / (4 * Math.PI * epsilon[i]) * p_d[i] * Math.Cos(theta[i]) / Math.Pow(r[i], 2);
+        Volt.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Volt_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * Volt.StandardDeviationPop();
+        Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Volt);
+        data.Add(Volt_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman56.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman56.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman56.cs	(revision 17682)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman56 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman56() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman56(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman56(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.6.15a 3/(4*pi*epsilon)*p_d*z/r**5*sqrt(x**2+y**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Ef" : "Ef_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "p_d", "r", "x", "y", "z", noiseRatio == null ? "Ef" : "Ef_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "p_d", "r", "x", "y", "z"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var p_d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var x       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var y       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var z       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var Ef = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(p_d);
+      data.Add(r);
+      data.Add(x);
+      data.Add(y);
+      data.Add(z);
+      data.Add(Ef);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = 3.0 / (4 * Math.PI * epsilon[i]) * p_d[i] * z[i] / Math.Pow(r[i], 5) *
+                  Math.Sqrt(Math.Pow(x[i], 2) + Math.Pow(y[i], 2));
+        Ef.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Ef_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * Ef.StandardDeviationPop();
+        Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Ef);
+        data.Add(Ef_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman57.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman57.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman57.cs	(revision 17682)
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman57 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman57() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman57(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman57(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "II.6.15b 3/(4*pi*epsilon)*p_d/r**3*cos(theta)*sin(theta) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Ef" : "Ef_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "p_d", "theta", "r", noiseRatio == null ? "Ef" : "Ef_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "p_d", "theta", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var p_d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var Ef = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(p_d);
+      data.Add(theta);
+      data.Add(r);
+      data.Add(Ef);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = 3.0 / (4 * Math.PI * epsilon[i]) * p_d[i] / Math.Pow(r[i], 3) * Math.Cos(theta[i]) * Math.Sin(theta[i]);
+        Ef.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Ef_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * Ef.StandardDeviationPop();
+        Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Ef);
+        data.Add(Ef_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman58.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman58.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman58.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman58 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman58() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman58(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman58(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.8.7 3/5*q**2/(4*pi*epsilon*d) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "epsilon", "d", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "epsilon", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(q);
+      data.Add(epsilon);
+      data.Add(d);
+      data.Add(E_n);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = 3.0 / 5 * Math.Pow(q[i], 2) / (4 * Math.PI * epsilon[i] * d[i]);
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman59.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman59.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman59.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman59 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman59() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman59(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman59(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.8.31 epsilon*Ef**2/2 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_den" : "E_den_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "Ef", noiseRatio == null ? "E_den" : "E_den_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "Ef"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_den = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(Ef);
+      data.Add(E_den);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = epsilon[i] * Math.Pow(Ef[i], 2) / 2;
+        E_den.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_den_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_den.StandardDeviationPop();
+        E_den_noise.AddRange(E_den.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_den);
+        data.Add(E_den_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman6.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman6.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman6.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman6 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman6() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman6(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman6(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.10.7 m_0/sqrt(1-v**2/c**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "m" : "m_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m_0", "v", "c", noiseRatio == null ? "m" : "m_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m_0", "v", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m_0  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+
+      var m = new List<double>();
+
+      data.Add(m_0);
+      data.Add(v);
+      data.Add(c);
+      data.Add(m);
+
+      for (var i = 0; i < m_0.Count; i++) {
+        var res = m_0[i] / Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2));
+        m.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var m_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * m.StandardDeviationPop();
+        m_noise.AddRange(m.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(m);
+        data.Add(m_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman60.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman60.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman60.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman60 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman60() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman60(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman60(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.10.9 sigma_den/epsilon*1/(1+chi) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Ef" : "Ef_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"sigma_den", "epsilon", "chi", noiseRatio == null ? "Ef" : "Ef_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"sigma_den", "epsilon", "chi"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data      = new List<List<double>>();
+      var sigma_den = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var chi       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Ef = new List<double>();
+
+      data.Add(sigma_den);
+      data.Add(epsilon);
+      data.Add(chi);
+      data.Add(Ef);
+
+      for (var i = 0; i < sigma_den.Count; i++) {
+        var res = sigma_den[i] / epsilon[i] * 1 / (1 + chi[i]);
+        Ef.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Ef_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * Ef.StandardDeviationPop();
+        Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Ef);
+        data.Add(Ef_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman61.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman61.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman61.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman61 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman61() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman61(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman61(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.11.3 q*Ef/(m*(omega_0**2-omega**2)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "x" : "x_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "Ef", "m", "omega_0", "omega", noiseRatio == null ? "x" : "x_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "Ef", "m", "omega_0", "omega"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 5).ToList();
+      var omega   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var x = new List<double>();
+
+      data.Add(q);
+      data.Add(Ef);
+      data.Add(m);
+      data.Add(omega_0);
+      data.Add(omega);
+      data.Add(x);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] * Ef[i] / (m[i] * (Math.Pow(omega_0[i], 2) - Math.Pow(omega[i], 2)));
+        x.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var x_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * x.StandardDeviationPop();
+        x_noise.AddRange(x.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(x);
+        data.Add(x_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman62.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman62.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman62.cs	(revision 17682)
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman62 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman62() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman62(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman62(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.11.17 n_0*(1 + p_d*Ef*cos(theta)/(kb*T)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "n" : "n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n_0", "kb", "T", "theta", "p_d", "Ef", noiseRatio == null ? "n" : "n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n_0", "kb", "T", "theta", "p_d", "Ef"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var n_0   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var T     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var p_d   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var Ef    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var n = new List<double>();
+
+      data.Add(n_0);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(theta);
+      data.Add(p_d);
+      data.Add(Ef);
+      data.Add(n);
+
+      for (var i = 0; i < n_0.Count; i++) {
+        var res = n_0[i] * (1 + p_d[i] * Ef[i] * Math.Cos(theta[i]) / (kb[i] * T[i]));
+        n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var n_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * n.StandardDeviationPop();
+        n_noise.AddRange(n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(n);
+        data.Add(n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman63.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman63.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman63.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman63 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman63() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman63(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman63(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.11.20 n_rho*p_d**2*Ef/(3*kb*T) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Pol" : "Pol_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n_rho", "p_d", "Ef", "kb", "T", noiseRatio == null ? "Pol" : "Pol_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n_rho", "p_d", "Ef", "kb", "T"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var n_rho = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var p_d   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Pol = new List<double>();
+
+      data.Add(n_rho);
+      data.Add(p_d);
+      data.Add(Ef);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(Pol);
+
+      for (var i = 0; i < n_rho.Count; i++) {
+        var res = n_rho[i] * Math.Pow(p_d[i], 2) * Ef[i] / (3 * kb[i] * T[i]);
+        Pol.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Pol_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Pol.StandardDeviationPop();
+        Pol_noise.AddRange(Pol.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Pol);
+        data.Add(Pol_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman64.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman64.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman64.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman64 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman64() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman64(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman64(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.11.27 n*alpha/(1-(n*alpha/3))*epsilon*Ef | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Pol" : "Pol_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n", "alpha", "epsilon", "Ef", noiseRatio == null ? "Pol" : "Pol_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n", "alpha", "epsilon", "Ef"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var n       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 1).ToList();
+      var alpha   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 1).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var Pol = new List<double>();
+
+      data.Add(n);
+      data.Add(alpha);
+      data.Add(epsilon);
+      data.Add(Ef);
+      data.Add(Pol);
+
+      for (var i = 0; i < n.Count; i++) {
+        var res = n[i] * alpha[i] / (1 - n[i] * alpha[i] / 3) * epsilon[i] * Ef[i];
+        Pol.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Pol_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Pol.StandardDeviationPop();
+        Pol_noise.AddRange(Pol.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Pol);
+        data.Add(Pol_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman65.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman65.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman65.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman65 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman65() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman65(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman65(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.11.28 1+n*alpha/(1-(n*alpha/3)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "theta" : "theta_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n", "alpha", noiseRatio == null ? "theta" : "theta_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n", "alpha"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var n     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 1).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 1).ToList();
+
+      var theta = new List<double>();
+
+      data.Add(n);
+      data.Add(alpha);
+      data.Add(theta);
+
+      for (var i = 0; i < n.Count; i++) {
+        var res = 1 + n[i] * alpha[i] / (1 - n[i] * alpha[i] / 3);
+        theta.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var theta_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * theta.StandardDeviationPop();
+        theta_noise.AddRange(theta.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(theta);
+        data.Add(theta_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman66.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman66.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman66.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman66 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman66() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman66(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman66(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.13.17 1/(4*pi*epsilon*c**2)*2*I/r | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "B" : "B_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "c", "I", "r", noiseRatio == null ? "B" : "B_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "c", "I", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var I       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var B = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(c);
+      data.Add(I);
+      data.Add(r);
+      data.Add(B);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = 1.0 / (4 * Math.PI * epsilon[i] * Math.Pow(c[i], 2)) * 2 * I[i] / r[i];
+        B.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var B_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * B.StandardDeviationPop();
+        B_noise.AddRange(B.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(B);
+        data.Add(B_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman67.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman67.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman67.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman67 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman67() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman67(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman67(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.13.23 rho_c_0/sqrt(1-v**2/c**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "rho_c" : "rho_c_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"rho_c_0", "v", "c", noiseRatio == null ? "rho_c" : "rho_c_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"rho_c_0", "v", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var rho_c_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+
+      var rho_c = new List<double>();
+
+      data.Add(rho_c_0);
+      data.Add(v);
+      data.Add(c);
+      data.Add(rho_c);
+
+      for (var i = 0; i < rho_c_0.Count; i++) {
+        var res = rho_c_0[i] / Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2));
+        rho_c.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var rho_c_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * rho_c.StandardDeviationPop();
+        rho_c_noise.AddRange(rho_c.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(rho_c);
+        data.Add(rho_c_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman68.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman68.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman68.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman68 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman68() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman68(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman68(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.13.34 rho_c_0*v/sqrt(1-v**2/c**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "j" : "j_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"rho_c_0", "v", "c", noiseRatio == null ? "j" : "j_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"rho_c_0", "v", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var rho_c_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+
+      var j = new List<double>();
+
+      data.Add(rho_c_0);
+      data.Add(v);
+      data.Add(c);
+      data.Add(j);
+
+      for (var i = 0; i < rho_c_0.Count; i++) {
+        var res = rho_c_0[i] * v[i] / Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2));
+        j.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var j_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * j.StandardDeviationPop();
+        j_noise.AddRange(j.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(j);
+        data.Add(j_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman69.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman69.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman69.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman69 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman69() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman69(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman69(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.15.4 -mom*B*cos(theta) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mom", "B", "theta", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mom", "B", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var mom   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(mom);
+      data.Add(B);
+      data.Add(theta);
+      data.Add(E_n);
+
+      for (var i = 0; i < mom.Count; i++) {
+        var res = -mom[i] * B[i] * Math.Cos(theta[i]);
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman7.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman7.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman7.cs	(revision 17682)
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman7 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman7() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman7(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman7(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.11.19 x1*y1+x2*y2+x3*y3 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "A" : "A_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"x1", "x2", "x3", "y1", "y2", "y3", noiseRatio == null ? "A" : "A_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"x1", "x2", "x3", "y1", "y2", "y3"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var x1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x3   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y3   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var A = new List<double>();
+
+      data.Add(x1);
+      data.Add(x2);
+      data.Add(x3);
+      data.Add(y1);
+      data.Add(y2);
+      data.Add(y3);
+      data.Add(A);
+
+      for (var i = 0; i < x1.Count; i++) {
+        var res = x1[i] * y1[i] + x2[i] * y2[i] + x3[i] * y3[i];
+        A.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var A_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * A.StandardDeviationPop();
+        A_noise.AddRange(A.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(A);
+        data.Add(A_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman70.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman70.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman70.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman70 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman70() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman70(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman70(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.15.5 -p_d*Ef*cos(theta) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"p_d", "Ef", "theta", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"p_d", "Ef", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var p_d   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(p_d);
+      data.Add(Ef);
+      data.Add(theta);
+      data.Add(E_n);
+
+      for (var i = 0; i < p_d.Count; i++) {
+        var res = -p_d[i] * Ef[i] * Math.Cos(theta[i]);
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman71.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman71.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman71.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman71 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman71() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman71(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman71(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.21.32 q/(4*pi*epsilon*r*(1-v/c)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Volt" : "Volt_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "epsilon", "r", "v", "c", noiseRatio == null ? "Volt" : "Volt_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "epsilon", "r", "v", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 3, 10).ToList();
+
+      var Volt = new List<double>();
+
+      data.Add(q);
+      data.Add(epsilon);
+      data.Add(r);
+      data.Add(v);
+      data.Add(c);
+      data.Add(Volt);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] / (4 * Math.PI * epsilon[i] * r[i] * (1 - v[i] / c[i]));
+        Volt.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Volt_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * Volt.StandardDeviationPop();
+        Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Volt);
+        data.Add(Volt_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman72.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman72.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman72.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman72 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman72() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman72(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman72(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.24.17 sqrt(omega**2/c**2-pi**2/d**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "k" : "k_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"omega", "c", "d", noiseRatio == null ? "k" : "k_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"omega", "c", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 4, 6).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2, 4).ToList();
+
+      var k = new List<double>();
+
+      data.Add(omega);
+      data.Add(c);
+      data.Add(d);
+      data.Add(k);
+
+      for (var i = 0; i < omega.Count; i++) {
+        var res = Math.Sqrt(Math.Pow(omega[i], 2) / Math.Pow(c[i], 2) - Math.Pow(Math.PI, 2) / Math.Pow(d[i], 2));
+        k.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var k_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * k.StandardDeviationPop();
+        k_noise.AddRange(k.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(k);
+        data.Add(k_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman73.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman73.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman73.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman73 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman73() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman73(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman73(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.27.16 epsilon*c*Ef**2 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "flux" : "flux_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "c", "Ef", noiseRatio == null ? "flux" : "flux_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "c", "Ef"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var flux = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(c);
+      data.Add(Ef);
+      data.Add(flux);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = epsilon[i] * c[i] * Math.Pow(Ef[i], 2);
+        flux.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var flux_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * flux.StandardDeviationPop();
+        flux_noise.AddRange(flux.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(flux);
+        data.Add(flux_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman74.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman74.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman74.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman74 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman74() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman74(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman74(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.27.18 epsilon*Ef**2 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_den" : "E_den_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"epsilon", "Ef", noiseRatio == null ? "E_den" : "E_den_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"epsilon", "Ef"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_den = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(Ef);
+      data.Add(E_den);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = epsilon[i] * Math.Pow(Ef[i], 2);
+        E_den.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_den_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_den.StandardDeviationPop();
+        E_den_noise.AddRange(E_den.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_den);
+        data.Add(E_den_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman75.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman75.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman75.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman75 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman75() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman75(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman75(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.34.2a q*v/(2*pi*r) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "I" : "I_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "v", "r", noiseRatio == null ? "I" : "I_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "v", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var I = new List<double>();
+
+      data.Add(q);
+      data.Add(v);
+      data.Add(r);
+      data.Add(I);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] * v[i] / (2 * Math.PI * r[i]);
+        I.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var I_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * I.StandardDeviationPop();
+        I_noise.AddRange(I.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(I);
+        data.Add(I_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman76.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman76.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman76.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman76 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman76() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman76(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman76(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.34.2 q*v*r/2 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "mom" : "mom_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "v", "r", noiseRatio == null ? "mom" : "mom_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "v", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var v    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var mom = new List<double>();
+
+      data.Add(q);
+      data.Add(v);
+      data.Add(r);
+      data.Add(mom);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] * v[i] * r[i] / 2;
+        mom.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var mom_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * mom.StandardDeviationPop();
+        mom_noise.AddRange(mom.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(mom);
+        data.Add(mom_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman77.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman77.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman77.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman77 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman77() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman77(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman77(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.34.11 g_*q*B/(2*m) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "omega" : "omega_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"g_", "q", "B", "m", noiseRatio == null ? "omega" : "omega_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"g_", "q", "B", "m"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var g_   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var omega = new List<double>();
+
+      data.Add(g_);
+      data.Add(q);
+      data.Add(B);
+      data.Add(m);
+      data.Add(omega);
+
+      for (var i = 0; i < g_.Count; i++) {
+        var res = g_[i] * q[i] * B[i] / (2 * m[i]);
+        omega.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var omega_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * omega.StandardDeviationPop();
+        omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(omega);
+        data.Add(omega_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman78.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman78.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman78.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman78 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman78() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman78(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman78(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.34.29a q*h/(4*pi*m) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "mom" : "mom_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "h", "m", noiseRatio == null ? "mom" : "mom_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "h", "m"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var mom = new List<double>();
+
+      data.Add(q);
+      data.Add(h);
+      data.Add(m);
+      data.Add(mom);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] * h[i] / (4 * Math.PI * m[i]);
+        mom.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var mom_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * mom.StandardDeviationPop();
+        mom_noise.AddRange(mom.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(mom);
+        data.Add(mom_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman79.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman79.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman79.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman79 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman79() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman79(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman79(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.34.29b g_*mom*B*Jz/h | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"g_", "h", "Jz", "mom", "B", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"g_", "h", "Jz", "mom", "B"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var g_   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Jz   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var mom  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(g_);
+      data.Add(h);
+      data.Add(Jz);
+      data.Add(mom);
+      data.Add(B);
+      data.Add(E_n);
+
+      for (var i = 0; i < g_.Count; i++) {
+        var res = g_[i] * mom[i] * B[i] * Jz[i] / h[i];
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman8.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman8.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman8.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman8 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman8() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman8(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman8(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.12.1 mu*Nn | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mu", "Nn", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mu", "Nn"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var mu   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Nn   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var F = new List<double>();
+
+      data.Add(mu);
+      data.Add(Nn);
+      data.Add(F);
+
+      for (var i = 0; i < mu.Count; i++) {
+        var res = mu[i] * Nn[i];
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman80.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman80.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman80.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman80 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman80() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman80(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman80(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.35.18 n_0/(exp(mom*B/(kb*T))+exp(-mom*B/(kb*T))) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "n" : "n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n_0", "kb", "T", "mom", "B", noiseRatio == null ? "n" : "n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n_0", "kb", "T", "mom", "B"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var n_0  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var kb   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var T    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var mom  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var B    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var n = new List<double>();
+
+      data.Add(n_0);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(mom);
+      data.Add(B);
+      data.Add(n);
+
+      for (var i = 0; i < n_0.Count; i++) {
+        var res = n_0[i] / (Math.Exp(mom[i] * B[i] / (kb[i] * T[i])) + Math.Exp(-mom[i] * B[i] / (kb[i] * T[i])));
+        n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var n_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * n.StandardDeviationPop();
+        n_noise.AddRange(n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(n);
+        data.Add(n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman81.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman81.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman81.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman81 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman81() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman81(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman81(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.35.21 n_rho*mom*tanh(mom*B/(kb*T)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "M" : "M_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"n_rho", "mom", "B", "kb", "T", noiseRatio == null ? "M" : "M_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"n_rho", "mom", "B", "kb", "T"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var n_rho = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var mom   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var M = new List<double>();
+
+      data.Add(n_rho);
+      data.Add(mom);
+      data.Add(B);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(M);
+
+      for (var i = 0; i < n_rho.Count; i++) {
+        var res = n_rho[i] * mom[i] * Math.Tanh(mom[i] * B[i] / (kb[i] * T[i]));
+        M.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var M_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * M.StandardDeviationPop();
+        M_noise.AddRange(M.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(M);
+        data.Add(M_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman82.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman82.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman82.cs	(revision 17682)
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman82 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman82() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman82(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman82(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "II.36.38 mom*B/(kb*T)+(mom*alpha*M)/(epsilon*c**2*kb*T) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "f" : "f_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mom", "B", "kb", "T", "alpha", "epsilon", "c", "M", noiseRatio == null ? "f" : "f_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"mom", "B", "kb", "T", "alpha", "epsilon", "c", "M"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var mom     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var B       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var kb      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var T       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var alpha   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var M       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var f = new List<double>();
+
+      data.Add(mom);
+      data.Add(B);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(alpha);
+      data.Add(epsilon);
+      data.Add(c);
+      data.Add(M);
+      data.Add(f);
+
+      for (var i = 0; i < mom.Count; i++) {
+        var res = mom[i] * B[i] / (kb[i] * T[i]) +
+                  mom[i] * alpha[i] * M[i] / (epsilon[i] * Math.Pow(c[i], 2) * kb[i] * T[i]);
+        f.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var f_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * f.StandardDeviationPop();
+        f_noise.AddRange(f.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(f);
+        data.Add(f_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman83.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman83.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman83.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman83 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman83() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman83(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman83(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.37.1 mom*(1+chi)*B | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mom", "B", "chi", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mom", "B", "chi"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var mom  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var chi  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(mom);
+      data.Add(B);
+      data.Add(chi);
+      data.Add(E_n);
+
+      for (var i = 0; i < mom.Count; i++) {
+        var res = mom[i] * (1 + chi[i]) * B[i];
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman84.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman84.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman84.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman84 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman84() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman84(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman84(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.38.3 Y*A*x/d | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"Y", "A", "d", "x", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"Y", "A", "d", "x"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var Y    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var A    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var F = new List<double>();
+
+      data.Add(Y);
+      data.Add(A);
+      data.Add(d);
+      data.Add(x);
+      data.Add(F);
+
+      for (var i = 0; i < Y.Count; i++) {
+        var res = Y[i] * A[i] * x[i] / d[i];
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman85.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman85.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman85.cs	(revision 17682)
@@ -0,0 +1,79 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman85 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman85() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman85(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman85(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("II.38.14 Y/(2*(1+sigma)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "mu_S" : "mu_S_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"Y", "sigma", noiseRatio == null ? "mu_S" : "mu_S_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"Y", "sigma"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var Y     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var sigma = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var mu_S = new List<double>();
+
+      data.Add(Y);
+      data.Add(sigma);
+      data.Add(mu_S);
+
+      for (var i = 0; i < Y.Count; i++) {
+        var res = Y[i] / (2 * (1 + sigma[i]));
+        mu_S.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var mu_S_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * mu_S.StandardDeviationPop();
+        mu_S_noise.AddRange(mu_S.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(mu_S);
+        data.Add(mu_S_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman86.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman86.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman86.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman86 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman86() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman86(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman86(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.4.32 1/(exp(h*omega/(kb*T))-1) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "n" : "n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"h", "omega", "kb", "T", noiseRatio == null ? "n" : "n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"h", "omega", "kb", "T"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var h     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var n = new List<double>();
+
+      data.Add(h);
+      data.Add(omega);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(n);
+
+      for (var i = 0; i < h.Count; i++) {
+        var res = 1.0 / (Math.Exp(h[i] * omega[i] / (kb[i] * T[i])) - 1);
+        n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var n_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * n.StandardDeviationPop();
+        n_noise.AddRange(n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(n);
+        data.Add(n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman87.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman87.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman87.cs	(revision 17682)
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman87 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman87() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman87(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman87(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "III.4.33 h*omega/(exp(h*omega/(kb*T))-1) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"h", "omega", "kb", "T", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"h", "omega", "kb", "T"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var h     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var kb    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var T     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(h);
+      data.Add(omega);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(E_n);
+
+      for (var i = 0; i < h.Count; i++) {
+        var res = h[i] * omega[i] / (Math.Exp(h[i] * omega[i] / (kb[i] * T[i])) - 1);
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman88.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman88.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman88.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman88 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman88() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman88(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman88(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.7.38 2*mom*B/h | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "omega" : "omega_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mom", "B", "h", noiseRatio == null ? "omega" : "omega_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mom", "B", "h"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var mom  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var B    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var omega = new List<double>();
+
+      data.Add(mom);
+      data.Add(B);
+      data.Add(h);
+      data.Add(omega);
+
+      for (var i = 0; i < mom.Count; i++) {
+        var res = 2 * mom[i] * B[i] / h[i];
+        omega.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var omega_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * omega.StandardDeviationPop();
+        omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(omega);
+        data.Add(omega_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman89.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman89.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman89.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman89 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman89() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman89(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman89(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.8.54 sin(E_n*t/h)**2 | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "prob" : "prob_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"E_n", "t", "h", noiseRatio == null ? "prob" : "prob_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"E_n", "t", "h"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var E_n  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var t    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 4).ToList();
+
+      var prob = new List<double>();
+
+      data.Add(E_n);
+      data.Add(t);
+      data.Add(h);
+      data.Add(prob);
+
+      for (var i = 0; i < E_n.Count; i++) {
+        var res = Math.Pow(Math.Sin(E_n[i] * t[i] / h[i]), 2);
+        prob.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var prob_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * prob.StandardDeviationPop();
+        prob_noise.AddRange(prob.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(prob);
+        data.Add(prob_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman9.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman9.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman9.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman9 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman9() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman9(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman9(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("I.12.2 q1*q2/(4*pi*epsilon*r**2) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q1", "q2", "epsilon", "r", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q1", "q2", "epsilon", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q1      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q2      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var F = new List<double>();
+
+      data.Add(q1);
+      data.Add(q2);
+      data.Add(epsilon);
+      data.Add(r);
+      data.Add(F);
+
+      for (var i = 0; i < q1.Count; i++) {
+        var res = q1[i] * q2[i] / (4 * Math.PI * epsilon[i] * Math.Pow(r[i], 2));
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman90.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman90.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman90.cs	(revision 17682)
@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman90 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman90() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman90(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman90(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "III.9.52 (p_d*Ef*t/h*sin((omega-omega_0)*t/2)**2/((omega-omega_0)*t/2)**2 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "prob" : "prob_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"p_d", "Ef", "t", "h", "omega", "omega_0", noiseRatio == null ? "prob" : "prob_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"p_d", "Ef", "t", "h", "omega", "omega_0"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var p_d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var Ef      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var t       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var h       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var omega   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var prob = new List<double>();
+
+      data.Add(p_d);
+      data.Add(Ef);
+      data.Add(t);
+      data.Add(h);
+      data.Add(omega);
+      data.Add(omega_0);
+      data.Add(prob);
+
+      for (var i = 0; i < p_d.Count; i++) {
+        var res = p_d[i] * Ef[i] * t[i] / h[i] *
+                  Math.Pow(Math.Sin((omega[i] - omega_0[i]) * t[i] / 2), 2) /
+                  Math.Pow((omega[i] - omega_0[i]) * t[i] / 2, 2);
+        prob.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var prob_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * prob.StandardDeviationPop();
+        prob_noise.AddRange(prob.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(prob);
+        data.Add(prob_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman91.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman91.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman91.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman91 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman91() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman91(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman91(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.10.19 mom*sqrt(Bx**2+By**2+Bz**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"mom", "Bx", "By", "Bz", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"mom", "Bx", "By", "Bz"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var mom  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Bx   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var By   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Bz   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(mom);
+      data.Add(Bx);
+      data.Add(By);
+      data.Add(Bz);
+      data.Add(E_n);
+
+      for (var i = 0; i < mom.Count; i++) {
+        var res = mom[i] * Math.Sqrt(Math.Pow(Bx[i], 2) + Math.Pow(By[i], 2) + Math.Pow(Bz[i], 2));
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman92.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman92.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman92.cs	(revision 17682)
@@ -0,0 +1,75 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman92 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman92() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman92(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman92(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.12.43 n*h | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "L" : "L_noise"; } }
+    protected override string[] VariableNames { get { return new[] {"n", "h", noiseRatio == null ? "L" : "L_noise"}; } }
+    protected override string[] AllowedInputVariables { get { return new[] {"n", "h"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var n    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var L = new List<double>();
+
+      data.Add(n);
+      data.Add(h);
+      data.Add(L);
+
+      for (var i = 0; i < n.Count; i++) {
+        var res = n[i] * h[i];
+        L.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var L_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * L.StandardDeviationPop();
+        L_noise.AddRange(L.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(L);
+        data.Add(L_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman93.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman93.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman93.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman93 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman93() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman93(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman93(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.13.18 2*E_n*d**2*k/h | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "v" : "v_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"E_n", "d", "k", "h", noiseRatio == null ? "v" : "v_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"E_n", "d", "k", "h"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var E_n  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var k    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var v = new List<double>();
+
+      data.Add(E_n);
+      data.Add(d);
+      data.Add(k);
+      data.Add(h);
+      data.Add(v);
+
+      for (var i = 0; i < E_n.Count; i++) {
+        var res = 2 * E_n[i] * Math.Pow(d[i], 2) * k[i] / h[i];
+        v.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var v_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * v.StandardDeviationPop();
+        v_noise.AddRange(v.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(v);
+        data.Add(v_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman94.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman94.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman94.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman94 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman94() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman94(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman94(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.14.14 I_0*(exp(q*Volt/(kb*T))-1) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "I" : "I_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"I_0", "q", "Volt", "kb", "T", noiseRatio == null ? "I" : "I_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"I_0", "q", "Volt", "kb", "T"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var I_0  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var Volt = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var kb   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var T    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var I = new List<double>();
+
+      data.Add(I_0);
+      data.Add(q);
+      data.Add(Volt);
+      data.Add(kb);
+      data.Add(T);
+      data.Add(I);
+
+      for (var i = 0; i < I_0.Count; i++) {
+        var res = I_0[i] * (Math.Exp(q[i] * Volt[i] / (kb[i] * T[i])) - 1);
+        I.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var I_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * I.StandardDeviationPop();
+        I_noise.AddRange(I.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(I);
+        data.Add(I_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman95.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman95.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman95.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman95 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman95() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman95(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman95(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.15.12 2*U*(1-cos(k*d)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"U", "k", "d", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"U", "k", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var U    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var k    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(U);
+      data.Add(k);
+      data.Add(d);
+      data.Add(E_n);
+
+      for (var i = 0; i < U.Count; i++) {
+        var res = 2 * U[i] * (1 - Math.Cos(k[i] * d[i]));
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman96.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman96.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman96.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman96 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman96() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman96(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman96(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.15.14 h**2/(2*E_n*d**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "m" : "m_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"h", "E_n", "d", noiseRatio == null ? "m" : "m_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"h", "E_n", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var h    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var E_n  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var m = new List<double>();
+
+      data.Add(h);
+      data.Add(E_n);
+      data.Add(d);
+      data.Add(m);
+
+      for (var i = 0; i < h.Count; i++) {
+        var res = Math.Pow(h[i], 2) / (2 * E_n[i] * Math.Pow(d[i], 2));
+        m.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var m_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * m.StandardDeviationPop();
+        m_noise.AddRange(m.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(m);
+        data.Add(m_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman97.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman97.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman97.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman97 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman97() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman97(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman97(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.15.27 2*pi*alpha/(n*d) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "k" : "k_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"alpha", "n", "d", noiseRatio == null ? "k" : "k_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"alpha", "n", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var n     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var k = new List<double>();
+
+      data.Add(alpha);
+      data.Add(n);
+      data.Add(d);
+      data.Add(k);
+
+      for (var i = 0; i < alpha.Count; i++) {
+        var res = 2 * Math.PI * alpha[i] / (n[i] * d[i]);
+        k.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var k_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * k.StandardDeviationPop();
+        k_noise.AddRange(k.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(k);
+        data.Add(k_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman98.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman98.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman98.cs	(revision 17682)
@@ -0,0 +1,81 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman98 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman98() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman98(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman98(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("III.17.37 beta*(1+alpha*cos(theta)) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "f" : "f_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"beta", "alpha", "theta", noiseRatio == null ? "f" : "f_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"beta", "alpha", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var beta  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var f = new List<double>();
+
+      data.Add(beta);
+      data.Add(alpha);
+      data.Add(theta);
+      data.Add(f);
+
+      for (var i = 0; i < beta.Count; i++) {
+        var res = beta[i] * (1 + alpha[i] * Math.Cos(theta[i]));
+        f.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var f_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * f.StandardDeviationPop();
+        f_noise.AddRange(f.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(f);
+        data.Add(f_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman99.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman99.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman99.cs	(revision 17682)
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class Feynman99 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public Feynman99() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public Feynman99(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public Feynman99(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "III.19.51 -m*q**4/(2*(4*pi*epsilon)**2*h**2)*(1/n**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "q", "h", "n", "epsilon", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "q", "h", "n", "epsilon"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var n       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(m);
+      data.Add(q);
+      data.Add(h);
+      data.Add(n);
+      data.Add(epsilon);
+      data.Add(E_n);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = -m[i] * Math.Pow(q[i], 4) / (2 * Math.Pow(4 * Math.PI * epsilon[i], 2) *
+                                               Math.Pow(h[i], 2) * (1.0 / Math.Pow(n[i], 2)));
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus1.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus1.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus1.cs	(revision 17682)
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus1 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus1() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus1(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus1(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Rutherford scattering: (Z_1*Z_2*alpha*hbar*c/(4*E_n*sin(theta/2)**2))**2 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "A" : "A_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"Z_1", "Z_2", "alpha", "hbar", "c", "E_n", "theta", noiseRatio == null ? "A" : "A_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"Z_1", "Z_2", "alpha", "hbar", "c", "E_n", "theta"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var Z_1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var Z_2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var hbar  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var E_n   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var A = new List<double>();
+
+      data.Add(Z_1);
+      data.Add(Z_2);
+      data.Add(alpha);
+      data.Add(hbar);
+      data.Add(c);
+      data.Add(E_n);
+      data.Add(theta);
+      data.Add(A);
+
+      for (var i = 0; i < Z_1.Count; i++) {
+        var res = Math.Pow(
+          Z_1[i] * Z_2[i] * alpha[i] * hbar[i] * c[i] / (4 * E_n[i] * Math.Pow(Math.Sin(theta[i] / 2), 2)), 2);
+        A.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var A_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * A.StandardDeviationPop();
+        A_noise.AddRange(A.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(A);
+        data.Add(A_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus10.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus10.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus10.cs	(revision 17682)
@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus10 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus10() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus10(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus10(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("Goldstein 3.74: 2*pi*d**(3/2)/sqrt(G*(m1+m2)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "t" : "t_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"d", "G", "m1", "m2", noiseRatio == null ? "t" : "t_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"d", "G", "m1", "m2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var d    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var G    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var m1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var m2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var t = new List<double>();
+
+      data.Add(d);
+      data.Add(G);
+      data.Add(m1);
+      data.Add(m2);
+      data.Add(t);
+
+      for (var i = 0; i < d.Count; i++) {
+        var res = 2 * Math.PI * Math.Pow(d[i], 3.0 / 2) / Math.Sqrt(G[i] * (m1[i] + m2[i]));
+        t.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var t_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * t.StandardDeviationPop();
+        t_noise.AddRange(t.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(t);
+        data.Add(t_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus11.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus11.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus11.cs	(revision 17682)
@@ -0,0 +1,95 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus11 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus11() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus11(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus11(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Goldstein 3.99: sqrt(1+2*epsilon**2*E_n*L**2/(m*(Z_1*Z_2*q**2)**2)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "alpha" : "alpha_noise"; } }
+
+    protected override string[] VariableNames {
+      get {
+        return new[] {"epsilon", "L", "m", "Z_1", "Z_2", "q", "E_n", noiseRatio == null ? "alpha" : "alpha_noise"};
+      }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"epsilon", "L", "m", "Z_1", "Z_2", "q", "E_n"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var L       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var Z_1     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var Z_2     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var E_n     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var alpha = new List<double>();
+
+      data.Add(epsilon);
+      data.Add(L);
+      data.Add(m);
+      data.Add(Z_1);
+      data.Add(Z_2);
+      data.Add(q);
+      data.Add(E_n);
+      data.Add(alpha);
+
+      for (var i = 0; i < epsilon.Count; i++) {
+        var res = Math.Sqrt(1 + 2 * Math.Pow(epsilon[i], 2) * E_n[i] * Math.Pow(L[i], 2) /
+                            (m[i] * Math.Pow(Z_1[i] * Z_2[i] * Math.Pow(q[i], 2), 2)));
+        alpha.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var alpha_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * alpha.StandardDeviationPop();
+        alpha_noise.AddRange(alpha.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(alpha);
+        data.Add(alpha_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus12.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus12.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus12.cs	(revision 17682)
@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus12 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus12() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus12(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus12(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Goldstein 8.56: sqrt((p-q*A_vec)**2*c**2+m**2*c**4)+q*Volt | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "c", "p", "q", "A_vec", "Volt", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "c", "p", "q", "A_vec", "Volt"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var m     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var p     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var q     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var A_vec = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var Volt  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(m);
+      data.Add(c);
+      data.Add(p);
+      data.Add(q);
+      data.Add(A_vec);
+      data.Add(Volt);
+      data.Add(E_n);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = Math.Sqrt(Math.Pow(p[i] - q[i] * A_vec[i], 2) * Math.Pow(c[i], 2) +
+                            Math.Pow(m[i], 2) * Math.Pow(c[i], 4)) + q[i] * Volt[i];
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus13.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus13.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus13.cs	(revision 17682)
@@ -0,0 +1,90 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus13 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus13() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus13(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus13(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Goldstein 12.80: 1/(2*m)*(p**2+m**2*omega**2*x**2*(1+alpha*x/y)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "E_n" : "E_n_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "omega", "p", "y", "x", "alpha", noiseRatio == null ? "E_n" : "E_n_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "omega", "p", "y", "x", "alpha"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var m     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var p     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var x     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var E_n = new List<double>();
+
+      data.Add(m);
+      data.Add(omega);
+      data.Add(p);
+      data.Add(y);
+      data.Add(x);
+      data.Add(alpha);
+      data.Add(E_n);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = 1.0 / (2 * m[i]) * (Math.Pow(p[i], 2) +
+                                      Math.Pow(m[i], 2) * Math.Pow(omega[i], 2) * Math.Pow(x[i], 2) *
+                                      (1 + alpha[i] * x[i] / y[i]));
+        E_n.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var E_n_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * E_n.StandardDeviationPop();
+        E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(E_n);
+        data.Add(E_n_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus14.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus14.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus14.cs	(revision 17682)
@@ -0,0 +1,88 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus14 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus14() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus14(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus14(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Jackson 2.11: q/(4*pi*epsilon*y**2)*(4*pi*epsilon*Volt*d-q*d*y**3/(y**2-d**2)**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "F" : "F_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "y", "Volt", "d", "epsilon", noiseRatio == null ? "F" : "F_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "y", "Volt", "d", "epsilon"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var y       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var Volt    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 4, 6).ToList();
+      var epsilon = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var F = new List<double>();
+
+      data.Add(q);
+      data.Add(y);
+      data.Add(Volt);
+      data.Add(d);
+      data.Add(epsilon);
+      data.Add(F);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] / (4 * Math.PI * epsilon[i] * Math.Pow(y[i], 2)) * (
+                    4 * Math.PI * epsilon[i] * Volt[i] * d[i] - q[i] * d[i] * Math.Pow(y[i], 3) /
+                    Math.Pow(Math.Pow(y[i], 2) - Math.Pow(d[i], 2), 2));
+        F.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var F_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * F.StandardDeviationPop();
+        F_noise.AddRange(F.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(F);
+        data.Add(F_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus15.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus15.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus15.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus15 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus15() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus15(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus15(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Jackson 3.45: q/sqrt(r**2+d**2-2*r*d*cos(alpha)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Volt" : "Volt_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"q", "r", "d", "alpha", noiseRatio == null ? "Volt" : "Volt_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"q", "r", "d", "alpha"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var q       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var d       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 4, 6).ToList();
+      var alpha   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 6).ToList();
+
+      var Volt = new List<double>();
+
+      data.Add(q);
+      data.Add(r);
+      data.Add(d);
+      data.Add(alpha);
+      data.Add(Volt);
+
+      for (var i = 0; i < q.Count; i++) {
+        var res = q[i] /
+                  Math.Sqrt(Math.Pow(r[i], 2) + Math.Pow(d[i], 2) - 2 * r[i] * d[i] * Math.Cos(alpha[i]));
+        Volt.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Volt_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * Volt.StandardDeviationPop();
+        Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Volt);
+        data.Add(Volt_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus16.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus16.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus16.cs	(revision 17682)
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus16 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus16() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus16(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus16(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Jackson 4.60: Ef*cos(theta)*((alpha-1)/(alpha+2)*d**3/r**2-r) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Volt" : "Volt_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"Ef", "theta", "r", "d", "alpha", noiseRatio == null ? "Volt" : "Volt_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"Ef", "theta", "r", "d", "alpha"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var Ef    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 6).ToList();
+      var r     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var Volt = new List<double>();
+
+      data.Add(Ef);
+      data.Add(theta);
+      data.Add(r);
+      data.Add(d);
+      data.Add(alpha);
+      data.Add(Volt);
+
+      for (var i = 0; i < Ef.Count; i++) {
+        var res = Ef[i] * Math.Cos(theta[i]) *
+                  ((alpha[i] - 1) / (alpha[i] + 2) * Math.Pow(d[i], 3) / Math.Pow(r[i], 2) - r[i] );
+        Volt.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Volt_noise  = new List<double>();
+        var sigma_noise = (double) noiseRatio * Volt.StandardDeviationPop();
+        Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Volt);
+        data.Add(Volt_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus17.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus17.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus17.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus17 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus17() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus17(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus17(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Jackson 11.38: sqrt(1-v**2/c**2)*omega/(1+v/c*cos(theta)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "omega_0" : "omega_0_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"c", "v", "omega", "theta", noiseRatio == null ? "omega_0" : "omega_0_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"c", "v", "omega", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 5, 20).ToList();
+      var v     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var omega = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 6).ToList();
+
+      var omega_0 = new List<double>();
+
+      data.Add(c);
+      data.Add(v);
+      data.Add(omega);
+      data.Add(theta);
+      data.Add(omega_0);
+
+      for (var i = 0; i < c.Count; i++) {
+        var res = Math.Sqrt(1 - Math.Pow(v[i], 2) / Math.Pow(c[i], 2)) * omega[i] /
+                  (1 + v[i] / c[i] * Math.Cos(theta[i]));
+        omega_0.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var omega_0_noise = new List<double>();
+        var sigma_noise   = (double) noiseRatio * omega_0.StandardDeviationPop();
+        omega_0_noise.AddRange(omega_0.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(omega_0);
+        data.Add(omega_0_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus18.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus18.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus18.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus18 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus18() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus18(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus18(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("Weinberg 15.2.1: 3/(8*pi*G)*(c**2*k_f/r**2+H_G**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "rho_0" : "rho_0_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"G", "k_f", "r", "H_G", "c", noiseRatio == null ? "rho_0" : "rho_0_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"G", "k_f", "r", "H_G", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var G    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var k_f  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var H_G  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var rho_0 = new List<double>();
+
+      data.Add(G);
+      data.Add(k_f);
+      data.Add(r);
+      data.Add(H_G);
+      data.Add(c);
+      data.Add(rho_0);
+
+      for (var i = 0; i < G.Count; i++) {
+        var res = 3.0 / (8 * Math.PI * G[i]) * (Math.Pow(c[i], 2) * k_f[i] / Math.Pow(r[i], 2) + Math.Pow(H_G[i], 2));
+        rho_0.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var rho_0_noise = new List<double>();
+        var sigma_noise = (double) noiseRatio * rho_0.StandardDeviationPop();
+        rho_0_noise.AddRange(rho_0.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(rho_0);
+        data.Add(rho_0_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus19.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus19.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus19.cs	(revision 17682)
@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus19 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus19() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus19(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus19(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Weinberg 15.2.2: -1/(8*pi*G)*(c**4*k_f/r**2 + c**2*H_G**2*(1-2*alpha)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "pr" : "pr_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"G", "k_f", "r", "H_G", "alpha", "c", noiseRatio == null ? "pr" : "pr_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"G", "k_f", "r", "H_G", "alpha", "c"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var G     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var k_f   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var H_G   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+
+      var pr = new List<double>();
+
+      data.Add(G);
+      data.Add(k_f);
+      data.Add(r);
+      data.Add(H_G);
+      data.Add(alpha);
+      data.Add(c);
+      data.Add(pr);
+
+      for (var i = 0; i < G.Count; i++) {
+        var res = -1.0 / (8 * Math.PI * G[i]) * (Math.Pow(c[i], 4) * k_f[i] / Math.Pow(r[i], 2) +
+                                                 Math.Pow(c[i], 2) * Math.Pow(H_G[i], 2) * (1 - 2 * alpha[i]));
+        pr.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var pr_noise    = new List<double>();
+        var sigma_noise = (double) noiseRatio * pr.StandardDeviationPop();
+        pr_noise.AddRange(pr.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(pr);
+        data.Add(pr_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus2.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus2.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus2.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus2 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus2() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus2(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus2(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("Friedman Equation: sqrt(8*pi*G*rho/3-alpha*c**2/d**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "H_G" : "H_G_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"G", "rho", "alpha", "c", "d", noiseRatio == null ? "H_G" : "H_G_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"G", "rho", "alpha", "c", "d"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var G     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var rho   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var d     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var H_G = new List<double>();
+
+      data.Add(G);
+      data.Add(rho);
+      data.Add(alpha);
+      data.Add(c);
+      data.Add(d);
+      data.Add(H_G);
+
+      for (var i = 0; i < G.Count; i++) {
+        var res = Math.Sqrt(8 * Math.PI * G[i] * rho[i] / 3 - alpha[i] * Math.Pow(c[i], 2) / Math.Pow(d[i], 2));
+        H_G.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var H_G_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * H_G.StandardDeviationPop();
+        H_G_noise.AddRange(H_G.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(H_G);
+        data.Add(H_G_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus20.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus20.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus20.cs	(revision 17682)
@@ -0,0 +1,94 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus20 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus20() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus20(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus20(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Schwarz 13.132 (Klein-Nishina): pi*alpha**2*h**2/(m**2*c**2)*(omega_0/omega)**2*(omega_0/omega+omega/omega_0-sin(beta)**2) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "A" : "A_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"omega", "omega_0", "alpha", "h", "m", "c", "beta", noiseRatio == null ? "A" : "A_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"omega", "omega_0", "alpha", "h", "m", "c", "beta"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data    = new List<List<double>>();
+      var omega   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var omega_0 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var alpha   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var h       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var c       = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var beta    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 6).ToList();
+
+      var A = new List<double>();
+
+      data.Add(omega);
+      data.Add(omega_0);
+      data.Add(alpha);
+      data.Add(h);
+      data.Add(m);
+      data.Add(c);
+      data.Add(beta);
+      data.Add(A);
+
+      for (var i = 0; i < omega.Count; i++) {
+        var res = Math.PI * Math.Pow(alpha[i], 2) * Math.Pow(h[i], 2) /
+                  (Math.Pow(m[i], 2) * Math.Pow(c[i], 2)) * Math.Pow(omega_0[i] / omega[i], 2) *
+                  (omega_0[i] / omega[i] + omega[i] / omega_0[i] - Math.Pow(Math.Sin(beta[i]), 2));
+        A.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var A_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * A.StandardDeviationPop();
+        A_noise.AddRange(A.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(A);
+        data.Add(A_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus3.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus3.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus3.cs	(revision 17682)
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus3 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus3() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus3(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus3(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Compton Scattering: E_n/(1+E_n/(m*c**2)*(1-cos(theta))) | {0} samples | {1}", trainingSamples,
+          noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "K" : "K_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"E_n", "m", "c", "theta", noiseRatio == null ? "K" : "K_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"E_n", "m", "c", "theta"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var E_n   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var m     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var c     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var K = new List<double>();
+
+      data.Add(E_n);
+      data.Add(m);
+      data.Add(c);
+      data.Add(theta);
+      data.Add(K);
+
+      for (var i = 0; i < E_n.Count; i++) {
+        var res = E_n[i] / (1 + E_n[i] / (m[i] * Math.Pow(c[i], 2)) * (1 - Math.Cos(theta[i])));
+        K.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var K_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * K.StandardDeviationPop();
+        K_noise.AddRange(K.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(K);
+        data.Add(K_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus4.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus4.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus4.cs	(revision 17682)
@@ -0,0 +1,87 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus4 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus4() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus4(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus4(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Radiated gravitational wave power: -32/5*G**4/c**5*(m1*m2)**2*(m1+m2)/r**5 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "Pwr" : "Pwr_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"G", "c", "m1", "m2", "r", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"G", "c", "m1", "m2", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var G    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var c    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+      var m1   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var m2   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 5).ToList();
+      var r    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var Pwr = new List<double>();
+
+      data.Add(G);
+      data.Add(c);
+      data.Add(m1);
+      data.Add(m2);
+      data.Add(r);
+      data.Add(Pwr);
+
+      for (var i = 0; i < G.Count; i++) {
+        var res = -32.0 / 5 * Math.Pow(G[i], 4) / Math.Pow(c[i], 5) * Math.Pow(m1[i] * m2[i], 2) * (m1[i] + m2[i]) /
+                  Math.Pow(r[i], 5);
+        Pwr.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var Pwr_noise   = new List<double>();
+        var sigma_noise = (double) noiseRatio * Pwr.StandardDeviationPop();
+        Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(Pwr);
+        data.Add(Pwr_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus5.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus5.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus5.cs	(revision 17682)
@@ -0,0 +1,82 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus5 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus5() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus5(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus5(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Relativistic aberation: arccos((cos(theta2)-v/c)/(1-v/c*cos(theta2))) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "theta1" : "theta1_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"c", "v", "theta2", noiseRatio == null ? "theta1" : "theta1_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"c", "v", "theta2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data   = new List<List<double>>();
+      var c      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 4, 6).ToList();
+      var v      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta2 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var theta1 = new List<double>();
+
+      data.Add(c);
+      data.Add(v);
+      data.Add(theta2);
+      data.Add(theta1);
+
+      for (var i = 0; i < c.Count; i++) {
+        var res = Math.Acos((Math.Cos(theta2[i]) - v[i] / c[i]) / (1 - v[i] / c[i] * Math.Cos(theta2[i])));
+        theta1.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var theta1_noise = new List<double>();
+        var sigma_noise  = (double) noiseRatio * theta1.StandardDeviationPop();
+        theta1_noise.AddRange(theta1.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(theta1);
+        data.Add(theta1_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus6.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus6.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus6.cs	(revision 17682)
@@ -0,0 +1,86 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus6 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus6() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus6(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus6(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "N-slit diffraction: I_0*(sin(alpha/2)*sin(n*delta/2)/(alpha/2*sin(delta/2)))**2 | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "I" : "I_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"I_0", "alpha", "delta", "n", noiseRatio == null ? "I" : "I_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"I_0", "alpha", "delta", "n"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data  = new List<List<double>>();
+      var I_0   = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var alpha = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var delta = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var n     = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 2).ToList();
+
+      var I = new List<double>();
+
+      data.Add(I_0);
+      data.Add(alpha);
+      data.Add(delta);
+      data.Add(n);
+      data.Add(I);
+
+      for (var i = 0; i < I_0.Count; i++) {
+        var res = I_0[i] * Math.Pow(
+                    Math.Sin(alpha[i] / 2) * Math.Sin(n[i] * delta[i] / 2) / (alpha[i] / 2 * Math.Sin(delta[i] / 2)),
+                    2);
+        I.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var I_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * I.StandardDeviationPop();
+        I_noise.AddRange(I.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(I);
+        data.Add(I_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus7.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus7.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus7.cs	(revision 17682)
@@ -0,0 +1,85 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus7 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus7() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus7(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus7(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format("Goldstein 3.16: sqrt(2/m*(E_n-U-L**2/(2*m*r**2))) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "v" : "v_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "E_n", "U", "L", "r", noiseRatio == null ? "v" : "v_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"m", "E_n", "U", "L", "r"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data = new List<List<double>>();
+      var m    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var E_n  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 8, 12).ToList();
+      var U    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var L    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var r    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+
+      var v = new List<double>();
+
+      data.Add(m);
+      data.Add(E_n);
+      data.Add(U);
+      data.Add(L);
+      data.Add(r);
+      data.Add(v);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = Math.Sqrt(2 / m[i] * (E_n[i] - U[i] - Math.Pow(L[i], 2) / (2 * m[i] * Math.Pow(r[i], 2))));
+        v.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var v_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * v.StandardDeviationPop();
+        v_noise.AddRange(v.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(v);
+        data.Add(v_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus8.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus8.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus8.cs	(revision 17682)
@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus8 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus8() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus8(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus8(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Goldstein 3.55: m*k_G/L**2*(1+sqrt(1+2*E_n*L**2/(m*k_G**2))*cos(theta1-theta2)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "k" : "k_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"m", "k_G", "L", "E_n", "theta1", "theta2", noiseRatio == null ? "k" : "k_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables {
+      get { return new[] {"m", "k_G", "L", "E_n", "theta1", "theta2"}; }
+    }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data   = new List<List<double>>();
+      var m      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var k_G    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var L      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var E_n    = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var theta1 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 6).ToList();
+      var theta2 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 0, 6).ToList();
+
+      var k = new List<double>();
+
+      data.Add(m);
+      data.Add(k_G);
+      data.Add(L);
+      data.Add(E_n);
+      data.Add(theta1);
+      data.Add(theta2);
+      data.Add(k);
+
+      for (var i = 0; i < m.Count; i++) {
+        var res = m[i] * k_G[i] / Math.Pow(L[i], 2) *
+                  (1 + Math.Sqrt(1 + 2 * E_n[i] * Math.Pow(L[i], 2) / (m[i] * Math.Pow(k_G[i], 2))) *
+                   Math.Cos(theta1[i] - theta2[i]));
+        k.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var k_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * k.StandardDeviationPop();
+        k_noise.AddRange(k.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(k);
+        data.Add(k_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus9.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus9.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus9.cs	(revision 17682)
@@ -0,0 +1,84 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanBonus9 : FeynmanDescriptor {
+    private readonly int testSamples;
+    private readonly int trainingSamples;
+
+    public FeynmanBonus9() : this((int) DateTime.Now.Ticks, 10000, 10000, null) { }
+
+    public FeynmanBonus9(int seed) {
+      Seed            = seed;
+      trainingSamples = 10000;
+      testSamples     = 10000;
+      noiseRatio      = null;
+    }
+
+    public FeynmanBonus9(int seed, int trainingSamples, int testSamples, double? noiseRatio) {
+      Seed                 = seed;
+      this.trainingSamples = trainingSamples;
+      this.testSamples     = testSamples;
+      this.noiseRatio      = noiseRatio;
+    }
+
+    public override string Name {
+      get {
+        return string.Format(
+          "Goldstein 3.64: d*(1-alpha**2)/(1+alpha*cos(theta1-theta2)) | {0} samples | {1}",
+          trainingSamples, noiseRatio == null ? "no noise" : string.Format(System.Globalization.CultureInfo.InvariantCulture, "noise={0:g}",noiseRatio));
+      }
+    }
+
+    protected override string TargetVariable { get { return noiseRatio == null ? "r" : "r_noise"; } }
+
+    protected override string[] VariableNames {
+      get { return new[] {"d", "alpha", "theta1", "theta2", noiseRatio == null ? "r" : "r_noise"}; }
+    }
+
+    protected override string[] AllowedInputVariables { get { return new[] {"d", "alpha", "theta1", "theta2"}; } }
+
+    public int Seed { get; private set; }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return trainingSamples; } }
+    protected override int TestPartitionStart { get { return trainingSamples; } }
+    protected override int TestPartitionEnd { get { return trainingSamples + testSamples; } }
+
+    protected override List<List<double>> GenerateValues() {
+      var rand = new MersenneTwister((uint) Seed);
+
+      var data   = new List<List<double>>();
+      var d      = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 1, 3).ToList();
+      var alpha  = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 2, 4).ToList();
+      var theta1 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 4, 5).ToList();
+      var theta2 = ValueGenerator.GenerateUniformDistributedValues(rand.Next(), TestPartitionEnd, 4, 5).ToList();
+
+      var r = new List<double>();
+
+      data.Add(d);
+      data.Add(alpha);
+      data.Add(theta1);
+      data.Add(theta2);
+      data.Add(r);
+
+      for (var i = 0; i < d.Count; i++) {
+        var res = d[i] * (1 - Math.Pow(alpha[i], 2)) / (1 + alpha[i] * Math.Cos(theta1[i] - theta2[i]));
+        r.Add(res);
+      }
+
+      if (noiseRatio != null) {
+        var r_noise     = new List<double>();
+        var sigma_noise = (double) noiseRatio * r.StandardDeviationPop();
+        r_noise.AddRange(r.Select(md => md + NormalDistributedRandom.NextDouble(rand, 0, sigma_noise)));
+        data.Remove(r);
+        data.Add(r_noise);
+      }
+
+      return data;
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanDescriptor.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanDescriptor.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanDescriptor.cs	(revision 17682)
@@ -0,0 +1,21 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public abstract class FeynmanDescriptor : ArtificialRegressionDataDescriptor {
+    protected double? noiseRatio;
+    public override string Description {
+      get {
+        return "Feynman instances ... descriptions follows: " + Environment.NewLine;
+      }
+    }
+
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TestPartitionStart { get { return 100; } }
+    protected override int TestPartitionEnd { get { return 200; } }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanLargeInstanceProvider.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanLargeInstanceProvider.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanLargeInstanceProvider.cs	(revision 17682)
@@ -0,0 +1,173 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanLargeInstanceProvider : ArtificialRegressionInstanceProvider {
+    public override string Name {
+      get { return "'AI Feynman' Benchmark Problems (large)"; }
+    }
+
+    public override string Description {
+      get { return "Problem instances from \"AI Feynman\" paper (Feynman Symbolic Regression Database)"; }
+    }
+
+    public override Uri WebLink {
+      get { return new Uri("https://space.mit.edu/home/tegmark/aifeynman.html"); }
+    }
+
+    public override string ReferencePublication {
+      get { return "Udrescu, Silviu-Marian, and Max Tegmark. \"AI Feynman: A physics-inspired method for symbolic regression.\" Science Advances 6.16 (2020): eaay2631."; }
+    }
+
+    public int Seed { get; private set; }
+
+    public FeynmanLargeInstanceProvider() : this((int)DateTime.Now.Ticks) { }
+
+    public FeynmanLargeInstanceProvider(int seed) {
+      Seed = seed;
+    }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      var descriptorList = new List<IDataDescriptor>();
+      var rand = new MersenneTwister((uint)Seed);
+
+
+      var noiseRatio = new double?[] { null, 1, 10E-2, 10E-4 };
+
+      #region types
+      var descriptorTypes = new Type[] {
+        typeof(Feynman1),
+        typeof(Feynman2),
+        typeof(Feynman3),
+        typeof(Feynman4),
+        typeof(Feynman5),
+        typeof(Feynman6),
+        typeof(Feynman7),
+        typeof(Feynman8),
+        typeof(Feynman9),
+        typeof(Feynman10),
+        typeof(Feynman11),
+        typeof(Feynman12),
+        typeof(Feynman13),
+        typeof(Feynman14),
+        typeof(Feynman15),
+        typeof(Feynman16),
+        typeof(Feynman17),
+        typeof(Feynman18),
+        typeof(Feynman19),
+        typeof(Feynman20),
+        typeof(Feynman21),
+        typeof(Feynman22),
+        typeof(Feynman23),
+        typeof(Feynman24),
+        typeof(Feynman25),
+        typeof(Feynman26),
+        typeof(Feynman27),
+        typeof(Feynman28),
+        typeof(Feynman29),
+        typeof(Feynman30),
+        typeof(Feynman31),
+        typeof(Feynman32),
+        typeof(Feynman33),
+        typeof(Feynman34),
+        typeof(Feynman35),
+        typeof(Feynman36),
+        typeof(Feynman37),
+        typeof(Feynman38),
+        typeof(Feynman39),
+        typeof(Feynman40),
+        typeof(Feynman41),
+        typeof(Feynman42),
+        typeof(Feynman43),
+        typeof(Feynman44),
+        typeof(Feynman45),
+        typeof(Feynman46),
+        typeof(Feynman47),
+        typeof(Feynman48),
+        typeof(Feynman49),
+        typeof(Feynman50),
+        typeof(Feynman51),
+        typeof(Feynman52),
+        typeof(Feynman53),
+        typeof(Feynman54),
+        typeof(Feynman55),
+        typeof(Feynman56),
+        typeof(Feynman57),
+        typeof(Feynman58),
+        typeof(Feynman59),
+        typeof(Feynman60),
+        typeof(Feynman61),
+        typeof(Feynman62),
+        typeof(Feynman63),
+        typeof(Feynman64),
+        typeof(Feynman65),
+        typeof(Feynman66),
+        typeof(Feynman67),
+        typeof(Feynman68),
+        typeof(Feynman69),
+        typeof(Feynman70),
+        typeof(Feynman71),
+        typeof(Feynman72),
+        typeof(Feynman73),
+        typeof(Feynman74),
+        typeof(Feynman75),
+        typeof(Feynman76),
+        typeof(Feynman77),
+        typeof(Feynman78),
+        typeof(Feynman79),
+        typeof(Feynman80),
+        typeof(Feynman81),
+        typeof(Feynman82),
+        typeof(Feynman83),
+        typeof(Feynman84),
+        typeof(Feynman85),
+        typeof(Feynman86),
+        typeof(Feynman87),
+        typeof(Feynman88),
+        typeof(Feynman89),
+        typeof(Feynman90),
+        typeof(Feynman91),
+        typeof(Feynman92),
+        typeof(Feynman93),
+        typeof(Feynman94),
+        typeof(Feynman95),
+        typeof(Feynman96),
+        typeof(Feynman97),
+        typeof(Feynman98),
+        typeof(Feynman99),
+        typeof(Feynman100),
+        typeof(FeynmanBonus1),
+        typeof(FeynmanBonus2),
+        typeof(FeynmanBonus3),
+        typeof(FeynmanBonus4),
+        typeof(FeynmanBonus5),
+        typeof(FeynmanBonus6),
+        typeof(FeynmanBonus7),
+        typeof(FeynmanBonus8),
+        typeof(FeynmanBonus9),
+        typeof(FeynmanBonus10),
+        typeof(FeynmanBonus11),
+        typeof(FeynmanBonus12),
+        typeof(FeynmanBonus13),
+        typeof(FeynmanBonus14),
+        typeof(FeynmanBonus15),
+        typeof(FeynmanBonus16),
+        typeof(FeynmanBonus17),
+        typeof(FeynmanBonus18),
+        typeof(FeynmanBonus19),
+        typeof(FeynmanBonus20)
+   };
+      #endregion
+
+
+      foreach (var n in noiseRatio) {
+        foreach (var type in descriptorTypes) {
+          descriptorList.Add((IDataDescriptor)Activator.CreateInstance(type, rand.Next(), 10000, 10000, n));
+        }
+      }
+      return descriptorList.ToList();
+    }
+  }
+}
Index: /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanSmallInstanceProvider.cs
===================================================================
--- /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanSmallInstanceProvider.cs	(revision 17682)
+++ /trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanSmallInstanceProvider.cs	(revision 17682)
@@ -0,0 +1,173 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Random;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class FeynmanSmallInstanceProvider : ArtificialRegressionInstanceProvider {
+    public override string Name {
+      get { return "'AI Feynman' Benchmark Problems (small)"; }
+    }
+
+    public override string Description {
+      get { return "Problem instances from \"AI Feynman\" paper (Feynman Symbolic Regression Database)"; }
+    }
+
+    public override Uri WebLink {
+      get { return new Uri("https://space.mit.edu/home/tegmark/aifeynman.html"); }
+    }
+
+    public override string ReferencePublication {
+      get { return "Udrescu, Silviu-Marian, and Max Tegmark. \"AI Feynman: A physics-inspired method for symbolic regression.\" Science Advances 6.16 (2020): eaay2631."; }
+    }
+
+    public int Seed { get; private set; }
+
+    public FeynmanSmallInstanceProvider() : this((int)DateTime.Now.Ticks) { }
+
+    public FeynmanSmallInstanceProvider(int seed) {
+      Seed = seed;
+    }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      var descriptorList = new List<IDataDescriptor>();
+      var rand = new MersenneTwister((uint)Seed);
+
+
+      var noiseRatio = new double?[] { null, 1, 10E-2, 10E-4 };
+
+      #region types
+      var descriptorTypes = new Type[] {
+        typeof(Feynman1),
+        typeof(Feynman2),
+        typeof(Feynman3),
+        typeof(Feynman4),
+        typeof(Feynman5),
+        typeof(Feynman6),
+        typeof(Feynman7),
+        typeof(Feynman8),
+        typeof(Feynman9),
+        typeof(Feynman10),
+        typeof(Feynman11),
+        typeof(Feynman12),
+        typeof(Feynman13),
+        typeof(Feynman14),
+        typeof(Feynman15),
+        typeof(Feynman16),
+        typeof(Feynman17),
+        typeof(Feynman18),
+        typeof(Feynman19),
+        typeof(Feynman20),
+        typeof(Feynman21),
+        typeof(Feynman22),
+        typeof(Feynman23),
+        typeof(Feynman24),
+        typeof(Feynman25),
+        typeof(Feynman26),
+        typeof(Feynman27),
+        typeof(Feynman28),
+        typeof(Feynman29),
+        typeof(Feynman30),
+        typeof(Feynman31),
+        typeof(Feynman32),
+        typeof(Feynman33),
+        typeof(Feynman34),
+        typeof(Feynman35),
+        typeof(Feynman36),
+        typeof(Feynman37),
+        typeof(Feynman38),
+        typeof(Feynman39),
+        typeof(Feynman40),
+        typeof(Feynman41),
+        typeof(Feynman42),
+        typeof(Feynman43),
+        typeof(Feynman44),
+        typeof(Feynman45),
+        typeof(Feynman46),
+        typeof(Feynman47),
+        typeof(Feynman48),
+        typeof(Feynman49),
+        typeof(Feynman50),
+        typeof(Feynman51),
+        typeof(Feynman52),
+        typeof(Feynman53),
+        typeof(Feynman54),
+        typeof(Feynman55),
+        typeof(Feynman56),
+        typeof(Feynman57),
+        typeof(Feynman58),
+        typeof(Feynman59),
+        typeof(Feynman60),
+        typeof(Feynman61),
+        typeof(Feynman62),
+        typeof(Feynman63),
+        typeof(Feynman64),
+        typeof(Feynman65),
+        typeof(Feynman66),
+        typeof(Feynman67),
+        typeof(Feynman68),
+        typeof(Feynman69),
+        typeof(Feynman70),
+        typeof(Feynman71),
+        typeof(Feynman72),
+        typeof(Feynman73),
+        typeof(Feynman74),
+        typeof(Feynman75),
+        typeof(Feynman76),
+        typeof(Feynman77),
+        typeof(Feynman78),
+        typeof(Feynman79),
+        typeof(Feynman80),
+        typeof(Feynman81),
+        typeof(Feynman82),
+        typeof(Feynman83),
+        typeof(Feynman84),
+        typeof(Feynman85),
+        typeof(Feynman86),
+        typeof(Feynman87),
+        typeof(Feynman88),
+        typeof(Feynman89),
+        typeof(Feynman90),
+        typeof(Feynman91),
+        typeof(Feynman92),
+        typeof(Feynman93),
+        typeof(Feynman94),
+        typeof(Feynman95),
+        typeof(Feynman96),
+        typeof(Feynman97),
+        typeof(Feynman98),
+        typeof(Feynman99),
+        typeof(Feynman100),
+        typeof(FeynmanBonus1),
+        typeof(FeynmanBonus2),
+        typeof(FeynmanBonus3),
+        typeof(FeynmanBonus4),
+        typeof(FeynmanBonus5),
+        typeof(FeynmanBonus6),
+        typeof(FeynmanBonus7),
+        typeof(FeynmanBonus8),
+        typeof(FeynmanBonus9),
+        typeof(FeynmanBonus10),
+        typeof(FeynmanBonus11),
+        typeof(FeynmanBonus12),
+        typeof(FeynmanBonus13),
+        typeof(FeynmanBonus14),
+        typeof(FeynmanBonus15),
+        typeof(FeynmanBonus16),
+        typeof(FeynmanBonus17),
+        typeof(FeynmanBonus18),
+        typeof(FeynmanBonus19),
+        typeof(FeynmanBonus20)
+   };
+      #endregion
+
+
+      foreach (var n in noiseRatio) {
+        foreach (var type in descriptorTypes) {
+          descriptorList.Add((IDataDescriptor)Activator.CreateInstance(type, rand.Next(), 100, 100, n));
+        }
+      }
+      return descriptorList.ToList();
+    }
+  }
+}
