Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceLinear.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceLinear.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceLinear.cs	(revision 8430)
@@ -0,0 +1,119 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "CovarianceLinear", Description = "Linear covariance function for Gaussian processes.")]
+  public class CovarianceLinear : Item, ICovarianceFunction {
+    private static readonly double[] emptyArray = new double[0];
+
+    [Storable]
+    private double[,] x;
+    [Storable]
+    private double[,] xt;
+
+    private double[,] k;
+    private bool symmetric;
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return 0;
+    }
+    [StorableConstructor]
+    protected CovarianceLinear(bool deserializing) : base(deserializing) { }
+    protected CovarianceLinear(CovarianceLinear original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.x != null) {
+        this.x = new double[original.x.GetLength(0), original.x.GetLength(1)];
+        Array.Copy(original.x, this.x, x.Length);
+
+        this.xt = new double[original.xt.GetLength(0), original.xt.GetLength(1)];
+        Array.Copy(original.xt, this.xt, xt.Length);
+
+        this.k = new double[original.k.GetLength(0), original.k.GetLength(1)];
+        Array.Copy(original.k, this.k, k.Length);
+      }
+      this.symmetric = original.symmetric;
+    }
+    public CovarianceLinear()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovarianceLinear(this, cloner);
+    }
+
+    public void SetParameter(double[] hyp) {
+      if (hyp.Length > 0) throw new ArgumentException("No hyperparameters are allowed for the linear covariance function.");
+      k = null;
+    }
+
+    public void SetData(double[,] x) {
+      SetData(x, x);
+      this.symmetric = true;
+    }
+
+    public void SetData(double[,] x, double[,] xt) {
+      this.x = x;
+      this.xt = xt;
+      this.symmetric = false;
+
+      k = null;
+    }
+
+    public double GetCovariance(int i, int j) {
+      if (k == null) CalculateInnerProduct();
+      return k[i, j];
+    }
+
+    public double[] GetGradient(int i, int j) {
+      return emptyArray;
+    }
+
+
+    private void CalculateInnerProduct() {
+      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      int cols = xt.GetLength(0);
+      k = new double[rows, cols];
+      if (symmetric) {
+        for (int i = 0; i < rows; i++) {
+          for (int j = i; j < cols; j++) {
+            k[i, j] = Util.ScalarProd(Util.GetRow(x, i),
+                                      Util.GetRow(x, j));
+            k[j, i] = k[i, j];
+          }
+        }
+      } else {
+        for (int i = 0; i < rows; i++) {
+          for (int j = 0; j < cols; j++) {
+            k[i, j] = Util.ScalarProd(Util.GetRow(x, i),
+                                      Util.GetRow(xt, j));
+          }
+        }
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceNNOne.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceNNOne.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceNNOne.cs	(revision 8430)
@@ -0,0 +1,128 @@
+﻿using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.GaussianProcess {
+  public class CovarianceNNOne : ICovarianceFunction {
+    private double[,] x;
+    private double[,] xt;
+    private double sf2;
+    private double l2;
+    private double[,] S;
+    private double[] sx;
+    private double[] sz;
+    private double sxsx;
+    private double sxsz;
+
+    public int NumberOfParameters {
+      get { return 2; }
+    }
+
+    public void SetMatrix(double[,] x) {
+      SetMatrix(x, x);
+    }
+
+    public void SetMatrix(double[,] x, double[,] xt) {
+      this.x = x;
+      this.xt = xt;
+      S = null;
+      sx = null;
+      sz = null;
+    }
+
+    public void SetHyperparamter(double[] hyp) {
+      if (hyp.Length != 2) throw new ArgumentException();
+      this.l2 = Math.Exp(2 * hyp[0]);
+      this.sf2 = Math.Exp(2 * hyp[1]);
+      S = null;
+      sx = null;
+      sz = null;
+    }
+
+    public double GetCovariance(int i, int j) {
+      if (S == null) CalculateVectorProducts();
+      if (sx == null) CalculateSx();
+      bool symmetric = x == xt;
+      double k;
+      if (symmetric) {
+        k = S[i, j] / sxsx;
+      } else {
+        k = S[i, j] / sxsz;
+      }
+      return sf2 * Math.Asin(k);
+    }
+
+
+    public double[] GetDiagonalCovariances() {
+      if (x != xt) throw new InvalidOperationException();
+      if (sx == null) CalculateSx();
+      int rows = x.GetLength(0);
+      var k = new double[rows];
+      for (int i = 0; i < rows; i++) {
+        k[i] = sx[i] / (sx[i] + l2);
+        k[i] = sf2 * Math.Asin(k[i]);
+      }
+      return k;
+    }
+
+    public double[] GetDerivatives(int i, int j) {
+      double[] dhyp = new double[NumberOfParameters];
+      double[] vx = sx.Select(e => e / (l2 + e) / 2).ToArray();
+
+      double k;
+      double v;
+      if (x == xt) {
+        k = S[i, j] / sxsx;
+        v = vx[i] + vx[j];
+      } else {
+        double[] vz = sz.Select(e => e / (l2 + e) / 2).ToArray();
+        v = vx[i] + vz[j];
+        k = S[i, j] / sxsz;
+      }
+      dhyp[0] = -2 * sf2 * (k - k * v) / Math.Sqrt(1 - k * k);
+      dhyp[1] = 2.0 * sf2 * Math.Asin(k);
+      return dhyp;
+    }
+
+    private void CalculateSx() {
+      this.sx = new double[x.GetLength(0)];
+      for (int i = 0; i < sx.Length; i++) {
+        sx[i] = 1 + Product(GetRow(x, i), GetRow(x, i));
+      }
+      this.sz = new double[xt.GetLength(0)];
+      for (int i = 0; i < sz.Length; i++) {
+        sz[i] = 1 + Product(GetRow(xt, i), GetRow(xt, i));
+      }
+
+      sxsx = Product(sx.Select(e => Math.Sqrt(l2 + e)), sx.Select(e => Math.Sqrt(l2 + e)));
+      sxsz = Product(sx.Select(e => Math.Sqrt(l2 + e)), sz.Select(e => Math.Sqrt(l2 + e)));
+    }
+
+    private void CalculateVectorProducts() {
+      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      int cols = xt.GetLength(0);
+      S = new double[rows, cols];
+      bool symmetric = x == xt;
+      for (int i = 0; i < rows; i++) {
+        for (int j = i; j < rows; j++) {
+          S[i, j] = 1 + Product(GetRow(x, i), GetRow(xt, j));
+          if (symmetric) {
+            S[j, i] = S[i, j];
+          } else {
+            S[j, i] = 1 + Product(GetRow(x, j), GetRow(xt, i));
+          }
+        }
+      }
+    }
+
+
+    private double Product(IEnumerable<double> x, IEnumerable<double> y) {
+      return x.Zip(y, (a, b) => a * b).Sum();
+    }
+    private static IEnumerable<double> GetRow(double[,] x, int r) {
+      int cols = x.GetLength(1);
+      return Enumerable.Range(0, cols).Select(c => x[r, c]);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovariancePeriodic.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovariancePeriodic.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovariancePeriodic.cs	(revision 8430)
@@ -0,0 +1,164 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "CovariancePeriodic", Description = "Periodic covariance function for Gaussian processes.")]
+  public class CovariancePeriodic : Item, ICovarianceFunction {
+    [Storable]
+    private double[,] x;
+    [Storable]
+    private double[,] xt;
+    [Storable]
+    private double sf2;
+    [Storable]
+    private double l;
+    [Storable]
+    private double p;
+
+    private bool symmetric;
+
+    private double[,] sd;
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return 3;
+    }
+    [StorableConstructor]
+    protected CovariancePeriodic(bool deserializing) : base(deserializing) { }
+    protected CovariancePeriodic(CovariancePeriodic original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.x != null) {
+        x = new double[original.x.GetLength(0), original.x.GetLength(1)];
+        Array.Copy(original.x, x, x.Length);
+        xt = new double[original.xt.GetLength(0), original.xt.GetLength(1)];
+        Array.Copy(original.xt, xt, xt.Length);
+      }
+      sf2 = original.sf2;
+      l = original.l;
+      p = original.p;
+      symmetric = original.symmetric;
+    }
+    public CovariancePeriodic()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovariancePeriodic(this, cloner);
+    }
+
+    public void SetParameter(double[] hyp) {
+      if (hyp.Length != 3) throw new ArgumentException();
+      this.l = Math.Exp(hyp[0]);
+      this.p = Math.Exp(hyp[1]);
+      this.sf2 = Math.Exp(2 * hyp[2]);
+
+      sf2 = Math.Min(10E6, sf2); // upper limit for the scale
+
+      sd = null;
+    }
+    public void SetData(double[,] x) {
+      SetData(x, x);
+      this.symmetric = true;
+    }
+
+    public void SetData(double[,] x, double[,] xt) {
+      this.x = x;
+      this.xt = xt;
+      this.symmetric = false;
+
+      sd = null;
+    }
+
+    public double GetCovariance(int i, int j) {
+      if (sd == null) CalculateSquaredDistances();
+      double k = sd[i, j];
+      k = Math.PI * k / p;
+      k = Math.Sin(k) / l;
+      k = k * k;
+
+      return sf2 * Math.Exp(-2.0 * k);
+    }
+
+
+    public double[] GetDiagonalCovariances() {
+      if (x != xt) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      var cov = new double[rows];
+      for (int i = 0; i < rows; i++) {
+        double k = Math.Sqrt(Util.SqrDist(Util.GetRow(x, i), Util.GetRow(xt, i)));
+        k = Math.PI * k / p;
+        k = Math.Sin(k) / l;
+        k = k * k;
+        cov[i] = sf2 * Math.Exp(-2.0 * k);
+      }
+      return cov;
+    }
+
+    public double[] GetGradient(int i, int j) {
+
+      var res = new double[3];
+      double k = sd[i, j];
+      k = Math.PI * k / p;
+      {
+        double newK = Math.Sin(k) / l;
+        newK = newK * newK;
+        res[0] = 4 * sf2 * Math.Exp(-2 * newK) * newK;
+      }
+      {
+        double r = Math.Sin(k) / l;
+        res[1] = 4 * sf2 / l * Math.Exp(-2 * r * r) * r * Math.Cos(k) * k;
+      }
+      {
+        double newK = Math.Sin(k) / l;
+        newK = newK * newK;
+        res[2] = 2 * sf2 * Math.Exp(-2 * newK);
+      }
+
+      return res;
+    }
+
+    private void CalculateSquaredDistances() {
+      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      int cols = xt.GetLength(0);
+      sd = new double[rows, cols];
+
+      if (symmetric) {
+        for (int i = 0; i < rows; i++) {
+          for (int j = i; j < cols; j++) {
+            sd[i, j] = Math.Sqrt(Util.SqrDist(Util.GetRow(x, i), Util.GetRow(x, j)));
+            sd[j, i] = sd[i, j];
+          }
+        }
+      } else {
+        for (int i = 0; i < rows; i++) {
+          for (int j = 0; j < cols; j++) {
+            sd[i, j] = Math.Sqrt(Util.SqrDist(Util.GetRow(x, i), Util.GetRow(xt, j)));
+          }
+        }
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceProd.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceProd.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceProd.cs	(revision 8430)
@@ -0,0 +1,92 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "CovarianceProd",
+    Description = "Product covariance function for Gaussian processes.")]
+  public class CovarianceProd : Item, ICovarianceFunction {
+    [Storable]
+    private ItemList<ICovarianceFunction> factors;
+
+    [Storable]
+    private int numberOfVariables;
+    public ItemList<ICovarianceFunction> Factors {
+      get { return factors; }
+    }
+
+    [StorableConstructor]
+    protected CovarianceProd(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected CovarianceProd(CovarianceProd original, Cloner cloner)
+      : base(original, cloner) {
+      this.factors = cloner.Clone(original.factors);
+      this.numberOfVariables = original.numberOfVariables;
+    }
+
+    public CovarianceProd()
+      : base() {
+      this.factors = new ItemList<ICovarianceFunction>();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovarianceProd(this, cloner);
+    }
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      this.numberOfVariables = numberOfVariables;
+      return factors.Select(t => t.GetNumberOfParameters(numberOfVariables)).Sum();
+    }
+
+    public void SetParameter(double[] hyp) {
+      int offset = 0;
+      foreach (var t in factors) {
+        var numberOfParameters = t.GetNumberOfParameters(numberOfVariables);
+        t.SetParameter(hyp.Skip(offset).Take(numberOfParameters).ToArray());
+        offset += numberOfParameters;
+      }
+    }
+    public void SetData(double[,] x) {
+      SetData(x, x);
+    }
+
+    public void SetData(double[,] x, double[,] xt) {
+      foreach (var t in factors) {
+        t.SetData(x, xt);
+      }
+    }
+
+    public double GetCovariance(int i, int j) {
+      return factors.Select(t => t.GetCovariance(i, j)).Aggregate((a, b) => a * b);
+    }
+
+    public double[] GetGradient(int i, int j) {
+      return factors.Select(t => t.GetGradient(i, j)).SelectMany(seq => seq).ToArray();
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSEard.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSEard.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSEard.cs	(revision 8430)
@@ -0,0 +1,136 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "CovarianceSEard", Description = "Squared exponential covariance function with automatic relevance determination for Gaussian processes.")]
+  public class CovarianceSEard : Item, ICovarianceFunction {
+    [Storable]
+    private double[,] x;
+    [Storable]
+    private double[,] xt;
+    [Storable]
+    private double sf2;
+    [Storable]
+    private double[] l;
+
+    private double[,] sd;
+    private bool symmetric;
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return numberOfVariables + 1;
+    }
+    [StorableConstructor]
+    protected CovarianceSEard(bool deserializing) : base(deserializing) { }
+    protected CovarianceSEard(CovarianceSEard original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.x != null) {
+        this.x = new double[original.x.GetLength(0), original.x.GetLength(1)];
+        Array.Copy(original.x, this.x, x.Length);
+
+        this.xt = new double[original.xt.GetLength(0), original.xt.GetLength(1)];
+        Array.Copy(original.xt, this.xt, xt.Length);
+
+        this.sd = new double[original.sd.GetLength(0), original.sd.GetLength(1)];
+        Array.Copy(original.sd, this.sd, sd.Length);
+
+        this.l = new double[original.l.Length];
+        Array.Copy(original.l, this.l, l.Length);
+      }
+      this.sf2 = original.sf2;
+      this.symmetric = original.symmetric;
+    }
+    public CovarianceSEard()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovarianceSEard(this, cloner);
+    }
+
+    public void SetParameter(double[] hyp) {
+      this.l = hyp.Take(hyp.Length - 1).Select(Math.Exp).ToArray();
+      this.sf2 = Math.Exp(2 * hyp[hyp.Length - 1]);
+      sf2 = Math.Min(10E6, sf2); // upper limit for the scale
+
+      sd = null;
+    }
+
+    public void SetData(double[,] x) {
+      SetData(x, x);
+      this.symmetric = true;
+    }
+
+    public void SetData(double[,] x, double[,] xt) {
+      this.x = x;
+      this.xt = xt;
+      this.symmetric = false;
+
+      sd = null;
+    }
+
+    public double GetCovariance(int i, int j) {
+      if (sd == null) CalculateSquaredDistances();
+      return sf2 * Math.Exp(-sd[i, j] / 2.0);
+    }
+
+    public double[] GetGradient(int i, int j) {
+      var res = new double[l.Length + 1];
+      for (int k = 0; k < l.Length; k++) {
+        double sqrDist = Util.SqrDist(x[i, k] / l[k], xt[j, k] / l[k]);
+
+        res[k] = sf2 * Math.Exp(-sd[i, j] / 2.0) * sqrDist;
+      }
+      res[res.Length - 1] = 2.0 * sf2 * Math.Exp(-sd[i, j] / 2.0);
+      return res;
+    }
+
+
+    private void CalculateSquaredDistances() {
+      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      int cols = xt.GetLength(0);
+      sd = new double[rows, cols];
+      if (symmetric) {
+        for (int i = 0; i < rows; i++) {
+          for (int j = i; j < cols; j++) {
+            sd[i, j] = Util.SqrDist(Util.GetRow(x, i).Select((e, k) => e / l[k]),
+                                    Util.GetRow(xt, j).Select((e, k) => e / l[k]));
+            sd[j, i] = sd[i, j];
+          }
+        }
+      } else {
+        for (int i = 0; i < rows; i++) {
+          for (int j = 0; j < cols; j++) {
+            sd[i, j] = Util.SqrDist(Util.GetRow(x, i).Select((e, k) => e / l[k]),
+                                    Util.GetRow(xt, j).Select((e, k) => e / l[k]));
+          }
+        }
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSEiso.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSEiso.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSEiso.cs	(revision 8430)
@@ -0,0 +1,131 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "CovarianceSEiso",
+    Description = "Isotropic squared exponential covariance function for Gaussian processes.")]
+  public class CovarianceSEiso : Item, ICovarianceFunction {
+    [Storable]
+    private double[,] x;
+    [Storable]
+    private double[,] xt;
+    [Storable]
+    private double sf2;
+    [Storable]
+    private double l;
+    [Storable]
+    private bool symmetric;
+    private double[,] sd;
+
+    [StorableConstructor]
+    protected CovarianceSEiso(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected CovarianceSEiso(CovarianceSEiso original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.x != null) {
+        this.x = new double[original.x.GetLength(0), original.x.GetLength(1)];
+        Array.Copy(original.x, this.x, x.Length);
+
+        this.xt = new double[original.xt.GetLength(0), original.xt.GetLength(1)];
+        Array.Copy(original.xt, this.xt, xt.Length);
+
+        this.sd = new double[original.sd.GetLength(0), original.sd.GetLength(1)];
+        Array.Copy(original.sd, this.sd, sd.Length);
+        this.sf2 = original.sf2;
+      }
+      this.sf2 = original.sf2;
+      this.l = original.l;
+      this.symmetric = original.symmetric;
+    }
+
+    public CovarianceSEiso()
+      : base() {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovarianceSEiso(this, cloner);
+    }
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return 2;
+    }
+
+    public void SetParameter(double[] hyp) {
+      this.l = Math.Exp(hyp[0]);
+      this.sf2 = Math.Min(1E6, Math.Exp(2 * hyp[1])); // upper limit for scale
+      sd = null;
+    }
+    public void SetData(double[,] x) {
+      SetData(x, x);
+      this.symmetric = true;
+    }
+
+
+    public void SetData(double[,] x, double[,] xt) {
+      this.symmetric = false;
+      this.x = x;
+      this.xt = xt;
+      sd = null;
+    }
+
+    public double GetCovariance(int i, int j) {
+      if (sd == null) CalculateSquaredDistances();
+      return sf2 * Math.Exp(-sd[i, j] / 2.0);
+    }
+
+    public double[] GetGradient(int i, int j) {
+      var res = new double[2];
+      res[0] = sf2 * Math.Exp(-sd[i, j] / 2.0) * sd[i, j];
+      res[1] = 2.0 * sf2 * Math.Exp(-sd[i, j] / 2.0);
+      return res;
+    }
+
+    private void CalculateSquaredDistances() {
+      if (x.GetLength(1) != xt.GetLength(1)) throw new InvalidOperationException();
+      int rows = x.GetLength(0);
+      int cols = xt.GetLength(0);
+      sd = new double[rows, cols];
+      if (symmetric) {
+        for (int i = 0; i < rows; i++) {
+          for (int j = i; j < rows; j++) {
+            sd[i, j] = Util.SqrDist(Util.GetRow(x, i).Select(e => e / l), Util.GetRow(xt, j).Select(e => e / l));
+            sd[j, i] = sd[i, j];
+          }
+        }
+      } else {
+        for (int i = 0; i < rows; i++) {
+          for (int j = 0; j < cols; j++) {
+            sd[i, j] = Util.SqrDist(Util.GetRow(x, i).Select(e => e / l), Util.GetRow(xt, j).Select(e => e / l));
+          }
+        }
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSum.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSum.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/CovarianceSum.cs	(revision 8430)
@@ -0,0 +1,92 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "CovarianceSum",
+    Description = "Sum covariance function for Gaussian processes.")]
+  public class CovarianceSum : Item, ICovarianceFunction {
+    [Storable]
+    private ItemList<ICovarianceFunction> terms;
+
+    [Storable]
+    private int numberOfVariables;
+    public ItemList<ICovarianceFunction> Terms {
+      get { return terms; }
+    }
+
+    [StorableConstructor]
+    protected CovarianceSum(bool deserializing)
+      : base(deserializing) {
+    }
+
+    protected CovarianceSum(CovarianceSum original, Cloner cloner)
+      : base(original, cloner) {
+      this.terms = cloner.Clone(original.terms);
+      this.numberOfVariables = original.numberOfVariables;
+    }
+
+    public CovarianceSum()
+      : base() {
+      this.terms = new ItemList<ICovarianceFunction>();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new CovarianceSum(this, cloner);
+    }
+
+    public int GetNumberOfParameters(int numberOfVariables) {
+      this.numberOfVariables = numberOfVariables;
+      return terms.Select(t => t.GetNumberOfParameters(numberOfVariables)).Sum();
+    }
+
+    public void SetParameter(double[] hyp) {
+      int offset = 0;
+      foreach (var t in terms) {
+        var numberOfParameters = t.GetNumberOfParameters(numberOfVariables);
+        t.SetParameter(hyp.Skip(offset).Take(numberOfParameters).ToArray());
+        offset += numberOfParameters;
+      }
+    }
+    public void SetData(double[,] x) {
+      SetData(x, x);
+    }
+
+    public void SetData(double[,] x, double[,] xt) {
+      foreach (var t in terms) {
+        t.SetData(x, xt);
+      }
+    }
+
+    public double GetCovariance(int i, int j) {
+      return terms.Select(t => t.GetCovariance(i, j)).Sum();
+    }
+
+    public double[] GetGradient(int i, int j) {
+      return terms.Select(t => t.GetGradient(i, j)).SelectMany(seq => seq).ToArray();
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessHyperparameterInitializer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessHyperparameterInitializer.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessHyperparameterInitializer.cs	(revision 8430)
@@ -0,0 +1,89 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "GaussianProcessHyperparameterInitializer",
+    Description = "Initializers the hyperparameter vector based on the mean function, covariance function, and number of allowed input variables.")]
+  public sealed class GaussianProcessHyperparameterInitializer : SingleSuccessorOperator {
+    private const string MeanFunctionParameterName = "MeanFunction";
+    private const string CovarianceFunctionParameterName = "CovarianceFunction";
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string HyperparameterParameterName = "Hyperparameter";
+
+    #region Parameter Properties
+    // in
+    public ILookupParameter<IMeanFunction> MeanFunctionParameter {
+      get { return (ILookupParameter<IMeanFunction>)Parameters[MeanFunctionParameterName]; }
+    }
+    public ILookupParameter<ICovarianceFunction> CovarianceFunctionParameter {
+      get { return (ILookupParameter<ICovarianceFunction>)Parameters[CovarianceFunctionParameterName]; }
+    }
+    public ILookupParameter<IDataAnalysisProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IDataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    // out
+    public ILookupParameter<RealVector> HyperparameterParameter {
+      get { return (ILookupParameter<RealVector>)Parameters[HyperparameterParameterName]; }
+    }
+    #endregion
+
+    #region Properties
+    private IMeanFunction MeanFunction { get { return MeanFunctionParameter.ActualValue; } }
+    private ICovarianceFunction CovarianceFunction { get { return CovarianceFunctionParameter.ActualValue; } }
+    private IDataAnalysisProblemData ProblemData { get { return ProblemDataParameter.ActualValue; } }
+    #endregion
+
+    [StorableConstructor]
+    private GaussianProcessHyperparameterInitializer(bool deserializing) : base(deserializing) { }
+    private GaussianProcessHyperparameterInitializer(GaussianProcessHyperparameterInitializer original, Cloner cloner) : base(original, cloner) { }
+    public GaussianProcessHyperparameterInitializer()
+      : base() {
+      // in
+      Parameters.Add(new LookupParameter<IMeanFunction>(MeanFunctionParameterName, "The mean function for the Gaussian process model."));
+      Parameters.Add(new LookupParameter<ICovarianceFunction>(CovarianceFunctionParameterName, "The covariance function for the Gaussian process model."));
+      Parameters.Add(new LookupParameter<IDataAnalysisProblemData>(ProblemDataParameterName, "The input data for the Gaussian process."));
+      // out
+      Parameters.Add(new LookupParameter<RealVector>(HyperparameterParameterName, "The initial hyperparameter vector for the Gaussian process model."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessHyperparameterInitializer(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var inputVariablesCount = ProblemData.AllowedInputVariables.Count();
+      int l = 1 + MeanFunction.GetNumberOfParameters(inputVariablesCount) +
+              CovarianceFunction.GetNumberOfParameters(inputVariablesCount);
+      HyperparameterParameter.ActualValue = new RealVector(l);
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModel.cs	(revision 8430)
@@ -0,0 +1,264 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  /// <summary>
+  /// Represents a Gaussian process model.
+  /// </summary>
+  [StorableClass]
+  [Item("GaussianProcessModel", "Represents a Gaussian process posterior.")]
+  public sealed class GaussianProcessModel : NamedItem, IGaussianProcessModel {
+    [Storable]
+    private double negativeLogLikelihood;
+    public double NegativeLogLikelihood {
+      get { return negativeLogLikelihood; }
+    }
+
+    [Storable]
+    private ICovarianceFunction covarianceFunction;
+    public ICovarianceFunction CovarianceFunction {
+      get { return covarianceFunction; }
+    }
+    [Storable]
+    private IMeanFunction meanFunction;
+    public IMeanFunction MeanFunction {
+      get { return meanFunction; }
+    }
+    [Storable]
+    private string targetVariable;
+    public string TargetVariable {
+      get { return targetVariable; }
+    }
+    [Storable]
+    private string[] allowedInputVariables;
+    public string[] AllowedInputVariables {
+      get { return allowedInputVariables; }
+    }
+
+    [Storable]
+    private double[] alpha;
+    [Storable]
+    private double sqrSigmaNoise;
+
+    [Storable]
+    private double[,] l;
+
+    [Storable]
+    private double[,] x;
+    [Storable]
+    private Scaling scaling;
+
+
+    [StorableConstructor]
+    private GaussianProcessModel(bool deserializing) : base(deserializing) { }
+    private GaussianProcessModel(GaussianProcessModel original, Cloner cloner)
+      : base(original, cloner) {
+      this.meanFunction = cloner.Clone(original.meanFunction);
+      this.covarianceFunction = cloner.Clone(original.covarianceFunction);
+      this.scaling = cloner.Clone(original.scaling);
+      this.negativeLogLikelihood = original.negativeLogLikelihood;
+      this.targetVariable = original.targetVariable;
+      this.sqrSigmaNoise = original.sqrSigmaNoise;
+
+      // shallow copies of arrays because they cannot be modified
+      this.allowedInputVariables = original.allowedInputVariables;
+      this.alpha = original.alpha;
+      this.l = original.l;
+      this.x = original.x;
+    }
+    public GaussianProcessModel(Dataset ds, string targetVariable, IEnumerable<string> allowedInputVariables, IEnumerable<int> rows,
+      IEnumerable<double> hyp, IMeanFunction meanFunction, ICovarianceFunction covarianceFunction)
+      : base() {
+      this.name = ItemName;
+      this.description = ItemDescription;
+      this.meanFunction = (IMeanFunction)meanFunction.Clone();
+      this.covarianceFunction = (ICovarianceFunction)covarianceFunction.Clone();
+      this.targetVariable = targetVariable;
+      this.allowedInputVariables = allowedInputVariables.ToArray();
+
+      sqrSigmaNoise = Math.Exp(2.0 * hyp.First());
+      sqrSigmaNoise = Math.Max(10E-6, sqrSigmaNoise); // lower limit for the noise level
+
+      int nVariables = this.allowedInputVariables.Length;
+      this.meanFunction.SetParameter(hyp.Skip(1)
+        .Take(this.meanFunction.GetNumberOfParameters(nVariables))
+        .ToArray());
+      this.covarianceFunction.SetParameter(hyp.Skip(1 + this.meanFunction.GetNumberOfParameters(nVariables))
+        .Take(this.covarianceFunction.GetNumberOfParameters(nVariables))
+        .ToArray());
+
+      CalculateModel(ds, rows);
+    }
+
+    private void CalculateModel(Dataset ds, IEnumerable<int> rows) {
+      scaling = new Scaling(ds, allowedInputVariables, rows);
+      x = AlglibUtil.PrepareAndScaleInputMatrix(ds, allowedInputVariables, rows, scaling);
+
+      var y = ds.GetDoubleValues(targetVariable, rows).ToArray();
+
+      int n = x.GetLength(0);
+      l = new double[n, n];
+
+      meanFunction.SetData(x);
+      covarianceFunction.SetData(x);
+
+      // calculate means and covariances
+      double[] m = meanFunction.GetMean(x);
+      for (int i = 0; i < n; i++) {
+
+        for (int j = i; j < n; j++) {
+          l[j, i] = covarianceFunction.GetCovariance(i, j) / sqrSigmaNoise;
+          if (j == i) l[j, i] += 1.0;
+        }
+      }
+
+      // cholesky decomposition
+      int info;
+      alglib.densesolverreport denseSolveRep;
+
+      var res = alglib.trfac.spdmatrixcholesky(ref l, n, false);
+      if (!res) throw new InvalidOperationException("Matrix is not positive semidefinite");
+
+      // calculate sum of diagonal elements for likelihood
+      double diagSum = Enumerable.Range(0, n).Select(i => Math.Log(l[i, i])).Sum();
+
+      // solve for alpha
+      double[] ym = y.Zip(m, (a, b) => a - b).ToArray();
+
+      alglib.spdmatrixcholeskysolve(l, n, false, ym, out info, out denseSolveRep, out alpha);
+      for (int i = 0; i < alpha.Length; i++)
+        alpha[i] = alpha[i] / sqrSigmaNoise;
+      negativeLogLikelihood = 0.5 * Util.ScalarProd(ym, alpha) + diagSum + (n / 2.0) * Math.Log(2.0 * Math.PI * sqrSigmaNoise);
+    }
+
+    public double[] GetHyperparameterGradients() {
+      // derivatives
+      int n = x.GetLength(0);
+      int nAllowedVariables = x.GetLength(1);
+      double[,] q = new double[n, n];
+      double[,] eye = new double[n, n];
+      for (int i = 0; i < n; i++) eye[i, i] = 1.0;
+
+      int info;
+      alglib.densesolverreport denseSolveRep;
+
+      alglib.spdmatrixcholeskysolvem(l, n, false, eye, n, out info, out denseSolveRep, out q);
+      // double[,] a2 = outerProd(alpha, alpha);
+      for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++)
+          q[i, j] = q[i, j] / sqrSigmaNoise - alpha[i] * alpha[j]; // a2[i, j];
+      }
+
+      double noiseGradient = sqrSigmaNoise * Enumerable.Range(0, n).Select(i => q[i, i]).Sum();
+
+      double[] meanGradients = new double[meanFunction.GetNumberOfParameters(nAllowedVariables)];
+      for (int i = 0; i < meanGradients.Length; i++) {
+        var meanGrad = meanFunction.GetGradients(i, x);
+        meanGradients[i] = -Util.ScalarProd(meanGrad, alpha);
+      }
+
+      double[] covGradients = new double[covarianceFunction.GetNumberOfParameters(nAllowedVariables)];
+      if (covGradients.Length > 0) {
+        for (int i = 0; i < n; i++) {
+          for (int j = 0; j < n; j++) {
+            var covDeriv = covarianceFunction.GetGradient(i, j);
+            for (int k = 0; k < covGradients.Length; k++) {
+              covGradients[k] += q[i, j] * covDeriv[k];
+            }
+          }
+        }
+        covGradients = covGradients.Select(g => g / 2.0).ToArray();
+      }
+
+      return new double[] { noiseGradient }
+        .Concat(meanGradients)
+        .Concat(covGradients).ToArray();
+    }
+
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessModel(this, cloner);
+    }
+
+    #region IRegressionModel Members
+    public IEnumerable<double> GetEstimatedValues(Dataset dataset, IEnumerable<int> rows) {
+      return GetEstimatedValuesHelper(dataset, rows);
+    }
+    public GaussianProcessRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData) {
+      return new GaussianProcessRegressionSolution(this, problemData);
+    }
+    IRegressionSolution IRegressionModel.CreateRegressionSolution(IRegressionProblemData problemData) {
+      return CreateRegressionSolution(problemData);
+    }
+    #endregion
+
+    private IEnumerable<double> GetEstimatedValuesHelper(Dataset dataset, IEnumerable<int> rows) {
+      var newX = AlglibUtil.PrepareAndScaleInputMatrix(dataset, allowedInputVariables, rows, scaling);
+      int newN = newX.GetLength(0);
+      int n = x.GetLength(0);
+      // var predMean = new double[newN];
+      // predVar = new double[newN];
+
+
+
+      // var kss = new double[newN];
+      var Ks = new double[newN, n];
+      double[,] sWKs = new double[n, newN];
+      // double[,] v;
+
+
+      // for stddev 
+      //covarianceFunction.SetParameter(covHyp, newX);
+      //kss = covarianceFunction.GetDiagonalCovariances();
+
+      covarianceFunction.SetData(x, newX);
+      meanFunction.SetData(newX);
+      var ms = meanFunction.GetMean(newX);
+      for (int i = 0; i < newN; i++) {
+
+        for (int j = 0; j < n; j++) {
+          Ks[i, j] = covarianceFunction.GetCovariance(j, i);
+          sWKs[j, i] = Ks[i, j] / Math.Sqrt(sqrSigmaNoise);
+        }
+      }
+
+      // for stddev 
+      // alglib.rmatrixsolvem(l, n, sWKs, newN, true, out info, out denseSolveRep, out v);
+
+
+      for (int i = 0; i < newN; i++) {
+        // predMean[i] = ms[i] + prod(GetRow(Ks, i), alpha);
+        yield return ms[i] + Util.ScalarProd(Util.GetRow(Ks, i), alpha);
+        // var sumV2 = prod(GetCol(v, i), GetCol(v, i));
+        // predVar[i] = kss[i] - sumV2;
+      }
+
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessModelCreator.cs	(revision 8430)
@@ -0,0 +1,86 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Operators;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  // base class for GaussianProcessModelCreators (specific for classification and regression)
+  public abstract class GaussianProcessModelCreator : SingleSuccessorOperator {
+    private const string HyperparameterParameterName = "Hyperparameter";
+    private const string MeanFunctionParameterName = "MeanFunction";
+    private const string CovarianceFunctionParameterName = "CovarianceFunction";
+    private const string ModelParameterName = "Model";
+    private const string NegativeLogLikelihoodParameterName = "NegativeLogLikelihood";
+    private const string HyperparameterGradientsParameterName = "HyperparameterGradients";
+
+    #region Parameter Properties
+    // in
+    public ILookupParameter<RealVector> HyperparameterParameter {
+      get { return (ILookupParameter<RealVector>)Parameters[HyperparameterParameterName]; }
+    }
+    public ILookupParameter<IMeanFunction> MeanFunctionParameter {
+      get { return (ILookupParameter<IMeanFunction>)Parameters[MeanFunctionParameterName]; }
+    }
+    public ILookupParameter<ICovarianceFunction> CovarianceFunctionParameter {
+      get { return (ILookupParameter<ICovarianceFunction>)Parameters[CovarianceFunctionParameterName]; }
+    }
+    // out
+    public ILookupParameter<IGaussianProcessModel> ModelParameter {
+      get { return (ILookupParameter<IGaussianProcessModel>)Parameters[ModelParameterName]; }
+    }
+    public ILookupParameter<RealVector> HyperparameterGradientsParameter {
+      get { return (ILookupParameter<RealVector>)Parameters[HyperparameterGradientsParameterName]; }
+    }
+    public ILookupParameter<DoubleValue> NegativeLogLikelihoodParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[NegativeLogLikelihoodParameterName]; }
+    }
+
+    #endregion
+
+    #region Properties
+    protected RealVector Hyperparameter { get { return HyperparameterParameter.ActualValue; } }
+    protected IMeanFunction MeanFunction { get { return MeanFunctionParameter.ActualValue; } }
+    protected ICovarianceFunction CovarianceFunction { get { return CovarianceFunctionParameter.ActualValue; } }
+    #endregion
+
+    [StorableConstructor]
+    protected GaussianProcessModelCreator(bool deserializing) : base(deserializing) { }
+    protected GaussianProcessModelCreator(GaussianProcessModelCreator original, Cloner cloner) : base(original, cloner) { }
+    protected GaussianProcessModelCreator()
+      : base() {
+      // in
+      Parameters.Add(new LookupParameter<RealVector>(HyperparameterParameterName, "The hyperparameters for the Gaussian process model."));
+      Parameters.Add(new LookupParameter<IMeanFunction>(MeanFunctionParameterName, "The mean function for the Gaussian process model."));
+      Parameters.Add(new LookupParameter<ICovarianceFunction>(CovarianceFunctionParameterName, "The covariance function for the Gaussian process model."));
+      // out
+      Parameters.Add(new LookupParameter<IGaussianProcessModel>(ModelParameterName, "The resulting Gaussian process model"));
+      Parameters.Add(new LookupParameter<RealVector>(HyperparameterGradientsParameterName, "The gradients of the hyperparameters for the produced Gaussian process model (necessary for hyperparameter optimization)"));
+      Parameters.Add(new LookupParameter<DoubleValue>(NegativeLogLikelihoodParameterName, "The negative log-likelihood of the produced Gaussian process model given the data."));
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegression.cs	(revision 8430)
@@ -0,0 +1,183 @@
+
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Algorithms.GradientDescent;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.PluginInfrastructure;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  /// <summary>
+  ///Gaussian process regression data analysis algorithm.
+  /// </summary>
+  [Item("Gaussian Process Regression", "Gaussian process regression data analysis algorithm.")]
+  [Creatable("Data Analysis")]
+  [StorableClass]
+  public sealed class GaussianProcessRegression : EngineAlgorithm, IStorableContent {
+    public string Filename { get; set; }
+
+    public override Type ProblemType { get { return typeof(IRegressionProblem); } }
+    public new IRegressionProblem Problem {
+      get { return (IRegressionProblem)base.Problem; }
+      set { base.Problem = value; }
+    }
+
+    private const string MeanFunctionParameterName = "MeanFunction";
+    private const string CovarianceFunctionParameterName = "CovarianceFunction";
+    private const string MinimizationIterationsParameterName = "Iterations";
+    private const string ApproximateGradientsParameterName = "ApproximateGradients";
+
+    #region parameter properties
+    public IConstrainedValueParameter<IMeanFunction> MeanFunctionParameter {
+      get { return (IConstrainedValueParameter<IMeanFunction>)Parameters[MeanFunctionParameterName]; }
+    }
+    public IConstrainedValueParameter<ICovarianceFunction> CovarianceFunctionParameter {
+      get { return (IConstrainedValueParameter<ICovarianceFunction>)Parameters[CovarianceFunctionParameterName]; }
+    }
+    public IValueParameter<IntValue> MinimizationIterationsParameter {
+      get { return (IValueParameter<IntValue>)Parameters[MinimizationIterationsParameterName]; }
+    }
+    #endregion
+    #region properties
+    public IMeanFunction MeanFunction {
+      set { MeanFunctionParameter.Value = value; }
+      get { return MeanFunctionParameter.Value; }
+    }
+    public ICovarianceFunction CovarianceFunction {
+      set { CovarianceFunctionParameter.Value = value; }
+      get { return CovarianceFunctionParameter.Value; }
+    }
+    public int MinimizationIterations {
+      set { MinimizationIterationsParameter.Value.Value = value; }
+      get { return MinimizationIterationsParameter.Value.Value; }
+    }
+    #endregion
+    [StorableConstructor]
+    private GaussianProcessRegression(bool deserializing) : base(deserializing) { }
+    private GaussianProcessRegression(GaussianProcessRegression original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public GaussianProcessRegression()
+      : base() {
+      this.name = ItemName;
+      this.description = ItemDescription;
+
+      Problem = new RegressionProblem();
+
+      List<IMeanFunction> meanFunctions = ApplicationManager.Manager.GetInstances<IMeanFunction>().ToList();
+      List<ICovarianceFunction> covFunctions = ApplicationManager.Manager.GetInstances<ICovarianceFunction>().ToList();
+
+      Parameters.Add(new ConstrainedValueParameter<IMeanFunction>(MeanFunctionParameterName, "The mean function to use.",
+        new ItemSet<IMeanFunction>(meanFunctions), meanFunctions.First()));
+      Parameters.Add(new ConstrainedValueParameter<ICovarianceFunction>(CovarianceFunctionParameterName, "The covariance function to use.",
+        new ItemSet<ICovarianceFunction>(covFunctions), covFunctions.First()));
+      Parameters.Add(new ValueParameter<IntValue>(MinimizationIterationsParameterName, "The number of iterations for likelihood optimization with LM-BFGS.", new IntValue(20)));
+      Parameters.Add(new ValueParameter<BoolValue>(ApproximateGradientsParameterName, "Indicates that gradients should not be approximated (necessary for LM-BFGS).", new BoolValue(false)));
+      Parameters[ApproximateGradientsParameterName].Hidden = true; // should not be changed
+
+      var gpInitializer = new GaussianProcessHyperparameterInitializer();
+      var bfgsInitializer = new LbfgsInitializer();
+      var makeStep = new LbfgsMakeStep();
+      var branch = new ConditionalBranch();
+      var modelCreator = new GaussianProcessRegressionModelCreator();
+      var updateResults = new LbfgsUpdateResults();
+      var analyzer = new LbfgsAnalyzer();
+      var finalModelCreator = new GaussianProcessRegressionModelCreator();
+      var finalAnalyzer = new LbfgsAnalyzer();
+      var solutionCreator = new GaussianProcessRegressionSolutionCreator();
+
+      OperatorGraph.InitialOperator = gpInitializer;
+
+      gpInitializer.CovarianceFunctionParameter.ActualName = CovarianceFunctionParameterName;
+      gpInitializer.MeanFunctionParameter.ActualName = MeanFunctionParameterName;
+      gpInitializer.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
+      gpInitializer.HyperparameterParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      gpInitializer.Successor = bfgsInitializer;
+
+      bfgsInitializer.IterationsParameter.ActualName = MinimizationIterationsParameterName;
+      bfgsInitializer.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      bfgsInitializer.ApproximateGradientsParameter.ActualName = ApproximateGradientsParameterName;
+      bfgsInitializer.Successor = makeStep;
+
+      makeStep.StateParameter.ActualName = bfgsInitializer.StateParameter.Name;
+      makeStep.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      makeStep.Successor = branch;
+
+      branch.ConditionParameter.ActualName = makeStep.TerminationCriterionParameter.Name;
+      branch.FalseBranch = modelCreator;
+      branch.TrueBranch = finalModelCreator;
+
+      modelCreator.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
+      modelCreator.MeanFunctionParameter.ActualName = MeanFunctionParameterName;
+      modelCreator.CovarianceFunctionParameter.ActualName = CovarianceFunctionParameterName;
+      modelCreator.Successor = updateResults;
+
+      updateResults.StateParameter.ActualName = bfgsInitializer.StateParameter.Name;
+      updateResults.QualityParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
+      updateResults.QualityGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
+      updateResults.ApproximateGradientsParameter.ActualName = ApproximateGradientsParameterName;
+      updateResults.Successor = analyzer;
+
+      analyzer.QualityParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
+      analyzer.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      analyzer.QualityGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
+      analyzer.StateParameter.ActualName = bfgsInitializer.StateParameter.Name;
+      analyzer.PointsTableParameter.ActualName = "Hyperparameter table";
+      analyzer.QualityGradientsTableParameter.ActualName = "Gradients table";
+      analyzer.QualitiesTableParameter.ActualName = "Negative log likelihood table";
+      analyzer.Successor = makeStep;
+
+      finalModelCreator.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
+      finalModelCreator.MeanFunctionParameter.ActualName = MeanFunctionParameterName;
+      finalModelCreator.CovarianceFunctionParameter.ActualName = CovarianceFunctionParameterName;
+      finalModelCreator.HyperparameterParameter.ActualName = bfgsInitializer.PointParameter.ActualName;
+      finalModelCreator.Successor = finalAnalyzer;
+
+      finalAnalyzer.QualityParameter.ActualName = modelCreator.NegativeLogLikelihoodParameter.Name;
+      finalAnalyzer.PointParameter.ActualName = modelCreator.HyperparameterParameter.Name;
+      finalAnalyzer.QualityGradientsParameter.ActualName = modelCreator.HyperparameterGradientsParameter.Name;
+      finalAnalyzer.PointsTableParameter.ActualName = analyzer.PointsTableParameter.ActualName;
+      finalAnalyzer.QualityGradientsTableParameter.ActualName = analyzer.QualityGradientsTableParameter.ActualName;
+      finalAnalyzer.QualitiesTableParameter.ActualName = analyzer.QualitiesTableParameter.ActualName;
+      finalAnalyzer.Successor = solutionCreator;
+
+      solutionCreator.ModelParameter.ActualName = finalModelCreator.ModelParameter.Name;
+      solutionCreator.ProblemDataParameter.ActualName = Problem.ProblemDataParameter.Name;
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessRegression(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionModelCreator.cs	(revision 8430)
@@ -0,0 +1,73 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.RealVectorEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "GaussianProcessRegressionModelCreator",
+    Description = "Creates a Gaussian process model for regression given the data, the hyperparameters, a mean function, and a covariance function.")]
+  public sealed class GaussianProcessRegressionModelCreator : GaussianProcessModelCreator {
+    private const string ProblemDataParameterName = "ProblemData";
+
+    #region Parameter Properties
+    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    #endregion
+
+    #region Properties
+    private IRegressionProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
+    }
+    #endregion
+    [StorableConstructor]
+    private GaussianProcessRegressionModelCreator(bool deserializing) : base(deserializing) { }
+    private GaussianProcessRegressionModelCreator(GaussianProcessRegressionModelCreator original, Cloner cloner) : base(original, cloner) { }
+    public GaussianProcessRegressionModelCreator()
+      : base() {
+      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The regression problem data for the Gaussian process model."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessRegressionModelCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var model = Create(ProblemData, Hyperparameter.ToArray(), MeanFunction, CovarianceFunction);
+      ModelParameter.ActualValue = model;
+      NegativeLogLikelihoodParameter.ActualValue = new DoubleValue(model.NegativeLogLikelihood);
+      HyperparameterGradientsParameter.ActualValue = new RealVector(model.GetHyperparameterGradients());
+      return base.Apply();
+    }
+
+    public static IGaussianProcessModel Create(IRegressionProblemData problemData, double[] hyperparameter, IMeanFunction meanFunction, ICovarianceFunction covarianceFunction) {
+      return new GaussianProcessModel(problemData.Dataset, problemData.TargetVariable, problemData.AllowedInputVariables, problemData.TrainingIndices, hyperparameter, meanFunction, covarianceFunction);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolution.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolution.cs	(revision 8430)
@@ -0,0 +1,54 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  /// <summary>
+  /// Represents a Gaussian process solution for a regression problem which can be visualized in the GUI.
+  /// </summary>
+  [Item("GaussianProcessRegressionSolution", "Represents a Gaussian process solution for a regression problem which can be visualized in the GUI.")]
+  [StorableClass]
+  public sealed class GaussianProcessRegressionSolution : RegressionSolution, IGaussianProcessSolution {
+
+    public new IGaussianProcessModel Model {
+      get { return (IGaussianProcessModel)base.Model; }
+      set { base.Model = value; }
+    }
+
+    [StorableConstructor]
+    private GaussianProcessRegressionSolution(bool deserializing) : base(deserializing) { }
+    private GaussianProcessRegressionSolution(GaussianProcessRegressionSolution original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public GaussianProcessRegressionSolution(IGaussianProcessModel model, IRegressionProblemData problemData)
+      : base(model, problemData) {
+      RecalculateResults();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessRegressionSolution(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/GaussianProcessRegressionSolutionCreator.cs	(revision 8430)
@@ -0,0 +1,96 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Operators;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "GaussianProcessRegressionSolutionCreator",
+    Description = "Creates a Gaussian process solution from a trained model.")]
+  public sealed class GaussianProcessRegressionSolutionCreator : SingleSuccessorOperator {
+    private const string ProblemDataParameterName = "ProblemData";
+    private const string ModelParameterName = "GaussianProcessRegressionModel";
+    private const string SolutionParameterName = "Solution";
+    private const string ResultsParameterName = "Results";
+    private const string TrainingRSquaredResultName = "Training R²";
+    private const string TestRSquaredResultName = "Test R²";
+
+    #region Parameter Properties
+    public ILookupParameter<IRegressionProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<IRegressionProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    public ILookupParameter<IGaussianProcessSolution> SolutionParameter {
+      get { return (ILookupParameter<IGaussianProcessSolution>)Parameters[SolutionParameterName]; }
+    }
+    public ILookupParameter<IGaussianProcessModel> ModelParameter {
+      get { return (ILookupParameter<IGaussianProcessModel>)Parameters[ModelParameterName]; }
+    }
+    public ILookupParameter<ResultCollection> ResultsParameter {
+      get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private GaussianProcessRegressionSolutionCreator(bool deserializing) : base(deserializing) { }
+    private GaussianProcessRegressionSolutionCreator(GaussianProcessRegressionSolutionCreator original, Cloner cloner) : base(original, cloner) { }
+    public GaussianProcessRegressionSolutionCreator()
+      : base() {
+      // in
+      Parameters.Add(new LookupParameter<IRegressionProblemData>(ProblemDataParameterName, "The regression problem data for the Gaussian process solution."));
+      Parameters.Add(new LookupParameter<IGaussianProcessModel>(ModelParameterName, "The Gaussian process regression model to use for the solution."));
+      // in & out
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection of the algorithm."));
+      // out
+      Parameters.Add(new LookupParameter<IGaussianProcessSolution>(SolutionParameterName, "The produced Gaussian process solution."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new GaussianProcessRegressionSolutionCreator(this, cloner);
+    }
+
+    public override IOperation Apply() {
+      var m = ModelParameter.ActualValue;
+      var data = ProblemDataParameter.ActualValue;
+      var s = new GaussianProcessRegressionSolution(m, data);
+
+
+      SolutionParameter.ActualValue = s;
+      var results = ResultsParameter.ActualValue;
+      if (!results.ContainsKey(SolutionParameterName)) {
+        results.Add(new Result(SolutionParameterName, "The Gaussian process regression solution", s));
+        results.Add(new Result(TrainingRSquaredResultName, "The Pearson's R² of the Gaussian process solution on the training partition.", new DoubleValue(s.TrainingRSquared)));
+        results.Add(new Result(TestRSquaredResultName, "The Pearson's R² of the Gaussian process solution on the test partition.", new DoubleValue(s.TestRSquared)));
+      } else {
+        results[SolutionParameterName].Value = s;
+        results[TrainingRSquaredResultName].Value = new DoubleValue(s.TrainingRSquared);
+        results[TestRSquaredResultName].Value = new DoubleValue(s.TestRSquared);
+      }
+      return base.Apply();
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/ICovarianceFunction.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/ICovarianceFunction.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/ICovarianceFunction.cs	(revision 8430)
@@ -0,0 +1,34 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  public interface ICovarianceFunction : IItem {
+    int GetNumberOfParameters(int numberOfVariables);
+    void SetParameter(double[] hyp);
+    void SetData(double[,] x);
+    void SetData(double[,] x, double[,] xt);
+
+    double GetCovariance(int i, int j);
+    double[] GetGradient(int i, int j);
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/IMeanFunction.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/IMeanFunction.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/IMeanFunction.cs	(revision 8430)
@@ -0,0 +1,31 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+using HeuristicLab.Core;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  public interface IMeanFunction : IItem {
+    int GetNumberOfParameters(int numberOfVariables);
+    void SetParameter(double[] hyp);
+    void SetData(double[,] x);
+    double[] GetMean(double[,] x);
+    double[] GetGradients(int k, double[,] x);
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanConst.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanConst.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanConst.cs	(revision 8430)
@@ -0,0 +1,68 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "MeanConst", Description = "Constant mean function for Gaussian processes.")]
+  public class MeanConst : Item, IMeanFunction {
+    [Storable]
+    private double c;
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return 1;
+    }
+    [StorableConstructor]
+    protected MeanConst(bool deserializing) : base(deserializing) { }
+    protected MeanConst(MeanConst original, Cloner cloner)
+      : base(original, cloner) {
+      this.c = original.c;
+    }
+    public MeanConst()
+      : base() {
+    }
+
+    public void SetParameter(double[] hyp) {
+      if (hyp.Length != 1) throw new ArgumentException("Only one hyper-parameter allowed for constant mean function.", "hyp");
+      this.c = hyp[0];
+    }
+    public void SetData(double[,] x) {
+      // nothing to do
+    }
+
+    public double[] GetMean(double[,] x) {
+      return Enumerable.Repeat(c, x.GetLength(0)).ToArray();
+    }
+
+    public double[] GetGradients(int k, double[,] x) {
+      if (k > 0) throw new ArgumentException();
+      return Enumerable.Repeat(1.0, x.GetLength(0)).ToArray();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MeanConst(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanLinear.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanLinear.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanLinear.cs	(revision 8430)
@@ -0,0 +1,81 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "MeanLinear", Description = "Linear mean function for Gaussian processes.")]
+  public class MeanLinear : Item, IMeanFunction {
+    [Storable]
+    private double[] alpha;
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return numberOfVariables;
+    }
+    [StorableConstructor]
+    protected MeanLinear(bool deserializing) : base(deserializing) { }
+    protected MeanLinear(MeanLinear original, Cloner cloner)
+      : base(original, cloner) {
+      if (original.alpha != null) {
+        this.alpha = new double[original.alpha.Length];
+        Array.Copy(original.alpha, alpha, original.alpha.Length);
+      }
+    }
+    public MeanLinear()
+      : base() {
+    }
+
+    public void SetParameter(double[] hyp) {
+      this.alpha = new double[hyp.Length];
+      Array.Copy(hyp, alpha, hyp.Length);
+    }
+    public void SetData(double[,] x) {
+      // nothing to do
+    }
+
+    public double[] GetMean(double[,] x) {
+      // sanity check
+      if (alpha.Length != x.GetLength(1)) throw new ArgumentException("The number of hyperparameters must match the number of variables for the linear mean function.");
+      int cols = x.GetLength(1);
+      int n = x.GetLength(0);
+      return (from i in Enumerable.Range(0, n)
+              let rowVector = from j in Enumerable.Range(0, cols)
+                              select x[i, j]
+              select Util.ScalarProd(alpha, rowVector))
+        .ToArray();
+    }
+
+    public double[] GetGradients(int k, double[,] x) {
+      int cols = x.GetLength(1);
+      int n = x.GetLength(0);
+      if (k > cols) throw new ArgumentException();
+      return (from r in Enumerable.Range(0, n)
+              select x[r, k]).ToArray();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MeanLinear(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanZero.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanZero.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/MeanZero.cs	(revision 8430)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "MeanZero", Description = "Constant zero mean function for Gaussian processes.")]
+  public class MeanZero : Item, IMeanFunction {
+    public int GetNumberOfParameters(int numberOfVariables) {
+      return 0;
+    }
+    [StorableConstructor]
+    protected MeanZero(bool deserializing) : base(deserializing) { }
+    protected MeanZero(MeanZero original, Cloner cloner)
+      : base(original, cloner) {
+    }
+    public MeanZero() {
+    }
+
+    public void SetParameter(double[] hyp) {
+      if (hyp.Length > 0) throw new ArgumentException("No hyper-parameters allowed for zero mean function.", "hyp");
+    }
+
+    public void SetData(double[,] x) {
+      // do nothing
+    }
+
+    public double[] GetMean(double[,] x) {
+      return Enumerable.Repeat(0.0, x.GetLength(0)).ToArray();
+    }
+
+    public double[] GetGradients(int k, double[,] x) {
+      if (k > 0) throw new ArgumentException();
+      return Enumerable.Repeat(0.0, x.GetLength(0)).ToArray();
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new MeanZero(this, cloner);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/Util.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/Util.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/GaussianProcess/Util.cs	(revision 8430)
@@ -0,0 +1,50 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  public static class Util {
+    public static double ScalarProd(IEnumerable<double> v, IEnumerable<double> u) {
+      return v.Zip(u, (vi, ui) => vi * ui).Sum();
+    }
+
+    public static double SqrDist(double x, double y) {
+      double d = x - y;
+      return Math.Max(d * d, 0.0);
+    }
+
+    public static double SqrDist(IEnumerable<double> x, IEnumerable<double> y) {
+      return x.Zip(y, SqrDist).Sum();
+    }
+
+    public static IEnumerable<double> GetRow(double[,] x, int r) {
+      int cols = x.GetLength(1);
+      return Enumerable.Range(0, cols).Select(c => x[r, c]);
+    }
+    public static IEnumerable<double> GetCol(double[,] x, int c) {
+      int rows = x.GetLength(0);
+      return Enumerable.Range(0, rows).Select(r => x[r, c]);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/HeuristicLab.Algorithms.DataAnalysis-3.4.csproj	(revision 8430)
@@ -52,5 +52,5 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
-    <OutputPath>$(SolutionDir)\bin\</OutputPath>
+    <OutputPath>..\..\..\..\trunk\sources\bin\</OutputPath>
     <DefineConstants>TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
@@ -102,9 +102,63 @@
   <ItemGroup>
     <Reference Include="ALGLIB-3.5.0, Version=3.5.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <HintPath>..\..\bin\ALGLIB-3.5.0.dll</HintPath>
+      <HintPath>..\..\..\..\trunk\sources\bin\ALGLIB-3.5.0.dll</HintPath>
       <Private>False</Private>
     </Reference>
+    <Reference Include="HeuristicLab.Algorithms.Benchmarks-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Algorithms.Benchmarks-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Algorithms.GradientDescent-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Algorithms.GradientDescent-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Analysis-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Collections-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Common.Resources-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Common.Resources-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Core-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Core-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Data-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Data-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Encodings.RealVectorEncoding-3.3">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Encodings.RealVectorEncoding-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Operators-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Optimization-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Optimization-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Parameters-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Parameters-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Persistence-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Persistence-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.PluginInfrastructure-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.PluginInfrastructure-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Problems.Instances-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Problems.Instances-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Random-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\..\..\..\trunk\sources\bin\HeuristicLab.Random-3.3.dll</HintPath>
+    </Reference>
     <Reference Include="LibSVM-1.6.3, Version=1.6.3.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <HintPath>..\..\bin\LibSVM-1.6.3.dll</HintPath>
+      <HintPath>..\..\..\..\trunk\sources\bin\LibSVM-1.6.3.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -113,7 +167,5 @@
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
-    <Reference Include="System.Data" />
     <Reference Include="System.Drawing" />
-    <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
@@ -122,4 +174,27 @@
     </Compile>
     <Compile Include="FixedDataAnalysisAlgorithm.cs" />
+    <Compile Include="GaussianProcess\CovarianceProd.cs" />
+    <Compile Include="GaussianProcess\CovarianceSum.cs" />
+    <Compile Include="GaussianProcess\CovariancePeriodic.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessHyperparameterInitializer.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessRegressionSolutionCreator.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessRegressionModelCreator.cs" />
+    <Compile Include="GaussianProcess\CovarianceLinear.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessModelCreator.cs">
+      <SubType>Code</SubType>
+    </Compile>
+    <Compile Include="GaussianProcess\MeanLinear.cs" />
+    <Compile Include="GaussianProcess\Util.cs" />
+    <Compile Include="GaussianProcess\MeanZero.cs" />
+    <Compile Include="GaussianProcess\MeanConst.cs" />
+    <Compile Include="GaussianProcess\IMeanFunction.cs" />
+    <Compile Include="GaussianProcess\CovarianceSEard.cs" />
+    <Compile Include="GaussianProcess\CovarianceSEiso.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessModel.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessRegression.cs" />
+    <Compile Include="GaussianProcess\GaussianProcessRegressionSolution.cs" />
+    <Compile Include="GaussianProcess\ICovarianceFunction.cs" />
+    <Compile Include="Interfaces\IGaussianProcessModel.cs" />
+    <Compile Include="Interfaces\IGaussianProcessSolution.cs" />
     <Compile Include="Interfaces\INearestNeighbourClassificationSolution.cs" />
     <Compile Include="Interfaces\INearestNeighbourRegressionSolution.cs" />
@@ -144,4 +219,5 @@
     </Compile>
     <Compile Include="Linear\AlglibUtil.cs" />
+    <Compile Include="Linear\Scaling.cs" />
     <Compile Include="Linear\LinearDiscriminantAnalysis.cs" />
     <Compile Include="Linear\LinearRegression.cs">
@@ -185,80 +261,22 @@
       <SubType>Code</SubType>
     </Compile>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\..\HeuristicLab.Collections\3.3\HeuristicLab.Collections-3.3.csproj">
-      <Project>{958B43BC-CC5C-4FA2-8628-2B3B01D890B6}</Project>
-      <Name>HeuristicLab.Collections-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Common.Resources\3.3\HeuristicLab.Common.Resources-3.3.csproj">
-      <Project>{0E27A536-1C4A-4624-A65E-DC4F4F23E3E1}</Project>
-      <Name>HeuristicLab.Common.Resources-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Common\3.3\HeuristicLab.Common-3.3.csproj">
-      <Project>{A9AD58B9-3EF9-4CC1-97E5-8D909039FF5C}</Project>
-      <Name>HeuristicLab.Common-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Core\3.3\HeuristicLab.Core-3.3.csproj">
-      <Project>{C36BD924-A541-4A00-AFA8-41701378DDC5}</Project>
-      <Name>HeuristicLab.Core-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Data\3.3\HeuristicLab.Data-3.3.csproj">
-      <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
-      <Name>HeuristicLab.Data-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
+    <Compile Include="TimeSeries\AutoregressiveModeling.cs" />
+  </ItemGroup>
+  <ItemGroup>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.4\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj">
       <Project>{06D4A186-9319-48A0-BADE-A2058D462EEA}</Project>
       <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4</Name>
-      <Private>False</Private>
     </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Optimization\3.3\HeuristicLab.Optimization-3.3.csproj">
-      <Project>{14AB8D24-25BC-400C-A846-4627AA945192}</Project>
-      <Name>HeuristicLab.Optimization-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Parameters\3.3\HeuristicLab.Parameters-3.3.csproj">
-      <Project>{56F9106A-079F-4C61-92F6-86A84C2D84B7}</Project>
-      <Name>HeuristicLab.Parameters-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Persistence\3.3\HeuristicLab.Persistence-3.3.csproj">
-      <Project>{102BC7D3-0EF9-439C-8F6D-96FF0FDB8E1B}</Project>
-      <Name>HeuristicLab.Persistence-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.PluginInfrastructure\3.3\HeuristicLab.PluginInfrastructure-3.3.csproj">
-      <Project>{94186A6A-5176-4402-AE83-886557B53CCA}</Project>
-      <Name>HeuristicLab.PluginInfrastructure-3.3</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis.Symbolic.Classification\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4.csproj">
-      <Project>{05BAE4E1-A9FA-4644-AA77-42558720159E}</Project>
-      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic.Classification-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj">
-      <Project>{5AC82412-911B-4FA2-A013-EDC5E3F3FCC2}</Project>
-      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4</Name>
-      <Private>False</Private>
+    <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4.csproj">
+      <Project>{07486E68-1517-4B9D-A58D-A38E99AE71AB}</Project>
+      <Name>HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis-3.4</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis.Symbolic\3.4\HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj">
       <Project>{3D28463F-EC96-4D82-AFEE-38BE91A0CA00}</Project>
       <Name>HeuristicLab.Problems.DataAnalysis.Symbolic-3.4</Name>
-      <Private>False</Private>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
       <Project>{DF87C13E-A889-46FF-8153-66DCAA8C5674}</Project>
       <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
-      <Private>False</Private>
-    </ProjectReference>
-    <ProjectReference Include="..\..\HeuristicLab.Problems.Instances\3.3\HeuristicLab.Problems.Instances-3.3.csproj">
-      <Project>{3540E29E-4793-49E7-8EE2-FEA7F61C3994}</Project>
-      <Name>HeuristicLab.Problems.Instances-3.3</Name>
-      <Private>False</Private>
     </ProjectReference>
   </ItemGroup>
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IDataAnalysisAlgorithm.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IDataAnalysisAlgorithm.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IDataAnalysisAlgorithm.cs	(revision 8430)
@@ -28,5 +28,5 @@
   /// </summary>
   public interface IDataAnalysisAlgorithm<T> : IAlgorithm where T : class, IDataAnalysisProblem {
-    new T Problem { get; }
+    new T Problem { get; set; }
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessModel.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessModel.cs	(revision 8430)
@@ -0,0 +1,34 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  /// <summary>
+  /// Interface to represent a Gaussian process posterior
+  /// </summary>
+  public interface IGaussianProcessModel : IRegressionModel {
+    double NegativeLogLikelihood { get; }
+    IMeanFunction MeanFunction { get; }
+    ICovarianceFunction CovarianceFunction { get; }
+    double[] GetHyperparameterGradients();
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessSolution.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Interfaces/IGaussianProcessSolution.cs	(revision 8430)
@@ -0,0 +1,31 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  /// <summary>
+  /// Interface to represent a Gaussian process solution (either regression or classification)
+  /// </summary>
+  public interface IGaussianProcessSolution : IDataAnalysisSolution {
+    new IGaussianProcessModel Model { get; }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/AlglibUtil.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/AlglibUtil.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/AlglibUtil.cs	(revision 8430)
@@ -45,4 +45,23 @@
       return matrix;
     }
+    public static double[,] PrepareAndScaleInputMatrix(Dataset dataset, IEnumerable<string> variables, IEnumerable<int> rows, Scaling scaling) {
+      List<string> variablesList = variables.ToList();
+      List<int> rowsList = rows.ToList();
+
+      double[,] matrix = new double[rowsList.Count, variablesList.Count];
+
+      int col = 0;
+      foreach (string column in variables) {
+        var values = scaling.GetScaledValues(dataset, column, rows);
+        int row = 0;
+        foreach (var value in values) {
+          matrix[row, col] = value;
+          row++;
+        }
+        col++;
+      }
+
+      return matrix;
+    }
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 8430)
@@ -68,5 +68,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       int nClasses = problemData.ClassNames.Count();
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 8430)
@@ -72,5 +72,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs	(revision 8430)
@@ -69,5 +69,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -81,10 +81,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
       int info;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/Scaling.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/Scaling.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/Scaling.cs	(revision 8430)
@@ -0,0 +1,62 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis {
+  [StorableClass]
+  [Item(Name = "Scaling", Description = "Contains information about scaling of variables for data-analysis algorithms.")]
+  public class Scaling : Item {
+    [Storable]
+    private Dictionary<string, Tuple<double, double>> scalingParameters = new Dictionary<string, Tuple<double, double>>();
+    [StorableConstructor]
+    protected Scaling(bool deserializing) : base(deserializing) { }
+    protected Scaling(Scaling original, Cloner cloner)
+      : base(original, cloner) {
+      foreach (var pair in original.scalingParameters)
+        scalingParameters.Add(pair.Key, Tuple.Create(pair.Value.Item1, pair.Value.Item2));
+    }
+    public Scaling(Dataset ds, IEnumerable<string> variables, IEnumerable<int> rows) {
+      foreach (var variable in variables) {
+        var values = ds.GetDoubleValues(variable, rows);
+        var min = values.Min();
+        var max = values.Max();
+        scalingParameters[variable] = Tuple.Create(min, max);
+      }
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Scaling(this, cloner);
+    }
+
+    public IEnumerable<double> GetScaledValues(Dataset ds, string variable, IEnumerable<int> rows) {
+      double min = scalingParameters[variable].Item1;
+      double max = scalingParameters[variable].Item2;
+      return ds.GetDoubleValues(variable, rows).Select(x => (x - min) / (max - min));
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs	(revision 8430)
@@ -87,5 +87,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -99,10 +99,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
       alglib.nearestneighbor.kdtreebuild(inputMatrix, nRows, inputMatrix.GetLength(1) - 1, 1, 2, kdtree);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs	(revision 8430)
@@ -87,5 +87,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs	(revision 8430)
@@ -53,6 +53,6 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters[DecayParameterName]; }
     }
-    public ConstrainedValueParameter<IntValue> HiddenLayersParameter {
-      get { return (ConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
+    public IConstrainedValueParameter<IntValue> HiddenLayersParameter {
+      get { return (IConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
     }
     public IFixedValueParameter<IntValue> NodesInFirstHiddenLayerParameter {
@@ -185,5 +185,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -195,10 +195,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs	(revision 8430)
@@ -57,6 +57,6 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters[DecayParameterName]; }
     }
-    public ConstrainedValueParameter<IntValue> HiddenLayersParameter {
-      get { return (ConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
+    public IConstrainedValueParameter<IntValue> HiddenLayersParameter {
+      get { return (IConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
     }
     public IFixedValueParameter<IntValue> NodesInFirstHiddenLayerParameter {
@@ -171,5 +171,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -181,10 +181,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs	(revision 8430)
@@ -57,6 +57,6 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters[DecayParameterName]; }
     }
-    public ConstrainedValueParameter<IntValue> HiddenLayersParameter {
-      get { return (ConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
+    public IConstrainedValueParameter<IntValue> HiddenLayersParameter {
+      get { return (IConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
     }
     public IFixedValueParameter<IntValue> NodesInFirstHiddenLayerParameter {
@@ -170,5 +170,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs	(revision 8430)
@@ -26,11 +26,8 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
-using HeuristicLab.Problems.DataAnalysis.Symbolic.Regression;
-using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
@@ -53,6 +50,6 @@
       get { return (IFixedValueParameter<DoubleValue>)Parameters[DecayParameterName]; }
     }
-    public ConstrainedValueParameter<IntValue> HiddenLayersParameter {
-      get { return (ConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
+    public IConstrainedValueParameter<IntValue> HiddenLayersParameter {
+      get { return (IConstrainedValueParameter<IntValue>)Parameters[HiddenLayersParameterName]; }
     }
     public IFixedValueParameter<IntValue> NodesInFirstHiddenLayerParameter {
@@ -186,5 +183,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Plugin.cs.frame	(revision 8430)
@@ -26,8 +26,9 @@
   /// Plugin class for HeuristicLab.Algorithms.DataAnalysis plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Algorithms.DataAnalysis", "Provides wrappers for data analysis algorithms implemented in external libraries (linear regression, linear discriminant analysis, k-means clustering, support vector classification and regression)", "3.4.2.$WCREV$")]
+  [Plugin("HeuristicLab.Algorithms.DataAnalysis", "Provides wrappers for data analysis algorithms implemented in external libraries (linear regression, linear discriminant analysis, k-means clustering, support vector classification and regression)", "3.4.3.$WCREV$")]
   [PluginFile("HeuristicLab.Algorithms.DataAnalysis-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.ALGLIB", "3.5.0")]
-  [PluginDependency("HeuristicLab.LibSVM", "1.6.3")]
+  [PluginDependency("HeuristicLab.Algorithms.GradientDescent", "3.3")]
+  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
@@ -35,5 +36,7 @@
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
+  [PluginDependency("HeuristicLab.Encodings.RealVectorEncoding", "3.3")]
   [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")]
+  [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
@@ -43,4 +46,5 @@
   [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic.Classification", "3.4")]
   [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic.Regression", "3.4")]
+  [PluginDependency("HeuristicLab.LibSVM", "1.6.3")]
   public class HeuristicLabAlgorithmsDataAnalysisPlugin : PluginBase {
   }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.2.$WCREV$")]
+[assembly: AssemblyFileVersion("3.4.3.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs	(revision 8430)
@@ -97,5 +97,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -111,10 +111,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nCols - 1] = classIndizes[inputMatrix[row, nCols - 1]];
+        inputMatrix[row, nCols - 1] = classIndices[inputMatrix[row, nCols - 1]];
       }
       // execute random forest algorithm
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs	(revision 8430)
@@ -97,5 +97,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 8430)
@@ -46,9 +46,9 @@
 
     #region parameter properties
-    public IValueParameter<StringValue> SvmTypeParameter {
-      get { return (IValueParameter<StringValue>)Parameters[SvmTypeParameterName]; }
+    public IConstrainedValueParameter<StringValue> SvmTypeParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[SvmTypeParameterName]; }
     }
-    public IValueParameter<StringValue> KernelTypeParameter {
-      get { return (IValueParameter<StringValue>)Parameters[KernelTypeParameterName]; }
+    public IConstrainedValueParameter<StringValue> KernelTypeParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[KernelTypeParameterName]; }
     }
     public IValueParameter<DoubleValue> NuParameter {
@@ -65,7 +65,9 @@
     public StringValue SvmType {
       get { return SvmTypeParameter.Value; }
+      set { SvmTypeParameter.Value = value; }
     }
     public StringValue KernelType {
       get { return KernelTypeParameter.Value; }
+      set { KernelTypeParameter.Value = value; }
     }
     public DoubleValue Nu {
@@ -130,5 +132,5 @@
       Dataset dataset = problemData.Dataset;
       string targetVariable = problemData.TargetVariable;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
 
       //extract SVM parameters from scope and set them
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs	(revision 8430)
@@ -162,5 +162,5 @@
       // calculate predictions for the currently requested rows
       SVM.Problem problem = SupportVectorMachineUtil.CreateSvmProblem(dataset, targetVariable, allowedInputVariables, rows);
-      SVM.Problem scaledProblem = Scaling.Scale(RangeTransform, problem);
+      SVM.Problem scaledProblem = SVM.Scaling.Scale(RangeTransform, problem);
 
       for (int i = 0; i < scaledProblem.Count; i++) {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 8430)
@@ -47,9 +47,9 @@
 
     #region parameter properties
-    public IValueParameter<StringValue> SvmTypeParameter {
-      get { return (IValueParameter<StringValue>)Parameters[SvmTypeParameterName]; }
+    public IConstrainedValueParameter<StringValue> SvmTypeParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[SvmTypeParameterName]; }
     }
-    public IValueParameter<StringValue> KernelTypeParameter {
-      get { return (IValueParameter<StringValue>)Parameters[KernelTypeParameterName]; }
+    public IConstrainedValueParameter<StringValue> KernelTypeParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[KernelTypeParameterName]; }
     }
     public IValueParameter<DoubleValue> NuParameter {
@@ -69,7 +69,9 @@
     public StringValue SvmType {
       get { return SvmTypeParameter.Value; }
+      set { SvmTypeParameter.Value = value; }
     }
     public StringValue KernelType {
       get { return KernelTypeParameter.Value; }
+      set { KernelTypeParameter.Value = value; }
     }
     public DoubleValue Nu {
@@ -138,5 +140,5 @@
       Dataset dataset = problemData.Dataset;
       string targetVariable = problemData.TargetVariable;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
 
       //extract SVM parameters from scope and set them
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/TimeSeries/AutoregressiveModeling.cs	(revision 8430)
@@ -0,0 +1,139 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Optimization;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
+using HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis;
+
+namespace HeuristicLab.Algorithms.DataAnalysis.TimeSeries {
+  [Item("Autoregressive Modeling", "Timeseries modeling algorithm that creates AR-N models.")]
+  [Creatable("Data Analysis")]
+  [StorableClass]
+  public class AutoregressiveModeling : FixedDataAnalysisAlgorithm<ITimeSeriesPrognosisProblem> {
+    private const string TimeOffesetParameterName = "Maximum Time Offset";
+
+    public IFixedValueParameter<IntValue> TimeOffsetParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[TimeOffesetParameterName]; }
+    }
+
+
+    public int TimeOffset {
+      get { return TimeOffsetParameter.Value.Value; }
+      set { TimeOffsetParameter.Value.Value = value; }
+    }
+
+    [StorableConstructor]
+    protected AutoregressiveModeling(bool deserializing) : base(deserializing) { }
+    protected AutoregressiveModeling(AutoregressiveModeling original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new AutoregressiveModeling(this, cloner);
+    }
+
+    public AutoregressiveModeling()
+      : base() {
+      Parameters.Add(new FixedValueParameter<IntValue>(TimeOffesetParameterName, "The maximum time offset for the model ranging from 1 to infinity.", new IntValue(1)));
+      Problem = new TimeSeriesPrognosisProblem();
+    }
+
+    protected override void Run() {
+      double rmsError, cvRmsError;
+      var solution = CreateAutoRegressiveSolution(Problem.ProblemData, TimeOffset, out rmsError, out cvRmsError);
+      Results.Add(new Result("Autoregressive solution", "The autoregressive time series prognosis solution.", solution));
+      Results.Add(new Result("Root mean square error", "The root of the mean of squared errors of the autoregressive time series prognosis solution on the training set.", new DoubleValue(rmsError)));
+      Results.Add(new Result("Estimated root mean square error (cross-validation)", "The estimated root of the mean of squared errors of the autoregressive time series prognosis solution via cross validation.", new DoubleValue(cvRmsError)));
+    }
+
+    /// <summary>
+    /// Calculates an AR(p) model. For further information see http://en.wikipedia.org/wiki/Autoregressive_model
+    /// </summary>
+    /// <param name="problemData">The problem data which should be used for training</param>
+    /// <param name="timeOffset">The parameter p of the AR(p) specifying the maximum time offset [1,infinity] </param>
+    /// <returns>The times series autoregressive solution </returns>
+    public ITimeSeriesPrognosisSolution CreateAutoRegressiveSolution(ITimeSeriesPrognosisProblemData problemData, int timeOffset) {
+      double rmsError, cvRmsError;
+      return CreateAutoRegressiveSolution(problemData, timeOffset, out rmsError, out cvRmsError);
+    }
+
+    internal ITimeSeriesPrognosisSolution CreateAutoRegressiveSolution(ITimeSeriesPrognosisProblemData problemData, int timeOffset, out double rmsError, out double cvRmsError) {
+      Dataset dataset = problemData.Dataset;
+      string targetVariable = problemData.TargetVariable;
+
+      double[,] inputMatrix = new double[problemData.TrainingPartition.Size, timeOffset + 1];
+      var targetValues = problemData.Dataset.GetReadOnlyDoubleValues(targetVariable);
+      for (int i = 0, row = problemData.TrainingPartition.Start; i < problemData.TrainingPartition.Size; i++, row++) {
+        for (int col = 0; col < timeOffset + 1; col++) {
+          inputMatrix[i, col] = targetValues[row - col];
+        }
+      }
+
+      if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
+        throw new NotSupportedException("Linear regression does not support NaN or infinity values in the input dataset.");
+
+
+      alglib.linearmodel lm = new alglib.linearmodel();
+      alglib.lrreport ar = new alglib.lrreport();
+      int nRows = inputMatrix.GetLength(0);
+      int nFeatures = inputMatrix.GetLength(1) - 1;
+      double[] coefficients = new double[nFeatures + 1]; // last coefficient is for the constant
+
+      int retVal = 1;
+      alglib.lrbuild(inputMatrix, nRows, nFeatures, out retVal, out lm, out ar);
+      if (retVal != 1) throw new ArgumentException("Error in calculation of linear regression solution");
+      rmsError = ar.rmserror;
+      cvRmsError = ar.cvrmserror;
+
+      alglib.lrunpack(lm, out coefficients, out nFeatures);
+
+
+      ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
+      ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
+      tree.Root.AddSubtree(startNode);
+      ISymbolicExpressionTreeNode addition = new Addition().CreateTreeNode();
+      startNode.AddSubtree(addition);
+
+      for (int i = 0; i < timeOffset; i++) {
+        LaggedVariableTreeNode node = (LaggedVariableTreeNode)new HeuristicLab.Problems.DataAnalysis.Symbolic.LaggedVariable().CreateTreeNode();
+        node.VariableName = targetVariable;
+        node.Weight = coefficients[i];
+        node.Lag = (i + 1) * -1;
+        addition.AddSubtree(node);
+      }
+
+      ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
+      cNode.Value = coefficients[coefficients.Length - 1];
+      addition.AddSubtree(cNode);
+
+      var interpreter = new SymbolicTimeSeriesPrognosisExpressionTreeInterpreter(problemData.TargetVariable);
+      var model = new SymbolicTimeSeriesPrognosisModel(tree, interpreter);
+      var solution = model.CreateTimeSeriesPrognosisSolution((ITimeSeriesPrognosisProblemData)problemData.Clone());
+      return solution;
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 8430)
@@ -85,5 +85,5 @@
       Dataset dataset = problemData.Dataset;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       int info;
       double[,] centers;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs	(revision 8430)
@@ -52,6 +52,6 @@
     public KMeansClusteringSolution(KMeansClusteringModel model, IClusteringProblemData problemData)
       : base(model, problemData) {
-      double trainingIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TrainingIndizes);
-      double testIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TestIndizes);
+      double trainingIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TrainingIndices);
+      double testIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TestIndices);
       this.Add(new Result(TrainingIntraClusterSumOfSquaresResultName, "The sum of squared distances of points of the training partition to the cluster center (is minimized by k-Means).", new DoubleValue(trainingIntraClusterSumOfSquares)));
       this.Add(new Result(TestIntraClusterSumOfSquaresResultName, "The sum of squared distances of points of the test partition to the cluster center (is minimized by k-Means).", new DoubleValue(testIntraClusterSumOfSquares)));
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineCreater.cs	(revision 8430)
@@ -139,4 +139,14 @@
       // the grammar in the newly defined function is a clone of the grammar of the originating branch
       defunNode.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBody.Grammar.Clone());
+
+      var allowedChildSymbols = selectedBody.Grammar.GetAllowedChildSymbols(selectedBody.Symbol);
+      foreach (var allowedChildSymbol in allowedChildSymbols)
+        defunNode.Grammar.AddAllowedChildSymbol(defunNode.Symbol, allowedChildSymbol);
+      var maxSubtrees = selectedBody.Grammar.GetMaximumSubtreeCount(selectedBody.Symbol);
+      for (int i = 0; i < maxSubtrees; i++) {
+        foreach (var allowedChildSymbol in selectedBody.Grammar.GetAllowedChildSymbols(selectedBody.Symbol, i))
+          defunNode.Grammar.AddAllowedChildSymbol(defunNode.Symbol, allowedChildSymbol);
+      }
+
       // remove all argument symbols from grammar except that one contained in cutpoints
       var oldArgumentSymbols = selectedBody.Grammar.Symbols.OfType<Argument>().ToList();
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/ArchitectureManipulators/SubroutineDuplicater.cs	(revision 8430)
@@ -73,4 +73,14 @@
       symbolicExpressionTree.Root.AddSubtree(duplicatedDefunBranch);
       duplicatedDefunBranch.SetGrammar((ISymbolicExpressionTreeGrammar)selectedBranch.Grammar.Clone());
+
+      var allowedChildSymbols = selectedBranch.Grammar.GetAllowedChildSymbols(selectedBranch.Symbol);
+      foreach (var allowedChildSymbol in allowedChildSymbols)
+        duplicatedDefunBranch.Grammar.AddAllowedChildSymbol(duplicatedDefunBranch.Symbol, allowedChildSymbol);
+      var maxSubtrees = selectedBranch.Grammar.GetMaximumSubtreeCount(selectedBranch.Symbol);
+      for (int i = 0; i < maxSubtrees; i++) {
+        foreach (var allowedChildSymbol in selectedBranch.Grammar.GetAllowedChildSymbols(selectedBranch.Symbol, i))
+          duplicatedDefunBranch.Grammar.AddAllowedChildSymbol(duplicatedDefunBranch.Symbol, allowedChildSymbol);
+      }
+
       // add an invoke symbol for each branch that is allowed to invoke the original function
       foreach (var subtree in symbolicExpressionTree.Root.Subtrees.OfType<SymbolicExpressionTreeTopLevelNode>()) {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/FullTreeCreator.cs	(revision 8430)
@@ -161,5 +161,6 @@
           .Where(s => seedNode.Grammar.IsAllowedChildSymbol(seedNode.Symbol, s, i))
           .ToList();
-        var selectedSymbol = possibleSymbols.SelectRandom(random);
+        var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+        var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
@@ -192,6 +193,6 @@
         if (!possibleSymbols.Any())
           throw new InvalidOperationException("No symbols are available for the tree.");
-
-        var selectedSymbol = possibleSymbols.SelectRandom(random);
+        var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+        var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/GrowTreeCreator.cs	(revision 8430)
@@ -160,5 +160,6 @@
           .Where(s => seedNode.Grammar.IsAllowedChildSymbol(seedNode.Symbol, s, i))
           .ToList();
-        var selectedSymbol = possibleSymbols.SelectRandom(random);
+        var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+        var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
@@ -178,7 +179,5 @@
         throw new ArgumentException("Cannot grow node of arity zero. Expected a function node.");
 
-      var allowedSymbols = root.Grammar.AllowedSymbols
-        .Where(s => s.InitialFrequency > 0.0)
-        .ToList();
+      var allowedSymbols = root.Grammar.AllowedSymbols.Where(s => s.InitialFrequency > 0.0).ToList();
 
       for (var i = 0; i < arity; i++) {
@@ -187,7 +186,9 @@
             root.Grammar.GetMinimumExpressionDepth(s) - 1 <= maxDepth - currentDepth)
           .ToList();
+
         if (!possibleSymbols.Any())
           throw new InvalidOperationException("No symbols are available for the tree.");
-        var selectedSymbol = possibleSymbols.SelectRandom(random);
+        var weights = possibleSymbols.Select(s => s.InitialFrequency).ToList();
+        var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
         var tree = selectedSymbol.CreateTreeNode();
         if (tree.HasLocalParameters) tree.ResetLocalParameters(random);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Creators/ProbabilisticTreeCreator.cs	(revision 8430)
@@ -176,6 +176,7 @@
         extensionPoints.Add(x);
       }
-      long minExtensionPointsLength = extensionPoints.Select(x => x.MinimumExtensionLength).Sum();
-      long maxExtensionPointsLength = extensionPoints.Select(x => x.MaximumExtensionLength).Sum();
+      //necessary to use long data type as the extension point length could be int.MaxValue
+      long minExtensionPointsLength = extensionPoints.Select(x => (long)x.MinimumExtensionLength).Sum();
+      long maxExtensionPointsLength = extensionPoints.Select(x => (long)x.MaximumExtensionLength).Sum();
 
       // while there are pending extension points and we have not reached the limit of adding new extension points
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SymbolicExpressionTreeCrossover.cs	(revision 8430)
@@ -59,4 +59,6 @@
       Parameters.Add(new ScopeTreeLookupParameter<ISymbolicExpressionTree>(ParentsParameterName, "The parent symbolic expression trees which should be crossed."));
       Parameters.Add(new LookupParameter<ISymbolicExpressionTree>(ChildParameterName, "The child symbolic expression tree resulting from the crossover."));
+      ParentsParameter.ActualName = "SymbolicExpressionTree";
+      ChildParameter.ActualName = "SymbolicExpressionTree";
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj	(revision 8430)
@@ -163,4 +163,5 @@
     <Compile Include="Manipulators\ChangeNodeTypeManipulation.cs" />
     <Compile Include="Interfaces\Operators\ISymbolicExpressionTreeManipulator.cs" />
+    <Compile Include="Manipulators\RemoveBranchManipulation.cs" />
     <Compile Include="Manipulators\ReplaceBranchManipulation.cs" />
     <Compile Include="Manipulators\FullTreeShaker.cs" />
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/OnePointShaker.cs	(revision 8430)
@@ -57,4 +57,8 @@
 
     protected override void Manipulate(IRandom random, ISymbolicExpressionTree tree) {
+      OnePointShaker.Shake(random, tree, ShakingFactor);
+    }
+
+    public static void Shake(IRandom random, ISymbolicExpressionTree tree, double shakingFactor) {
       List<ISymbolicExpressionTreeNode> parametricNodes = new List<ISymbolicExpressionTreeNode>();
       tree.Root.ForEachNodePostfix(n => {
@@ -63,5 +67,5 @@
       if (parametricNodes.Count > 0) {
         var selectedPoint = parametricNodes.SelectRandom(random);
-        selectedPoint.ShakeLocalParameters(random, ShakingFactor);
+        selectedPoint.ShakeLocalParameters(random, shakingFactor);
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/RemoveBranchManipulation.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/RemoveBranchManipulation.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Manipulators/RemoveBranchManipulation.cs	(revision 8430)
@@ -0,0 +1,132 @@
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
+  [StorableClass]
+  [Item("RemoveBranchManipulation", "Removes a random sub-tree of the input tree and fixes the tree by generating random subtrees if necessary..")]
+  public sealed class RemoveBranchManipulation : SymbolicExpressionTreeManipulator, ISymbolicExpressionTreeSizeConstraintOperator {
+    private const int MAX_TRIES = 100;
+    private const string MaximumSymbolicExpressionTreeLengthParameterName = "MaximumSymbolicExpressionTreeLength";
+    private const string MaximumSymbolicExpressionTreeDepthParameterName = "MaximumSymbolicExpressionTreeDepth";
+    #region Parameter Properties
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeLengthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeLengthParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> MaximumSymbolicExpressionTreeDepthParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
+    }
+    #endregion
+    #region Properties
+    public IntValue MaximumSymbolicExpressionTreeLength {
+      get { return MaximumSymbolicExpressionTreeLengthParameter.ActualValue; }
+    }
+    public IntValue MaximumSymbolicExpressionTreeDepth {
+      get { return MaximumSymbolicExpressionTreeDepthParameter.ActualValue; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private RemoveBranchManipulation(bool deserializing) : base(deserializing) { }
+    private RemoveBranchManipulation(RemoveBranchManipulation original, Cloner cloner) : base(original, cloner) { }
+    public RemoveBranchManipulation()
+      : base() {
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new RemoveBranchManipulation(this, cloner);
+    }
+
+    protected override void Manipulate(IRandom random, ISymbolicExpressionTree symbolicExpressionTree) {
+      RemoveRandomBranch(random, symbolicExpressionTree, MaximumSymbolicExpressionTreeLength.Value, MaximumSymbolicExpressionTreeDepth.Value);
+    }
+
+    public static void RemoveRandomBranch(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, int maxTreeLength, int maxTreeDepth) {
+      var allowedSymbols = new List<ISymbol>();
+      ISymbolicExpressionTreeNode parent;
+      int childIndex;
+      int maxLength;
+      int maxDepth;
+      // repeat until a fitting parent and child are found (MAX_TRIES times)
+      int tries = 0;
+
+      var nodes = symbolicExpressionTree.Root.IterateNodesPrefix().Skip(1).Where(n => n.SubtreeCount > 0).ToList();
+      do {
+        parent = nodes.SelectRandom(random);
+        childIndex = random.Next(parent.SubtreeCount);
+        var child = parent.GetSubtree(childIndex);
+        maxLength = maxTreeLength - symbolicExpressionTree.Length + child.GetLength();
+        maxDepth = maxTreeDepth - symbolicExpressionTree.Depth + child.GetDepth();
+
+        allowedSymbols.Clear();
+        foreach (var symbol in parent.Grammar.GetAllowedChildSymbols(parent.Symbol, childIndex)) {
+          // check basic properties that the new symbol must have
+          if (symbol.Name != child.Symbol.Name &&
+            symbol.InitialFrequency > 0 &&
+            parent.Grammar.GetMinimumExpressionDepth(symbol) + 1 <= maxDepth &&
+            parent.Grammar.GetMinimumExpressionLength(symbol) <= maxLength) {
+            allowedSymbols.Add(symbol);
+          }
+        }
+        tries++;
+      } while (tries < MAX_TRIES && allowedSymbols.Count == 0);
+
+      if (tries >= MAX_TRIES) return;
+      ReplaceWithMinimalTree(random, symbolicExpressionTree.Root, parent, childIndex);
+    }
+
+    private static void ReplaceWithMinimalTree(IRandom random, ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode parent, int childIndex) {
+      // determine possible symbols that will lead to the smallest possible tree
+      var possibleSymbols = (from s in parent.Grammar.GetAllowedChildSymbols(parent.Symbol, childIndex)
+                             where s.InitialFrequency > 0.0
+                             group s by parent.Grammar.GetMinimumExpressionLength(s) into g
+                             orderby g.Key
+                             select g).First().ToList();
+      var weights = possibleSymbols.Select(x => x.InitialFrequency).ToList();
+      var selectedSymbol = possibleSymbols.SelectRandom(weights, random);
+      var newTreeNode = selectedSymbol.CreateTreeNode();
+      if (newTreeNode.HasLocalParameters) newTreeNode.ResetLocalParameters(random);
+      parent.RemoveSubtree(childIndex);
+      parent.InsertSubtree(childIndex, newTreeNode);
+
+      var topLevelNode = newTreeNode as SymbolicExpressionTreeTopLevelNode;
+      if (topLevelNode != null)
+        topLevelNode.SetGrammar((ISymbolicExpressionTreeGrammar)root.Grammar.Clone());
+
+      for (int i = 0; i < newTreeNode.Grammar.GetMinimumSubtreeCount(newTreeNode.Symbol); i++) {
+        // insert a dummy sub-tree and add the pending extension to the list
+        var dummy = new SymbolicExpressionTreeNode();
+        newTreeNode.AddSubtree(dummy);
+        // replace the just inserted dummy by recursive application
+        ReplaceWithMinimalTree(random, root, newTreeNode, i);
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Plugin.cs.frame	(revision 8430)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
-  [Plugin("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding","Provides operators and related classes for the symbolic expression tree encoding.", "3.4.2.$WCREV$")]
+  [Plugin("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding","Provides operators and related classes for the symbolic expression tree encoding.", "3.4.3.$WCREV$")]
   [PluginFile("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -45,3 +45,3 @@
 
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.2.$WCREV$")]
+[assembly: AssemblyFileVersion("3.4.3.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTree.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTree.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTree.cs	(revision 8430)
@@ -23,4 +23,5 @@
 using System.Collections.Generic;
 using System.Drawing;
+using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -77,5 +78,5 @@
     public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesBreadth() {
       if (root == null)
-        return new SymbolicExpressionTreeNode[0];
+        return Enumerable.Empty<SymbolicExpressionTreeNode>();
       return root.IterateNodesBreadth();
     }
@@ -83,10 +84,10 @@
     public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPrefix() {
       if (root == null)
-        return new SymbolicExpressionTreeNode[0];
+        return Enumerable.Empty<SymbolicExpressionTreeNode>();
       return root.IterateNodesPrefix();
     }
     public IEnumerable<ISymbolicExpressionTreeNode> IterateNodesPostfix() {
       if (root == null)
-        return new SymbolicExpressionTreeNode[0];
+        return Enumerable.Empty<SymbolicExpressionTreeNode>();
       return root.IterateNodesPostfix();
     }
Index: anches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/StartSymbolTreeNode.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/StartSymbolTreeNode.cs	(revision 8429)
+++ 	(revision )
@@ -1,38 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.GeneralSymbols {
-  [StorableClass]
-  public sealed class StartSymbolTreeNode : SymbolicExpressionTreeTopLevelNode {
-    // copy constructor
-    private StartSymbolTreeNode(StartSymbolTreeNode original)
-      : base(original) {
-    }
-
-    public StartSymbolTreeNode(StartSymbol startSymbol) : base(startSymbol) { }
-
-    public override object Clone() {
-      return new StartSymbolTreeNode(this);
-    }
-  }
-}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis.Views/3.4/InteractiveSymbolicTimeSeriesPrognosisSolutionSimplifierView.cs	(revision 8430)
@@ -51,5 +51,5 @@
     protected override void UpdateModel(ISymbolicExpressionTree tree) {
       var model = new SymbolicTimeSeriesPrognosisModel(tree, Content.Model.Interpreter);
-      SymbolicTimeSeriesPrognosisModel.Scale(model, Content.ProblemData, Content.ProblemData.TrainingIndizes);
+      SymbolicTimeSeriesPrognosisModel.Scale(model, Content.ProblemData, Content.ProblemData.TrainingIndices);
       Content.Model = model;
     }
@@ -66,5 +66,5 @@
     protected override Dictionary<ISymbolicExpressionTreeNode, double> CalculateImpactValues(ISymbolicExpressionTree tree) {
       var interpreter = Content.Model.Interpreter;
-      var rows = Content.ProblemData.TrainingIndizes;
+      var rows = Content.ProblemData.TrainingIndices;
       var dataset = Content.ProblemData.Dataset;
       var targetVariable = Content.ProblemData.TargetVariable;
@@ -107,5 +107,5 @@
       start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone());
       var interpreter = Content.Model.Interpreter;
-      var rows = Content.ProblemData.TrainingIndizes;
+      var rows = Content.ProblemData.TrainingIndices;
       var allPrognosedValues = interpreter.GetSymbolicExpressionTreeValues(tempTree, Content.ProblemData.Dataset, rows);
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveProblem.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveProblem.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveProblem.cs	(revision 8430)
@@ -85,6 +85,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveTrainingBestSolutionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveTrainingBestSolutionAnalyzer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveTrainingBestSolutionAnalyzer.cs	(revision 8430)
@@ -77,5 +77,5 @@
       var model = new SymbolicTimeSeriesPrognosisModel((ISymbolicExpressionTree)bestTree.Clone(), SymbolicDataAnalysisTreeInterpreterParameter.ActualValue as ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper);
       if (ApplyLinearScaling.Value)
-        SymbolicTimeSeriesPrognosisModel.Scale(model, ProblemDataParameter.ActualValue, ProblemDataParameter.ActualValue.TrainingIndizes);
+        SymbolicTimeSeriesPrognosisModel.Scale(model, ProblemDataParameter.ActualValue, ProblemDataParameter.ActualValue.TrainingIndices);
       return new SymbolicTimeSeriesPrognosisSolution(model, (ITimeSeriesPrognosisProblemData)ProblemDataParameter.ActualValue.Clone());
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveValidationBestSolutionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SingleObjective/SymbolicTimeSeriesPrognosisSingleObjectiveValidationBestSolutionAnalyzer.cs	(revision 8430)
@@ -66,5 +66,5 @@
       var model = new SymbolicTimeSeriesPrognosisModel((ISymbolicExpressionTree)bestTree.Clone(), SymbolicDataAnalysisTreeInterpreterParameter.ActualValue as ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter, EstimationLimitsParameter.ActualValue.Lower, EstimationLimitsParameter.ActualValue.Upper);
       if (ApplyLinearScaling.Value)
-        SymbolicTimeSeriesPrognosisModel.Scale(model, ProblemDataParameter.ActualValue, ProblemDataParameter.ActualValue.TrainingIndizes);
+        SymbolicTimeSeriesPrognosisModel.Scale(model, ProblemDataParameter.ActualValue, ProblemDataParameter.ActualValue.TrainingIndices);
       return new SymbolicTimeSeriesPrognosisSolution(model, (ITimeSeriesPrognosisProblemData)ProblemDataParameter.ActualValue.Clone());
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisExpressionTreeInterpreter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisExpressionTreeInterpreter.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisExpressionTreeInterpreter.cs	(revision 8430)
@@ -57,8 +57,13 @@
     }
 
-    public SymbolicTimeSeriesPrognosisExpressionTreeInterpreter()
+    internal SymbolicTimeSeriesPrognosisExpressionTreeInterpreter()
       : base("SymbolicTimeSeriesPrognosisInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
       Parameters.Add(new FixedValueParameter<StringValue>(TargetVariableParameterName));
       TargetVariableParameter.Hidden = true;
+    }
+
+    public SymbolicTimeSeriesPrognosisExpressionTreeInterpreter(string targetVariable)
+      : this() {
+      TargetVariable = targetVariable;
     }
 
Index: anches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisInterpreter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis/3.4/SymbolicTimeSeriesPrognosisInterpreter.cs	(revision 8429)
+++ 	(revision )
@@ -1,500 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System.Linq;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic.TimeSeriesPrognosis {
-  [StorableClass]
-  [Item("SymbolicTimeSeriesPrognosisInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.")]
-  public sealed class SymbolicTimeSeriesPrognosisInterpreter : ParameterizedNamedItem, ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter {
-    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
-    #region private classes
-    private class InterpreterState {
-      private double[] argumentStack;
-      private int argumentStackPointer;
-      private Instruction[] code;
-      private int pc;
-      public int ProgramCounter {
-        get { return pc; }
-        set { pc = value; }
-      }
-      internal InterpreterState(Instruction[] code, int argumentStackSize) {
-        this.code = code;
-        this.pc = 0;
-        if (argumentStackSize > 0) {
-          this.argumentStack = new double[argumentStackSize];
-        }
-        this.argumentStackPointer = 0;
-      }
-
-      internal void Reset() {
-        this.pc = 0;
-        this.argumentStackPointer = 0;
-      }
-
-      internal Instruction NextInstruction() {
-        return code[pc++];
-      }
-      private void Push(double val) {
-        argumentStack[argumentStackPointer++] = val;
-      }
-      private double Pop() {
-        return argumentStack[--argumentStackPointer];
-      }
-
-      internal void CreateStackFrame(double[] argValues) {
-        // push in reverse order to make indexing easier
-        for (int i = argValues.Length - 1; i >= 0; i--) {
-          argumentStack[argumentStackPointer++] = argValues[i];
-        }
-        Push(argValues.Length);
-      }
-
-      internal void RemoveStackFrame() {
-        int size = (int)Pop();
-        argumentStackPointer -= size;
-      }
-
-      internal double GetStackFrameValue(ushort index) {
-        // layout of stack:
-        // [0]   <- argumentStackPointer
-        // [StackFrameSize = N + 1]
-        // [Arg0] <- argumentStackPointer - 2 - 0
-        // [Arg1] <- argumentStackPointer - 2 - 1
-        // [...]
-        // [ArgN] <- argumentStackPointer - 2 - N
-        // <Begin of stack frame>
-        return argumentStack[argumentStackPointer - index - 2];
-      }
-    }
-    private class OpCodes {
-      public const byte Add = 1;
-      public const byte Sub = 2;
-      public const byte Mul = 3;
-      public const byte Div = 4;
-
-      public const byte Sin = 5;
-      public const byte Cos = 6;
-      public const byte Tan = 7;
-
-      public const byte Log = 8;
-      public const byte Exp = 9;
-
-      public const byte IfThenElse = 10;
-
-      public const byte GT = 11;
-      public const byte LT = 12;
-
-      public const byte AND = 13;
-      public const byte OR = 14;
-      public const byte NOT = 15;
-
-
-      public const byte Average = 16;
-
-      public const byte Call = 17;
-
-      public const byte Variable = 18;
-      public const byte LagVariable = 19;
-      public const byte Constant = 20;
-      public const byte Arg = 21;
-
-      public const byte Power = 22;
-      public const byte Root = 23;
-      public const byte TimeLag = 24;
-      public const byte Integral = 25;
-      public const byte Derivative = 26;
-
-      public const byte VariableCondition = 27;
-    }
-    #endregion
-
-    private Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
-      { typeof(Addition), OpCodes.Add },
-      { typeof(Subtraction), OpCodes.Sub },
-      { typeof(Multiplication), OpCodes.Mul },
-      { typeof(Division), OpCodes.Div },
-      { typeof(Sine), OpCodes.Sin },
-      { typeof(Cosine), OpCodes.Cos },
-      { typeof(Tangent), OpCodes.Tan },
-      { typeof(Logarithm), OpCodes.Log },
-      { typeof(Exponential), OpCodes.Exp },
-      { typeof(IfThenElse), OpCodes.IfThenElse },
-      { typeof(GreaterThan), OpCodes.GT },
-      { typeof(LessThan), OpCodes.LT },
-      { typeof(And), OpCodes.AND },
-      { typeof(Or), OpCodes.OR },
-      { typeof(Not), OpCodes.NOT},
-      { typeof(Average), OpCodes.Average},
-      { typeof(InvokeFunction), OpCodes.Call },
-      { typeof(HeuristicLab.Problems.DataAnalysis.Symbolic.Variable), OpCodes.Variable },
-      { typeof(LaggedVariable), OpCodes.LagVariable },
-      { typeof(Constant), OpCodes.Constant },
-      { typeof(Argument), OpCodes.Arg },
-      { typeof(Power),OpCodes.Power},
-      { typeof(Root),OpCodes.Root},
-      { typeof(TimeLag), OpCodes.TimeLag}, 
-      { typeof(Integral), OpCodes.Integral},
-      { typeof(Derivative), OpCodes.Derivative},
-      { typeof(VariableCondition),OpCodes.VariableCondition}
-    };
-
-    public override bool CanChangeName {
-      get { return false; }
-    }
-    public override bool CanChangeDescription {
-      get { return false; }
-    }
-
-    #region parameter properties
-    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
-      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
-    }
-    #endregion
-
-    #region properties
-    public BoolValue CheckExpressionsWithIntervalArithmetic {
-      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
-      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
-    }
-
-    [Storable]
-    private readonly string[] targetVariables;
-    #endregion
-
-
-    [StorableConstructor]
-    private SymbolicTimeSeriesPrognosisInterpreter(bool deserializing) : base(deserializing) { }
-    private SymbolicTimeSeriesPrognosisInterpreter(SymbolicTimeSeriesPrognosisInterpreter original, Cloner cloner)
-      : base(original, cloner) {
-      this.targetVariables = original.targetVariables;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicTimeSeriesPrognosisInterpreter(this, cloner);
-    }
-
-    public SymbolicTimeSeriesPrognosisInterpreter(string[] targetVariables)
-      : base("SymbolicTimeSeriesPrognosisInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
-      Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
-      this.targetVariables = targetVariables;
-    }
-
-    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, IEnumerable<int> rows) {
-      throw new NotSupportedException();
-    }
-
-    // for each row for each target variable one prognosis (=enumerable of future values)
-    public IEnumerable<IEnumerable<IEnumerable<double>>> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, IEnumerable<int> rows, int horizon) {
-      if (CheckExpressionsWithIntervalArithmetic.Value)
-        throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
-      var compiler = new SymbolicExpressionTreeCompiler();
-      Instruction[] code = compiler.Compile(tree, MapSymbolToOpCode);
-      int necessaryArgStackSize = 0;
-      for (int i = 0; i < code.Length; i++) {
-        Instruction instr = code[i];
-        if (instr.opCode == OpCodes.Variable) {
-          var variableTreeNode = instr.dynamicNode as VariableTreeNode;
-          instr.iArg0 = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
-          code[i] = instr;
-        } else if (instr.opCode == OpCodes.LagVariable) {
-          var laggedVariableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
-          instr.iArg0 = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
-          code[i] = instr;
-        } else if (instr.opCode == OpCodes.VariableCondition) {
-          var variableConditionTreeNode = instr.dynamicNode as VariableConditionTreeNode;
-          instr.iArg0 = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
-        } else if (instr.opCode == OpCodes.Call) {
-          necessaryArgStackSize += instr.nArguments + 1;
-        }
-      }
-      var state = new InterpreterState(code, necessaryArgStackSize);
-
-      int nComponents = tree.Root.GetSubtree(0).SubtreeCount;
-      // produce a n-step forecast for each target variable for all rows
-      var cachedPrognosedValues = new Dictionary<string, double[]>();
-      foreach (var targetVariable in targetVariables)
-        cachedPrognosedValues[targetVariable] = new double[horizon];
-      foreach (var rowEnum in rows) {
-        int row = rowEnum;
-        List<double[]> vProgs = new List<double[]>();
-        foreach (var horizonRow in Enumerable.Range(row, horizon)) {
-          int localRow = horizonRow; // create a local variable for the ref parameter
-          var vPrognosis = from i in Enumerable.Range(0, nComponents)
-                           select Evaluate(dataset, ref localRow, row - 1, state, cachedPrognosedValues);
-
-          var vPrognosisArr = vPrognosis.ToArray();
-          vProgs.Add(vPrognosisArr);
-          // set cachedValues for prognosis of future values
-          for (int i = 0; i < vPrognosisArr.Length; i++)
-            cachedPrognosedValues[targetVariables[i]][horizonRow - row] = vPrognosisArr[i];
-
-          state.Reset();
-        }
-
-        yield return from component in Enumerable.Range(0, nComponents)
-                     select from prognosisStep in Enumerable.Range(0, vProgs.Count)
-                            select vProgs[prognosisStep][component];
-      }
-    }
-
-    private double Evaluate(Dataset dataset, ref int row, int lastObservedRow, InterpreterState state, Dictionary<string, double[]> cachedPrognosedValues) {
-      Instruction currentInstr = state.NextInstruction();
-      switch (currentInstr.opCode) {
-        case OpCodes.Add: {
-            double s = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            return s;
-          }
-        case OpCodes.Sub: {
-            double s = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s -= Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            if (currentInstr.nArguments == 1) s = -s;
-            return s;
-          }
-        case OpCodes.Mul: {
-            double p = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              p *= Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            return p;
-          }
-        case OpCodes.Div: {
-            double p = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              p /= Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            if (currentInstr.nArguments == 1) p = 1.0 / p;
-            return p;
-          }
-        case OpCodes.Average: {
-            double sum = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              sum += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            return sum / currentInstr.nArguments;
-          }
-        case OpCodes.Cos: {
-            return Math.Cos(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-          }
-        case OpCodes.Sin: {
-            return Math.Sin(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-          }
-        case OpCodes.Tan: {
-            return Math.Tan(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-          }
-        case OpCodes.Power: {
-            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            double y = Math.Round(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-            return Math.Pow(x, y);
-          }
-        case OpCodes.Root: {
-            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            double y = Math.Round(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-            return Math.Pow(x, 1 / y);
-          }
-        case OpCodes.Exp: {
-            return Math.Exp(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-          }
-        case OpCodes.Log: {
-            return Math.Log(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
-          }
-        case OpCodes.IfThenElse: {
-            double condition = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            double result;
-            if (condition > 0.0) {
-              result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); SkipInstructions(state);
-            } else {
-              SkipInstructions(state); result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            return result;
-          }
-        case OpCodes.AND: {
-            double result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              if (result > 0.0) result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-              else {
-                SkipInstructions(state);
-              }
-            }
-            return result > 0.0 ? 1.0 : -1.0;
-          }
-        case OpCodes.OR: {
-            double result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              if (result <= 0.0) result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-              else {
-                SkipInstructions(state);
-              }
-            }
-            return result > 0.0 ? 1.0 : -1.0;
-          }
-        case OpCodes.NOT: {
-            return Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues) > 0.0 ? -1.0 : 1.0;
-          }
-        case OpCodes.GT: {
-            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            double y = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            if (x > y) return 1.0;
-            else return -1.0;
-          }
-        case OpCodes.LT: {
-            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            double y = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            if (x < y) return 1.0;
-            else return -1.0;
-          }
-        case OpCodes.TimeLag: {
-            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
-            row += timeLagTreeNode.Lag;
-            double result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            row -= timeLagTreeNode.Lag;
-            return result;
-          }
-        case OpCodes.Integral: {
-            int savedPc = state.ProgramCounter;
-            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
-            double sum = 0.0;
-            for (int i = 0; i < Math.Abs(timeLagTreeNode.Lag); i++) {
-              row += Math.Sign(timeLagTreeNode.Lag);
-              sum += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-              state.ProgramCounter = savedPc;
-            }
-            row -= timeLagTreeNode.Lag;
-            sum += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            return sum;
-          }
-
-        //mkommend: derivate calculation taken from: 
-        //http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/smooth-low-noise-differentiators/
-        //one sided smooth differentiatior, N = 4
-        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
-        case OpCodes.Derivative: {
-            int savedPc = state.ProgramCounter;
-            double f_0 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); row--;
-            state.ProgramCounter = savedPc;
-            double f_1 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); row -= 2;
-            state.ProgramCounter = savedPc;
-            double f_3 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); row--;
-            state.ProgramCounter = savedPc;
-            double f_4 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            row += 4;
-
-            return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
-          }
-        case OpCodes.Call: {
-            // evaluate sub-trees
-            double[] argValues = new double[currentInstr.nArguments];
-            for (int i = 0; i < currentInstr.nArguments; i++) {
-              argValues[i] = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            }
-            // push on argument values on stack 
-            state.CreateStackFrame(argValues);
-
-            // save the pc
-            int savedPc = state.ProgramCounter;
-            // set pc to start of function  
-            state.ProgramCounter = (ushort)currentInstr.iArg0;
-            // evaluate the function
-            double v = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-
-            // delete the stack frame
-            state.RemoveStackFrame();
-
-            // restore the pc => evaluation will continue at point after my subtrees  
-            state.ProgramCounter = savedPc;
-            return v;
-          }
-        case OpCodes.Arg: {
-            return state.GetStackFrameValue((ushort)currentInstr.iArg0);
-          }
-        case OpCodes.Variable: {
-            if (row < 0 || row >= dataset.Rows)
-              return double.NaN;
-            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
-            if (row <= lastObservedRow) return ((IList<double>)currentInstr.iArg0)[row] * variableTreeNode.Weight;
-            else return cachedPrognosedValues[variableTreeNode.VariableName][row - lastObservedRow - 1] * variableTreeNode.Weight;
-          }
-        case OpCodes.LagVariable: {
-            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
-            int actualRow = row + laggedVariableTreeNode.Lag;
-            if (actualRow < 0 || actualRow >= dataset.Rows)
-              return double.NaN;
-            if (actualRow <= lastObservedRow) return ((IList<double>)currentInstr.iArg0)[actualRow] * laggedVariableTreeNode.Weight;
-            else return cachedPrognosedValues[laggedVariableTreeNode.VariableName][actualRow - lastObservedRow - 1] * laggedVariableTreeNode.Weight;
-          }
-        case OpCodes.Constant: {
-            var constTreeNode = currentInstr.dynamicNode as ConstantTreeNode;
-            return constTreeNode.Value;
-          }
-
-        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
-        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
-        case OpCodes.VariableCondition: {
-            if (row < 0 || row >= dataset.Rows)
-              return double.NaN;
-            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
-            double variableValue;
-            if (row <= lastObservedRow)
-              variableValue = ((IList<double>)currentInstr.iArg0)[row];
-            else
-              variableValue = cachedPrognosedValues[variableConditionTreeNode.VariableName][row - lastObservedRow - 1];
-
-            double x = variableValue - variableConditionTreeNode.Threshold;
-            double p = 1 / (1 + Math.Exp(-variableConditionTreeNode.Slope * x));
-
-            double trueBranch = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-            double falseBranch = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
-
-            return trueBranch * p + falseBranch * (1 - p);
-          }
-        default: throw new NotSupportedException();
-      }
-    }
-
-    private byte MapSymbolToOpCode(ISymbolicExpressionTreeNode treeNode) {
-      if (symbolToOpcode.ContainsKey(treeNode.Symbol.GetType()))
-        return symbolToOpcode[treeNode.Symbol.GetType()];
-      else
-        throw new NotSupportedException("Symbol: " + treeNode.Symbol);
-    }
-
-    // skips a whole branch
-    private void SkipInstructions(InterpreterState state) {
-      int i = 1;
-      while (i > 0) {
-        i += state.NextInstruction().nArguments;
-        i--;
-      }
-    }
-  }
-}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/GraphicalSymbolicDataAnalysisModelView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/GraphicalSymbolicDataAnalysisModelView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/GraphicalSymbolicDataAnalysisModelView.cs	(revision 8430)
@@ -26,5 +26,5 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
   [View("Graphical Representation")]
-  [Content(typeof(ISymbolicDataAnalysisModel))]
+  [Content(typeof(ISymbolicDataAnalysisModel), true)]
   public partial class GraphicalSymbolicDataAnalysisModelView : AsynchronousContentView {
     public GraphicalSymbolicDataAnalysisModelView()
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/GraphicalSymbolicDataAnalysisModelView.designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/GraphicalSymbolicDataAnalysisModelView.designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/GraphicalSymbolicDataAnalysisModelView.designer.cs	(revision 8430)
@@ -64,5 +64,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.symbolicExpressionTreeView);
       this.Name = "SymbolicExpressionModelView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.Designer.cs	(revision 8430)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -64,6 +64,6 @@
       // treeChart
       // 
-      this.treeChart.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-            | System.Windows.Forms.AnchorStyles.Left) 
+      this.treeChart.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Left)
             | System.Windows.Forms.AnchorStyles.Right)));
       this.treeChart.BackgroundColor = System.Drawing.Color.White;
@@ -80,6 +80,6 @@
       // viewHost
       // 
-      this.viewHost.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom) 
-            | System.Windows.Forms.AnchorStyles.Left) 
+      this.viewHost.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+            | System.Windows.Forms.AnchorStyles.Left)
             | System.Windows.Forms.AnchorStyles.Right)));
       this.viewHost.Caption = "View";
@@ -125,5 +125,5 @@
       // flowLayoutPanel
       // 
-      this.flowLayoutPanel.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left) 
+      this.flowLayoutPanel.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)
             | System.Windows.Forms.AnchorStyles.Right)));
       this.flowLayoutPanel.Controls.Add(this.btnSimplify);
@@ -171,5 +171,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.splitContainer);
       this.Name = "InteractiveSymbolicDataAnalysisSolutionSimplifierView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/MathSymbolicDataAnalysisModelView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/MathSymbolicDataAnalysisModelView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/MathSymbolicDataAnalysisModelView.cs	(revision 8430)
@@ -21,13 +21,12 @@
 
 using System;
+using System.IO;
 using System.Windows.Forms;
 using HeuristicLab.MainForm;
 using HeuristicLab.MainForm.WindowsForms;
-using System.Threading;
-using System.IO;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
   [View("Mathematical Representation")]
-  [Content(typeof(ISymbolicDataAnalysisModel), true)]
+  [Content(typeof(ISymbolicDataAnalysisModel))]
   public partial class MathSymbolicDataAnalysisModelView : AsynchronousContentView {
     private SymbolicDataAnalysisExpressionLatexFormatter formatter = new SymbolicDataAnalysisExpressionLatexFormatter();
@@ -42,5 +41,5 @@
 
       string hlDir = Path.GetFullPath(AppDomain.CurrentDomain.BaseDirectory);
-      webBrowser.Navigate("file://"+Path.Combine(hlDir, "displayModelFrame.html"));
+      webBrowser.Navigate("file://" + Path.Combine(hlDir, "displayModelFrame.html"));
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/MathSymbolicDataAnalysisModelView.designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/MathSymbolicDataAnalysisModelView.designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/MathSymbolicDataAnalysisModelView.designer.cs	(revision 8430)
@@ -68,5 +68,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.webBrowser);
       this.Name = "MathSymbolicDataAnalysisModelView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Plugin.cs.frame	(revision 8430)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Views {
-  [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic.Views","Provides views for symbolic data analysis problem classes.", "3.4.2.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic.Views","Provides views for symbolic data analysis problem classes.", "3.4.3.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.DataAnalysis.Symbolic.Views-3.4.dll", PluginFileType.Assembly)]
   [PluginFile("displayModelFrame.html", PluginFileType.Data)]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.2.$WCREV$")]
+[assembly: AssemblyFileVersion("3.4.3.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/RunCollectionVariableImpactView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/RunCollectionVariableImpactView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/RunCollectionVariableImpactView.Designer.cs	(revision 8430)
@@ -101,5 +101,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.variableImpactsGroupBox);
       this.Controls.Add(this.foldsLabel);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/ConstantView.Designer.cs	(revision 8430)
@@ -214,5 +214,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.mutationGroupBox);
       this.Controls.Add(this.initializationGroupBox);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/LaggedVariableView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/LaggedVariableView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/LaggedVariableView.Designer.cs	(revision 8430)
@@ -183,5 +183,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.minTimeOffsetTextBox);
       this.Controls.Add(this.maxTimeOffsetLabel);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/TimeLagView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/TimeLagView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/TimeLagView.Designer.cs	(revision 8430)
@@ -123,5 +123,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.maxTimeOffsetTextBox);
       this.Controls.Add(this.minTimeOffsetTextBox);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableConditionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableConditionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableConditionView.Designer.cs	(revision 8430)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -46,13 +46,4 @@
     /// </summary>
     private void InitializeComponent() {
-      this.thresholdInitializationMuLabel = new System.Windows.Forms.Label();
-      this.thresholdInitializationMuTextBox = new System.Windows.Forms.TextBox();
-      this.initializationGroupBox = new System.Windows.Forms.GroupBox();
-      this.slopeInitializationSigmaLabel = new System.Windows.Forms.Label();
-      this.slopeInitializationSigmaTextBox = new System.Windows.Forms.TextBox();
-      this.slopeInitializationMuLabel = new System.Windows.Forms.Label();
-      this.slopeInitializationMuTextBox = new System.Windows.Forms.TextBox();
-      this.thresholdInitializationSigmaLabel = new System.Windows.Forms.Label();
-      this.thresholdInitializationSigmaTextBox = new System.Windows.Forms.TextBox();
       this.mutationGroupBox = new System.Windows.Forms.GroupBox();
       this.slopeChangeSigmaLabel = new System.Windows.Forms.Label();
@@ -64,7 +55,21 @@
       this.ThresholdChangeMuLabel = new System.Windows.Forms.Label();
       this.thresholdChangeMuTextBox = new System.Windows.Forms.TextBox();
+      this.tabControl = new System.Windows.Forms.TabControl();
+      this.variableNamesTabPage = new System.Windows.Forms.TabPage();
+      this.parametersTabPage = new System.Windows.Forms.TabPage();
+      this.initializationGroupBox = new System.Windows.Forms.GroupBox();
+      this.slopeInitializationSigmaLabel = new System.Windows.Forms.Label();
+      this.slopeInitializationSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.slopeInitializationMuLabel = new System.Windows.Forms.Label();
+      this.slopeInitializationMuTextBox = new System.Windows.Forms.TextBox();
+      this.thresholdInitializationSigmaLabel = new System.Windows.Forms.Label();
+      this.thresholdInitializationSigmaTextBox = new System.Windows.Forms.TextBox();
+      this.thresholdInitializationMuLabel = new System.Windows.Forms.Label();
+      this.thresholdInitializationMuTextBox = new System.Windows.Forms.TextBox();
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).BeginInit();
+      this.mutationGroupBox.SuspendLayout();
+      this.tabControl.SuspendLayout();
+      this.parametersTabPage.SuspendLayout();
       this.initializationGroupBox.SuspendLayout();
-      this.mutationGroupBox.SuspendLayout();
       this.SuspendLayout();
       // 
@@ -76,13 +81,23 @@
       // 
       this.errorProvider.SetIconAlignment(this.initialFrequencyTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
-      this.initialFrequencyTextBox.Size = new System.Drawing.Size(233, 20);
+      this.initialFrequencyTextBox.Size = new System.Drawing.Size(427, 20);
+      // 
+      // minimumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.minimumArityLabel, "The minimum arity of the symbol");
+      // 
+      // maximumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.maximumArityLabel, "The maximum arity of the symbol");
       // 
       // minimumArityTextBox
       // 
       this.errorProvider.SetIconAlignment(this.minimumArityTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.minimumArityTextBox.Size = new System.Drawing.Size(421, 20);
       // 
       // maximumArityTextBox
       // 
       this.errorProvider.SetIconAlignment(this.maximumArityTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
+      this.maximumArityTextBox.Size = new System.Drawing.Size(421, 20);
       // 
       // nameTextBox
@@ -90,32 +105,160 @@
       this.errorProvider.SetIconAlignment(this.nameTextBox, System.Windows.Forms.ErrorIconAlignment.MiddleLeft);
       this.errorProvider.SetIconPadding(this.nameTextBox, 2);
-      this.nameTextBox.Size = new System.Drawing.Size(203, 20);
-      // 
-      // thresholdInitializationMuLabel
-      // 
-      this.thresholdInitializationMuLabel.AutoSize = true;
-      this.thresholdInitializationMuLabel.Location = new System.Drawing.Point(6, 18);
-      this.thresholdInitializationMuLabel.Name = "thresholdInitializationMuLabel";
-      this.thresholdInitializationMuLabel.Size = new System.Drawing.Size(80, 13);
-      this.thresholdInitializationMuLabel.TabIndex = 0;
-      this.thresholdInitializationMuLabel.Text = "Threshold (mu):";
-      this.toolTip.SetToolTip(this.thresholdInitializationMuLabel, "The mu (mean) parameter of the normal distribution to use for initial weights.");
-      // 
-      // thresholdInitializationMuTextBox
-      // 
-      this.thresholdInitializationMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.thresholdInitializationMuTextBox.Location = new System.Drawing.Point(114, 15);
-      this.thresholdInitializationMuTextBox.Name = "thresholdInitializationMuTextBox";
-      this.thresholdInitializationMuTextBox.Size = new System.Drawing.Size(203, 20);
-      this.thresholdInitializationMuTextBox.TabIndex = 1;
-      this.toolTip.SetToolTip(this.thresholdInitializationMuTextBox, "The mu (mean) parameter of the normal distribution from which to sample the initi" +
-        "al thresholds.");
-      this.thresholdInitializationMuTextBox.TextChanged += new System.EventHandler(this.thresholdMuTextBox_TextChanged);
+      this.nameTextBox.Size = new System.Drawing.Size(397, 20);
+      // 
+      // infoLabel
+      // 
+      this.infoLabel.Location = new System.Drawing.Point(495, 3);
+      // 
+      // mutationGroupBox
+      // 
+      this.mutationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.mutationGroupBox.Controls.Add(this.slopeChangeSigmaLabel);
+      this.mutationGroupBox.Controls.Add(this.slopeChangeSigmaTextBox);
+      this.mutationGroupBox.Controls.Add(this.slopeChangeMuLabel);
+      this.mutationGroupBox.Controls.Add(this.slopeChangeMuTextBox);
+      this.mutationGroupBox.Controls.Add(this.thresholdChangeSigmaLabel);
+      this.mutationGroupBox.Controls.Add(this.thresholdChangeSigmaTextBox);
+      this.mutationGroupBox.Controls.Add(this.ThresholdChangeMuLabel);
+      this.mutationGroupBox.Controls.Add(this.thresholdChangeMuTextBox);
+      this.mutationGroupBox.Location = new System.Drawing.Point(6, 142);
+      this.mutationGroupBox.Name = "mutationGroupBox";
+      this.mutationGroupBox.Size = new System.Drawing.Size(503, 126);
+      this.mutationGroupBox.TabIndex = 6;
+      this.mutationGroupBox.TabStop = false;
+      this.mutationGroupBox.Text = "Mutation";
+      // 
+      // slopeChangeSigmaLabel
+      // 
+      this.slopeChangeSigmaLabel.AutoSize = true;
+      this.slopeChangeSigmaLabel.Location = new System.Drawing.Point(6, 102);
+      this.slopeChangeSigmaLabel.Name = "slopeChangeSigmaLabel";
+      this.slopeChangeSigmaLabel.Size = new System.Drawing.Size(112, 13);
+      this.slopeChangeSigmaLabel.TabIndex = 6;
+      this.slopeChangeSigmaLabel.Text = "Slope change (sigma):";
+      this.toolTip.SetToolTip(this.slopeChangeSigmaLabel, "The sigma parameter for the normal distribution to use to sample the change in sl" +
+              "ope.");
+      // 
+      // slopeChangeSigmaTextBox
+      // 
+      this.slopeChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.slopeChangeSigmaTextBox.Location = new System.Drawing.Point(149, 99);
+      this.slopeChangeSigmaTextBox.Name = "slopeChangeSigmaTextBox";
+      this.slopeChangeSigmaTextBox.Size = new System.Drawing.Size(345, 20);
+      this.slopeChangeSigmaTextBox.TabIndex = 7;
+      this.toolTip.SetToolTip(this.slopeChangeSigmaTextBox, "The sigma parameter for the normal distribution to use to sample the change in sl" +
+              "ope.");
+      this.slopeChangeSigmaTextBox.TextChanged += new System.EventHandler(this.SlopeChangeSigmaTextBox_TextChanged);
+      // 
+      // slopeChangeMuLabel
+      // 
+      this.slopeChangeMuLabel.AutoSize = true;
+      this.slopeChangeMuLabel.Location = new System.Drawing.Point(6, 76);
+      this.slopeChangeMuLabel.Name = "slopeChangeMuLabel";
+      this.slopeChangeMuLabel.Size = new System.Drawing.Size(99, 13);
+      this.slopeChangeMuLabel.TabIndex = 4;
+      this.slopeChangeMuLabel.Text = "Slope change (mu):";
+      this.toolTip.SetToolTip(this.slopeChangeMuLabel, "The nu (mean) parameter for the normal distribution to sample the change in slope" +
+              ".");
+      // 
+      // slopeChangeMuTextBox
+      // 
+      this.slopeChangeMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.slopeChangeMuTextBox.Location = new System.Drawing.Point(149, 73);
+      this.slopeChangeMuTextBox.Name = "slopeChangeMuTextBox";
+      this.slopeChangeMuTextBox.Size = new System.Drawing.Size(345, 20);
+      this.slopeChangeMuTextBox.TabIndex = 5;
+      this.toolTip.SetToolTip(this.slopeChangeMuTextBox, "The mu (mean) parameter for the normal distribution to sample the change in slope" +
+              ".");
+      this.slopeChangeMuTextBox.TextChanged += new System.EventHandler(this.SlopeChangeMuTextBox_TextChanged);
+      // 
+      // thresholdChangeSigmaLabel
+      // 
+      this.thresholdChangeSigmaLabel.AutoSize = true;
+      this.thresholdChangeSigmaLabel.Location = new System.Drawing.Point(6, 44);
+      this.thresholdChangeSigmaLabel.Name = "thresholdChangeSigmaLabel";
+      this.thresholdChangeSigmaLabel.Size = new System.Drawing.Size(132, 13);
+      this.thresholdChangeSigmaLabel.TabIndex = 2;
+      this.thresholdChangeSigmaLabel.Text = "Threshold change (sigma):";
+      this.toolTip.SetToolTip(this.thresholdChangeSigmaLabel, "The sigma parameter for the normal distribution to use to sample the change in th" +
+              "reshold.");
+      // 
+      // thresholdChangeSigmaTextBox
+      // 
+      this.thresholdChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdChangeSigmaTextBox.Location = new System.Drawing.Point(149, 41);
+      this.thresholdChangeSigmaTextBox.Name = "thresholdChangeSigmaTextBox";
+      this.thresholdChangeSigmaTextBox.Size = new System.Drawing.Size(345, 20);
+      this.thresholdChangeSigmaTextBox.TabIndex = 3;
+      this.toolTip.SetToolTip(this.thresholdChangeSigmaTextBox, "The sigma parameter for the normal distribution to use to sample the change in th" +
+              "reshold.");
+      this.thresholdChangeSigmaTextBox.TextChanged += new System.EventHandler(this.ThresholdChangeSigmaTextBox_TextChanged);
+      // 
+      // ThresholdChangeMuLabel
+      // 
+      this.ThresholdChangeMuLabel.AutoSize = true;
+      this.ThresholdChangeMuLabel.Location = new System.Drawing.Point(6, 18);
+      this.ThresholdChangeMuLabel.Name = "ThresholdChangeMuLabel";
+      this.ThresholdChangeMuLabel.Size = new System.Drawing.Size(119, 13);
+      this.ThresholdChangeMuLabel.TabIndex = 0;
+      this.ThresholdChangeMuLabel.Text = "Threshold change (mu):";
+      this.toolTip.SetToolTip(this.ThresholdChangeMuLabel, "The nu (mean) parameter for the normal distribution to sample the change in thres" +
+              "hold.");
+      // 
+      // thresholdChangeMuTextBox
+      // 
+      this.thresholdChangeMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdChangeMuTextBox.Location = new System.Drawing.Point(149, 15);
+      this.thresholdChangeMuTextBox.Name = "thresholdChangeMuTextBox";
+      this.thresholdChangeMuTextBox.Size = new System.Drawing.Size(345, 20);
+      this.thresholdChangeMuTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.thresholdChangeMuTextBox, "The mu (mean) parameter for the normal distribution to sample the change in thres" +
+              "hold.");
+      this.thresholdChangeMuTextBox.TextChanged += new System.EventHandler(this.ThresholdChangeMuTextBox_TextChanged);
+      // 
+      // tabControl
+      // 
+      this.tabControl.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.tabControl.Controls.Add(this.variableNamesTabPage);
+      this.tabControl.Controls.Add(this.parametersTabPage);
+      this.tabControl.Location = new System.Drawing.Point(0, 127);
+      this.tabControl.Name = "tabControl";
+      this.tabControl.SelectedIndex = 0;
+      this.tabControl.Size = new System.Drawing.Size(520, 299);
+      this.tabControl.TabIndex = 10;
+      // 
+      // variableNamesTabPage
+      // 
+      this.variableNamesTabPage.Location = new System.Drawing.Point(4, 22);
+      this.variableNamesTabPage.Name = "variableNamesTabPage";
+      this.variableNamesTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.variableNamesTabPage.Size = new System.Drawing.Size(512, 273);
+      this.variableNamesTabPage.TabIndex = 0;
+      this.variableNamesTabPage.Text = "Variable Names";
+      this.variableNamesTabPage.UseVisualStyleBackColor = true;
+      // 
+      // parametersTabPage
+      // 
+      this.parametersTabPage.Controls.Add(this.initializationGroupBox);
+      this.parametersTabPage.Controls.Add(this.mutationGroupBox);
+      this.parametersTabPage.Location = new System.Drawing.Point(4, 22);
+      this.parametersTabPage.Name = "parametersTabPage";
+      this.parametersTabPage.Padding = new System.Windows.Forms.Padding(3);
+      this.parametersTabPage.Size = new System.Drawing.Size(512, 273);
+      this.parametersTabPage.TabIndex = 1;
+      this.parametersTabPage.Text = "Parameters";
+      this.parametersTabPage.UseVisualStyleBackColor = true;
       // 
       // initializationGroupBox
       // 
       this.initializationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
+                  | System.Windows.Forms.AnchorStyles.Right)));
       this.initializationGroupBox.Controls.Add(this.slopeInitializationSigmaLabel);
       this.initializationGroupBox.Controls.Add(this.slopeInitializationSigmaTextBox);
@@ -126,8 +269,8 @@
       this.initializationGroupBox.Controls.Add(this.thresholdInitializationMuLabel);
       this.initializationGroupBox.Controls.Add(this.thresholdInitializationMuTextBox);
-      this.initializationGroupBox.Location = new System.Drawing.Point(0, 127);
+      this.initializationGroupBox.Location = new System.Drawing.Point(6, 6);
       this.initializationGroupBox.Name = "initializationGroupBox";
-      this.initializationGroupBox.Size = new System.Drawing.Size(326, 127);
-      this.initializationGroupBox.TabIndex = 5;
+      this.initializationGroupBox.Size = new System.Drawing.Size(503, 130);
+      this.initializationGroupBox.TabIndex = 6;
       this.initializationGroupBox.TabStop = false;
       this.initializationGroupBox.Text = "Initialization";
@@ -146,12 +289,12 @@
       // 
       this.slopeInitializationSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
+                  | System.Windows.Forms.AnchorStyles.Right)));
       this.slopeInitializationSigmaTextBox.Location = new System.Drawing.Point(114, 102);
       this.slopeInitializationSigmaTextBox.Name = "slopeInitializationSigmaTextBox";
-      this.slopeInitializationSigmaTextBox.Size = new System.Drawing.Size(203, 20);
+      this.slopeInitializationSigmaTextBox.Size = new System.Drawing.Size(380, 20);
       this.slopeInitializationSigmaTextBox.TabIndex = 7;
       this.toolTip.SetToolTip(this.slopeInitializationSigmaTextBox, "The sigma parameter for the normal distribution from which to sample the initial " +
-        "slopes.");
-      this.slopeInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.slopeInitializationSigmaTextBox_TextChanged);
+              "slopes.");
+      this.slopeInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.SlopeInitializationSigmaTextBox_TextChanged);
       // 
       // slopeInitializationMuLabel
@@ -168,12 +311,12 @@
       // 
       this.slopeInitializationMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
+                  | System.Windows.Forms.AnchorStyles.Right)));
       this.slopeInitializationMuTextBox.Location = new System.Drawing.Point(114, 76);
       this.slopeInitializationMuTextBox.Name = "slopeInitializationMuTextBox";
-      this.slopeInitializationMuTextBox.Size = new System.Drawing.Size(203, 20);
+      this.slopeInitializationMuTextBox.Size = new System.Drawing.Size(380, 20);
       this.slopeInitializationMuTextBox.TabIndex = 5;
       this.toolTip.SetToolTip(this.slopeInitializationMuTextBox, "The mu (mean) parameter of the normal distribution from which to sample the initi" +
-        "al slopes.");
-      this.slopeInitializationMuTextBox.TextChanged += new System.EventHandler(this.slopeInitializationMuTextBox_TextChanged);
+              "al slopes.");
+      this.slopeInitializationMuTextBox.TextChanged += new System.EventHandler(this.SlopeInitializationMuTextBox_TextChanged);
       // 
       // thresholdInitializationSigmaLabel
@@ -190,132 +333,41 @@
       // 
       this.thresholdInitializationSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
+                  | System.Windows.Forms.AnchorStyles.Right)));
       this.thresholdInitializationSigmaTextBox.Location = new System.Drawing.Point(114, 41);
       this.thresholdInitializationSigmaTextBox.Name = "thresholdInitializationSigmaTextBox";
-      this.thresholdInitializationSigmaTextBox.Size = new System.Drawing.Size(203, 20);
+      this.thresholdInitializationSigmaTextBox.Size = new System.Drawing.Size(380, 20);
       this.thresholdInitializationSigmaTextBox.TabIndex = 3;
       this.toolTip.SetToolTip(this.thresholdInitializationSigmaTextBox, "The sigma parameter for the normal distribution from which to sample the initial " +
-        "thresholds.");
-      this.thresholdInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.thresholdInitializationSigmaTextBox_TextChanged);
-      // 
-      // mutationGroupBox
-      // 
-      this.mutationGroupBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.mutationGroupBox.Controls.Add(this.slopeChangeSigmaLabel);
-      this.mutationGroupBox.Controls.Add(this.slopeChangeSigmaTextBox);
-      this.mutationGroupBox.Controls.Add(this.slopeChangeMuLabel);
-      this.mutationGroupBox.Controls.Add(this.slopeChangeMuTextBox);
-      this.mutationGroupBox.Controls.Add(this.thresholdChangeSigmaLabel);
-      this.mutationGroupBox.Controls.Add(this.thresholdChangeSigmaTextBox);
-      this.mutationGroupBox.Controls.Add(this.ThresholdChangeMuLabel);
-      this.mutationGroupBox.Controls.Add(this.thresholdChangeMuTextBox);
-      this.mutationGroupBox.Location = new System.Drawing.Point(0, 260);
-      this.mutationGroupBox.Name = "mutationGroupBox";
-      this.mutationGroupBox.Size = new System.Drawing.Size(326, 127);
-      this.mutationGroupBox.TabIndex = 6;
-      this.mutationGroupBox.TabStop = false;
-      this.mutationGroupBox.Text = "Mutation";
-      // 
-      // slopeChangeSigmaLabel
-      // 
-      this.slopeChangeSigmaLabel.AutoSize = true;
-      this.slopeChangeSigmaLabel.Location = new System.Drawing.Point(6, 102);
-      this.slopeChangeSigmaLabel.Name = "slopeChangeSigmaLabel";
-      this.slopeChangeSigmaLabel.Size = new System.Drawing.Size(112, 13);
-      this.slopeChangeSigmaLabel.TabIndex = 6;
-      this.slopeChangeSigmaLabel.Text = "Slope change (sigma):";
-      this.toolTip.SetToolTip(this.slopeChangeSigmaLabel, "The sigma parameter for the normal distribution to use to sample the change in sl" +
-        "ope.");
-      // 
-      // slopeChangeSigmaTextBox
-      // 
-      this.slopeChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.slopeChangeSigmaTextBox.Location = new System.Drawing.Point(149, 99);
-      this.slopeChangeSigmaTextBox.Name = "slopeChangeSigmaTextBox";
-      this.slopeChangeSigmaTextBox.Size = new System.Drawing.Size(168, 20);
-      this.slopeChangeSigmaTextBox.TabIndex = 7;
-      this.toolTip.SetToolTip(this.slopeChangeSigmaTextBox, "The sigma parameter for the normal distribution to use to sample the change in sl" +
-        "ope.");
-      this.slopeChangeSigmaTextBox.TextChanged += new System.EventHandler(this.slopeChangeSigmaTextBox_TextChanged);
-      // 
-      // slopeChangeMuLabel
-      // 
-      this.slopeChangeMuLabel.AutoSize = true;
-      this.slopeChangeMuLabel.Location = new System.Drawing.Point(6, 76);
-      this.slopeChangeMuLabel.Name = "slopeChangeMuLabel";
-      this.slopeChangeMuLabel.Size = new System.Drawing.Size(99, 13);
-      this.slopeChangeMuLabel.TabIndex = 4;
-      this.slopeChangeMuLabel.Text = "Slope change (mu):";
-      this.toolTip.SetToolTip(this.slopeChangeMuLabel, "The nu (mean) parameter for the normal distribution to sample the change in slope" +
-        ".");
-      // 
-      // slopeChangeMuTextBox
-      // 
-      this.slopeChangeMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.slopeChangeMuTextBox.Location = new System.Drawing.Point(149, 73);
-      this.slopeChangeMuTextBox.Name = "slopeChangeMuTextBox";
-      this.slopeChangeMuTextBox.Size = new System.Drawing.Size(168, 20);
-      this.slopeChangeMuTextBox.TabIndex = 5;
-      this.toolTip.SetToolTip(this.slopeChangeMuTextBox, "The mu (mean) parameter for the normal distribution to sample the change in slope" +
-        ".");
-      this.slopeChangeMuTextBox.TextChanged += new System.EventHandler(this.slopeChangeMuTextBox_TextChanged);
-      // 
-      // thresholdChangeSigmaLabel
-      // 
-      this.thresholdChangeSigmaLabel.AutoSize = true;
-      this.thresholdChangeSigmaLabel.Location = new System.Drawing.Point(6, 44);
-      this.thresholdChangeSigmaLabel.Name = "thresholdChangeSigmaLabel";
-      this.thresholdChangeSigmaLabel.Size = new System.Drawing.Size(132, 13);
-      this.thresholdChangeSigmaLabel.TabIndex = 2;
-      this.thresholdChangeSigmaLabel.Text = "Threshold change (sigma):";
-      this.toolTip.SetToolTip(this.thresholdChangeSigmaLabel, "The sigma parameter for the normal distribution to use to sample the change in th" +
-        "reshold.");
-      // 
-      // thresholdChangeSigmaTextBox
-      // 
-      this.thresholdChangeSigmaTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.thresholdChangeSigmaTextBox.Location = new System.Drawing.Point(149, 41);
-      this.thresholdChangeSigmaTextBox.Name = "thresholdChangeSigmaTextBox";
-      this.thresholdChangeSigmaTextBox.Size = new System.Drawing.Size(168, 20);
-      this.thresholdChangeSigmaTextBox.TabIndex = 3;
-      this.toolTip.SetToolTip(this.thresholdChangeSigmaTextBox, "The sigma parameter for the normal distribution to use to sample the change in th" +
-        "reshold.");
-      this.thresholdChangeSigmaTextBox.TextChanged += new System.EventHandler(this.thresholdChangeSigmaTextBox_TextChanged);
-      // 
-      // ThresholdChangeMuLabel
-      // 
-      this.ThresholdChangeMuLabel.AutoSize = true;
-      this.ThresholdChangeMuLabel.Location = new System.Drawing.Point(6, 18);
-      this.ThresholdChangeMuLabel.Name = "ThresholdChangeMuLabel";
-      this.ThresholdChangeMuLabel.Size = new System.Drawing.Size(119, 13);
-      this.ThresholdChangeMuLabel.TabIndex = 0;
-      this.ThresholdChangeMuLabel.Text = "Threshold change (mu):";
-      this.toolTip.SetToolTip(this.ThresholdChangeMuLabel, "The nu (mean) parameter for the normal distribution to sample the change in thres" +
-        "hold.");
-      // 
-      // thresholdChangeMuTextBox
-      // 
-      this.thresholdChangeMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
-      this.thresholdChangeMuTextBox.Location = new System.Drawing.Point(149, 15);
-      this.thresholdChangeMuTextBox.Name = "thresholdChangeMuTextBox";
-      this.thresholdChangeMuTextBox.Size = new System.Drawing.Size(168, 20);
-      this.thresholdChangeMuTextBox.TabIndex = 1;
-      this.toolTip.SetToolTip(this.thresholdChangeMuTextBox, "The mu (mean) parameter for the normal distribution to sample the change in thres" +
-        "hold.");
-      this.thresholdChangeMuTextBox.TextChanged += new System.EventHandler(this.thresholdChangeMuTextBox_TextChanged);
+              "thresholds.");
+      this.thresholdInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.ThresholdInitializationSigmaTextBox_TextChanged);
+      // 
+      // thresholdInitializationMuLabel
+      // 
+      this.thresholdInitializationMuLabel.AutoSize = true;
+      this.thresholdInitializationMuLabel.Location = new System.Drawing.Point(6, 18);
+      this.thresholdInitializationMuLabel.Name = "thresholdInitializationMuLabel";
+      this.thresholdInitializationMuLabel.Size = new System.Drawing.Size(80, 13);
+      this.thresholdInitializationMuLabel.TabIndex = 0;
+      this.thresholdInitializationMuLabel.Text = "Threshold (mu):";
+      this.toolTip.SetToolTip(this.thresholdInitializationMuLabel, "The mu (mean) parameter of the normal distribution to use for initial weights.");
+      // 
+      // thresholdInitializationMuTextBox
+      // 
+      this.thresholdInitializationMuTextBox.Anchor = ((System.Windows.Forms.AnchorStyles)(((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
+      this.thresholdInitializationMuTextBox.Location = new System.Drawing.Point(114, 15);
+      this.thresholdInitializationMuTextBox.Name = "thresholdInitializationMuTextBox";
+      this.thresholdInitializationMuTextBox.Size = new System.Drawing.Size(380, 20);
+      this.thresholdInitializationMuTextBox.TabIndex = 1;
+      this.toolTip.SetToolTip(this.thresholdInitializationMuTextBox, "The mu (mean) parameter of the normal distribution from which to sample the initi" +
+              "al thresholds.");
+      this.thresholdInitializationMuTextBox.TextChanged += new System.EventHandler(this.ThresholdInitializationMuTextBox_TextChanged);
       // 
       // VariableConditionView
       // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
-      this.Controls.Add(this.mutationGroupBox);
-      this.Controls.Add(this.initializationGroupBox);
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
+      this.Controls.Add(this.tabControl);
       this.Name = "VariableConditionView";
-      this.Size = new System.Drawing.Size(326, 376);
+      this.Size = new System.Drawing.Size(520, 426);
       this.Controls.SetChildIndex(this.maximumArityLabel, 0);
       this.Controls.SetChildIndex(this.maximumArityTextBox, 0);
@@ -323,15 +375,16 @@
       this.Controls.SetChildIndex(this.minimumArityTextBox, 0);
       this.Controls.SetChildIndex(this.infoLabel, 0);
-      this.Controls.SetChildIndex(this.initializationGroupBox, 0);
       this.Controls.SetChildIndex(this.initialFrequencyTextBox, 0);
       this.Controls.SetChildIndex(this.initialFrequencyLabel, 0);
       this.Controls.SetChildIndex(this.nameLabel, 0);
       this.Controls.SetChildIndex(this.nameTextBox, 0);
-      this.Controls.SetChildIndex(this.mutationGroupBox, 0);
+      this.Controls.SetChildIndex(this.tabControl, 0);
       ((System.ComponentModel.ISupportInitialize)(this.errorProvider)).EndInit();
+      this.mutationGroupBox.ResumeLayout(false);
+      this.mutationGroupBox.PerformLayout();
+      this.tabControl.ResumeLayout(false);
+      this.parametersTabPage.ResumeLayout(false);
       this.initializationGroupBox.ResumeLayout(false);
       this.initializationGroupBox.PerformLayout();
-      this.mutationGroupBox.ResumeLayout(false);
-      this.mutationGroupBox.PerformLayout();
       this.ResumeLayout(false);
       this.PerformLayout();
@@ -341,9 +394,4 @@
     #endregion
 
-    private System.Windows.Forms.Label thresholdInitializationMuLabel;
-    private System.Windows.Forms.TextBox thresholdInitializationMuTextBox;
-    protected System.Windows.Forms.GroupBox initializationGroupBox;
-    private System.Windows.Forms.Label thresholdInitializationSigmaLabel;
-    private System.Windows.Forms.TextBox thresholdInitializationSigmaTextBox;
     protected System.Windows.Forms.GroupBox mutationGroupBox;
     private System.Windows.Forms.Label thresholdChangeSigmaLabel;
@@ -351,12 +399,20 @@
     private System.Windows.Forms.Label ThresholdChangeMuLabel;
     private System.Windows.Forms.TextBox thresholdChangeMuTextBox;
+    private System.Windows.Forms.Label slopeChangeSigmaLabel;
+    private System.Windows.Forms.TextBox slopeChangeSigmaTextBox;
+    private System.Windows.Forms.Label slopeChangeMuLabel;
+    private System.Windows.Forms.TextBox slopeChangeMuTextBox;
+    protected System.Windows.Forms.TabControl tabControl;
+    protected System.Windows.Forms.TabPage variableNamesTabPage;
+    protected System.Windows.Forms.TabPage parametersTabPage;
+    protected System.Windows.Forms.GroupBox initializationGroupBox;
     private System.Windows.Forms.Label slopeInitializationSigmaLabel;
     private System.Windows.Forms.TextBox slopeInitializationSigmaTextBox;
     private System.Windows.Forms.Label slopeInitializationMuLabel;
     private System.Windows.Forms.TextBox slopeInitializationMuTextBox;
-    private System.Windows.Forms.Label slopeChangeSigmaLabel;
-    private System.Windows.Forms.TextBox slopeChangeSigmaTextBox;
-    private System.Windows.Forms.Label slopeChangeMuLabel;
-    private System.Windows.Forms.TextBox slopeChangeMuTextBox;
+    private System.Windows.Forms.Label thresholdInitializationSigmaLabel;
+    private System.Windows.Forms.TextBox thresholdInitializationSigmaTextBox;
+    private System.Windows.Forms.Label thresholdInitializationMuLabel;
+    private System.Windows.Forms.TextBox thresholdInitializationMuTextBox;
 
   }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableConditionView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableConditionView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableConditionView.cs	(revision 8430)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -21,5 +21,10 @@
 
 using System;
+using System.Linq;
 using System.Windows.Forms;
+using HeuristicLab.Collections;
+using HeuristicLab.Core;
+using HeuristicLab.Core.Views;
+using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views;
 using HeuristicLab.MainForm;
@@ -30,4 +35,6 @@
   [Content(typeof(VariableCondition), true)]
   public partial class VariableConditionView : SymbolView {
+    private readonly CheckedItemCollectionView<StringValue> variableNamesView;
+
     public new VariableCondition Content {
       get { return (VariableCondition)base.Content; }
@@ -37,4 +44,30 @@
     public VariableConditionView() {
       InitializeComponent();
+      variableNamesView = new CheckedItemCollectionView<StringValue>();
+      variableNamesView.Dock = DockStyle.Fill;
+      variableNamesTabPage.Controls.Add(variableNamesView);
+      variableNamesView.Content = new CheckedItemCollection<StringValue>();
+
+      RegisterVariableNamesViewContentEvents();
+    }
+
+    private void RegisterVariableNamesViewContentEvents() {
+      variableNamesView.Content.ItemsAdded += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.ItemsRemoved += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CheckedItemsChanged += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CollectionReset += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      foreach (var variable in variableNamesView.Content) {
+        variable.ValueChanged += new EventHandler(Variable_ValueChanged);
+      }
+    }
+
+    private void DeregisterVariableNamesViewContentEvents() {
+      variableNamesView.Content.ItemsAdded -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.ItemsRemoved -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CheckedItemsChanged -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CollectionReset -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      foreach (var variable in variableNamesView.Content) {
+        variable.ValueChanged -= new EventHandler(Variable_ValueChanged);
+      }
     }
 
@@ -76,6 +109,4 @@
     }
 
-
-
     private void UpdateControl() {
       if (Content == null) {
@@ -88,5 +119,20 @@
         slopeChangeMuTextBox.Text = string.Empty;
         slopeChangeSigmaTextBox.Text = string.Empty;
+        // temporarily deregister to prevent circular calling of events
+        DeregisterVariableNamesViewContentEvents();
+        variableNamesView.Content.Clear();
+        RegisterVariableNamesViewContentEvents();
       } else {
+        var existingEntries = variableNamesView.Content.ToList();
+
+        // temporarily deregister to prevent circular calling of events
+        DeregisterVariableNamesViewContentEvents();
+        // add additional entries
+        foreach (var variableName in Content.VariableNames.Except(existingEntries.Select(x => x.Value)))
+          variableNamesView.Content.Add(new StringValue(variableName), true);
+        foreach (var oldEntry in existingEntries.Where(x => !Content.VariableNames.Contains(x.Value)))
+          variableNamesView.Content.Remove(oldEntry);
+        RegisterVariableNamesViewContentEvents();
+
         thresholdInitializationMuTextBox.Text = Content.ThresholdInitializerMu.ToString();
         thresholdInitializationSigmaTextBox.Text = Content.ThresholdInitializerSigma.ToString();
@@ -102,5 +148,25 @@
 
     #region control events
-    private void thresholdMuTextBox_TextChanged(object sender, EventArgs e) {
+    private void VariableNames_Changed(object sender, CollectionItemsChangedEventArgs<StringValue> e) {
+      foreach (var newVar in e.Items)
+        newVar.ValueChanged += new EventHandler(Variable_ValueChanged);
+      foreach (var oldVar in e.OldItems)
+        oldVar.ValueChanged -= new EventHandler(Variable_ValueChanged);
+      UpdateContent();
+    }
+
+    private void Variable_ValueChanged(object sender, EventArgs e) {
+      UpdateContent();
+    }
+
+    private void UpdateContent() {
+      if (Content != null) {
+        DeregisterContentEvents();
+        Content.VariableNames = variableNamesView.Content.CheckedItems.Select(x => x.Value).ToList();
+        RegisterContentEvents();
+      }
+    }
+
+    private void ThresholdInitializationMuTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(thresholdInitializationMuTextBox.Text, out value)) {
@@ -109,5 +175,5 @@
       } else errorProvider.SetError(thresholdInitializationMuTextBox, "Invalid value");
     }
-    private void thresholdInitializationSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void ThresholdInitializationSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(thresholdInitializationSigmaTextBox.Text, out value)) {
@@ -116,5 +182,5 @@
       } else errorProvider.SetError(thresholdInitializationSigmaTextBox, "Invalid value");
     }
-    private void slopeInitializationMuTextBox_TextChanged(object sender, EventArgs e) {
+    private void SlopeInitializationMuTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(slopeInitializationMuTextBox.Text, out value)) {
@@ -123,5 +189,5 @@
       } else errorProvider.SetError(slopeInitializationMuTextBox, "Invalid value");
     }
-    private void slopeInitializationSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void SlopeInitializationSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(slopeInitializationSigmaTextBox.Text, out value)) {
@@ -131,5 +197,5 @@
     }
 
-    private void thresholdChangeMuTextBox_TextChanged(object sender, EventArgs e) {
+    private void ThresholdChangeMuTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(thresholdChangeMuTextBox.Text, out value)) {
@@ -139,5 +205,5 @@
     }
 
-    private void thresholdChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void ThresholdChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(thresholdChangeSigmaTextBox.Text, out value)) {
@@ -146,5 +212,5 @@
       } else errorProvider.SetError(thresholdChangeSigmaTextBox, "Invalid value");
     }
-    private void slopeChangeMuTextBox_TextChanged(object sender, EventArgs e) {
+    private void SlopeChangeMuTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(slopeChangeMuTextBox.Text, out value)) {
@@ -154,5 +220,5 @@
     }
 
-    private void slopeChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void SlopeChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double value;
       if (double.TryParse(slopeChangeSigmaTextBox.Text, out value)) {
@@ -162,5 +228,4 @@
     }
     #endregion
-
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableView.Designer.cs	(revision 8430)
@@ -74,4 +74,12 @@
       this.initialFrequencyTextBox.Size = new System.Drawing.Size(311, 20);
       // 
+      // minimumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.minimumArityLabel, "The minimum arity of the symbol");
+      // 
+      // maximumArityLabel
+      // 
+      this.toolTip.SetToolTip(this.maximumArityLabel, "The maximum arity of the symbol");
+      // 
       // minimumArityTextBox
       // 
@@ -114,5 +122,5 @@
       this.toolTip.SetToolTip(this.weightInitializationMuTextBox, "The mu (mean) parameter of the normal distribution from which to sample the initi" +
         "al weights.");
-      this.weightInitializationMuTextBox.TextChanged += new System.EventHandler(this.weightMuTextBox_TextChanged);
+      this.weightInitializationMuTextBox.TextChanged += new System.EventHandler(this.WeightMuTextBox_TextChanged);
       // 
       // initializationGroupBox
@@ -151,5 +159,5 @@
       this.toolTip.SetToolTip(this.weightInitializationSigmaTextBox, "The sigma parameter for the normal distribution from which to sample the initial " +
         "weights.");
-      this.weightInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.weightSigmaTextBox_TextChanged);
+      this.weightInitializationSigmaTextBox.TextChanged += new System.EventHandler(this.WeightSigmaTextBox_TextChanged);
       // 
       // mutationGroupBox
@@ -189,5 +197,5 @@
       this.toolTip.SetToolTip(this.multiplicativeWeightChangeSigmaTextBox, "The sigma (std.dev.) parameter for the normal distribution to sample a multiplica" +
         "tive change in weight.");
-      this.multiplicativeWeightChangeSigmaTextBox.TextChanged += new System.EventHandler(this.multiplicativeWeightChangeSigmaTextBox_TextChanged);
+      this.multiplicativeWeightChangeSigmaTextBox.TextChanged += new System.EventHandler(this.MultiplicativeWeightChangeSigmaTextBox_TextChanged);
       // 
       // additiveWeightChangeLabel
@@ -212,5 +220,5 @@
       this.toolTip.SetToolTip(this.additiveWeightChangeSigmaTextBox, "The sigma (std.dev.) parameter for the normal distribution to sample an additive " +
         "change in weight.");
-      this.additiveWeightChangeSigmaTextBox.TextChanged += new System.EventHandler(this.additiveWeightChangeSigmaTextBox_TextChanged);
+      this.additiveWeightChangeSigmaTextBox.TextChanged += new System.EventHandler(this.AdditiveWeightChangeSigmaTextBox_TextChanged);
       // 
       // tabControl
@@ -232,5 +240,5 @@
       this.variableNamesTabPage.Name = "variableNamesTabPage";
       this.variableNamesTabPage.Padding = new System.Windows.Forms.Padding(3);
-      this.variableNamesTabPage.Size = new System.Drawing.Size(400, 141);
+      this.variableNamesTabPage.Size = new System.Drawing.Size(400, 164);
       this.variableNamesTabPage.TabIndex = 0;
       this.variableNamesTabPage.Text = "Variable Names";
@@ -252,5 +260,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.tabControl);
       this.Name = "VariableView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/Symbols/VariableView.cs	(revision 8430)
@@ -54,10 +54,10 @@
 
     private void RegisterVariableNamesViewContentEvents() {
-      variableNamesView.Content.ItemsAdded += new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
-      variableNamesView.Content.ItemsRemoved += new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
-      variableNamesView.Content.CheckedItemsChanged += new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
-      variableNamesView.Content.CollectionReset += new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
+      variableNamesView.Content.ItemsAdded += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.ItemsRemoved += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CheckedItemsChanged += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CollectionReset += new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
       foreach (var variable in variableNamesView.Content) {
-        variable.ValueChanged += new EventHandler(variable_ValueChanged);
+        variable.ValueChanged += new EventHandler(Variable_ValueChanged);
       }
     }
@@ -65,10 +65,10 @@
 
     private void DeregisterVariableNamesViewContentEvents() {
-      variableNamesView.Content.ItemsAdded -= new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
-      variableNamesView.Content.ItemsRemoved -= new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
-      variableNamesView.Content.CheckedItemsChanged -= new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
-      variableNamesView.Content.CollectionReset -= new CollectionItemsChangedEventHandler<StringValue>(variableNames_Changed);
+      variableNamesView.Content.ItemsAdded -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.ItemsRemoved -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CheckedItemsChanged -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
+      variableNamesView.Content.CollectionReset -= new CollectionItemsChangedEventHandler<StringValue>(VariableNames_Changed);
       foreach (var variable in variableNamesView.Content) {
-        variable.ValueChanged -= new EventHandler(variable_ValueChanged);
+        variable.ValueChanged -= new EventHandler(Variable_ValueChanged);
       }
     }
@@ -109,15 +109,13 @@
 
     #region control event handlers
-    private void variableNames_Changed(object sender, CollectionItemsChangedEventArgs<StringValue> args) {
-      if (args.Items != null)
-        foreach (var newVar in args.Items)
-          newVar.ValueChanged += new EventHandler(variable_ValueChanged);
-      if (args.OldItems != null)
-        foreach (var oldVar in args.OldItems)
-          oldVar.ValueChanged -= new EventHandler(variable_ValueChanged);
+    private void VariableNames_Changed(object sender, CollectionItemsChangedEventArgs<StringValue> e) {
+      foreach (var newVar in e.Items)
+        newVar.ValueChanged += new EventHandler(Variable_ValueChanged);
+      foreach (var oldVar in e.OldItems)
+        oldVar.ValueChanged -= new EventHandler(Variable_ValueChanged);
       UpdateContent();
     }
 
-    private void variable_ValueChanged(object sender, EventArgs e) {
+    private void Variable_ValueChanged(object sender, EventArgs e) {
       UpdateContent();
     }
@@ -131,6 +129,5 @@
     }
 
-
-    private void weightMuTextBox_TextChanged(object sender, EventArgs e) {
+    private void WeightMuTextBox_TextChanged(object sender, EventArgs e) {
       double nu;
       if (double.TryParse(weightInitializationMuTextBox.Text, out nu)) {
@@ -141,5 +138,5 @@
       }
     }
-    private void weightSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void WeightSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double sigma;
       if (double.TryParse(weightInitializationSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
@@ -151,5 +148,5 @@
     }
 
-    private void additiveWeightChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void AdditiveWeightChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double sigma;
       if (double.TryParse(additiveWeightChangeSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
@@ -160,5 +157,5 @@
       }
     }
-    private void multiplicativeWeightChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
+    private void MultiplicativeWeightChangeSigmaTextBox_TextChanged(object sender, EventArgs e) {
       double sigma;
       if (double.TryParse(multiplicativeWeightChangeSigmaTextBox.Text, out sigma) && sigma >= 0.0) {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TextualSymbolicDataAnalysisModelView.designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TextualSymbolicDataAnalysisModelView.designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/TextualSymbolicDataAnalysisModelView.designer.cs	(revision 8430)
@@ -64,5 +64,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.symbolicExpressionTreeView);
       this.Name = "SymbolicExpressionModelView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs	(revision 8430)
@@ -70,16 +70,20 @@
 
     protected override Allele[] CalculateAlleles(ISymbolicExpressionTree solution) {
-      return GetAllSubtreesOfDepth(solution, AlleleTreeDepth)
+      return CalculateAlleles(solution, AlleleTreeDepth);
+    }
+
+    public static Allele[] CalculateAlleles(ISymbolicExpressionTree solution, int alleleTreedepth) {
+      return GetAllSubtreesOfDepth(solution, alleleTreedepth)
         .AsParallel()
-        .Select(t => GetAlleleFromSubtreeOfDepth(t, AlleleTreeDepth))
+        .Select(t => GetAlleleFromSubtreeOfDepth(t, alleleTreedepth))
         .ToArray();
     }
 
-    private Allele GetAlleleFromSubtreeOfDepth(ISymbolicExpressionTreeNode tree, int d) {
+    private static Allele GetAlleleFromSubtreeOfDepth(ISymbolicExpressionTreeNode tree, int d) {
       string textualRepresentation = GetTextualRepresentationFromSubtreeOfDepth(tree, d);
       return new Allele(textualRepresentation);
     }
 
-    private string GetTextualRepresentationFromSubtreeOfDepth(ISymbolicExpressionTreeNode tree, int d) {
+    private static string GetTextualRepresentationFromSubtreeOfDepth(ISymbolicExpressionTreeNode tree, int d) {
       if (d == 0) return "";
       StringBuilder builder = new StringBuilder();
@@ -100,5 +104,5 @@
     }
 
-    private IEnumerable<ISymbolicExpressionTreeNode> GetAllSubtreesOfDepth(ISymbolicExpressionTree solution, int d) {
+    private static IEnumerable<ISymbolicExpressionTreeNode> GetAllSubtreesOfDepth(ISymbolicExpressionTree solution, int d) {
       return from node in solution.IterateNodesPostfix()
              where node.GetDepth() >= d
Index: anches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisComplexityAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisComplexityAnalyzer.cs	(revision 8429)
+++ 	(revision )
@@ -1,147 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Analysis;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Optimization;
-using HeuristicLab.Parameters;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.PluginInfrastructure;
-using HeuristicLab.PluginInfrastructure.Manager;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  /// <summary>
-  /// Calculates the complexity of all trees in the population.
-  /// </summary>
-  [Item("SymbolicDataAnalysisComplexityAnalyzer", "Calculates the complexity of all trees in the population.")]
-  [StorableClass]
-  public sealed class SymbolicDataAnalysisComplexityAnalyzer : SymbolicDataAnalysisAnalyzer {
-    private const string ComplexityParameterName = "Complexity";
-    private const string WeightsParameterName = "Weights";
-    
-    public override bool EnabledByDefault {
-      get { return false; }
-    }
-
-    #region parameter properties
-    public IScopeTreeLookupParameter<DoubleValue> ComplexityParameter {
-      get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
-    }
-    public IValueParameter<ItemDictionary<StringValue, DoubleValue>> WeightsParameter {
-      get { return (IValueParameter<ItemDictionary<StringValue, DoubleValue>>)Parameters[WeightsParameterName]; }
-    }
-    #endregion
-
-    [StorableConstructor]
-    private SymbolicDataAnalysisComplexityAnalyzer(bool deserializing) : base(deserializing) { }
-    private SymbolicDataAnalysisComplexityAnalyzer(SymbolicDataAnalysisComplexityAnalyzer original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    public SymbolicDataAnalysisComplexityAnalyzer()
-      : base() {
-      var defaultWeights = new Dictionary<string, double>()
-                             {
-                                { "StartSymbol", 0.0},
-                                { "ProgramRootSymbol", 0.0},
-                                { "Addition", 1.0 },
-                                { "AiryA", 10.0 },
-                                { "AiryB", 10.0 },
-                                { "And", 2.0 },
-                                { "Average", 2.0 },
-                                { "Bessel", 10.0 },
-                                { "Constant", 1.0 },
-                                { "Cosine", 5.0 },
-                                { "CosineIntegral", 10.0 },
-                                { "Dawson", 10.0 },
-                                { "Derivative", 5.0 },
-                                { "Division", 2.0 },
-                                { "Erf", 10.0 },
-                                { "Exponential", 5.0 },
-                                { "ExponentialIntegralEi", 10.0 },
-                                { "FresnelCosineIntegral", 10.0 },
-                                { "FresnelSineIntegral", 10.0 },
-                                { "Gamma", 10.0 },
-                                { "GreaterThan", 2.0 },
-                                { "HyperbolicCosineIntegral", 10.0 },
-                                { "HyperbolicSineIntegral", 10.0 },
-                                { "IfThenElse", 3.0 },
-                                { "Integral", 5.0},
-                                { "LaggedVariable", 2.0 },
-                                { "LessThan", 2.0 },
-                                { "Logarithm", 5.0 },
-                                { "Multiplication", 2.0 },
-                                { "Norm", 10.0 },
-                                { "Not", 2.0 },
-                                { "Or", 1.0 },
-                                { "Power", 5.0 },
-                                { "Psi", 10.0 },
-                                { "Root", 5.0 },
-                                { "Sine", 5.0 },
-                                { "SineIntegral", 10.0 },
-                                { "Square", 2.0 },
-                                { "SquareRoot", 2.0 },
-                                { "Subtraction", 1.0 },
-                                { "Tangent", 3.0 },
-                                { "TimeLag", 3.0 },
-                                { "Variable", 1.0 },
-                                { "Variable Condition", 5.0 },
-                             };
-
-      var defaultWeightsTable = new ItemDictionary<StringValue, DoubleValue>();
-      foreach (var p in defaultWeights) {
-        defaultWeightsTable.Add(new StringValue(p.Key), new DoubleValue(p.Value));
-      }
-      Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of the tree."));
-      Parameters.Add(new ValueParameter<ItemDictionary<StringValue, DoubleValue>>(WeightsParameterName, "A table with complexity weights for each symbol.", defaultWeightsTable));
-    }
-
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new SymbolicDataAnalysisComplexityAnalyzer(this, cloner);
-    }
-
-    public override IOperation Apply() {
-      ItemArray<ISymbolicExpressionTree> expressions = SymbolicExpressionTreeParameter.ActualValue;
-      var weightsTable = WeightsParameter.Value;
-      var weights = new Dictionary<string, double>();
-      foreach (var p in weightsTable)
-        weights.Add(p.Key.Value, p.Value.Value);
-      var complexities = from t in expressions
-                         select CalculateComplexity(t, weights);
-      ComplexityParameter.ActualValue = new ItemArray<DoubleValue>(complexities.Select(x => new DoubleValue(x)).ToArray());
-      return base.Apply();
-    }
-
-    private double CalculateComplexity(ISymbolicExpressionTree t, Dictionary<string, double> weights) {
-      double c = 0.0;
-      foreach (var n in t.Root.IterateNodesPrefix()) {
-        if (!weights.ContainsKey(n.Symbol.Name)) throw new ArgumentException("Weight for symbol " + n.Symbol.Name + " is not defined.");
-        c += weights[n.Symbol.Name];
-      }
-      return c;
-    }
-  }
-}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs	(revision 8430)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,9 +27,7 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -38,9 +37,13 @@
   [Item("SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer", "An operator that analyzes the Pareto-best symbolic data analysis solution for single objective symbolic data analysis problems.")]
   [StorableClass]
-  public abstract class SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<T> : SymbolicDataAnalysisSingleObjectiveAnalyzer
-    where T : class, ISymbolicDataAnalysisSolution {
+  public abstract class SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<S, T> : SymbolicDataAnalysisSingleObjectiveAnalyzer, ISymbolicDataAnalysisInterpreterOperator, ISymbolicDataAnalysisBoundedOperator
+    where T : class, ISymbolicDataAnalysisSolution
+    where S : class, IDataAnalysisProblemData {
+    private const string ProblemDataParameterName = "ProblemData";
     private const string TrainingBestSolutionsParameterName = "Best training solutions";
     private const string TrainingBestSolutionQualitiesParameterName = "Best training solution qualities";
     private const string ComplexityParameterName = "Complexity";
+    private const string SymbolicDataAnalysisTreeInterpreterParameterName = "SymbolicDataAnalysisTreeInterpreter";
+    private const string EstimationLimitsParameterName = "EstimationLimits";
 
     public override bool EnabledByDefault {
@@ -58,4 +61,13 @@
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
     }
+    public ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter> SymbolicDataAnalysisTreeInterpreterParameter {
+      get { return (ILookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>)Parameters[SymbolicDataAnalysisTreeInterpreterParameterName]; }
+    }
+    public ILookupParameter<S> ProblemDataParameter {
+      get { return (ILookupParameter<S>)Parameters[ProblemDataParameterName]; }
+    }
+    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
+      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
     #endregion
     #region properties
@@ -72,10 +84,13 @@
     [StorableConstructor]
     protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(bool deserializing) : base(deserializing) { }
-    protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<T> original, Cloner cloner) : base(original, cloner) { }
+    protected SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer(SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer<S, T> original, Cloner cloner) : base(original, cloner) { }
     public SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer()
       : base() {
+      Parameters.Add(new LookupParameter<S>(ProblemDataParameterName, "The problem data for the symbolic data analysis solution."));
       Parameters.Add(new LookupParameter<ItemList<T>>(TrainingBestSolutionsParameterName, "The training best (Pareto-optimal) symbolic data analysis solutions."));
       Parameters.Add(new LookupParameter<ItemList<DoubleArray>>(TrainingBestSolutionQualitiesParameterName, "The qualities of the training best (Pareto-optimal) solutions."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of each tree."));
+      Parameters.Add(new LookupParameter<ISymbolicDataAnalysisExpressionTreeInterpreter>(SymbolicDataAnalysisTreeInterpreterParameterName, "The symbolic data analysis tree interpreter for the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic classification model."));
     }
 
@@ -100,5 +115,5 @@
 
       List<double> complexities;
-      if (ComplexityParameter.ActualValue != null) {
+      if (ComplexityParameter.ActualValue != null && ComplexityParameter.ActualValue.Length == qualities.Count) {
         complexities = ComplexityParameter.ActualValue.Select(x => x.Value).ToList();
       } else {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs	(revision 8430)
@@ -20,4 +20,5 @@
 #endregion
 
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -26,9 +27,7 @@
 using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using System;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -38,5 +37,5 @@
   [Item("SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer", "An operator that analyzes the Pareto-best symbolic data analysis solution for single objective symbolic data analysis problems.")]
   [StorableClass]
-  public abstract class SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<S, T, U> : SymbolicDataAnalysisSingleObjectiveValidationAnalyzer<T, U>
+  public abstract class SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer<S, T, U> : SymbolicDataAnalysisSingleObjectiveValidationAnalyzer<T, U>, ISymbolicDataAnalysisBoundedOperator
     where S : class, ISymbolicDataAnalysisSolution
     where T : class, ISymbolicDataAnalysisSingleObjectiveEvaluator<U>
@@ -45,4 +44,5 @@
     private const string ValidationBestSolutionQualitiesParameterName = "Best validation solution qualities";
     private const string ComplexityParameterName = "Complexity";
+    private const string EstimationLimitsParameterName = "EstimationLimits";
 
     public override bool EnabledByDefault {
@@ -60,4 +60,8 @@
       get { return (IScopeTreeLookupParameter<DoubleValue>)Parameters[ComplexityParameterName]; }
     }
+    public IValueLookupParameter<DoubleLimit> EstimationLimitsParameter {
+      get { return (IValueLookupParameter<DoubleLimit>)Parameters[EstimationLimitsParameterName]; }
+    }
+
     #endregion
     #region properties
@@ -80,4 +84,5 @@
       Parameters.Add(new LookupParameter<ItemList<DoubleArray>>(ValidationBestSolutionQualitiesParameterName, "The qualities of the validation best (Pareto-optimal) solutions."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(ComplexityParameterName, "The complexity of each tree."));
+      Parameters.Add(new ValueLookupParameter<DoubleLimit>(EstimationLimitsParameterName, "The lower and upper limit for the estimated values produced by the symbolic classification model."));
     }
 
@@ -137,5 +142,5 @@
 
       List<double> complexities;
-      if (ComplexityParameter.ActualValue != null) {
+      if (ComplexityParameter.ActualValue != null && ComplexityParameter.ActualValue.Length == trainingQuality.Length) {
         complexities = ComplexityParameter.ActualValue.Select(x => x.Value).ToList();
       } else {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Crossovers/SymbolicDataAnalysisExpressionDepthConstrainedCrossover.cs	(revision 8430)
@@ -41,6 +41,6 @@
 
     #region Parameter properties
-    public ConstrainedValueParameter<StringValue> DepthRangeParameter {
-      get { return (ConstrainedValueParameter<StringValue>)Parameters[DepthRangeParameterName]; }
+    public IConstrainedValueParameter<StringValue> DepthRangeParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[DepthRangeParameterName]; }
     }
     #endregion
@@ -89,14 +89,14 @@
       var depthRange = new IntRange();
       const int depthOffset = 2; // skip the first 2 levels (root + startNode)
-      switch ((int)Enum.Parse(typeof(Ranges), mode)) {
-        case (int)Ranges.HighLevel:
+      switch ((Ranges)Enum.Parse(typeof(Ranges), mode)) {
+        case Ranges.HighLevel:
           depthRange.Start = depthOffset; // skip the first 2 levels (root + startNode)
           depthRange.End = depthRange.Start + (int)Math.Round(depth * 0.25);
           break;
-        case (int)Ranges.Standard:
+        case Ranges.Standard:
           depthRange.Start = depthOffset + (int)Math.Round(depth * 0.25);
           depthRange.End = depthRange.Start + (int)Math.Round(depth * 0.5);
           break;
-        case (int)Ranges.LowLevel:
+        case Ranges.LowLevel:
           depthRange.Start = depthOffset + (int)Math.Round(depth * 0.75);
           depthRange.End = Math.Max(depthRange.Start, depth);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs	(revision 8430)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -58,5 +58,4 @@
         StringBuilder strBuilder = new StringBuilder();
         constants.Clear();
-        targetCount = 1;
         strBuilder.AppendLine(FormatRecursively(symbolicExpressionTree.Root));
         return strBuilder.ToString();
@@ -75,8 +74,10 @@
         strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
       }
+      int i = 1;
       foreach (SymbolicExpressionTreeNode subTree in node.Subtrees.Skip(1)) {
-        FormatSep(node, strBuilder);
+        FormatSep(node, strBuilder, i);
         // format the whole subtree
         strBuilder.Append(FormatRecursively(subTree));
+        i++;
       }
 
@@ -225,5 +226,5 @@
     }
 
-    private void FormatSep(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+    private void FormatSep(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, int step) {
       if (node.Symbol is Addition) {
         strBuilder.Append(" + ");
@@ -233,6 +234,6 @@
         strBuilder.Append(@" \cdot ");
       } else if (node.Symbol is Division) {
-        if (node.SubtreeCount <= 2)
-          strBuilder.Append(@" }{ ");
+        if (step + 1 == node.SubtreeCount)
+          strBuilder.Append(@"}{");
         else
           strBuilder.Append(@" }{ \cfrac{ ");
@@ -326,10 +327,7 @@
       } else if (node.Symbol is Multiplication) {
       } else if (node.Symbol is Division) {
-        if (node.SubtreeCount == 1 || node.SubtreeCount == 2)
+        strBuilder.Append(" } ");
+        for (int i = 2; i < node.SubtreeCount; i++)
           strBuilder.Append(" } ");
-        else
-          for (int i = 0; i < node.SubtreeCount; i++) {
-            strBuilder.Append(" } ");
-          }
       } else if (node.Symbol is Average) {
         strBuilder.Append(@" \right) ");
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs	(revision 8430)
@@ -231,4 +231,64 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(")");
+      } else if (node.Symbol is AiryA) {
+        stringBuilder.Append("airy(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is AiryB) {
+        stringBuilder.Append("airy(2, ");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is Bessel) {
+        stringBuilder.Append("besseli(0.0,");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is CosineIntegral) {
+        stringBuilder.Append("cosint(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is Dawson) {
+        stringBuilder.Append("dawson(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is Erf) {
+        stringBuilder.Append("erf(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is ExponentialIntegralEi) {
+        stringBuilder.Append("expint(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is FresnelCosineIntegral) {
+        stringBuilder.Append("FresnelC(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is FresnelSineIntegral) {
+        stringBuilder.Append("FresnelS(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is Gamma) {
+        stringBuilder.Append("gamma(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is HyperbolicCosineIntegral) {
+        stringBuilder.Append("Chi(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is HyperbolicSineIntegral) {
+        stringBuilder.Append("Shi(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is Norm) {
+        stringBuilder.Append("normpdf(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is Psi) {
+        stringBuilder.Append("psi(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (node.Symbol is SineIntegral) {
+        stringBuilder.Append("sinint(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
       } else if (symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
         VariableTreeNode variableTreeNode = node as VariableTreeNode;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 8430)
@@ -127,5 +127,4 @@
   <ItemGroup>
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectiveValidationParetoBestSolutionAnalyzer.cs" />
-    <Compile Include="Analyzers\SymbolicDataAnalysisComplexityAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisSingleObjectiveTrainingParetoBestSolutionAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicDataAnalysisMultiObjectiveValidationAnalyzer.cs" />
Index: anches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicTimeSeriesPrognogisExpressionTreeInterpreter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicTimeSeriesPrognogisExpressionTreeInterpreter.cs	(revision 8429)
+++ 	(revision )
@@ -1,32 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2011 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Collections.Generic;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public interface ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter : INamedItem {
-    IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset,
-                                                        string[] targetVariables, IEnumerable<int> rows);
-    IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, string[] targetVariables, IEnumerable<int> rows, int horizon);
-  }
-}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame	(revision 8430)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic","Provides base classes for symbolic data analysis tasks.", "3.4.2.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic","Provides base classes for symbolic data analysis tasks.", "3.4.3.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.ALGLIB", "3.5.0")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.2.$WCREV$")]
+[assembly: AssemblyFileVersion("3.4.3.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 8430)
@@ -0,0 +1,967 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableClass]
+  [Item("SymbolicDataAnalysisExpressionTreeILEmittingInterpreter", "Interpreter for symbolic expression trees.")]
+  public sealed class SymbolicDataAnalysisExpressionTreeILEmittingInterpreter : ParameterizedNamedItem,
+                                                                                ISymbolicDataAnalysisExpressionTreeInterpreter {
+    private static MethodInfo listGetValue =
+      typeof(IList<double>).GetProperty("Item", new Type[] { typeof(int) }).GetGetMethod();
+
+    private static MethodInfo cos = typeof(Math).GetMethod("Cos", new Type[] { typeof(double) });
+    private static MethodInfo sin = typeof(Math).GetMethod("Sin", new Type[] { typeof(double) });
+    private static MethodInfo tan = typeof(Math).GetMethod("Tan", new Type[] { typeof(double) });
+    private static MethodInfo exp = typeof(Math).GetMethod("Exp", new Type[] { typeof(double) });
+    private static MethodInfo log = typeof(Math).GetMethod("Log", new Type[] { typeof(double) });
+    private static MethodInfo power = typeof(Math).GetMethod("Pow", new Type[] { typeof(double), typeof(double) });
+    private static MethodInfo round = typeof(Math).GetMethod("Round", new Type[] { typeof(double) });
+    private static MethodInfo sqrt = typeof(Math).GetMethod("Sqrt", new Type[] { typeof(double) });
+
+    internal delegate double CompiledFunction(int sampleIndex, IList<double>[] columns, IList<double>[] cachedValues, int cacheStartIndex);
+    private static Type thisType = typeof(SymbolicDataAnalysisExpressionTreeILEmittingInterpreter);
+    private static MethodInfo airyA = thisType.GetMethod("AiryA", new Type[] { typeof(double) });
+    private static MethodInfo airyB = thisType.GetMethod("AiryB", new Type[] { typeof(double) });
+    private static MethodInfo gamma = thisType.GetMethod("Gamma", new Type[] { typeof(double) });
+    private static MethodInfo psi = thisType.GetMethod("Psi", new Type[] { typeof(double) });
+    private static MethodInfo dawson = thisType.GetMethod("Dawson", new Type[] { typeof(double) });
+    private static MethodInfo expIntegralEi = thisType.GetMethod("ExpIntegralEi", new Type[] { typeof(double) });
+    private static MethodInfo sinIntegral = thisType.GetMethod("SinIntegral", new Type[] { typeof(double) });
+    private static MethodInfo cosIntegral = thisType.GetMethod("CosIntegral", new Type[] { typeof(double) });
+    private static MethodInfo hypSinIntegral = thisType.GetMethod("HypSinIntegral", new Type[] { typeof(double) });
+    private static MethodInfo hypCosIntegral = thisType.GetMethod("HypCosIntegral", new Type[] { typeof(double) });
+    private static MethodInfo fresnelCosIntegral = thisType.GetMethod("FresnelCosIntegral", new Type[] { typeof(double) });
+    private static MethodInfo fresnelSinIntegral = thisType.GetMethod("FresnelSinIntegral", new Type[] { typeof(double) });
+    private static MethodInfo norm = thisType.GetMethod("Norm", new Type[] { typeof(double) });
+    private static MethodInfo erf = thisType.GetMethod("Erf", new Type[] { typeof(double) });
+    private static MethodInfo bessel = thisType.GetMethod("Bessel", new Type[] { typeof(double) });
+
+    
+
+    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
+    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
+
+    #region private classes
+
+    private class InterpreterState {
+      private Instruction[] code;
+      private int pc;
+
+      public int ProgramCounter {
+        get { return pc; }
+        set { pc = value; }
+      }
+
+      private bool inLaggedContext;
+
+      public bool InLaggedContext {
+        get { return inLaggedContext; }
+        set { inLaggedContext = value; }
+      }
+
+      internal InterpreterState(Instruction[] code) {
+        this.inLaggedContext = false;
+        this.code = code;
+        this.pc = 0;
+      }
+
+      internal Instruction NextInstruction() {
+        return code[pc++];
+      }
+    }
+
+    private class OpCodes {
+      public const byte Add = 1;
+      public const byte Sub = 2;
+      public const byte Mul = 3;
+      public const byte Div = 4;
+
+      public const byte Sin = 5;
+      public const byte Cos = 6;
+      public const byte Tan = 7;
+
+      public const byte Log = 8;
+      public const byte Exp = 9;
+
+      public const byte IfThenElse = 10;
+
+      public const byte GT = 11;
+      public const byte LT = 12;
+
+      public const byte AND = 13;
+      public const byte OR = 14;
+      public const byte NOT = 15;
+
+
+      public const byte Average = 16;
+
+      public const byte Call = 17;
+
+      public const byte Variable = 18;
+      public const byte LagVariable = 19;
+      public const byte Constant = 20;
+      public const byte Arg = 21;
+
+      public const byte Power = 22;
+      public const byte Root = 23;
+      public const byte TimeLag = 24;
+      public const byte Integral = 25;
+      public const byte Derivative = 26;
+
+      public const byte VariableCondition = 27;
+
+      public const byte Square = 28;
+      public const byte SquareRoot = 29;
+      public const byte Gamma = 30;
+      public const byte Psi = 31;
+      public const byte Dawson = 32;
+      public const byte ExponentialIntegralEi = 33;
+      public const byte CosineIntegral = 34;
+      public const byte SineIntegral = 35;
+      public const byte HyperbolicCosineIntegral = 36;
+      public const byte HyperbolicSineIntegral = 37;
+      public const byte FresnelCosineIntegral = 38;
+      public const byte FresnelSineIntegral = 39;
+      public const byte AiryA = 40;
+      public const byte AiryB = 41;
+      public const byte Norm = 42;
+      public const byte Erf = 43;
+      public const byte Bessel = 44;
+    }
+
+    #endregion
+
+    private Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>()
+                                                      {
+                                                        {typeof (Addition), OpCodes.Add},
+                                                        {typeof (Subtraction), OpCodes.Sub},
+                                                        {typeof (Multiplication), OpCodes.Mul},
+                                                        {typeof (Division), OpCodes.Div},
+                                                        {typeof (Sine), OpCodes.Sin},
+                                                        {typeof (Cosine), OpCodes.Cos},
+                                                        {typeof (Tangent), OpCodes.Tan},
+                                                        {typeof (Logarithm), OpCodes.Log},
+                                                        {typeof (Exponential), OpCodes.Exp},
+                                                        {typeof (IfThenElse), OpCodes.IfThenElse},
+                                                        {typeof (GreaterThan), OpCodes.GT},
+                                                        {typeof (LessThan), OpCodes.LT},
+                                                        {typeof (And), OpCodes.AND},
+                                                        {typeof (Or), OpCodes.OR},
+                                                        {typeof (Not), OpCodes.NOT},
+                                                        {typeof (Average), OpCodes.Average},
+                                                        {typeof (InvokeFunction), OpCodes.Call},
+                                                        {
+                                                          typeof (HeuristicLab.Problems.DataAnalysis.Symbolic.Variable),
+                                                          OpCodes.Variable
+                                                          },
+                                                        {typeof (LaggedVariable), OpCodes.LagVariable},
+                                                        {typeof (Constant), OpCodes.Constant},
+                                                        {typeof (Argument), OpCodes.Arg},
+                                                        {typeof (Power), OpCodes.Power},
+                                                        {typeof (Root), OpCodes.Root},
+                                                        {typeof (TimeLag), OpCodes.TimeLag},
+                                                        {typeof (Integral), OpCodes.Integral},
+                                                        {typeof (Derivative), OpCodes.Derivative},
+                                                        {typeof (VariableCondition), OpCodes.VariableCondition},
+                                                        {typeof (Square), OpCodes.Square},
+                                                        {typeof (SquareRoot), OpCodes.SquareRoot},
+                                                        {typeof (Gamma), OpCodes.Gamma},
+                                                        {typeof (Psi), OpCodes.Psi},
+                                                        {typeof (Dawson), OpCodes.Dawson},
+                                                        {typeof (ExponentialIntegralEi), OpCodes.ExponentialIntegralEi},
+                                                        {typeof (CosineIntegral), OpCodes.CosineIntegral},
+                                                        {typeof (SineIntegral), OpCodes.SineIntegral},
+                                                        {
+                                                          typeof (HyperbolicCosineIntegral),
+                                                          OpCodes.HyperbolicCosineIntegral
+                                                          },
+                                                        {
+                                                          typeof (HyperbolicSineIntegral), OpCodes.HyperbolicSineIntegral
+                                                          },
+                                                        {typeof (FresnelCosineIntegral), OpCodes.FresnelCosineIntegral},
+                                                        {typeof (FresnelSineIntegral), OpCodes.FresnelSineIntegral},
+                                                        {typeof (AiryA), OpCodes.AiryA},
+                                                        {typeof (AiryB), OpCodes.AiryB},
+                                                        {typeof (Norm), OpCodes.Norm},
+                                                        {typeof (Erf), OpCodes.Erf},
+                                                        {typeof (Bessel), OpCodes.Bessel}
+                                                      };
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    #region parameter properties
+
+    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
+      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
+    }
+
+    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    }
+
+    #endregion
+
+    #region properties
+
+    public BoolValue CheckExpressionsWithIntervalArithmetic {
+      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
+      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
+    }
+
+    public IntValue EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value; }
+      set { EvaluatedSolutionsParameter.Value = value; }
+    }
+
+    #endregion
+
+
+    [StorableConstructor]
+    private SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(bool deserializing)
+      : base(deserializing) {
+    }
+
+    private SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(
+      SymbolicDataAnalysisExpressionTreeILEmittingInterpreter original, Cloner cloner)
+      : base(original, cloner) {
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(this, cloner);
+    }
+
+    public SymbolicDataAnalysisExpressionTreeILEmittingInterpreter()
+      : base("SymbolicDataAnalysisExpressionTreeILEmittingInterpreter", "Interpreter for symbolic expression trees.") {
+      Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
+                                                   "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.",
+                                                   new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName,
+                                                  "A counter for the total number of solutions the interpreter has evaluated",
+                                                  new IntValue(0)));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(EvaluatedSolutionsParameterName))
+        Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName,
+                                                    "A counter for the total number of solutions the interpreter has evaluated",
+                                                    new IntValue(0)));
+    }
+
+    #region IStatefulItem
+
+    public void InitializeState() {
+      EvaluatedSolutions.Value = 0;
+    }
+
+    public void ClearState() {
+      EvaluatedSolutions.Value = 0;
+    }
+
+    #endregion
+
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset,
+                                                               IEnumerable<int> rows) {
+      return GetSymbolicExpressionTreeValues(tree, dataset, new string[] { "#NOTHING#" }, rows);
+    }
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, string[] targetVariables, IEnumerable<int> rows) {
+      return GetSymbolicExpressionTreeValues(tree, dataset, targetVariables, rows, 1);
+    }
+    // for each row for each horizon for each target variable one value
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, string[] targetVariables, IEnumerable<int> rows, int horizon) {
+      if (CheckExpressionsWithIntervalArithmetic.Value)
+        throw new NotSupportedException(
+          "Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
+      EvaluatedSolutions.Value++; // increment the evaluated solutions counter
+      var compiler = new SymbolicExpressionTreeCompiler();
+      Instruction[] code = compiler.Compile(tree, MapSymbolToOpCode);
+      int necessaryArgStackSize = 0;
+
+      Dictionary<string, int> doubleVariableNames =
+        dataset.DoubleVariables.Select((x, i) => new { x, i }).ToDictionary(e => e.x, e => e.i);
+
+      for (int i = 0; i < code.Length; i++) {
+        Instruction instr = code[i];
+        if (instr.opCode == OpCodes.Variable) {
+          var variableTreeNode = instr.dynamicNode as VariableTreeNode;
+          instr.iArg0 = doubleVariableNames[variableTreeNode.VariableName];
+          code[i] = instr;
+        } else if (instr.opCode == OpCodes.LagVariable) {
+          var variableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
+          instr.iArg0 = doubleVariableNames[variableTreeNode.VariableName];
+          code[i] = instr;
+        } else if (instr.opCode == OpCodes.VariableCondition) {
+          var variableConditionTreeNode = instr.dynamicNode as VariableConditionTreeNode;
+          instr.iArg0 = doubleVariableNames[variableConditionTreeNode.VariableName];
+        } else if (instr.opCode == OpCodes.Call) {
+          necessaryArgStackSize += instr.nArguments + 1;
+        }
+      }
+      var state = new InterpreterState(code);
+      Type[] methodArgs = { typeof(int), typeof(IList<double>[]), typeof(IList<double>[]), typeof(int) };
+
+      CompiledFunction[] function = new CompiledFunction[targetVariables.Length];
+      for (int i = 0; i < function.Length; i++) {
+        DynamicMethod testFun = new DynamicMethod("TestFun", typeof(double), methodArgs, typeof(SymbolicDataAnalysisExpressionTreeILEmittingInterpreter).Module);
+        ILGenerator il = testFun.GetILGenerator();
+        CompileInstructions(il, state, dataset);
+        il.Emit(System.Reflection.Emit.OpCodes.Conv_R8);
+        il.Emit(System.Reflection.Emit.OpCodes.Ret);
+        function[i] = (CompiledFunction)testFun.CreateDelegate(typeof(CompiledFunction));
+      }
+      var values = doubleVariableNames.Keys
+        .Select(v => dataset.GetReadOnlyDoubleValues(v))
+        .ToArray();
+      var cachedValues = (from var in doubleVariableNames.Keys
+                          select new double[horizon]).ToArray();
+      foreach (var row in rows) {
+        // init first line of cache 
+        int c = 0;
+        foreach (var var in doubleVariableNames.Keys)
+          cachedValues[c++][0] = dataset.GetDoubleValue(var, row);
+        for (int horizonRow = row; horizonRow < row + horizon; horizonRow++) {
+          for (int i = 0; i < function.Length; i++) {
+            var componentProg = function[i](horizonRow, values, cachedValues, row);
+            // set cachedValues for prognosis of future values
+            if (horizon > 1)
+              cachedValues[doubleVariableNames[targetVariables[i]]][horizonRow - row] = componentProg;
+            yield return componentProg;
+          }
+        }
+      }
+    }
+
+    private void CompileInstructions(ILGenerator il, InterpreterState state, Dataset ds) {
+      Instruction currentInstr = state.NextInstruction();
+      int nArgs = currentInstr.nArguments;
+
+      switch (currentInstr.opCode) {
+        case OpCodes.Add: {
+            if (nArgs > 0) {
+              CompileInstructions(il, state, ds);
+            }
+            for (int i = 1; i < nArgs; i++) {
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Add);
+            }
+            return;
+          }
+        case OpCodes.Sub: {
+            if (nArgs == 1) {
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Neg);
+              return;
+            }
+            if (nArgs > 0) {
+              CompileInstructions(il, state, ds);
+            }
+            for (int i = 1; i < nArgs; i++) {
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Sub);
+            }
+            return;
+          }
+        case OpCodes.Mul: {
+            if (nArgs > 0) {
+              CompileInstructions(il, state, ds);
+            }
+            for (int i = 1; i < nArgs; i++) {
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            }
+            return;
+          }
+        case OpCodes.Div: {
+            if (nArgs == 1) {
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Div);
+              return;
+            }
+            if (nArgs > 0) {
+              CompileInstructions(il, state, ds);
+            }
+            for (int i = 1; i < nArgs; i++) {
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Div);
+            }
+            return;
+          }
+        case OpCodes.Average: {
+            CompileInstructions(il, state, ds);
+            for (int i = 1; i < nArgs; i++) {
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Add);
+            }
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, nArgs);
+            il.Emit(System.Reflection.Emit.OpCodes.Div);
+            return;
+          }
+        case OpCodes.Cos: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, cos);
+            return;
+          }
+        case OpCodes.Sin: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, sin);
+            return;
+          }
+        case OpCodes.Tan: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, tan);
+            return;
+          }
+        case OpCodes.Power: {
+            CompileInstructions(il, state, ds);
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, round);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            return;
+          }
+        case OpCodes.Root: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, round);
+            il.Emit(System.Reflection.Emit.OpCodes.Div);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            return;
+          }
+        case OpCodes.Exp: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, exp);
+            return;
+          }
+        case OpCodes.Log: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, log);
+            return;
+          }
+        case OpCodes.Square: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            return;
+          }
+        case OpCodes.SquareRoot: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
+            return;
+          }
+        case OpCodes.AiryA: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, airyA);
+            return;
+          }
+        case OpCodes.AiryB: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, airyB);
+            return;
+          }
+        case OpCodes.Bessel: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, bessel);
+            return;
+          }
+        case OpCodes.CosineIntegral: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, cosIntegral);
+            return;
+          }
+        case OpCodes.Dawson: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, dawson);
+            return;
+          }
+        case OpCodes.Erf: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, erf);
+            return;
+          }
+        case OpCodes.ExponentialIntegralEi: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, expIntegralEi);
+            return;
+          }
+        case OpCodes.FresnelCosineIntegral: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelCosIntegral);
+            return;
+          }
+        case OpCodes.FresnelSineIntegral: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelSinIntegral);
+            return;
+          }
+        case OpCodes.Gamma: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, gamma);
+            return;
+          }
+        case OpCodes.HyperbolicCosineIntegral: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, hypCosIntegral);
+            return;
+          }
+        case OpCodes.HyperbolicSineIntegral: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, hypSinIntegral);
+            return;
+          }
+        case OpCodes.Norm: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, norm);
+            return;
+          }
+        case OpCodes.Psi: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, psi);
+            return;
+          }
+        case OpCodes.SineIntegral: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
+            return;
+          }
+        case OpCodes.IfThenElse: {
+            Label end = il.DefineLabel();
+            Label c1 = il.DefineLabel();
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
+            il.Emit(System.Reflection.Emit.OpCodes.Cgt);
+            il.Emit(System.Reflection.Emit.OpCodes.Brfalse, c1);
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Br, end);
+            il.MarkLabel(c1);
+            CompileInstructions(il, state, ds);
+            il.MarkLabel(end);
+            return;
+          }
+        case OpCodes.AND: {
+            Label falseBranch = il.DefineLabel();
+            Label end = il.DefineLabel();
+            CompileInstructions(il, state, ds);
+            for (int i = 1; i < nArgs; i++) {
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
+              il.Emit(System.Reflection.Emit.OpCodes.Cgt);
+              il.Emit(System.Reflection.Emit.OpCodes.Brfalse, falseBranch);
+              CompileInstructions(il, state, ds);
+            }
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
+            il.Emit(System.Reflection.Emit.OpCodes.Cgt);
+            il.Emit(System.Reflection.Emit.OpCodes.Brfalse, falseBranch);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1
+            il.Emit(System.Reflection.Emit.OpCodes.Br, end);
+            il.MarkLabel(falseBranch);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // -1
+            il.Emit(System.Reflection.Emit.OpCodes.Neg);
+            il.MarkLabel(end);
+            return;
+          }
+        case OpCodes.OR: {
+            Label trueBranch = il.DefineLabel();
+            Label end = il.DefineLabel();
+            Label resultBranch = il.DefineLabel();
+            CompileInstructions(il, state, ds);
+            for (int i = 1; i < nArgs; i++) {
+              Label nextArgBranch = il.DefineLabel();
+              // complex definition because of special properties of NaN  
+              il.Emit(System.Reflection.Emit.OpCodes.Dup);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // <= 0        
+              il.Emit(System.Reflection.Emit.OpCodes.Ble, nextArgBranch);
+              il.Emit(System.Reflection.Emit.OpCodes.Br, resultBranch);
+              il.MarkLabel(nextArgBranch);
+              il.Emit(System.Reflection.Emit.OpCodes.Pop);
+              CompileInstructions(il, state, ds);
+            }
+            il.MarkLabel(resultBranch);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
+            il.Emit(System.Reflection.Emit.OpCodes.Cgt);
+            il.Emit(System.Reflection.Emit.OpCodes.Brtrue, trueBranch);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // -1
+            il.Emit(System.Reflection.Emit.OpCodes.Neg);
+            il.Emit(System.Reflection.Emit.OpCodes.Br, end);
+            il.MarkLabel(trueBranch);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1
+            il.MarkLabel(end);
+            return;
+          }
+        case OpCodes.NOT: {
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
+            il.Emit(System.Reflection.Emit.OpCodes.Cgt);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
+            il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
+            il.Emit(System.Reflection.Emit.OpCodes.Sub);
+            il.Emit(System.Reflection.Emit.OpCodes.Neg); // * -1
+            return;
+          }
+        case OpCodes.GT: {
+            CompileInstructions(il, state, ds);
+            CompileInstructions(il, state, ds);
+
+            il.Emit(System.Reflection.Emit.OpCodes.Cgt); // 1 (>) / 0 (otherwise)
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
+            il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
+            il.Emit(System.Reflection.Emit.OpCodes.Sub);
+            return;
+          }
+        case OpCodes.LT: {
+            CompileInstructions(il, state, ds);
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Clt);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // * 2
+            il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // - 1
+            il.Emit(System.Reflection.Emit.OpCodes.Sub);
+            return;
+          }
+        case OpCodes.TimeLag: {
+            LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, laggedTreeNode.Lag);
+            il.Emit(System.Reflection.Emit.OpCodes.Add);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            var prevLaggedContext = state.InLaggedContext;
+            state.InLaggedContext = true;
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row += lag
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, laggedTreeNode.Lag);
+            il.Emit(System.Reflection.Emit.OpCodes.Sub);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            state.InLaggedContext = prevLaggedContext;
+            return;
+          }
+        case OpCodes.Integral: {
+            int savedPc = state.ProgramCounter;
+            LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, laggedTreeNode.Lag);
+            il.Emit(System.Reflection.Emit.OpCodes.Add);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            var prevLaggedContext = state.InLaggedContext;
+            state.InLaggedContext = true;
+            CompileInstructions(il, state, ds);
+            for (int l = laggedTreeNode.Lag; l < 0; l++) {
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row += lag
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_1);
+              il.Emit(System.Reflection.Emit.OpCodes.Add);
+              il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+              state.ProgramCounter = savedPc;
+              CompileInstructions(il, state, ds);
+              il.Emit(System.Reflection.Emit.OpCodes.Add);
+            }
+            state.InLaggedContext = prevLaggedContext;
+            return;
+          }
+
+        //mkommend: derivate calculation taken from: 
+        //http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/smooth-low-noise-differentiators/
+        //one sided smooth differentiatior, N = 4
+        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
+        case OpCodes.Derivative: {
+            int savedPc = state.ProgramCounter;
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row --
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_M1);
+            il.Emit(System.Reflection.Emit.OpCodes.Add);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            state.ProgramCounter = savedPc;
+            var prevLaggedContext = state.InLaggedContext;
+            state.InLaggedContext = true;
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // f_0 + 2 * f_1
+            il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            il.Emit(System.Reflection.Emit.OpCodes.Add);
+
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -=2
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_2);
+            il.Emit(System.Reflection.Emit.OpCodes.Sub);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            state.ProgramCounter = savedPc;
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0); // f_0 + 2 * f_1 - 2 * f_3
+            il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            il.Emit(System.Reflection.Emit.OpCodes.Sub);
+
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row --
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_M1);
+            il.Emit(System.Reflection.Emit.OpCodes.Add);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            state.ProgramCounter = savedPc;
+            CompileInstructions(il, state, ds);
+            il.Emit(System.Reflection.Emit.OpCodes.Sub); // f_0 + 2 * f_1 - 2 * f_3 - f_4
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 8.0); // / 8
+            il.Emit(System.Reflection.Emit.OpCodes.Div);
+
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row +=4
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_4);
+            il.Emit(System.Reflection.Emit.OpCodes.Add);
+            il.Emit(System.Reflection.Emit.OpCodes.Starg, 0);
+            state.InLaggedContext = prevLaggedContext;
+            return;
+          }
+        case OpCodes.Call: {
+            throw new NotSupportedException(
+              "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
+          }
+        case OpCodes.Arg: {
+            throw new NotSupportedException(
+              "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
+          }
+        case OpCodes.Variable: {
+            VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
+            if (!state.InLaggedContext) {
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
+              // load correct column of the current variable
+              il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
+              il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            } else {
+              var nanResult = il.DefineLabel();
+              var normalResult = il.DefineLabel();
+              var cachedValue = il.DefineLabel();
+              var multiplyValue = il.DefineLabel();
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+              il.Emit(System.Reflection.Emit.OpCodes.Dup);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
+              il.Emit(System.Reflection.Emit.OpCodes.Blt, nanResult);
+              il.Emit(System.Reflection.Emit.OpCodes.Dup);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
+              il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3);
+              il.Emit(System.Reflection.Emit.OpCodes.Bge, cachedValue);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
+              il.Emit(System.Reflection.Emit.OpCodes.Br, multiplyValue);
+              il.MarkLabel(cachedValue);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_2); // load cached values array
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+              il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3); // startRow
+              il.Emit(System.Reflection.Emit.OpCodes.Sub); // startRow
+              il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
+              il.MarkLabel(multiplyValue);
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
+              il.Emit(System.Reflection.Emit.OpCodes.Mul);
+              il.Emit(System.Reflection.Emit.OpCodes.Br, normalResult);
+              il.MarkLabel(nanResult);
+              il.Emit(System.Reflection.Emit.OpCodes.Pop); // rowIndex
+              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
+              il.MarkLabel(normalResult);
+            }
+            return;
+          }
+        case OpCodes.LagVariable: {
+            var nanResult = il.DefineLabel();
+            var normalResult = il.DefineLabel();
+            var cachedValue = il.DefineLabel();
+            var multiplyValue = il.DefineLabel();
+            LaggedVariableTreeNode varNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+            il.Emit(System.Reflection.Emit.OpCodes.Add); // actualRowIndex = rowIndex + sampleOffset
+            il.Emit(System.Reflection.Emit.OpCodes.Dup);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
+            il.Emit(System.Reflection.Emit.OpCodes.Blt, nanResult);
+            il.Emit(System.Reflection.Emit.OpCodes.Dup);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, ds.Rows);
+            il.Emit(System.Reflection.Emit.OpCodes.Bge, nanResult);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3); // startindex
+            il.Emit(System.Reflection.Emit.OpCodes.Bge, cachedValue);
+            // normal value
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0); // load correct column of the current variable
+            il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+            il.Emit(System.Reflection.Emit.OpCodes.Add); // actualRowIndex = rowIndex + sampleOffset
+            il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
+            il.Emit(System.Reflection.Emit.OpCodes.Br, multiplyValue);
+            il.MarkLabel(cachedValue);
+            // cached value
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_2); // load cached values
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, (int)currentInstr.iArg0); // load correct column of the current variable
+            il.Emit(System.Reflection.Emit.OpCodes.Ldelem_Ref);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4, varNode.Lag); // lag
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // rowIndex
+            il.Emit(System.Reflection.Emit.OpCodes.Add); // actualRowIndex = rowIndex + sampleOffset
+            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_3); // startRow
+            il.Emit(System.Reflection.Emit.OpCodes.Sub); // startRow            
+            il.Emit(System.Reflection.Emit.OpCodes.Call, listGetValue);
+
+            il.MarkLabel(multiplyValue);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, varNode.Weight); // load weight
+            il.Emit(System.Reflection.Emit.OpCodes.Mul);
+            il.Emit(System.Reflection.Emit.OpCodes.Br, normalResult);
+            il.MarkLabel(nanResult);
+            il.Emit(System.Reflection.Emit.OpCodes.Pop); // pop the row index
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, double.NaN);
+            il.MarkLabel(normalResult);
+            return;
+          }
+        case OpCodes.Constant: {
+            ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
+            return;
+          }
+
+        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
+        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
+        case OpCodes.VariableCondition: {
+            throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
+                                            " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
+          }
+        default:
+          throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
+                                          " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
+      }
+    }
+
+    private byte MapSymbolToOpCode(ISymbolicExpressionTreeNode treeNode) {
+      byte opCode;
+      if (!symbolToOpcode.TryGetValue(treeNode.Symbol.GetType(), out opCode))
+        throw new NotSupportedException("Symbol: " + treeNode.Symbol);
+      return opCode;
+    }
+
+
+    public static double AiryA(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double ai, aip, bi, bip;
+      alglib.airy(x, out ai, out aip, out bi, out bip);
+      return ai;
+    }
+
+    public static double AiryB(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double ai, aip, bi, bip;
+      alglib.airy(x, out ai, out aip, out bi, out bip);
+      return bi;
+    }
+    public static double Dawson(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      return alglib.dawsonintegral(x);
+    }
+
+    public static double Gamma(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      return alglib.gammafunction(x);
+    }
+
+    public static double Psi(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) return double.NaN;
+      return alglib.psi(x);
+    }
+
+    public static double ExpIntegralEi(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      return alglib.exponentialintegralei(x);
+    }
+
+    public static double SinIntegral(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double si, ci;
+      alglib.sinecosineintegrals(x, out si, out ci);
+      return si;
+    }
+
+    public static double CosIntegral(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double si, ci;
+      alglib.sinecosineintegrals(x, out si, out ci);
+      return ci;
+    }
+
+    public static double HypSinIntegral(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double shi, chi;
+      alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
+      return shi;
+    }
+
+    public static double HypCosIntegral(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double shi, chi;
+      alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
+      return chi;
+    }
+
+    public static double FresnelCosIntegral(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double c = 0, s = 0;
+      alglib.fresnelintegral(x, ref c, ref s);
+      return c;
+    }
+
+    public static double FresnelSinIntegral(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      double c = 0, s = 0;
+      alglib.fresnelintegral(x, ref c, ref s);
+      return s;
+    }
+
+    public static double Norm(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      return alglib.normaldistribution(x);
+    }
+
+    public static double Erf(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      return alglib.errorfunction(x);
+    }
+
+    public static double Bessel(double x) {
+      if (double.IsNaN(x)) return double.NaN;
+      return alglib.besseli0(x);
+    }
+
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 8430)
@@ -0,0 +1,666 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Parameters;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [StorableClass]
+  [Item("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.")]
+  public sealed class SymbolicDataAnalysisExpressionTreeInterpreter : ParameterizedNamedItem,
+    ISymbolicDataAnalysisExpressionTreeInterpreter, ISymbolicTimeSeriesPrognosisExpressionTreeInterpreter {
+    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
+    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
+    #region private classes
+    private class InterpreterState {
+      private double[] argumentStack;
+      private int argumentStackPointer;
+      private Instruction[] code;
+      private int pc;
+      public int ProgramCounter {
+        get { return pc; }
+        set { pc = value; }
+      }
+      internal InterpreterState(Instruction[] code, int argumentStackSize) {
+        this.code = code;
+        this.pc = 0;
+        if (argumentStackSize > 0) {
+          this.argumentStack = new double[argumentStackSize];
+        }
+        this.argumentStackPointer = 0;
+      }
+
+      internal void Reset() {
+        this.pc = 0;
+        this.argumentStackPointer = 0;
+      }
+
+      internal Instruction NextInstruction() {
+        return code[pc++];
+      }
+      private void Push(double val) {
+        argumentStack[argumentStackPointer++] = val;
+      }
+      private double Pop() {
+        return argumentStack[--argumentStackPointer];
+      }
+
+      internal void CreateStackFrame(double[] argValues) {
+        // push in reverse order to make indexing easier
+        for (int i = argValues.Length - 1; i >= 0; i--) {
+          argumentStack[argumentStackPointer++] = argValues[i];
+        }
+        Push(argValues.Length);
+      }
+
+      internal void RemoveStackFrame() {
+        int size = (int)Pop();
+        argumentStackPointer -= size;
+      }
+
+      internal double GetStackFrameValue(ushort index) {
+        // layout of stack:
+        // [0]   <- argumentStackPointer
+        // [StackFrameSize = N + 1]
+        // [Arg0] <- argumentStackPointer - 2 - 0
+        // [Arg1] <- argumentStackPointer - 2 - 1
+        // [...]
+        // [ArgN] <- argumentStackPointer - 2 - N
+        // <Begin of stack frame>
+        return argumentStack[argumentStackPointer - index - 2];
+      }
+    }
+    private class OpCodes {
+      public const byte Add = 1;
+      public const byte Sub = 2;
+      public const byte Mul = 3;
+      public const byte Div = 4;
+
+      public const byte Sin = 5;
+      public const byte Cos = 6;
+      public const byte Tan = 7;
+
+      public const byte Log = 8;
+      public const byte Exp = 9;
+
+      public const byte IfThenElse = 10;
+
+      public const byte GT = 11;
+      public const byte LT = 12;
+
+      public const byte AND = 13;
+      public const byte OR = 14;
+      public const byte NOT = 15;
+
+
+      public const byte Average = 16;
+
+      public const byte Call = 17;
+
+      public const byte Variable = 18;
+      public const byte LagVariable = 19;
+      public const byte Constant = 20;
+      public const byte Arg = 21;
+
+      public const byte Power = 22;
+      public const byte Root = 23;
+      public const byte TimeLag = 24;
+      public const byte Integral = 25;
+      public const byte Derivative = 26;
+
+      public const byte VariableCondition = 27;
+
+      public const byte Square = 28;
+      public const byte SquareRoot = 29;
+      public const byte Gamma = 30;
+      public const byte Psi = 31;
+      public const byte Dawson = 32;
+      public const byte ExponentialIntegralEi = 33;
+      public const byte CosineIntegral = 34;
+      public const byte SineIntegral = 35;
+      public const byte HyperbolicCosineIntegral = 36;
+      public const byte HyperbolicSineIntegral = 37;
+      public const byte FresnelCosineIntegral = 38;
+      public const byte FresnelSineIntegral = 39;
+      public const byte AiryA = 40;
+      public const byte AiryB = 41;
+      public const byte Norm = 42;
+      public const byte Erf = 43;
+      public const byte Bessel = 44;
+    }
+    #endregion
+
+    private Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
+      { typeof(Addition), OpCodes.Add },
+      { typeof(Subtraction), OpCodes.Sub },
+      { typeof(Multiplication), OpCodes.Mul },
+      { typeof(Division), OpCodes.Div },
+      { typeof(Sine), OpCodes.Sin },
+      { typeof(Cosine), OpCodes.Cos },
+      { typeof(Tangent), OpCodes.Tan },
+      { typeof(Logarithm), OpCodes.Log },
+      { typeof(Exponential), OpCodes.Exp },
+      { typeof(IfThenElse), OpCodes.IfThenElse },
+      { typeof(GreaterThan), OpCodes.GT },
+      { typeof(LessThan), OpCodes.LT },
+      { typeof(And), OpCodes.AND },
+      { typeof(Or), OpCodes.OR },
+      { typeof(Not), OpCodes.NOT},
+      { typeof(Average), OpCodes.Average},
+      { typeof(InvokeFunction), OpCodes.Call },
+      { typeof(Variable), OpCodes.Variable },
+      { typeof(LaggedVariable), OpCodes.LagVariable },
+      { typeof(Constant), OpCodes.Constant },
+      { typeof(Argument), OpCodes.Arg },
+      { typeof(Power),OpCodes.Power},
+      { typeof(Root),OpCodes.Root},
+      { typeof(TimeLag), OpCodes.TimeLag}, 
+      { typeof(Integral), OpCodes.Integral},
+      { typeof(Derivative), OpCodes.Derivative},
+      { typeof(VariableCondition),OpCodes.VariableCondition},
+      { typeof(Square),OpCodes.Square},
+      { typeof(SquareRoot),OpCodes.SquareRoot},
+      { typeof(Gamma), OpCodes.Gamma },
+      { typeof(Psi), OpCodes.Psi },
+      { typeof(Dawson), OpCodes.Dawson},
+      { typeof(ExponentialIntegralEi), OpCodes.ExponentialIntegralEi },
+      { typeof(CosineIntegral), OpCodes.CosineIntegral },
+      { typeof(SineIntegral), OpCodes.SineIntegral },
+      { typeof(HyperbolicCosineIntegral), OpCodes.HyperbolicCosineIntegral },
+      { typeof(HyperbolicSineIntegral), OpCodes.HyperbolicSineIntegral },
+      { typeof(FresnelCosineIntegral), OpCodes.FresnelCosineIntegral },
+      { typeof(FresnelSineIntegral), OpCodes.FresnelSineIntegral },
+      { typeof(AiryA), OpCodes.AiryA },
+      { typeof(AiryB), OpCodes.AiryB },
+      { typeof(Norm), OpCodes.Norm},
+      { typeof(Erf), OpCodes.Erf},
+      { typeof(Bessel), OpCodes.Bessel}
+    };
+
+    public override bool CanChangeName {
+      get { return false; }
+    }
+    public override bool CanChangeDescription {
+      get { return false; }
+    }
+
+    #region parameter properties
+    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
+      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
+    }
+
+    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    }
+    #endregion
+
+    #region properties
+    public BoolValue CheckExpressionsWithIntervalArithmetic {
+      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
+      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
+    }
+
+    public IntValue EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value; }
+      set { EvaluatedSolutionsParameter.Value = value; }
+    }
+    #endregion
+
+    [StorableConstructor]
+    private SymbolicDataAnalysisExpressionTreeInterpreter(bool deserializing) : base(deserializing) { }
+    private SymbolicDataAnalysisExpressionTreeInterpreter(SymbolicDataAnalysisExpressionTreeInterpreter original, Cloner cloner) : base(original, cloner) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisExpressionTreeInterpreter(this, cloner);
+    }
+
+    public SymbolicDataAnalysisExpressionTreeInterpreter()
+      : base("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
+      Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
+      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(EvaluatedSolutionsParameterName))
+        Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+    }
+
+    #region IStatefulItem
+    public void InitializeState() {
+      EvaluatedSolutions.Value = 0;
+    }
+
+    public void ClearState() {
+    }
+    #endregion
+
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, IEnumerable<int> rows) {
+      return GetSymbolicExpressionTreeValues(tree, dataset, new string[] { "#NOTHING#" }, rows);
+    }
+
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, string[] targetVariables, IEnumerable<int> rows) {
+      return GetSymbolicExpressionTreeValues(tree, dataset, targetVariables, rows, 1);
+    }
+
+
+    // for each row for each horizon for each target variable one value 
+    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, Dataset dataset, string[] targetVariables, IEnumerable<int> rows, int horizon) {
+      if (CheckExpressionsWithIntervalArithmetic.Value)
+        throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
+      EvaluatedSolutions.Value++; // increment the evaluated solutions counter
+      var compiler = new SymbolicExpressionTreeCompiler();
+      Instruction[] code = compiler.Compile(tree, MapSymbolToOpCode);
+      int necessaryArgStackSize = 0;
+      for (int i = 0; i < code.Length; i++) {
+        Instruction instr = code[i];
+        if (instr.opCode == OpCodes.Variable) {
+          var variableTreeNode = instr.dynamicNode as VariableTreeNode;
+          instr.iArg0 = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
+          code[i] = instr;
+        } else if (instr.opCode == OpCodes.LagVariable) {
+          var laggedVariableTreeNode = instr.dynamicNode as LaggedVariableTreeNode;
+          instr.iArg0 = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
+          code[i] = instr;
+        } else if (instr.opCode == OpCodes.VariableCondition) {
+          var variableConditionTreeNode = instr.dynamicNode as VariableConditionTreeNode;
+          instr.iArg0 = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
+        } else if (instr.opCode == OpCodes.Call) {
+          necessaryArgStackSize += instr.nArguments + 1;
+        }
+      }
+      var state = new InterpreterState(code, necessaryArgStackSize);
+
+      int nComponents = tree.Root.GetSubtree(0).SubtreeCount;
+      // produce a n-step forecast for each target variable for all rows
+      var cachedPrognosedValues = new Dictionary<string, double[]>();
+      foreach (var targetVariable in targetVariables)
+        cachedPrognosedValues[targetVariable] = new double[horizon];
+      foreach (var rowEnum in rows) {
+        int row = rowEnum;
+        foreach (var horizonRow in Enumerable.Range(row, horizon)) {
+          int localRow = horizonRow; // create a local variable for the ref parameter
+          for (int c = 0; c < nComponents; c++) {
+            var prog = Evaluate(dataset, ref localRow, row - 1, state, cachedPrognosedValues);
+            yield return prog;
+            cachedPrognosedValues[targetVariables[c]][horizonRow - row] = prog;
+          }
+
+          state.Reset();
+        }
+      }
+    }
+
+    private double Evaluate(Dataset dataset, ref int row, int lastObservedRow, InterpreterState state, Dictionary<string, double[]> cachedPrognosedValues) {
+      Instruction currentInstr = state.NextInstruction();
+      switch (currentInstr.opCode) {
+        case OpCodes.Add: {
+            double s = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            return s;
+          }
+        case OpCodes.Sub: {
+            double s = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s -= Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            if (currentInstr.nArguments == 1) s = -s;
+            return s;
+          }
+        case OpCodes.Mul: {
+            double p = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              p *= Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            return p;
+          }
+        case OpCodes.Div: {
+            double p = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              p /= Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            if (currentInstr.nArguments == 1) p = 1.0 / p;
+            return p;
+          }
+        case OpCodes.Average: {
+            double sum = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              sum += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            return sum / currentInstr.nArguments;
+          }
+        case OpCodes.Cos: {
+            return Math.Cos(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+          }
+        case OpCodes.Sin: {
+            return Math.Sin(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+          }
+        case OpCodes.Tan: {
+            return Math.Tan(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+          }
+        case OpCodes.Square: {
+            return Math.Pow(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues), 2);
+          }
+        case OpCodes.Power: {
+            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            double y = Math.Round(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+            return Math.Pow(x, y);
+          }
+        case OpCodes.SquareRoot: {
+            return Math.Sqrt(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+          }
+        case OpCodes.Root: {
+            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            double y = Math.Round(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+            return Math.Pow(x, 1 / y);
+          }
+        case OpCodes.Exp: {
+            return Math.Exp(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+          }
+        case OpCodes.Log: {
+            return Math.Log(Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues));
+          }
+        case OpCodes.Gamma: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else return alglib.gammafunction(x);
+          }
+        case OpCodes.Psi: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) return double.NaN;
+            return alglib.psi(x);
+          }
+        case OpCodes.Dawson: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            return alglib.dawsonintegral(x);
+          }
+        case OpCodes.ExponentialIntegralEi: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            return alglib.exponentialintegralei(x);
+          }
+        case OpCodes.SineIntegral: {
+            double si, ci;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.sinecosineintegrals(x, out si, out ci);
+              return si;
+            }
+          }
+        case OpCodes.CosineIntegral: {
+            double si, ci;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.sinecosineintegrals(x, out si, out ci);
+              return ci;
+            }
+          }
+        case OpCodes.HyperbolicSineIntegral: {
+            double shi, chi;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
+              return shi;
+            }
+          }
+        case OpCodes.HyperbolicCosineIntegral: {
+            double shi, chi;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
+              return chi;
+            }
+          }
+        case OpCodes.FresnelCosineIntegral: {
+            double c = 0, s = 0;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.fresnelintegral(x, ref c, ref s);
+              return c;
+            }
+          }
+        case OpCodes.FresnelSineIntegral: {
+            double c = 0, s = 0;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.fresnelintegral(x, ref c, ref s);
+              return s;
+            }
+          }
+        case OpCodes.AiryA: {
+            double ai, aip, bi, bip;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.airy(x, out ai, out aip, out bi, out bip);
+              return ai;
+            }
+          }
+        case OpCodes.AiryB: {
+            double ai, aip, bi, bip;
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else {
+              alglib.airy(x, out ai, out aip, out bi, out bip);
+              return bi;
+            }
+          }
+        case OpCodes.Norm: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else return alglib.normaldistribution(x);
+          }
+        case OpCodes.Erf: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else return alglib.errorfunction(x);
+          }
+        case OpCodes.Bessel: {
+            var x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (double.IsNaN(x)) return double.NaN;
+            else return alglib.besseli0(x);
+          }
+        case OpCodes.IfThenElse: {
+            double condition = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            double result;
+            if (condition > 0.0) {
+              result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); SkipInstructions(state);
+            } else {
+              SkipInstructions(state); result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            return result;
+          }
+        case OpCodes.AND: {
+            double result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              if (result > 0.0) result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+              else {
+                SkipInstructions(state);
+              }
+            }
+            return result > 0.0 ? 1.0 : -1.0;
+          }
+        case OpCodes.OR: {
+            double result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              if (result <= 0.0) result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+              else {
+                SkipInstructions(state);
+              }
+            }
+            return result > 0.0 ? 1.0 : -1.0;
+          }
+        case OpCodes.NOT: {
+            return Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues) > 0.0 ? -1.0 : 1.0;
+          }
+        case OpCodes.GT: {
+            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            double y = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (x > y) return 1.0;
+            else return -1.0;
+          }
+        case OpCodes.LT: {
+            double x = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            double y = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            if (x < y) return 1.0;
+            else return -1.0;
+          }
+        case OpCodes.TimeLag: {
+            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
+            row += timeLagTreeNode.Lag;
+            double result = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            row -= timeLagTreeNode.Lag;
+            return result;
+          }
+        case OpCodes.Integral: {
+            int savedPc = state.ProgramCounter;
+            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
+            double sum = 0.0;
+            for (int i = 0; i < Math.Abs(timeLagTreeNode.Lag); i++) {
+              row += Math.Sign(timeLagTreeNode.Lag);
+              sum += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+              state.ProgramCounter = savedPc;
+            }
+            row -= timeLagTreeNode.Lag;
+            sum += Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            return sum;
+          }
+
+        //mkommend: derivate calculation taken from: 
+        //http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/smooth-low-noise-differentiators/
+        //one sided smooth differentiatior, N = 4
+        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
+        case OpCodes.Derivative: {
+            int savedPc = state.ProgramCounter;
+            double f_0 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); row--;
+            state.ProgramCounter = savedPc;
+            double f_1 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); row -= 2;
+            state.ProgramCounter = savedPc;
+            double f_3 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues); row--;
+            state.ProgramCounter = savedPc;
+            double f_4 = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            row += 4;
+
+            return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
+          }
+        case OpCodes.Call: {
+            // evaluate sub-trees
+            double[] argValues = new double[currentInstr.nArguments];
+            for (int i = 0; i < currentInstr.nArguments; i++) {
+              argValues[i] = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            }
+            // push on argument values on stack 
+            state.CreateStackFrame(argValues);
+
+            // save the pc
+            int savedPc = state.ProgramCounter;
+            // set pc to start of function  
+            state.ProgramCounter = (ushort)currentInstr.iArg0;
+            // evaluate the function
+            double v = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+
+            // delete the stack frame
+            state.RemoveStackFrame();
+
+            // restore the pc => evaluation will continue at point after my subtrees  
+            state.ProgramCounter = savedPc;
+            return v;
+          }
+        case OpCodes.Arg: {
+            return state.GetStackFrameValue((ushort)currentInstr.iArg0);
+          }
+        case OpCodes.Variable: {
+            if (row < 0 || row >= dataset.Rows)
+              return double.NaN;
+            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
+            if (row <= lastObservedRow || !cachedPrognosedValues.ContainsKey(variableTreeNode.VariableName)) return ((IList<double>)currentInstr.iArg0)[row] * variableTreeNode.Weight;
+            else return cachedPrognosedValues[variableTreeNode.VariableName][row - lastObservedRow - 1] * variableTreeNode.Weight;
+          }
+        case OpCodes.LagVariable: {
+            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
+            int actualRow = row + laggedVariableTreeNode.Lag;
+            if (actualRow < 0 || actualRow >= dataset.Rows)
+              return double.NaN;
+            if (actualRow <= lastObservedRow || !cachedPrognosedValues.ContainsKey(laggedVariableTreeNode.VariableName)) return ((IList<double>)currentInstr.iArg0)[actualRow] * laggedVariableTreeNode.Weight;
+            else return cachedPrognosedValues[laggedVariableTreeNode.VariableName][actualRow - lastObservedRow - 1] * laggedVariableTreeNode.Weight;
+          }
+        case OpCodes.Constant: {
+            var constTreeNode = currentInstr.dynamicNode as ConstantTreeNode;
+            return constTreeNode.Value;
+          }
+
+        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
+        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
+        case OpCodes.VariableCondition: {
+            if (row < 0 || row >= dataset.Rows)
+              return double.NaN;
+            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
+            double variableValue;
+            if (row <= lastObservedRow || !cachedPrognosedValues.ContainsKey(variableConditionTreeNode.VariableName))
+              variableValue = ((IList<double>)currentInstr.iArg0)[row];
+            else
+              variableValue = cachedPrognosedValues[variableConditionTreeNode.VariableName][row - lastObservedRow - 1];
+
+            double x = variableValue - variableConditionTreeNode.Threshold;
+            double p = 1 / (1 + Math.Exp(-variableConditionTreeNode.Slope * x));
+
+            double trueBranch = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+            double falseBranch = Evaluate(dataset, ref row, lastObservedRow, state, cachedPrognosedValues);
+
+            return trueBranch * p + falseBranch * (1 - p);
+          }
+        default: throw new NotSupportedException();
+      }
+    }
+
+    private byte MapSymbolToOpCode(ISymbolicExpressionTreeNode treeNode) {
+      byte opCode;
+      if (!symbolToOpcode.TryGetValue(treeNode.Symbol.GetType(), out opCode))
+        throw new NotSupportedException("Symbol: " + treeNode.Symbol);
+      return opCode;
+    }
+
+    // skips a whole branch
+    private void SkipInstructions(InterpreterState state) {
+      int i = 1;
+      while (i > 0) {
+        i += state.NextInstruction().nArguments;
+        i--;
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs	(revision 8430)
@@ -203,5 +203,4 @@
       Operators.Add(new SymbolicExpressionSymbolFrequencyAnalyzer());
       Operators.Add(new SymbolicDataAnalysisVariableFrequencyAnalyzer());
-      Operators.Add(new SymbolicDataAnalysisComplexityAnalyzer());
       Operators.Add(new MinAverageMaxSymbolicExpressionTreeLengthAnalyzer());
       Operators.Add(new SymbolicExpressionTreeLengthAnalyzer());
@@ -313,6 +312,4 @@
       foreach (var op in operators.OfType<ISymbolicDataAnalysisExpressionCrossover<T>>()) {
         op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameterName;
-      }
-      foreach (var op in operators.OfType<ISymbolicDataAnalysisExpressionCrossover<T>>()) {
         op.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
         op.EvaluationPartitionParameter.ActualName = FitnessCalculationPartitionParameter.Name;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs	(revision 8430)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableConditionTreeNode.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableConditionTreeNode.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableConditionTreeNode.cs	(revision 8430)
@@ -1,5 +1,5 @@
 ﻿#region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2010 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.Designer.cs	(revision 8430)
@@ -71,5 +71,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.SamplesComboBox);
       this.Name = "ClassificationEnsembleSolutionEstimatedClassValuesView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.cs	(revision 8430)
@@ -73,20 +73,20 @@
       }
 
-      int[] indizes;
+      int[] indices;
       double[] estimatedClassValues;
 
       switch (SamplesComboBox.SelectedItem.ToString()) {
         case SamplesComboBoxAllSamples: {
-            indizes = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).ToArray();
+            indices = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).ToArray();
             estimatedClassValues = Content.EstimatedClassValues.ToArray();
             break;
           }
         case SamplesComboBoxTrainingSamples: {
-            indizes = Content.ProblemData.TrainingIndizes.ToArray();
+            indices = Content.ProblemData.TrainingIndices.ToArray();
             estimatedClassValues = Content.EstimatedTrainingClassValues.ToArray();
             break;
           }
         case SamplesComboBoxTestSamples: {
-            indizes = Content.ProblemData.TestIndizes.ToArray();
+            indices = Content.ProblemData.TestIndices.ToArray();
             estimatedClassValues = Content.EstimatedTestClassValues.ToArray();
             break;
@@ -98,11 +98,11 @@
       int classValuesCount = Content.ProblemData.ClassValues.Count;
       int solutionsCount = Content.ClassificationSolutions.Count();
-      string[,] values = new string[indizes.Length, 5 + classValuesCount + solutionsCount];
+      string[,] values = new string[indices.Length, 5 + classValuesCount + solutionsCount];
       double[] target = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable).ToArray();
-      List<List<double?>> estimatedValuesVector = GetEstimatedValues(SamplesComboBox.SelectedItem.ToString(), indizes,
+      List<List<double?>> estimatedValuesVector = GetEstimatedValues(SamplesComboBox.SelectedItem.ToString(), indices,
                                                             Content.ClassificationSolutions);
 
-      for (int i = 0; i < indizes.Length; i++) {
-        int row = indizes[i];
+      for (int i = 0; i < indices.Length; i++) {
+        int row = indices[i];
         values[i, 0] = row.ToString();
         values[i, 1] = target[i].ToString();
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionModelView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionModelView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionModelView.Designer.cs	(revision 8430)
@@ -50,5 +50,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "RegressionEnsembleSolutionModelView";
       this.ResumeLayout(false);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.Designer.cs	(revision 8430)
@@ -65,5 +65,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.label1);
       this.Controls.Add(this.cmbSamples);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.cs	(revision 8430)
@@ -107,8 +107,8 @@
         double[] predictedValues;
         if (cmbSamples.SelectedItem.ToString() == TrainingSamples) {
-          rows = Content.ProblemData.TrainingIndizes;
+          rows = Content.ProblemData.TrainingIndices;
           predictedValues = Content.EstimatedTrainingClassValues.ToArray();
         } else if (cmbSamples.SelectedItem.ToString() == TestSamples) {
-          rows = Content.ProblemData.TestIndizes;
+          rows = Content.ProblemData.TestIndices;
           predictedValues = Content.EstimatedTestClassValues.ToArray();
         } else throw new InvalidOperationException();
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.Designer.cs	(revision 8430)
@@ -50,5 +50,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "EstimatedValuesView";
       this.Size = new System.Drawing.Size(310, 285);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.cs	(revision 8430)
@@ -96,5 +96,5 @@
           var estimatedTraining = Content.EstimatedTrainingClassValues.GetEnumerator();
           estimatedTraining.MoveNext();
-          foreach (var trainingRow in Content.ProblemData.TrainingIndizes) {
+          foreach (var trainingRow in Content.ProblemData.TrainingIndices) {
             values[trainingRow, 3] = estimatedTraining.Current.ToString();
             estimatedTraining.MoveNext();
@@ -102,5 +102,5 @@
           var estimatedTest = Content.EstimatedTestClassValues.GetEnumerator();
           estimatedTest.MoveNext();
-          foreach (var testRow in Content.ProblemData.TestIndizes) {
+          foreach (var testRow in Content.ProblemData.TestIndices) {
             values[testRow, 4] = estimatedTest.Current.ToString();
             estimatedTest.MoveNext();
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.Designer.cs	(revision 8430)
@@ -76,5 +76,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.label1);
       this.Controls.Add(this.cmbSamples);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.cs	(revision 8430)
@@ -101,7 +101,7 @@
 
         if (cmbSamples.SelectedItem.ToString() == TrainingSamples) {
-          rows = Content.ProblemData.TrainingIndizes;
+          rows = Content.ProblemData.TrainingIndices;
         } else if (cmbSamples.SelectedItem.ToString() == TestSamples) {
-          rows = Content.ProblemData.TestIndizes;
+          rows = Content.ProblemData.TestIndices;
         } else throw new InvalidOperationException();
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionEstimatedClassValuesView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionEstimatedClassValuesView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionEstimatedClassValuesView.Designer.cs	(revision 8430)
@@ -50,5 +50,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "EstimatedValuesView";
       this.Size = new System.Drawing.Size(310, 285);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.Designer.cs	(revision 8430)
@@ -80,5 +80,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.label1);
       this.Controls.Add(this.JitterTrackBar);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.cs	(revision 8430)
@@ -137,5 +137,5 @@
       var targetValues = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable).ToList();
 
-      foreach (int row in Content.ProblemData.TrainingIndizes) {
+      foreach (int row in Content.ProblemData.TrainingIndices) {
         double estimatedValue = estimatedValues[row];
         double targetValue = targetValues[row];
@@ -150,5 +150,5 @@
       }
 
-      foreach (int row in Content.ProblemData.TestIndizes) {
+      foreach (int row in Content.ProblemData.TestIndices) {
         double estimatedValue = estimatedValues[row];
         double targetValue = targetValues[row];
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Clustering/ClusteringSolutionEstimatedClusterView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Clustering/ClusteringSolutionEstimatedClusterView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Clustering/ClusteringSolutionEstimatedClusterView.Designer.cs	(revision 8430)
@@ -50,5 +50,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "EstimatedValuesView";
       this.Size = new System.Drawing.Size(310, 285);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisSolutionEvaluationView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisSolutionEvaluationView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/DataAnalysisSolutionEvaluationView.Designer.cs	(revision 8430)
@@ -46,5 +46,5 @@
     private void InitializeComponent() {
       components = new System.ComponentModel.Container();
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Plugin.cs.frame	(revision 8430)
@@ -26,5 +26,5 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Views {
-  [Plugin("HeuristicLab.Problems.DataAnalysis.Views", "Provides views for base classes for data analysis tasks.", "3.4.2.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.DataAnalysis.Views", "Provides views for base classes for data analysis tasks.", "3.4.3.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.DataAnalysis.Views-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.2.$WCREV$")]
+[assembly: AssemblyFileVersion("3.4.3.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionEnsembleSolutionModelView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionEnsembleSolutionModelView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionEnsembleSolutionModelView.Designer.cs	(revision 8430)
@@ -50,5 +50,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "RegressionEnsembleSolutionModelView";
       this.ResumeLayout(false);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.Designer.cs	(revision 8430)
@@ -36,6 +36,6 @@
       // 
       this.chart.Anchor = ((System.Windows.Forms.AnchorStyles)((((System.Windows.Forms.AnchorStyles.Top | System.Windows.Forms.AnchorStyles.Bottom)
-            | System.Windows.Forms.AnchorStyles.Left)
-            | System.Windows.Forms.AnchorStyles.Right)));
+                  | System.Windows.Forms.AnchorStyles.Left)
+                  | System.Windows.Forms.AnchorStyles.Right)));
       chartArea1.Name = "ChartArea1";
       this.chart.ChartAreas.Add(chartArea1);
@@ -73,6 +73,5 @@
       // RegressionSolutionErrorCharacteristicsCurveView
       // 
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.label1);
       this.Controls.Add(this.cmbSamples);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs	(revision 8430)
@@ -26,5 +26,4 @@
 using System.Windows.Forms.DataVisualization.Charting;
 using HeuristicLab.MainForm;
-using HeuristicLab.MainForm.WindowsForms;
 
 namespace HeuristicLab.Problems.DataAnalysis.Views {
@@ -32,5 +31,4 @@
   [Content(typeof(IRegressionSolution))]
   public partial class RegressionSolutionErrorCharacteristicsCurveView : DataAnalysisSolutionEvaluationView {
-    private IRegressionSolution constantModel;
     protected const string TrainingSamples = "Training";
     protected const string TestSamples = "Test";
@@ -103,6 +101,6 @@
       if (Content == null) return;
 
+      var constantModel = CreateConstantModel();
       var originalValues = GetOriginalValues().ToList();
-      constantModel = CreateConstantModel();
       var baselineEstimatedValues = GetEstimatedValues(constantModel);
       var baselineResiduals = GetResiduals(originalValues, baselineEstimatedValues);
@@ -117,4 +115,5 @@
       baselineSeries.ToolTip = "Area over Curve: " + CalculateAreaOverCurve(baselineSeries);
       baselineSeries.Tag = constantModel;
+      baselineSeries.LegendToolTip = "Double-click to open model";
       chart.Series.Add(baselineSeries);
 
@@ -131,4 +130,5 @@
       UpdateSeries(estimatedValues, solutionSeries);
       solutionSeries.ToolTip = "Area over Curve: " + CalculateAreaOverCurve(solutionSeries);
+      solutionSeries.LegendToolTip = "Double-click to open model";
       chart.Series.Add(solutionSeries);
     }
@@ -169,8 +169,8 @@
       switch (cmbSamples.SelectedItem.ToString()) {
         case TrainingSamples:
-          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
           break;
         case TestSamples:
-          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
+          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices);
           break;
         case AllSamples:
@@ -201,9 +201,4 @@
     }
 
-    protected IEnumerable<double> GetbaselineEstimatedValues(IEnumerable<double> originalValues) {
-      double averageTrainingTarget = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).Average();
-      return Enumerable.Repeat(averageTrainingTarget, originalValues.Count());
-    }
-
     protected virtual List<double> GetResiduals(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues) {
       return originalValues.Zip(estimatedValues, (x, y) => Math.Abs(x - y)).ToList();
@@ -239,5 +234,5 @@
 
     private IRegressionSolution CreateConstantModel() {
-      double averageTrainingTarget = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).Average();
+      double averageTrainingTarget = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).Average();
       var solution = new ConstantRegressionModel(averageTrainingTarget).CreateRegressionSolution(ProblemData);
       solution.Name = "Baseline";
@@ -248,8 +243,9 @@
     private void chart_MouseMove(object sender, MouseEventArgs e) {
       HitTestResult result = chart.HitTest(e.X, e.Y);
-      if (result.ChartElementType == ChartElementType.LegendItem)
+      if (result.ChartElementType == ChartElementType.LegendItem) {
         Cursor = Cursors.Hand;
-      else
+      } else {
         Cursor = Cursors.Default;
+      }
     }
   }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.Designer.cs	(revision 8430)
@@ -50,5 +50,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "EstimatedValuesView";
       this.Size = new System.Drawing.Size(310, 285);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.cs	(revision 8430)
@@ -93,10 +93,10 @@
           var estimated_test = Content.EstimatedTestValues.GetEnumerator();
 
-          foreach (var row in Content.ProblemData.TrainingIndizes) {
+          foreach (var row in Content.ProblemData.TrainingIndices) {
             estimated_training.MoveNext();
             values[row, 3] = estimated_training.Current.ToString();
           }
 
-          foreach (var row in Content.ProblemData.TestIndizes) {
+          foreach (var row in Content.ProblemData.TestIndices) {
             estimated_test.MoveNext();
             values[row, 4] = estimated_test.Current.ToString();
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.Designer.cs	(revision 8430)
@@ -72,5 +72,5 @@
       this.AllowDrop = true;
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.chart);
       this.Name = "RegressionSolutionLineChartView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs	(revision 8430)
@@ -72,5 +72,5 @@
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].ChartType = SeriesChartType.FastLine;
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].EmptyPointStyle.Color = this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Color;
-        this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TrainingIndizes.ToArray(), Content.EstimatedTrainingValues.ToArray());
+        this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TrainingIndices.ToArray(), Content.EstimatedTrainingValues.ToArray());
         this.InsertEmptyPoints(this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME]);
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Tag = Content;
@@ -79,15 +79,15 @@
         this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].LegendText = ESTIMATEDVALUES_TEST_SERIES_NAME;
         this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].ChartType = SeriesChartType.FastLine;
-        this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TestIndizes.ToArray(), Content.EstimatedTestValues.ToArray());
+        this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TestIndices.ToArray(), Content.EstimatedTestValues.ToArray());
         this.InsertEmptyPoints(this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME]);
         this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Tag = Content;
         // series of remaining points
-        int[] allIndizes = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndizes).Except(Content.ProblemData.TestIndizes).ToArray();
+        int[] allIndices = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndices).Except(Content.ProblemData.TestIndices).ToArray();
         var estimatedValues = Content.EstimatedValues.ToArray();
-        List<double> allEstimatedValues = allIndizes.Select(index => estimatedValues[index]).ToList();
+        List<double> allEstimatedValues = allIndices.Select(index => estimatedValues[index]).ToList();
         this.chart.Series.Add(ESTIMATEDVALUES_ALL_SERIES_NAME);
         this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].LegendText = ESTIMATEDVALUES_ALL_SERIES_NAME;
         this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].ChartType = SeriesChartType.FastLine;
-        this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Points.DataBindXY(allIndizes, allEstimatedValues);
+        this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Points.DataBindXY(allIndices, allEstimatedValues);
         this.InsertEmptyPoints(this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME]);
         this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Tag = Content;
@@ -170,8 +170,8 @@
 
       int[] attr = new int[Content.ProblemData.Dataset.Rows + 1]; // add a virtual last row that is again empty to simplify loop further down
-      foreach (var row in Content.ProblemData.TrainingIndizes) {
+      foreach (var row in Content.ProblemData.TrainingIndices) {
         attr[row] += 1;
       }
-      foreach (var row in Content.ProblemData.TestIndizes) {
+      foreach (var row in Content.ProblemData.TestIndices) {
         attr[row] += 2;
       }
@@ -223,22 +223,22 @@
         string targetVariableName = Content.ProblemData.TargetVariable;
 
-        IEnumerable<int> indizes = null;
+        IEnumerable<int> indices = null;
         IEnumerable<double> predictedValues = null;
         switch (series.Name) {
           case ESTIMATEDVALUES_ALL_SERIES_NAME:
-            indizes = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndizes).Except(Content.ProblemData.TestIndizes).ToArray();
+            indices = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndices).Except(Content.ProblemData.TestIndices).ToArray();
             var estimatedValues = Content.EstimatedValues.ToArray();
-            predictedValues = indizes.Select(index => estimatedValues[index]).ToList();
+            predictedValues = indices.Select(index => estimatedValues[index]).ToList();
             break;
           case ESTIMATEDVALUES_TRAINING_SERIES_NAME:
-            indizes = Content.ProblemData.TrainingIndizes.ToArray();
+            indices = Content.ProblemData.TrainingIndices.ToArray();
             predictedValues = Content.EstimatedTrainingValues.ToArray();
             break;
           case ESTIMATEDVALUES_TEST_SERIES_NAME:
-            indizes = Content.ProblemData.TestIndizes.ToArray();
+            indices = Content.ProblemData.TestIndices.ToArray();
             predictedValues = Content.EstimatedTestValues.ToArray();
             break;
         }
-        series.Points.DataBindXY(indizes, predictedValues);
+        series.Points.DataBindXY(indices, predictedValues);
         this.InsertEmptyPoints(series);
         chart.Legends[series.Legend].ForeColor = Color.Black;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionResidualHistogram.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionResidualHistogram.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionResidualHistogram.Designer.cs	(revision 8430)
@@ -41,5 +41,5 @@
       this.chart.Location = new System.Drawing.Point(0, 0);
       this.chart.Name = "chart";
-      this.chart.Size = new System.Drawing.Size(358, 225);
+      this.chart.Size = new System.Drawing.Size(289, 220);
       this.chart.TabIndex = 0;
       this.chart.CustomizeLegend += new System.EventHandler<System.Windows.Forms.DataVisualization.Charting.CustomizeLegendEventArgs>(this.chart_CustomizeLegend);
@@ -50,6 +50,5 @@
       // 
       this.AllowDrop = true;
-      this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.chart);
       this.Name = "RegressionSolutionResidualHistogram";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionResidualHistogram.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionResidualHistogram.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionResidualHistogram.cs	(revision 8430)
@@ -39,16 +39,7 @@
     protected const string TEST_SAMPLES = "Test samples";
     /// <summary>
-    /// used to reduce code duplication
-    /// </summary>
-    protected static string[] ALL_SERIES = new string[] { ALL_SAMPLES, TRAINING_SAMPLES, TEST_SAMPLES };
-    /// <summary>
     /// approximate amount of bins 
     /// </summary>
     protected const double bins = 25;
-    /// <summary>
-    ///  keeps for all series a list for every bin with the position of the bin, the relative frequency of the
-    ///  residuals and the beginning and the end of the interval of the bin
-    ///  </summary>
-    protected Dictionary<string, List<List<double>>> relativeFrequencies;
     #endregion
 
@@ -61,6 +52,5 @@
       : base() {
       InitializeComponent();
-      relativeFrequencies = new Dictionary<string, List<List<double>>>();
-      foreach (string series in ALL_SERIES) {
+      foreach (string series in new List<String>() { ALL_SAMPLES, TRAINING_SAMPLES, TEST_SAMPLES }) {
         chart.Series.Add(series);
         chart.Series[series].LegendText = series;
@@ -71,5 +61,4 @@
         chart.Series[series].BorderColor = Color.Black;
         chart.Series[series].ToolTip = series + " Y = #VALY from #CUSTOMPROPERTY(from) to #CUSTOMPROPERTY(to)";
-        relativeFrequencies[series] = new List<List<double>>();
       }
       //configure axis 
@@ -87,24 +76,22 @@
 
     private void RedrawChart() {
-      foreach (string series in ALL_SERIES) {
-        chart.Series[series].Points.Clear();
-        relativeFrequencies[series].Clear();
+      foreach (Series series in chart.Series) {
+        series.Points.Clear();
       }
       if (Content != null) {
-        Dictionary<string, List<double>> residuals = CalculateResiduals();
-        double realMax = Math.Max(Math.Abs(residuals[ALL_SAMPLES].Min()), Math.Abs(residuals[ALL_SAMPLES].Max()));
-        double roundedMax = HumanRoundMax(realMax);
-        double intervalWidth = (roundedMax * 2.0) / bins;
-        intervalWidth = HumanRoundMax(intervalWidth);
-        // sets roundedMax to a value, so that zero will be in the middle of the x axis
-        double help = realMax / intervalWidth;
-        help = help % 1 < 0.5 ? (int)help : (int)help + 1;
-        roundedMax = help * intervalWidth;
-
-        foreach (string series in ALL_SERIES) {
-          CalculateFrequencies(residuals[series], series, roundedMax, intervalWidth);
-          if (!series.Equals(ALL_SAMPLES))
-            ShowValues(chart.Series[series], relativeFrequencies[series]);
+        List<double> residuals = CalculateResiduals(Content);
+
+        double max = 0.0;
+        foreach (Series series in chart.Series) {
+          CalculateFrequencies(residuals, series);
+          double seriesMax = series.Points.Select(p => p.YValues.First()).Max();
+          max = max < seriesMax ? seriesMax : max;
         }
+
+        // ALL_SAMPLES has to be calculated to know its highest frequency, but it is not shown in the beginning
+        chart.Series.First(s => s.Name.Equals(ALL_SAMPLES)).Points.Clear();
+
+        double roundedMax, intervalWidth;
+        CalculateResidualParameters(residuals, out roundedMax, out intervalWidth);
 
         ChartArea chartArea = chart.ChartAreas[0];
@@ -112,7 +99,5 @@
         chartArea.AxisX.Maximum = roundedMax + intervalWidth;
         // get the highest frequency of a residual of any series
-        chartArea.AxisY.Maximum = (from series in relativeFrequencies.Values
-                                   select (from residual in series
-                                           select residual.ElementAt(1)).Max()).Max();
+        chartArea.AxisY.Maximum = max;
         if (chartArea.AxisY.Maximum < 0.1) {
           chartArea.AxisY.Interval = 0.01;
@@ -132,38 +117,69 @@
     }
 
-    private Dictionary<string, List<double>> CalculateResiduals() {
-      Dictionary<string, List<double>> residuals = new Dictionary<string, List<double>>();
-
-      foreach (string series in ALL_SERIES) {
-        residuals[series] = new List<double>();
-      }
+    private List<double> CalculateResiduals(IRegressionSolution solution) {
+      List<double> residuals = new List<double>();
+
+      IRegressionProblemData problemdata = solution.ProblemData;
+      List<double> targetValues = problemdata.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable).ToList();
+      List<double> estimatedValues = solution.EstimatedValues.ToList();
+
+      for (int i = 0; i < solution.ProblemData.Dataset.Rows; i++) {
+        double residual = estimatedValues[i] - targetValues[i];
+        residuals.Add(residual);
+      }
+      return residuals;
+    }
+
+    private void CalculateFrequencies(List<double> residualValues, Series series) {
+      double roundedMax, intervalWidth;
+      CalculateResidualParameters(residualValues, out roundedMax, out intervalWidth);
+
+      IEnumerable<double> relevantResiduals = residualValues;
       IRegressionProblemData problemdata = Content.ProblemData;
-      List<double> targetValues = problemdata.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable).ToList();
-      List<double> estimatedValues = Content.EstimatedValues.ToList();
-
-      for (int i = 0; i < Content.ProblemData.Dataset.Rows; i++) {
-        double residual = estimatedValues[i] - targetValues[i];
-        residuals[ALL_SAMPLES].Add(residual);
-        if (i >= problemdata.TrainingPartition.Start && i < problemdata.TrainingPartition.End)
-          residuals[TRAINING_SAMPLES].Add(residual);
-        if (i >= problemdata.TestPartition.Start && i < problemdata.TestPartition.End)
-          residuals[TEST_SAMPLES].Add(residual);
-      }
-      return residuals;
-    }
-
-    private void CalculateFrequencies(List<double> residualValues, string series, double max, double intervalWidth) {
+      if (series.Name.Equals(TRAINING_SAMPLES)) {
+        relevantResiduals = residualValues.Skip(problemdata.TrainingPartition.Start).Take(problemdata.TrainingPartition.Size);
+      } else if (series.Name.Equals(TEST_SAMPLES)) {
+        relevantResiduals = residualValues.Skip(problemdata.TestPartition.Start).Take(problemdata.TestPartition.Size);
+      }
+
       double intervalCenter = intervalWidth / 2.0;
-      double sampleCount = residualValues.Count();
-      double current = -max;
+      double sampleCount = relevantResiduals.Count();
+      double current = -roundedMax;
+      DataPointCollection seriesPoints = series.Points;
 
       for (int i = 0; i <= bins; i++) {
-        IEnumerable<double> help = residualValues.Where(x => x >= (current - intervalCenter) && x < (current + intervalCenter));
-        relativeFrequencies[series].Add(new List<double>() { current, help.Count() / sampleCount, current - intervalCenter, current + intervalCenter });
+        IEnumerable<double> help = relevantResiduals.Where(x => x >= (current - intervalCenter) && x < (current + intervalCenter));
+        seriesPoints.AddXY(current, help.Count() / sampleCount);
+        seriesPoints[seriesPoints.Count - 1]["from"] = (current - intervalCenter).ToString();
+        seriesPoints[seriesPoints.Count - 1]["to"] = (current + intervalCenter).ToString();
         current += intervalWidth;
       }
     }
 
-    private double HumanRoundMax(double max) {
+    private void ToggleSeriesData(Series series) {
+      if (series.Points.Count > 0) {  //checks if series is shown
+        if (chart.Series.Any(s => s != series && s.Points.Count > 0)) {
+          series.Points.Clear();
+        }
+      } else if (Content != null) {
+        List<double> residuals = CalculateResiduals(Content);
+        CalculateFrequencies(residuals, series);
+        chart.Legends[series.Legend].ForeColor = Color.Black;
+        chart.Refresh();
+      }
+    }
+
+    private static void CalculateResidualParameters(List<double> residuals, out double roundedMax, out double intervalWidth) {
+      double realMax = Math.Max(Math.Abs(residuals.Min()), Math.Abs(residuals.Max()));
+      roundedMax = HumanRoundMax(realMax);
+      intervalWidth = (roundedMax * 2.0) / bins;
+      intervalWidth = HumanRoundMax(intervalWidth);
+      // sets roundedMax to a value, so that zero will be in the middle of the x axis
+      double help = realMax / intervalWidth;
+      help = help % 1 < 0.5 ? (int)help : (int)help + 1;
+      roundedMax = help * intervalWidth;
+    }
+
+    private static double HumanRoundMax(double max) {
       double base10;
       if (max > 0) base10 = Math.Pow(10.0, Math.Floor(Math.Log10(max)));
@@ -216,25 +232,4 @@
     }
     #endregion
-
-    private void ToggleSeriesData(Series series) {
-      if (series.Points.Count > 0) {  //checks if series is shown
-        if (chart.Series.Any(s => s != series && s.Points.Count > 0)) {
-          series.Points.Clear();
-        }
-      } else if (Content != null) {
-        ShowValues(series, relativeFrequencies[series.Name]);
-        chart.Legends[series.Legend].ForeColor = Color.Black;
-        chart.Refresh();
-      }
-    }
-    private void ShowValues(Series series, List<List<double>> relativeSeriesFrequencies) {
-      DataPointCollection seriesPoints = series.Points;
-
-      foreach (var valueList in relativeSeriesFrequencies) {
-        seriesPoints.AddXY(valueList[0], valueList[1]);
-        seriesPoints[seriesPoints.Count - 1]["from"] = valueList[2].ToString();
-        seriesPoints[seriesPoints.Count - 1]["to"] = valueList[3].ToString();
-      }
-    }
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionScatterPlotView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionScatterPlotView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionScatterPlotView.cs	(revision 8430)
@@ -119,4 +119,20 @@
       this.chart.ChartAreas[0].CursorX.Interval = zoomInterval;
       this.chart.ChartAreas[0].CursorY.Interval = zoomInterval;
+
+      this.chart.ChartAreas[0].AxisX.ScaleView.SmallScrollSize = zoomInterval;
+      this.chart.ChartAreas[0].AxisY.ScaleView.SmallScrollSize = zoomInterval;
+
+      this.chart.ChartAreas[0].AxisX.ScaleView.SmallScrollMinSizeType = DateTimeIntervalType.Number;
+      this.chart.ChartAreas[0].AxisX.ScaleView.SmallScrollMinSize = zoomInterval;
+      this.chart.ChartAreas[0].AxisY.ScaleView.SmallScrollMinSizeType = DateTimeIntervalType.Number;
+      this.chart.ChartAreas[0].AxisY.ScaleView.SmallScrollMinSize = zoomInterval;
+
+      if (digits < 0) {
+        this.chart.ChartAreas[0].AxisX.LabelStyle.Format = "F" + (int)Math.Abs(digits);
+        this.chart.ChartAreas[0].AxisY.LabelStyle.Format = "F" + (int)Math.Abs(digits);
+      } else {
+        this.chart.ChartAreas[0].AxisX.LabelStyle.Format = "F0";
+        this.chart.ChartAreas[0].AxisY.LabelStyle.Format = "F0";
+      }
     }
 
@@ -132,8 +148,8 @@
         if (this.chart.Series[TRAINING_SERIES].Points.Count > 0)
           this.chart.Series[TRAINING_SERIES].Points.DataBindXY(Content.EstimatedTrainingValues.ToArray(), "",
-            dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndizes).ToArray(), "");
+            dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndices).ToArray(), "");
         if (this.chart.Series[TEST_SERIES].Points.Count > 0)
           this.chart.Series[TEST_SERIES].Points.DataBindXY(Content.EstimatedTestValues.ToArray(), "",
-           dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndizes).ToArray(), "");
+           dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndices).ToArray(), "");
 
         double max = Content.EstimatedTrainingValues.Concat(Content.EstimatedTestValues.Concat(Content.EstimatedValues.Concat(dataset.GetDoubleValues(targetVariableName)))).Max();
@@ -180,9 +196,9 @@
           case TRAINING_SERIES:
             predictedValues = Content.EstimatedTrainingValues.ToArray();
-            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndizes).ToArray();
+            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndices).ToArray();
             break;
           case TEST_SERIES:
             predictedValues = Content.EstimatedTestValues.ToArray();
-            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndizes).ToArray();
+            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndices).ToArray();
             break;
         }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClassificationEnsembleSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClassificationEnsembleSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClassificationEnsembleSolutionView.Designer.cs	(revision 8430)
@@ -45,5 +45,5 @@
     private void InitializeComponent() {
       components = new System.ComponentModel.Container();
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClassificationSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClassificationSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClassificationSolutionView.Designer.cs	(revision 8430)
@@ -46,5 +46,5 @@
     private void InitializeComponent() {
       components = new System.ComponentModel.Container();
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.itemsGroupBox.Text = "Classification Solution";
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClusteringSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClusteringSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/ClusteringSolutionView.Designer.cs	(revision 8430)
@@ -71,5 +71,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "ClusteringSolutionView";
       this.splitContainer.Panel1.ResumeLayout(false);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.Designer.cs	(revision 8430)
@@ -70,5 +70,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "DataAnalysisSolutionView";
       this.splitContainer.Panel1.ResumeLayout(false);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DataAnalysisSolutionView.cs	(revision 8430)
@@ -137,4 +137,14 @@
     }
 
+    protected override void showDetailsCheckBox_CheckedChanged(object sender, EventArgs e) {
+      if (showDetailsCheckBox.Checked && itemsListView.SelectedItems.Count == 1 && itemsListView.SelectedItems[0].Tag is Type) {
+        Type viewType = (Type)itemsListView.SelectedItems[0].Tag;
+        viewHost.ViewType = viewType;
+        viewHost.Content = Content;
+        splitContainer.Panel2Collapsed = false;
+        detailsGroupBox.Enabled = true;
+      } else base.showDetailsCheckBox_CheckedChanged(sender, e);
+    }
+
     #region drag and drop
     protected override void itemsListView_DragEnter(object sender, DragEventArgs e) {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DiscriminantFunctionClassificationSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DiscriminantFunctionClassificationSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/DiscriminantFunctionClassificationSolutionView.Designer.cs	(revision 8430)
@@ -46,5 +46,5 @@
     private void InitializeComponent() {
       components = new System.ComponentModel.Container();
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/NamedDataAnalysisSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/NamedDataAnalysisSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/NamedDataAnalysisSolutionView.Designer.cs	(revision 8430)
@@ -46,5 +46,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Controls.Add(this.panel);
       this.Name = "NamedDataAnalysisSolutionView";
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/RegressionEnsembleSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/RegressionEnsembleSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/RegressionEnsembleSolutionView.Designer.cs	(revision 8430)
@@ -45,5 +45,5 @@
     private void InitializeComponent() {
       components = new System.ComponentModel.Container();
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/RegressionSolutionView.Designer.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/RegressionSolutionView.Designer.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/Solution Views/RegressionSolutionView.Designer.cs	(revision 8430)
@@ -71,5 +71,5 @@
       // 
       this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
-      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
+      this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Inherit;
       this.Name = "RegressionSolutionView";
       this.splitContainer.Panel1.ResumeLayout(false);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionLineChartView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionLineChartView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionLineChartView.cs	(revision 8430)
@@ -19,4 +19,5 @@
  */
 #endregion
+
 using System;
 using System.Collections.Generic;
@@ -50,11 +51,13 @@
       this.chart.CustomizeAllChartAreas();
       this.chart.ChartAreas[0].CursorX.IsUserSelectionEnabled = true;
+      this.chart.ChartAreas[0].CursorX.Interval = 1;
       this.chart.ChartAreas[0].AxisX.ScaleView.Zoomable = true;
       this.chart.ChartAreas[0].AxisX.IsStartedFromZero = true;
-      this.chart.ChartAreas[0].CursorX.Interval = 1;
 
       this.chart.ChartAreas[0].CursorY.IsUserSelectionEnabled = true;
+      this.chart.ChartAreas[0].CursorY.Interval = 0.1;
       this.chart.ChartAreas[0].AxisY.ScaleView.Zoomable = true;
-      this.chart.ChartAreas[0].CursorY.Interval = 0;
+
+      this.chart.SuppressExceptions = false;
     }
 
@@ -69,6 +72,7 @@
         this.chart.Series[TARGETVARIABLE_SERIES_NAME].LegendText = targetVariable;
         this.chart.Series[TARGETVARIABLE_SERIES_NAME].ChartType = SeriesChartType.FastLine;
-        this.chart.Series[TARGETVARIABLE_SERIES_NAME].Points.DataBindXY(Enumerable.Range(0, Content.ProblemData.Dataset.Rows).ToArray(),
-          Content.ProblemData.Dataset.GetDoubleValues(targetVariable).ToArray());
+        AddDataPoints(chart.Series[TARGETVARIABLE_SERIES_NAME].Points, Enumerable.Range(0, Content.ProblemData.Dataset.Rows), Content.ProblemData.Dataset.GetDoubleValues(targetVariable));
+        //this.chart.Series[TARGETVARIABLE_SERIES_NAME].Points.DataBindXY(Enumerable.Range(0, Content.ProblemData.Dataset.Rows).ToArray(),
+        //  Content.ProblemData.Dataset.GetDoubleValues(targetVariable).ToArray());
 
         this.chart.Series.Add(PROGNOSEDVALUES_TRAINING_SERIES_NAME);
@@ -76,11 +80,13 @@
         this.chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].ChartType = SeriesChartType.FastLine;
         if (prognosedValuesCheckbox.Checked) {
-          this.chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Points
-            .DataBindXY(Content.ProblemData.TrainingIndizes.ToArray(),
-                        Content.GetPrognosedValues(Content.ProblemData.TrainingIndizes.Take(1), Content.ProblemData.TrainingIndizes.Count().ToEnumerable()).First().ToArray());
+          //this.chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Points
+          //  .DataBindXY(Content.ProblemData.TrainingIndices.ToArray(),
+          //              Content.GetPrognosedValues(Content.ProblemData.TrainingIndices.Take(1), Content.ProblemData.TrainingIndices.Count().ToEnumerable()).First().ToArray());
+          AddDataPoints(chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Points, Content.ProblemData.TrainingIndices, Content.GetPrognosedValues(Content.ProblemData.TrainingIndices.Take(1), Content.ProblemData.TrainingIndices.Count().ToEnumerable()).First());
         } else {
-          this.chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Points
-            .DataBindXY(Content.ProblemData.TrainingIndizes.ToArray(),
-                        Content.GetPrognosedValues(Content.ProblemData.TrainingIndizes, Enumerable.Repeat(1, Content.ProblemData.TrainingIndizes.Count())).SelectMany(x => x).ToArray());
+          //this.chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Points
+          //  .DataBindXY(Content.ProblemData.TrainingIndices.ToArray(),
+          //              Content.GetPrognosedValues(Content.ProblemData.TrainingIndices, Enumerable.Repeat(1, Content.ProblemData.TrainingIndices.Count())).SelectMany(x => x).ToArray());
+          AddDataPoints(chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Points, Content.ProblemData.TrainingIndices, Content.GetPrognosedValues(Content.ProblemData.TrainingIndices, Enumerable.Repeat(1, Content.ProblemData.TrainingIndices.Count())).SelectMany(x => x));
         }
         this.chart.Series[PROGNOSEDVALUES_TRAINING_SERIES_NAME].Tag = Content;
@@ -94,16 +100,33 @@
         this.chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].ChartType = SeriesChartType.FastLine;
         if (prognosedValuesCheckbox.Checked) {
-          this.chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Points
-            .DataBindXY(Content.ProblemData.TestIndizes.ToArray(),
-                        Content.GetPrognosedValues(Content.ProblemData.TestIndizes.Take(1), Content.ProblemData.TestIndizes.Count().ToEnumerable()).First().ToArray());
+          //this.chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Points
+          //  .DataBindXY(Content.ProblemData.TestIndices.ToArray(),
+          //              Content.GetPrognosedValues(Content.ProblemData.TestIndices.Take(1), Content.ProblemData.TestIndices.Count().ToEnumerable()).First().ToArray());
+          AddDataPoints(chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Points, Content.ProblemData.TestIndices, Content.GetPrognosedValues(Content.ProblemData.TestIndices.Take(1), Content.ProblemData.TestIndices.Count().ToEnumerable()).First());
         } else {
-          this.chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Points
-            .DataBindXY(Content.ProblemData.TestIndizes.ToArray(),
-                       Content.GetPrognosedValues(Content.ProblemData.TestIndizes, Enumerable.Repeat(1, Content.ProblemData.TestIndizes.Count())).SelectMany(x => x).ToArray());
+          //this.chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Points
+          //  .DataBindXY(Content.ProblemData.TestIndices.ToArray(),
+          //              Content.GetPrognosedValues(Content.ProblemData.TestIndices, Enumerable.Repeat(1, Content.ProblemData.TestIndices.Count())).SelectMany(x => x).ToArray());
+          AddDataPoints(chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Points, Content.ProblemData.TestIndices, Content.GetPrognosedValues(Content.ProblemData.TestIndices, Enumerable.Repeat(1, Content.ProblemData.TestIndices.Count())).SelectMany(x => x));
         }
         this.chart.Series[PROGNOSEDVALUES_TEST_SERIES_NAME].Tag = Content;
-
         UpdateCursorInterval();
         this.UpdateStripLines();
+      }
+      chart.Refresh();
+    }
+
+    private void AddDataPoints(DataPointCollection points, IEnumerable<int> xValues, IEnumerable<double> yValues) {
+      var xValuesEnumerator = xValues.GetEnumerator();
+      var yValuesEnumerator = yValues.GetEnumerator();
+
+      while (xValuesEnumerator.MoveNext() & yValuesEnumerator.MoveNext()) {
+        var xValue = xValuesEnumerator.Current;
+        var yValue = yValuesEnumerator.Current;
+
+        if (yValue < (double)decimal.MaxValue && yValue > (double)decimal.MinValue) {
+          DataPoint dataPoint = new DataPoint(xValue, yValue);
+          points.Add(dataPoint);
+        }
       }
     }
@@ -166,8 +189,8 @@
 
       int[] attr = new int[Content.ProblemData.Dataset.Rows + 1]; // add a virtual last row that is again empty to simplify loop further down
-      foreach (var row in Content.ProblemData.TrainingIndizes) {
+      foreach (var row in Content.ProblemData.TrainingIndices) {
         attr[row] += 1;
       }
-      foreach (var row in Content.ProblemData.TestIndizes) {
+      foreach (var row in Content.ProblemData.TestIndices) {
         attr[row] += 2;
       }
@@ -215,19 +238,19 @@
         }
       } else if (Content != null) {
-        IEnumerable<int> indizes = null;
+        IEnumerable<int> Indices = null;
         IEnumerable<double> predictedValues = null;
 
         switch (series.Name) {
           case PROGNOSEDVALUES_TRAINING_SERIES_NAME:
-            indizes = Content.ProblemData.TrainingIndizes.ToArray();
-            predictedValues = Content.GetPrognosedValues(Content.ProblemData.TrainingIndizes.Take(1), Content.ProblemData.TrainingPartition.Size.ToEnumerable()).First();
+            Indices = Content.ProblemData.TrainingIndices.ToArray();
+            predictedValues = Content.GetPrognosedValues(Content.ProblemData.TrainingIndices.Take(1), Content.ProblemData.TrainingPartition.Size.ToEnumerable()).First();
             break;
           case PROGNOSEDVALUES_TEST_SERIES_NAME:
             testPrognosisStart = Content.ProblemData.TestPartition.Start;
-            indizes = Content.ProblemData.TestIndizes.ToArray();
-            predictedValues = Content.GetPrognosedValues(Content.ProblemData.TestIndizes.Take(1), Content.ProblemData.TestPartition.Size.ToEnumerable()).First();
+            Indices = Content.ProblemData.TestIndices.ToArray();
+            predictedValues = Content.GetPrognosedValues(Content.ProblemData.TestIndices.Take(1), Content.ProblemData.TestPartition.Size.ToEnumerable()).First();
             break;
         }
-        series.Points.DataBindXY(indizes, predictedValues);
+        series.Points.DataBindXY(Indices, predictedValues);
         chart.DataManipulator.InsertEmptyPoints(1, IntervalType.Number, series.Name);
         chart.Legends[series.Legend].ForeColor = Color.Black;
@@ -238,24 +261,24 @@
 
     private void chart_MouseMove(object sender, MouseEventArgs e) {
-      HitTestResult result = chart.HitTest(e.X, e.Y);
-      if (result.ChartElementType == ChartElementType.LegendItem && result.Series.Name != TARGETVARIABLE_SERIES_NAME)
-        Cursor = Cursors.Hand;
-      else
-        Cursor = Cursors.Default;
+      //HitTestResult result = chart.HitTest(e.X, e.Y);
+      //if (result.ChartElementType == ChartElementType.LegendItem && result.Series.Name != TARGETVARIABLE_SERIES_NAME)
+      //  Cursor = Cursors.Hand;
+      //else
+      //  Cursor = Cursors.Default;
     }
 
     private void chart_MouseDown(object sender, MouseEventArgs e) {
-      HitTestResult result = chart.HitTest(e.X, e.Y);
-      if (result.ChartElementType == ChartElementType.LegendItem && result.Series.Name != TARGETVARIABLE_SERIES_NAME) {
-        ToggleSeriesData(result.Series);
-      } else if (result.ChartElementType == ChartElementType.Axis || result.ChartElementType == ChartElementType.AxisLabels ||
-        result.ChartElementType == ChartElementType.TickMarks) {
-        chart.ChartAreas[0].CursorX.SetCursorPixelPosition(new Point(e.X, e.Y), true);
-        int pos = (int)Math.Round(chart.ChartAreas[0].CursorX.Position);
-        if (pos >= Content.ProblemData.TestPartition.Start && pos < Content.ProblemData.TestPartition.End) {
-          testPrognosisStart = pos;
-          RedrawChart();
-        }
-      }
+      //HitTestResult result = chart.HitTest(e.X, e.Y);
+      //if (result.ChartElementType == ChartElementType.LegendItem && result.Series.Name != TARGETVARIABLE_SERIES_NAME) {
+      //  ToggleSeriesData(result.Series);
+      //} else if (result.ChartElementType == ChartElementType.Axis || result.ChartElementType == ChartElementType.AxisLabels ||
+      //  result.ChartElementType == ChartElementType.TickMarks) {
+      //  chart.ChartAreas[0].CursorX.SetCursorPixelPosition(new Point(e.X, e.Y), true);
+      //  int pos = (int)Math.Round(chart.ChartAreas[0].CursorX.Position);
+      //  if (pos >= Content.ProblemData.TestPartition.Start && pos < Content.ProblemData.TestPartition.End) {
+      //    testPrognosisStart = pos;
+      //    RedrawChart();
+      //  }
+      //}
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionPrognosedValuesView.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionPrognosedValuesView.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis.Views/3.4/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionPrognosedValuesView.cs	(revision 8430)
@@ -95,6 +95,6 @@
 
       string[,] values = new string[Content.ProblemData.Dataset.Rows, 4];
-      var prognosedTraining = Content.GetPrognosedValues(Content.ProblemData.TrainingIndizes.Take(1), Content.ProblemData.TrainingPartition.Size.ToEnumerable()).First();
-      var prognosedTest = Content.GetPrognosedValues(Content.ProblemData.TestIndizes.Take(1), Content.ProblemData.TestPartition.Size.ToEnumerable()).First();
+      var prognosedTraining = Content.GetPrognosedValues(Content.ProblemData.TrainingIndices.Take(1), Content.ProblemData.TrainingPartition.Size.ToEnumerable()).First();
+      var prognosedTest = Content.GetPrognosedValues(Content.ProblemData.TestIndices.Take(1), Content.ProblemData.TestPartition.Size.ToEnumerable()).First();
       double[] target = Content.ProblemData.Dataset.GetDoubleValues(targetVariable).ToArray();
 
@@ -105,5 +105,5 @@
       }
 
-      var rowsEnumerator = Content.ProblemData.TrainingIndizes.GetEnumerator();
+      var rowsEnumerator = Content.ProblemData.TrainingIndices.GetEnumerator();
       var prognosisEnumerator = prognosedTraining.GetEnumerator();
       while (rowsEnumerator.MoveNext() & prognosisEnumerator.MoveNext()) {
@@ -113,5 +113,5 @@
       }
 
-      rowsEnumerator = Content.ProblemData.TestIndizes.GetEnumerator();
+      rowsEnumerator = Content.ProblemData.TestIndices.GetEnumerator();
       prognosisEnumerator = prognosedTest.GetEnumerator();
       while (rowsEnumerator.MoveNext() & prognosisEnumerator.MoveNext()) {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs	(revision 8430)
@@ -131,6 +131,6 @@
         for (int col = 0; col < storableData.GetLength(1); col++) {
           string columName = variableNames[col];
-          var values = new List<double>();
-          for (int row = 0; row < storableData.GetLength(0); row++) {
+          var values = new List<double>(rows);
+          for (int row = 0; row < rows; row++) {
             values.Add(storableData[row, col]);
           }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj	(revision 8430)
@@ -93,4 +93,6 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="ALGLIB-3.5.0, Version=3.5.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
+    <Reference Include="HeuristicLab.ALGLIB-3.5.0, Version=3.5.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
     <Reference Include="HeuristicLab.Common-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL" />
@@ -140,5 +142,5 @@
     </Compile>
     <Compile Include="Implementation\Regression\RegressionEnsembleSolution.cs" />
-    <Compile Include="Implementation\TimeSeriesPrognosis\Models\TimeSeriesPrognosisConstantModel.cs" />
+    <Compile Include="Implementation\TimeSeriesPrognosis\Models\ConstantTimeSeriesPrognosisModel.cs" />
     <Compile Include="Implementation\TimeSeriesPrognosis\Models\TimeSeriesPrognosisMovingAverageModel.cs" />
     <Compile Include="Implementation\TimeSeriesPrognosis\Models\TimeSeriesPrognosisAutoRegressiveModel.cs" />
@@ -159,4 +161,6 @@
     <Compile Include="Interfaces\Regression\IRegressionEnsembleSolution.cs" />
     <Compile Include="Implementation\Regression\RegressionSolutionBase.cs" />
+    <Compile Include="OnlineCalculators\AutoCorrelationCalculator.cs" />
+    <Compile Include="OnlineCalculators\HoeffdingsDependenceCalculator.cs" />
     <Compile Include="OnlineCalculators\OnlineMaxAbsoluteErrorCalculator.cs" />
     <Compile Include="OnlineCalculators\OnlineMeanErrorCalculator.cs" />
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs	(revision 8430)
@@ -37,4 +37,7 @@
   [Creatable("Data Analysis - Ensembles")]
   public sealed class ClassificationEnsembleSolution : ClassificationSolution, IClassificationEnsembleSolution {
+    private readonly Dictionary<int, double> trainingEvaluationCache = new Dictionary<int, double>();
+    private readonly Dictionary<int, double> testEvaluationCache = new Dictionary<int, double>();
+
     public new IClassificationEnsembleModel Model {
       get { return (IClassificationEnsembleModel)base.Model; }
@@ -85,4 +88,7 @@
       }
 
+      trainingEvaluationCache = new Dictionary<int, double>(original.ProblemData.TrainingIndices.Count());
+      testEvaluationCache = new Dictionary<int, double>(original.ProblemData.TestIndices.Count());
+
       classificationSolutions = cloner.Clone(original.classificationSolutions);
       RegisterClassificationSolutionsEventHandler();
@@ -128,4 +134,7 @@
       }
 
+      trainingEvaluationCache = new Dictionary<int, double>(problemData.TrainingIndices.Count());
+      testEvaluationCache = new Dictionary<int, double>(problemData.TestIndices.Count());
+
       RegisterClassificationSolutionsEventHandler();
       classificationSolutions.AddRange(solutions);
@@ -148,18 +157,14 @@
     public override IEnumerable<double> EstimatedTrainingClassValues {
       get {
-        var rows = ProblemData.TrainingIndizes;
-        var estimatedValuesEnumerators = (from model in Model.Models
-                                          select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
-                                         .ToList();
-        var rowsEnumerator = rows.GetEnumerator();
-        // aggregate to make sure that MoveNext is called for all enumerators 
-        while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
-          int currentRow = rowsEnumerator.Current;
-
-          var selectedEnumerators = from pair in estimatedValuesEnumerators
-                                    where RowIsTrainingForModel(currentRow, pair.Model) && !RowIsTestForModel(currentRow, pair.Model)
-                                    select pair.EstimatedValuesEnumerator;
-          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current));
+        var rows = ProblemData.TrainingIndices;
+        var rowsToEvaluate = rows.Except(trainingEvaluationCache.Keys);
+        var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+        var valuesEnumerator = GetEstimatedValues(rowsToEvaluate, (r, m) => RowIsTrainingForModel(r, m) && !RowIsTestForModel(r, m)).GetEnumerator();
+
+        while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+          trainingEvaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
         }
+
+        return rows.Select(row => trainingEvaluationCache[row]);
       }
     }
@@ -167,19 +172,31 @@
     public override IEnumerable<double> EstimatedTestClassValues {
       get {
-        var rows = ProblemData.TestIndizes;
-        var estimatedValuesEnumerators = (from model in Model.Models
-                                          select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
-                                         .ToList();
-        var rowsEnumerator = ProblemData.TestIndizes.GetEnumerator();
-        // aggregate to make sure that MoveNext is called for all enumerators 
-        while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
-          int currentRow = rowsEnumerator.Current;
-
-          var selectedEnumerators = from pair in estimatedValuesEnumerators
-                                    where RowIsTestForModel(currentRow, pair.Model)
-                                    select pair.EstimatedValuesEnumerator;
-
-          yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current));
+        var rows = ProblemData.TestIndices;
+        var rowsToEvaluate = rows.Except(testEvaluationCache.Keys);
+        var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+        var valuesEnumerator = GetEstimatedValues(rowsToEvaluate, RowIsTestForModel).GetEnumerator();
+
+        while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+          testEvaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
         }
+
+        return rows.Select(row => testEvaluationCache[row]);
+      }
+    }
+
+    private IEnumerable<double> GetEstimatedValues(IEnumerable<int> rows, Func<int, IClassificationModel, bool> modelSelectionPredicate) {
+      var estimatedValuesEnumerators = (from model in Model.Models
+                                        select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
+                                       .ToList();
+      var rowsEnumerator = rows.GetEnumerator();
+      // aggregate to make sure that MoveNext is called for all enumerators 
+      while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
+        int currentRow = rowsEnumerator.Current;
+
+        var selectedEnumerators = from pair in estimatedValuesEnumerators
+                                  where modelSelectionPredicate(currentRow, pair.Model)
+                                  select pair.EstimatedValuesEnumerator;
+
+        yield return AggregateEstimatedClassValues(selectedEnumerators.Select(x => x.Current));
       }
     }
@@ -196,6 +213,15 @@
 
     public override IEnumerable<double> GetEstimatedClassValues(IEnumerable<int> rows) {
-      return from xs in GetEstimatedClassValueVectors(ProblemData.Dataset, rows)
-             select AggregateEstimatedClassValues(xs);
+      var rowsToEvaluate = rows.Except(evaluationCache.Keys);
+      var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+      var valuesEnumerator = (from xs in GetEstimatedClassValueVectors(ProblemData.Dataset, rowsToEvaluate)
+                              select AggregateEstimatedClassValues(xs))
+                             .GetEnumerator();
+
+      while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+        evaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
+      }
+
+      return rows.Select(row => evaluationCache[row]);
     }
 
@@ -223,4 +249,8 @@
 
     protected override void OnProblemDataChanged() {
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
+
       IClassificationProblemData problemData = new ClassificationProblemData(ProblemData.Dataset,
                                                                      ProblemData.AllowedInputVariables,
@@ -251,7 +281,15 @@
     public void AddClassificationSolutions(IEnumerable<IClassificationSolution> solutions) {
       classificationSolutions.AddRange(solutions);
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
     public void RemoveClassificationSolutions(IEnumerable<IClassificationSolution> solutions) {
       classificationSolutions.RemoveRange(solutions);
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
 
@@ -275,4 +313,8 @@
       trainingPartitions[solution.Model] = solution.ProblemData.TrainingPartition;
       testPartitions[solution.Model] = solution.ProblemData.TestPartition;
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
 
@@ -282,4 +324,8 @@
       trainingPartitions.Remove(solution.Model);
       testPartitions.Remove(solution.Model);
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
   }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs	(revision 8430)
@@ -207,6 +207,6 @@
 
     #region parameter properties
-    public ConstrainedValueParameter<StringValue> TargetVariableParameter {
-      get { return (ConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
+    public IConstrainedValueParameter<StringValue> TargetVariableParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     }
     public IFixedValueParameter<StringMatrix> ClassNamesParameter {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs	(revision 8430)
@@ -44,5 +44,5 @@
     public ClassificationSolution(IClassificationModel model, IClassificationProblemData problemData)
       : base(model, problemData) {
-      evaluationCache = new Dictionary<int, double>();
+      evaluationCache = new Dictionary<int, double>(problemData.Dataset.Rows);
     }
 
@@ -51,8 +51,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TestIndices); }
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs	(revision 8430)
@@ -87,7 +87,7 @@
     protected void CalculateResults() {
       double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
-      double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToArray();
+      double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
       double[] estimatedTestClassValues = EstimatedTestClassValues.ToArray(); // cache values
-      double[] originalTestClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes).ToArray();
+      double[] originalTestClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices).ToArray();
 
       OnlineCalculatorError errorState;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs	(revision 8430)
@@ -59,8 +59,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TestIndices); }
     }
 
@@ -82,8 +82,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingValues {
-      get { return GetEstimatedValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestValues {
-      get { return GetEstimatedValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedValues(ProblemData.TestIndices); }
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs	(revision 8430)
@@ -103,7 +103,7 @@
     protected void CalculateRegressionResults() {
       double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
-      double[] originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToArray();
+      double[] originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
       double[] estimatedTestValues = EstimatedTestValues.ToArray(); // cache values
-      double[] originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes).ToArray();
+      double[] originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices).ToArray();
 
       OnlineCalculatorError errorState;
@@ -140,5 +140,5 @@
       double[] classValues;
       double[] thresholds;
-      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
       AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, EstimatedTrainingValues, targetClassValues, out classValues, out thresholds);
 
@@ -149,5 +149,5 @@
       double[] classValues;
       double[] thresholds;
-      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
       NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(ProblemData, EstimatedTrainingValues, targetClassValues, out classValues, out thresholds);
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ThresholdCalculators/AccuracyMaximizationThresholdCalculator.cs	(revision 8430)
@@ -54,8 +54,9 @@
     public static void CalculateThresholds(IClassificationProblemData problemData, IEnumerable<double> estimatedValues, IEnumerable<double> targetClassValues, out double[] classValues, out double[] thresholds) {
       int slices = 100;
+      double minThresholdInc = 10e-5; // necessary to prevent infinite loop when maxEstimated - minEstimated is effectively zero (constant model)
       List<double> estimatedValuesList = estimatedValues.ToList();
       double maxEstimatedValue = estimatedValuesList.Max();
       double minEstimatedValue = estimatedValuesList.Min();
-      double thresholdIncrement = (maxEstimatedValue - minEstimatedValue) / slices;
+      double thresholdIncrement = Math.Max((maxEstimatedValue - minEstimatedValue) / slices, minThresholdInc);
       var estimatedAndTargetValuePairs =
         estimatedValuesList.Zip(targetClassValues, (x, y) => new { EstimatedValue = x, TargetClassValue = y })
@@ -70,6 +71,4 @@
 
       // incrementally calculate accuracy of all possible thresholds
-      int[,] confusionMatrix = new int[nClasses, nClasses];
-
       for (int i = 1; i < thresholds.Length; i++) {
         double lowerThreshold = thresholds[i - 1];
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs	(revision 8430)
@@ -68,5 +68,5 @@
     public virtual IEnumerable<int> TrainingClusterValues {
       get {
-        return GetClusterValues(ProblemData.TrainingIndizes);
+        return GetClusterValues(ProblemData.TrainingIndices);
       }
     }
@@ -74,5 +74,5 @@
     public virtual IEnumerable<int> TestClusterValues {
       get {
-        return GetClusterValues(ProblemData.TestIndizes);
+        return GetClusterValues(ProblemData.TestIndices);
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 8430)
@@ -75,5 +75,5 @@
     }
 
-    public virtual IEnumerable<int> TrainingIndizes {
+    public virtual IEnumerable<int> TrainingIndices {
       get {
         return Enumerable.Range(TrainingPartition.Start, Math.Max(0, TrainingPartition.End - TrainingPartition.Start))
@@ -81,5 +81,5 @@
       }
     }
-    public virtual IEnumerable<int> TestIndizes {
+    public virtual IEnumerable<int> TestIndices {
       get {
         return Enumerable.Range(TestPartition.Start, Math.Max(0, TestPartition.End - TestPartition.Start))
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs	(revision 8430)
@@ -37,4 +37,7 @@
   [Creatable("Data Analysis - Ensembles")]
   public sealed class RegressionEnsembleSolution : RegressionSolution, IRegressionEnsembleSolution {
+    private readonly Dictionary<int, double> trainingEvaluationCache = new Dictionary<int, double>();
+    private readonly Dictionary<int, double> testEvaluationCache = new Dictionary<int, double>();
+
     public new IRegressionEnsembleModel Model {
       get { return (IRegressionEnsembleModel)base.Model; }
@@ -52,7 +55,7 @@
 
     [Storable]
-    private Dictionary<IRegressionModel, IntRange> trainingPartitions;
+    private readonly Dictionary<IRegressionModel, IntRange> trainingPartitions;
     [Storable]
-    private Dictionary<IRegressionModel, IntRange> testPartitions;
+    private readonly Dictionary<IRegressionModel, IntRange> testPartitions;
 
     [StorableConstructor]
@@ -86,4 +89,7 @@
       }
 
+      trainingEvaluationCache = new Dictionary<int, double>(original.ProblemData.TrainingIndices.Count());
+      testEvaluationCache = new Dictionary<int, double>(original.ProblemData.TestIndices.Count());
+
       regressionSolutions = cloner.Clone(original.regressionSolutions);
       RegisterRegressionSolutionsEventHandler();
@@ -133,4 +139,7 @@
       }
 
+      trainingEvaluationCache = new Dictionary<int, double>(problemData.TrainingIndices.Count());
+      testEvaluationCache = new Dictionary<int, double>(problemData.TestIndices.Count());
+
       RegisterRegressionSolutionsEventHandler();
       regressionSolutions.AddRange(solutions);
@@ -153,18 +162,14 @@
     public override IEnumerable<double> EstimatedTrainingValues {
       get {
-        var rows = ProblemData.TrainingIndizes;
-        var estimatedValuesEnumerators = (from model in Model.Models
-                                          select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedValues(ProblemData.Dataset, rows).GetEnumerator() })
-                                         .ToList();
-        var rowsEnumerator = rows.GetEnumerator();
-        // aggregate to make sure that MoveNext is called for all enumerators 
-        while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
-          int currentRow = rowsEnumerator.Current;
-
-          var selectedEnumerators = from pair in estimatedValuesEnumerators
-                                    where RowIsTrainingForModel(currentRow, pair.Model) && !RowIsTestForModel(currentRow, pair.Model)
-                                    select pair.EstimatedValuesEnumerator;
-          yield return AggregateEstimatedValues(selectedEnumerators.Select(x => x.Current));
+        var rows = ProblemData.TrainingIndices;
+        var rowsToEvaluate = rows.Except(trainingEvaluationCache.Keys);
+        var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+        var valuesEnumerator = GetEstimatedValues(rowsToEvaluate, (r, m) => RowIsTrainingForModel(r, m) && !RowIsTestForModel(r, m)).GetEnumerator();
+
+        while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+          trainingEvaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
         }
+
+        return rows.Select(row => trainingEvaluationCache[row]);
       }
     }
@@ -172,19 +177,31 @@
     public override IEnumerable<double> EstimatedTestValues {
       get {
-        var rows = ProblemData.TestIndizes;
-        var estimatedValuesEnumerators = (from model in Model.Models
-                                          select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedValues(ProblemData.Dataset, rows).GetEnumerator() })
-                                         .ToList();
-        var rowsEnumerator = ProblemData.TestIndizes.GetEnumerator();
-        // aggregate to make sure that MoveNext is called for all enumerators 
-        while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
-          int currentRow = rowsEnumerator.Current;
-
-          var selectedEnumerators = from pair in estimatedValuesEnumerators
-                                    where RowIsTestForModel(currentRow, pair.Model)
-                                    select pair.EstimatedValuesEnumerator;
-
-          yield return AggregateEstimatedValues(selectedEnumerators.Select(x => x.Current));
+        var rows = ProblemData.TestIndices;
+        var rowsToEvaluate = rows.Except(testEvaluationCache.Keys);
+        var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+        var valuesEnumerator = GetEstimatedValues(rowsToEvaluate, RowIsTestForModel).GetEnumerator();
+
+        while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+          testEvaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
         }
+
+        return rows.Select(row => testEvaluationCache[row]);
+      }
+    }
+
+    private IEnumerable<double> GetEstimatedValues(IEnumerable<int> rows, Func<int, IRegressionModel, bool> modelSelectionPredicate) {
+      var estimatedValuesEnumerators = (from model in Model.Models
+                                        select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedValues(ProblemData.Dataset, rows).GetEnumerator() })
+                                       .ToList();
+      var rowsEnumerator = rows.GetEnumerator();
+      // aggregate to make sure that MoveNext is called for all enumerators 
+      while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
+        int currentRow = rowsEnumerator.Current;
+
+        var selectedEnumerators = from pair in estimatedValuesEnumerators
+                                  where modelSelectionPredicate(currentRow, pair.Model)
+                                  select pair.EstimatedValuesEnumerator;
+
+        yield return AggregateEstimatedValues(selectedEnumerators.Select(x => x.Current));
       }
     }
@@ -201,6 +218,15 @@
 
     public override IEnumerable<double> GetEstimatedValues(IEnumerable<int> rows) {
-      return from xs in GetEstimatedValueVectors(ProblemData.Dataset, rows)
-             select AggregateEstimatedValues(xs);
+      var rowsToEvaluate = rows.Except(evaluationCache.Keys);
+      var rowsEnumerator = rowsToEvaluate.GetEnumerator();
+      var valuesEnumerator = (from xs in GetEstimatedValueVectors(ProblemData.Dataset, rowsToEvaluate)
+                              select AggregateEstimatedValues(xs))
+                             .GetEnumerator();
+
+      while (rowsEnumerator.MoveNext() & valuesEnumerator.MoveNext()) {
+        evaluationCache.Add(rowsEnumerator.Current, valuesEnumerator.Current);
+      }
+
+      return rows.Select(row => evaluationCache[row]);
     }
 
@@ -223,4 +249,7 @@
 
     protected override void OnProblemDataChanged() {
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
       IRegressionProblemData problemData = new RegressionProblemData(ProblemData.Dataset,
                                                                      ProblemData.AllowedInputVariables,
@@ -251,7 +280,15 @@
     public void AddRegressionSolutions(IEnumerable<IRegressionSolution> solutions) {
       regressionSolutions.AddRange(solutions);
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
     public void RemoveRegressionSolutions(IEnumerable<IRegressionSolution> solutions) {
       regressionSolutions.RemoveRange(solutions);
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
 
@@ -275,4 +312,8 @@
       trainingPartitions[solution.Model] = solution.ProblemData.TrainingPartition;
       testPartitions[solution.Model] = solution.ProblemData.TestPartition;
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
 
@@ -282,4 +323,8 @@
       trainingPartitions.Remove(solution.Model);
       testPartitions.Remove(solution.Model);
+
+      trainingEvaluationCache.Clear();
+      testEvaluationCache.Clear();
+      evaluationCache.Clear();
     }
   }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs	(revision 8430)
@@ -95,6 +95,6 @@
     #endregion
 
-    public ConstrainedValueParameter<StringValue> TargetVariableParameter {
-      get { return (ConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
+    public IConstrainedValueParameter<StringValue> TargetVariableParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     }
     public string TargetVariable {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs	(revision 8430)
@@ -55,8 +55,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingValues {
-      get { return GetEstimatedValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestValues {
-      get { return GetEstimatedValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedValues(ProblemData.TestIndices); }
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs	(revision 8430)
@@ -138,5 +138,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TrainingMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the training partition", new DoubleValue()));
-        double trainingMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes), out errorState);
+        double trainingMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices), out errorState);
         TrainingMeanAbsoluteError = errorState == OnlineCalculatorError.None ? trainingMAE : double.NaN;
       }
@@ -145,5 +145,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TestMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the test partition", new DoubleValue()));
-        double testMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes), out errorState);
+        double testMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices), out errorState);
         TestMeanAbsoluteError = errorState == OnlineCalculatorError.None ? testMAE : double.NaN;
       }
@@ -152,5 +152,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TrainingMeanErrorResultName, "Mean of errors of the model on the training partition", new DoubleValue()));
-        double trainingME = OnlineMeanErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes), out errorState);
+        double trainingME = OnlineMeanErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices), out errorState);
         TrainingMeanError = errorState == OnlineCalculatorError.None ? trainingME : double.NaN;
       }
@@ -158,5 +158,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TestMeanErrorResultName, "Mean of errors of the model on the test partition", new DoubleValue()));
-        double testME = OnlineMeanErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes), out errorState);
+        double testME = OnlineMeanErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices), out errorState);
         TestMeanError = errorState == OnlineCalculatorError.None ? testME : double.NaN;
       }
@@ -166,7 +166,7 @@
     protected void CalculateResults() {
       IEnumerable<double> estimatedTrainingValues = EstimatedTrainingValues; // cache values
-      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
       IEnumerable<double> estimatedTestValues = EstimatedTestValues; // cache values
-      IEnumerable<double> originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
+      IEnumerable<double> originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices);
 
       OnlineCalculatorError errorState;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/ConstantTimeSeriesPrognosisModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/ConstantTimeSeriesPrognosisModel.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/ConstantTimeSeriesPrognosisModel.cs	(revision 8430)
@@ -0,0 +1,57 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableClass]
+  [Item("Constant TimeSeries Model", "A time series model that returns for all prediciton the same constant value.")]
+  public class ConstantTimeSeriesPrognosisModel : NamedItem, ITimeSeriesPrognosisModel {
+    [Storable]
+    public double Constant { get; private set; }
+
+    [StorableConstructor]
+    protected ConstantTimeSeriesPrognosisModel(bool deserializing) : base(deserializing) { }
+    protected ConstantTimeSeriesPrognosisModel(ConstantTimeSeriesPrognosisModel original, Cloner cloner)
+      : base(original, cloner) {
+      Constant = original.Constant;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ConstantTimeSeriesPrognosisModel(this, cloner);
+    }
+
+    public ConstantTimeSeriesPrognosisModel(double constant) {
+      Constant = constant;
+    }
+
+    public IEnumerable<IEnumerable<double>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, IEnumerable<int> horizons) {
+      return horizons.Select(horizon => Enumerable.Repeat(Constant, horizon));
+    }
+
+    public ITimeSeriesPrognosisSolution CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData) {
+      return new TimeSeriesPrognosisSolution(this, problemData);
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisAutoRegressiveModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisAutoRegressiveModel.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisAutoRegressiveModel.cs	(revision 8430)
@@ -30,11 +30,8 @@
   [Item("Autoregressive TimeSeries Model", "A linear autoregressive time series model used to predict future values.")]
   public class TimeSeriesPrognosisAutoRegressiveModel : NamedItem, ITimeSeriesPrognosisModel {
-    //Currently it is only possible to calculate AR(1)
-    //The paramater calculation for AR(p) is described in http://en.wikipedia.org/wiki/Autoregressive_model and should be inserted in the future
-
     [Storable]
-    public double Alpha { get; private set; }
+    public double[] Phi { get; private set; }
     [Storable]
-    public double Beta { get; private set; }
+    public double Constant { get; private set; }
     [Storable]
     public string TargetVariable { get; private set; }
@@ -46,6 +43,6 @@
     protected TimeSeriesPrognosisAutoRegressiveModel(TimeSeriesPrognosisAutoRegressiveModel original, Cloner cloner)
       : base(original, cloner) {
-      this.Alpha = original.Alpha;
-      this.Beta = original.Beta;
+      this.Phi = (double[])original.Phi.Clone();
+      this.Constant = original.Constant;
       this.TargetVariable = original.TargetVariable;
       this.TimeOffset = original.TimeOffset;
@@ -56,8 +53,8 @@
     public TimeSeriesPrognosisAutoRegressiveModel(double alpha, double beta, string targetVariable)
       : base() {
-      Alpha = alpha;
-      Beta = beta;
+      //Alpha = alpha;
+      //Beta = beta;
       TargetVariable = targetVariable;
-      TimeOffset = -1;
+      TimeOffset = 1;
     }
 
@@ -71,8 +68,7 @@
         double[] prognosis = new double[horizon];
 
-        if (row == 0) continue;
-        prognosis[0] = dataset.GetDoubleValue(TargetVariable, row + TimeOffset);
+        prognosis[0] = dataset.GetDoubleValue(TargetVariable, row - TimeOffset);
         for (int i = 1; i < horizon; i++) {
-          prognosis[i] = Beta * prognosis[i - 1] + Alpha;
+          //prognosis[i] = Beta * prognosis[i - 1] + Alpha;
         }
         yield return prognosis;
Index: anches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisConstantModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisConstantModel.cs	(revision 8429)
+++ 	(revision )
@@ -1,57 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System.Collections.Generic;
-using System.Linq;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.DataAnalysis {
-  [StorableClass]
-  [Item("Constant TimeSeries Model", "A time series model that returns for all prediciton the same constant value.")]
-  public class TimeSeriesPrognosisConstantModel : NamedItem, ITimeSeriesPrognosisModel {
-    [Storable]
-    public double Constant { get; private set; }
-
-    [StorableConstructor]
-    protected TimeSeriesPrognosisConstantModel(bool deserializing) : base(deserializing) { }
-    protected TimeSeriesPrognosisConstantModel(TimeSeriesPrognosisConstantModel original, Cloner cloner)
-      : base(original, cloner) {
-      Constant = original.Constant;
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new TimeSeriesPrognosisConstantModel(this, cloner);
-    }
-
-    public TimeSeriesPrognosisConstantModel(double constant) {
-      Constant = constant;
-    }
-
-    public IEnumerable<IEnumerable<double>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, IEnumerable<int> horizons) {
-      return horizons.Select(horizon => Enumerable.Repeat(Constant, horizon));
-    }
-
-    public ITimeSeriesPrognosisSolution CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData) {
-      return new TimeSeriesPrognosisSolution(this, problemData);
-    }
-  }
-}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisMovingAverageModel.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisMovingAverageModel.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/Models/TimeSeriesPrognosisMovingAverageModel.cs	(revision 8430)
@@ -61,5 +61,4 @@
         int startIndex = row - WindowSize;
 
-        if (row == 0) continue;
         if (startIndex < 0) startIndex = 0;
         int count = row - startIndex - 1;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionBase.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionBase.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionBase.cs	(revision 8430)
@@ -194,11 +194,11 @@
       OnlineCalculatorError errorState;
       //mean model
-      double trainingMean = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).Average();
-      var meanModel = new TimeSeriesPrognosisConstantModel(trainingMean);
+      double trainingMean = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).Average();
+      var meanModel = new ConstantTimeSeriesPrognosisModel(trainingMean);
 
       //AR1 model
       double alpha, beta;
-      IEnumerable<double> trainingStartValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes.Select(r => r - 1).Where(r => r > 0)).ToList();
-      OnlineLinearScalingParameterCalculator.Calculate(ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes.Where(x => x > 0)), trainingStartValues, out alpha, out beta, out errorState);
+      IEnumerable<double> trainingStartValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices.Select(r => r - 1).Where(r => r > 0)).ToList();
+      OnlineLinearScalingParameterCalculator.Calculate(ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices.Where(x => x > 0)), trainingStartValues, out alpha, out beta, out errorState);
       var AR1model = new TimeSeriesPrognosisAutoRegressiveModel(alpha, beta, ProblemData.TargetVariable);
 
@@ -208,7 +208,7 @@
 
       #region Calculate training quality measures
-      var trainingHorizions = ProblemData.TrainingIndizes.Select(r => Math.Min(horizon, ProblemData.TrainingPartition.End - r)).ToList();
-      IEnumerable<IEnumerable<double>> trainingTargetValues = ProblemData.TrainingIndizes.Zip(trainingHorizions, Enumerable.Range).Select(r => ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, r)).ToList();
-      IEnumerable<IEnumerable<double>> trainingEstimatedValues = Model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndizes, trainingHorizions).ToList();
+      var trainingHorizions = ProblemData.TrainingIndices.Select(r => Math.Min(horizon, ProblemData.TrainingPartition.End - r)).ToList();
+      IEnumerable<IEnumerable<double>> trainingTargetValues = ProblemData.TrainingIndices.Zip(trainingHorizions, Enumerable.Range).Select(r => ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, r)).ToList();
+      IEnumerable<IEnumerable<double>> trainingEstimatedValues = Model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndices, trainingHorizions).ToList();
 
       TrainingMeanSquaredError = OnlineMeanSquaredErrorCalculator.Calculate(trainingTargetValues.SelectMany(x => x), trainingEstimatedValues.SelectMany(x => x), out errorState);
@@ -223,7 +223,7 @@
       TrainingNormalizedMeanSquaredError = errorState == OnlineCalculatorError.None ? TrainingNormalizedMeanSquaredError : double.PositiveInfinity;
 
-      IEnumerable<IEnumerable<double>> trainingMeanModelPredictions = meanModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndizes, trainingHorizions);
-      IEnumerable<IEnumerable<double>> trainingAR1ModelPredictions = AR1model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndizes, trainingHorizions);
-      IEnumerable<IEnumerable<double>> trainingMovingAverageModelPredictions = MovingAverageModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndizes, trainingHorizions);
+      IEnumerable<IEnumerable<double>> trainingMeanModelPredictions = meanModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndices, trainingHorizions);
+      IEnumerable<IEnumerable<double>> trainingAR1ModelPredictions = AR1model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndices, trainingHorizions);
+      IEnumerable<IEnumerable<double>> trainingMovingAverageModelPredictions = MovingAverageModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TrainingIndices, trainingHorizions);
 
       TrainingDirectionalSymmetry = OnlineDirectionalSymmetryCalculator.Calculate(trainingStartValues, trainingTargetValues, trainingEstimatedValues, out errorState);
@@ -240,7 +240,7 @@
 
       #region  Calculate test quality measures
-      var testHorizions = ProblemData.TestIndizes.Select(r => Math.Min(horizon, ProblemData.TestPartition.End - r)).ToList();
-      IEnumerable<IEnumerable<double>> testTargetValues = ProblemData.TestIndizes.Zip(testHorizions, Enumerable.Range).Select(r => ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, r)).ToList();
-      IEnumerable<IEnumerable<double>> testEstimatedValues = Model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndizes, testHorizions).ToList();
+      var testHorizions = ProblemData.TestIndices.Select(r => Math.Min(horizon, ProblemData.TestPartition.End - r)).ToList();
+      IEnumerable<IEnumerable<double>> testTargetValues = ProblemData.TestIndices.Zip(testHorizions, Enumerable.Range).Select(r => ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, r)).ToList();
+      IEnumerable<IEnumerable<double>> testEstimatedValues = Model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndices, testHorizions).ToList();
 
       TestMeanSquaredError = OnlineMeanSquaredErrorCalculator.Calculate(testTargetValues.SelectMany(x => x), testEstimatedValues.SelectMany(x => x), out errorState);
@@ -255,8 +255,8 @@
       TestNormalizedMeanSquaredError = errorState == OnlineCalculatorError.None ? TestNormalizedMeanSquaredError : double.PositiveInfinity;
 
-      IEnumerable<double> testStartValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes.Select(r => r - 1).Where(r => r > 0)).ToList();
-      IEnumerable<IEnumerable<double>> testMeanModelPredictions = meanModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndizes, testHorizions);
-      IEnumerable<IEnumerable<double>> testAR1ModelPredictions = AR1model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndizes, testHorizions);
-      IEnumerable<IEnumerable<double>> testMovingAverageModelPredictions = MovingAverageModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndizes, testHorizions);
+      IEnumerable<double> testStartValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices.Select(r => r - 1).Where(r => r > 0)).ToList();
+      IEnumerable<IEnumerable<double>> testMeanModelPredictions = meanModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndices, testHorizions);
+      IEnumerable<IEnumerable<double>> testAR1ModelPredictions = AR1model.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndices, testHorizions);
+      IEnumerable<IEnumerable<double>> testMovingAverageModelPredictions = MovingAverageModel.GetPrognosedValues(ProblemData.Dataset, ProblemData.TestIndices, testHorizions);
 
       TestDirectionalSymmetry = OnlineDirectionalSymmetryCalculator.Calculate(testStartValues, testTargetValues, testEstimatedValues, out errorState);
@@ -270,5 +270,5 @@
       TestTheilsUStatisticMovingAverage = OnlineTheilsUStatisticCalculator.Calculate(testStartValues, testTargetValues, testMovingAverageModelPredictions, testEstimatedValues, out errorState);
       TestTheilsUStatisticMovingAverage = errorState == OnlineCalculatorError.None ? TestTheilsUStatisticMovingAverage : double.PositiveInfinity; ; ;
-      #endregion     
+      #endregion
     }
   }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 8430)
@@ -36,6 +36,6 @@
     IntRange TestPartition { get; }
 
-    IEnumerable<int> TrainingIndizes { get; }
-    IEnumerable<int> TestIndizes { get; }
+    IEnumerable<int> TrainingIndices { get; }
+    IEnumerable<int> TestIndices { get; }
 
     bool IsTrainingSample(int index);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs	(revision 8430)
@@ -24,13 +24,13 @@
 namespace HeuristicLab.Problems.DataAnalysis {
   [Flags]
-  public enum OnlineCalculatorError { 
+  public enum OnlineCalculatorError {
     /// <summary>
     /// No error occurred
     /// </summary>
-    None = 0, 
+    None = 0,
     /// <summary>
     /// An invalid value has been added (often +/- Infinity and NaN are invalid values)
     /// </summary>
-    InvalidValueAdded = 1, 
+    InvalidValueAdded = 1,
     /// <summary>
     /// The number of elements added to the evaluator is not sufficient to calculate the result value
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/AutoCorrelationCalculator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/AutoCorrelationCalculator.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/AutoCorrelationCalculator.cs	(revision 8430)
@@ -0,0 +1,38 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System.Linq;
+
+namespace HeuristicLab.Problems.DataAnalysis.OnlineCalculators {
+  public class AutoCorrelationCalculator {
+    public static double[] Calculate(double[] values, out OnlineCalculatorError error) {
+      error = OnlineCalculatorError.None;
+      if (values.Any(x => double.IsNaN(x) || double.IsInfinity(x))) {
+        error = OnlineCalculatorError.InvalidValueAdded;
+        return new double[0];
+      }
+
+      double[] correlations = new double[values.Length];
+      alglib.corr.corrr1dcircular(values, values.Length, values, values.Length, ref correlations);
+      return correlations;
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/HoeffdingsDependenceCalculator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/HoeffdingsDependenceCalculator.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/HoeffdingsDependenceCalculator.cs	(revision 8430)
@@ -0,0 +1,130 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+
+namespace HeuristicLab.Problems.DataAnalysis {
+  public class HoeffdingsDependenceCalculator {
+
+    public static double Calculate(IEnumerable<double> originalValues, IEnumerable<double> estimatedValues, out OnlineCalculatorError errorState) {
+      double d = HoeffD(originalValues, estimatedValues, out errorState);
+      if (errorState != OnlineCalculatorError.None) return double.NaN;
+      return d;
+    }
+
+    /// <summary>
+    /// computes Hoeffding's dependence coefficient. 
+    /// Source: hoeffd.r from R package hmisc http://cran.r-project.org/web/packages/Hmisc/index.html
+    /// </summary>
+    private static double HoeffD(IEnumerable<double> xs, IEnumerable<double> ys, out OnlineCalculatorError errorState) {
+      double[] rx = TiedRank(xs);
+      double[] ry = TiedRank(ys);
+      if (rx.Length != ry.Length) throw new ArgumentException("The number of elements in xs and ys does not match");
+      double[] rxy = TiedRank(xs, ys);
+
+      int n = rx.Length;
+      double q = 0, r = 0, s = 0;
+      double scaling = 1.0 / (n * (n - 1));
+      for (int i = 0; i < n; i++) {
+        q += (rx[i] - 1) * (rx[i] - 2) * (ry[i] - 1) * (ry[i] - 2) * scaling;
+        r += (rx[i] - 2) * (ry[i] - 2) * rxy[i] * scaling;
+        s += rxy[i] * (rxy[i] - 1) * scaling;
+      }
+      errorState = OnlineCalculatorError.None;
+      // return 30.0 * (q - 2 * (n - 2) * r + (n - 2) * (n - 3) * s) / n / (n - 1) / (n - 2) / (n - 3) / (n - 4);
+      double t0 = q / (n - 2) / (n - 3) / (n - 4);
+      double t1 = 2 * r / (n - 3) / (n - 4);
+      double t2 = s / (n - 4);
+      return 30.0 * (t0 - t1 + t2);
+    }
+
+    private static double[] TiedRank(IEnumerable<double> xs) {
+      var xsArr = xs.ToArray();
+      var idx = Enumerable.Range(1, xsArr.Length).ToArray();
+      Array.Sort(xsArr, idx);
+      CRank(xsArr);
+      Array.Sort(idx, xsArr);
+      return xsArr;
+    }
+
+    /// <summary>
+    /// Calculates the joint rank with midranks for ties. Source: hoeffd.r from R package hmisc http://cran.r-project.org/web/packages/Hmisc/index.html
+    /// </summary>
+    /// <param name="xs"></param>
+    /// <param name="ys"></param>
+    /// <returns></returns>
+    private static double[] TiedRank(IEnumerable<double> xs, IEnumerable<double> ys) {
+      var xsArr = xs.ToArray();
+      var ysArr = ys.ToArray();
+      var r = new double[xsArr.Length];
+      int n = r.Length;
+      for (int i = 0; i < n; i++) {
+        var xi = xsArr[i];
+        var yi = ysArr[i];
+        double ri = 0.0;
+        for (int j = 0; j < n; j++) {
+          if (i != j) {
+            double cx;
+            if (xsArr[j] < xi) cx = 1.0;
+            else if (xsArr[j] > xi) cx = 0.0;
+            else cx = 0.5;  // eq
+            double cy;
+            if (ysArr[j] < yi) cy = 1.0;
+            else if (ysArr[j] > yi) cy = 0.0;
+            else cy = 0.5; // eq
+            ri = ri + cx * cy;
+          }
+        }
+        r[i] = ri;
+      }
+      return r;
+    }
+
+    /// <summary>
+    /// Calculates midranks. Source: Numerical Recipes in C. p 642
+    /// </summary>
+    /// <param name="w">Sorted array of elements, replaces the elements by their rank, including midranking of ties</param>
+    /// <returns></returns>
+    private static void CRank(double[] w) {
+      int i = 0;
+      int n = w.Length;
+      while (i < n - 1) {
+        if (w[i + 1] > w[i]) {    // w[i+1] must be larger or equal w[i] as w must be sorted
+          // not a tie
+          w[i] = i + 1;
+          i++;
+        } else {
+          int j;
+          for (j = i + 1; j < n && w[j] <= w[i]; j++) ; // how far does it go (<= effectively means == as w must be sorted, side-step equality for double values)
+          double rank = 1 + 0.5 * (i + j - 1);
+          int k;
+          for (k = i; k < j; k++) w[k] = rank; // set the rank for all tied entries
+          i = j;
+        }
+      }
+
+      if (i == n - 1) w[n - 1] = n;   // if the last element was not tied, this is its rank
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineLinearScalingParameterCalculator.cs	(revision 8430)
@@ -55,5 +55,4 @@
     }
 
-    private int cnt;
     private OnlineMeanAndVarianceCalculator targetMeanCalculator;
     private OnlineMeanAndVarianceCalculator originalMeanAndVarianceCalculator;
@@ -68,5 +67,4 @@
 
     public void Reset() {
-      cnt = 0;
       targetMeanCalculator.Reset();
       originalMeanAndVarianceCalculator.Reset();
@@ -85,5 +83,4 @@
       originalTargetCovarianceCalculator.Add(original, target);
 
-      cnt++;
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineTheilsUStatisticCalculator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineTheilsUStatisticCalculator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/OnlineCalculators/OnlineTheilsUStatisticCalculator.cs	(revision 8430)
@@ -55,5 +55,5 @@
     }
 
-    public void Add(double startValue, IEnumerable<double> referenceContinuation, IEnumerable<double> actualContinuation, IEnumerable<double> predictedContinuation) {
+    public void Add(double startValue, IEnumerable<double> actualContinuation, IEnumerable<double> referenceContinuation, IEnumerable<double> predictedContinuation) {
       if (double.IsNaN(startValue) || (errorState & OnlineCalculatorError.InvalidValueAdded) > 0) {
         errorState = errorState | OnlineCalculatorError.InvalidValueAdded;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Plugin.cs.frame	(revision 8430)
@@ -26,6 +26,7 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
-  [Plugin("HeuristicLab.Problems.DataAnalysis","Provides base classes for data analysis tasks.", "3.4.2.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.DataAnalysis","Provides base classes for data analysis tasks.", "3.4.3.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.DataAnalysis-3.4.dll", PluginFileType.Assembly)]
+  [PluginDependency("HeuristicLab.ALGLIB","3.5")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -53,3 +53,3 @@
 // by using the '*' as shown below:
 [assembly: AssemblyVersion("3.4.0.0")]
-[assembly: AssemblyFileVersion("3.4.2.$WCREV$")]
+[assembly: AssemblyFileVersion("3.4.3.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/CSV/ClassifiactionCSVInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/CSV/ClassifiactionCSVInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/CSV/ClassifiactionCSVInstanceProvider.cs	(revision 8430)
@@ -20,12 +20,15 @@
 #endregion
 
-
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
 using HeuristicLab.Problems.DataAnalysis;
+
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
   public class ClassificationCSVInstanceProvider : ClassificationInstanceProvider {
     public override string Name {
-      get { return "CSV Problem Provider"; }
+      get { return "CSV File"; }
     }
     public override string Description {
@@ -48,4 +51,61 @@
       throw new NotImplementedException();
     }
+
+    public override bool CanImportData {
+      get { return true; }
+    }
+    public override IClassificationProblemData ImportData(string path) {
+      TableFileParser csvFileParser = new TableFileParser();
+
+      csvFileParser.Parse(path);
+
+      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
+      string targetVar = csvFileParser.VariableNames.Where(x => dataset.DoubleVariables.Contains(x)).Last();
+      IEnumerable<string> allowedInputVars = dataset.DoubleVariables.Where(x => !x.Equals(targetVar));
+
+      ClassificationProblemData claData = new ClassificationProblemData(dataset, allowedInputVars, targetVar);
+
+      int trainingPartEnd = csvFileParser.Rows * 2 / 3;
+      claData.TrainingPartition.Start = 0;
+      claData.TrainingPartition.End = trainingPartEnd;
+      claData.TestPartition.Start = trainingPartEnd;
+      claData.TestPartition.End = csvFileParser.Rows;
+      int pos = path.LastIndexOf('\\');
+      if (pos < 0)
+        claData.Name = path;
+      else {
+        pos++;
+        claData.Name = path.Substring(pos, path.Length - pos);
+      }
+
+      return claData;
+    }
+
+    public override bool CanExportData {
+      get { return true; }
+    }
+    public override void ExportData(IClassificationProblemData instance, string path) {
+      StringBuilder strBuilder = new StringBuilder();
+
+      foreach (var variable in instance.InputVariables) {
+        strBuilder.Append(variable + ";");
+      }
+      strBuilder.Remove(strBuilder.Length - 1, 1);
+      strBuilder.AppendLine();
+
+      Dataset dataset = instance.Dataset;
+
+      for (int i = 0; i < dataset.Rows; i++) {
+        for (int j = 0; j < dataset.Columns; j++) {
+          strBuilder.Append(dataset.GetValue(i, j) + ";");
+        }
+        strBuilder.Remove(strBuilder.Length - 1, 1);
+        strBuilder.AppendLine();
+      }
+
+      using (StreamWriter writer = new StreamWriter(path)) {
+        writer.Write(strBuilder);
+      }
+    }
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/ClassificationInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/ClassificationInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/ClassificationInstanceProvider.cs	(revision 8430)
@@ -20,72 +20,8 @@
 #endregion
 
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
-  public abstract class ClassificationInstanceProvider : IProblemInstanceProvider<IClassificationProblemData> {
-    public IClassificationProblemData LoadData(string path) {
-      TableFileParser csvFileParser = new TableFileParser();
-
-      csvFileParser.Parse(path);
-
-      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
-      string targetVar = csvFileParser.VariableNames.Last();
-      IEnumerable<string> allowedInputVars = csvFileParser.VariableNames.Where(x => !x.Equals(targetVar));
-
-      ClassificationProblemData claData = new ClassificationProblemData(dataset, allowedInputVars, targetVar);
-
-      int trainingPartEnd = csvFileParser.Rows * 2 / 3;
-      claData.TrainingPartition.Start = 0;
-      claData.TrainingPartition.End = trainingPartEnd;
-      claData.TestPartition.Start = trainingPartEnd;
-      claData.TestPartition.End = csvFileParser.Rows;
-      int pos = path.LastIndexOf('\\');
-      if (pos < 0)
-        claData.Name = path;
-      else {
-        pos++;
-        claData.Name = path.Substring(pos, path.Length - pos);
-      }
-
-      return claData;
-    }
-
-    public void SaveData(IClassificationProblemData instance, string path) {
-      StringBuilder strBuilder = new StringBuilder();
-
-      foreach (var variable in instance.InputVariables) {
-        strBuilder.Append(variable + ";");
-      }
-      strBuilder.Remove(strBuilder.Length - 1, 1);
-      strBuilder.AppendLine();
-
-      Dataset dataset = instance.Dataset;
-
-      for (int i = 0; i < dataset.Rows; i++) {
-        for (int j = 0; j < dataset.Columns; j++) {
-          strBuilder.Append(dataset.GetValue(i, j) + ";");
-        }
-        strBuilder.Remove(strBuilder.Length - 1, 1);
-        strBuilder.AppendLine();
-      }
-
-      using (StreamWriter writer = new StreamWriter(path)) {
-        writer.Write(strBuilder);
-      }
-    }
-
-    public abstract IEnumerable<IDataDescriptor> GetDataDescriptors();
-    public abstract IClassificationProblemData LoadData(IDataDescriptor descriptor);
-
-    public abstract string Name { get; }
-    public abstract string Description { get; }
-    public abstract Uri WebLink { get; }
-    public abstract string ReferencePublication { get; }
+  public abstract class ClassificationInstanceProvider : ProblemInstanceProvider<IClassificationProblemData> {
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/RealWorld/ClassificationRealWorldInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/RealWorld/ClassificationRealWorldInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/RealWorld/ClassificationRealWorldInstanceProvider.cs	(revision 8430)
@@ -47,5 +47,4 @@
     public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
       List<IDataDescriptor> descriptorList = new List<IDataDescriptor>();
-      descriptorList.Add(new Iris());
       descriptorList.Add(new Mammography());
       var solutionsArchiveName = GetResourceName(FileName + @"\.zip");
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/ResourceClassificationInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/ResourceClassificationInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Classification/ResourceClassificationInstanceProvider.cs	(revision 8430)
@@ -70,6 +70,6 @@
 
         Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
-        string targetVar = csvFileParser.VariableNames.Last();
-        IEnumerable<string> allowedInputVars = csvFileParser.VariableNames.Where(x => !x.Equals(targetVar));
+        string targetVar = csvFileParser.VariableNames.Where(x => dataset.DoubleVariables.Contains(x)).Last();
+        IEnumerable<string> allowedInputVars = dataset.DoubleVariables.Where(x => !x.Equals(targetVar));
 
         ClassificationProblemData claData = new ClassificationProblemData(dataset, allowedInputVars, targetVar);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Clustering/CSV/ClusteringCSVInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Clustering/CSV/ClusteringCSVInstanceProvider.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Clustering/CSV/ClusteringCSVInstanceProvider.cs	(revision 8430)
@@ -0,0 +1,107 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class ClusteringCSVInstanceProvider : ClusteringInstanceProvider {
+    public override string Name {
+      get { return "CSV File"; }
+    }
+    public override string Description {
+      get {
+        return "";
+      }
+    }
+    public override Uri WebLink {
+      get { return new Uri("http://dev.heuristiclab.com/trac/hl/core/wiki/UsersFAQ#DataAnalysisImportFileFormat"); }
+    }
+    public override string ReferencePublication {
+      get { return ""; }
+    }
+
+    public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
+      return new List<IDataDescriptor>();
+    }
+
+    public override IClusteringProblemData LoadData(IDataDescriptor descriptor) {
+      throw new NotImplementedException();
+    }
+
+    public override bool CanImportData {
+      get { return true; }
+    }
+    public override IClusteringProblemData ImportData(string path) {
+      var csvFileParser = new TableFileParser();
+
+      csvFileParser.Parse(path);
+
+      var dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
+      var claData = new ClusteringProblemData(dataset, dataset.DoubleVariables);
+
+      int trainingPartEnd = csvFileParser.Rows * 2 / 3;
+      claData.TrainingPartition.Start = 0;
+      claData.TrainingPartition.End = trainingPartEnd;
+      claData.TestPartition.Start = trainingPartEnd;
+      claData.TestPartition.End = csvFileParser.Rows;
+      int pos = path.LastIndexOf('\\');
+      if (pos < 0)
+        claData.Name = path;
+      else {
+        pos++;
+        claData.Name = path.Substring(pos, path.Length - pos);
+      }
+
+      return claData;
+    }
+
+    public override bool CanExportData {
+      get { return true; }
+    }
+    public override void ExportData(IClusteringProblemData instance, string path) {
+      var strBuilder = new StringBuilder();
+
+      foreach (var variable in instance.InputVariables) {
+        strBuilder.Append(variable + ";");
+      }
+      strBuilder.Remove(strBuilder.Length - 1, 1);
+      strBuilder.AppendLine();
+
+      var dataset = instance.Dataset;
+
+      for (int i = 0; i < dataset.Rows; i++) {
+        for (int j = 0; j < dataset.Columns; j++) {
+          strBuilder.Append(dataset.GetValue(i, j) + ";");
+        }
+        strBuilder.Remove(strBuilder.Length - 1, 1);
+        strBuilder.AppendLine();
+      }
+
+      using (var writer = new StreamWriter(path)) {
+        writer.Write(strBuilder);
+      }
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Clustering/ClusteringInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Clustering/ClusteringInstanceProvider.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Clustering/ClusteringInstanceProvider.cs	(revision 8430)
@@ -0,0 +1,27 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using HeuristicLab.Problems.DataAnalysis;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public abstract class ClusteringInstanceProvider : ProblemInstanceProvider<IClusteringProblemData> {
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj	(revision 8430)
@@ -37,4 +37,64 @@
     <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x86'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances.DataAnalysis-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x86'">
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x86</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances.DataAnalysis-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Debug|x64'">
+    <DebugSymbols>true</DebugSymbols>
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <DebugType>full</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances.DataAnalysis-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Release|x64'">
+    <OutputPath>..\..\bin\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <Optimize>true</Optimize>
+    <DebugType>pdbonly</DebugType>
+    <PlatformTarget>x64</PlatformTarget>
+    <CodeAnalysisLogFile>..\..\bin\HeuristicLab.Problems.Instances.DataAnalysis-3.3.dll.CodeAnalysisLog.xml</CodeAnalysisLogFile>
+    <CodeAnalysisUseTypeNameInSuppression>true</CodeAnalysisUseTypeNameInSuppression>
+    <CodeAnalysisModuleSuppressionsFile>GlobalSuppressions.cs</CodeAnalysisModuleSuppressionsFile>
+    <ErrorReport>prompt</ErrorReport>
+    <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+    <CodeAnalysisRuleSetDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\\Rule Sets</CodeAnalysisRuleSetDirectories>
+    <CodeAnalysisIgnoreBuiltInRuleSets>true</CodeAnalysisIgnoreBuiltInRuleSets>
+    <CodeAnalysisRuleDirectories>;C:\Program Files (x86)\Microsoft Visual Studio 10.0\Team Tools\Static Analysis Tools\FxCop\\Rules</CodeAnalysisRuleDirectories>
+    <CodeAnalysisIgnoreBuiltInRules>false</CodeAnalysisIgnoreBuiltInRules>
+  </PropertyGroup>
   <ItemGroup>
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
@@ -82,4 +142,6 @@
     <Compile Include="Classification\ResourceClassificationDataDescriptor.cs" />
     <Compile Include="Classification\ResourceClassificationInstanceProvider.cs" />
+    <Compile Include="Clustering\ClusteringInstanceProvider.cs" />
+    <Compile Include="Clustering\CSV\ClusteringCSVInstanceProvider.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
@@ -89,14 +151,17 @@
     <Compile Include="Regression\Keijzer\KeijzerFunctionFourteen.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionEleven.cs" />
-    <Compile Include="Regression\Keijzer\KeijzerFunctionNine.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionFive.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionEight.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionFifteen.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionFour.cs" />
+    <Compile Include="Regression\Keijzer\KeijzerFunctionNine.cs" />
+    <Compile Include="Regression\Keijzer\KeijzerFunctionOne.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionSeven.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionSix.cs" />
-    <Compile Include="Regression\Keijzer\KeijzerFunctionSixteen.cs" />
+    <Compile Include="Regression\Keijzer\KeijzerFunctionTen.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionThirteen.cs" />
+    <Compile Include="Regression\Keijzer\KeijzerFunctionThree.cs" />
     <Compile Include="Regression\Keijzer\KeijzerFunctionTwelve.cs" />
+    <Compile Include="Regression\Keijzer\KeijzerFunctionTwo.cs" />
     <Compile Include="Regression\Keijzer\KeijzerInstanceProvider.cs" />
     <Compile Include="Regression\Korns\KornsFunctionEight.cs" />
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Plugin.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Plugin.cs.frame	(revision 8430)
@@ -23,7 +23,6 @@
 
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
-  [Plugin("HeuristicLab.Problems.Instances.DataAnalysis", "3.3.6.$WCREV$")]
+  [Plugin("HeuristicLab.Problems.Instances.DataAnalysis", "3.3.7.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.Instances.DataAnalysis-3.3.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.Common", "3.3")]
   [PluginDependency("HeuristicLab.Core", "3.3")]
   [PluginDependency("HeuristicLab.Data", "3.3")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -55,3 +55,3 @@
 // [assembly: AssemblyVersion("1.0.*")]
 [assembly: AssemblyVersion("3.3.0.0")]
-[assembly: AssemblyFileVersion("3.3.6.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.7.$WCREV$")]
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/CSV/RegressionCSVInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/CSV/RegressionCSVInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/CSV/RegressionCSVInstanceProvider.cs	(revision 8430)
@@ -20,12 +20,15 @@
 #endregion
 
-
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
 using HeuristicLab.Problems.DataAnalysis;
+
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
   public class RegressionCSVInstanceProvider : RegressionInstanceProvider {
     public override string Name {
-      get { return "CSV Problem Provider"; }
+      get { return "CSV File"; }
     }
     public override string Description {
@@ -44,8 +47,64 @@
       return new List<IDataDescriptor>();
     }
-
     public override IRegressionProblemData LoadData(IDataDescriptor descriptor) {
       throw new NotImplementedException();
     }
+
+    public override bool CanImportData {
+      get { return true; }
+    }
+    public override IRegressionProblemData ImportData(string path) {
+      TableFileParser csvFileParser = new TableFileParser();
+      csvFileParser.Parse(path);
+
+      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
+      string targetVar = csvFileParser.VariableNames.Where(x => dataset.DoubleVariables.Contains(x)).Last();
+
+      IEnumerable<string> allowedInputVars = dataset.DoubleVariables.Where(x => !x.Equals(targetVar));
+
+      IRegressionProblemData regData = new RegressionProblemData(dataset, allowedInputVars, targetVar);
+
+      int trainingPartEnd = csvFileParser.Rows * 2 / 3;
+      regData.TrainingPartition.Start = 0;
+      regData.TrainingPartition.End = trainingPartEnd;
+      regData.TestPartition.Start = trainingPartEnd;
+      regData.TestPartition.End = csvFileParser.Rows;
+
+      int pos = path.LastIndexOf('\\');
+      if (pos < 0)
+        regData.Name = path;
+      else {
+        pos++;
+        regData.Name = path.Substring(pos, path.Length - pos);
+      }
+      return regData;
+    }
+
+    public override bool CanExportData {
+      get { return true; }
+    }
+    public override void ExportData(IRegressionProblemData instance, string path) {
+      StringBuilder strBuilder = new StringBuilder();
+
+      foreach (var variable in instance.InputVariables) {
+        strBuilder.Append(variable + ";");
+      }
+      strBuilder.Remove(strBuilder.Length - 1, 1);
+      strBuilder.AppendLine();
+
+      Dataset dataset = instance.Dataset;
+
+      for (int i = 0; i < dataset.Rows; i++) {
+        for (int j = 0; j < dataset.Columns; j++) {
+          strBuilder.Append(dataset.GetValue(i, j) + ";");
+        }
+        strBuilder.Remove(strBuilder.Length - 1, 1);
+        strBuilder.AppendLine();
+      }
+
+      using (StreamWriter writer = new StreamWriter(path)) {
+        writer.Write(strBuilder);
+      }
+    }
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionEight.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionEight.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionEight.cs	(revision 8430)
@@ -27,14 +27,13 @@
   public class KeijzerFunctionEight : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 8 f(x) = log(x)"; } }
+    public override string Name { get { return "Keijzer 8 f(x) = sqrt(x)"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
-          + "Authors: Maarten Keijzer" + Environment.NewLine
-          + "Function: f(x) = log(x)" + Environment.NewLine
-          + "range(train): x = [0:1:100]" + Environment.NewLine
-          + "range(test): x = [0:0.1:100]" + Environment.NewLine
-          + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
-          + "Note: The problem starts with 1 to avoid log(0), which is minus infinity!";
+        + "Authors: Maarten Keijzer" + Environment.NewLine
+        + "Function: f(x) = sqrt(x)" + Environment.NewLine
+        + "range(train): x = [0:1:100]" + Environment.NewLine
+        + "range(test): x = [0:0.1:100]" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
       }
     }
@@ -43,12 +42,12 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 100; } }
-    protected override int TestPartitionStart { get { return 100; } }
-    protected override int TestPartitionEnd { get { return 1091; } }
+    protected override int TrainingPartitionEnd { get { return 101; } }
+    protected override int TestPartitionStart { get { return 101; } }
+    protected override int TestPartitionEnd { get { return 1102; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      data.Add(ValueGenerator.GenerateSteps(1, 100, 1).ToList());
-      data[0].AddRange(ValueGenerator.GenerateSteps(1, 100, 0.1));
+      data.Add(ValueGenerator.GenerateSteps(0, 100, 1).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(0, 100, 0.1));
 
       double x;
@@ -56,5 +55,5 @@
       for (int i = 0; i < data[0].Count; i++) {
         x = data[0][i];
-        results.Add(Math.Log(x));
+        results.Add(Math.Sqrt(x));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionEleven.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionEleven.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionEleven.cs	(revision 8430)
@@ -27,13 +27,16 @@
   public class KeijzerFunctionEleven : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 11 f(x, y) = x ^ y"; } }
+    public override string Name { get { return "Keijzer 11 f(x, y) = xy + sin((x - 1)(y - 1))"; } }
     public override string Description {
       get {
-        return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
-        + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x, y) = x ^ y" + Environment.NewLine
-        + "range(train): 100 Train cases x,y = rnd(0, 1)" + Environment.NewLine
-        + "range(test): x,y = [0:0.01:1]" + Environment.NewLine
-        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+        return
+          "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
+          + "Authors: Maarten Keijzer" + Environment.NewLine
+          + "Function: f(x, y) = xy + sin((x - 1)(y - 1))" + Environment.NewLine
+          + "range(train): 20 Training cases x,y = rnd(-3, 3)" + Environment.NewLine
+          + "range(test): x,y = [-3:0.01:3]" + Environment.NewLine
+          + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
+          + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the interval [-3, 3] (not ca. 360000 as described) "
+          + ", but 5000 cases are created";
       }
     }
@@ -42,18 +45,12 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 100; } }
-    protected override int TestPartitionStart { get { return 100; } }
-    protected override int TestPartitionEnd { get { return 10301; } }
+    protected override int TrainingPartitionEnd { get { return 20; } }
+    protected override int TestPartitionStart { get { return 2500; } }
+    protected override int TestPartitionEnd { get { return 2600; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-
-      List<double> oneVariableTestData = ValueGenerator.GenerateSteps(0, 1, 0.01).ToList();
-      List<List<double>> testData = new List<List<double>>() { oneVariableTestData, oneVariableTestData };
-
-      var combinations = ValueGenerator.GenerateAllCombinationsOfValuesInLists(testData).ToList<IEnumerable<double>>();
       for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(100, 0, 1).ToList());
-        data[i].AddRange(combinations[i]);
+        data.Add(ValueGenerator.GenerateUniformDistributedValues(5020, -3, 3).ToList());
       }
 
@@ -63,5 +60,5 @@
         x = data[0][i];
         y = data[1][i];
-        results.Add(Math.Pow(x, y));
+        results.Add(x * y + Math.Sin((x - 1) * (y - 1)));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFifteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFifteen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFifteen.cs	(revision 8430)
@@ -27,14 +27,14 @@
   public class KeijzerFunctionFifteen : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 15 f(x, y) = 8 / (2 + x^2 + y^2)"; } }
+    public override string Name { get { return "Keijzer 15 f(x, y) = x³ / 5 + y³ / 2 - y - x"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x, y) = 8 / (2 + x^2 + y^2)" + Environment.NewLine
-        + "range(train): 20 Train cases x,y = rnd(-3, 3)" + Environment.NewLine
+        + "Function: f(x, y) = x³ / 5 + y³ / 2 - y - x" + Environment.NewLine
+        + "range(train): 20 Training cases x,y = rnd(-3, 3)" + Environment.NewLine
         + "range(test): x,y = [-3:0.01:3]" + Environment.NewLine
         + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
-        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the intercal [-3, 3] (not ca. 360000 as described) "
+        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the interval [-3, 3] (not ca. 360000 as described) "
         + ", but 5000 cases are created";
       }
@@ -46,5 +46,5 @@
     protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 2500; } }
-    protected override int TestPartitionEnd { get { return 5000; } }
+    protected override int TestPartitionEnd { get { return 2600; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -59,5 +59,5 @@
         x = data[0][i];
         y = data[1][i];
-        results.Add(8 / (2 + Math.Pow(x, 2) + Math.Pow(y, 2)));
+        results.Add(Math.Pow(x, 3) / 5 + Math.Pow(y, 3) / 2 - y - x);
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFive.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFive.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFive.cs	(revision 8430)
@@ -27,34 +27,36 @@
   public class KeijzerFunctionFive : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 5 f(x) = x ^ 3  * exp(-x) * cos(x) * sin(x) * (sin(x) ^ 2 * cos(x) - 1)"; } }
+    public override string Name { get { return "Keijzer 5 f(x) = (30 * x * z) / ((x - 10)  * y²)"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x) = x ^ 3  * exp(-x) * cos(x) * sin(x) * (sin(x) ^ 2 * cos(x) - 1)" + Environment.NewLine
-        + "range(train): x = [0:0.05:10]" + Environment.NewLine
-        + "range(test): x = [0.05:0.05:10.05]" + Environment.NewLine
-        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine
-        + "Note: {exp, log, sin, cos}, 100000 evals";
+        + "Function: f(x) = (30 * x * z) / ((x - 10)  * y²)" + Environment.NewLine
+        + "range(train): 1000 points x,z = rnd(-1, 1), y = rnd(1, 2)" + Environment.NewLine
+        + "range(test): 10000 points x,z = rnd(-1, 1), y = rnd(1, 2)" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
       }
     }
     protected override string TargetVariable { get { return "F"; } }
-    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
-    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
+    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z", "F" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y", "Z" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 201; } }
-    protected override int TestPartitionStart { get { return 201; } }
-    protected override int TestPartitionEnd { get { return 402; } }
+    protected override int TrainingPartitionEnd { get { return 1000; } }
+    protected override int TestPartitionStart { get { return 1000; } }
+    protected override int TestPartitionEnd { get { return 11000; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      data.Add(ValueGenerator.GenerateSteps(0, 10, 0.05).ToList());
-      data[0].AddRange(ValueGenerator.GenerateSteps(0.05, 10.05, 0.05));
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -1, 1).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 1, 2).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -1, 1).ToList());
 
-      double x;
+      double x, y, z;
       List<double> results = new List<double>();
       for (int i = 0; i < data[0].Count; i++) {
         x = data[0][i];
-        results.Add(Math.Pow(x, 3) * Math.Exp(-x) * Math.Cos(x) * Math.Sin(x) * (Math.Pow(Math.Sin(x), 2) * Math.Cos(x) - 1));
+        y = data[1][i];
+        z = data[2][i];
+        results.Add((30 * x * z) / ((x - 10) * Math.Pow(y, 2)));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFour.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFour.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFour.cs	(revision 8430)
@@ -27,13 +27,14 @@
   public class KeijzerFunctionFour : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 4 f(x) = 0.3 * x *sin(2 * PI * x)"; } }
+    public override string Name { get { return "Keijzer 4 f(x) = x³  * exp(-x) * cos(x) * sin(x) * (sin(x)² * cos(x) - 1)"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x) = 0.3 * x *sin(2 * PI * x)" + Environment.NewLine
-        + "range(train): x = [-1:0.1:1]" + Environment.NewLine
-        + "range(test): x = [-1:0.001:1]" + Environment.NewLine
-        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+        + "Function: f(x) = x³  * exp(-x) * cos(x) * sin(x) * (sin(x)² * cos(x) - 1)" + Environment.NewLine
+        + "range(train): x = [0:0.05:10]" + Environment.NewLine
+        + "range(test): x = [0.05:0.05:10.05]" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine
+        + "Note: {exp, log, sin, cos}, 100000 evals";
       }
     }
@@ -42,12 +43,12 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 21; } }
-    protected override int TestPartitionStart { get { return 21; } }
-    protected override int TestPartitionEnd { get { return 2022; } }
+    protected override int TrainingPartitionEnd { get { return 201; } }
+    protected override int TestPartitionStart { get { return 201; } }
+    protected override int TestPartitionEnd { get { return 402; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      data.Add(ValueGenerator.GenerateSteps(-1, 1, 0.1).ToList());
-      data[0].AddRange(ValueGenerator.GenerateSteps(-1, 1, 0.001));
+      data.Add(ValueGenerator.GenerateSteps(0, 10, 0.05).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(0.05, 10.05, 0.05));
 
       double x;
@@ -55,5 +56,5 @@
       for (int i = 0; i < data[0].Count; i++) {
         x = data[0][i];
-        results.Add(0.3 * x * Math.Sin(2 * Math.PI * x));
+        results.Add(Math.Pow(x, 3) * Math.Exp(-x) * Math.Cos(x) * Math.Sin(x) * (Math.Pow(Math.Sin(x), 2) * Math.Cos(x) - 1));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFourteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFourteen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionFourteen.cs	(revision 8430)
@@ -27,14 +27,14 @@
   public class KeijzerFunctionFourteen : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 14 f(x, y) = 6 * sin(x) * cos(y)"; } }
+    public override string Name { get { return "Keijzer 14 f(x, y) = 8 / (2 + x² + y²)"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x, y) = 6 * sin(x) * cos(y)" + Environment.NewLine
+        + "Function: f(x, y) = 8 / (2 + x² + y²)" + Environment.NewLine
         + "range(train): 20 Train cases x,y = rnd(-3, 3)" + Environment.NewLine
         + "range(test): x,y = [-3:0.01:3]" + Environment.NewLine
         + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
-        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the intercal [-3, 3] (not ca. 360000 as described) "
+        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the interval [-3, 3] (not ca. 360000 as described) "
         + ", but 5000 cases are created";
       }
@@ -46,5 +46,5 @@
     protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 2500; } }
-    protected override int TestPartitionEnd { get { return 5000; } }
+    protected override int TestPartitionEnd { get { return 2600; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -59,5 +59,5 @@
         x = data[0][i];
         y = data[1][i];
-        results.Add(6 * Math.Sin(x) * Math.Cos(y));
+        results.Add(8 / (2 + Math.Pow(x, 2) + Math.Pow(y, 2)));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionNine.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionNine.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionNine.cs	(revision 8430)
@@ -27,10 +27,10 @@
   public class KeijzerFunctionNine : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 9 f(x) = sqrt(x)"; } }
+    public override string Name { get { return "Keijzer 9 f(x) = arcsinh(x)  i.e. ln(x + sqrt(x² + 1))"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x) = sqrt(x)" + Environment.NewLine
+        + "Function: f(x) = arcsinh(x)  i.e. ln(x + sqrt(x² + 1))" + Environment.NewLine
         + "range(train): x = [0:1:100]" + Environment.NewLine
         + "range(test): x = [0:0.1:100]" + Environment.NewLine
@@ -42,7 +42,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 101; } }
-    protected override int TestPartitionStart { get { return 101; } }
-    protected override int TestPartitionEnd { get { return 1102; } }
+    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TestPartitionStart { get { return 100; } }
+    protected override int TestPartitionEnd { get { return 1100; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -55,5 +55,5 @@
       for (int i = 0; i < data[0].Count; i++) {
         x = data[0][i];
-        results.Add(Math.Sqrt(x));
+        results.Add(Math.Log(x + Math.Sqrt(x*x + 1)));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionOne.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionOne.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionOne.cs	(revision 8430)
@@ -0,0 +1,64 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class KeijzerFunctionOne : ArtificialRegressionDataDescriptor {
+
+    public override string Name { get { return "Keijzer 1 f(x) = 0.3 * x *sin(2 * PI * x)"; } }
+    public override string Description {
+      get {
+        return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
+        + "Authors: Maarten Keijzer" + Environment.NewLine
+        + "Function: f(x) = 0.3 * x *sin(2 * PI * x)" + Environment.NewLine
+        + "range(train): x = [-1:0.1:1]" + Environment.NewLine
+        + "range(test): x = [-1:0.001:1]" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+      }
+    }
+    protected override string TargetVariable { get { return "F"; } }
+    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return 21; } }
+    protected override int TestPartitionStart { get { return 21; } }
+    protected override int TestPartitionEnd { get { return 2022; } }
+
+    protected override List<List<double>> GenerateValues() {
+      List<List<double>> data = new List<List<double>>();
+      data.Add(ValueGenerator.GenerateSteps(-1, 1, 0.1).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(-1, 1, 0.001));
+
+      double x;
+      List<double> results = new List<double>();
+      for (int i = 0; i < data[0].Count; i++) {
+        x = data[0][i];
+        results.Add(0.3 * x * Math.Sin(2 * Math.PI * x));
+      }
+      data.Add(results);
+
+      return data;
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSeven.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSeven.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSeven.cs	(revision 8430)
@@ -27,13 +27,14 @@
   public class KeijzerFunctionSeven : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 7 f(x) = Sum(1 / i) From 1 to X"; } }
+    public override string Name { get { return "Keijzer 7 f(x) = ln(x)"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
-        + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x) = (30 * x * y) / ((x - 10)  * y^2)" + Environment.NewLine
-        + "range(train): x = [1:1:50]" + Environment.NewLine
-        + "range(test): x = [1:1:120]" + Environment.NewLine
-        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+          + "Authors: Maarten Keijzer" + Environment.NewLine
+          + "Function: f(x) = ln(x)" + Environment.NewLine
+          + "range(train): x = [1:1:100]" + Environment.NewLine
+          + "range(test): x = [1:0.1:100]" + Environment.NewLine
+          + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
+          + "Note: The problem starts with 1 to avoid log(0), which is minus infinity!";
       }
     }
@@ -42,12 +43,12 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 50; } }
-    protected override int TestPartitionStart { get { return 50; } }
-    protected override int TestPartitionEnd { get { return 170; } }
+    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TestPartitionStart { get { return 100; } }
+    protected override int TestPartitionEnd { get { return 1091; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      data.Add(ValueGenerator.GenerateSteps(1, 50, 1).ToList());
-      data[0].AddRange(ValueGenerator.GenerateSteps(1, 120, 1));
+      data.Add(ValueGenerator.GenerateSteps(1, 100, 1).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(1, 100, 0.1));
 
       double x;
@@ -55,5 +56,5 @@
       for (int i = 0; i < data[0].Count; i++) {
         x = data[0][i];
-        results.Add(Enumerable.Range(1, (int)x).Sum(j => 1.0 / j));
+        results.Add(Math.Log(x));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSix.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSix.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSix.cs	(revision 8430)
@@ -27,36 +27,33 @@
   public class KeijzerFunctionSix : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 6 f(x) = (30 * x * z) / ((x - 10)  * y^2)"; } }
+    public override string Name { get { return "Keijzer 6 f(x) = Sum(1 / i) From 1 to X"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x) = (30 * x * z) / ((x - 10)  * y^2)" + Environment.NewLine
-        + "range(train): 1000 points x,z = rnd(-1, 1), y = rnd(1, 2)" + Environment.NewLine
-        + "range(test): 10000 points x,z = rnd(-1, 1), y = rnd(1, 2)" + Environment.NewLine
+        + "Function: f(x) = Sum(1 / i) From 1 to X" + Environment.NewLine
+        + "range(train): x = [1:1:50]" + Environment.NewLine
+        + "range(test): x = [1:1:120]" + Environment.NewLine
         + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
       }
     }
     protected override string TargetVariable { get { return "F"; } }
-    protected override string[] InputVariables { get { return new string[] { "X", "Y", "Z", "F" }; } }
-    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y", "Z" }; } }
+    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 1000; } }
-    protected override int TestPartitionStart { get { return 1000; } }
-    protected override int TestPartitionEnd { get { return 11000; } }
+    protected override int TrainingPartitionEnd { get { return 50; } }
+    protected override int TestPartitionStart { get { return 50; } }
+    protected override int TestPartitionEnd { get { return 170; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -1, 1).ToList());
-      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 1, 2).ToList());
-      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -1, 1).ToList());
+      data.Add(ValueGenerator.GenerateSteps(1, 50, 1).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(1, 120, 1));
 
-      double x, y, z;
+      double x;
       List<double> results = new List<double>();
       for (int i = 0; i < data[0].Count; i++) {
         x = data[0][i];
-        y = data[1][i];
-        z = data[2][i];
-        results.Add((30 * x * z) / ((x - 10) * Math.Pow(y, 2)));
+        results.Add(Enumerable.Range(1, (int)x).Sum(j => 1.0 / j));
       }
       data.Add(results);
Index: anches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSixteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionSixteen.cs	(revision 8429)
+++ 	(revision )
@@ -1,68 +1,0 @@
-﻿#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace HeuristicLab.Problems.Instances.DataAnalysis {
-  public class KeijzerFunctionSixteen : ArtificialRegressionDataDescriptor {
-
-    public override string Name { get { return "Keijzer 16 f(x, y) = x^3 / 5 + y^3 / 2 - y - x"; } }
-    public override string Description {
-      get {
-        return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
-        + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x, y) = x^3 / 5 + y^3 / 2 - y - x" + Environment.NewLine
-        + "range(train): 20 Training cases x,y = rnd(-3, 3)" + Environment.NewLine
-        + "range(test): x,y = [-3:0.01:3]" + Environment.NewLine
-        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
-        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the intercal [-3, 3] (not ca. 360000 as described) "
-        + ", but 5000 cases are created";
-      }
-    }
-    protected override string TargetVariable { get { return "F"; } }
-    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
-    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
-    protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 20; } }
-    protected override int TestPartitionStart { get { return 2500; } }
-    protected override int TestPartitionEnd { get { return 5000; } }
-
-    protected override List<List<double>> GenerateValues() {
-      List<List<double>> data = new List<List<double>>();
-      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(5000, -3, 3).ToList());
-      }
-
-      double x, y;
-      List<double> results = new List<double>();
-      for (int i = 0; i < data[0].Count; i++) {
-        x = data[0][i];
-        y = data[1][i];
-        results.Add(Math.Pow(x, 3) / 5 + Math.Pow(y, 3) / 2 - y - x);
-      }
-      data.Add(results);
-
-      return data;
-    }
-  }
-}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTen.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTen.cs	(revision 8430)
@@ -0,0 +1,72 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class KeijzerFunctionTen : ArtificialRegressionDataDescriptor {
+
+    public override string Name { get { return "Keijzer 10 f(x, y) = x ^ y"; } }
+    public override string Description {
+      get {
+        return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
+        + "Authors: Maarten Keijzer" + Environment.NewLine
+        + "Function: f(x, y) = x ^ y" + Environment.NewLine
+        + "range(train): 100 Train cases x,y = rnd(0, 1)" + Environment.NewLine
+        + "range(test): x,y = [0:0.01:1]" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+      }
+    }
+    protected override string TargetVariable { get { return "F"; } }
+    protected override string[] InputVariables { get { return new string[] { "X", "Y", "F" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TestPartitionStart { get { return 100; } }
+    protected override int TestPartitionEnd { get { return 10100; } }
+
+    protected override List<List<double>> GenerateValues() {
+      List<List<double>> data = new List<List<double>>();
+
+      List<double> oneVariableTestData = ValueGenerator.GenerateSteps(0, 1, 0.01).ToList();
+      List<List<double>> testData = new List<List<double>>() { oneVariableTestData, oneVariableTestData };
+
+      var combinations = ValueGenerator.GenerateAllCombinationsOfValuesInLists(testData).ToList<IEnumerable<double>>();
+      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
+        data.Add(ValueGenerator.GenerateUniformDistributedValues(100, 0, 1).ToList());
+        data[i].AddRange(combinations[i]);
+      }
+
+      double x, y;
+      List<double> results = new List<double>();
+      for (int i = 0; i < data[0].Count; i++) {
+        x = data[0][i];
+        y = data[1][i];
+        results.Add(Math.Pow(x, y));
+      }
+      data.Add(results);
+
+      return data;
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionThirteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionThirteen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionThirteen.cs	(revision 8430)
@@ -27,14 +27,14 @@
   public class KeijzerFunctionThirteen : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 13 f(x, y) = x^4 - x^3 + y^2 / 2 - y"; } }
+    public override string Name { get { return "Keijzer 13 f(x, y) = 6 * sin(x) * cos(y)"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x, y) = x^4 - x^3 + y^2 / 2 - y" + Environment.NewLine
-        + "range(train): 20 Training cases x,y = rnd(-3, 3)" + Environment.NewLine
+        + "Function: f(x, y) = 6 * sin(x) * cos(y)" + Environment.NewLine
+        + "range(train): 20 Train cases x,y = rnd(-3, 3)" + Environment.NewLine
         + "range(test): x,y = [-3:0.01:3]" + Environment.NewLine
         + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
-        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the intercal [-3, 3] (not ca. 360000 as described) "
+        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the interval [-3, 3] (not ca. 360000 as described) "
         + ", but 5000 cases are created";
       }
@@ -46,5 +46,5 @@
     protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 2500; } }
-    protected override int TestPartitionEnd { get { return 5000; } }
+    protected override int TestPartitionEnd { get { return 2600; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -59,5 +59,5 @@
         x = data[0][i];
         y = data[1][i];
-        results.Add(Math.Pow(x, 4) - Math.Pow(x, 3) + Math.Pow(y, 2) / 2 - y);
+        results.Add(6 * Math.Sin(x) * Math.Cos(y));
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionThree.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionThree.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionThree.cs	(revision 8430)
@@ -0,0 +1,64 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class KeijzerFunctionThree : ArtificialRegressionDataDescriptor {
+
+    public override string Name { get { return "Keijzer 3 f(x) = 0.3 * x *sin(2 * PI * x)"; } }
+    public override string Description {
+      get {
+        return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
+        + "Authors: Maarten Keijzer" + Environment.NewLine
+        + "Function: f(x) = 0.3 * x *sin(2 * PI * x)" + Environment.NewLine
+        + "range(train): x = [-3:0.1:3]" + Environment.NewLine
+        + "range(test): x = [-3:0.001:3]" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+      }
+    }
+    protected override string TargetVariable { get { return "F"; } }
+    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return 61; } }
+    protected override int TestPartitionStart { get { return 61; } }
+    protected override int TestPartitionEnd { get { return 6062; } }
+
+    protected override List<List<double>> GenerateValues() {
+      List<List<double>> data = new List<List<double>>();
+      data.Add(ValueGenerator.GenerateSteps(-3, 3, 0.1).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(-3, 3, 0.001));
+
+      double x;
+      List<double> results = new List<double>();
+      for (int i = 0; i < data[0].Count; i++) {
+        x = data[0][i];
+        results.Add(0.3 * x * Math.Sin(2 * Math.PI * x));
+      }
+      data.Add(results);
+
+      return data;
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTwelve.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTwelve.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTwelve.cs	(revision 8430)
@@ -27,14 +27,14 @@
   public class KeijzerFunctionTwelve : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Keijzer 12 f(x, y) = xy + sin((x - 1)(y - 1))"; } }
+    public override string Name { get { return "Keijzer 12 f(x, y) = x^4 - x³ + y² / 2 - y"; } }
     public override string Description {
       get {
         return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
         + "Authors: Maarten Keijzer" + Environment.NewLine
-        + "Function: f(x, y) = xy + sin((x - 1)(y - 1))" + Environment.NewLine
+        + "Function: f(x, y) = x^4 - x³ + y² / 2 - y" + Environment.NewLine
         + "range(train): 20 Training cases x,y = rnd(-3, 3)" + Environment.NewLine
         + "range(test): x,y = [-3:0.01:3]" + Environment.NewLine
         + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)" + Environment.NewLine + Environment.NewLine
-        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the intercal [-3, 3] (not ca. 360000 as described) "
+        + "Note: Test partition has been adjusted to only 100 random uniformly distributed test cases in the interval [-3, 3] (not ca. 360000 as described) "
         + ", but 5000 cases are created";
       }
@@ -46,5 +46,5 @@
     protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 2500; } }
-    protected override int TestPartitionEnd { get { return 5000; } }
+    protected override int TestPartitionEnd { get { return 2600; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -59,5 +59,5 @@
         x = data[0][i];
         y = data[1][i];
-        results.Add(x * y + Math.Sin((x - 1) * (y - 1)));
+        results.Add(Math.Pow(x, 4) - Math.Pow(x, 3) + Math.Pow(y, 2) / 2 - y);
       }
       data.Add(results);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTwo.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTwo.cs	(revision 8430)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerFunctionTwo.cs	(revision 8430)
@@ -0,0 +1,64 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2012 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace HeuristicLab.Problems.Instances.DataAnalysis {
+  public class KeijzerFunctionTwo : ArtificialRegressionDataDescriptor {
+
+    public override string Name { get { return "Keijzer 2 f(x) = 0.3 * x *sin(2 * PI * x)"; } }
+    public override string Description {
+      get {
+        return "Paper: Improving Symbolic Regression with Interval Arithmetic and Linear Scaling" + Environment.NewLine
+        + "Authors: Maarten Keijzer" + Environment.NewLine
+        + "Function: f(x) = 0.3 * x *sin(2 * PI * x)" + Environment.NewLine
+        + "range(train): x = [-2:0.1:2]" + Environment.NewLine
+        + "range(test): x = [-2:0.001:2]" + Environment.NewLine
+        + "Function Set: x + y, x * y, 1/x, -x, sqrt(x)";
+      }
+    }
+    protected override string TargetVariable { get { return "F"; } }
+    protected override string[] InputVariables { get { return new string[] { "X", "F" }; } }
+    protected override string[] AllowedInputVariables { get { return new string[] { "X" }; } }
+    protected override int TrainingPartitionStart { get { return 0; } }
+    protected override int TrainingPartitionEnd { get { return 41; } }
+    protected override int TestPartitionStart { get { return 41; } }
+    protected override int TestPartitionEnd { get { return 4042; } }
+
+    protected override List<List<double>> GenerateValues() {
+      List<List<double>> data = new List<List<double>>();
+      data.Add(ValueGenerator.GenerateSteps(-2, 2, 0.1).ToList());
+      data[0].AddRange(ValueGenerator.GenerateSteps(-2, 2, 0.001));
+
+      double x;
+      List<double> results = new List<double>();
+      for (int i = 0; i < data[0].Count; i++) {
+        x = data[0][i];
+        results.Add(0.3 * x * Math.Sin(2 * Math.PI * x));
+      }
+      data.Add(results);
+
+      return data;
+    }
+  }
+}
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Keijzer/KeijzerInstanceProvider.cs	(revision 8430)
@@ -32,12 +32,15 @@
     }
     public override Uri WebLink {
-      get { return new Uri("http://groups.csail.mit.edu/EVO-DesignOpt/GPBenchmarks/"); }
+      get { return new Uri("http://www.gpbenchmarks.org/wiki/index.php?title=Problem_Classification#Keijzer"); }
     }
     public override string ReferencePublication {
-      get { return ""; }
+      get { return "McDermott et al., 2012 \"Genetic Programming Needs Better Benchmarks\", in Proc. of GECCO 2012."; }
     }
 
     public override IEnumerable<IDataDescriptor> GetDataDescriptors() {
       List<IDataDescriptor> descriptorList = new List<IDataDescriptor>();
+      descriptorList.Add(new KeijzerFunctionOne());
+      descriptorList.Add(new KeijzerFunctionTwo());
+      descriptorList.Add(new KeijzerFunctionThree());
       descriptorList.Add(new KeijzerFunctionFour());
       descriptorList.Add(new KeijzerFunctionFive());
@@ -46,4 +49,5 @@
       descriptorList.Add(new KeijzerFunctionEight());
       descriptorList.Add(new KeijzerFunctionNine());
+      descriptorList.Add(new KeijzerFunctionTen());
       descriptorList.Add(new KeijzerFunctionEleven());
       descriptorList.Add(new KeijzerFunctionTwelve());
@@ -51,5 +55,4 @@
       descriptorList.Add(new KeijzerFunctionFourteen());
       descriptorList.Add(new KeijzerFunctionFifteen());
-      descriptorList.Add(new KeijzerFunctionSixteen());
       return descriptorList;
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionEight.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionEight.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionEight.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 6.87 + (11 * sqrt(7.23 * X0 * X3 * X4))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -48,13 +47,15 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList());
-      }
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
 
       double x0, x3, x4;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionEleven.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionEleven.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionEleven.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 6.87 + (11 * cos(7.23 * X0 * X0 * X0))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFive.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFive.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFive.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 3.0 + (2.13 * log(X4))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -48,13 +47,15 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList());
-      }
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
 
       double x4;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFiveteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFiveteen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFiveteen.cs	(revision 8430)
@@ -27,14 +27,13 @@
   public class KornsFunctionFiveteen : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Korns 15 y = 12.0 - (6.0 * ((tan(X0) / exp(X1)) * (log(X2) - tan(X3))))"; } }
+    public override string Name { get { return "Korns 15 y = 12.0 - (6.0 * ((tan(X0) / exp(X1)) * (ln(X2) - tan(X3))))"; } }
     public override string Description {
       get {
         return "Paper: Accuracy in Symbolic Regression" + Environment.NewLine
         + "Authors: Michael F. Korns" + Environment.NewLine
-        + "Function: y = 12.0 - (6.0 * ((tan(X0) / exp(X1)) * (log(X2) - tan(X3))))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Function: y = 12.0 - (6.0 * ((tan(X0) / exp(X1)) * (ln(X2) - tan(X3))))" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -48,13 +47,15 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList());
-      }
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
 
       double x0, x1, x2, x3;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFour.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFour.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFour.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = -2.3 + (0.13 * sin(X2))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,8 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
+
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFourteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFourteen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionFourteen.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 22.0 + (4.2 * ((cos(X0) - tan(X1)) * (tanh(X2) / sin(X3))))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionNine.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionNine.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionNine.cs	(revision 8430)
@@ -27,14 +27,13 @@
   public class KornsFunctionNine : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Korns 9 y = ((sqrt(X0) / log(X1)) * (exp(X2) / square(X3)))"; } }
+    public override string Name { get { return "Korns 9 y = ((sqrt(X0) / log(X1)) * (exp(X2) / X3²)"; } }
     public override string Description {
       get {
         return "Paper: Accuracy in Symbolic Regression" + Environment.NewLine
         + "Authors: Michael F. Korns" + Environment.NewLine
-        + "Function: y = ((sqrt(X0) / log(X1)) * (exp(X2) / square(X3)))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Function: y = (sqrt(X0) / log(X1)) * (exp(X2) / X3²)" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -48,13 +47,15 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList());
-      }
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList()); 
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList()); 
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList()); 
 
       double x0, x1, x2, x3;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionOne.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionOne.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionOne.cs	(revision 8430)
@@ -33,8 +33,8 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 1.57 + (24.3 * X3)" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
         + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +47,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionSeven.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionSeven.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionSeven.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 213.80940889 - (213.80940889 * exp(-0.54723748542 * X0))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionSix.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionSix.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionSix.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 1.3 + (0.13 * sqrt(X0))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -48,13 +47,15 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
-      for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList());
-      }
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, 0, 50).ToList()); // note: range is only [0,50] to prevent NaN values (deviates from gp benchmark paper)
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList()); 
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(TestPartitionEnd, -50, 50).ToList()); 
 
       double x0;
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTen.cs	(revision 8430)
@@ -27,14 +27,13 @@
   public class KornsFunctionTen : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Korns 10 y = 0.81 + (24.3 * (((2.0 * X1) + (3.0 * square(X2))) / ((4.0 * cube(X3)) + (5.0 * quart(X4)))))"; } }
+    public override string Name { get { return "Korns 10 y = 0.81 + (24.3 * (((2.0 * X1) + (3.0 * X2²)) / ((4.0 * X3³) + (5.0 * X4^4))))"; } }
     public override string Description {
       get {
         return "Paper: Accuracy in Symbolic Regression" + Environment.NewLine
         + "Authors: Michael F. Korns" + Environment.NewLine
-        + "Function: y = 0.81 + (24.3 * (((2.0 * X1) + (3.0 * square(X2))) / ((4.0 * cube(X3)) + (5.0 * quart(X4)))))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Function: y =  0.81 + (24.3 * (((2.0 * X1) + (3.0 * X2²)) / ((4.0 * X3³) + (5.0 * X4^4))))" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionThirteen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionThirteen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionThirteen.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 32.0 - (3.0 * ((tan(X0) / tan(X1)) * (tan(X2) / tan(X3))))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionThree.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionThree.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionThree.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 1.57 + (24.3 * X3)" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTwelve.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTwelve.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTwelve.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 2.0 - (2.1 * (cos(9.8 * X0) * sin(1.3 * X4)))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTwo.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTwo.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsFunctionTwo.cs	(revision 8430)
@@ -33,8 +33,7 @@
         + "Authors: Michael F. Korns" + Environment.NewLine
         + "Function: y = 0.23 + (14.2 * ((X3 + X1) / (3.0 * X4)))" + Environment.NewLine
-        + "Real Numbers: 3.45, -.982, 100.389, and all other real constants" + Environment.NewLine
-        + "Row Features: x1, x2, x9, and all other features" + Environment.NewLine
-        + "Binary Operators: +, -, *, /" + Environment.NewLine
-        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, log, exp" + Environment.NewLine
+        + "Binary Operators: +, -, *, % (protected division)" + Environment.NewLine
+        + "Unary Operators: sqrt, square, cube, cos, sin, tan, tanh, ln(|x|) (protected log), exp" + Environment.NewLine
+        + "Constants: random finit 64-bit IEEE double" + Environment.NewLine
         + "\"Our testing regimen uses only statistical best practices out-of-sample testing techniques. "
         + "We test each of the test cases on matrices of 10000 rows by 1 to 5 columns with no noise. "
@@ -47,7 +46,7 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X0", "X1", "X2", "X3", "X4" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 5000; } }
-    protected override int TestPartitionStart { get { return 5000; } }
-    protected override int TestPartitionEnd { get { return 10000; } }
+    protected override int TrainingPartitionEnd { get { return 10000; } }
+    protected override int TestPartitionStart { get { return 10000; } }
+    protected override int TestPartitionEnd { get { return 20000; } }
 
     protected override List<List<double>> GenerateValues() {
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Korns/KornsInstanceProvider.cs	(revision 8430)
@@ -32,8 +32,8 @@
     }
     public override Uri WebLink {
-      get { return new Uri("http://groups.csail.mit.edu/EVO-DesignOpt/GPBenchmarks/"); }
+      get { return new Uri("http://www.gpbenchmarks.org/wiki/index.php?title=Problem_Classification#Korns"); }
     }
     public override string ReferencePublication {
-      get { return ""; }
+      get { return "McDermott et al., 2012 \"Genetic Programming Needs Better Benchmarks\", in Proc. of GECCO 2012."; }
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionEight.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionEight.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionEight.cs	(revision 8430)
@@ -33,7 +33,7 @@
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
         + "Function: F8 = Sqrt(x)" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [0, 4]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Fitcases: 20 random points in [0, 4]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionEleven.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionEleven.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionEleven.cs	(revision 8430)
@@ -33,7 +33,7 @@
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
         + "Function: F11 = x^y" + Environment.NewLine
-        + "Fitcases: 100 random points ⊆ [0, 1]x[0, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Fitcases: 20 random points in [0, 1]x[0, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
@@ -42,5 +42,5 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 500; } }
     protected override int TestPartitionEnd { get { return 1000; } }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionFive.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionFive.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionFive.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionFive : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F5 = sin(x^2)cos(x) - 1"; } }
+    public override string Name { get { return "Nguyen F5 = sin(x²)cos(x) - 1"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F5 = sin(x^2)cos(x) - 1" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [-1, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F5 = sin(x²)cos(x) - 1" + Environment.NewLine
+        + "Fitcases: 20 random points in [-1, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionFour.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionFour.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionFour.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionFour : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F4 = x^6 + x^5 + x^4 + x^3 + x^2 + x"; } }
+    public override string Name { get { return "Nguyen F4 = x^6 + x^5 + x^4 + x³ + x² + x"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F4 = x^6 + x^5 + x^4 + x^3 + x^2 + x" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [-1, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F4 = x^6 + x^5 + x^4 + x³ + x² + x" + Environment.NewLine
+        + "Fitcases: 20 random points in [-1, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionNine.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionNine.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionNine.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionNine : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F9 = sin(x) + sin(y^2)"; } }
+    public override string Name { get { return "Nguyen F9 = sin(x) + sin(y²)"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F9 = sin(x) + sin(y^2)" + Environment.NewLine
-        + "Fitcases: 100 random points ⊆ [0, 1]x[0, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F9 = sin(x) + sin(y²)" + Environment.NewLine
+        + "Fitcases: 20 random points in [0, 1]x[0, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
@@ -42,5 +42,5 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 500; } }
     protected override int TestPartitionEnd { get { return 1000; } }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionOne.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionOne.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionOne.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionOne : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F1 = x^3 + x^2 + x"; } }
+    public override string Name { get { return "Nguyen F1 = x³ + x² + x"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F1 = x^3 + x^2 + x" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [-1, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F1 = x³ + x² + x" + Environment.NewLine
+        + "Fitcases: 20 random points in [-1, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionSeven.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionSeven.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionSeven.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionSeven : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F7 = log(x + 1) + log(x^2 + 1)"; } }
+    public override string Name { get { return "Nguyen F7 = log(x + 1) + log(x² + 1)"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F7 = log(x + 1) + log(x^2 + 1)" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [0, 2]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F7 = ln(x + 1) + ln(x² + 1)" + Environment.NewLine
+        + "Fitcases: 20 random points in [0, 2]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionSix.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionSix.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionSix.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionSix : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F6 = sin(x) + sin(x + x^2)"; } }
+    public override string Name { get { return "Nguyen F6 = sin(x) + sin(x + x²)"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F6 = sin(x) + sin(x + x^2)" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [-1, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F6 = sin(x) + sin(x + x²)" + Environment.NewLine
+        + "Fitcases: 20 random points in [-1, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTen.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTen.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTen.cs	(revision 8430)
@@ -33,7 +33,7 @@
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
         + "Function: F10 = 2sin(x)cos(y)" + Environment.NewLine
-        + "Fitcases: 100 random points ⊆ [0, 1]x[0, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Fitcases: 20 random points in [0, 1]x[0, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
@@ -42,5 +42,5 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 500; } }
     protected override int TestPartitionEnd { get { return 1000; } }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionThree.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionThree.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionThree.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionThree : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F3 = x^5 + x^4 + x^3 + x^2 + x"; } }
+    public override string Name { get { return "Nguyen F3 = x^5 + x^4 + x³ + x² + x"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F3 = x^5 + x^4 + x^3 + x^2 + x" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [-1, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F3 = x^5 + x^4 + x³ + x² + x" + Environment.NewLine
+        + "Fitcases: 20 random points in [-1, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTwelve.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTwelve.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTwelve.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionTwelve : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F12 = x^4 - x^3 + y^2/2 - y"; } }
+    public override string Name { get { return "Nguyen F12 = x^4 - x³ + y²/2 - y"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F12 = x^4 - x^3 + y^2/2 - y" + Environment.NewLine
-        + "Fitcases: 100 random points ⊆ [0, 1]x[0, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F12 = x^4 - x³ + y²/2 - y" + Environment.NewLine
+        + "Fitcases: 20 random points in [0, 1]x[0, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
@@ -42,5 +42,5 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 100; } }
+    protected override int TrainingPartitionEnd { get { return 20; } }
     protected override int TestPartitionStart { get { return 500; } }
     protected override int TestPartitionEnd { get { return 1000; } }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTwo.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTwo.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenFunctionTwo.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class NguyenFunctionTwo : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Nguyen F2 = x^4 + x^3 + x^2 + x"; } }
+    public override string Name { get { return "Nguyen F2 = x^4 + x³ + x² + x"; } }
     public override string Description {
       get {
         return "Paper: Semantically-based Crossover in Genetic Programming: Application to Real-valued Symbolic Regression" + Environment.NewLine
         + "Authors: Nguyen Quang Uy · Nguyen Xuan Hoai · Michael O’Neill · R.I. McKay · Edgar Galvan-Lopez" + Environment.NewLine
-        + "Function: F2 = x^4 + x^3 + x^2 + x" + Environment.NewLine
-        + "Fitcases: 20 random points ⊆ [-1, 1]" + Environment.NewLine
-        + "Non-terminals: +, -, *, /, sin, cos, exp, log (protected version)" + Environment.NewLine
-        + "Terminals: X, 1 for single variable problems, and X, Y for bivariable problems";
+        + "Function: F2 = x^4 + x³ + x² + x" + Environment.NewLine
+        + "Fitcases: 20 random points in [-1, 1]" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Nguyen/NguyenInstanceProvider.cs	(revision 8430)
@@ -32,8 +32,8 @@
     }
     public override Uri WebLink {
-      get { return new Uri("http://groups.csail.mit.edu/EVO-DesignOpt/GPBenchmarks/"); }
+      get { return new Uri("http://www.gpbenchmarks.org/wiki/index.php?title=Problem_Classification#Nguyen_et_al"); }
     }
     public override string ReferencePublication {
-      get { return ""; }
+      get { return "McDermott et al., 2012 \"Genetic Programming Needs Better Benchmarks\", in Proc. of GECCO 2012."; }
     }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/RegressionInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/RegressionInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/RegressionInstanceProvider.cs	(revision 8430)
@@ -20,73 +20,8 @@
 #endregion
 
-using System;
-using System.Collections;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
 using HeuristicLab.Problems.DataAnalysis;
 
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
-  public abstract class RegressionInstanceProvider : IProblemInstanceProvider<IRegressionProblemData> {
-
-    public IRegressionProblemData LoadData(string path) {
-      TableFileParser csvFileParser = new TableFileParser();
-      csvFileParser.Parse(path);
-
-      Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
-      string targetVar = csvFileParser.VariableNames.Last();
-
-      IEnumerable<string> allowedInputVars = csvFileParser.VariableNames.Where(x => !x.Equals(targetVar));
-
-      IRegressionProblemData regData = new RegressionProblemData(dataset, allowedInputVars, targetVar);
-
-      int trainingPartEnd = csvFileParser.Rows * 2 / 3;
-      regData.TrainingPartition.Start = 0;
-      regData.TrainingPartition.End = trainingPartEnd;
-      regData.TestPartition.Start = trainingPartEnd;
-      regData.TestPartition.End = csvFileParser.Rows;
-
-      int pos = path.LastIndexOf('\\');
-      if (pos < 0)
-        regData.Name = path;
-      else {
-        pos++;
-        regData.Name = path.Substring(pos, path.Length - pos);
-      }
-      return regData;
-    }
-
-    public void SaveData(IRegressionProblemData instance, string path) {
-      StringBuilder strBuilder = new StringBuilder();
-
-      foreach (var variable in instance.InputVariables) {
-        strBuilder.Append(variable + ";");
-      }
-      strBuilder.Remove(strBuilder.Length - 1, 1);
-      strBuilder.AppendLine();
-
-      Dataset dataset = instance.Dataset;
-
-      for (int i = 0; i < dataset.Rows; i++) {
-        for (int j = 0; j < dataset.Columns; j++) {
-          strBuilder.Append(dataset.GetValue(i, j) + ";");
-        }
-        strBuilder.Remove(strBuilder.Length - 1, 1);
-        strBuilder.AppendLine();
-      }
-
-      using (StreamWriter writer = new StreamWriter(path)) {
-        writer.Write(strBuilder);
-      }
-    }
-
-    public abstract IEnumerable<IDataDescriptor> GetDataDescriptors();
-    public abstract IRegressionProblemData LoadData(IDataDescriptor descriptor);
-
-    public abstract string Name { get; }
-    public abstract string Description { get; }
-    public abstract Uri WebLink { get; }
-    public abstract string ReferencePublication { get; }
+  public abstract class RegressionInstanceProvider : ProblemInstanceProvider<IRegressionProblemData> {
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/ResourceRegressionInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/ResourceRegressionInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/ResourceRegressionInstanceProvider.cs	(revision 8430)
@@ -70,6 +70,6 @@
 
         Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
-        string targetVar = csvFileParser.VariableNames.Last();
-        IEnumerable<string> allowedInputVars = csvFileParser.VariableNames.Where(x => !x.Equals(targetVar));
+        string targetVar = csvFileParser.VariableNames.Where(x => dataset.DoubleVariables.Contains(x)).Last();
+        IEnumerable<string> allowedInputVars = dataset.DoubleVariables.Where(x => !x.Equals(targetVar));
 
         IRegressionProblemData regData = new RegressionProblemData(dataset, allowedInputVars, targetVar);
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/ValueGenerator.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/ValueGenerator.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/ValueGenerator.cs	(revision 8430)
@@ -29,17 +29,46 @@
     private static FastRandom rand = new FastRandom();
 
+    /// <summary>
+    /// Generates a sequence of evenly spaced points between start and end (inclusive!).
+    /// </summary>
+    /// <param name="start">The smallest and first value of the sequence.</param>
+    /// <param name="end">The largest and last value of the sequence.</param>
+    /// <param name="stepWidth">The step size between subsequent values.</param>
+    /// <returns>An sequence of values from start to end (inclusive)</returns>
     public static IEnumerable<double> GenerateSteps(double start, double end, double stepWidth) {
-      int steps = (int)Math.Round(((end - start) / stepWidth) + 1);
-      for (int i = 0; i < steps; i++)
-        yield return start + i * stepWidth;
+      if (start > end) throw new ArgumentException("start must be less than or equal end.");
+      if (stepWidth <= 0) throw new ArgumentException("stepwith must be larger than zero.", "stepWidth");
+      double x = start;
+      while (x <= end) {
+        yield return x;
+        x += stepWidth;
+      }
     }
 
-    public static IEnumerable<double> GenerateUniformDistributedValues(int amount, double start, double end) {
-      for (int i = 0; i < amount; i++)
-        yield return rand.NextDouble() * (end - start) + start;
+    /// <summary>
+    /// Generates uniformly distributed values between start and end (inclusive!) 
+    /// </summary>
+    /// <param name="n">Number of values to generate.</param>
+    /// <param name="start">The lower value (inclusive)</param>
+    /// <param name="end">The upper value (inclusive)</param>
+    /// <returns>An enumerable including n values in [start, end]</returns>
+    public static IEnumerable<double> GenerateUniformDistributedValues(int n, double start, double end) {
+      for (int i = 0; i < n; i++) {
+        // we need to return a random value including end.
+        // so we cannot use rand.NextDouble() as it returns a value strictly smaller than 1.
+        double r = rand.NextUInt() / (double)uint.MaxValue;    // r \in [0,1]
+        yield return r * (end - start) + start;
+      }
     }
 
-    public static IEnumerable<double> GenerateNormalDistributedValues(int amount, double mu, double sigma) {
-      for (int i = 0; i < amount; i++)
+    /// <summary>
+    /// Generates normally distributed values sampling from N(mu, sigma) 
+    /// </summary>
+    /// <param name="n">Number of values to generate.</param>
+    /// <param name="mu">The mu parameter of the normal distribution</param>
+    /// <param name="sigma">The sigma parameter of the normal distribution</param>
+    /// <returns>An enumerable including n values ~ N(mu, sigma)</returns>
+    public static IEnumerable<double> GenerateNormalDistributedValues(int n, double mu, double sigma) {
+      for (int i = 0; i < n; i++)
         yield return NormalDistributedRandom.NextDouble(rand, mu, sigma);
     }
@@ -82,65 +111,4 @@
       }
     }
-
-    //recursive approach
-    /*public static IEnumerable<IEnumerable<double>> GenerateAllCombinationsOfValuesInLists(List<List<double>> lists) {
-      int cur = 0;
-      List<double> curCombination = new List<double>();
-      List<List<double>> allCombinations = new List<List<double>>();
-      for (int i = 0; i < lists.Count; i++) {
-        allCombinations.Add(new List<double>());
-      }
-      if (lists.Count() > cur) {
-        foreach (var item in lists[cur]) {
-          curCombination.Clear();
-          curCombination.Add(item);
-          GetCombination(lists, cur + 1, curCombination, allCombinations);
-        }
-      }
-      return allCombinations;
-    }
-
-    private static void GetCombination(List<List<double>> lists, int cur, List<double> curCombinations, List<List<double>> allCombinations) {
-      if (lists.Count > cur) {
-        foreach (var item in lists[cur]) {
-          if (curCombinations.Count > cur) {
-            curCombinations.RemoveAt(cur);
-          }
-          curCombinations.Add(item);
-          GetCombination(lists, cur + 1, curCombinations, allCombinations);
-        }
-      } else {
-        for (int i = 0; i < curCombinations.Count; i++) {
-          allCombinations[i].Add(curCombinations[i]);
-        }
-      }
-    }         */
-
-    //original
-    /*public static IEnumerable<IEnumerable<double>> GenerateAllCombinationsOfValuesInLists(List<List<double>> sets) {
-
-      var combinations = new List<List<double>>();
-
-      foreach (var value in sets[0])
-        combinations.Add(new List<double> { value });
-
-      foreach (var set in sets.Skip(1))
-        combinations = AddListToCombinations(combinations, set);
-
-      IEnumerable<IEnumerable<double>> res = (from i in Enumerable.Range(0, sets.Count)
-                                              select (from list in combinations
-                                                      select list.ElementAt(i)));
-
-      return res;
-    }
-
-    private static List<List<double>> AddListToCombinations
-         (List<List<double>> combinations, List<double> set) {
-      var newCombinations = from value in set
-                            from combination in combinations
-                            select new List<double>(combination) { value };
-
-      return newCombinations.ToList();
-    }    */
   }
 }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Various/SpatialCoevolution.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Various/SpatialCoevolution.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Various/SpatialCoevolution.cs	(revision 8430)
@@ -27,16 +27,17 @@
   public class SpatialCoevolution : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Spatial co-evolution F(x,y) = 1/(1+power(x,-4)) + 1/(1+pow(y,-4))"; } }
+    public override string Name { get { return "Spatial co-evolution F(x,y) = 1/(1 + x^(-4)) + 1/(1 + y^(-4))"; } }
     public override string Description {
       get {
         return "Paper: Evolutionary consequences of coevolving targets" + Environment.NewLine
         + "Authors: Ludo Pagie and Paulien Hogeweg" + Environment.NewLine
-        + "Function: F(x,y) = 1/(1+power(x,-4)) + 1/(1+pow(y,-4))" + Environment.NewLine
-        + "Terminal set: x, y" + Environment.NewLine
+        + "Function: F(x,y) = 1/(1 + x^(-4)) + 1/(1 + y^(-4))" + Environment.NewLine
+        + "Non-terminals: +, -, *, % (protected division), sin, cos, exp, ln(|x|) (protected log)" + Environment.NewLine
+        + "Terminals: only variables (no random constants)" + Environment.NewLine
         + "The fitness of a solution is defined as the mean of the absolute differences between "
         + "the target function and the solution over all problems on the basis of which it is evaluated. "
         + "A solution is considered completely ’correct’ if, for all 676 problems in the ’complete’ "
         + "problem set used in the static evaluation scheme, the absolute difference between "
-        + "solution and target function is less than 0:01 (this is a so-called hit).";
+        + "solution and target function is less than 0.01 (this is a so-called hit).";
       }
     }
@@ -45,18 +46,18 @@
     protected override string[] AllowedInputVariables { get { return new string[] { "X", "Y" }; } }
     protected override int TrainingPartitionStart { get { return 0; } }
-    protected override int TrainingPartitionEnd { get { return 250; } }
-    protected override int TestPartitionStart { get { return 250; } }
-    protected override int TestPartitionEnd { get { return 500; } }
+    protected override int TrainingPartitionEnd { get { return 676; } }
+    protected override int TestPartitionStart { get { return 676; } }
+    protected override int TestPartitionEnd { get { return 1676; } }
 
     protected override List<List<double>> GenerateValues() {
       List<List<double>> data = new List<List<double>>();
 
-      List<double> oneVariableTestData = ValueGenerator.GenerateSteps(-5, 5, 0.4).ToList();
-      List<List<double>> testData = new List<List<double>>() { oneVariableTestData, oneVariableTestData };
-      var combinations = ValueGenerator.GenerateAllCombinationsOfValuesInLists(testData).ToList<IEnumerable<double>>();
+      List<double> evenlySpacedSequence = ValueGenerator.GenerateSteps(-5, 5, 0.4).ToList();
+      List<List<double>> trainingData = new List<List<double>>() { evenlySpacedSequence, evenlySpacedSequence };
+      var combinations = ValueGenerator.GenerateAllCombinationsOfValuesInLists(trainingData).ToList();
 
       for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(1000, -5, 5).ToList());
-        data[i].AddRange(combinations[i]);
+        data.Add(combinations[i].ToList());
+        data[i].AddRange(ValueGenerator.GenerateUniformDistributedValues(1000, -5, 5).ToList());
       }
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/KotanchekFunction.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/KotanchekFunction.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/KotanchekFunction.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class KotanchekFunction : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva Kotanchek"; } }
+    public override string Name { get { return "Vladislavleva-1 F1(X1,X2) = exp(-(X1 - 1))² / (1.2 + (X2 -2.5)²"; } }
     public override string Description {
       get {
         return "Paper: Order of Nonlinearity as a Complexity Measure for Models Generated by Symbolic Regression via Pareto Genetic Programming " + Environment.NewLine
         + "Authors: Ekaterina J. Vladislavleva, Member, IEEE, Guido F. Smits, Member, IEEE, and Dick den Hertog" + Environment.NewLine
-        + "Function: F1(X1, X2) = e^-(X1 - 1)^2 / (1.2 + (X2 -2.5)^2" + Environment.NewLine
+        + "Function: F1(X1, X2) = exp(-(X1 - 1))² / (1.2 + (X2 -2.5)²" + Environment.NewLine
         + "Training Data: 100 points X1, X2 = Rand(0.3, 4)" + Environment.NewLine
         + "Test Data: 2026 points (X1, X2) = (-0.2:0.1:4.2)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real, e^x, e^-x";
+        + "Function Set: +, -, *, /, square, e^x, e^-x, x^eps, x + eps, x * eps";
       }
     }
@@ -43,6 +43,6 @@
     protected override int TrainingPartitionStart { get { return 0; } }
     protected override int TrainingPartitionEnd { get { return 100; } }
-    protected override int TestPartitionStart { get { return 1000; } }
-    protected override int TestPartitionEnd { get { return 3025; } }
+    protected override int TestPartitionStart { get { return 100; } }
+    protected override int TestPartitionEnd { get { return 2126; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -53,5 +53,5 @@
       var combinations = ValueGenerator.GenerateAllCombinationsOfValuesInLists(testData).ToList<IEnumerable<double>>();
       for (int i = 0; i < AllowedInputVariables.Count(); i++) {
-        data.Add(ValueGenerator.GenerateUniformDistributedValues(1000, 0.3, 4).ToList());
+        data.Add(ValueGenerator.GenerateUniformDistributedValues(100, 0.3, 4).ToList());
         data[i].AddRange(combinations[i]);
       }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RationalPolynomialThreeDimensional.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RationalPolynomialThreeDimensional.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RationalPolynomialThreeDimensional.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class RationalPolynomialThreeDimensional : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva RatPol3D"; } }
+    public override string Name { get { return "Vladislavleva-5 F5(X1, X2, X3) = 30 * ((X1 - 1) * (X3 -1)) / (X2² * (X1 - 10))"; } }
     public override string Description {
       get {
         return "Paper: Order of Nonlinearity as a Complexity Measure for Models Generated by Symbolic Regression via Pareto Genetic Programming " + Environment.NewLine
         + "Authors: Ekaterina J. Vladislavleva, Member, IEEE, Guido F. Smits, Member, IEEE, and Dick den Hertog" + Environment.NewLine
-        + "Function: F5(X1, X2, X3) = 30 * ((X1 - 1) * (X3 -1)) / (X2^2 * (X1 - 10))" + Environment.NewLine
+        + "Function: F5(X1, X2, X3) = 30 * ((X1 - 1) * (X3 -1)) / (X2² * (X1 - 10))" + Environment.NewLine
         + "Training Data: 300 points X1, X3 = Rand(0.05, 2), X2 = Rand(1, 2)" + Environment.NewLine
         + "Test Data: 2701 points X1, X3 = (-0.05:0.15:2.1), X2 = (0.95:0.1:2.05)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real";
+        + "Function Set: +, -, *, /, square, x^eps, x + eps, x * eps";
       }
     }
@@ -49,8 +49,8 @@
       List<List<double>> data = new List<List<double>>();
 
-      int amountOfPoints = 1000;
-      data.Add(ValueGenerator.GenerateUniformDistributedValues(amountOfPoints, 0.05, 2).ToList());
-      data.Add(ValueGenerator.GenerateUniformDistributedValues(amountOfPoints, 1, 2).ToList());
-      data.Add(ValueGenerator.GenerateUniformDistributedValues(amountOfPoints, 0.05, 2).ToList());
+      int n = 1000;
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(n, 0.05, 2).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(n, 1, 2).ToList());
+      data.Add(ValueGenerator.GenerateUniformDistributedValues(n, 0.05, 2).ToList());
 
       List<List<double>> testData = new List<List<double>>() { 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RationalPolynomialTwoDimensional.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RationalPolynomialTwoDimensional.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RationalPolynomialTwoDimensional.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class RationalPolynomialTwoDimensional : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva RatPol2D"; } }
+    public override string Name { get { return "Vladislavleva-8 F8(X1, X2) = ((X1 - 3)^4 + (X2 - 3)³ - (X2 -3)) / ((X2 - 2)^4 + 10)"; } }
     public override string Description {
       get {
         return "Paper: Order of Nonlinearity as a Complexity Measure for Models Generated by Symbolic Regression via Pareto Genetic Programming " + Environment.NewLine
         + "Authors: Ekaterina J. Vladislavleva, Member, IEEE, Guido F. Smits, Member, IEEE, and Dick den Hertog" + Environment.NewLine
-        + "Function: F8(X1, X2) = ((X1 - 3)^4 + (X2 - 3)^3 - (X2 -3)) / ((X2 - 2)^4 + 10)" + Environment.NewLine
+        + "Function: F8(X1, X2) = ((X1 - 3)^4 + (X2 - 3)³ - (X2 -3)) / ((X2 - 2)^4 + 10)" + Environment.NewLine
         + "Training Data: 50 points X1, X2 = Rand(0.05, 6.05)" + Environment.NewLine
         + "Test Data: 1157 points X1, X2 = (-0.25:0.2:6.35)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real";
+        + "Function Set: +, -, *, /, square, x^eps, x + eps, x * eps";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RippleFunction.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RippleFunction.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/RippleFunction.cs	(revision 8430)
@@ -27,5 +27,5 @@
   public class RippleFunction : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva Ripple"; } }
+    public override string Name { get { return "Vladislavleva-7  F7(X1, X2) = (X1 - 3)(X2 - 3) + 2 * sin((X1 - 4)(X2 - 4))"; } }
     public override string Description {
       get {
@@ -35,5 +35,5 @@
         + "Training Data: 300 points X1, X2 = Rand(0.05, 6.05)" + Environment.NewLine
         + "Test Data: 1000 points X1, X2 = Rand(-0.25, 6.35)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real, e^x, e^-x, sin(x), cos(x)";
+        + "Function Set: +, -, *, /, square, e^x, e^-x, sin(x), cos(x), x^eps, x + eps, x + eps";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SalutowiczFunctionOneDimensional.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SalutowiczFunctionOneDimensional.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SalutowiczFunctionOneDimensional.cs	(revision 8430)
@@ -27,13 +27,13 @@
   public class SalutowiczFunctionOneDimensional : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva Salutowicz"; } }
+    public override string Name { get { return "Vladislavleva-2 F2(X) = exp(-X) * X³ * cos(X) * sin(X) * (cos(X)sin(X)² - 1)"; } }
     public override string Description {
       get {
         return "Paper: Order of Nonlinearity as a Complexity Measure for Models Generated by Symbolic Regression via Pareto Genetic Programming " + Environment.NewLine
         + "Authors: Ekaterina J. Vladislavleva, Member, IEEE, Guido F. Smits, Member, IEEE, and Dick den Hertog" + Environment.NewLine
-        + "Function: F2(X) = e^-X * X^3 * cos(X) * sin(X) * (cos(X)sin(X)^2 - 1)" + Environment.NewLine
+        + "Function: F2(X) = exp(-X) * X³ * cos(X) * sin(X) * (cos(X)sin(X)² - 1)" + Environment.NewLine
         + "Training Data: 100 points X = (0.05:0.1:10)" + Environment.NewLine
         + "Test Data: 221 points X = (-0.5:0.05:10.5)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real, e^x, e^-x, sin(x), cos(x)";
+        + "Function Set: +, -, *, /, square, e^x, e^-x, sin(x), cos(x), x^eps, x + eps, x + eps";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SalutowiczFunctionTwoDimensional.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SalutowiczFunctionTwoDimensional.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SalutowiczFunctionTwoDimensional.cs	(revision 8430)
@@ -27,14 +27,13 @@
   public class SalutowiczFunctionTwoDimensional : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva Salutowicz2D"; } }
+    public override string Name { get { return "Vladislavleva-3 F3(X1, X2) = exp(-X1) * X1³ * cos(X1) * sin(X1) * (cos(X1)sin(X1)² - 1)(X2 - 5)"; } }
     public override string Description {
       get {
         return "Paper: Order of Nonlinearity as a Complexity Measure for Models Generated by Symbolic Regression via Pareto Genetic Programming " + Environment.NewLine
         + "Authors: Ekaterina J. Vladislavleva, Member, IEEE, Guido F. Smits, Member, IEEE, and Dick den Hertog" + Environment.NewLine
-        + "Function: F3(X1, X2) = e^-X1 * X1^3 * cos(X1) * sin(X1) * (cos(X1)sin(X1)^2 - 1)(X2 - 5)" + Environment.NewLine
+        + "Function: F3(X1, X2) = exp(-X1) * X1³ * cos(X1) * sin(X1) * (cos(X1)sin(X1)² - 1)(X2 - 5)" + Environment.NewLine
         + "Training Data: 601 points X1 = (0.05:0.1:10), X2 = (0.05:2:10.05)" + Environment.NewLine
-        + "Test Data: 2554 points X1 = (-0.5:0.05:10.5), X2 = (-0.5:0.5:10.5)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real, e^x, e^-x, sin(x), cos(x)" + Environment.NewLine + Environment.NewLine
-        + "Important: The stepwidth of the variable X1 in the test partition has been set to 0.1, to fit the amount of data points.";
+        + "Test Data: 4840 points X1 = (-0.5:0.05:10.5), X2 = (-0.5:0.5:10.5)" + Environment.NewLine
+        + "Function Set: +, -, *, /, square, e^x, e^-x, sin(x), cos(x), x^eps, x + eps, x + eps";
       }
     }
@@ -45,5 +44,5 @@
     protected override int TrainingPartitionEnd { get { return 601; } }
     protected override int TestPartitionStart { get { return 601; } }
-    protected override int TestPartitionEnd { get { return 3155; } }
+    protected override int TestPartitionEnd { get { return 5441; } }
 
     protected override List<List<double>> GenerateValues() {
@@ -55,5 +54,5 @@
 
       List<List<double>> testData = new List<List<double>>() {
-        ValueGenerator.GenerateSteps(-0.5, 10.5, 0.1).ToList(),
+        ValueGenerator.GenerateSteps(-0.5, 10.5, 0.05).ToList(),
         ValueGenerator.GenerateSteps(-0.5, 10.5, 0.5).ToList()
       };
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SineCosineFunction.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SineCosineFunction.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/SineCosineFunction.cs	(revision 8430)
@@ -27,5 +27,5 @@
   public class SineCosineFunction : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva SineCosine"; } }
+    public override string Name { get { return "Vladislavleva-6 F6(X1, X2) = 6 * sin(X1) * cos(X2)"; } }
     public override string Description {
       get {
@@ -35,5 +35,5 @@
         + "Training Data: 30 points X1, X2 = Rand(0.1, 5.9)" + Environment.NewLine
         + "Test Data: 961 points X1, X2 = (-0.05:0.02:6.05)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real, e^x, e^-x";
+        + "Function Set: +, -, *, /, square, e^x, e^-x, x^eps, x + eps, x * eps";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/UnwrappedBallFunctionFiveDimensional.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/UnwrappedBallFunctionFiveDimensional.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/UnwrappedBallFunctionFiveDimensional.cs	(revision 8430)
@@ -27,5 +27,5 @@
   public class UnwrappedBallFunctionFiveDimensional : ArtificialRegressionDataDescriptor {
 
-    public override string Name { get { return "Vladislavleva UBall5D"; } }
+    public override string Name { get { return "Vladislavleva-4 F4(X1, X2, X3, X4, X5) = 10 / (5 + Sum(Xi - 3)^2)"; } }
     public override string Description {
       get {
@@ -35,5 +35,5 @@
         + "Training Data: 1024 points Xi = Rand(0.05, 6.05)" + Environment.NewLine
         + "Test Data: 5000 points Xi = Rand(-0.25, 6.35)" + Environment.NewLine
-        + "Function Set: +, -, *, /, sqaure, x^real, x + real, x + real";
+        + "Function Set: +, -, *, /, square, x^eps, x + eps, x * eps";
       }
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/VladislavlevaInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/VladislavlevaInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/Regression/Vladislavleva/VladislavlevaInstanceProvider.cs	(revision 8430)
@@ -32,8 +32,8 @@
     }
     public override Uri WebLink {
-      get { return new Uri("http://groups.csail.mit.edu/EVO-DesignOpt/GPBenchmarks/"); }
+      get { return new Uri("http://www.gpbenchmarks.org/wiki/index.php?title=Problem_Classification#Vladislavleva_et_al"); }
     }
     public override string ReferencePublication {
-      get { return ""; }
+      get { return "McDermott et al., 2012 \"Genetic Programming Needs Better Benchmarks\", in Proc. of GECCO 2012."; }
     }
 
@@ -41,10 +41,11 @@
       List<IDataDescriptor> descriptorList = new List<IDataDescriptor>();
       descriptorList.Add(new KotanchekFunction());
-      descriptorList.Add(new RationalPolynomialTwoDimensional());
-      descriptorList.Add(new RationalPolynomialThreeDimensional());
-      descriptorList.Add(new RippleFunction());
       descriptorList.Add(new SalutowiczFunctionOneDimensional());
       descriptorList.Add(new SalutowiczFunctionTwoDimensional());
       descriptorList.Add(new UnwrappedBallFunctionFiveDimensional());
+      descriptorList.Add(new RationalPolynomialThreeDimensional());
+      descriptorList.Add(new SineCosineFunction());
+      descriptorList.Add(new RippleFunction());
+      descriptorList.Add(new RationalPolynomialTwoDimensional());
       return descriptorList;
     }
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/TimeSeries/TimeSeriesPrognosisInstanceProvider.cs
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/TimeSeries/TimeSeriesPrognosisInstanceProvider.cs	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.Instances.DataAnalysis/3.3/TimeSeries/TimeSeriesPrognosisInstanceProvider.cs	(revision 8430)
@@ -29,6 +29,9 @@
 namespace HeuristicLab.Problems.Instances.DataAnalysis {
   public abstract class TimeSeriesPrognosisInstanceProvider : IProblemInstanceProvider<ITimeSeriesPrognosisProblemData> {
+    public bool CanImportData { get { return true; } }
+    public bool CanExportData { get { return true; } }
 
-    public ITimeSeriesPrognosisProblemData LoadData(string path) {
+
+    public ITimeSeriesPrognosisProblemData ImportData(string path) {
       TableFileParser csvFileParser = new TableFileParser();
       csvFileParser.Parse(path);
@@ -36,5 +39,5 @@
       Dataset dataset = new Dataset(csvFileParser.VariableNames, csvFileParser.Values);
       string targetVar = csvFileParser.VariableNames.Last();
-      
+
       IEnumerable<string> allowedInputVars = dataset.DoubleVariables.Where(x => !x.Equals(targetVar));
 
@@ -57,5 +60,5 @@
     }
 
-    public void SaveData(ITimeSeriesPrognosisProblemData instance, string path) {
+    public void ExportData(ITimeSeriesPrognosisProblemData instance, string path) {
       StringBuilder strBuilder = new StringBuilder();
 
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab.TimeSeries-3.3.sln
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab.TimeSeries-3.3.sln	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab.TimeSeries-3.3.sln	(revision 8430)
@@ -28,7 +28,10 @@
 	ProjectSection(ProjectDependencies) = postProject
 		{94C7714E-29D4-4D6D-B213-2C18D627AB75} = {94C7714E-29D4-4D6D-B213-2C18D627AB75}
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8} = {2E782078-FA81-4B70-B56F-74CE38DAC6C8}
 	EndProjectSection
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Problems.Instances.DataAnalysis-3.3", "HeuristicLab.Problems.Instances.DataAnalysis\3.3\HeuristicLab.Problems.Instances.DataAnalysis-3.3.csproj", "{94C7714E-29D4-4D6D-B213-2C18D627AB75}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HeuristicLab.Algorithms.DataAnalysis-3.4", "HeuristicLab.Algorithms.DataAnalysis\3.4\HeuristicLab.Algorithms.DataAnalysis-3.4.csproj", "{2E782078-FA81-4B70-B56F-74CE38DAC6C8}"
 EndProject
 Global
@@ -137,4 +140,16 @@
 		{94C7714E-29D4-4D6D-B213-2C18D627AB75}.Release|x64.ActiveCfg = Release|Any CPU
 		{94C7714E-29D4-4D6D-B213-2C18D627AB75}.Release|x86.ActiveCfg = Release|Any CPU
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Debug|x64.ActiveCfg = Debug|x64
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Debug|x64.Build.0 = Debug|x64
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Debug|x86.ActiveCfg = Debug|x86
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Debug|x86.Build.0 = Debug|x86
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Release|x64.ActiveCfg = Release|x64
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Release|x64.Build.0 = Release|x64
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Release|x86.ActiveCfg = Release|x86
+		{2E782078-FA81-4B70-B56F-74CE38DAC6C8}.Release|x86.Build.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab/3.3/Files.txt
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab/3.3/Files.txt	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab/3.3/Files.txt	(revision 8430)
@@ -6,2 +6,4 @@
 *.dll
 *.txt
+mathjax.zip
+displayModelFrame.html
Index: /branches/HeuristicLab.TimeSeries/HeuristicLab/3.3/Properties/AssemblyInfo.cs.frame
===================================================================
--- /branches/HeuristicLab.TimeSeries/HeuristicLab/3.3/Properties/AssemblyInfo.cs.frame	(revision 8429)
+++ /branches/HeuristicLab.TimeSeries/HeuristicLab/3.3/Properties/AssemblyInfo.cs.frame	(revision 8430)
@@ -51,4 +51,4 @@
 //      Revision
 //
-[assembly: AssemblyVersion("3.3.6.$WCREV$")]
-[assembly: AssemblyFileVersion("3.3.6.$WCREV$")]
+[assembly: AssemblyVersion("3.3.7.$WCREV$")]
+[assembly: AssemblyFileVersion("3.3.7.$WCREV$")]
