Changeset 712

Timestamp:

11/05/08 21:34:12 (15 years ago)

Author:

gkronber

Message:

fixed a stupid mistake introduced with r702 #328 (GP evaluation doesn't work in a thread parallel engine).

Location:

trunk/sources

Files:

• HeuristicLab.GP.StructureIdentification.Classification/AccuracyEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification.Classification/ClassificationMeanSquaredErrorEvaluator.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification.Classification/ConfusionMatrixEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification.Classification/MulticlassModeller.cs (modified) (4 diffs)
• HeuristicLab.GP.StructureIdentification.TimeSeries/AveragePercentageChangeEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification.TimeSeries/ProfitEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification.TimeSeries/TheilInequalityCoefficientEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/CoefficientOfDeterminationEvaluator.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/EarlyStoppingMeanSquaredErrorEvaluator.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/GPEvaluatorBase.cs (modified) (3 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/MeanAbsolutePercentageErrorEvaluator.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/MeanSquaredErrorEvaluator.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/SimpleEvaluator.cs (modified) (2 diffs)
• HeuristicLab.GP.StructureIdentification/Evaluators/VarianceAccountedForEvaluator.cs (modified) (2 diffs)

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/AccuracyEvaluator.cs

@@ -45 +45 @@
     public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, double[] classes, double[] thresholds, int start, int end) {
       DoubleData accuracy = GetVariableValue<DoubleData>("Accuracy", scope, false, false);
-      if(accuracy == null) {
+      if (accuracy == null) {
         accuracy = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Accuracy"), accuracy));
@@ -52 +52 @@
       int nSamples = end - start;
       int nCorrect = 0;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double est = evaluator.Evaluate(sample);
-        double origClass = dataset.GetValue(targetVariable, sample);
+        double origClass = dataset.GetValue(sample, targetVariable);
         double estClass = double.NaN;
         // if estimation is lower than the smallest threshold value -> estimated class is the lower class
-        if(est < thresholds[0]) estClass = classes[0];
+        if (est < thresholds[0]) estClass = classes[0];
         // if estimation is larger (or equal) than the largest threshold value -> estimated class is the upper class
-        else if(est >= thresholds[thresholds.Length - 1]) estClass = classes[classes.Length - 1];
+        else if (est >= thresholds[thresholds.Length - 1]) estClass = classes[classes.Length - 1];
         else {
           // otherwise the estimated class is the class which upper threshold is larger than the estimated value
-          for(int k = 0; k < thresholds.Length; k++) {
-            if(thresholds[k] > est) {
+          for (int k = 0; k < thresholds.Length; k++) {
+            if (thresholds[k] > est) {
               estClass = classes[k];
               break;
@@ -69 +69 @@
           }
         }
-        if(Math.Abs(estClass - origClass) < EPSILON) nCorrect++;
+        if (Math.Abs(estClass - origClass) < EPSILON) nCorrect++;
       }
       accuracy.Data = nCorrect / (double)nSamples;

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/ClassificationMeanSquaredErrorEvaluator.cs

@@ -43 +43 @@
     }
 
-    public override void  Evaluate(IScope scope, BakedTreeEvaluator evaluator, HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable, double[] classes, double[] thresholds, int start, int end)
-{
+    public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable, double[] classes, double[] thresholds, int start, int end) {
       double errorsSquaredSum = 0;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double estimated = evaluator.Evaluate(sample);
-        double original = dataset.GetValue(targetVariable, sample);
-        if(!double.IsNaN(original) && !double.IsInfinity(original)) {
+        double original = dataset.GetValue(sample, targetVariable);
+        if (!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
           // between classes use squared error
           // on the lower end and upper end only add linear error if the absolute error is larger than 1
           // the error>1.0 constraint is needed for balance because in the interval ]-1, 1[ the squared error is smaller than the absolute error
-          if((IsEqual(original, classes[0]) && error < -1.0) ||
+          if ((IsEqual(original, classes[0]) && error < -1.0) ||
             (IsEqual(original, classes[classes.Length - 1]) && error > 1.0)) {
             errorsSquaredSum += Math.Abs(error); // only add linear error below the smallest class or above the largest class
@@ -64 +63 @@
 
       errorsSquaredSum /= (end - start);
-      if(double.IsNaN(errorsSquaredSum) || double.IsInfinity(errorsSquaredSum)) {
+      if (double.IsNaN(errorsSquaredSum) || double.IsInfinity(errorsSquaredSum)) {
         errorsSquaredSum = double.MaxValue;
       }
 
       DoubleData mse = GetVariableValue<DoubleData>("MSE", scope, false, false);
-      if(mse == null) {
+      if (mse == null) {
         mse = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MSE"), mse));

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/ConfusionMatrixEvaluator.cs

@@ -43 +43 @@
     public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, HeuristicLab.DataAnalysis.Dataset dataset, int targetVariable, double[] classes, double[] thresholds, int start, int end) {
       IntMatrixData matrix = GetVariableValue<IntMatrixData>("ConfusionMatrix", scope, false, false);
-      if(matrix == null) {
+      if (matrix == null) {
         matrix = new IntMatrixData(new int[classes.Length, classes.Length]);
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("ConfusionMatrix"), matrix));
@@ -49 +49 @@
 
       int nSamples = end - start;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double est = evaluator.Evaluate(sample);
-        double origClass = dataset.GetValue(targetVariable,sample);
+        double origClass = dataset.GetValue(sample, targetVariable);
         int estClassIndex = -1;
         // if estimation is lower than the smallest threshold value -> estimated class is the lower class
-        if(est < thresholds[0]) estClassIndex = 0;
+        if (est < thresholds[0]) estClassIndex = 0;
         // if estimation is larger (or equal) than the largest threshold value -> estimated class is the upper class
-        else if(est >= thresholds[thresholds.Length - 1]) estClassIndex = classes.Length - 1;
+        else if (est >= thresholds[thresholds.Length - 1]) estClassIndex = classes.Length - 1;
         else {
           // otherwise the estimated class is the class which upper threshold is larger than the estimated value
-          for(int k = 0; k < thresholds.Length; k++) {
-            if(thresholds[k] > est) {
+          for (int k = 0; k < thresholds.Length; k++) {
+            if (thresholds[k] > est) {
               estClassIndex = k;
               break;
@@ -68 +68 @@
 
         // find the first threshold index that is larger to the original value
-        int origClassIndex = classes.Length-1;
-        for(int i = 0; i < thresholds.Length; i++) {
-          if(origClass < thresholds[i]) {
+        int origClassIndex = classes.Length - 1;
+        for (int i = 0; i < thresholds.Length; i++) {
+          if (origClass < thresholds[i]) {
             origClassIndex = i;
             break;

trunk/sources/HeuristicLab.GP.StructureIdentification.Classification/MulticlassModeller.cs

@@ -69 +69 @@
       binaryClassValues.Add(new DoubleData(0.0));
       binaryClassValues.Add(new DoubleData(1.0));
-      for(int i = 0; i < classValues.Count-1; i++) {
-        for(int j = i+1; j < classValues.Count; j++) {
+      for (int i = 0; i < classValues.Count - 1; i++) {
+        for (int j = i + 1; j < classValues.Count; j++) {
           Dataset dataset = new Dataset();
           dataset.Columns = origDataset.Columns;
@@ -82 +82 @@
           trainingSamplesStart = 0;
           List<double[]> rows = new List<double[]>();
-          for(int k = origTrainingSamplesStart; k < origTrainingSamplesEnd; k++) {
+          for (int k = origTrainingSamplesStart; k < origTrainingSamplesEnd; k++) {
             double[] row = new double[dataset.Columns];
             double targetValue = origDataset.GetValue(k, targetVariable);
-            if(IsEqual(targetValue, classAValue)) {
-              for(int l = 0; l < row.Length; l++) {
+            if (IsEqual(targetValue, classAValue)) {
+              for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
               }
               row[targetVariable] = 0;
               rows.Add(row);
-            } else if(IsEqual(targetValue, classBValue)) {
-              for(int l = 0; l < row.Length; l++) {
+            } else if (IsEqual(targetValue, classBValue)) {
+              for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
               }
@@ -101 +101 @@
           trainingSamplesEnd = rows.Count;
           validationSamplesStart = rows.Count;
-          for(int k = origValidationSamplesStart; k < origValidationSamplesEnd; k++) {
+          for (int k = origValidationSamplesStart; k < origValidationSamplesEnd; k++) {
             double[] row = new double[dataset.Columns];
             double targetValue = origDataset.GetValue(k, targetVariable);
-            if(IsEqual(targetValue, classAValue)) {
-              for(int l = 0; l < row.Length; l++) {
+            if (IsEqual(targetValue, classAValue)) {
+              for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
               }
               row[targetVariable] = 0;
               rows.Add(row);
-            } else if(IsEqual(targetValue, classBValue)) {
-              for(int l = 0; l < row.Length; l++) {
+            } else if (IsEqual(targetValue, classBValue)) {
+              for (int l = 0; l < row.Length; l++) {
                 row[l] = origDataset.GetValue(k, l);
               }
@@ -122 +122 @@
           dataset.Rows = rows.Count;
           dataset.Samples = new double[dataset.Rows * dataset.Columns];
-          for(int k = 0; k < dataset.Rows; k++) {
-            for(int l = 0; l < dataset.Columns; l++) {
+          for (int k = 0; k < dataset.Rows; k++) {
+            for (int l = 0; l < dataset.Columns; l++) {
               dataset.SetValue(k, l, rows[k][l]);
             }
           }
 
-          Scope childScope = new Scope(classAValue+" vs. "+classBValue);
+          Scope childScope = new Scope(classAValue + " vs. " + classBValue);
 
           childScope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName(TARGETCLASSVALUES), binaryClassValues));

trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/AveragePercentageChangeEvaluator.cs

@@ -45 +45 @@
       bool differential = GetVariableValue<BoolData>("Differential", scope, true).Data;
       DoubleData apc = GetVariableValue<DoubleData>("APC", scope, false, false);
-      if(apc == null) {
+      if (apc == null) {
         apc = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("APC"), apc));
@@ -51 +51 @@
 
       double percentageSum = 0;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double prevOriginal;
         double originalPercentageChange;
         double estimatedPercentageChange;
-        if(differential) {
-          prevOriginal = dataset.GetValue(targetVariable,sample - 1);
-          originalPercentageChange = (dataset.GetValue(targetVariable,sample) - prevOriginal) / prevOriginal;
+        if (differential) {
+          prevOriginal = dataset.GetValue(sample - 1, targetVariable);
+          originalPercentageChange = (dataset.GetValue(sample, targetVariable) - prevOriginal) / prevOriginal;
           estimatedPercentageChange = (evaluator.Evaluate(sample) - prevOriginal) / prevOriginal;
-          if(updateTargetValues) {
-            dataset.SetValue(targetVariable, sample, estimatedPercentageChange * prevOriginal + prevOriginal);
+          if (updateTargetValues) {
+            dataset.SetValue(sample, targetVariable, estimatedPercentageChange * prevOriginal + prevOriginal);
           }
         } else {
-          originalPercentageChange = dataset.GetValue(targetVariable,sample);
+          originalPercentageChange = dataset.GetValue(sample, targetVariable);
           estimatedPercentageChange = evaluator.Evaluate(sample);
-          if(updateTargetValues) {
-            dataset.SetValue(targetVariable, sample, estimatedPercentageChange);
+          if (updateTargetValues) {
+            dataset.SetValue(sample, targetVariable, estimatedPercentageChange);
           }
         }
-        if(!double.IsNaN(originalPercentageChange) && !double.IsInfinity(originalPercentageChange)) {
-          if((estimatedPercentageChange > 0 && originalPercentageChange > 0) ||
+        if (!double.IsNaN(originalPercentageChange) && !double.IsInfinity(originalPercentageChange)) {
+          if ((estimatedPercentageChange > 0 && originalPercentageChange > 0) ||
             (estimatedPercentageChange < 0 && originalPercentageChange < 0)) {
             percentageSum += Math.Abs(originalPercentageChange);
-          } else if((estimatedPercentageChange > 0 && originalPercentageChange < 0) ||
+          } else if ((estimatedPercentageChange > 0 && originalPercentageChange < 0) ||
             (estimatedPercentageChange < 0 && originalPercentageChange > 0)) {
             percentageSum -= Math.Abs(originalPercentageChange);
@@ -81 +81 @@
 
       percentageSum /= (end - start);
-      if(double.IsNaN(percentageSum) || double.IsInfinity(percentageSum)) {
+      if (double.IsNaN(percentageSum) || double.IsInfinity(percentageSum)) {
         percentageSum = double.MinValue;
       }

trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/ProfitEvaluator.cs

@@ -47 +47 @@
       double transactionCost = GetVariableValue<DoubleData>("TransactionCost", scope, true).Data;
       DoubleData profit = GetVariableValue<DoubleData>("Profit", scope, false, false);
-      if(profit == null) {
+      if (profit == null) {
         profit = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("Profit"), profit));
@@ -55 +55 @@
       double cB = 0;
       double exchangeRate = double.MaxValue;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         exchangeRate = dataset.GetValue(sample, exchangeRateVarIndex);
-        double originalPercentageChange = dataset.GetValue(targetVariable, sample);
+        double originalPercentageChange = dataset.GetValue(sample, targetVariable);
         double estimatedPercentageChange = evaluator.Evaluate(sample);
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimatedPercentageChange);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimatedPercentageChange);
         }
-        if(!double.IsNaN(originalPercentageChange) && !double.IsInfinity(originalPercentageChange)) {
-          if(estimatedPercentageChange > 0) {
+        if (!double.IsNaN(originalPercentageChange) && !double.IsInfinity(originalPercentageChange)) {
+          if (estimatedPercentageChange > 0) {
             // prediction is the rate of B/A will increase (= get more B for one A) => exchange all B to A
             cA += (cB / exchangeRate) * (1 - transactionCost);
             cB = 0;
-          } else if(estimatedPercentageChange < 0) {
+          } else if (estimatedPercentageChange < 0) {
             // prediction is the rate of B/A will drop (= get more A for one B) => exchange all A to B
             cB += (cA * exchangeRate) * (1 - transactionCost);
@@ -75 +75 @@
       }
 
-      if(double.IsNaN(cA) || double.IsInfinity(cA) || double.IsInfinity(cB) || double.IsNaN(cB)) {
+      if (double.IsNaN(cA) || double.IsInfinity(cA) || double.IsInfinity(cB) || double.IsNaN(cB)) {
         cA = 0;
         cB = 0;

trunk/sources/HeuristicLab.GP.StructureIdentification.TimeSeries/TheilInequalityCoefficientEvaluator.cs

@@ -55 +55 @@
 
     public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
-    #region create result variables
+      #region create result variables
       DoubleData theilInequaliy = GetVariableValue<DoubleData>("TheilInequalityCoefficient", scope, false, false);
-      if(theilInequaliy == null) {
+      if (theilInequaliy == null) {
         theilInequaliy = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficient"), theilInequaliy));
       }
       DoubleData uBias = GetVariableValue<DoubleData>("TheilInequalityCoefficientBias", scope, false, false);
-      if(uBias == null) {
+      if (uBias == null) {
         uBias = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficientBias"), uBias));
       }
       DoubleData uVariance = GetVariableValue<DoubleData>("TheilInequalityCoefficientVariance", scope, false, false);
-      if(uVariance == null) {
+      if (uVariance == null) {
         uVariance = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficientVariance"), uVariance));
       }
       DoubleData uCovariance = GetVariableValue<DoubleData>("TheilInequalityCoefficientCovariance", scope, false, false);
-      if(uCovariance == null) {
+      if (uCovariance == null) {
         uCovariance = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("TheilInequalityCoefficientCovariance"), uCovariance));
@@ -83 +83 @@
       double[] originalChanges = new double[end - start];
       int nSamples = 0;
-      for(int sample = start; sample < end; sample++) {
-        double prevValue = dataset.GetValue(targetVariable, sample - 1);
+      for (int sample = start; sample < end; sample++) {
+        double prevValue = dataset.GetValue(sample - 1, targetVariable);
         double estimatedChange = evaluator.Evaluate(sample) - prevValue;
-        double originalChange = dataset.GetValue(targetVariable, sample) - prevValue;
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimatedChange + prevValue);
+        double originalChange = dataset.GetValue(sample, targetVariable) - prevValue;
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimatedChange + prevValue);
         }
-        if(!double.IsNaN(originalChange) && !double.IsInfinity(originalChange)) {
+        if (!double.IsNaN(originalChange) && !double.IsInfinity(originalChange)) {
           double error = estimatedChange - originalChange;
           errorsSquaredSum += error * error;
@@ -100 +100 @@
       }
       double quality = Math.Sqrt(errorsSquaredSum / nSamples) / Math.Sqrt(originalSquaredSum / nSamples);
-      if(double.IsNaN(quality) || double.IsInfinity(quality))
+      if (double.IsNaN(quality) || double.IsInfinity(quality))
         quality = double.MaxValue;
       theilInequaliy.Data = quality; // U2

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/CoefficientOfDeterminationEvaluator.cs

@@ -46 +46 @@
       double originalDeviationTotalSumOfSquares = 0.0;
       double targetMean = dataset.GetMean(targetVariable, start, end);
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double estimated = evaluator.Evaluate(sample);
-        double original = dataset.GetValue(targetVariable, sample);
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimated);
+        double original = dataset.GetValue(sample, targetVariable);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimated);
         }
-        if(!double.IsNaN(original) && !double.IsInfinity(original)) {
+        if (!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
           errorsSquaredSum += error * error;
@@ -62 +62 @@
 
       double quality = 1 - errorsSquaredSum / originalDeviationTotalSumOfSquares;
-      if(quality > 1)
+      if (quality > 1)
         throw new InvalidProgramException();
-      if(double.IsNaN(quality) || double.IsInfinity(quality))
+      if (double.IsNaN(quality) || double.IsInfinity(quality))
         quality = double.MaxValue;
 
       DoubleData r2 = GetVariableValue<DoubleData>("R2", scope, false, false);
-      if(r2 == null) {
+      if (r2 == null) {
         r2 = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("R2"), r2));

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/EarlyStoppingMeanSquaredErrorEvaluator.cs

@@ -47 +47 @@
       double qualityLimit = GetVariableValue<DoubleData>("QualityLimit", scope, false).Data;
       DoubleData mse = GetVariableValue<DoubleData>("MSE", scope, false, false);
-      if(mse == null) {
+      if (mse == null) {
         mse = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MSE"), mse));
@@ -54 +54 @@
       double errorsSquaredSum = 0;
       int rows = end - start;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double estimated = evaluator.Evaluate(sample);
-        double original = dataset.GetValue(targetVariable, sample);
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimated);
+        double original = dataset.GetValue(sample, targetVariable);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimated);
         }
-        if(!double.IsNaN(original) && !double.IsInfinity(original)) {
+        if (!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
           errorsSquaredSum += error * error;
         }
         // check the limit and stop as soon as we hit the limit
-        if(errorsSquaredSum / rows >= qualityLimit) {
+        if (errorsSquaredSum / rows >= qualityLimit) {
           mse.Data = errorsSquaredSum / (sample - start + 1); // return estimated MSE (when the remaining errors are on average the same)
           return;
@@ -71 +71 @@
       }
       errorsSquaredSum /= rows;
-      if(double.IsNaN(errorsSquaredSum) || double.IsInfinity(errorsSquaredSum)) {
+      if (double.IsNaN(errorsSquaredSum) || double.IsInfinity(errorsSquaredSum)) {
         errorsSquaredSum = double.MaxValue;
       }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/GPEvaluatorBase.cs

@@ -57 +57 @@
       double[] backupValues = null;
       // prepare for autoregressive modelling by saving the original values of the target-variable to a backup array
-      if(useEstimatedValues &&
-        (backupValues == null || backupValues.Length!=end-start)) {
+      if (useEstimatedValues &&
+        (backupValues == null || backupValues.Length != end - start)) {
         backupValues = new double[end - start];
-        for(int i = start; i < end; i++) {
+        for (int i = start; i < end; i++) {
           backupValues[i - start] = dataset.GetValue(i, targetVariable);
         }
@@ -72 +72 @@
 
       // restore the values of the target variable from the backup array if necessary
-      if(useEstimatedValues) {
-        for(int i = start; i < end; i++) {
+      if (useEstimatedValues) {
+        for (int i = start; i < end; i++) {
           dataset.SetValue(i, targetVariable, backupValues[i - start]);
         }
@@ -79 +79 @@
 
       // update the value of total evaluated nodes
-      scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data = totalEvaluatedNodes + treeSize * (end-start);
+      scope.GetVariableValue<DoubleData>("TotalEvaluatedNodes", true).Data = totalEvaluatedNodes + treeSize * (end - start);
       return null;
     }

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/MeanAbsolutePercentageErrorEvaluator.cs

@@ -46 +46 @@
       double errorsSum = 0.0;
       int n = 0;
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double estimated = evaluator.Evaluate(sample);
-        double original = dataset.GetValue(targetVariable, sample);
+        double original = dataset.GetValue(sample, targetVariable);
 
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimated);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimated);
         }
-        
-        if(!double.IsNaN(original) && !double.IsInfinity(original) && original != 0.0) {
+
+        if (!double.IsNaN(original) && !double.IsInfinity(original) && original != 0.0) {
           double percent_error = Math.Abs((estimated - original) / original);
           errorsSum += percent_error;
@@ -61 +61 @@
       }
       double quality = errorsSum / n;
-      if(double.IsNaN(quality) || double.IsInfinity(quality))
+      if (double.IsNaN(quality) || double.IsInfinity(quality))
         quality = double.MaxValue;
 
       // create a variable for the MAPE
       DoubleData mape = GetVariableValue<DoubleData>("MAPE", scope, false, false);
-      if(mape == null) {
+      if (mape == null) {
         mape = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MAPE"), mape));

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/MeanSquaredErrorEvaluator.cs

@@ -45 +45 @@
     public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
       double errorsSquaredSum = 0;
-      for(int sample = start; sample < end; sample++) {
-        double original = dataset.GetValue(targetVariable, sample);
+      for (int sample = start; sample < end; sample++) {
+        double original = dataset.GetValue(sample, targetVariable);
         double estimated = evaluator.Evaluate(sample);
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimated);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimated);
         }
-        if(!double.IsNaN(original) && !double.IsInfinity(original)) {
+        if (!double.IsNaN(original) && !double.IsInfinity(original)) {
           double error = estimated - original;
           errorsSquaredSum += error * error;
@@ -58 +58 @@
 
       errorsSquaredSum /= (end - start);
-      if(double.IsNaN(errorsSquaredSum) || double.IsInfinity(errorsSquaredSum)) {
+      if (double.IsNaN(errorsSquaredSum) || double.IsInfinity(errorsSquaredSum)) {
         errorsSquaredSum = double.MaxValue;
       }
 
       DoubleData mse = GetVariableValue<DoubleData>("MSE", scope, false, false);
-      if(mse == null) {
+      if (mse == null) {
         mse = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("MSE"), mse));

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/SimpleEvaluator.cs

@@ -38 +38 @@
     public override void Evaluate(IScope scope, BakedTreeEvaluator evaluator, Dataset dataset, int targetVariable, int start, int end, bool updateTargetValues) {
       ItemList values = GetVariableValue<ItemList>("Values", scope, false, false);
-      if(values == null) {
+      if (values == null) {
         values = new ItemList();
         IVariableInfo info = GetVariableInfo("Values");
-        if(info.Local)
+        if (info.Local)
           AddVariable(new HeuristicLab.Core.Variable(info.ActualName, values));
         else
@@ -48 +48 @@
       values.Clear();
 
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         ItemList row = new ItemList();
         double estimated = evaluator.Evaluate(sample);
-        double original = dataset.GetValue(targetVariable, sample);
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimated);
+        double original = dataset.GetValue(sample, targetVariable);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimated);
         }
         row.Add(new DoubleData(estimated));

trunk/sources/HeuristicLab.GP.StructureIdentification/Evaluators/VarianceAccountedForEvaluator.cs

@@ -57 +57 @@
       double[] errors = new double[nSamples];
       double[] originalTargetVariableValues = new double[nSamples];
-      for(int sample = start; sample < end; sample++) {
+      for (int sample = start; sample < end; sample++) {
         double estimated = evaluator.Evaluate(sample);
-        double original = dataset.GetValue(targetVariable, sample);
-        if(updateTargetValues) {
-          dataset.SetValue(targetVariable, sample, estimated);
+        double original = dataset.GetValue(sample, targetVariable);
+        if (updateTargetValues) {
+          dataset.SetValue(sample, targetVariable, estimated);
         }
-        if(!double.IsNaN(original) && !double.IsInfinity(original)) {
+        if (!double.IsNaN(original) && !double.IsInfinity(original)) {
           errors[sample - start] = original - estimated;
           originalTargetVariableValues[sample - start] = original;
@@ -72 +72 @@
       double quality = 1 - errorsVariance / originalsVariance;
 
-      if(double.IsNaN(quality) || double.IsInfinity(quality)) {
+      if (double.IsNaN(quality) || double.IsInfinity(quality)) {
         quality = double.MaxValue;
       }
       DoubleData vaf = GetVariableValue<DoubleData>("VAF", scope, false, false);
-      if(vaf == null) {
+      if (vaf == null) {
         vaf = new DoubleData();
         scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("VAF"), vaf));