Index: /trunk/sources/HeuristicLab.GP.Boolean/3.3/FunctionLibraryInjector.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.Boolean/3.3/FunctionLibraryInjector.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.GP.Boolean/3.3/FunctionLibraryInjector.cs	(revision 2165)
@@ -32,5 +32,4 @@
   public class FunctionLibraryInjector : OperatorBase {
     private const string TARGETVARIABLE = "TargetVariable";
-    private const string ALLOWEDFEATURES = "AllowedFeatures";
     private const string OPERATORLIBRARY = "FunctionLibrary";
 
@@ -45,24 +44,11 @@
       : base() {
       AddVariableInfo(new VariableInfo(TARGETVARIABLE, "The target variable", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo(ALLOWEDFEATURES, "List of indexes of allowed features", typeof(ItemList<IntData>), VariableKind.In));
       AddVariableInfo(new VariableInfo(OPERATORLIBRARY, "Preconfigured default operator library", typeof(GPOperatorLibrary), VariableKind.New));
     }
 
     public override IOperation Apply(IScope scope) {
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>(ALLOWEDFEATURES, scope, true);
       int targetVariable = GetVariableValue<IntData>(TARGETVARIABLE, scope, true).Data;
 
-      // remove the target-variable in case it occures in allowed features
-      List<IntData> ts = allowedFeatures.FindAll(d => d.Data == targetVariable);
-      foreach (IntData t in ts) allowedFeatures.Remove(t);
-
       InitDefaultOperatorLibrary();
-
-      int[] allowedIndexes = new int[allowedFeatures.Count];
-      for (int i = 0; i < allowedIndexes.Length; i++) {
-        allowedIndexes[i] = allowedFeatures[i].Data;
-      }
-
-      variable.SetConstraints(allowedIndexes);
 
       scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName(OPERATORLIBRARY), operatorLibrary));
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableEvaluationImpactCalculator.cs	(revision 2165)
@@ -41,5 +41,5 @@
 
 
-    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
       IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Evaluators/VariableQualityImpactCalculator.cs	(revision 2165)
@@ -40,5 +40,5 @@
     }
 
-    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
       ITreeEvaluator evaluator = GetVariableValue<ITreeEvaluator>("TreeEvaluator", scope, true);
       IFunctionTree tree = GetVariableValue<IFunctionTree>("FunctionTree", scope, true);
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjector.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjector.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/FunctionLibraryInjector.cs	(revision 2165)
@@ -32,7 +32,7 @@
 namespace HeuristicLab.GP.StructureIdentification {
   public class FunctionLibraryInjector : OperatorBase {
+    private const string NUMBEROFINPUTVARIABLES = "NumberOfInputVariables";
     private const string FUNCTIONLIBRARY = "FunctionLibrary";
     private const string TARGETVARIABLE = "TargetVariable";
-    private const string ALLOWEDFEATURES = "AllowedFeatures";
     private const string MINTIMEOFFSET = "MinTimeOffset";
     private const string MAXTIMEOFFSET = "MaxTimeOffset";
@@ -70,8 +70,8 @@
     public FunctionLibraryInjector()
       : base() {
+      AddVariableInfo(new VariableInfo(NUMBEROFINPUTVARIABLES, "The number of available input variables", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo(TARGETVARIABLE, "The target variable", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo(ALLOWEDFEATURES, "List of indexes of allowed features", typeof(ItemList<IntData>), VariableKind.In));
-      AddVariableInfo(new Core.VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), Core.VariableKind.In));
-      AddVariableInfo(new Core.VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), Core.VariableKind.In));
+      AddVariableInfo(new VariableInfo(MINTIMEOFFSET, "Minimal time offset for all features", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo(MAXTIMEOFFSET, "Maximal time offset for all feature", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo(FUNCTIONLIBRARY, "Preconfigured default operator library", typeof(GPOperatorLibrary), VariableKind.New));
 
@@ -111,6 +111,5 @@
       StructId.Variable variable;
       GPOperatorLibrary operatorLibrary;
-
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>(ALLOWEDFEATURES, scope, true);
+      int nInputVariables = GetVariableValue<IntData>(NUMBEROFINPUTVARIABLES, scope, true).Data;
       int targetVariable = GetVariableValue<IntData>(TARGETVARIABLE, scope, true).Data;
 
@@ -226,11 +225,6 @@
       ConditionalAddOperator(XOR_ALLOWED, operatorLibrary, xor);
 
-      int[] allowedIndexes = new int[allowedFeatures.Count];
-      for (int i = 0; i < allowedIndexes.Length; i++) {
-        allowedIndexes[i] = allowedFeatures[i].Data;
-      }
-
-      variable.SetConstraints(allowedIndexes, minTimeOffset, maxTimeOffset);
-      differential.SetConstraints(allowedIndexes, minTimeOffset, maxTimeOffset);
+      variable.SetConstraints(1, nInputVariables, minTimeOffset, maxTimeOffset);
+      differential.SetConstraints(1, nInputVariables, minTimeOffset, maxTimeOffset);
 
       scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName(FUNCTIONLIBRARY), operatorLibrary));
Index: /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Variable.cs
===================================================================
--- /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Variable.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.GP.StructureIdentification/3.3/Variable.cs	(revision 2165)
@@ -154,53 +154,28 @@
     }
 
-    public void SetConstraints(int[] allowedIndexes, int minSampleOffset, int maxSampleOffset) {
+    public void SetConstraints(int minInputIndex, int maxInputIndex, int minSampleOffset, int maxSampleOffset) {
       ConstrainedIntData offset = GetVariableValue<ConstrainedIntData>(OFFSET, null, false);
-      IntBoundedConstraint rangeConstraint = new IntBoundedConstraint();
+      IntBoundedConstraint offsetConstraint = new IntBoundedConstraint();
       this.minOffset = minSampleOffset;
       this.maxOffset = maxSampleOffset;
-      rangeConstraint.LowerBound = minSampleOffset;
-      rangeConstraint.LowerBoundEnabled = true;
-      rangeConstraint.LowerBoundIncluded = true;
-      rangeConstraint.UpperBound = maxSampleOffset;
-      rangeConstraint.UpperBoundEnabled = true;
-      rangeConstraint.UpperBoundIncluded = true;
-      offset.AddConstraint(rangeConstraint);
+      offsetConstraint.LowerBound = minSampleOffset;
+      offsetConstraint.LowerBoundEnabled = true;
+      offsetConstraint.LowerBoundIncluded = true;
+      offsetConstraint.UpperBound = maxSampleOffset;
+      offsetConstraint.UpperBoundEnabled = true;
+      offsetConstraint.UpperBoundIncluded = true;
+      offset.AddConstraint(offsetConstraint);
 
       ConstrainedIntData index = GetVariableValue<ConstrainedIntData>(INDEX, null, false);
-      Array.Sort(allowedIndexes);
-      minIndex = allowedIndexes[0]; maxIndex = allowedIndexes[allowedIndexes.Length - 1];
-      List<IConstraint> constraints = new List<IConstraint>();
-      int start = allowedIndexes[0];
-      int prev = start;
-      for(int i = 1; i < allowedIndexes.Length; i++) {
-        if(allowedIndexes[i] != prev + 1) {
-          IntBoundedConstraint lastRange = new IntBoundedConstraint();
-          lastRange.LowerBound = start;
-          lastRange.LowerBoundEnabled = true;
-          lastRange.LowerBoundIncluded = true;
-          lastRange.UpperBound = prev;
-          lastRange.UpperBoundEnabled = true;
-          lastRange.UpperBoundIncluded = true;
-          constraints.Add(lastRange);
-          start = allowedIndexes[i];
-          prev = start;
-        }
-        prev = allowedIndexes[i];
-      }
-      IntBoundedConstraint range = new IntBoundedConstraint();
-      range.LowerBound = start;
-      range.LowerBoundEnabled = true;
-      range.LowerBoundIncluded = true;
-      range.UpperBound = prev;
-      range.UpperBoundEnabled = true;
-      range.UpperBoundIncluded = true;
-      constraints.Add(range);
-      if(constraints.Count > 1) {
-        OrConstraint or = new OrConstraint();
-        foreach(IConstraint c in constraints) or.Clauses.Add(c);
-        index.AddConstraint(or);
-      } else {
-        index.AddConstraint(constraints[0]);
-      }
+      IntBoundedConstraint indexConstraint = new IntBoundedConstraint();
+      minIndex = minInputIndex;
+      maxIndex = maxInputIndex;
+      indexConstraint.LowerBound = minInputIndex;
+      indexConstraint.LowerBoundEnabled = true;
+      indexConstraint.LowerBoundIncluded = true;
+      indexConstraint.UpperBound = maxInputIndex;
+      indexConstraint.UpperBoundEnabled = true;
+      indexConstraint.UpperBoundIncluded = true;
+      index.AddConstraint(indexConstraint);
 
       SetupInitialization();
Index: /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegressionOperator.cs
===================================================================
--- /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegressionOperator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.LinearRegression/3.2/LinearRegressionOperator.cs	(revision 2165)
@@ -38,5 +38,4 @@
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesEnd", "End index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("AllowedFeatures", "List of indexes of allowed features", typeof(ItemList<IntData>), VariableKind.In));
       AddVariableInfo(new VariableInfo("LinearRegressionModel", "Formula that was calculated by linear regression", typeof(IFunctionTree), VariableKind.Out | VariableKind.New));
       AddVariableInfo(new VariableInfo("TreeSize", "The size (number of nodes) of the tree", typeof(IntData), VariableKind.New | VariableKind.Out));
@@ -49,20 +48,11 @@
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
       int end = GetVariableValue<IntData>("SamplesEnd", scope, true).Data;
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>("AllowedFeatures", scope, true);
-      List<int> allowedRows = CalculateAllowedRows(dataset, allowedFeatures, targetVariable, start, end);
+      List<int> allowedRows = CalculateAllowedRows(dataset, targetVariable, start, end);
+      List<int> allowedColumns = CalculateAllowedColumns(dataset, targetVariable, start, end);
 
-      List<IntData> disallowedFeatures = new List<IntData>();
-      foreach (IntData allowedFeature in allowedFeatures) {
-        if (IsAlmost(dataset.GetMinimum(allowedFeature.Data, start, end), 0.0) &&
-            IsAlmost(dataset.GetMaximum(allowedFeature.Data, start, end), 0.0)) 
-          disallowedFeatures.Add(allowedFeature);
-      }
-      foreach (IntData disallowedFeature in disallowedFeatures)
-        allowedFeatures.Remove(disallowedFeature);
-
-      double[,] inputMatrix = PrepareInputMatrix(dataset, allowedFeatures, allowedRows);
+      double[,] inputMatrix = PrepareInputMatrix(dataset, allowedColumns, allowedRows);
       double[] targetVector = PrepareTargetVector(dataset, targetVariable, allowedRows);
       double[] coefficients = CalculateCoefficients(inputMatrix, targetVector);
-      IFunctionTree tree = CreateModel(coefficients, allowedFeatures);
+      IFunctionTree tree = CreateModel(coefficients, allowedColumns);
 
       scope.AddVariable(new HeuristicLab.Core.Variable(scope.TranslateName("LinearRegressionModel"), tree));
@@ -76,5 +66,5 @@
     }
 
-    private IFunctionTree CreateModel(double[] coefficients, ItemList<IntData> allowedFeatures) {
+    private IFunctionTree CreateModel(double[] coefficients, List<int> allowedColumns) {
       IFunctionTree root = new Addition().GetTreeNode();
       IFunctionTree actNode = root;
@@ -84,5 +74,5 @@
       for (int i = 0; i < coefficients.Length - 1; i++) {
         v = new GP.StructureIdentification.Variable();
-        v.GetVariable(GP.StructureIdentification.Variable.INDEX).Value = new ConstrainedIntData(allowedFeatures[i].Data);
+        v.GetVariable(GP.StructureIdentification.Variable.INDEX).Value = new ConstrainedIntData(allowedColumns[i]);
         v.GetVariable(GP.StructureIdentification.Variable.WEIGHT).Value = new ConstrainedDoubleData(coefficients[i]);
         v.GetVariable(GP.StructureIdentification.Variable.OFFSET).Value = new ConstrainedIntData(0);
@@ -90,5 +80,5 @@
       }
       GP.StructureIdentification.Constant c = new Constant();
-      c.GetVariable(GP.StructureIdentification.Constant.VALUE).Value = new ConstrainedDoubleData(coefficients[coefficients.Length - 1] * 1.0);
+      c.GetVariable(GP.StructureIdentification.Constant.VALUE).Value = new ConstrainedDoubleData(coefficients[coefficients.Length - 1]);
       nodes.Enqueue(c.GetTreeNode());
 
@@ -107,5 +97,5 @@
       double[] weights = new double[targetVector.Length];
       double[] coefficients = new double[inputMatrix.GetLength(1)];
-      for(int i=0;i<weights.Length;i++) weights[i] = 1.0;
+      for (int i = 0; i < weights.Length; i++) weights[i] = 1.0;
       // call external ALGLIB solver
       leastsquares.buildgeneralleastsquares(ref targetVector, ref weights, ref inputMatrix, inputMatrix.GetLength(0), inputMatrix.GetLength(1), ref coefficients);
@@ -115,11 +105,11 @@
 
     //returns list of valid row indexes (rows without NaN values)
-    private List<int> CalculateAllowedRows(Dataset dataset, ItemList<IntData> allowedFeatures, int targetVariable, int start, int end) {
+    private List<int> CalculateAllowedRows(Dataset dataset, int targetVariable, int start, int end) {
       List<int> allowedRows = new List<int>();
       bool add;
       for (int row = start; row < end; row++) {
         add = true;
-        for (int col = 0; col < allowedFeatures.Count && add == true; col++) {
-          if (double.IsNaN(dataset.GetValue(row, allowedFeatures[col].Data)) ||
+        for (int col = 0; col < dataset.Columns && add == true; col++) {
+          if (double.IsNaN(dataset.GetValue(row, col)) ||
               double.IsNaN(dataset.GetValue(row, targetVariable)))
             add = false;
@@ -132,14 +122,26 @@
     }
 
-    private double[,] PrepareInputMatrix(Dataset dataset, ItemList<IntData> allowedFeatures, List<int> allowedRows) {
+    //returns list of valid column indexes (columns which contain at least one non-zero value)
+    private List<int> CalculateAllowedColumns(Dataset dataset, int targetVariable, int start, int end) {
+      List<int> allowedColumns = new List<int>();
+      for (int i = 0; i < dataset.Columns; i++) {
+        if (i == targetVariable) continue;
+        if (!IsAlmost(dataset.GetMinimum(i, start, end), 0.0) ||
+            !IsAlmost(dataset.GetMaximum(i, start, end), 0.0))
+          allowedColumns.Add(i);
+      }
+      return allowedColumns;
+    }
+
+    private double[,] PrepareInputMatrix(Dataset dataset, List<int> allowedColumns, List<int> allowedRows) {
       int rowCount = allowedRows.Count;
-      double[,] matrix = new double[rowCount, allowedFeatures.Count + 1];
-      for (int col = 0; col < allowedFeatures.Count; col++) {
+      double[,] matrix = new double[rowCount, allowedColumns.Count + 1];
+      for (int col = 0; col < allowedColumns.Count; col++) {
         for (int row = 0; row < allowedRows.Count; row++)
-          matrix[row, col] = dataset.GetValue(allowedRows[row], allowedFeatures[col].Data);
+          matrix[row, col] = dataset.GetValue(allowedRows[row], allowedColumns[col]);
       }
       //add constant 1.0 in last column
       for (int i = 0; i < rowCount; i++)
-        matrix[i, allowedFeatures.Count] = constant;
+        matrix[i, allowedColumns.Count] = constant;
       return matrix;
     }
Index: /trunk/sources/HeuristicLab.Modeling/3.2/ProblemInjector.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/ProblemInjector.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/ProblemInjector.cs	(revision 2165)
@@ -77,4 +77,5 @@
 
       AddVariableInfo(new VariableInfo("MaxNumberOfTrainingSamples", "Maximal number of training samples to use (optional)", typeof(IntData), VariableKind.In));
+      AddVariableInfo(new VariableInfo("NumberOfInputVariables", "The number of available input variables", typeof(IntData), VariableKind.New));
     }
 
@@ -97,10 +98,7 @@
       Dataset scopeDataset = CreateNewDataset(operatorDataset, targetVariable, operatorAllowedFeatures);
 
-      ItemList<IntData> allowedFeatures = new ItemList<IntData>();
-      allowedFeatures.AddRange(Enumerable.Range(1, scopeDataset.Columns -1 ).Select(x=>new IntData(x)));
-
       scope.AddVariable(new Variable("Dataset", scopeDataset));
-      scope.AddVariable(new Variable("AllowedFeatures", allowedFeatures));
       scope.AddVariable(new Variable("TargetVariable", new IntData(0)));
+      scope.AddVariable(new Variable("NumberOfInputVariables", new IntData(scopeDataset.Columns - 1)));
 
       int trainingStart = GetVariableValue<IntData>("TrainingSamplesStart", scope, true).Data;
Index: /trunk/sources/HeuristicLab.Modeling/3.2/VariableEvaluationImpactCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/VariableEvaluationImpactCalculator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/VariableEvaluationImpactCalculator.cs	(revision 2165)
@@ -58,6 +58,6 @@
     }
 
-    protected override double[] CalculateValue(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
-      return GetOutputs(scope, dataset, targetVariable, allowedFeatures, start, end);
+    protected override double[] CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
+      return GetOutputs(scope, dataset, targetVariable, start, end);
     }
 
@@ -75,5 +75,5 @@
     }
 
-    protected abstract double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end);
+    protected abstract double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, int start, int end);
   }
 }
Index: /trunk/sources/HeuristicLab.Modeling/3.2/VariableImpactCalculatorBase.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/VariableImpactCalculatorBase.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/VariableImpactCalculatorBase.cs	(revision 2165)
@@ -34,5 +34,5 @@
 
     public override string Description {
-      get { return @"Calculates the impact of all allowed input variables on the model."; }
+      get { return @"Calculates the impact of all input variables on the model."; }
     }
 
@@ -47,5 +47,4 @@
       AddVariableInfo(new VariableInfo("Dataset", "Dataset", typeof(Dataset), VariableKind.In));
       AddVariableInfo(new VariableInfo("TargetVariable", "TargetVariable", typeof(IntData), VariableKind.In));
-      AddVariableInfo(new VariableInfo("AllowedFeatures", "Indexes of allowed input variables", typeof(ItemList<IntData>), VariableKind.In));
       AddVariableInfo(new VariableInfo("TrainingSamplesStart", "TrainingSamplesStart", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("TrainingSamplesEnd", "TrainingSamplesEnd", typeof(IntData), VariableKind.In));
@@ -54,5 +53,4 @@
 
     public override IOperation Apply(IScope scope) {
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>("AllowedFeatures", scope, true);
       int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
       Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
@@ -61,13 +59,15 @@
       int end = GetVariableValue<IntData>("TrainingSamplesEnd", scope, true).Data;
 
-      T referenceValue = CalculateValue(scope, dataset, targetVariable, allowedFeatures, start, end);
-      double[] impacts = new double[allowedFeatures.Count];
+      T referenceValue = CalculateValue(scope, dataset, targetVariable, start, end);
+      double[] impacts = new double[dataset.Columns];
 
-      for (int i = 0; i < allowedFeatures.Count && !abortRequested; i++) {
-        int currentVariable = allowedFeatures[i].Data;
-        var oldValues = ReplaceVariableValues(dirtyDataset, currentVariable, CalculateNewValues(dirtyDataset, currentVariable, start, end), start, end);
-        T newValue = CalculateValue(scope, dirtyDataset, targetVariable, allowedFeatures, start, end);
-        impacts[i] = CalculateImpact(referenceValue, newValue);
-        ReplaceVariableValues(dirtyDataset, currentVariable, oldValues, start, end);
+      for (int i = 0; i < impacts.Length && !abortRequested; i++) {
+        int currentVariable = i;
+        if (currentVariable != targetVariable) {
+          var oldValues = ReplaceVariableValues(dirtyDataset, currentVariable, CalculateNewValues(dirtyDataset, currentVariable, start, end), start, end);
+          T newValue = CalculateValue(scope, dirtyDataset, targetVariable, start, end);
+          impacts[i] = CalculateImpact(referenceValue, newValue);
+          ReplaceVariableValues(dirtyDataset, currentVariable, oldValues, start, end);
+        }
       }
 
@@ -76,10 +76,12 @@
 
         ItemList variableImpacts = new ItemList();
-        for (int i = 0; i < allowedFeatures.Count; i++) {
-          int currentVariable = allowedFeatures[i].Data;
-          ItemList row = new ItemList();
-          row.Add(new StringData(dataset.GetVariableName(currentVariable)));
-          row.Add(new DoubleData(impacts[i]));
-          variableImpacts.Add(row);
+        for (int i = 0; i < impacts.Length; i++) {
+          int currentVariable = i;
+          if (currentVariable != targetVariable) {
+            ItemList row = new ItemList();
+            row.Add(new StringData(dataset.GetVariableName(currentVariable)));
+            row.Add(new DoubleData(impacts[i]));
+            variableImpacts.Add(row);
+          }
         }
 
@@ -91,5 +93,5 @@
     }
 
-    protected abstract T CalculateValue(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end);
+    protected abstract T CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end);
 
     protected abstract double CalculateImpact(T referenceValue, T newValue);
Index: /trunk/sources/HeuristicLab.Modeling/3.2/VariableQualityImpactCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.Modeling/3.2/VariableQualityImpactCalculator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.Modeling/3.2/VariableQualityImpactCalculator.cs	(revision 2165)
@@ -43,9 +43,9 @@
     }
 
-    protected override double CalculateValue(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
-      return CalculateQuality(scope, dataset, targetVariable, allowedFeatures, start, end);
+    protected override double CalculateValue(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
+      return CalculateQuality(scope, dataset, targetVariable, start, end);
     }
 
-    protected abstract double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end);
+    protected abstract double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end);
   }
 }
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SVMHelper.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SVMHelper.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SVMHelper.cs	(revision 2165)
@@ -9,17 +9,19 @@
 namespace HeuristicLab.SupportVectorMachines {
   public class SVMHelper {
-    public static SVM.Problem CreateSVMProblem(Dataset dataset, ItemList<IntData> allowedFeatures, int targetVariable, int start, int end) {
+    public static SVM.Problem CreateSVMProblem(Dataset dataset, int targetVariable, int start, int end) {
       int rowCount = end - start;
-      double[] samples = dataset.Samples;
+      List<int> skippedFeatures = new List<int>();
+      for (int i = 0; i < dataset.Columns; i++) {
+        if (i != targetVariable) {
+          if (dataset.GetRange(i, start, end) == 0)
+            skippedFeatures.Add(i);
+        }
+      }
 
-      List<int> skippedFeatures = new List<int>();
-      for (int i = 0; i < allowedFeatures.Count; i++) {
-        if (dataset.GetRange(allowedFeatures[i].Data, start, end) == 0)
-          skippedFeatures.Add(i);
-      }
+      int maxColumns = dataset.Columns - skippedFeatures.Count();
 
       double[] targetVector = new double[rowCount];
       for (int i = 0; i < rowCount; i++) {
-        double value = samples[(start + i) * dataset.Columns + targetVariable];
+        double value = dataset.GetValue(start + i, targetVariable);
           targetVector[i] = value;
       }
@@ -31,12 +33,12 @@
       for (int row = 0; row < rowCount; row++) {
         tempRow = new List<SVM.Node>();
-        for (int col = 0; col < allowedFeatures.Count; col++) {
-          if (!skippedFeatures.Contains(col)) {
-            double value = samples[(start + row) * dataset.Columns + allowedFeatures[col].Data];
+        for (int col = 0; col < dataset.Columns; col++) {
+          if (!skippedFeatures.Contains(col) && col!=targetVariable) {
+            double value = dataset.GetValue(start + row, col);
             if (!double.IsNaN(value))
-              tempRow.Add(new SVM.Node(allowedFeatures[col].Data, value));
+              tempRow.Add(new SVM.Node(col, value));
           }
         }
-        if (!double.IsNaN(samples[(start + row) * dataset.Columns + targetVariable])) {
+        if (!double.IsNaN(dataset.GetValue(start + row, targetVariable))) {
           nodes[addedRows] = tempRow.ToArray();
           addedRows++;
@@ -44,5 +46,5 @@
       }
 
-      return new SVM.Problem(targetVector.Length, targetVector, nodes, allowedFeatures.Max(x => x.Data));
+      return new SVM.Problem(targetVector.Length, targetVector, nodes, maxColumns);
     }
   }
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorCreator.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorCreator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorCreator.cs	(revision 2165)
@@ -39,5 +39,4 @@
       //Dataset infos
       AddVariableInfo(new VariableInfo("Dataset", "Dataset with all samples on which to apply the function", typeof(Dataset), VariableKind.In));
-      AddVariableInfo(new VariableInfo("AllowedFeatures", "List of indexes of allowed features", typeof(ItemList<IntData>), VariableKind.In));
       AddVariableInfo(new VariableInfo("TargetVariable", "Index of the column of the dataset that holds the target variable", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
@@ -67,5 +66,4 @@
       abortRequested = false;
       Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>("AllowedFeatures", scope, true);
       int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
@@ -83,5 +81,5 @@
       parameter.Gamma = GetVariableValue<DoubleData>("SVMGamma", scope, true).Data;
 
-      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, allowedFeatures, targetVariable, start, end);
+      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, targetVariable, start, end);
       SVM.RangeTransform rangeTransform = SVM.Scaling.DetermineRange(problem);
       SVM.Problem scaledProblem = SVM.Scaling.Scale(problem, rangeTransform);
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/SupportVectorEvaluator.cs	(revision 2165)
@@ -35,5 +35,4 @@
       //Dataset infos
       AddVariableInfo(new VariableInfo("Dataset", "Dataset with all samples on which to apply the function", typeof(Dataset), VariableKind.In));
-      AddVariableInfo(new VariableInfo("AllowedFeatures", "List of indexes of allowed features", typeof(ItemList<IntData>), VariableKind.In));
       AddVariableInfo(new VariableInfo("TargetVariable", "Index of the column of the dataset that holds the target variable", typeof(IntData), VariableKind.In));
       AddVariableInfo(new VariableInfo("SamplesStart", "Start index of samples in dataset to evaluate", typeof(IntData), VariableKind.In));
@@ -47,5 +46,4 @@
     public override IOperation Apply(IScope scope) {
       Dataset dataset = GetVariableValue<Dataset>("Dataset", scope, true);
-      ItemList<IntData> allowedFeatures = GetVariableValue<ItemList<IntData>>("AllowedFeatures", scope, true);
       int targetVariable = GetVariableValue<IntData>("TargetVariable", scope, true).Data;
       int start = GetVariableValue<IntData>("SamplesStart", scope, true).Data;
@@ -53,5 +51,5 @@
 
       SVMModel modelData = GetVariableValue<SVMModel>("SVMModel", scope, true);
-      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, allowedFeatures, targetVariable, start, end);
+      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, targetVariable, start, end);
       SVM.Problem scaledProblem = SVM.Scaling.Scale(problem, modelData.RangeTransform);
 
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableEvaluationImpactCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableEvaluationImpactCalculator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableEvaluationImpactCalculator.cs	(revision 2165)
@@ -38,7 +38,7 @@
 
 
-    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+    protected override double[] GetOutputs(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
       SVMModel model = GetVariableValue<SVMModel>("SVMModel", scope, true);
-      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, allowedFeatures, targetVariable, start, end);
+      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, targetVariable, start, end);
       SVM.Problem scaledProblem = SVM.Scaling.Scale(problem, model.RangeTransform);
 
Index: /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableQualityImpactCalculator.cs
===================================================================
--- /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableQualityImpactCalculator.cs	(revision 2164)
+++ /trunk/sources/HeuristicLab.SupportVectorMachines/3.2/VariableQualityImpactCalculator.cs	(revision 2165)
@@ -37,7 +37,7 @@
     }
 
-    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, ItemList<IntData> allowedFeatures, int start, int end) {
+    protected override double CalculateQuality(IScope scope, Dataset dataset, int targetVariable, int start, int end) {
       SVMModel model = GetVariableValue<SVMModel>("SVMModel", scope, true);
-      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, allowedFeatures, targetVariable, start, end);
+      SVM.Problem problem = SVMHelper.CreateSVMProblem(dataset, targetVariable, start, end);
       SVM.Problem scaledProblem = SVM.Scaling.Scale(problem, model.RangeTransform);
 
