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 7099)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisProblemData.cs	(revision 7100)
@@ -34,5 +34,5 @@
   [Item("TimeSeriesPrognosisProblemData", "Represents an item containing all data defining a time series prognosis problem.")]
   public class TimeSeriesPrognosisProblemData : DataAnalysisProblemData, ITimeSeriesPrognosisProblemData {
-    protected const string TargetVariableParameterName = "TargetVariable";
+    protected const string TargetVariablesParameterName = "TargetVariables";
 
     #region default data
@@ -1541,5 +1541,5 @@
     private static readonly Dataset defaultDataset;
     private static readonly IEnumerable<string> defaultAllowedInputVariables;
-    private static readonly string defaultTargetVariable;
+    private static readonly string[] defaultTargetVariables;
 
     private static readonly TimeSeriesPrognosisProblemData emptyProblemData;
@@ -1552,5 +1552,5 @@
       defaultDataset.Name = "Mackey-Glass (t=17) Time Series Benchmark Dataset";
       defaultAllowedInputVariables = new List<string>() { "x" };
-      defaultTargetVariable = "x";
+      defaultTargetVariables = new string[] { "x" };
 
       var problemData = new TimeSeriesPrognosisProblemData();
@@ -1564,14 +1564,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>(TargetVariableParameterName, new ItemSet<StringValue>()));
+      problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariablesParameterName, new ItemSet<StringValue>()));
       emptyProblemData = problemData;
     }
     #endregion
 
-    public ConstrainedValueParameter<StringValue> TargetVariableParameter {
-      get { return (ConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
+    public ValueParameter<CheckedItemList<StringValue>> TargetVariablesParameter {
+      get { return (ValueParameter<CheckedItemList<StringValue>>)Parameters[TargetVariablesParameterName]; }
     }
-    public string TargetVariable {
-      get { return TargetVariableParameter.Value.Value; }
+    public IEnumerable<string> TargetVariables {
+      get { return TargetVariablesParameter.Value.CheckedItems.Select(x => x.Value.Value); }
     }
 
@@ -1593,16 +1593,20 @@
 
     public TimeSeriesPrognosisProblemData()
-      : this(defaultDataset, defaultAllowedInputVariables, defaultTargetVariable) {
+      : this(defaultDataset, defaultAllowedInputVariables, defaultTargetVariables) {
     }
 
-    public TimeSeriesPrognosisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable)
+    public TimeSeriesPrognosisProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, IEnumerable<string> targetVariables)
       : base(dataset, allowedInputVariables) {
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
-      Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
+      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));
       RegisterParameterEvents();
     }
 
     private void RegisterParameterEvents() {
-      TargetVariableParameter.ValueChanged += TargetVariableParameter_ValueChanged;
+      TargetVariablesParameter.Value.CheckedItemsChanged += TargetVariableParameter_ValueChanged;
     }
 
@@ -1619,5 +1623,5 @@
       dataset.Name = Path.GetFileName(fileName);
 
-      TimeSeriesPrognosisProblemData problemData = new TimeSeriesPrognosisProblemData(dataset, dataset.DoubleVariables, dataset.DoubleVariables.First());
+      TimeSeriesPrognosisProblemData problemData = new TimeSeriesPrognosisProblemData(dataset, dataset.DoubleVariables, dataset.DoubleVariables.Take(1));
       problemData.Name = "Data imported from " + Path.GetFileName(fileName);
       return problemData;
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 7099)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolution.cs	(revision 7100)
@@ -47,15 +47,20 @@
     }
 
-    public override IEnumerable<double> PrognosedValues {
-      get { return GetPrognosedValues(Enumerable.Range(0, ProblemData.Dataset.Rows)); }
+    public override IEnumerable<IEnumerable<double>> PrognosedTrainingValues {
+      get {
+        return GetPrognosedValues(Enumerable.Range(ProblemData.TrainingPartition.Start, 1),
+          ProblemData.TrainingPartition.End - ProblemData.TrainingPartition.Start)
+          .First();
+      }
     }
-    public override IEnumerable<double> PrognosedTrainingValues {
-      get { return GetPrognosedValues(ProblemData.TrainingIndizes); }
+    public override IEnumerable<IEnumerable<double>> PrognosedTestValues {
+      get {
+        return GetPrognosedValues(Enumerable.Range(ProblemData.TestPartition.Start, 1),
+          ProblemData.TestPartition.End - ProblemData.TestPartition.Start)
+          .First();
+      }
     }
-    public override IEnumerable<double> PrognosedTestValues {
-      get { return GetPrognosedValues(ProblemData.TestIndizes); }
-    }
-    public override IEnumerable<double> GetPrognosedValues(IEnumerable<int> rows) {
-      return Model.GetPrognosedValues(ProblemData.Dataset, rows);
+    public override IEnumerable<IEnumerable<IEnumerable<double>>> GetPrognosedValues(IEnumerable<int> rows, int horizon) {
+      return Model.GetPrognosedValues(ProblemData.Dataset, rows, horizon);
     }
 
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 7099)
+++ branches/HeuristicLab.TimeSeries/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/TimeSeriesPrognosis/TimeSeriesPrognosisSolutionBase.cs	(revision 7100)
@@ -20,4 +20,5 @@
 #endregion
 
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
@@ -57,73 +58,72 @@
     }
 
-    public abstract IEnumerable<double> PrognosedValues { get; }
-    public abstract IEnumerable<double> PrognosedTrainingValues { get; }
-    public abstract IEnumerable<double> PrognosedTestValues { get; }
-    public abstract IEnumerable<double> GetPrognosedValues(IEnumerable<int> rows);
+    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);
 
     #region Results
-    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 TrainingTheilsUStatistic {
-      get { return ((DoubleValue)this[TrainingTheilsUStatisticResultName].Value).Value; }
-      private set { ((DoubleValue)this[TrainingTheilsUStatisticResultName].Value).Value = value; }
-    }
-    public double TestTheilsUStatistic {
-      get { return ((DoubleValue)this[TestTheilsUStatisticResultName].Value).Value; }
-      private set { ((DoubleValue)this[TestTheilsUStatisticResultName].Value).Value = value; }
+    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[] TrainingTheilsUStatistic {
+      get { return ((DoubleArray)this[TrainingTheilsUStatisticResultName].Value).ToArray(); }
+      private set { this[TrainingTheilsUStatisticResultName].Value = new DoubleArray(value); }
+    }
+    public double[] TestTheilsUStatistic {
+      get { return ((DoubleArray)this[TestTheilsUStatisticResultName].Value).ToArray(); }
+      private set { this[TestTheilsUStatisticResultName].Value = new DoubleArray(value); }
     }
     #endregion
@@ -136,20 +136,20 @@
     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 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 PercentValue()));
-      Add(new Result(TestRelativeErrorResultName, "Average of the relative errors of the model output and the actual values on the test partition", new PercentValue()));
-      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 PercentValue()));
-      Add(new Result(TestDirectionalSymmetryResultName, "The average directional symmetry of the forecasts of the model on the test partition", new PercentValue()));
-      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(TrainingTheilsUStatisticResultName, "The average Theil's U statistic of the forecasts of the model on the training partition", new DoubleValue()));
-      Add(new Result(TestTheilsUStatisticResultName, "The average Theil's U statistic of the forecasts of the model on the test partition", new DoubleValue()));
+      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(TrainingTheilsUStatisticResultName, "The average Theil's U statistic of the forecasts of the model on the training partition", new DoubleArray()));
+      Add(new Result(TestTheilsUStatisticResultName, "The average Theil's U statistic of the forecasts of the model on the test partition", new DoubleArray()));
     }
 
@@ -160,4 +160,6 @@
 
     protected void CalculateResults() {
+      OnlineCalculatorError errorState;
+      /*
       double[] estimatedTrainingValues = PrognosedTrainingValues.ToArray(); // cache values
       double[] originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToArray();
@@ -165,5 +167,4 @@
       double[] originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes).ToArray();
 
-      OnlineCalculatorError errorState;
       double trainingMse = OnlineMeanSquaredErrorCalculator.Calculate(originalTrainingValues, estimatedTrainingValues, out errorState);
       TrainingMeanSquaredError = errorState == OnlineCalculatorError.None ? trainingMse : double.NaN;
@@ -190,35 +191,69 @@
       double testNmse = OnlineNormalizedMeanSquaredErrorCalculator.Calculate(originalTestValues, estimatedTestValues, out errorState);
       TestNormalizedMeanSquaredError = errorState == OnlineCalculatorError.None ? testNmse : double.NaN;
-
-      var startTrainingValues = originalTrainingValues;
-      // each continuation is only one element long
-      var actualContinuationsTraining = from x in originalTrainingValues.Skip(1)
-                                        select Enumerable.Repeat(x, 1);
-      // each forecast is only one elemnt long
-      // disregards the first estimated value (we could include this again by extending the list of original values by one step to the left
-      // this is the easier way
-      var predictedContinuationsTraining = from x in estimatedTrainingValues.Skip(1)
-                                           select Enumerable.Repeat(x, 1);
-
-      var startTestValues = originalTestValues;
-      var actualContinuationsTest = from x in originalTestValues.Skip(1)
-                                    select Enumerable.Repeat(x, 1);
-      var predictedContinuationsTest = from x in estimatedTestValues.Skip(1)
-                                       select Enumerable.Repeat(x, 1);
-
-      double trainingDirectionalSymmetry = OnlineDirectionalSymmetryCalculator.Calculate(startTrainingValues, actualContinuationsTraining, predictedContinuationsTraining, out errorState);
-      TrainingDirectionalSymmetry = errorState == OnlineCalculatorError.None ? trainingDirectionalSymmetry : double.NaN;
-      double testDirectionalSymmetry = OnlineDirectionalSymmetryCalculator.Calculate(startTestValues, actualContinuationsTest, predictedContinuationsTest, out errorState);
-      TestDirectionalSymmetry = errorState == OnlineCalculatorError.None ? testDirectionalSymmetry : double.NaN;
-
-      double trainingWeightedDirectionalSymmetry = OnlineWeightedDirectionalSymmetryCalculator.Calculate(startTrainingValues, actualContinuationsTraining, predictedContinuationsTraining, out errorState);
-      TrainingWeightedDirectionalSymmetry = errorState == OnlineCalculatorError.None ? trainingWeightedDirectionalSymmetry : double.NaN;
-      double testWeightedDirectionalSymmetry = OnlineWeightedDirectionalSymmetryCalculator.Calculate(startTestValues, actualContinuationsTest, predictedContinuationsTest, out errorState);
-      TestWeightedDirectionalSymmetry = errorState == OnlineCalculatorError.None ? testWeightedDirectionalSymmetry : double.NaN;
-
-      double trainingTheilsU = OnlineTheilsUStatisticCalculator.Calculate(startTrainingValues, actualContinuationsTraining, predictedContinuationsTraining, out errorState);
-      TrainingTheilsUStatistic = errorState == OnlineCalculatorError.None ? trainingTheilsU : double.NaN;
-      double testTheilsU = OnlineTheilsUStatisticCalculator.Calculate(startTestValues, actualContinuationsTest, predictedContinuationsTest, out errorState);
-      TestTheilsUStatistic = errorState == OnlineCalculatorError.None ? testTheilsU : double.NaN;
+              */
+
+      double[] trainingDs = new double[ProblemData.TargetVariables.Count()];
+      double[] testDs = new double[ProblemData.TargetVariables.Count()];
+
+      double[] trainingWds = new double[ProblemData.TargetVariables.Count()];
+      double[] testWds = new double[ProblemData.TargetVariables.Count()];
+
+      double[] trainingTheilsU = new double[ProblemData.TargetVariables.Count()];
+      double[] testTheilsU = new double[ProblemData.TargetVariables.Count()];
+      int i = 0;
+      var predictedContinuationTraining = PrognosedTrainingValues.ToArray();
+      var predictedContinuationTest = PrognosedTestValues.ToArray();
+
+      foreach (var targetVariable in ProblemData.TargetVariables) {
+        var actualTrainingValues = ProblemData.Dataset.GetDoubleValues(targetVariable, ProblemData.TrainingIndizes).ToArray();
+        var startTrainingValues = actualTrainingValues.Take(1);
+        // only one continuation (but the full training set)
+        var actualContinuationTraining = actualTrainingValues.Skip(1);
+
+        var actualTestValues = ProblemData.Dataset.GetDoubleValues(targetVariable, ProblemData.TestIndizes).ToArray();
+        var startTestValues = actualTestValues.Take(1);
+        // only one continuation (but the full training set)
+        var actualContinuationTest = actualTestValues.Skip(1);
+
+
+        trainingDs[i] = OnlineDirectionalSymmetryCalculator.Calculate(startTrainingValues,
+          Enumerable.Repeat(actualContinuationTraining, 1),
+          Enumerable.Repeat(predictedContinuationTraining[i], 1), out errorState);
+        if (errorState != OnlineCalculatorError.None) trainingDs[i] = double.NaN;
+
+        testDs[i] = OnlineDirectionalSymmetryCalculator.Calculate(startTestValues,
+          Enumerable.Repeat(actualContinuationTest, 1),
+          Enumerable.Repeat(predictedContinuationTest[i], 1), out errorState);
+        if (errorState != OnlineCalculatorError.None) testDs[i] = double.NaN;
+
+        trainingWds[i] =
+          OnlineWeightedDirectionalSymmetryCalculator.Calculate(startTrainingValues,
+          Enumerable.Repeat(actualContinuationTraining, 1),
+          Enumerable.Repeat(predictedContinuationTraining[i], 1), out errorState);
+        if (errorState != OnlineCalculatorError.None) trainingWds[i] = double.NaN;
+
+        testWds[i] = OnlineWeightedDirectionalSymmetryCalculator.Calculate(startTestValues,
+          Enumerable.Repeat(actualContinuationTest, 1),
+          Enumerable.Repeat(predictedContinuationTest[i], 1), out errorState);
+        if (errorState != OnlineCalculatorError.None) testWds[i] = double.NaN;
+
+        trainingTheilsU[i] = OnlineTheilsUStatisticCalculator.Calculate(startTrainingValues,
+          Enumerable.Repeat(actualContinuationTraining, 1),
+          Enumerable.Repeat(predictedContinuationTraining[i], 1), out errorState);
+        if (errorState != OnlineCalculatorError.None) trainingTheilsU[i] = double.NaN;
+
+        testTheilsU[i] = OnlineTheilsUStatisticCalculator.Calculate(startTestValues,
+          Enumerable.Repeat(actualContinuationTest, 1),
+          Enumerable.Repeat(predictedContinuationTest[i], 1), out errorState);
+        if (errorState != OnlineCalculatorError.None) testTheilsU[i] = double.NaN;
+        i++;
+      }
+
+      TrainingDirectionalSymmetry = trainingDs;
+      TestDirectionalSymmetry = testDs;
+      TrainingWeightedDirectionalSymmetry = trainingWds;
+      TestWeightedDirectionalSymmetry = testWds;
+      TrainingTheilsUStatistic = trainingTheilsU;
+      TestTheilsUStatistic = testTheilsU;
     }
   }
