Changeset 17973


Ignore:
Timestamp:
05/04/21 14:29:30 (5 days ago)
Author:
chaider
Message:

#3075

  • Added target without noise to noisy instances
  • Moved noise calculation to descriptor
Location:
trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman
Files:
121 edited

Legend:

Unmodified
Added
Removed
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman1.cs

    r17966 r17973  
    3434
    3535    protected override string TargetVariable { get { return noiseRatio == null ? "f" : "f_noise"; } }
    36     protected override string[] VariableNames { get { return new[] {"theta", noiseRatio == null ? "f" : "f_noise"}; } }
     36
     37    protected override string[] VariableNames {
     38      get { return noiseRatio == null ? new[] {"theta", "f"} : new[] { "theta", "f", "f_noise" }; }
     39    }
     40
    3741    protected override string[] AllowedInputVariables { get { return new[] {"theta"}; } }
    3842
     
    5660
    5761      for (var i = 0; i < theta.Count; i++) {
    58         var res = Math.Exp(Math.Pow(-theta[i], 2) / 2) / Math.Sqrt(2 * Math.PI);
     62        var res = Math.Exp(Math.Pow(-i, 2) / 2) / Math.Sqrt(2 * Math.PI);
    5963        f.Add(res);
    6064      }
    6165
    62       if (noiseRatio != null) {
     66      /*if (noiseRatio != null) {
    6367        var f_noise     = new List<double>();
    6468        var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * f.StandardDeviationPop();
     
    6670        data.Remove(f);
    6771        data.Add(f_noise);
    68       }
     72      }*/
     73      var targetNoise = GetNoisyTarget(f, rand);
     74      if (targetNoise != null) data.Add(targetNoise);
    6975
    7076      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman10.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q1", "epsilon", "r", noiseRatio == null ? "Ef" : "Ef_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q1", "epsilon", "r", "Ef" } : new[] { "q1", "epsilon", "r", "Ef", "Ef_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var Ef_noise    = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Ef.StandardDeviationPop();
    73         Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(Ef);
    75         data.Add(Ef_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(Ef, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman100.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"rho_c_0", "q", "A_vec", "m", noiseRatio == null ? "j" : "j_noise"}; }
     38      get { return noiseRatio == null ? new[] { "rho_c_0", "q", "A_vec", "m", "j"} : new[] { "rho_c_0", "q", "A_vec", "m", "j", "j_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var j_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * j.StandardDeviationPop();
    75         j_noise.AddRange(j.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(j);
    77         data.Add(j_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(j, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman11.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q2", "Ef", noiseRatio == null ? "F" : "F_noise"}; }
     38      get { return noiseRatio == null ? new[] {"q2", "Ef", "F" } : new[] { "q2", "Ef", "F", "F_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var F_noise     = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    71         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(F);
    73         data.Add(F_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(F, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman12.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "Ef", "B", "v", "theta", noiseRatio == null ? "F" : "F_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "Ef", "B", "v", "theta", "F" } : new[] { "q", "Ef", "B", "v", "theta", "F", "F_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var F_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    77         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(F);
    79         data.Add(F_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(F, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman13.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "v", "u", "w", noiseRatio == null ? "K" : "K_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "v", "u", "w", "K" } : new[] { "m", "v", "u", "w", "K", "K_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var K_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * K.StandardDeviationPop();
    75         K_noise.AddRange(K.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(K);
    77         data.Add(K_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(K, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman14.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m1", "m2", "r1", "r2", "G", noiseRatio == null ? "U" : "U_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m1", "m2", "r1", "r2", "G", "U" } : new[] { "m1", "m2", "r1", "r2", "G", "U", "U_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var U_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * U.StandardDeviationPop();
    77         U_noise.AddRange(U.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(U);
    79         data.Add(U_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(U, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman15.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "g", "z", noiseRatio == null ? "U" : "U_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "g", "z", "U" } : new[] { "m", "g", "z", "U", "U_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var U_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * U.StandardDeviationPop();
    73         U_noise.AddRange(U.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(U);
    75         data.Add(U_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(U, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman16.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"k_spring", "x", noiseRatio == null ? "U" : "U_noise"}; }
     38      get { return noiseRatio == null ? new[] { "k_spring", "x", "U" } : new[] { "k_spring", "x", "U", "U_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var U_noise     = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * U.StandardDeviationPop();
    71         U_noise.AddRange(U.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(U);
    73         data.Add(U_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(U, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman17.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] { "x", "u", "c", "t", noiseRatio == null ? "x1" : "x1_noise" }; }
     38      get { return noiseRatio == null ? new[] { "x", "u", "c", "t", "x1" } : new[] { "x", "u", "c", "t", "x1", "x1_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var x1_noise = new List<double>();
    74         var sigma_noise = (double)Math.Sqrt(noiseRatio.Value) * x1.StandardDeviationPop();
    75         x1_noise.AddRange(x1.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(x1);
    77         data.Add(x1_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(x1, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman18.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"x", "c", "u", "t", noiseRatio == null ? "t1" : "t1_noise"}; }
     38      get { return noiseRatio == null ? new[] { "x", "c", "u", "t", "t1" } : new[] { "x", "c", "u", "t", "t1", "t1_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var t1_noise    = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * t1.StandardDeviationPop();
    75         t1_noise.AddRange(t1.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(t1);
    77         data.Add(t1_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(t1, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman19.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m_0", "v", "c", noiseRatio == null ? "p" : "p_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m_0", "v", "c", "p" } : new[] { "m_0", "v", "c", "p", "p_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var p_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * p.StandardDeviationPop();
    73         p_noise.AddRange(p.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(p);
    75         data.Add(p_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(p, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman2.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"sigma", "theta", noiseRatio == null ? "f" : "f_noise"}; }
     38      get { return noiseRatio == null ? new[] { "sigma", "theta", "f" } : new[] { "sigma", "theta", "f", "f_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var f_noise     = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * f.StandardDeviationPop();
    71         f_noise.AddRange(f.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(f);
    73         data.Add(f_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(f, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman20.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"c", "v", "u", noiseRatio == null ? "v1" : "v1_noise"}; }
     38      get { return noiseRatio == null ? new[] { "c", "v", "u", "v1" } : new[] { "c", "v", "u", "v1", "v1_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var v1_noise    = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * v1.StandardDeviationPop();
    73         v1_noise.AddRange(v1.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(v1);
    75         data.Add(v1_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(v1, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman21.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m1", "m2", "r1", "r2", noiseRatio == null ? "r" : "r_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m1", "m2", "r1", "r2", "r" } : new[] { "m1", "m2", "r1", "r2", "r", "r_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var r_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * r.StandardDeviationPop();
    75         r_noise.AddRange(r.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(r);
    77         data.Add(r_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(r, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman22.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"r", "F", "theta", noiseRatio == null ? "tau" : "tau_noise"}; }
     38      get { return noiseRatio == null ? new[] { "r", "F", "theta", "tau" } : new[] { "r", "F", "theta", "tau", "tau_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var tau_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * tau.StandardDeviationPop();
    73         tau_noise.AddRange(tau.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(tau);
    75         data.Add(tau_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(tau, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman23.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "r", "v", "theta", noiseRatio == null ? "L" : "L_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "r", "v", "theta", "L" } : new[] { "m", "r", "v", "theta", "L", "L_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var L_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * L.StandardDeviationPop();
    75         L_noise.AddRange(L.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(L);
    77         data.Add(L_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(L, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman24.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "omega", "omega_0", "x", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "omega", "omega_0", "x", "E_n" } : new[] { "m", "omega", "omega_0", "x", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var E_n_noise   = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    75         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(E_n);
    77         data.Add(E_n_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(E_n, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman25.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "C", noiseRatio == null ? "Volt" : "Volt_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "C", "Volt" } : new[] { "q", "C", "Volt", "Volt_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var Volt_noise  = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Volt.StandardDeviationPop();
    71         Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(Volt);
    73         data.Add(Volt_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(Volt, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman26.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n", "theta2", noiseRatio == null ? "theta1" : "theta1_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n", "theta2", "theta1" } : new[] { "n", "theta2", "theta1", "theta1_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var theta1_noise = new List<double>();
    70         var sigma_noise  = (double) Math.Sqrt(noiseRatio.Value) * theta1.StandardDeviationPop();
    71         theta1_noise.AddRange(theta1.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(theta1);
    73         data.Add(theta1_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(theta1, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman27.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"d1", "d2", "n", noiseRatio == null ? "foc" : "foc_noise"}; }
     38      get { return noiseRatio == null ? new[] { "d1", "d2", "n", "foc" } : new[] { "d1", "d2", "n", "foc", "foc_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var foc_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * foc.StandardDeviationPop();
    73         foc_noise.AddRange(foc.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(foc);
    75         data.Add(foc_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(foc, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman28.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"omega", "c", noiseRatio == null ? "k" : "k_noise"}; }
     38      get { return noiseRatio == null ? new[] { "omega", "c", "k" } : new[] { "omega", "c", "k", "k_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var k_noise     = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * k.StandardDeviationPop();
    71         k_noise.AddRange(k.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(k);
    73         data.Add(k_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(k, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman29.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"x1", "x2", "theta1", "theta2", noiseRatio == null ? "x" : "x_noise"}; }
     38      get { return noiseRatio == null ? new[] { "x1", "x2", "theta1", "theta2", "x" } : new[] { "x1", "x2", "theta1", "theta2", "x", "x_noise" }; }
    3939    }
    4040
     
    7171      }
    7272
    73       if (noiseRatio != null) {
    74         var x_noise     = new List<double>();
    75         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * x.StandardDeviationPop();
    76         x_noise.AddRange(x.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    77         data.Remove(x);
    78         data.Add(x_noise);
    79       }
     73      var targetNoise = GetNoisyTarget(x, rand);
     74      if (targetNoise != null) data.Add(targetNoise);
    8075
    8176      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman3.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"sigma", "theta", "theta1", noiseRatio == null ? "f" : "f_noise"}; }
     39      get { return noiseRatio == null ? new[] { "sigma", "theta", "theta1", "f" } : new[] { "sigma", "theta", "theta1", "f", "f_noise" }; }
    4040    }
    4141
     
    6969      }
    7070
    71       if (noiseRatio != null) {
    72         var f_noise     = new List<double>();
    73         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * f.StandardDeviationPop();
    74         f_noise.AddRange(f.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    75         data.Remove(f);
    76         data.Add(f_noise);
    77       }
     71      var targetNoise = GetNoisyTarget(f, rand);
     72      if (targetNoise != null) data.Add(targetNoise);
    7873
    7974      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman30.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"Int_0", "theta", "n", noiseRatio == null ? "Int" : "Int_noise"}; }
     38      get { return noiseRatio == null ? new[] { "Int_0", "theta", "n", "Int" } : new[] { "Int_0", "theta", "n", "Int", "Int_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var Int_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Int.StandardDeviationPop();
    73         Int_noise.AddRange(Int.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(Int);
    75         data.Add(Int_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(Int, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman31.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"lambd", "d", "n", noiseRatio == null ? "theta" : "theta_noise"}; }
     38      get { return noiseRatio == null ? new[] { "lambd", "d", "n", "theta" } : new[] { "lambd", "d", "n", "theta", "theta_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var theta_noise = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * theta.StandardDeviationPop();
    73         theta_noise.AddRange(theta.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(theta);
    75         data.Add(theta_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(theta, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman32.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "a", "epsilon", "c", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "a", "epsilon", "c", "Pwr" } : new[] { "q", "a", "epsilon", "c", "Pwr", "Pwr_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var Pwr_noise   = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Pwr.StandardDeviationPop();
    75         Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(Pwr);
    77         data.Add(Pwr_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(Pwr, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman33.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"epsilon", "c", "Ef", "r", "omega", "omega_0", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
     39      get { return noiseRatio == null ? new[] { "epsilon", "c", "Ef", "r", "omega", "omega_0", "Pwr" } : new[] { "epsilon", "c", "Ef", "r", "omega", "omega_0", "Pwr", "Pwr_noise" }; }
    4040    }
    4141
     
    7878      }
    7979
    80       if (noiseRatio != null) {
    81         var Pwr_noise   = new List<double>();
    82         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Pwr.StandardDeviationPop();
    83         Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    84         data.Remove(Pwr);
    85         data.Add(Pwr_noise);
    86       }
     80      var targetNoise = GetNoisyTarget(Pwr, rand);
     81      if (targetNoise != null) data.Add(targetNoise);
    8782
    8883      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman34.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "v", "B", "p", noiseRatio == null ? "omega" : "omega_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "v", "B", "p", "omega" } : new[] { "q", "v", "B", "p", "omega", "omega_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var omega_noise = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * omega.StandardDeviationPop();
    75         omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(omega);
    77         data.Add(omega_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(omega, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman35.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"c", "v", "omega_0", noiseRatio == null ? "omega" : "omega_noise"}; }
     38      get { return noiseRatio == null ? new[] { "c", "v", "omega_0", "omega" } : new[] { "c", "v", "omega_0", "omega", "omega_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var omega_noise = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * omega.StandardDeviationPop();
    73         omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(omega);
    75         data.Add(omega_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(omega, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman36.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"c", "v", "omega_0", noiseRatio == null ? "omega" : "omega_noise"}; }
     38      get { return noiseRatio == null ? new[] { "c", "v", "omega_0", "omega" } : new[] { "c", "v", "omega_0", "omega", "omega_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var omega_noise = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * omega.StandardDeviationPop();
    73         omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(omega);
    75         data.Add(omega_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(omega, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman37.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"omega", "h", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "omega", "h", "E_n" } : new[] { "omega", "h", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var E_n_noise   = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    71         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(E_n);
    73         data.Add(E_n_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(E_n, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman38.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"I1", "I2", "delta", noiseRatio == null ? "Int" : "Int_noise"}; }
     38      get { return noiseRatio == null ? new[] { "I1", "I2", "delta", "Int" } : new[] { "I1", "I2", "delta", "Int", "Int_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var Int_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Int.StandardDeviationPop();
    73         Int_noise.AddRange(Int.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(Int);
    75         data.Add(Int_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(Int, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman39.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "q", "h", "epsilon", noiseRatio == null ? "r" : "r_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "q", "h", "epsilon", "r" } : new[] { "m", "q", "h", "epsilon", "r", "r_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var r_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * r.StandardDeviationPop();
    75         r_noise.AddRange(r.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(r);
    77         data.Add(r_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(r, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman4.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"x1", "x2", "y1", "y2", noiseRatio == null ? "d" : "d_noise"}; }
     38      get { return noiseRatio == null ? new[] { "x1", "x2", "y1", "y2", "d" } : new[] { "x1", "x2", "y1", "y2", "d", "d_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var d_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * d.StandardDeviationPop();
    75         d_noise.AddRange(d.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(d);
    77         data.Add(d_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(d, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman40.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"pF", "V", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "pF", "V", "E_n" } : new[] { "pF", "V", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var E_n_noise   = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    71         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(E_n);
    73         data.Add(E_n_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(E_n, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman41.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"gamma", "pF", "V", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "gamma", "pF", "V", "E_n" } : new[] { "gamma", "pF", "V", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman42.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n", "T", "V", "kb", noiseRatio == null ? "pr" : "pr_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n", "T", "V", "kb", "pr" } : new[] { "n", "T", "V", "kb", "pr", "pr_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var pr_noise    = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * pr.StandardDeviationPop();
    75         pr_noise.AddRange(pr.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(pr);
    77         data.Add(pr_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(pr, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman43.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n_0", "m", "x", "T", "g", "kb", noiseRatio == null ? "n" : "n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n_0", "m", "x", "T", "g", "kb", "n" } : new[] { "n_0", "m", "x", "T", "g", "kb", "n", "n_noise" }; }
    3939    }
    4040
     
    7474      }
    7575
    76       if (noiseRatio != null) {
    77         var n_noise     = new List<double>();
    78         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * n.StandardDeviationPop();
    79         n_noise.AddRange(n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    80         data.Remove(n);
    81         data.Add(n_noise);
    82       }
     76      var targetNoise = GetNoisyTarget(n, rand);
     77      if (targetNoise != null) data.Add(targetNoise);
    8378
    8479      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman44.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"omega", "T", "h", "kb", "c", noiseRatio == null ? "L_rad" : "L_rad_noise"}; }
     39      get { return noiseRatio == null ? new[] { "omega", "T", "h", "kb", "c", "L_rad" } : new[] { "omega", "T", "h", "kb", "c", "L_rad", "L_rad_noise" }; }
    4040    }
    4141
     
    7575      }
    7676
    77       if (noiseRatio != null) {
    78         var L_rad_noise = new List<double>();
    79         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * L_rad.StandardDeviationPop();
    80         L_rad_noise.AddRange(L_rad.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    81         data.Remove(L_rad);
    82         data.Add(L_rad_noise);
    83       }
     77      var targetNoise = GetNoisyTarget(L_rad, rand);
     78      if (targetNoise != null) data.Add(targetNoise);
    8479
    8580      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman45.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mu_drift", "q", "Volt", "d", noiseRatio == null ? "v" : "v_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mu_drift", "q", "Volt", "d", "v" } : new[] { "mu_drift", "q", "Volt", "d", "v", "v_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var v_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * v.StandardDeviationPop();
    75         v_noise.AddRange(v.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(v);
    77         data.Add(v_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(v, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman46.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mob", "T", "kb", noiseRatio == null ? "D" : "D_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mob", "T", "kb", "D" } : new[] { "mob", "T", "kb", "D", "D_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var D_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * D.StandardDeviationPop();
    73         D_noise.AddRange(D.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(D);
    75         data.Add(D_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(D, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman47.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"gamma", "kb", "A", "v", noiseRatio == null ? "kappa" : "kappa_noise"}; }
     38      get { return noiseRatio == null ? new[] { "gamma", "kb", "A", "v", "kappa" } : new[] { "gamma", "kb", "A", "v", "kappa", "kappa_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var kappa_noise = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * kappa.StandardDeviationPop();
    75         kappa_noise.AddRange(kappa.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(kappa);
    77         data.Add(kappa_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(kappa, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman48.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n", "kb", "T", "V1", "V2", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n", "kb", "T", "V1", "V2", "E_n" } : new[] { "n", "kb", "T", "V1", "V2", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var E_n_noise   = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    77         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(E_n);
    79         data.Add(E_n_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(E_n, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman49.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"gamma", "pr", "rho", noiseRatio == null ? "c" : "c_noise"}; }
     38      get { return noiseRatio == null ? new[] { "gamma", "pr", "rho", "c" } : new[] { "gamma", "pr", "rho", "c", "c_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var c_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * c.StandardDeviationPop();
    73         c_noise.AddRange(c.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(c);
    75         data.Add(c_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(c, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman5.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m1", "m2", "G", "x1", "x2", "y1", "y2", "z1", "z2", noiseRatio == null ? "F" : "F_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m1", "m2", "G", "x1", "x2", "y1", "y2", "z1", "z2", "F" } : new[] { "m1", "m2", "G", "x1", "x2", "y1", "y2", "z1", "z2", "F", "F_noise" }; }
    3939    }
    4040
     
    8383      }
    8484
    85       if (noiseRatio != null) {
    86         var F_noise     = new List<double>();
    87         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    88         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    89         data.Remove(F);
    90         data.Add(F_noise);
    91       }
     85      var targetNoise = GetNoisyTarget(F, rand);
     86      if (targetNoise != null) data.Add(targetNoise);
    9287
    9388      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman50.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "v", "c", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "v", "c", "E_n" } : new[] { "m", "v", "c", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman51.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"x1", "omega", "t", "alpha", noiseRatio == null ? "x" : "x_noise"}; }
     38      get { return noiseRatio == null ? new[] { "x1", "omega", "t", "alpha", "x" } : new[] { "x1", "omega", "t", "alpha", "x", "x_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var x_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * x.StandardDeviationPop();
    75         x_noise.AddRange(x.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(x);
    77         data.Add(x_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(x, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman52.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"kappa", "T1", "T2", "A", "d", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
     38      get { return noiseRatio == null ? new[] { "kappa", "T1", "T2", "A", "d", "Pwr" } : new[] { "kappa", "T1", "T2", "A", "d", "Pwr", "Pwr_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var Pwr_noise   = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Pwr.StandardDeviationPop();
    77         Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(Pwr);
    79         data.Add(Pwr_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(Pwr, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman53.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"Pwr", "r", noiseRatio == null ? "flux" : "flux_noise"}; }
     38      get { return noiseRatio == null ? new[] { "Pwr", "r", "flux" } : new[] { "Pwr", "r", "flux", "flux_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var flux_noise  = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * flux.StandardDeviationPop();
    71         flux_noise.AddRange(flux.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(flux);
    73         data.Add(flux_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(flux, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman54.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "epsilon", "r", noiseRatio == null ? "Volt" : "Volt_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "epsilon", "r", "Volt" } : new[] { "q", "epsilon", "r", "Volt", "Volt_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var Volt_noise  = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Volt.StandardDeviationPop();
    73         Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(Volt);
    75         data.Add(Volt_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(Volt, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman55.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"epsilon", "p_d", "theta", "r", noiseRatio == null ? "Volt" : "Volt_noise"}; }
     38      get { return noiseRatio == null ? new[] { "epsilon", "p_d", "theta", "r", "Volt" } : new[] { "epsilon", "p_d", "theta", "r", "Volt", "Volt_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var Volt_noise  = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Volt.StandardDeviationPop();
    75         Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(Volt);
    77         data.Add(Volt_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(Volt, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman56.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"epsilon", "p_d", "r", "x", "y", "z", noiseRatio == null ? "Ef" : "Ef_noise"}; }
     38      get { return noiseRatio == null ? new[] { "epsilon", "p_d", "r", "x", "y", "z", "Ef" } : new[] { "epsilon", "p_d", "r", "x", "y", "z", "Ef", "Ef_noise" }; }
    3939    }
    4040
     
    7575      }
    7676
    77       if (noiseRatio != null) {
    78         var Ef_noise    = new List<double>();
    79         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Ef.StandardDeviationPop();
    80         Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    81         data.Remove(Ef);
    82         data.Add(Ef_noise);
    83       }
     77      var targetNoise = GetNoisyTarget(Ef, rand);
     78      if (targetNoise != null) data.Add(targetNoise);
    8479
    8580      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman57.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"epsilon", "p_d", "theta", "r", noiseRatio == null ? "Ef" : "Ef_noise"}; }
     39      get { return noiseRatio == null ? new[] { "epsilon", "p_d", "theta", "r", "Ef" } : new[] { "epsilon", "p_d", "theta", "r", "Ef", "Ef_noise" }; }
    4040    }
    4141
     
    7171      }
    7272
    73       if (noiseRatio != null) {
    74         var Ef_noise    = new List<double>();
    75         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Ef.StandardDeviationPop();
    76         Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    77         data.Remove(Ef);
    78         data.Add(Ef_noise);
    79       }
     73      var targetNoise = GetNoisyTarget(Ef, rand);
     74      if (targetNoise != null) data.Add(targetNoise);
    8075
    8176      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman58.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "epsilon", "d", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "epsilon", "d", "E_n" } : new[] { "q", "epsilon", "d", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman59.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"epsilon", "Ef", noiseRatio == null ? "E_den" : "E_den_noise"}; }
     38      get { return noiseRatio == null ? new[] { "epsilon", "Ef", "E_den" } : new[] { "epsilon", "Ef", "E_den", "E_den_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var E_den_noise = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_den.StandardDeviationPop();
    71         E_den_noise.AddRange(E_den.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(E_den);
    73         data.Add(E_den_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(E_den, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman6.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m_0", "v", "c", noiseRatio == null ? "m" : "m_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m_0", "v", "c", "m" } : new[] { "m_0", "v", "c", "m", "m_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var m_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * m.StandardDeviationPop();
    73         m_noise.AddRange(m.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(m);
    75         data.Add(m_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(m, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman60.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"sigma_den", "epsilon", "chi", noiseRatio == null ? "Ef" : "Ef_noise"}; }
     38      get { return noiseRatio == null ? new[] { "sigma_den", "epsilon", "chi", "Ef" } : new[] { "sigma_den", "epsilon", "chi", "Ef", "Ef_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var Ef_noise    = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Ef.StandardDeviationPop();
    73         Ef_noise.AddRange(Ef.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(Ef);
    75         data.Add(Ef_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(Ef, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman61.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "Ef", "m", "omega_0", "omega", noiseRatio == null ? "x" : "x_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "Ef", "m", "omega_0", "omega", "x" } : new[] { "q", "Ef", "m", "omega_0", "omega", "x", "x_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var x_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * x.StandardDeviationPop();
    77         x_noise.AddRange(x.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(x);
    79         data.Add(x_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(x, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman62.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n_0", "kb", "T", "theta", "p_d", "Ef", noiseRatio == null ? "n" : "n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n_0", "kb", "T", "theta", "p_d", "Ef", "n" } : new[] { "n_0", "kb", "T", "theta", "p_d", "Ef", "n", "n_noise" }; }
    3939    }
    4040
     
    7474      }
    7575
    76       if (noiseRatio != null) {
    77         var n_noise     = new List<double>();
    78         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * n.StandardDeviationPop();
    79         n_noise.AddRange(n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    80         data.Remove(n);
    81         data.Add(n_noise);
    82       }
     76      var targetNoise = GetNoisyTarget(n, rand);
     77      if (targetNoise != null) data.Add(targetNoise);
    8378
    8479      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman63.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n_rho", "p_d", "Ef", "kb", "T", noiseRatio == null ? "Pol" : "Pol_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n_rho", "p_d", "Ef", "kb", "T", "Pol" } : new[] { "n_rho", "p_d", "Ef", "kb", "T", "Pol", "Pol_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var Pol_noise   = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Pol.StandardDeviationPop();
    77         Pol_noise.AddRange(Pol.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(Pol);
    79         data.Add(Pol_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(Pol, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman64.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n", "alpha", "epsilon", "Ef", noiseRatio == null ? "Pol" : "Pol_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n", "alpha", "epsilon", "Ef", "Pol" } : new[] { "n", "alpha", "epsilon", "Ef", "Pol", "Pol_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var Pol_noise   = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Pol.StandardDeviationPop();
    75         Pol_noise.AddRange(Pol.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(Pol);
    77         data.Add(Pol_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(Pol, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman65.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n", "alpha", noiseRatio == null ? "theta" : "theta_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n", "alpha", "theta" } : new[] { "n", "alpha", "theta", "theta_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var theta_noise = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * theta.StandardDeviationPop();
    71         theta_noise.AddRange(theta.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(theta);
    73         data.Add(theta_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(theta, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman66.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"epsilon", "c", "I", "r", noiseRatio == null ? "B" : "B_noise"}; }
     38      get { return noiseRatio == null ? new[] { "epsilon", "c", "I", "r", "B" } : new[] { "epsilon", "c", "I", "r", "B", "B_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var B_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * B.StandardDeviationPop();
    75         B_noise.AddRange(B.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(B);
    77         data.Add(B_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(B, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman67.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"rho_c_0", "v", "c", noiseRatio == null ? "rho_c" : "rho_c_noise"}; }
     38      get { return noiseRatio == null ? new[] { "rho_c_0", "v", "c", "rho_c" } : new[] { "rho_c_0", "v", "c", "rho_c", "rho_c_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var rho_c_noise = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * rho_c.StandardDeviationPop();
    73         rho_c_noise.AddRange(rho_c.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(rho_c);
    75         data.Add(rho_c_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(rho_c, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman68.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"rho_c_0", "v", "c", noiseRatio == null ? "j" : "j_noise"}; }
     38      get { return noiseRatio == null ? new[] { "rho_c_0", "v", "c", "j" } : new[] { "rho_c_0", "v", "c", "j", "j_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var j_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * j.StandardDeviationPop();
    73         j_noise.AddRange(j.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(j);
    75         data.Add(j_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(j, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman69.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mom", "B", "theta", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mom", "B", "theta", "E_n" } : new[] { "mom", "B", "theta", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman7.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"x1", "x2", "x3", "y1", "y2", "y3", noiseRatio == null ? "A" : "A_noise"}; }
     38      get { return noiseRatio == null ? new[] { "x1", "x2", "x3", "y1", "y2", "y3", "A" } : new[] { "x1", "x2", "x3", "y1", "y2", "y3", "A", "A_noise" }; }
    3939    }
    4040
     
    7474      }
    7575
    76       if (noiseRatio != null) {
    77         var A_noise     = new List<double>();
    78         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * A.StandardDeviationPop();
    79         A_noise.AddRange(A.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    80         data.Remove(A);
    81         data.Add(A_noise);
    82       }
     76      var targetNoise = GetNoisyTarget(A, rand);
     77      if (targetNoise != null) data.Add(targetNoise);
    8378
    8479      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman70.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"p_d", "Ef", "theta", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "p_d", "Ef", "theta", "E_n" } : new[] { "p_d", "Ef", "theta", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman71.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "epsilon", "r", "v", "c", noiseRatio == null ? "Volt" : "Volt_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "epsilon", "r", "v", "c", "Volt" } : new[] { "q", "epsilon", "r", "v", "c", "Volt", "Volt_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var Volt_noise  = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Volt.StandardDeviationPop();
    77         Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(Volt);
    79         data.Add(Volt_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(Volt, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman72.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"omega", "c", "d", noiseRatio == null ? "k" : "k_noise"}; }
     38      get { return noiseRatio == null ? new[] { "omega", "c", "d", "k" } : new[] { "omega", "c", "d", "k", "k_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var k_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * k.StandardDeviationPop();
    73         k_noise.AddRange(k.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(k);
    75         data.Add(k_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(k, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman73.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"epsilon", "c", "Ef", noiseRatio == null ? "flux" : "flux_noise"}; }
     38      get { return noiseRatio == null ? new[] { "epsilon", "c", "Ef", "flux" } : new[] { "epsilon", "c", "Ef", "flux", "flux_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var flux_noise  = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * flux.StandardDeviationPop();
    73         flux_noise.AddRange(flux.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(flux);
    75         data.Add(flux_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(flux, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman74.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"epsilon", "Ef", noiseRatio == null ? "E_den" : "E_den_noise"}; }
     38      get { return noiseRatio == null ? new[] { "epsilon", "Ef", "E_den" } : new[] { "epsilon", "Ef", "E_den", "E_den_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var E_den_noise = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_den.StandardDeviationPop();
    71         E_den_noise.AddRange(E_den.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(E_den);
    73         data.Add(E_den_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(E_den, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman75.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "v", "r", noiseRatio == null ? "I" : "I_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "v", "r", "I" } : new[] { "q", "v", "r", "I", "I_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var I_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * I.StandardDeviationPop();
    73         I_noise.AddRange(I.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(I);
    75         data.Add(I_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(I, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman76.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "v", "r", noiseRatio == null ? "mom" : "mom_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "v", "r", "mom" } : new[] { "q", "v", "r", "mom", "mom_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var mom_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * mom.StandardDeviationPop();
    73         mom_noise.AddRange(mom.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(mom);
    75         data.Add(mom_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(mom, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman77.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"g_", "q", "B", "m", noiseRatio == null ? "omega" : "omega_noise"}; }
     38      get { return noiseRatio == null ? new[] { "g_", "q", "B", "m", "omega" } : new[] { "g_", "q", "B", "m", "omega", "omega_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var omega_noise = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * omega.StandardDeviationPop();
    75         omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(omega);
    77         data.Add(omega_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(omega, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman78.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q", "h", "m", noiseRatio == null ? "mom" : "mom_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q", "h", "m", "mom" } : new[] { "q", "h", "m", "mom", "mom_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var mom_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * mom.StandardDeviationPop();
    73         mom_noise.AddRange(mom.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(mom);
    75         data.Add(mom_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(mom, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman79.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"g_", "h", "Jz", "mom", "B", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "g_", "h", "Jz", "mom", "B", "E_n" } : new[] { "g_", "h", "Jz", "mom", "B", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var E_n_noise   = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    77         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(E_n);
    79         data.Add(E_n_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(E_n, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman8.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mu", "Nn", noiseRatio == null ? "F" : "F_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mu", "Nn", "F" } : new[] { "mu", "Nn", "F", "F_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var F_noise     = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    71         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(F);
    73         data.Add(F_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(F, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman80.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n_0", "kb", "T", "mom", "B", noiseRatio == null ? "n" : "n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n_0", "kb", "T", "mom", "B", "n" } : new[] { "n_0", "kb", "T", "mom", "B", "n", "n_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var n_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * n.StandardDeviationPop();
    77         n_noise.AddRange(n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(n);
    79         data.Add(n_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(n, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman81.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"n_rho", "mom", "B", "kb", "T", noiseRatio == null ? "M" : "M_noise"}; }
     38      get { return noiseRatio == null ? new[] { "n_rho", "mom", "B", "kb", "T", "M" } : new[] { "n_rho", "mom", "B", "kb", "T", "M", "M_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var M_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * M.StandardDeviationPop();
    77         M_noise.AddRange(M.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(M);
    79         data.Add(M_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(M, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman82.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"mom", "B", "kb", "T", "alpha", "epsilon", "c", "M", noiseRatio == null ? "f" : "f_noise"}; }
     39      get { return noiseRatio == null ? new[] { "mom", "B", "kb", "T", "alpha", "epsilon", "c", "M", "f" } : new[] { "mom", "B", "kb", "T", "alpha", "epsilon", "c", "M", "f", "f_noise" }; }
    4040    }
    4141
     
    8282      }
    8383
    84       if (noiseRatio != null) {
    85         var f_noise     = new List<double>();
    86         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * f.StandardDeviationPop();
    87         f_noise.AddRange(f.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    88         data.Remove(f);
    89         data.Add(f_noise);
    90       }
     84      var targetNoise = GetNoisyTarget(f, rand);
     85      if (targetNoise != null) data.Add(targetNoise);
    9186
    9287      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman83.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mom", "B", "chi", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mom", "B", "chi", "E_n" } : new[] { "mom", "B", "chi", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman84.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"Y", "A", "d", "x", noiseRatio == null ? "F" : "F_noise"}; }
     38      get { return noiseRatio == null ? new[] { "Y", "A", "d", "x", "F" } : new[] { "Y", "A", "d", "x", "F", "F_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var F_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    75         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(F);
    77         data.Add(F_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(F, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman85.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"Y", "sigma", noiseRatio == null ? "mu_S" : "mu_S_noise"}; }
     38      get { return noiseRatio == null ? new[] { "Y", "sigma", "mu_S" } : new[] { "Y", "sigma", "mu_S", "mu_S_noise" }; }
    3939    }
    4040
     
    6666      }
    6767
    68       if (noiseRatio != null) {
    69         var mu_S_noise  = new List<double>();
    70         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * mu_S.StandardDeviationPop();
    71         mu_S_noise.AddRange(mu_S.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    72         data.Remove(mu_S);
    73         data.Add(mu_S_noise);
    74       }
     68      var targetNoise = GetNoisyTarget(mu_S, rand);
     69      if (targetNoise != null) data.Add(targetNoise);
    7570
    7671      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman86.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"h", "omega", "kb", "T", noiseRatio == null ? "n" : "n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "h", "omega", "kb", "T", "n" } : new[] { "h", "omega", "kb", "T", "n", "n_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var n_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * n.StandardDeviationPop();
    75         n_noise.AddRange(n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(n);
    77         data.Add(n_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(n, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman87.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"h", "omega", "kb", "T", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     39      get { return noiseRatio == null ? new[] { "h", "omega", "kb", "T", "E_n" } : new[] { "h", "omega", "kb", "T", "E_n", "E_n_noise" }; }
    4040    }
    4141
     
    7171      }
    7272
    73       if (noiseRatio != null) {
    74         var E_n_noise   = new List<double>();
    75         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    76         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    77         data.Remove(E_n);
    78         data.Add(E_n_noise);
    79       }
     73      var targetNoise = GetNoisyTarget(E_n, rand);
     74      if (targetNoise != null) data.Add(targetNoise);
    8075
    8176      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman88.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mom", "B", "h", noiseRatio == null ? "omega" : "omega_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mom", "B", "h", "omega" } : new[] { "mom", "B", "h", "omega", "omega_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var omega_noise = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * omega.StandardDeviationPop();
    73         omega_noise.AddRange(omega.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(omega);
    75         data.Add(omega_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(omega, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman89.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"E_n", "t", "h", noiseRatio == null ? "prob" : "prob_noise"}; }
     38      get { return noiseRatio == null ? new[] { "E_n", "t", "h", "prob" } : new[] { "E_n", "t", "h", "prob", "prob_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var prob_noise  = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * prob.StandardDeviationPop();
    73         prob_noise.AddRange(prob.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(prob);
    75         data.Add(prob_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(prob, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman9.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"q1", "q2", "epsilon", "r", noiseRatio == null ? "F" : "F_noise"}; }
     38      get { return noiseRatio == null ? new[] { "q1", "q2", "epsilon", "r", "F" } : new[] { "q1", "q2", "epsilon", "r", "F", "F_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var F_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    75         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(F);
    77         data.Add(F_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(F, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman90.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"p_d", "Ef", "t", "h", "omega", "omega_0", noiseRatio == null ? "prob" : "prob_noise"}; }
     39      get { return noiseRatio == null ? new[] { "p_d", "Ef", "t", "h", "omega", "omega_0", "prob" } : new[] { "p_d", "Ef", "t", "h", "omega", "omega_0", "prob", "prob_noise" }; }
    4040    }
    4141
     
    7979      }
    8080
    81       if (noiseRatio != null) {
    82         var prob_noise  = new List<double>();
    83         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * prob.StandardDeviationPop();
    84         prob_noise.AddRange(prob.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    85         data.Remove(prob);
    86         data.Add(prob_noise);
    87       }
     81      var targetNoise = GetNoisyTarget(prob, rand);
     82      if (targetNoise != null) data.Add(targetNoise);
    8883
    8984      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman91.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"mom", "Bx", "By", "Bz", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "mom", "Bx", "By", "Bz", "E_n" } : new[] { "mom", "Bx", "By", "Bz", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var E_n_noise   = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    75         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(E_n);
    77         data.Add(E_n_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(E_n, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman92.cs

    r17966 r17973  
    3434
    3535    protected override string TargetVariable { get { return noiseRatio == null ? "L" : "L_noise"; } }
    36     protected override string[] VariableNames { get { return new[] {"n", "h", noiseRatio == null ? "L" : "L_noise"}; } }
     36
     37    protected override string[] VariableNames {
     38      get { return noiseRatio == null ? new[] { "n", "h", "L" } : new[] { "n", "h", "L", "L_noise" }; }
     39    }
    3740    protected override string[] AllowedInputVariables { get { return new[] {"n", "h"}; } }
    3841
     
    6265      }
    6366
    64       if (noiseRatio != null) {
    65         var L_noise     = new List<double>();
    66         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * L.StandardDeviationPop();
    67         L_noise.AddRange(L.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    68         data.Remove(L);
    69         data.Add(L_noise);
    70       }
     67      var targetNoise = GetNoisyTarget(L, rand);
     68      if (targetNoise != null) data.Add(targetNoise);
    7169
    7270      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman93.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"E_n", "d", "k", "h", noiseRatio == null ? "v" : "v_noise"}; }
     38      get { return noiseRatio == null ? new[] { "E_n", "d", "k", "h", "v" } : new[] { "E_n", "d", "k", "h", "v", "v_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var v_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * v.StandardDeviationPop();
    75         v_noise.AddRange(v.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(v);
    77         data.Add(v_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(v, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman94.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"I_0", "q", "Volt", "kb", "T", noiseRatio == null ? "I" : "I_noise"}; }
     38      get { return noiseRatio == null ? new[] { "I_0", "q", "Volt", "kb", "T", "I" } : new[] { "I_0", "q", "Volt", "kb", "T", "I", "I_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var I_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * I.StandardDeviationPop();
    77         I_noise.AddRange(I.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(I);
    79         data.Add(I_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(I, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman95.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"U", "k", "d", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     38      get { return noiseRatio == null ? new[] { "U", "k", "d", "E_n" } : new[] { "U", "k", "d", "E_n", "E_n_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var E_n_noise   = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    73         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(E_n);
    75         data.Add(E_n_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(E_n, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman96.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"h", "E_n", "d", noiseRatio == null ? "m" : "m_noise"}; }
     38      get { return noiseRatio == null ? new[] { "h", "E_n", "d", "m" } : new[] { "h", "E_n", "d", "m", "m_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var m_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * m.StandardDeviationPop();
    73         m_noise.AddRange(m.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(m);
    75         data.Add(m_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(m, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman97.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"alpha", "n", "d", noiseRatio == null ? "k" : "k_noise"}; }
     38      get { return noiseRatio == null ? new[] { "alpha", "n", "d", "k" } : new[] { "alpha", "n", "d", "k", "k_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var k_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * k.StandardDeviationPop();
    73         k_noise.AddRange(k.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(k);
    75         data.Add(k_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(k, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman98.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"beta", "alpha", "theta", noiseRatio == null ? "f" : "f_noise"}; }
     38      get { return noiseRatio == null ? new[] { "beta", "alpha", "theta", "f" } : new[] { "beta", "alpha", "theta", "f", "f_noise" }; }
    3939    }
    4040
     
    6868      }
    6969
    70       if (noiseRatio != null) {
    71         var f_noise     = new List<double>();
    72         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * f.StandardDeviationPop();
    73         f_noise.AddRange(f.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    74         data.Remove(f);
    75         data.Add(f_noise);
    76       }
     70      var targetNoise = GetNoisyTarget(f, rand);
     71      if (targetNoise != null) data.Add(targetNoise);
    7772
    7873      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/Feynman99.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"m", "q", "h", "n", "epsilon", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     39      get { return noiseRatio == null ? new[] { "m", "q", "h", "n", "epsilon", "E_n" } : new[] { "m", "q", "h", "n", "epsilon", "E_n", "E_n_noise" }; }
    4040    }
    4141
     
    7474      }
    7575
    76       if (noiseRatio != null) {
    77         var E_n_noise   = new List<double>();
    78         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    79         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    80         data.Remove(E_n);
    81         data.Add(E_n_noise);
    82       }
     76      var targetNoise = GetNoisyTarget(E_n, rand);
     77      if (targetNoise != null) data.Add(targetNoise);
    8378
    8479      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus1.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"Z_1", "Z_2", "alpha", "hbar", "c", "E_n", "theta", noiseRatio == null ? "A" : "A_noise"}; }
     39      get { return noiseRatio == null ? new[] { "Z_1", "Z_2", "alpha", "hbar", "c", "E_n", "theta", "A" } : new[] { "Z_1", "Z_2", "alpha", "hbar", "c", "E_n", "theta", "A", "A_noise" }; }
    4040    }
    4141
     
    8080      }
    8181
    82       if (noiseRatio != null) {
    83         var A_noise     = new List<double>();
    84         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * A.StandardDeviationPop();
    85         A_noise.AddRange(A.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    86         data.Remove(A);
    87         data.Add(A_noise);
    88       }
     82      var targetNoise = GetNoisyTarget(A, rand);
     83      if (targetNoise != null) data.Add(targetNoise);
    8984
    9085      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus10.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"d", "G", "m1", "m2", noiseRatio == null ? "t" : "t_noise"}; }
     38      get { return noiseRatio == null ? new[] { "d", "G", "m1", "m2", "t" } : new[] { "d", "G", "m1", "m2", "t", "t_noise" }; }
    3939    }
    4040
     
    7070      }
    7171
    72       if (noiseRatio != null) {
    73         var t_noise     = new List<double>();
    74         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * t.StandardDeviationPop();
    75         t_noise.AddRange(t.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    76         data.Remove(t);
    77         data.Add(t_noise);
    78       }
     72      var targetNoise = GetNoisyTarget(t, rand);
     73      if (targetNoise != null) data.Add(targetNoise);
    7974
    8075      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus11.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get {
    40         return new[] {"epsilon", "L", "m", "Z_1", "Z_2", "q", "E_n", noiseRatio == null ? "alpha" : "alpha_noise"};
    41       }
     39      get { return noiseRatio == null ? new[] { "epsilon", "L", "m", "Z_1", "Z_2", "q", "E_n", "alpha" } : new[] { "epsilon", "L", "m", "Z_1", "Z_2", "q", "E_n", "alpha", "alpha_noise" }; }
    4240    }
    4341
     
    8280      }
    8381
    84       if (noiseRatio != null) {
    85         var alpha_noise = new List<double>();
    86         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * alpha.StandardDeviationPop();
    87         alpha_noise.AddRange(alpha.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    88         data.Remove(alpha);
    89         data.Add(alpha_noise);
    90       }
     82      var targetNoise = GetNoisyTarget(alpha, rand);
     83      if (targetNoise != null) data.Add(targetNoise);
    9184
    9285      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus12.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"m", "c", "p", "q", "A_vec", "Volt", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     39      get { return noiseRatio == null ? new[] { "m", "c", "p", "q", "A_vec", "Volt", "E_n" } : new[] { "m", "c", "p", "q", "A_vec", "Volt", "E_n", "E_n_noise" }; }
    4040    }
    4141
     
    7676      }
    7777
    78       if (noiseRatio != null) {
    79         var E_n_noise   = new List<double>();
    80         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    81         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    82         data.Remove(E_n);
    83         data.Add(E_n_noise);
    84       }
     78      var targetNoise = GetNoisyTarget(E_n, rand);
     79      if (targetNoise != null) data.Add(targetNoise);
    8580
    8681      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus13.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"m", "omega", "p", "y", "x", "alpha", noiseRatio == null ? "E_n" : "E_n_noise"}; }
     39      get { return noiseRatio == null ? new[] { "m", "omega", "p", "y", "x", "alpha", "E_n" } : new[] { "m", "omega", "p", "y", "x", "alpha", "E_n", "E_n_noise" }; }
    4040    }
    4141
     
    7777      }
    7878
    79       if (noiseRatio != null) {
    80         var E_n_noise   = new List<double>();
    81         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * E_n.StandardDeviationPop();
    82         E_n_noise.AddRange(E_n.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    83         data.Remove(E_n);
    84         data.Add(E_n_noise);
    85       }
     79      var targetNoise = GetNoisyTarget(E_n, rand);
     80      if (targetNoise != null) data.Add(targetNoise);
    8681
    8782      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus14.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"q", "y", "Volt", "d", "epsilon", noiseRatio == null ? "F" : "F_noise"}; }
     39      get { return noiseRatio == null ? new[] { "q", "y", "Volt", "d", "epsilon", "F" } : new[] { "q", "y", "Volt", "d", "epsilon", "F", "F_noise"}; }
    4040    }
    4141
     
    7575      }
    7676
    77       if (noiseRatio != null) {
    78         var F_noise     = new List<double>();
    79         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * F.StandardDeviationPop();
    80         F_noise.AddRange(F.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    81         data.Remove(F);
    82         data.Add(F_noise);
    83       }
     77      var targetNoise = GetNoisyTarget(F, rand);
     78      if (targetNoise != null) data.Add(targetNoise);
    8479
    8580      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus15.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"q", "r", "d", "alpha", noiseRatio == null ? "Volt" : "Volt_noise"}; }
     39      get { return noiseRatio == null ? new[] { "q", "r", "d", "alpha", "Volt" } : new[] { "q", "r", "d", "alpha", "Volt", "Volt_noise" }; }
    4040    }
    4141
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var Volt_noise  = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Volt.StandardDeviationPop();
    77         Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(Volt);
    79         data.Add(Volt_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(Volt, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus16.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"Ef", "theta", "r", "d", "alpha", noiseRatio == null ? "Volt" : "Volt_noise"}; }
     39      get { return noiseRatio == null ? new[] { "Ef", "theta", "r", "d", "alpha", "Volt" } : new[] { "Ef", "theta", "r", "d", "alpha", "Volt", "Volt_noise" }; }
    4040    }
    4141
     
    7474      }
    7575
    76       if (noiseRatio != null) {
    77         var Volt_noise  = new List<double>();
    78         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Volt.StandardDeviationPop();
    79         Volt_noise.AddRange(Volt.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    80         data.Remove(Volt);
    81         data.Add(Volt_noise);
    82       }
     76      var targetNoise = GetNoisyTarget(Volt, rand);
     77      if (targetNoise != null) data.Add(targetNoise);
    8378
    8479      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus17.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"c", "v", "omega", "theta", noiseRatio == null ? "omega_0" : "omega_0_noise"}; }
     39      get { return noiseRatio == null ? new[] { "c", "v", "omega", "theta", "omega_0" } : new[] { "c", "v", "omega", "theta", "omega_0", "omega_0_noise"}; }
    4040    }
    4141
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var omega_0_noise = new List<double>();
    76         var sigma_noise   = (double) Math.Sqrt(noiseRatio.Value) * omega_0.StandardDeviationPop();
    77         omega_0_noise.AddRange(omega_0.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(omega_0);
    79         data.Add(omega_0_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(omega_0, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus18.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"G", "k_f", "r", "H_G", "c", noiseRatio == null ? "rho_0" : "rho_0_noise"}; }
     38      get { return noiseRatio == null ? new[] { "G", "k_f", "r", "H_G", "c", "rho_0" } : new[] { "G", "k_f", "r", "H_G", "c", "rho_0", "rho_0_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var rho_0_noise = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * rho_0.StandardDeviationPop();
    77         rho_0_noise.AddRange(rho_0.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(rho_0);
    79         data.Add(rho_0_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(rho_0, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus19.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"G", "k_f", "r", "H_G", "alpha", "c", noiseRatio == null ? "pr" : "pr_noise"}; }
     39      get { return noiseRatio == null ? new[] { "G", "k_f", "r", "H_G", "alpha", "c", "pr" } : new[] { "G", "k_f", "r", "H_G", "alpha", "c", "pr", "pr_noise" }; }
    4040    }
    4141
     
    7676      }
    7777
    78       if (noiseRatio != null) {
    79         var pr_noise    = new List<double>();
    80         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * pr.StandardDeviationPop();
    81         pr_noise.AddRange(pr.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    82         data.Remove(pr);
    83         data.Add(pr_noise);
    84       }
     78      var targetNoise = GetNoisyTarget(pr, rand);
     79      if (targetNoise != null) data.Add(targetNoise);
    8580
    8681      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus2.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"G", "rho", "alpha", "c", "d", noiseRatio == null ? "H_G" : "H_G_noise"}; }
     38      get { return noiseRatio == null ? new[] { "G", "rho", "alpha", "c", "d", "H_G" } : new[] { "G", "rho", "alpha", "c", "d", "H_G", "H_G_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var H_G_noise   = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * H_G.StandardDeviationPop();
    77         H_G_noise.AddRange(H_G.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(H_G);
    79         data.Add(H_G_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(H_G, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus20.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"omega", "omega_0", "alpha", "h", "m", "c", "beta", noiseRatio == null ? "A" : "A_noise"}; }
     39      get { return noiseRatio == null ? new[] { "omega", "omega_0", "alpha", "h", "m", "c", "beta", "A" } : new[] { "omega", "omega_0", "alpha", "h", "m", "c", "beta", "A", "A_noise" }; }
    4040    }
    4141
     
    8181      }
    8282
    83       if (noiseRatio != null) {
    84         var A_noise     = new List<double>();
    85         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * A.StandardDeviationPop();
    86         A_noise.AddRange(A.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    87         data.Remove(A);
    88         data.Add(A_noise);
    89       }
     83      var targetNoise = GetNoisyTarget(A, rand);
     84      if (targetNoise != null) data.Add(targetNoise);
    9085
    9186      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus3.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"E_n", "m", "c", "theta", noiseRatio == null ? "K" : "K_noise"}; }
     39      get { return noiseRatio == null ? new[] { "E_n", "m", "c", "theta", "K" } : new[] { "E_n", "m", "c", "theta", "K", "K_noise" }; }
    4040    }
    4141
     
    7171      }
    7272
    73       if (noiseRatio != null) {
    74         var K_noise     = new List<double>();
    75         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * K.StandardDeviationPop();
    76         K_noise.AddRange(K.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    77         data.Remove(K);
    78         data.Add(K_noise);
    79       }
     73      var targetNoise = GetNoisyTarget(K, rand);
     74      if (targetNoise != null) data.Add(targetNoise);
    8075
    8176      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus4.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"G", "c", "m1", "m2", "r", noiseRatio == null ? "Pwr" : "Pwr_noise"}; }
     39      get { return noiseRatio == null ? new[] { "G", "c", "m1", "m2", "r", "Pwr" } : new[] { "G", "c", "m1", "m2", "r", "Pwr", "Pwr_noise" }; }
    4040    }
    4141
     
    7474      }
    7575
    76       if (noiseRatio != null) {
    77         var Pwr_noise   = new List<double>();
    78         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * Pwr.StandardDeviationPop();
    79         Pwr_noise.AddRange(Pwr.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    80         data.Remove(Pwr);
    81         data.Add(Pwr_noise);
    82       }
     76      var targetNoise = GetNoisyTarget(Pwr, rand);
     77      if (targetNoise != null) data.Add(targetNoise);
    8378
    8479      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus5.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"c", "v", "theta2", noiseRatio == null ? "theta1" : "theta1_noise"}; }
     39      get { return noiseRatio == null ? new[] { "c", "v", "theta2", "theta1" } : new[] { "c", "v", "theta2", "theta1", "theta1_noise" }; }
    4040    }
    4141
     
    6969      }
    7070
    71       if (noiseRatio != null) {
    72         var theta1_noise = new List<double>();
    73         var sigma_noise  = (double) Math.Sqrt(noiseRatio.Value) * theta1.StandardDeviationPop();
    74         theta1_noise.AddRange(theta1.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    75         data.Remove(theta1);
    76         data.Add(theta1_noise);
    77       }
     71      var targetNoise = GetNoisyTarget(theta1, rand);
     72      if (targetNoise != null) data.Add(targetNoise);
    7873
    7974      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus6.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"I_0", "alpha", "delta", "n", noiseRatio == null ? "I" : "I_noise"}; }
     39      get { return noiseRatio == null ? new[] { "I_0", "alpha", "delta", "n", "I" } : new[] { "I_0", "alpha", "delta", "n", "I", "I_noise" }; }
    4040    }
    4141
     
    7373      }
    7474
    75       if (noiseRatio != null) {
    76         var I_noise     = new List<double>();
    77         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * I.StandardDeviationPop();
    78         I_noise.AddRange(I.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    79         data.Remove(I);
    80         data.Add(I_noise);
    81       }
     75      var targetNoise = GetNoisyTarget(I, rand);
     76      if (targetNoise != null) data.Add(targetNoise);
    8277
    8378      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus7.cs

    r17966 r17973  
    3636
    3737    protected override string[] VariableNames {
    38       get { return new[] {"m", "E_n", "U", "L", "r", noiseRatio == null ? "v" : "v_noise"}; }
     38      get { return noiseRatio == null ? new[] { "m", "E_n", "U", "L", "r", "v" } : new[] { "m", "E_n", "U", "L", "r", "v", "v_noise" }; }
    3939    }
    4040
     
    7272      }
    7373
    74       if (noiseRatio != null) {
    75         var v_noise     = new List<double>();
    76         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * v.StandardDeviationPop();
    77         v_noise.AddRange(v.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    78         data.Remove(v);
    79         data.Add(v_noise);
    80       }
     74      var targetNoise = GetNoisyTarget(v, rand);
     75      if (targetNoise != null) data.Add(targetNoise);
    8176
    8277      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus8.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"m", "k_G", "L", "E_n", "theta1", "theta2", noiseRatio == null ? "k" : "k_noise"}; }
     39      get { return noiseRatio == null ? new[] { "m", "k_G", "L", "E_n", "theta1", "theta2", "k" } : new[] { "m", "k_G", "L", "E_n", "theta1", "theta2", "k", "k_noise" }; }
    4040    }
    4141
     
    7979      }
    8080
    81       if (noiseRatio != null) {
    82         var k_noise     = new List<double>();
    83         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * k.StandardDeviationPop();
    84         k_noise.AddRange(k.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    85         data.Remove(k);
    86         data.Add(k_noise);
    87       }
     81      var targetNoise = GetNoisyTarget(k, rand);
     82      if (targetNoise != null) data.Add(targetNoise);
    8883
    8984      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanBonus9.cs

    r17966 r17973  
    3737
    3838    protected override string[] VariableNames {
    39       get { return new[] {"d", "alpha", "theta1", "theta2", noiseRatio == null ? "r" : "r_noise"}; }
     39      get { return noiseRatio == null ? new[] { "d", "alpha", "theta1", "theta2", "r" } : new[] { "d", "alpha", "theta1", "theta2", "r", "r_noise" }; }
    4040    }
    4141
     
    7171      }
    7272
    73       if (noiseRatio != null) {
    74         var r_noise     = new List<double>();
    75         var sigma_noise = (double) Math.Sqrt(noiseRatio.Value) * r.StandardDeviationPop();
    76         r_noise.AddRange(r.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigma_noise)));
    77         data.Remove(r);
    78         data.Add(r_noise);
    79       }
     73      var targetNoise = GetNoisyTarget(r, rand);
     74      if (targetNoise != null) data.Add(targetNoise);
    8075
    8176      return data;
  • trunk/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Feynman/FeynmanDescriptor.cs

    r17647 r17973  
    44using System.Text;
    55using System.Threading.Tasks;
     6using HeuristicLab.Common;
     7using HeuristicLab.Core;
     8using HeuristicLab.Random;
    69
    710namespace HeuristicLab.Problems.Instances.DataAnalysis {
     
    1417    }
    1518
     19    public List<double> GetNoisyTarget(List<double> target, IRandom rand) {
     20      if (noiseRatio == null) return null;
     21
     22      var targetNoise = new List<double>();
     23      var sigmaNoise = Math.Sqrt(noiseRatio.Value) * target.StandardDeviationPop();
     24      targetNoise.AddRange(target.Select(md => md + NormalDistributedRandomPolar.NextDouble(rand, 0, sigmaNoise)));
     25      return targetNoise;
     26
     27    }
     28
    1629    protected override int TrainingPartitionStart { get { return 0; } }
    1730    protected override int TrainingPartitionEnd { get { return 100; } }
Note: See TracChangeset for help on using the changeset viewer.