Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Dataset.cs	(revision 7989)
@@ -193,6 +193,5 @@
       if (values == null) throw new ArgumentException("The varialbe " + variableName + " is not a double variable.");
 
-      foreach (int index in rows)
-        yield return values[index];
+      return rows.Select(index => values[index]);
     }
 
Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs	(revision 7989)
@@ -20,24 +20,8 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using HeuristicLab.PluginInfrastructure;
 
 namespace HeuristicLab.Problems.DataAnalysis {
   public static class DatasetExtensions {
-    public static IEnumerable<double> GetVectorEnumerable(this Dataset ds, IEnumerable<string> targetVariables, IEnumerable<int> rows) {
-      var vars = targetVariables.ToArray();
-      var values = (from var in vars
-                    select ds.GetReadOnlyDoubleValues(var))
-        .ToArray();
-
-      foreach (var r in rows) {
-        for (int i = 0; i < values.Length; i++)
-          yield return values[i][r];
-      }
-    }
-
     public static IEnumerable<T> TakeEvery<T>(this IEnumerable<T> xs, int nth) {
       int i = 0;
Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs	(revision 7989)
@@ -33,5 +33,5 @@
   [Item("TimeSeriesPrognosisProblemData", "Represents an item containing all data defining a time series prognosis problem.")]
   public class TimeSeriesPrognosisProblemData : DataAnalysisProblemData, ITimeSeriesPrognosisProblemData {
-    protected const string TargetVariablesParameterName = "TargetVariables";
+    protected const string TargetVariableParameterName = "TargetVariable";
 
     #region default data
@@ -1540,5 +1540,5 @@
     private static readonly Dataset defaultDataset;
     private static readonly IEnumerable<string> defaultAllowedInputVariables;
-    private static readonly string[] defaultTargetVariables;
+    private static readonly string defaultTargetVariable;
 
     private static readonly TimeSeriesPrognosisProblemData emptyProblemData;
@@ -1551,5 +1551,5 @@
       defaultDataset.Name = "Mackey-Glass (t=17) Time Series Benchmark Dataset";
       defaultAllowedInputVariables = new List<string>() { "x" };
-      defaultTargetVariables = new string[] { "x" };
+      defaultTargetVariable = "x";
 
       var problemData = new TimeSeriesPrognosisProblemData();
@@ -1563,14 +1563,14 @@
       problemData.Parameters.Add(new FixedValueParameter<IntRange>(TrainingPartitionParameterName, "", (IntRange)new IntRange(0, 0).AsReadOnly()));
       problemData.Parameters.Add(new FixedValueParameter<IntRange>(TestPartitionParameterName, "", (IntRange)new IntRange(0, 0).AsReadOnly()));
-      problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariablesParameterName, new ItemSet<StringValue>()));
+      problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
       emptyProblemData = problemData;
     }
     #endregion
 
-    public ValueParameter<CheckedItemList<StringValue>> TargetVariablesParameter {
-      get { return (ValueParameter<CheckedItemList<StringValue>>)Parameters[TargetVariablesParameterName]; }
+    public ConstrainedValueParameter<StringValue> TargetVariableParameter {
+      get { return (ConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
     }
-    public IEnumerable<string> TargetVariables {
-      get { return TargetVariablesParameter.Value.CheckedItems.Select(x => x.Value.Value); }
+    public string TargetVariable {
+      get { return TargetVariableParameter.Value.Value; }
     }
 
@@ -1592,22 +1592,17 @@
 
     public TimeSeriesPrognosisProblemData()
-      : this(defaultDataset, defaultAllowedInputVariables, defaultTargetVariables) {
+      : this(defaultDataset, defaultAllowedInputVariables, defaultTargetVariable) {
     }
 
-    public TimeSeriesPrognosisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<string> targetVariables)
+    public TimeSeriesPrognosisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable)
       : base(dataset, allowedInputVariables) {
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
-      var targetVariablesList = new CheckedItemList<StringValue>(variables);
-      foreach (var targetVar in targetVariables) {
-        targetVariablesList.SetItemCheckedState(targetVariablesList.Single(x => x.Value == targetVar), true);
-      }
-      Parameters.Add(new FixedValueParameter<CheckedItemList<StringValue>>(TargetVariablesParameterName, targetVariablesList));
+      Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.First(x => x.Value == targetVariable)));
       RegisterParameterEvents();
     }
 
     private void RegisterParameterEvents() {
-      TargetVariablesParameter.Value.CheckedItemsChanged += TargetVariableParameter_ValueChanged;
+      TargetVariableParameter.ValueChanged += new EventHandler(TargetVariableParameter_ValueChanged);
     }
-
     private void TargetVariableParameter_ValueChanged(object sender, EventArgs e) {
       OnChanged();
Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolution.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolution.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolution.cs	(revision 7989)
@@ -21,5 +21,4 @@
 
 using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -33,13 +32,7 @@
 
     [StorableConstructor]
-    protected TimeSeriesPrognosisSolution(bool deserializing)
-      : base(deserializing) {
-    }
-    protected TimeSeriesPrognosisSolution(TimeSeriesPrognosisSolution original, Cloner cloner)
-      : base(original, cloner) {
-    }
-    protected TimeSeriesPrognosisSolution(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
-      : base(model, problemData) {
-    }
+    protected TimeSeriesPrognosisSolution(bool deserializing) : base(deserializing) { }
+    protected TimeSeriesPrognosisSolution(TimeSeriesPrognosisSolution original, Cloner cloner) : base(original, cloner) { }
+    protected TimeSeriesPrognosisSolution(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData) : base(model, problemData) { }
 
     protected override void RecalculateResults() {
@@ -47,28 +40,6 @@
     }
 
-    public override IEnumerable<IEnumerable<double>> PrognosedTrainingValues {
-      get {
-        return GetPrognosedValues(ProblemData.TrainingIndizes.Take(1),
-          ProblemData.TrainingPartition.End - ProblemData.TrainingPartition.Start)
-          .First();
-      }
-    }
-    public override IEnumerable<IEnumerable<double>> PrognosedTestValues {
-      get {
-        return GetPrognosedValues(ProblemData.TestIndizes.Take(1),
-          ProblemData.TestPartition.End - ProblemData.TestPartition.Start)
-          .First();
-      }
-    }
-    public override IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(IEnumerable<int> rows, int horizon) {
+    public override IEnumerable<IEnumerable<double>> GetPrognosedValues(IEnumerable<int> rows, int horizon) {
       return Model.GetPrognosedValues(ProblemData.Dataset, rows, horizon);
-    }
-
-    protected override void OnProblemDataChanged() {
-      base.OnProblemDataChanged();
-    }
-
-    protected override void OnModelChanged() {
-      base.OnModelChanged();
     }
   }
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 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionBase.cs	(revision 7989)
@@ -21,5 +21,4 @@
 
 using System;
-using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -75,88 +74,86 @@
     }
 
-    public abstract IEnumerable<IEnumerable<double>> PrognosedTrainingValues { get; }
-    public abstract IEnumerable<IEnumerable<double>> PrognosedTestValues { get; }
-    public abstract IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(IEnumerable<int> rows, int horizon);
+    public abstract IEnumerable<IEnumerable<double>> GetPrognosedValues(IEnumerable<int> rows, int horizon);
 
     #region Results
-    public double[] TrainingMeanSquaredError {
-      get { return ((DoubleArray)this[TrainingMeanSquaredErrorResultName].Value).ToArray(); }
-      private set { this[TrainingMeanSquaredErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestMeanSquaredError {
-      get { return ((DoubleArray)this[TestMeanSquaredErrorResultName].Value).ToArray(); }
-      private set { this[TestMeanSquaredErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingMeanAbsoluteError {
-      get { return ((DoubleArray)this[TrainingMeanAbsoluteErrorResultName].Value).ToArray(); }
-      private set { this[TrainingMeanAbsoluteErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestMeanAbsoluteError {
-      get { return ((DoubleArray)this[TestMeanAbsoluteErrorResultName].Value).ToArray(); }
-      private set { this[TestMeanAbsoluteErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingRSquared {
-      get { return ((DoubleArray)this[TrainingSquaredCorrelationResultName].Value).ToArray(); }
-      private set { this[TrainingSquaredCorrelationResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestRSquared {
-      get { return ((DoubleArray)this[TestSquaredCorrelationResultName].Value).ToArray(); }
-      private set { this[TestSquaredCorrelationResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingRelativeError {
-      get { return ((DoubleArray)this[TrainingRelativeErrorResultName].Value).ToArray(); }
-      private set { this[TrainingRelativeErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestRelativeError {
-      get { return ((DoubleArray)this[TestRelativeErrorResultName].Value).ToArray(); }
-      private set { this[TestRelativeErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingNormalizedMeanSquaredError {
-      get { return ((DoubleArray)this[TrainingNormalizedMeanSquaredErrorResultName].Value).ToArray(); }
-      private set { this[TrainingNormalizedMeanSquaredErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestNormalizedMeanSquaredError {
-      get { return ((DoubleArray)this[TestNormalizedMeanSquaredErrorResultName].Value).ToArray(); }
-      private set { this[TestNormalizedMeanSquaredErrorResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingDirectionalSymmetry {
-      get { return ((DoubleArray)this[TrainingDirectionalSymmetryResultName].Value).ToArray(); }
-      private set { this[TrainingDirectionalSymmetryResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestDirectionalSymmetry {
-      get { return ((DoubleArray)this[TestDirectionalSymmetryResultName].Value).ToArray(); }
-      private set { this[TestDirectionalSymmetryResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingWeightedDirectionalSymmetry {
-      get { return ((DoubleArray)this[TrainingWeightedDirectionalSymmetryResultName].Value).ToArray(); }
-      private set { this[TrainingWeightedDirectionalSymmetryResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestWeightedDirectionalSymmetry {
-      get { return ((DoubleArray)this[TestWeightedDirectionalSymmetryResultName].Value).ToArray(); }
-      private set { this[TestWeightedDirectionalSymmetryResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingTheilsUStatisticLast {
-      get { return ((DoubleArray)this[TrainingTheilsUStatisticLastResultName].Value).ToArray(); }
-      private set { this[TrainingTheilsUStatisticLastResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestTheilsUStatisticLast {
-      get { return ((DoubleArray)this[TestTheilsUStatisticLastResultName].Value).ToArray(); }
-      private set { this[TestTheilsUStatisticLastResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingTheilsUStatisticMean {
-      get { return ((DoubleArray)this[TrainingTheilsUStatisticMeanResultName].Value).ToArray(); }
-      private set { this[TrainingTheilsUStatisticMeanResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestTheilsUStatisticMean {
-      get { return ((DoubleArray)this[TestTheilsUStatisticMeanResultName].Value).ToArray(); }
-      private set { this[TestTheilsUStatisticMeanResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TrainingTheilsUStatisticMovingAverage {
-      get { return ((DoubleArray)this[TrainingTheilsUStatisticMaResultName].Value).ToArray(); }
-      private set { this[TrainingTheilsUStatisticMaResultName].Value = new DoubleArray(value); }
-    }
-    public double[] TestTheilsUStatisticMovingAverage {
-      get { return ((DoubleArray)this[TestTheilsUStatisticMaResultName].Value).ToArray(); }
-      private set { this[TestTheilsUStatisticMaResultName].Value = new DoubleArray(value); }
+    public double TrainingMeanSquaredError {
+      get { return ((DoubleValue)this[TrainingMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingMeanSquaredErrorResultName].Value).Value = value; }
+    }
+    public double TestMeanSquaredError {
+      get { return ((DoubleValue)this[TestMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestMeanSquaredErrorResultName].Value).Value = value; }
+    }
+    public double TrainingMeanAbsoluteError {
+      get { return ((DoubleValue)this[TrainingMeanAbsoluteErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingMeanAbsoluteErrorResultName].Value).Value = value; }
+    }
+    public double TestMeanAbsoluteError {
+      get { return ((DoubleValue)this[TestMeanAbsoluteErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestMeanAbsoluteErrorResultName].Value).Value = value; }
+    }
+    public double TrainingRSquared {
+      get { return ((DoubleValue)this[TrainingSquaredCorrelationResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingSquaredCorrelationResultName].Value).Value = value; }
+    }
+    public double TestRSquared {
+      get { return ((DoubleValue)this[TestSquaredCorrelationResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestSquaredCorrelationResultName].Value).Value = value; }
+    }
+    public double TrainingRelativeError {
+      get { return ((DoubleValue)this[TrainingRelativeErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingRelativeErrorResultName].Value).Value = value; }
+    }
+    public double TestRelativeError {
+      get { return ((DoubleValue)this[TestRelativeErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestRelativeErrorResultName].Value).Value = value; }
+    }
+    public double TrainingNormalizedMeanSquaredError {
+      get { return ((DoubleValue)this[TrainingNormalizedMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingNormalizedMeanSquaredErrorResultName].Value).Value = value; }
+    }
+    public double TestNormalizedMeanSquaredError {
+      get { return ((DoubleValue)this[TestNormalizedMeanSquaredErrorResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestNormalizedMeanSquaredErrorResultName].Value).Value = value; }
+    }
+    public double TrainingDirectionalSymmetry {
+      get { return ((DoubleValue)this[TrainingDirectionalSymmetryResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingDirectionalSymmetryResultName].Value).Value = value; }
+    }
+    public double TestDirectionalSymmetry {
+      get { return ((DoubleValue)this[TestDirectionalSymmetryResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestDirectionalSymmetryResultName].Value).Value = value; }
+    }
+    public double TrainingWeightedDirectionalSymmetry {
+      get { return ((DoubleValue)this[TrainingWeightedDirectionalSymmetryResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingWeightedDirectionalSymmetryResultName].Value).Value = value; }
+    }
+    public double TestWeightedDirectionalSymmetry {
+      get { return ((DoubleValue)this[TestWeightedDirectionalSymmetryResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestWeightedDirectionalSymmetryResultName].Value).Value = value; }
+    }
+    public double TrainingTheilsUStatisticLast {
+      get { return ((DoubleValue)this[TrainingTheilsUStatisticLastResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingTheilsUStatisticLastResultName].Value).Value = value; }
+    }
+    public double TestTheilsUStatisticLast {
+      get { return ((DoubleValue)this[TestTheilsUStatisticLastResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestTheilsUStatisticLastResultName].Value).Value = value; }
+    }
+    public double TrainingTheilsUStatisticMean {
+      get { return ((DoubleValue)this[TrainingTheilsUStatisticMeanResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingTheilsUStatisticMeanResultName].Value).Value = value; }
+    }
+    public double TestTheilsUStatisticMean {
+      get { return ((DoubleValue)this[TestTheilsUStatisticMeanResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestTheilsUStatisticMeanResultName].Value).Value = value; }
+    }
+    public double TrainingTheilsUStatisticMovingAverage {
+      get { return ((DoubleValue)this[TrainingTheilsUStatisticMaResultName].Value).Value; }
+      private set { ((DoubleValue)this[TrainingTheilsUStatisticMaResultName].Value).Value = value; }
+    }
+    public double TestTheilsUStatisticMovingAverage {
+      get { return ((DoubleValue)this[TestTheilsUStatisticMaResultName].Value).Value; }
+      private set { ((DoubleValue)this[TestTheilsUStatisticMaResultName].Value).Value = value; }
     }
     #endregion
@@ -170,237 +167,145 @@
     protected TimeSeriesPrognosisSolutionBase(ITimeSeriesPrognosisModel model, ITimeSeriesPrognosisProblemData problemData)
       : base(model, problemData) {
-      Add(new Result(TrainingMeanSquaredErrorResultName, "Mean of squared errors of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestMeanSquaredErrorResultName, "Mean of squared errors of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleArray()));
-      Add(new Result(TestSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleArray()));
-      Add(new Result(TrainingRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the training partition", new DoubleArray()));
-      Add(new Result(TestRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the test partition", new DoubleArray()));
-      Add(new Result(TrainingNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingWeightedDirectionalSymmetryResultName, "The average weighted directional symmetry of the forecasts of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestWeightedDirectionalSymmetryResultName, "The average weighted directional symmetry of the forecasts of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the test partition", new DoubleArray()));
-      Add(new Result(TrainingTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the training partition", new DoubleArray()));
-      Add(new Result(TestTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the test partition", new DoubleArray()));
+      Add(new Result(TrainingMeanSquaredErrorResultName, "Mean of squared errors of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestMeanSquaredErrorResultName, "Mean of squared errors of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the training partition", new DoubleValue()));
+      Add(new Result(TestSquaredCorrelationResultName, "Squared Pearson's correlation coefficient of the model output and the actual values on the test partition", new DoubleValue()));
+      Add(new Result(TrainingRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the training partition", new DoubleValue()));
+      Add(new Result(TestRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the test partition", new DoubleValue()));
+      Add(new Result(TrainingNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestNormalizedMeanSquaredErrorResultName, "Normalized mean of squared errors of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingWeightedDirectionalSymmetryResultName, "The average weighted directional symmetry of the forecasts of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestWeightedDirectionalSymmetryResultName, "The average weighted directional symmetry of the forecasts of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the test partition", new DoubleValue()));
+      Add(new Result(TrainingTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the training partition", new DoubleValue()));
+      Add(new Result(TestTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the test partition", new DoubleValue()));
       horizon = 1;
     }
 
-    [StorableHook(HookType.AfterDeserialization)]
-    private void AfterDeserialization() {
-      if (horizon == 0) horizon = 1;
-      bool anyNewResult = false;
-      if (!ContainsKey(TrainingTheilsUStatisticLastResultName)) {
-        Add(new Result(TrainingTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the training partition", new DoubleArray()));
-        anyNewResult = true;
-      }
-      if (!ContainsKey(TestTheilsUStatisticLastResultName)) {
-        Add(new Result(TestTheilsUStatisticLastResultName, "The average Theil's U statistic (reference: previous value) of the forecasts of the model on the test partition", new DoubleArray()));
-        anyNewResult = true;
-      }
-      if (!ContainsKey(TrainingTheilsUStatisticMeanResultName)) {
-        Add(new Result(TrainingTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the training partition", new DoubleArray()));
-        anyNewResult = true;
-      }
-      if (!ContainsKey(TestTheilsUStatisticMeanResultName)) {
-        Add(new Result(TestTheilsUStatisticMeanResultName, "The average Theil's U statistic (reference: mean value) of the forecasts of the model on the test partition", new DoubleArray()));
-        anyNewResult = true;
-      }
-      if (!ContainsKey(TrainingTheilsUStatisticMaResultName)) {
-        Add(new Result(TrainingTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the training partition", new DoubleArray()));
-        anyNewResult = true;
-      }
-      if (!ContainsKey(TestTheilsUStatisticMaResultName)) {
-        Add(new Result(TestTheilsUStatisticMaResultName, "The average Theil's U statistic (reference: moving average) of the forecasts of the model on the test partition", new DoubleArray()));
-        anyNewResult = true;
-      }
-      if (anyNewResult)
-        RecalculateResults();
-    }
 
     protected void CalculateResults() {
-      string[] targetVariables = ProblemData.TargetVariables.ToArray();
-
-      var trainingMseCalculators = new OnlineMeanSquaredErrorCalculator[targetVariables.Length];
-      var testMseCalculators = new OnlineMeanSquaredErrorCalculator[targetVariables.Length];
-      var trainingMaeCalculators = new OnlineMeanAbsoluteErrorCalculator[targetVariables.Length];
-      var testMaeCalculators = new OnlineMeanAbsoluteErrorCalculator[targetVariables.Length];
-      var trainingRSquaredCalculators = new OnlinePearsonsRSquaredCalculator[targetVariables.Length];
-      var testRSquaredCalculators = new OnlinePearsonsRSquaredCalculator[targetVariables.Length];
-      var trainingRelErrorCalculators = new OnlineMeanAbsolutePercentageErrorCalculator[targetVariables.Length];
-      var testRelErrorCalculators = new OnlineMeanAbsolutePercentageErrorCalculator[targetVariables.Length];
-      var trainingNmseCalculators = new OnlineNormalizedMeanSquaredErrorCalculator[targetVariables.Length];
-      var testNmseCalculators = new OnlineNormalizedMeanSquaredErrorCalculator[targetVariables.Length];
-
-      var trainingDsCalculators = new OnlineDirectionalSymmetryCalculator[targetVariables.Length];
-      var testDsCalculators = new OnlineDirectionalSymmetryCalculator[targetVariables.Length];
-      var trainingWdsCalculators = new OnlineWeightedDirectionalSymmetryCalculator[targetVariables.Length];
-      var testWdsCalculators = new OnlineWeightedDirectionalSymmetryCalculator[targetVariables.Length];
-      var trainingTheilsULastCalculators = new OnlineTheilsUStatisticCalculator[targetVariables.Length];
-      var testTheilsULastCalculators = new OnlineTheilsUStatisticCalculator[targetVariables.Length];
-      var trainingTheilsUMeanCalculators = new OnlineTheilsUStatisticCalculator[targetVariables.Length];
-      var testTheilsUMeanCalculators = new OnlineTheilsUStatisticCalculator[targetVariables.Length];
-      var trainingTheilsUMovingAverageCalculators = new OnlineTheilsUStatisticCalculator[targetVariables.Length];
-      var testTheilsUMovingAverageCalculators = new OnlineTheilsUStatisticCalculator[targetVariables.Length];
-      for (int i = 0; i < targetVariables.Length; i++) {
-        trainingMseCalculators[i] = new OnlineMeanSquaredErrorCalculator();
-        testMseCalculators[i] = new OnlineMeanSquaredErrorCalculator();
-        trainingMaeCalculators[i] = new OnlineMeanAbsoluteErrorCalculator();
-        testMaeCalculators[i] = new OnlineMeanAbsoluteErrorCalculator();
-        trainingRSquaredCalculators[i] = new OnlinePearsonsRSquaredCalculator();
-        testRSquaredCalculators[i] = new OnlinePearsonsRSquaredCalculator();
-        trainingRelErrorCalculators[i] = new OnlineMeanAbsolutePercentageErrorCalculator();
-        testRelErrorCalculators[i] = new OnlineMeanAbsolutePercentageErrorCalculator();
-        trainingNmseCalculators[i] = new OnlineNormalizedMeanSquaredErrorCalculator();
-        testNmseCalculators[i] = new OnlineNormalizedMeanSquaredErrorCalculator();
-
-        trainingDsCalculators[i] = new OnlineDirectionalSymmetryCalculator();
-        testDsCalculators[i] = new OnlineDirectionalSymmetryCalculator();
-        trainingWdsCalculators[i] = new OnlineWeightedDirectionalSymmetryCalculator();
-        testWdsCalculators[i] = new OnlineWeightedDirectionalSymmetryCalculator();
-        trainingTheilsULastCalculators[i] = new OnlineTheilsUStatisticCalculator();
-        testTheilsULastCalculators[i] = new OnlineTheilsUStatisticCalculator();
-        trainingTheilsUMeanCalculators[i] = new OnlineTheilsUStatisticCalculator();
-        testTheilsUMeanCalculators[i] = new OnlineTheilsUStatisticCalculator();
-        trainingTheilsUMovingAverageCalculators[i] = new OnlineTheilsUStatisticCalculator();
-        testTheilsUMovingAverageCalculators[i] = new OnlineTheilsUStatisticCalculator();
-      }
-
-      var allPrognosedTrainingValues = GetPrognosedValues(ProblemData.TrainingIndizes, horizon).GetEnumerator();
-      double[] mean = new double[targetVariables.Length];
-      for (int t = 0; t < targetVariables.Length; t++) {
-        double variance;
-        OnlineCalculatorError meanErrorState, varErrorState;
-        OnlineMeanAndVarianceCalculator.Calculate(ProblemData.Dataset.GetDoubleValues(targetVariables[t], ProblemData.TrainingIndizes), out mean[t], out variance, out meanErrorState, out varErrorState);
-        if (meanErrorState != OnlineCalculatorError.None) mean[t] = 0.0;
-      }
+      string targetVariable = ProblemData.TargetVariable;
+
+      var trainingMseCalculators = new OnlineMeanSquaredErrorCalculator();
+      var testMseCalculators = new OnlineMeanSquaredErrorCalculator();
+      var trainingMaeCalculators = new OnlineMeanAbsoluteErrorCalculator();
+      var testMaeCalculators = new OnlineMeanAbsoluteErrorCalculator();
+      var trainingRSquaredCalculators = new OnlinePearsonsRSquaredCalculator();
+      var testRSquaredCalculators = new OnlinePearsonsRSquaredCalculator();
+      var trainingRelErrorCalculators = new OnlineMeanAbsolutePercentageErrorCalculator();
+      var testRelErrorCalculators = new OnlineMeanAbsolutePercentageErrorCalculator();
+      var trainingNmseCalculators = new OnlineNormalizedMeanSquaredErrorCalculator();
+      var testNmseCalculators = new OnlineNormalizedMeanSquaredErrorCalculator();
+
+      var trainingDsCalculators = new OnlineDirectionalSymmetryCalculator();
+      var testDsCalculators = new OnlineDirectionalSymmetryCalculator();
+      var trainingWdsCalculators = new OnlineWeightedDirectionalSymmetryCalculator();
+      var testWdsCalculators = new OnlineWeightedDirectionalSymmetryCalculator();
+      var trainingTheilsULastCalculators = new OnlineTheilsUStatisticCalculator();
+      var testTheilsULastCalculators = new OnlineTheilsUStatisticCalculator();
+      var trainingTheilsUMeanCalculators = new OnlineTheilsUStatisticCalculator();
+      var testTheilsUMeanCalculators = new OnlineTheilsUStatisticCalculator();
+      var trainingTheilsUMovingAverageCalculators = new OnlineTheilsUStatisticCalculator();
+      var testTheilsUMovingAverageCalculators = new OnlineTheilsUStatisticCalculator();
+
+      double mean = ProblemData.Dataset.GetDoubleValues(targetVariable, ProblemData.TrainingIndizes).Average();
+
       foreach (var row in ProblemData.TrainingIndizes) {
         if (row + horizon < ProblemData.Dataset.Rows) {
-          allPrognosedTrainingValues.MoveNext();
-          var prognosedTrainingValues = allPrognosedTrainingValues.Current.SelectMany(x => x.ToArray()).ToArray();
-          for (int t = 0; t < targetVariables.Length; t++) {
-            var actualContinuation = ProblemData.Dataset.GetDoubleValues(targetVariables[t],
-                                                                         Enumerable.Range(row, horizon));
-            int maWindow = 10 * horizon;
-            var movingAverageContinuation = from h in Enumerable.Range(0, horizon)
-                                            select (from r in Enumerable.Range(row + h - maWindow, maWindow - h)
-                                                    where r > 0
-                                                    select ProblemData.Dataset.GetDoubleValue(targetVariables[t], r)
-                                                   ).Average();
-            double startValue = ProblemData.Dataset.GetDoubleValue(targetVariables[t], row - 1);
-            var prognosedContinuation = prognosedTrainingValues.Skip(t).TakeEvery(targetVariables.Length);
-            trainingDsCalculators[t].Add(startValue, actualContinuation, prognosedContinuation);
-            trainingWdsCalculators[t].Add(startValue, actualContinuation, prognosedContinuation);
-            trainingTheilsULastCalculators[t].Add(startValue, actualContinuation, prognosedContinuation);
-            trainingTheilsUMeanCalculators[t].Add(startValue, actualContinuation.Select(x => mean[t]), actualContinuation, prognosedContinuation);
-            trainingTheilsUMovingAverageCalculators[t].Add(startValue, movingAverageContinuation, actualContinuation, prognosedContinuation);
-
-            var actualContinuationEnumerator = actualContinuation.GetEnumerator();
-            var prognosedContinuationEnumerator = prognosedContinuation.GetEnumerator();
-            while (actualContinuationEnumerator.MoveNext() & prognosedContinuationEnumerator.MoveNext()) {
-              trainingMseCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              trainingMaeCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              trainingRelErrorCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              trainingRSquaredCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              trainingNmseCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-            }
-            if (actualContinuationEnumerator.MoveNext() | prognosedContinuationEnumerator.MoveNext())
-              throw new ArgumentException(
-                "Different number of elements in Actual continuation and prognosed continuation.");
+          var actualContinuation = ProblemData.Dataset.GetDoubleValues(targetVariable, Enumerable.Range(row, horizon)).ToList();
+          var prognosedContinuation = GetPrognosedValues(new List<int> { row }, horizon).First().ToList();
+
+          int maWindow = 10 * horizon;
+          var movingAverageContinuation = from h in Enumerable.Range(0, horizon)
+                                          select (from r in Enumerable.Range(row + h - maWindow, maWindow - h)
+                                                  where r > 0
+                                                  select ProblemData.Dataset.GetDoubleValue(targetVariable, r)
+                                                 ).Average();
+
+          double startValue = ProblemData.Dataset.GetDoubleValue(targetVariable, row - 1);
+
+          trainingDsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
+          trainingWdsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
+          trainingTheilsULastCalculators.Add(startValue, actualContinuation, prognosedContinuation);
+          trainingTheilsUMeanCalculators.Add(startValue, actualContinuation.Select(x => mean), actualContinuation, prognosedContinuation);
+          trainingTheilsUMovingAverageCalculators.Add(startValue, movingAverageContinuation, actualContinuation, prognosedContinuation);
+
+          var actualContinuationEnumerator = actualContinuation.GetEnumerator();
+          var prognosedContinuationEnumerator = prognosedContinuation.GetEnumerator();
+
+          while (actualContinuationEnumerator.MoveNext() & prognosedContinuationEnumerator.MoveNext()) {
+            trainingMseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            trainingMaeCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            trainingRelErrorCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            trainingRSquaredCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            trainingNmseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
           }
+          if (actualContinuationEnumerator.MoveNext() | prognosedContinuationEnumerator.MoveNext())
+            throw new ArgumentException("Different number of elements in Actual continuation and prognosed continuation.");
         }
       }
-      var allPrognosedTestValues = GetPrognosedValues(ProblemData.TestIndizes, horizon).ToArray().AsEnumerable().GetEnumerator();
+
+      mean = ProblemData.Dataset.GetDoubleValues(targetVariable, ProblemData.TestIndizes).Average();
       foreach (var row in ProblemData.TestIndizes) {
         if (row + horizon < ProblemData.Dataset.Rows) {
-          allPrognosedTestValues.MoveNext();
-          var prognosedTestValues = allPrognosedTestValues.Current.SelectMany(x => x);
-          for (int t = 0; t < targetVariables.Length; t++) {
-            var actualContinuation = ProblemData.Dataset.GetDoubleValues(targetVariables[t],
-                                                                         Enumerable.Range(row, horizon));
-            int maWindow = 10 * horizon;
-            var movingAverageContinuation = from h in Enumerable.Range(0, horizon)
-                                            select (from r in Enumerable.Range(row + h - maWindow, maWindow - h)
-                                                    where r > 0
-                                                    select ProblemData.Dataset.GetDoubleValue(targetVariables[t], r)
-                                                   ).Average();
-            double startValue = ProblemData.Dataset.GetDoubleValue(targetVariables[t], row - 1);
-            var prognosedContinuation = prognosedTestValues.Skip(t).TakeEvery(targetVariables.Length).ToArray();
-            testDsCalculators[t].Add(startValue, actualContinuation, prognosedContinuation);
-            testWdsCalculators[t].Add(startValue, actualContinuation, prognosedContinuation);
-            testTheilsULastCalculators[t].Add(startValue, actualContinuation, prognosedContinuation);
-            testTheilsUMeanCalculators[t].Add(startValue, actualContinuation.Select(x => mean[t]), actualContinuation, prognosedContinuation);
-            testTheilsUMovingAverageCalculators[t].Add(startValue, movingAverageContinuation, actualContinuation, prognosedContinuation);
-
-            var actualContinuationEnumerator = actualContinuation.GetEnumerator();
-            var prognosedContinuationEnumerator = prognosedContinuation.AsEnumerable().GetEnumerator();
-            while (actualContinuationEnumerator.MoveNext() & prognosedContinuationEnumerator.MoveNext()) {
-              testMseCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              testMaeCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              testRelErrorCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              testRSquaredCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-              testNmseCalculators[t].Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
-            }
-            if (actualContinuationEnumerator.MoveNext() | prognosedContinuationEnumerator.MoveNext())
-              throw new ArgumentException(
-                "Different number of elements in Actual continuation and prognosed continuation.");
+          var actualContinuation = ProblemData.Dataset.GetDoubleValues(targetVariable, Enumerable.Range(row, horizon)).ToList();
+          var prognosedContinuation = GetPrognosedValues(new List<int> { row }, horizon).First().ToList();
+
+          int maWindow = 10 * horizon;
+          var movingAverageContinuation = from h in Enumerable.Range(0, horizon)
+                                          select (from r in Enumerable.Range(row + h - maWindow, maWindow - h)
+                                                  where r > 0
+                                                  select ProblemData.Dataset.GetDoubleValue(targetVariable, r)
+                                                 ).Average();
+
+          double startValue = ProblemData.Dataset.GetDoubleValue(targetVariable, row - 1);
+          testDsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
+          testWdsCalculators.Add(startValue, actualContinuation, prognosedContinuation);
+          testTheilsULastCalculators.Add(startValue, actualContinuation, prognosedContinuation);
+          testTheilsUMeanCalculators.Add(startValue, actualContinuation.Select(x => mean), actualContinuation, prognosedContinuation);
+          testTheilsUMovingAverageCalculators.Add(startValue, movingAverageContinuation, actualContinuation, prognosedContinuation);
+
+          var actualContinuationEnumerator = actualContinuation.GetEnumerator();
+          var prognosedContinuationEnumerator = prognosedContinuation.GetEnumerator();
+          while (actualContinuationEnumerator.MoveNext() & prognosedContinuationEnumerator.MoveNext()) {
+            testMseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            testMaeCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            testRelErrorCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            testRSquaredCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
+            testNmseCalculators.Add(actualContinuationEnumerator.Current, prognosedContinuationEnumerator.Current);
           }
+          if (actualContinuationEnumerator.MoveNext() | prognosedContinuationEnumerator.MoveNext())
+            throw new ArgumentException("Different number of elements in Actual continuation and prognosed continuation.");
         }
       }
 
-
-      TrainingMeanSquaredError = trainingMseCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestMeanSquaredError = testMseCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TrainingMeanAbsoluteError = trainingMaeCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestMeanAbsoluteError = testMaeCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TrainingRelativeError = trainingRelErrorCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestRelativeError = testRelErrorCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TrainingRSquared = trainingRSquaredCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : 0.0)
-        .ToArray();
-      TestRSquared = testRSquaredCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : 0.0)
-        .ToArray();
-      TrainingNormalizedMeanSquaredError = trainingNmseCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestNormalizedMeanSquaredError = testNmseCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-
-      TrainingDirectionalSymmetry = trainingDsCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : 0.0)
-        .ToArray();
-      TestDirectionalSymmetry = testDsCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : 0.0)
-        .ToArray();
-      TrainingWeightedDirectionalSymmetry = trainingWdsCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestWeightedDirectionalSymmetry = testWdsCalculators.Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TrainingTheilsUStatisticLast = trainingTheilsULastCalculators
-        .Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestTheilsUStatisticLast = testTheilsULastCalculators
-        .Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TrainingTheilsUStatisticMean = trainingTheilsUMeanCalculators
-        .Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestTheilsUStatisticMean = testTheilsUMeanCalculators
-        .Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TrainingTheilsUStatisticMovingAverage = trainingTheilsUMovingAverageCalculators
-        .Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
-      TestTheilsUStatisticMovingAverage = testTheilsUMovingAverageCalculators
-        .Select(c => c.ErrorState == OnlineCalculatorError.None ? c.Value : double.PositiveInfinity)
-        .ToArray();
+      TrainingMeanSquaredError = trainingMseCalculators.ErrorState == OnlineCalculatorError.None ? trainingMseCalculators.Value : double.PositiveInfinity;
+      TestMeanSquaredError = testMseCalculators.ErrorState == OnlineCalculatorError.None ? testMseCalculators.Value : double.PositiveInfinity;
+      TrainingMeanAbsoluteError = trainingMaeCalculators.ErrorState == OnlineCalculatorError.None ? trainingMaeCalculators.Value : double.PositiveInfinity;
+      TestMeanAbsoluteError = testMaeCalculators.ErrorState == OnlineCalculatorError.None ? testMaeCalculators.Value : double.PositiveInfinity;
+      TrainingRelativeError = trainingRelErrorCalculators.ErrorState == OnlineCalculatorError.None ? trainingRelErrorCalculators.Value : double.PositiveInfinity;
+      TestRelativeError = testRelErrorCalculators.ErrorState == OnlineCalculatorError.None ? testRelErrorCalculators.Value : double.PositiveInfinity;
+      TrainingRSquared = trainingRSquaredCalculators.ErrorState == OnlineCalculatorError.None ? trainingRSquaredCalculators.Value : 0.0;
+      TestRSquared = testRSquaredCalculators.ErrorState == OnlineCalculatorError.None ? testRSquaredCalculators.Value : 0.0;
+      TrainingNormalizedMeanSquaredError = trainingNmseCalculators.ErrorState == OnlineCalculatorError.None ? trainingNmseCalculators.Value : double.PositiveInfinity;
+      TestNormalizedMeanSquaredError = testNmseCalculators.ErrorState == OnlineCalculatorError.None ? testNmseCalculators.Value : double.PositiveInfinity;
+
+      TrainingDirectionalSymmetry = trainingDsCalculators.ErrorState == OnlineCalculatorError.None ? trainingDsCalculators.Value : 0.0;
+      TestDirectionalSymmetry = testDsCalculators.ErrorState == OnlineCalculatorError.None ? testDsCalculators.Value : 0.0;
+      TrainingWeightedDirectionalSymmetry = trainingWdsCalculators.ErrorState == OnlineCalculatorError.None ? trainingWdsCalculators.Value : double.PositiveInfinity;
+      TestWeightedDirectionalSymmetry = testWdsCalculators.ErrorState == OnlineCalculatorError.None ? testWdsCalculators.Value : double.PositiveInfinity;
+      TrainingTheilsUStatisticLast = trainingTheilsULastCalculators.ErrorState == OnlineCalculatorError.None ? trainingTheilsULastCalculators.Value : double.PositiveInfinity;
+      TestTheilsUStatisticLast = testTheilsULastCalculators.ErrorState == OnlineCalculatorError.None ? testTheilsULastCalculators.Value : double.PositiveInfinity;
+      TrainingTheilsUStatisticMean = trainingTheilsUMeanCalculators.ErrorState == OnlineCalculatorError.None ? trainingTheilsUMeanCalculators.Value : double.PositiveInfinity;
+      TestTheilsUStatisticMean = testTheilsUMeanCalculators.ErrorState == OnlineCalculatorError.None ? testTheilsUMeanCalculators.Value : double.PositiveInfinity;
+      TrainingTheilsUStatisticMovingAverage = trainingTheilsUMovingAverageCalculators.ErrorState == OnlineCalculatorError.None ? trainingTheilsUMovingAverageCalculators.Value : double.PositiveInfinity;
+      TestTheilsUStatisticMovingAverage = testTheilsUMovingAverageCalculators.ErrorState == OnlineCalculatorError.None ? testTheilsUMovingAverageCalculators.Value : double.PositiveInfinity;
     }
   }
Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisModel.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisModel.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisModel.cs	(revision 7989)
@@ -23,5 +23,5 @@
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface ITimeSeriesPrognosisModel : IDataAnalysisModel {
-    IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, int horizon);
+    IEnumerable<IEnumerable<double>> GetPrognosedValues(Dataset dataset, IEnumerable<int> rows, int horizon);
     ITimeSeriesPrognosisSolution CreateTimeSeriesPrognosisSolution(ITimeSeriesPrognosisProblemData problemData);
   }
Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisProblemData.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisProblemData.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisProblemData.cs	(revision 7989)
@@ -20,8 +20,7 @@
 #endregion
 
-using System.Collections.Generic;
 namespace HeuristicLab.Problems.DataAnalysis {
   public interface ITimeSeriesPrognosisProblemData : IDataAnalysisProblemData {
-    IEnumerable<string> TargetVariables { get; }
+    string TargetVariable { get; }
   }
 }
Index: branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisSolution.cs
===================================================================
--- branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisSolution.cs	(revision 7886)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/ITimeSeriesPrognosisSolution.cs	(revision 7989)
@@ -27,26 +27,24 @@
     new ITimeSeriesPrognosisProblemData ProblemData { get; set; }
 
-    IEnumerable<IEnumerable<double>> PrognosedTrainingValues { get; }
-    IEnumerable<IEnumerable<double>> PrognosedTestValues { get; }
-    IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(IEnumerable<int> rows, int horizon);
+    IEnumerable<IEnumerable<double>> GetPrognosedValues(IEnumerable<int> rows, int horizon);
 
-    double[] TrainingMeanSquaredError { get; }
-    double[] TestMeanSquaredError { get; }
-    double[] TrainingMeanAbsoluteError { get; }
-    double[] TestMeanAbsoluteError { get; }
-    double[] TrainingRSquared { get; }
-    double[] TestRSquared { get; }
-    double[] TrainingRelativeError { get; }
-    double[] TestRelativeError { get; }
-    double[] TrainingNormalizedMeanSquaredError { get; }
-    double[] TestNormalizedMeanSquaredError { get; }
-    double[] TrainingTheilsUStatisticLast { get; }
-    double[] TestTheilsUStatisticLast { get; }
-    double[] TrainingTheilsUStatisticMean { get; }
-    double[] TestTheilsUStatisticMean { get; }
-    double[] TrainingDirectionalSymmetry { get; }
-    double[] TestDirectionalSymmetry { get; }
-    double[] TrainingWeightedDirectionalSymmetry { get; }
-    double[] TestWeightedDirectionalSymmetry { get; }
+    double TrainingMeanSquaredError { get; }
+    double TestMeanSquaredError { get; }
+    double TrainingMeanAbsoluteError { get; }
+    double TestMeanAbsoluteError { get; }
+    double TrainingRSquared { get; }
+    double TestRSquared { get; }
+    double TrainingRelativeError { get; }
+    double TestRelativeError { get; }
+    double TrainingNormalizedMeanSquaredError { get; }
+    double TestNormalizedMeanSquaredError { get; }
+    double TrainingTheilsUStatisticLast { get; }
+    double TestTheilsUStatisticLast { get; }
+    double TrainingTheilsUStatisticMean { get; }
+    double TestTheilsUStatisticMean { get; }
+    double TrainingDirectionalSymmetry { get; }
+    double TestDirectionalSymmetry { get; }
+    double TrainingWeightedDirectionalSymmetry { get; }
+    double TestWeightedDirectionalSymmetry { get; }
   }
 }
