Index: branches/HiveHiveEngine/HeuristicLab.Operators/3.3/IntDataReducer.cs
===================================================================
--- branches/HiveHiveEngine/HeuristicLab.Operators/3.3/IntDataReducer.cs	(revision 7325)
+++ branches/HiveHiveEngine/HeuristicLab.Operators/3.3/IntDataReducer.cs	(revision 7391)
@@ -36,15 +36,12 @@
       get { return (ScopeTreeLookupParameter<IntValue>)Parameters["ParameterToReduce"]; }
     }
-    public ValueLookupParameter<StringValue> TargetParameterName {
-      get { return (ValueLookupParameter<StringValue>)Parameters["TargetParameterName"]; }
-    }
-    private LookupParameter<IntValue> TargetParameter {
+    public LookupParameter<IntValue> TargetParameter {
       get { return (LookupParameter<IntValue>)Parameters["TargetParameter"]; }
     }
-    public ValueParameter<ReductionType> ReductionOperation {
-      get { return (ValueParameter<ReductionType>)Parameters["ReductionOperation"]; }
+    public ValueParameter<ReductionOperation> ReductionOperation {
+      get { return (ValueParameter<ReductionOperation>)Parameters["ReductionOperation"]; }
     }
-    public ValueParameter<TargetOperationType> TargetOperation {
-      get { return (ValueParameter<TargetOperationType>)Parameters["TargetOperation"]; }
+    public ValueParameter<ReductionOperation> TargetOperation {
+      get { return (ValueParameter<ReductionOperation>)Parameters["TargetOperation"]; }
     }
     #endregion
@@ -59,8 +56,7 @@
       #region Create parameters
       Parameters.Add(new ScopeTreeLookupParameter<IntValue>("ParameterToReduce", "The parameter on which the reduction operation should be applied."));
-      Parameters.Add(new ValueLookupParameter<StringValue>("TargetParameterName", "Parameter to store the result in.", new StringValue(string.Empty)));
-      Parameters.Add(new LookupParameter<IntValue>("TargetParameter", "The actual parameter defined by TargetParameterName."));
-      Parameters.Add(new ValueParameter<ReductionType>("ReductionOperation", "The reduction operation to perform."));
-      Parameters.Add(new ValueParameter<TargetOperationType>("TargetOperation", "The target operation to perform."));
+      Parameters.Add(new LookupParameter<IntValue>("TargetParameter", "The target variable in which the reduced value should be stored."));
+      Parameters.Add(new ValueParameter<ReductionOperation>("ReductionOperation", "The operation which is applied on the parameter to reduce."));
+      Parameters.Add(new ValueParameter<ReductionOperation>("TargetOperation", "The operation used to apply the reduced value to the target variable."));
       #endregion
     }
@@ -74,37 +70,40 @@
 
       if (intValues.Count() > 0) {
-        TargetParameter.ActualName = TargetParameterName.ActualValue.Value;
         if (TargetParameter.ActualValue == null) TargetParameter.ActualValue = new IntValue();
 
         int result = 1;
         switch (ReductionOperation.Value.Value) {
-          case ReductionTypes.Sum:
+          case ReductionOperations.Sum:
             result = intValues.Sum(x => x.Value);
             break;
-          case ReductionTypes.Prod:
+          case ReductionOperations.Prod:
             intValues.ForEach(x => result *= x.Value);
             break;
-          case ReductionTypes.Avg:
+          case ReductionOperations.Avg:
             result = (int)Math.Round(intValues.Average(x => x.Value));
             break;
-          case ReductionTypes.Min:
+          case ReductionOperations.Min:
             result = intValues.Min(x => x.Value);
             break;
-          case ReductionTypes.Max:
+          case ReductionOperations.Max:
             result = intValues.Max(x => x.Value);
             break;
+          default:
+            throw new InvalidOperationException("Operation " + ReductionOperation.Value.Value + " is not supported as ReductionOperation.");
         }
 
         switch (TargetOperation.Value.Value) {
-          case TargetOperationTypes.Set:
+          case ReductionOperations.Assign:
             TargetParameter.ActualValue.Value = result;
             break;
-          case TargetOperationTypes.Sum:
+          case ReductionOperations.Sum:
             TargetParameter.ActualValue.Value += result;
             break;
-          case TargetOperationTypes.Prod:
+          case ReductionOperations.Prod:
             if (TargetParameter.ActualValue.Value == 0) TargetParameter.ActualValue.Value = 1;
             TargetParameter.ActualValue.Value *= result;
             break;
+          default:
+            throw new InvalidOperationException("Operation " + TargetOperation.Value.Value + " is not supported as TargetOperation.");
         }
       }
