Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearDiscriminantAnalysis.cs	(revision 8139)
@@ -68,5 +68,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       int nClasses = problemData.ClassNames.Count();
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/LinearRegression.cs	(revision 8139)
@@ -72,5 +72,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/Linear/MultinomialLogitClassification.cs	(revision 8139)
@@ -69,5 +69,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -81,10 +81,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
       int info;
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourClassification.cs	(revision 8139)
@@ -87,5 +87,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -99,10 +99,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
       alglib.nearestneighbor.kdtreebuild(inputMatrix, nRows, inputMatrix.GetLength(1) - 1, 1, 2, kdtree);
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourRegression.cs	(revision 8139)
@@ -87,5 +87,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkClassification.cs	(revision 8139)
@@ -185,5 +185,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -195,10 +195,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
 
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleClassification.cs	(revision 8139)
@@ -171,5 +171,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -181,10 +181,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nFeatures] = classIndizes[inputMatrix[row, nFeatures]];
+        inputMatrix[row, nFeatures] = classIndices[inputMatrix[row, nFeatures]];
       }
 
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleRegression.cs	(revision 8139)
@@ -170,5 +170,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkRegression.cs	(revision 8139)
@@ -186,5 +186,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestClassification.cs	(revision 8139)
@@ -97,5 +97,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
@@ -111,10 +111,10 @@
       int nClasses = classValues.Count();
       // map original class values to values [0..nClasses-1]
-      Dictionary<double, double> classIndizes = new Dictionary<double, double>();
+      Dictionary<double, double> classIndices = new Dictionary<double, double>();
       for (int i = 0; i < nClasses; i++) {
-        classIndizes[classValues[i]] = i;
+        classIndices[classValues[i]] = i;
       }
       for (int row = 0; row < nRows; row++) {
-        inputMatrix[row, nCols - 1] = classIndizes[inputMatrix[row, nCols - 1]];
+        inputMatrix[row, nCols - 1] = classIndices[inputMatrix[row, nCols - 1]];
       }
       // execute random forest algorithm
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestRegression.cs	(revision 8139)
@@ -97,5 +97,5 @@
       string targetVariable = problemData.TargetVariable;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       double[,] inputMatrix = AlglibUtil.PrepareInputMatrix(dataset, allowedInputVariables.Concat(new string[] { targetVariable }), rows);
       if (inputMatrix.Cast<double>().Any(x => double.IsNaN(x) || double.IsInfinity(x)))
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorClassification.cs	(revision 8139)
@@ -132,5 +132,5 @@
       Dataset dataset = problemData.Dataset;
       string targetVariable = problemData.TargetVariable;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
 
       //extract SVM parameters from scope and set them
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorRegression.cs	(revision 8139)
@@ -140,5 +140,5 @@
       Dataset dataset = problemData.Dataset;
       string targetVariable = problemData.TargetVariable;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
 
       //extract SVM parameters from scope and set them
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClustering.cs	(revision 8139)
@@ -85,5 +85,5 @@
       Dataset dataset = problemData.Dataset;
       IEnumerable<string> allowedInputVariables = problemData.AllowedInputVariables;
-      IEnumerable<int> rows = problemData.TrainingIndizes;
+      IEnumerable<int> rows = problemData.TrainingIndices;
       int info;
       double[,] centers;
Index: /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Algorithms.DataAnalysis/3.4/kMeans/KMeansClusteringSolution.cs	(revision 8139)
@@ -52,6 +52,6 @@
     public KMeansClusteringSolution(KMeansClusteringModel model, IClusteringProblemData problemData)
       : base(model, problemData) {
-      double trainingIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TrainingIndizes);
-      double testIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TestIndizes);
+      double trainingIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TrainingIndices);
+      double testIntraClusterSumOfSquares = KMeansClusteringUtil.CalculateIntraClusterSumOfSquares(model, problemData.Dataset, problemData.TestIndices);
       this.Add(new Result(TrainingIntraClusterSumOfSquaresResultName, "The sum of squared distances of points of the training partition to the cluster center (is minimized by k-Means).", new DoubleValue(trainingIntraClusterSumOfSquares)));
       this.Add(new Result(TestIntraClusterSumOfSquaresResultName, "The sum of squared distances of points of the test partition to the cluster center (is minimized by k-Means).", new DoubleValue(testIntraClusterSumOfSquares)));
Index: /trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Data.Views/3.3/StringConvertibleMatrixView.cs	(revision 8139)
@@ -35,6 +35,6 @@
   [Content(typeof(IStringConvertibleMatrix), true)]
   public partial class StringConvertibleMatrixView : AsynchronousContentView {
-    private int[] virtualRowIndizes;
-    private List<KeyValuePair<int, SortOrder>> sortedColumnIndizes;
+    private int[] virtualRowIndices;
+    private List<KeyValuePair<int, SortOrder>> sortedColumnIndices;
     private RowComparer rowComparer;
 
@@ -82,5 +82,5 @@
       errorProvider.SetIconAlignment(columnsTextBox, ErrorIconAlignment.MiddleLeft);
       errorProvider.SetIconPadding(columnsTextBox, 2);
-      sortedColumnIndizes = new List<KeyValuePair<int, SortOrder>>();
+      sortedColumnIndices = new List<KeyValuePair<int, SortOrder>>();
       rowComparer = new RowComparer();
     }
@@ -108,5 +108,5 @@
         dataGridView.Rows.Clear();
         dataGridView.Columns.Clear();
-        virtualRowIndizes = new int[0];
+        virtualRowIndices = new int[0];
       } else
         UpdateData();
@@ -128,5 +128,5 @@
       columnsTextBox.Text = Content.Columns.ToString();
       columnsTextBox.Enabled = true;
-      virtualRowIndizes = Enumerable.Range(0, Content.Rows).ToArray();
+      virtualRowIndices = Enumerable.Range(0, Content.Rows).ToArray();
 
       if (Content.Columns == 0 && dataGridView.ColumnCount != Content.Columns && !Content.ReadOnly)
@@ -178,6 +178,6 @@
 
       while (updatedRows < count) {
-        if (virtualRowIndizes[index] < Content.RowNames.Count())
-          dataGridView.Rows[index].HeaderCell.Value = Content.RowNames.ElementAt(virtualRowIndizes[index]);
+        if (virtualRowIndices[index] < Content.RowNames.Count())
+          dataGridView.Rows[index].HeaderCell.Value = Content.RowNames.ElementAt(virtualRowIndices[index]);
         else
           dataGridView.Rows[index].HeaderCell.Value = "Row " + (index + 1);
@@ -273,5 +273,5 @@
       if (!dataGridView.ReadOnly) {
         string value = e.Value.ToString();
-        int rowIndex = virtualRowIndizes[e.RowIndex];
+        int rowIndex = virtualRowIndices[e.RowIndex];
         e.ParsingApplied = Content.SetValue(value, rowIndex, e.ColumnIndex);
         if (e.ParsingApplied) e.Value = Content.GetValue(rowIndex, e.ColumnIndex);
@@ -283,5 +283,5 @@
     private void dataGridView_CellValueNeeded(object sender, DataGridViewCellValueEventArgs e) {
       if (Content != null && e.RowIndex < Content.Rows && e.ColumnIndex < Content.Columns) {
-        int rowIndex = virtualRowIndizes[e.RowIndex];
+        int rowIndex = virtualRowIndices[e.RowIndex];
         e.Value = Content.GetValue(rowIndex, e.ColumnIndex);
       }
@@ -340,5 +340,5 @@
 
       for (int i = minRowIndex; i <= maxRowIndex; i++) {
-        int rowIndex = this.virtualRowIndizes[i];
+        int rowIndex = this.virtualRowIndices[i];
         if (addRowNames) {
           s.Append(Content.RowNames.ElementAt(rowIndex));
@@ -399,24 +399,24 @@
       if (Content != null) {
         if (e.Button == MouseButtons.Left && Content.SortableView) {
-          bool addToSortedIndizes = (Control.ModifierKeys & Keys.Control) == Keys.Control;
+          bool addToSortedIndices = (Control.ModifierKeys & Keys.Control) == Keys.Control;
           SortOrder newSortOrder = SortOrder.Ascending;
-          if (sortedColumnIndizes.Any(x => x.Key == e.ColumnIndex)) {
-            SortOrder oldSortOrder = sortedColumnIndizes.Where(x => x.Key == e.ColumnIndex).First().Value;
+          if (sortedColumnIndices.Any(x => x.Key == e.ColumnIndex)) {
+            SortOrder oldSortOrder = sortedColumnIndices.Where(x => x.Key == e.ColumnIndex).First().Value;
             int enumLength = Enum.GetValues(typeof(SortOrder)).Length;
             newSortOrder = oldSortOrder = (SortOrder)Enum.Parse(typeof(SortOrder), ((((int)oldSortOrder) + 1) % enumLength).ToString());
           }
 
-          if (!addToSortedIndizes)
-            sortedColumnIndizes.Clear();
-
-          if (sortedColumnIndizes.Any(x => x.Key == e.ColumnIndex)) {
-            int sortedIndex = sortedColumnIndizes.FindIndex(x => x.Key == e.ColumnIndex);
+          if (!addToSortedIndices)
+            sortedColumnIndices.Clear();
+
+          if (sortedColumnIndices.Any(x => x.Key == e.ColumnIndex)) {
+            int sortedIndex = sortedColumnIndices.FindIndex(x => x.Key == e.ColumnIndex);
             if (newSortOrder != SortOrder.None)
-              sortedColumnIndizes[sortedIndex] = new KeyValuePair<int, SortOrder>(e.ColumnIndex, newSortOrder);
+              sortedColumnIndices[sortedIndex] = new KeyValuePair<int, SortOrder>(e.ColumnIndex, newSortOrder);
             else
-              sortedColumnIndizes.RemoveAt(sortedIndex);
+              sortedColumnIndices.RemoveAt(sortedIndex);
           } else
             if (newSortOrder != SortOrder.None)
-              sortedColumnIndizes.Add(new KeyValuePair<int, SortOrder>(e.ColumnIndex, newSortOrder));
+              sortedColumnIndices.Add(new KeyValuePair<int, SortOrder>(e.ColumnIndex, newSortOrder));
           Sort();
         }
@@ -425,11 +425,11 @@
 
     protected virtual void ClearSorting() {
-      virtualRowIndizes = Enumerable.Range(0, Content.Rows).ToArray();
-      sortedColumnIndizes.Clear();
+      virtualRowIndices = Enumerable.Range(0, Content.Rows).ToArray();
+      sortedColumnIndices.Clear();
       UpdateSortGlyph();
     }
 
     private void Sort() {
-      virtualRowIndizes = Sort(sortedColumnIndizes);
+      virtualRowIndices = Sort(sortedColumnIndices);
       UpdateSortGlyph();
       UpdateRowHeaders();
@@ -439,5 +439,5 @@
       int[] newSortedIndex = Enumerable.Range(0, Content.Rows).ToArray();
       if (sortedColumns.Count() != 0) {
-        rowComparer.SortedIndizes = sortedColumns;
+        rowComparer.SortedIndices = sortedColumns;
         rowComparer.Matrix = Content;
         Array.Sort(newSortedIndex, rowComparer);
@@ -448,5 +448,5 @@
       foreach (DataGridViewColumn col in this.dataGridView.Columns)
         col.HeaderCell.SortGlyphDirection = SortOrder.None;
-      foreach (KeyValuePair<int, SortOrder> p in sortedColumnIndizes)
+      foreach (KeyValuePair<int, SortOrder> p in sortedColumnIndices)
         this.dataGridView.Columns[p.Key].HeaderCell.SortGlyphDirection = p.Value;
     }
@@ -457,8 +457,8 @@
       }
 
-      private List<KeyValuePair<int, SortOrder>> sortedIndizes;
-      public IEnumerable<KeyValuePair<int, SortOrder>> SortedIndizes {
-        get { return this.sortedIndizes; }
-        set { sortedIndizes = new List<KeyValuePair<int, SortOrder>>(value); }
+      private List<KeyValuePair<int, SortOrder>> sortedIndices;
+      public IEnumerable<KeyValuePair<int, SortOrder>> SortedIndices {
+        get { return this.sortedIndices; }
+        set { sortedIndices = new List<KeyValuePair<int, SortOrder>>(value); }
       }
       private IStringConvertibleMatrix matrix;
@@ -477,8 +477,8 @@
         if (matrix == null)
           throw new InvalidOperationException("Could not sort IStringConvertibleMatrix if the matrix member is null.");
-        if (sortedIndizes == null)
+        if (sortedIndices == null)
           return 0;
 
-        foreach (KeyValuePair<int, SortOrder> pair in sortedIndizes.Where(p => p.Value != SortOrder.None)) {
+        foreach (KeyValuePair<int, SortOrder> pair in sortedIndices.Where(p => p.Value != SortOrder.None)) {
           string1 = matrix.GetValue(x, pair.Key);
           string2 = matrix.GetValue(y, pair.Key);
Index: /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionTabularView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionTabularView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Optimization.Views/3.3/RunCollectionViews/RunCollectionTabularView.cs	(revision 8139)
@@ -164,5 +164,5 @@
       RunCollectionRowComparer rowComparer = new RunCollectionRowComparer();
       if (sortedColumns.Count() != 0) {
-        rowComparer.SortedIndizes = sortedColumns;
+        rowComparer.SortedIndices = sortedColumns;
         rowComparer.Matrix = Content;
         Array.Sort(newSortedIndex, rowComparer);
@@ -194,8 +194,8 @@
       }
 
-      private List<KeyValuePair<int, SortOrder>> sortedIndizes;
-      public IEnumerable<KeyValuePair<int, SortOrder>> SortedIndizes {
-        get { return this.sortedIndizes; }
-        set { sortedIndizes = new List<KeyValuePair<int, SortOrder>>(value); }
+      private List<KeyValuePair<int, SortOrder>> sortedIndices;
+      public IEnumerable<KeyValuePair<int, SortOrder>> SortedIndices {
+        get { return this.sortedIndices; }
+        set { sortedIndices = new List<KeyValuePair<int, SortOrder>>(value); }
       }
       private RunCollection matrix;
@@ -212,8 +212,8 @@
         if (matrix == null)
           throw new InvalidOperationException("Could not sort IStringConvertibleMatrix if the matrix member is null.");
-        if (sortedIndizes == null)
+        if (sortedIndices == null)
           return 0;
 
-        foreach (KeyValuePair<int, SortOrder> pair in sortedIndizes.Where(p => p.Value != SortOrder.None)) {
+        foreach (KeyValuePair<int, SortOrder> pair in sortedIndices.Where(p => p.Value != SortOrder.None)) {
           value1 = matrix.GetValue(x, pair.Key);
           value2 = matrix.GetValue(y, pair.Key);
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs	(revision 8139)
@@ -69,5 +69,5 @@
       var interpreter = Content.Model.Interpreter;
       var dataset = Content.ProblemData.Dataset;
-      var rows = Content.ProblemData.TrainingIndizes;
+      var rows = Content.ProblemData.TrainingIndices;
       string targetVariable = Content.ProblemData.TargetVariable;
       Dictionary<ISymbolicExpressionTreeNode, double> impactValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
@@ -113,5 +113,5 @@
       start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone());
       var interpreter = Content.Model.Interpreter;
-      var rows = Content.ProblemData.TrainingIndizes;
+      var rows = Content.ProblemData.TrainingIndices;
       return interpreter.GetSymbolicExpressionTreeValues(tempTree, Content.ProblemData.Dataset, rows).Median();
     }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/MultiObjective/SymbolicClassificationMultiObjectiveProblem.cs	(revision 8139)
@@ -81,6 +81,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SingleObjective/SymbolicClassificationSingleObjectiveProblem.cs	(revision 8139)
@@ -97,6 +97,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs	(revision 8139)
@@ -125,5 +125,5 @@
       var dataset = problemData.Dataset;
       var targetVariable = problemData.TargetVariable;
-      var rows = problemData.TrainingIndizes;
+      var rows = problemData.TrainingIndices;
       var estimatedValues = model.Interpreter.GetSymbolicExpressionTreeValues(model.SymbolicExpressionTree, dataset, rows);
       var targetValues = dataset.GetDoubleValues(targetVariable, rows);
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs	(revision 8139)
@@ -66,5 +66,5 @@
       var interpreter = Content.Model.Interpreter;
       var dataset = Content.ProblemData.Dataset;
-      var rows = Content.ProblemData.TrainingIndizes;
+      var rows = Content.ProblemData.TrainingIndices;
       string targetVariable = Content.ProblemData.TargetVariable;
       Dictionary<ISymbolicExpressionTreeNode, double> impactValues = new Dictionary<ISymbolicExpressionTreeNode, double>();
@@ -106,5 +106,5 @@
       start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone());
       var interpreter = Content.Model.Interpreter;
-      var rows = Content.ProblemData.TrainingIndizes;
+      var rows = Content.ProblemData.TrainingIndices;
       return interpreter.GetSymbolicExpressionTreeValues(tempTree, Content.ProblemData.Dataset, rows).Median();
     }
@@ -122,5 +122,5 @@
 
     protected override void btnOptimizeConstants_Click(object sender, EventArgs e) {
-      SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(Content.Model.Interpreter, Content.Model.SymbolicExpressionTree, Content.ProblemData, Content.ProblemData.TrainingIndizes, 0.001, 0, 0.0001);
+      SymbolicRegressionConstantOptimizationEvaluator.OptimizeConstants(Content.Model.Interpreter, Content.Model.SymbolicExpressionTree, Content.ProblemData, Content.ProblemData.TrainingIndices, 0.001, 0, 0.0001);
       UpdateModel(Content.Model.SymbolicExpressionTree);
     }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionResponseFunctionView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionResponseFunctionView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/SymbolicRegressionSolutionResponseFunctionView.cs	(revision 8139)
@@ -142,35 +142,35 @@
       };
 
-      var mainTrainingIndizes = (from row in Content.ProblemData.TrainingIndizes
+      var mainTrainingIndices = (from row in Content.ProblemData.TrainingIndices
                                  where NearMedianValue(row)
                                  select row)
         .ToArray();
-      var mainTestIndizes = (from row in Content.ProblemData.TestIndizes
+      var mainTestIndices = (from row in Content.ProblemData.TestIndices
                              where NearMedianValue(row)
                              select row)
         .ToArray();
 
-      var freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, mainTrainingIndizes).ToArray();
+      var freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, mainTrainingIndices).ToArray();
       var trainingValues = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable,
-                                                                     mainTrainingIndizes).ToArray();
+                                                                     mainTrainingIndices).ToArray();
       Array.Sort(freeVariableValues, trainingValues);
       responseChart.Series["Training Data"].Points.DataBindXY(freeVariableValues, trainingValues);
 
-      freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, mainTestIndizes).ToArray();
+      freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, mainTestIndices).ToArray();
       var testValues = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable,
-                                                                     mainTestIndizes).ToArray();
+                                                                     mainTestIndices).ToArray();
       Array.Sort(freeVariableValues, testValues);
       responseChart.Series["Test Data"].Points.DataBindXY(freeVariableValues, testValues);
 
       // draw scatter plots of remaining values
-      freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, Content.ProblemData.TrainingIndizes).ToArray();
+      freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, Content.ProblemData.TrainingIndices).ToArray();
       trainingValues = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable,
-                                                                     Content.ProblemData.TrainingIndizes).ToArray();
+                                                                     Content.ProblemData.TrainingIndices).ToArray();
       Array.Sort(freeVariableValues, trainingValues);
       responseChart.Series["Training Data (edge)"].Points.DataBindXY(freeVariableValues, trainingValues);
 
-      freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, Content.ProblemData.TestIndizes).ToArray();
+      freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, Content.ProblemData.TestIndices).ToArray();
       testValues = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable,
-                                                                     Content.ProblemData.TestIndizes).ToArray();
+                                                                     Content.ProblemData.TestIndices).ToArray();
       Array.Sort(freeVariableValues, testValues);
       responseChart.Series["Test Data (edge)"].Points.DataBindXY(freeVariableValues, testValues);
@@ -187,8 +187,8 @@
       string freeVariable = (string)comboBox.SelectedItem;
 
-      var freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, Content.ProblemData.TrainingIndizes).ToArray();
+      var freeVariableValues = Content.ProblemData.Dataset.GetDoubleValues(freeVariable, Content.ProblemData.TrainingIndices).ToArray();
       var responseValues = Content.Model.Interpreter.GetSymbolicExpressionTreeValues(clonedTree,
                                                                               Content.ProblemData.Dataset,
-                                                                              Content.ProblemData.TrainingIndizes)
+                                                                              Content.ProblemData.TrainingIndices)
                                                                               .ToArray();
       Array.Sort(freeVariableValues, responseValues);
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/SymbolicRegressionMultiObjectiveProblem.cs	(revision 8139)
@@ -85,6 +85,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs	(revision 8139)
@@ -102,6 +102,6 @@
 
     private void UpdateEstimationLimits() {
-      if (ProblemData.TrainingIndizes.Any()) {
-        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToList();
+      if (ProblemData.TrainingIndices.Any()) {
+        var targetValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToList();
         var mean = targetValues.Average();
         var range = targetValues.Max() - targetValues.Min();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs	(revision 8139)
@@ -73,5 +73,5 @@
       var dataset = problemData.Dataset;
       var targetVariable = problemData.TargetVariable;
-      var rows = problemData.TrainingIndizes;
+      var rows = problemData.TrainingIndices;
       var estimatedValues = model.Interpreter.GetSymbolicExpressionTreeValues(model.SymbolicExpressionTree, dataset, rows);
       var targetValues = dataset.GetDoubleValues(targetVariable, rows);
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationEnsembleSolutionEstimatedClassValuesView.cs	(revision 8139)
@@ -73,20 +73,20 @@
       }
 
-      int[] indizes;
+      int[] indices;
       double[] estimatedClassValues;
 
       switch (SamplesComboBox.SelectedItem.ToString()) {
         case SamplesComboBoxAllSamples: {
-            indizes = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).ToArray();
+            indices = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).ToArray();
             estimatedClassValues = Content.EstimatedClassValues.ToArray();
             break;
           }
         case SamplesComboBoxTrainingSamples: {
-            indizes = Content.ProblemData.TrainingIndizes.ToArray();
+            indices = Content.ProblemData.TrainingIndices.ToArray();
             estimatedClassValues = Content.EstimatedTrainingClassValues.ToArray();
             break;
           }
         case SamplesComboBoxTestSamples: {
-            indizes = Content.ProblemData.TestIndizes.ToArray();
+            indices = Content.ProblemData.TestIndices.ToArray();
             estimatedClassValues = Content.EstimatedTestClassValues.ToArray();
             break;
@@ -98,11 +98,11 @@
       int classValuesCount = Content.ProblemData.ClassValues.Count;
       int solutionsCount = Content.ClassificationSolutions.Count();
-      string[,] values = new string[indizes.Length, 5 + classValuesCount + solutionsCount];
+      string[,] values = new string[indices.Length, 5 + classValuesCount + solutionsCount];
       double[] target = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable).ToArray();
-      List<List<double?>> estimatedValuesVector = GetEstimatedValues(SamplesComboBox.SelectedItem.ToString(), indizes,
+      List<List<double?>> estimatedValuesVector = GetEstimatedValues(SamplesComboBox.SelectedItem.ToString(), indices,
                                                             Content.ClassificationSolutions);
 
-      for (int i = 0; i < indizes.Length; i++) {
-        int row = indizes[i];
+      for (int i = 0; i < indices.Length; i++) {
+        int row = indices[i];
         values[i, 0] = row.ToString();
         values[i, 1] = target[i].ToString();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionConfusionMatrixView.cs	(revision 8139)
@@ -107,8 +107,8 @@
         double[] predictedValues;
         if (cmbSamples.SelectedItem.ToString() == TrainingSamples) {
-          rows = Content.ProblemData.TrainingIndizes;
+          rows = Content.ProblemData.TrainingIndices;
           predictedValues = Content.EstimatedTrainingClassValues.ToArray();
         } else if (cmbSamples.SelectedItem.ToString() == TestSamples) {
-          rows = Content.ProblemData.TestIndizes;
+          rows = Content.ProblemData.TestIndices;
           predictedValues = Content.EstimatedTestClassValues.ToArray();
         } else throw new InvalidOperationException();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/ClassificationSolutionEstimatedClassValuesView.cs	(revision 8139)
@@ -96,5 +96,5 @@
           var estimatedTraining = Content.EstimatedTrainingClassValues.GetEnumerator();
           estimatedTraining.MoveNext();
-          foreach (var trainingRow in Content.ProblemData.TrainingIndizes) {
+          foreach (var trainingRow in Content.ProblemData.TrainingIndices) {
             values[trainingRow, 3] = estimatedTraining.Current.ToString();
             estimatedTraining.MoveNext();
@@ -102,5 +102,5 @@
           var estimatedTest = Content.EstimatedTestClassValues.GetEnumerator();
           estimatedTest.MoveNext();
-          foreach (var testRow in Content.ProblemData.TestIndizes) {
+          foreach (var testRow in Content.ProblemData.TestIndices) {
             values[testRow, 4] = estimatedTest.Current.ToString();
             estimatedTest.MoveNext();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationRocCurvesView.cs	(revision 8139)
@@ -101,7 +101,7 @@
 
         if (cmbSamples.SelectedItem.ToString() == TrainingSamples) {
-          rows = Content.ProblemData.TrainingIndizes;
+          rows = Content.ProblemData.TrainingIndices;
         } else if (cmbSamples.SelectedItem.ToString() == TestSamples) {
-          rows = Content.ProblemData.TestIndizes;
+          rows = Content.ProblemData.TestIndices;
         } else throw new InvalidOperationException();
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Classification/DiscriminantFunctionClassificationSolutionThresholdView.cs	(revision 8139)
@@ -137,5 +137,5 @@
       var targetValues = Content.ProblemData.Dataset.GetDoubleValues(Content.ProblemData.TargetVariable).ToList();
 
-      foreach (int row in Content.ProblemData.TrainingIndizes) {
+      foreach (int row in Content.ProblemData.TrainingIndices) {
         double estimatedValue = estimatedValues[row];
         double targetValue = targetValues[row];
@@ -150,5 +150,5 @@
       }
 
-      foreach (int row in Content.ProblemData.TestIndizes) {
+      foreach (int row in Content.ProblemData.TestIndices) {
         double estimatedValue = estimatedValues[row];
         double targetValue = targetValues[row];
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionErrorCharacteristicsCurveView.cs	(revision 8139)
@@ -169,8 +169,8 @@
       switch (cmbSamples.SelectedItem.ToString()) {
         case TrainingSamples:
-          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
           break;
         case TestSamples:
-          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
+          originalValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices);
           break;
         case AllSamples:
@@ -234,5 +234,5 @@
 
     private IRegressionSolution CreateConstantModel() {
-      double averageTrainingTarget = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).Average();
+      double averageTrainingTarget = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).Average();
       var solution = new ConstantRegressionModel(averageTrainingTarget).CreateRegressionSolution(ProblemData);
       solution.Name = "Baseline";
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionEstimatedValuesView.cs	(revision 8139)
@@ -93,10 +93,10 @@
           var estimated_test = Content.EstimatedTestValues.GetEnumerator();
 
-          foreach (var row in Content.ProblemData.TrainingIndizes) {
+          foreach (var row in Content.ProblemData.TrainingIndices) {
             estimated_training.MoveNext();
             values[row, 3] = estimated_training.Current.ToString();
           }
 
-          foreach (var row in Content.ProblemData.TestIndizes) {
+          foreach (var row in Content.ProblemData.TestIndices) {
             estimated_test.MoveNext();
             values[row, 4] = estimated_test.Current.ToString();
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartView.cs	(revision 8139)
@@ -72,5 +72,5 @@
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].ChartType = SeriesChartType.FastLine;
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].EmptyPointStyle.Color = this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Color;
-        this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TrainingIndizes.ToArray(), Content.EstimatedTrainingValues.ToArray());
+        this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TrainingIndices.ToArray(), Content.EstimatedTrainingValues.ToArray());
         this.InsertEmptyPoints(this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME]);
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Tag = Content;
@@ -79,15 +79,15 @@
         this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].LegendText = ESTIMATEDVALUES_TEST_SERIES_NAME;
         this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].ChartType = SeriesChartType.FastLine;
-        this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TestIndizes.ToArray(), Content.EstimatedTestValues.ToArray());
+        this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Points.DataBindXY(Content.ProblemData.TestIndices.ToArray(), Content.EstimatedTestValues.ToArray());
         this.InsertEmptyPoints(this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME]);
         this.chart.Series[ESTIMATEDVALUES_TEST_SERIES_NAME].Tag = Content;
         // series of remaining points
-        int[] allIndizes = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndizes).Except(Content.ProblemData.TestIndizes).ToArray();
+        int[] allIndices = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndices).Except(Content.ProblemData.TestIndices).ToArray();
         var estimatedValues = Content.EstimatedValues.ToArray();
-        List<double> allEstimatedValues = allIndizes.Select(index => estimatedValues[index]).ToList();
+        List<double> allEstimatedValues = allIndices.Select(index => estimatedValues[index]).ToList();
         this.chart.Series.Add(ESTIMATEDVALUES_ALL_SERIES_NAME);
         this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].LegendText = ESTIMATEDVALUES_ALL_SERIES_NAME;
         this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].ChartType = SeriesChartType.FastLine;
-        this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Points.DataBindXY(allIndizes, allEstimatedValues);
+        this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Points.DataBindXY(allIndices, allEstimatedValues);
         this.InsertEmptyPoints(this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME]);
         this.chart.Series[ESTIMATEDVALUES_ALL_SERIES_NAME].Tag = Content;
@@ -170,8 +170,8 @@
 
       int[] attr = new int[Content.ProblemData.Dataset.Rows + 1]; // add a virtual last row that is again empty to simplify loop further down
-      foreach (var row in Content.ProblemData.TrainingIndizes) {
+      foreach (var row in Content.ProblemData.TrainingIndices) {
         attr[row] += 1;
       }
-      foreach (var row in Content.ProblemData.TestIndizes) {
+      foreach (var row in Content.ProblemData.TestIndices) {
         attr[row] += 2;
       }
@@ -223,22 +223,22 @@
         string targetVariableName = Content.ProblemData.TargetVariable;
 
-        IEnumerable<int> indizes = null;
+        IEnumerable<int> indices = null;
         IEnumerable<double> predictedValues = null;
         switch (series.Name) {
           case ESTIMATEDVALUES_ALL_SERIES_NAME:
-            indizes = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndizes).Except(Content.ProblemData.TestIndizes).ToArray();
+            indices = Enumerable.Range(0, Content.ProblemData.Dataset.Rows).Except(Content.ProblemData.TrainingIndices).Except(Content.ProblemData.TestIndices).ToArray();
             var estimatedValues = Content.EstimatedValues.ToArray();
-            predictedValues = indizes.Select(index => estimatedValues[index]).ToList();
+            predictedValues = indices.Select(index => estimatedValues[index]).ToList();
             break;
           case ESTIMATEDVALUES_TRAINING_SERIES_NAME:
-            indizes = Content.ProblemData.TrainingIndizes.ToArray();
+            indices = Content.ProblemData.TrainingIndices.ToArray();
             predictedValues = Content.EstimatedTrainingValues.ToArray();
             break;
           case ESTIMATEDVALUES_TEST_SERIES_NAME:
-            indizes = Content.ProblemData.TestIndizes.ToArray();
+            indices = Content.ProblemData.TestIndices.ToArray();
             predictedValues = Content.EstimatedTestValues.ToArray();
             break;
         }
-        series.Points.DataBindXY(indizes, predictedValues);
+        series.Points.DataBindXY(indices, predictedValues);
         this.InsertEmptyPoints(series);
         chart.Legends[series.Legend].ForeColor = Color.Black;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionScatterPlotView.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionScatterPlotView.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionScatterPlotView.cs	(revision 8139)
@@ -148,8 +148,8 @@
         if (this.chart.Series[TRAINING_SERIES].Points.Count > 0)
           this.chart.Series[TRAINING_SERIES].Points.DataBindXY(Content.EstimatedTrainingValues.ToArray(), "",
-            dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndizes).ToArray(), "");
+            dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndices).ToArray(), "");
         if (this.chart.Series[TEST_SERIES].Points.Count > 0)
           this.chart.Series[TEST_SERIES].Points.DataBindXY(Content.EstimatedTestValues.ToArray(), "",
-           dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndizes).ToArray(), "");
+           dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndices).ToArray(), "");
 
         double max = Content.EstimatedTrainingValues.Concat(Content.EstimatedTestValues.Concat(Content.EstimatedValues.Concat(dataset.GetDoubleValues(targetVariableName)))).Max();
@@ -196,9 +196,9 @@
           case TRAINING_SERIES:
             predictedValues = Content.EstimatedTrainingValues.ToArray();
-            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndizes).ToArray();
+            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TrainingIndices).ToArray();
             break;
           case TEST_SERIES:
             predictedValues = Content.EstimatedTestValues.ToArray();
-            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndizes).ToArray();
+            targetValues = Content.ProblemData.Dataset.GetDoubleValues(targetVariableName, Content.ProblemData.TestIndices).ToArray();
             break;
         }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs	(revision 8139)
@@ -148,5 +148,5 @@
     public override IEnumerable<double> EstimatedTrainingClassValues {
       get {
-        var rows = ProblemData.TrainingIndizes;
+        var rows = ProblemData.TrainingIndices;
         var estimatedValuesEnumerators = (from model in Model.Models
                                           select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
@@ -167,9 +167,9 @@
     public override IEnumerable<double> EstimatedTestClassValues {
       get {
-        var rows = ProblemData.TestIndizes;
+        var rows = ProblemData.TestIndices;
         var estimatedValuesEnumerators = (from model in Model.Models
                                           select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedClassValues(ProblemData.Dataset, rows).GetEnumerator() })
                                          .ToList();
-        var rowsEnumerator = ProblemData.TestIndizes.GetEnumerator();
+        var rowsEnumerator = ProblemData.TestIndices.GetEnumerator();
         // aggregate to make sure that MoveNext is called for all enumerators 
         while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolution.cs	(revision 8139)
@@ -51,8 +51,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TestIndices); }
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionBase.cs	(revision 8139)
@@ -87,7 +87,7 @@
     protected void CalculateResults() {
       double[] estimatedTrainingClassValues = EstimatedTrainingClassValues.ToArray(); // cache values
-      double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToArray();
+      double[] originalTrainingClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
       double[] estimatedTestClassValues = EstimatedTestClassValues.ToArray(); // cache values
-      double[] originalTestClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes).ToArray();
+      double[] originalTestClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices).ToArray();
 
       OnlineCalculatorError errorState;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolution.cs	(revision 8139)
@@ -59,8 +59,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestClassValues {
-      get { return GetEstimatedClassValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedClassValues(ProblemData.TestIndices); }
     }
 
@@ -82,8 +82,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingValues {
-      get { return GetEstimatedValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestValues {
-      get { return GetEstimatedValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedValues(ProblemData.TestIndices); }
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationSolutionBase.cs	(revision 8139)
@@ -103,7 +103,7 @@
     protected void CalculateRegressionResults() {
       double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
-      double[] originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes).ToArray();
+      double[] originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices).ToArray();
       double[] estimatedTestValues = EstimatedTestValues.ToArray(); // cache values
-      double[] originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes).ToArray();
+      double[] originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices).ToArray();
 
       OnlineCalculatorError errorState;
@@ -140,5 +140,5 @@
       double[] classValues;
       double[] thresholds;
-      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
       AccuracyMaximizationThresholdCalculator.CalculateThresholds(ProblemData, EstimatedTrainingValues, targetClassValues, out classValues, out thresholds);
 
@@ -149,5 +149,5 @@
       double[] classValues;
       double[] thresholds;
-      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      var targetClassValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
       NormalDistributionCutPointsThresholdCalculator.CalculateThresholds(ProblemData, EstimatedTrainingValues, targetClassValues, out classValues, out thresholds);
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Clustering/ClusteringSolution.cs	(revision 8139)
@@ -68,5 +68,5 @@
     public virtual IEnumerable<int> TrainingClusterValues {
       get {
-        return GetClusterValues(ProblemData.TrainingIndizes);
+        return GetClusterValues(ProblemData.TrainingIndices);
       }
     }
@@ -74,5 +74,5 @@
     public virtual IEnumerable<int> TestClusterValues {
       get {
-        return GetClusterValues(ProblemData.TestIndizes);
+        return GetClusterValues(ProblemData.TestIndices);
       }
     }
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/DataAnalysisProblemData.cs	(revision 8139)
@@ -75,5 +75,5 @@
     }
 
-    public virtual IEnumerable<int> TrainingIndizes {
+    public virtual IEnumerable<int> TrainingIndices {
       get {
         return Enumerable.Range(TrainingPartition.Start, Math.Max(0, TrainingPartition.End - TrainingPartition.Start))
@@ -81,5 +81,5 @@
       }
     }
-    public virtual IEnumerable<int> TestIndizes {
+    public virtual IEnumerable<int> TestIndices {
       get {
         return Enumerable.Range(TestPartition.Start, Math.Max(0, TestPartition.End - TestPartition.Start))
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionEnsembleSolution.cs	(revision 8139)
@@ -153,5 +153,5 @@
     public override IEnumerable<double> EstimatedTrainingValues {
       get {
-        var rows = ProblemData.TrainingIndizes;
+        var rows = ProblemData.TrainingIndices;
         var estimatedValuesEnumerators = (from model in Model.Models
                                           select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedValues(ProblemData.Dataset, rows).GetEnumerator() })
@@ -172,9 +172,9 @@
     public override IEnumerable<double> EstimatedTestValues {
       get {
-        var rows = ProblemData.TestIndizes;
+        var rows = ProblemData.TestIndices;
         var estimatedValuesEnumerators = (from model in Model.Models
                                           select new { Model = model, EstimatedValuesEnumerator = model.GetEstimatedValues(ProblemData.Dataset, rows).GetEnumerator() })
                                          .ToList();
-        var rowsEnumerator = ProblemData.TestIndizes.GetEnumerator();
+        var rowsEnumerator = ProblemData.TestIndices.GetEnumerator();
         // aggregate to make sure that MoveNext is called for all enumerators 
         while (rowsEnumerator.MoveNext() & estimatedValuesEnumerators.Select(en => en.EstimatedValuesEnumerator.MoveNext()).Aggregate(true, (acc, b) => acc & b)) {
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs	(revision 8139)
@@ -55,8 +55,8 @@
     }
     public override IEnumerable<double> EstimatedTrainingValues {
-      get { return GetEstimatedValues(ProblemData.TrainingIndizes); }
+      get { return GetEstimatedValues(ProblemData.TrainingIndices); }
     }
     public override IEnumerable<double> EstimatedTestValues {
-      get { return GetEstimatedValues(ProblemData.TestIndizes); }
+      get { return GetEstimatedValues(ProblemData.TestIndices); }
     }
 
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolutionBase.cs	(revision 8139)
@@ -138,5 +138,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TrainingMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the training partition", new DoubleValue()));
-        double trainingMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes), out errorState);
+        double trainingMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices), out errorState);
         TrainingMeanAbsoluteError = errorState == OnlineCalculatorError.None ? trainingMAE : double.NaN;
       }
@@ -145,5 +145,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TestMeanAbsoluteErrorResultName, "Mean of absolute errors of the model on the test partition", new DoubleValue()));
-        double testMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes), out errorState);
+        double testMAE = OnlineMeanAbsoluteErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices), out errorState);
         TestMeanAbsoluteError = errorState == OnlineCalculatorError.None ? testMAE : double.NaN;
       }
@@ -152,5 +152,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TrainingMeanErrorResultName, "Mean of errors of the model on the training partition", new DoubleValue()));
-        double trainingME = OnlineMeanErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes), out errorState);
+        double trainingME = OnlineMeanErrorCalculator.Calculate(EstimatedTrainingValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices), out errorState);
         TrainingMeanError = errorState == OnlineCalculatorError.None ? trainingME : double.NaN;
       }
@@ -158,5 +158,5 @@
         OnlineCalculatorError errorState;
         Add(new Result(TestMeanErrorResultName, "Mean of errors of the model on the test partition", new DoubleValue()));
-        double testME = OnlineMeanErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes), out errorState);
+        double testME = OnlineMeanErrorCalculator.Calculate(EstimatedTestValues, ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices), out errorState);
         TestMeanError = errorState == OnlineCalculatorError.None ? testME : double.NaN;
       }
@@ -166,7 +166,7 @@
     protected void CalculateResults() {
       IEnumerable<double> estimatedTrainingValues = EstimatedTrainingValues; // cache values
-      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
+      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TrainingIndices);
       IEnumerable<double> estimatedTestValues = EstimatedTestValues; // cache values
-      IEnumerable<double> originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndizes);
+      IEnumerable<double> originalTestValues = ProblemData.Dataset.GetDoubleValues(ProblemData.TargetVariable, ProblemData.TestIndices);
 
       OnlineCalculatorError errorState;
Index: /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs
===================================================================
--- /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 8138)
+++ /trunk/sources/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblemData.cs	(revision 8139)
@@ -36,6 +36,6 @@
     IntRange TestPartition { get; }
 
-    IEnumerable<int> TrainingIndizes { get; }
-    IEnumerable<int> TestIndizes { get; }
+    IEnumerable<int> TrainingIndices { get; }
+    IEnumerable<int> TestIndices { get; }
 
     bool IsTrainingSample(int index);
