Changeset 9242

Timestamp:

02/25/13 12:37:18 (12 years ago)

Author:

sforsten

Message:

#1980:

• fixed several bugs (crossover, subsumption, serialization etc.)
• added ModuloOperator
• CombinedIntegerVectorClassificationProblem\Data and VariableVectorClassificationProblem\Data inherit from ConditionActionClassificationProblem\Data
• it can now be set how often the analyzers have to be executed
• VariableVectorAction, VariableVectorCondition and VariableVectorInput now inherit from Item

Location:

branches/LearningClassifierSystems

Files:

• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs (modified) (5 diffs)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCreator.cs (modified) (2 diffs)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs (modified) (1 diff)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj (modified) (1 diff)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorClassificationProblem.cs (added)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorClassificationProblemData.cs (added)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCreator.cs (modified) (1 diff)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj (modified) (1 diff)
• HeuristicLab.Encodings.ConditionActionEncoding/3.3/Operator/ModuloOperator.cs (added)
• HeuristicLab.Encodings.VariableVector/3.3 (modified) (1 prop)
• HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs (modified) (3 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblem.cs (added)
• HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorClassificationProblemData.cs (added)
• HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Properties (modified) (1 prop)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs (modified) (7 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs (modified) (1 diff)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs (modified) (3 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs (modified) (8 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs (modified) (2 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs (modified) (7 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs (modified) (5 diffs)
• HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs (modified) (3 diffs)
• HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/CombinedIntegerVectorClassificationProblem.cs (modified) (3 diffs)
• HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/CombinedIntegerVectorClassificationProblemData.cs (modified) (1 diff)
• HeuristicLab.Problems.ConditionActionClassification/3.3/ConditionActionClassificationProblem.cs (modified) (2 diffs)
• HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/HeuristicLab.Problems.Instances.ConditionActionClassification-3.3.csproj (modified) (1 diff)
• HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/VariableVectorCVSInstanceProvider.cs (modified) (1 diff)
• HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs (modified) (6 diffs)
• HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs (modified) (4 diffs)

branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystem.cs

@@ -123 +123 @@
     public IConstrainedValueParameter<IManipulator> MutatorParameter {
       get { return (IConstrainedValueParameter<IManipulator>)Parameters["Mutator"]; }
+    }
+    public ValueParameter<IntValue> AnalyzeInIterationParameter {
+      get { return (ValueParameter<IntValue>)Parameters["AnalyzeInIteration"]; }
     }
     #endregion
@@ -253 +256 @@
       Parameters.Add(new ConstrainedValueParameter<ICrossover>("Crossover", "The operator used to cross solutions."));
       Parameters.Add(new ConstrainedValueParameter<IManipulator>("Mutator", "The operator used to mutate solutions."));
+      Parameters.Add(new ValueParameter<IntValue>("AnalyzeInIteration", "", new IntValue(50)));
       #endregion
 
@@ -275 +279 @@
       mainLoop.MutatorParameter.ActualName = MutatorParameter.Name;
       mainLoop.CrossoverProbabilityParameter.ActualName = CrossoverProbabilityParameter.Name;
+      mainLoop.AnalyzeInIterationParameter.ActualName = AnalyzeInIterationParameter.Name;
       #endregion
 

branches/LearningClassifierSystems/HeuristicLab.Algorithms.LearningClassifierSystems/3.3/LearningClassifierSystemMainLoop.cs

@@ -69 +69 @@
       get { return (ValueLookupParameter<IOperator>)Parameters["FinalAnalyzer"]; }
     }
+    public ValueLookupParameter<IntValue> AnalyzeInIterationParameter {
+      get { return (ValueLookupParameter<IntValue>)Parameters["AnalyzeInIteration"]; }
+    }
     #endregion
 
@@ -114 +117 @@
       Parameters.Add(new ValueLookupParameter<IOperator>("Analyzer", "The operator used to analyze each generation."));
       Parameters.Add(new ValueLookupParameter<IOperator>("FinalAnalyzer", "The operator used to analyze the last generation."));
+      Parameters.Add(new ValueLookupParameter<IntValue>("AnalyzeInIteration", ""));
       #endregion
 
@@ -119 +123 @@
       VariableCreator variableCreator = new VariableCreator();
       ResultsCollector resultsCollector = new ResultsCollector();
+      ModuloOperator moduloOperator = new ModuloOperator();
+      Comparator analyzerComparator = new Comparator();
+      ConditionalBranch analyzerConditionalBranch = new ConditionalBranch();
       Placeholder analyzer = new Placeholder();
       Placeholder finalAnalyzer = new Placeholder();
@@ -183 +190 @@
       resultsCollector.CollectedValues.Add(new LookupParameter<IntValue>("Iteration"));
       resultsCollector.ResultsParameter.ActualName = "Results";
+
+      moduloOperator.LeftSideParameter.ActualName = "Iteration";
+      moduloOperator.RightSideParameter.ActualName = AnalyzeInIterationParameter.ActualName;
+      moduloOperator.ResultParameter.ActualName = "ModuloResult";
+
+      analyzerComparator.LeftSideParameter.ActualName = "ModuloResult";
+      analyzerComparator.RightSideParameter.Value = new IntValue(0);
+      analyzerComparator.ResultParameter.ActualName = "DoAnalyzing";
+
+      analyzerConditionalBranch.ConditionParameter.ActualName = "DoAnalyzing";
 
       analyzer.Name = "Analyzer";
@@ -403 +420 @@
       deletionSelectorAfterGA.Successor = leftReducerAfterGA;
       leftReducerAfterGA.Successor = iterationCounter;
-      iterationCounter.Successor = analyzer;
-      analyzer.Successor = maxIterationsComparator;
+      iterationCounter.Successor = moduloOperator;
+      moduloOperator.Successor = analyzerComparator;
+      analyzerComparator.Successor = analyzerConditionalBranch;
+      analyzerConditionalBranch.Successor = maxIterationsComparator;
+      analyzerConditionalBranch.TrueBranch = analyzer;
       #endregion
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVectorCreator.cs

@@ -41 +41 @@
       get { return (LookupParameter<IRandom>)Parameters["Random"]; }
     }
-    public IValueLookupParameter<IntValue> LengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["Length"]; }
+    public IValueLookupParameter<ICombinedIntegerVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<ICombinedIntegerVectorClassificationProblemData>)Parameters["ProblemData"]; }
     }
-    public IValueLookupParameter<IntMatrix> BoundsParameter {
-      get { return (IValueLookupParameter<IntMatrix>)Parameters["Bounds"]; }
+    public ILookupParameter<CombinedIntegerVector> CombinedIntegerVectorParameter {
+      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["CombinedIntegerVector"]; }
     }
 
-    public IValueLookupParameter<IntValue> ActionPartLengthParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters["ActionPartLength"]; }
-    }
-
-    public ILookupParameter<CombinedIntegerVector> CombinedIntegerVectorParameter {
-      get { return (ILookupParameter<CombinedIntegerVector>)Parameters["CombinedIntegerVector"]; }
+    protected ICombinedIntegerVectorClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
     }
 
@@ -62 +58 @@
       : base() {
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("Length", "The length of the vector."));
-      Parameters.Add(new ValueLookupParameter<IntMatrix>("Bounds", "The bounds matrix can contain one row for each dimension with three columns specifying minimum (inclusive), maximum (exclusive), and step size. If less rows are given the matrix is cycled."));
+      Parameters.Add(new ValueLookupParameter<ICombinedIntegerVectorClassificationProblemData>("ProblemData", ""));
       Parameters.Add(new LookupParameter<CombinedIntegerVector>("CombinedIntegerVector", "The vector which should be manipulated."));
-      Parameters.Add(new ValueLookupParameter<IntValue>("ActionPartLength", "The length of the vector."));
     }
 
     public sealed override IOperation Apply() {
-      CombinedIntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, LengthParameter.ActualValue, BoundsParameter.ActualValue, ActionPartLengthParameter.ActualValue);
+      CombinedIntegerVectorParameter.ActualValue = Create(RandomParameter.ActualValue, ProblemData.LengthParameter.Value, ProblemData.BoundsParameter.Value, ProblemData.ActionLengthParameter.Value);
       return base.Apply();
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Covering/CombinedIntegerVectorCoveringCreator.cs

@@ -43 +43 @@
 
     protected override IClassifier CreateCoveredClassifier(IInput input, IAction action, IRandom random, double changeSymbolProbability) {
-      CombinedIntegerVector newCondition = (CombinedIntegerVector)input.Clone();
+      CombinedIntegerVector newCondition = (CombinedIntegerVector)((CombinedIntegerVector)input.Clone()).Condition;
 
       CombinedIntegerVector condition = (CombinedIntegerVector)input;

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj

@@ -128 +128 @@
     <Compile Include="Creators\UniformRandomCombinedIntegerVectorCreator.cs" />
     <Compile Include="Crossovers\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\ICombinedIntegerVectorClassificationProblem.cs" />
+    <Compile Include="Interfaces\ICombinedIntegerVectorClassificationProblemData.cs" />
     <Compile Include="Interfaces\ICombinedIntegerVectorManipulator.cs" />
     <Compile Include="Interfaces\ICombinedIntegerVectorCrossover.cs" />
-    <Compile Include="Interfaces\IBoundedCombinedIntegerVectorOperator.cs" />
     <Compile Include="Interfaces\ICombinedIntegerVectorCreator.cs" />
     <Compile Include="Interfaces\ICombinedIntegerVectorOperator.cs" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/Interfaces/ICombinedIntegerVectorCreator.cs

@@ -23 +23 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.CombinedIntegerVectorEncoding {
-  public interface ICombinedIntegerVectorCreator : ISolutionCreator, IBoundedCombinedIntegerVectorOperator, ICombinedIntegerVectorOperator, IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
-    IValueLookupParameter<IntValue> LengthParameter { get; }
-    IValueLookupParameter<IntValue> ActionPartLengthParameter { get; }
+  public interface ICombinedIntegerVectorCreator : ISolutionCreator, ICombinedIntegerVectorOperator, IOperator, IParameterizedNamedItem, INamedItem, IParameterizedItem, IItem, IContent, IDeepCloneable, ICloneable {
+    IValueLookupParameter<ICombinedIntegerVectorClassificationProblemData> ProblemDataParameter { get; }
     ILookupParameter<CombinedIntegerVector> CombinedIntegerVectorParameter { get; }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.ConditionActionEncoding/3.3/HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj

@@ -118 +118 @@
     <Compile Include="GA\XCSCheckIfGAShouldBeApplied.cs" />
     <Compile Include="Operator\CountNumberOfUniqueActions.cs" />
+    <Compile Include="Operator\ModuloOperator.cs" />
     <Compile Include="Operator\PredictionArrayCalculator.cs" />
     <Compile Include="Operator\MatchActionOperator.cs" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3

@@ -1 +1 @@
 obj
+Plugin.cs

@@ -1 +1 @@
 obj
+Plugin.cs

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Covering/VariableVectorCoveringCreator.cs

@@ -34 +34 @@
   public class VariableVectorCoveringCreator : CoveringSolutionCreator, IVariableVectorCoveringCreator {
 
-    public IValueLookupParameter<VariableVector> SampleVariableVectorParameter {
-      get { return (IValueLookupParameter<VariableVector>)Parameters["SampleVariableVector"]; }
+    public IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IVariableVectorClassificationProblemData>)Parameters["ProblemData"]; }
+    }
+
+    private IVariableVectorClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
     }
 
@@ -45 +49 @@
     public VariableVectorCoveringCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<VariableVector>("SampleVariableVector"));
+      Parameters.Add(new ValueLookupParameter<IVariableVectorClassificationProblemData>("ProblemData"));
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -55 +59 @@
       var actionCast = action as VariableVectorAction;
 
-      VariableVectorCondition sampleVariableVectorCondition = SampleVariableVectorParameter.ActualValue.Condition;
+      VariableVectorCondition sampleVariableVectorCondition = ProblemData.SampleVariableVectorParameter.Value.Condition;
       IEnumerable<IVariable> newCondition = CoverInput(inputCast, sampleVariableVectorCondition, random, changeSymbolProbability);
 
-      return new VariableVector(newCondition, actionCast.Values);
+      return new VariableVector(newCondition, actionCast.VariableDictionary.Values);
     }
 
     private IEnumerable<IVariable> CoverInput(VariableVectorInput input, VariableVectorCondition sample, IRandom random, double changeSymbolProbability) {
-      var conditionVariables = new List<IVariable>();
-      if (!sample.Keys.All(x => input.ContainsKey(x))) {
+      List<IVariable> conditionVariables = new List<IVariable>();
+      if (!sample.VariableDictionary.Keys.All(x => input.InputDictionary.ContainsKey(x))) {
         throw new ArgumentException("Input does not contain all variable names from sample");
       }
-      foreach (var keyValuePair in sample) {
+      foreach (var keyValuePair in sample.VariableDictionary) {
         IVariable variable = keyValuePair.Value.GetEmptyCopy();
-        variable.Cover(random, input[keyValuePair.Key], changeSymbolProbability);
+        variable.Cover(random, input.InputDictionary[keyValuePair.Key], changeSymbolProbability);
         conditionVariables.Add(variable);
       }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Crossover/SinglePointCrossover.cs

@@ -54 +54 @@
 
       if (parent1.Count != parent2.Count && parent1.VirtualLength != parent2.VirtualLength
-        && parent1Condition.Count != parent2Condition.Count && parent1Condition.VirtualLength != parent2Condition.VirtualLength
-        && parent1Action.Count != parent2Action.Count && parent1Action.VirtualLength != parent2Action.VirtualLength)
+        && parent1Condition.VariableDictionary.Count != parent2Condition.VariableDictionary.Count && parent1Condition.VirtualLength != parent2Condition.VirtualLength
+        && parent1Action.VariableDictionary.Count != parent2Action.VariableDictionary.Count && parent1Action.VirtualLength != parent2Action.VirtualLength)
         throw new ArgumentException("SinglePointCrossover: The parents are of different length.");
 
       int conditionLength = parent1Condition.VirtualLength;
       int breakPoint = random.Next(1, conditionLength);
-      IList<IVariable> newCondition = new List<IVariable>(parent1Condition.Count);
+      IList<IVariable> newCondition = new List<IVariable>(parent1Condition.VariableDictionary.Count);
 
       var keyEnumerator = parent1Condition.Order.GetEnumerator();
 
       int index = 0;
-      IVariable curVariable;
+      IVariable curVariable = null;
       while (index < breakPoint) {
-        keyEnumerator.MoveNext();
-        curVariable = parent1Condition[keyEnumerator.Current];
-        if (curVariable.VirtualLength == 1 || index + curVariable.VirtualLength - 1 < breakPoint) {
+        if (!keyEnumerator.MoveNext()) { throw new IndexOutOfRangeException("Enumerator has no next element!"); }
+        curVariable = parent1Condition.VariableDictionary[keyEnumerator.Current];
+        if (index + curVariable.VirtualLength <= breakPoint) {
           newCondition.Add(curVariable.GetSetCopy());
-          index += curVariable.VirtualLength;
         }
+        index += curVariable.VirtualLength;
       }
 
       // breakpoint is in between a variable
       if (index != breakPoint) {
-        newCondition.Add(parent1Condition[keyEnumerator.Current].CrossParentsAtPosition(parent2Condition[keyEnumerator.Current], breakPoint - index - 1));
+        newCondition.Add(parent1Condition.VariableDictionary[keyEnumerator.Current].CrossParentsAtPosition(parent2Condition.VariableDictionary[keyEnumerator.Current], breakPoint - (index - curVariable.VirtualLength)));
       }
 
       while (index < conditionLength) {
         keyEnumerator.MoveNext();
-        curVariable = parent2Condition[keyEnumerator.Current];
+        curVariable = parent2Condition.VariableDictionary[keyEnumerator.Current];
         newCondition.Add(curVariable.GetSetCopy());
         index += curVariable.VirtualLength;
       }
 
-      var action = random.Next(2) == 1 ? parent1Action.Values.Select(x => x.GetSetCopy()) : parent2Action.Values.Select(x => x.GetSetCopy());
+      var action = random.Next(2) == 1 ? parent1Action.VariableDictionary.Values.Select(x => x.GetSetCopy()) : parent2Action.VariableDictionary.Values.Select(x => x.GetSetCopy());
 
       return new VariableVector(newCondition, action);

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/HeuristicLab.Encodings.VariableVector-3.3.csproj

@@ -85 +85 @@
     <Compile Include="Covering\VariableVectorCoveringCreator.cs" />
     <Compile Include="Crossover\SinglePointCrossover.cs" />
+    <Compile Include="Interfaces\IVariableVectorClassificationProblem.cs" />
+    <Compile Include="Interfaces\IVariableVectorClassificationProblemData.cs" />
     <Compile Include="Interfaces\IVariableVectorCoveringCreator.cs" />
     <Compile Include="Interfaces\IVariableVectorCrossover.cs" />

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCoveringCreator.cs

@@ -25 +25 @@
 namespace HeuristicLab.Encodings.VariableVector {
   public interface IVariableVectorCoveringCreator : ICoveringSolutionCreator, IVariableVectorOperator {
-    IValueLookupParameter<VariableVector> SampleVariableVectorParameter { get; }
+    IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter { get; }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Interfaces/IVariableVectorCreator.cs

@@ -21 +21 @@
 
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Optimization;
 
 namespace HeuristicLab.Encodings.VariableVector {
   public interface IVariableVectorCreator : ISolutionCreator, IVariableVectorOperator {
-    IValueLookupParameter<PercentValue> SpreadPercentageParameter { get; }
-    IValueLookupParameter<VariableVector> SampleVariableVectorParameter { get; }
+    IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter { get; }
     ILookupParameter<VariableVector> VariableVectorParameter { get; }
-
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformActionManipulator.cs

@@ -60 +60 @@
       int actionIndex = random.Next(otherActions.Count());
       VariableVectorAction newAction = otherActions.ElementAt(actionIndex);
-      return new VariableVector(child.Condition.Values.Select(x => x.GetSetCopy()), newAction.Values.Select(x => x.GetSetCopy()));
+      return new VariableVector(child.Condition.VariableDictionary.Values.Select(x => x.GetSetCopy()), newAction.VariableDictionary.Values.Select(x => x.GetSetCopy()));
     }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Manipulator/UniformOnePositionInConditionManipulator.cs

@@ -57 +57 @@
       int count = 0;
       keyEnumerator.MoveNext();
-      while (count < condition.VirtualLength && count < index && count + condition[keyEnumerator.Current].VirtualLength <= index) {
-        count += condition[keyEnumerator.Current].VirtualLength;
+      while (count < condition.VirtualLength && count < index && count + condition.VariableDictionary[keyEnumerator.Current].VirtualLength <= index) {
+        count += condition.VariableDictionary[keyEnumerator.Current].VirtualLength;
         keyEnumerator.MoveNext();
       }
-      condition[keyEnumerator.Current].Manipulate(random, input[keyEnumerator.Current], index - count);
+      condition.VariableDictionary[keyEnumerator.Current].Manipulate(random, input.InputDictionary[keyEnumerator.Current], index - count);
       return child;
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/DoubleVariable.cs

@@ -66 +66 @@
       min = original.min;
       max = original.max;
+      currentSpread = original.currentSpread;
+      currentCenter = original.currentCenter;
     }
     public DoubleVariable() : base() { }
@@ -89 +91 @@
 
     public override string ToString() {
-      return (currentCenter - currentCenter) + " - " + (currentCenter + currentSpread);
+      return (currentCenter - currentSpread) + " - " + (currentCenter + currentSpread);
     }
 
@@ -97 +99 @@
 
     public override bool Match(double target) {
-      return currentCenter - currentSpread < target && target < currentCenter + currentSpread;
+      return currentCenter - currentSpread <= target && target <= currentCenter + currentSpread;
     }
 
@@ -128 +130 @@
       var targetCast = target as DoubleVariable;
       if (targetCast == null) { return false; }
-      if (variableName != targetCast.variableName || currentCenter != targetCast.currentCenter
-        || currentSpread != targetCast.currentSpread || max != targetCast.max
-        || min != targetCast.min) { return false; }
+      if (variableName != targetCast.variableName || currentCenter.IsAlmost(targetCast.currentCenter)
+        || currentSpread.IsAlmost(targetCast.currentSpread) || max.IsAlmost(targetCast.max)
+        || min.IsAlmost(targetCast.min)) { return false; }
 
       return true;
@@ -149 +151 @@
     }
 
-    public new DoubleVariable CrossParentsAtPosition(IVariable parent2, int pos) {
-      var parent2Cast = parent2 as DoubleVariable;
+    public override IVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+      DoubleVariable parent2Cast = parent2 as DoubleVariable;
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos > 1 || pos < 0) { throw new ArgumentOutOfRangeException(); }
       DoubleVariable crossed = (DoubleVariable)this.GetSetCopy();
-      if (pos == 0) {
+      if (pos == 1) {
         crossed.CurrentSpread = parent2Cast.CurrentSpread;
       }
@@ -180 +182 @@
 
     public override void Cover(IRandom random, string stringValue, double changeSymbolProbability) {
-      Cover(random, stringValue, 50);
+      CoverWithSpreadPercentage(random, stringValue, changeSymbolProbability);
     }
 
@@ -186 +188 @@
       currentCenter = double.Parse(stringValue);
       double delta = max - min;
-      currentSpread = random.NextDouble() * (delta * (spreadPercentage / 100));
+      currentSpread = random.NextDouble() * (delta * spreadPercentage);
     }
   }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IVariable.cs

@@ -30 +30 @@
 
     IVariable GetEmptyCopy();
+    //GetSetCopy is used instead of Clone, so that data doesn't have to be duplicated
     IVariable GetSetCopy();
 

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/IntVariable.cs

@@ -149 +149 @@
     }
 
-    public new IntVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+    public override IVariable CrossParentsAtPosition(IVariable parent2, int pos) {
       var parent2Cast = parent2 as IntVariable;
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
-      return (IntVariable)this.GetSetCopy();
+      return (IntVariable)parent2.GetSetCopy();
     }
 

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/StringVariable.cs

@@ -198 +198 @@
     }
 
-    public new StringVariable CrossParentsAtPosition(IVariable parent2, int pos) {
+    public override IVariable CrossParentsAtPosition(IVariable parent2, int pos) {
       var parent2Cast = parent2 as StringVariable;
       if (parent2Cast == null) { throw new ArgumentException("Argument is not of the correct type."); }
       if (pos != 0) { throw new ArgumentOutOfRangeException(); }
-      return (StringVariable)this.GetSetCopy();
+      return (StringVariable)parent2.GetSetCopy();
     }
 

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/Variable/Variable.cs

@@ -68 +68 @@
     public abstract bool IsGreaterThanOrEquallyGeneral(IVariable target);
 
-    public virtual IVariable CrossParentsAtPosition(IVariable parent2, int pos) { throw new NotSupportedException("This method is not supported."); }
+    public abstract IVariable CrossParentsAtPosition(IVariable parent2, int pos);
 
     public abstract void Manipulate(IRandom random, string stringValue, int pos);

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVector.cs

@@ -43 +43 @@
 
     public int Count {
-      get { return condition.Count + action.Count; }
+      get { return condition.VariableDictionary.Count + action.VariableDictionary.Count; }
     }
 
     public int VirtualLength {
-      get { return condition.Values.Sum(x => x.VirtualLength) + action.Values.Sum(x => x.VirtualLength); }
+      get { return condition.VariableDictionary.Values.Sum(x => x.VirtualLength) + action.VariableDictionary.Values.Sum(x => x.VirtualLength); }
     }
 
@@ -73 +73 @@
 
     public VariableVector GetEmptyCopy() {
-      return new VariableVector(Condition.Values.Select(x => x.GetEmptyCopy()), Action.Values.Select(x => x.GetEmptyCopy()));
+      return new VariableVector(Condition.VariableDictionary.Values.Select(x => x.GetEmptyCopy()), Action.VariableDictionary.Values.Select(x => x.GetEmptyCopy()));
     }
 
@@ -112 +112 @@
 
     public bool IsMoreGeneral(ICondition target) {
-      var targetCast = target as VariableVector;
+      var targetCast = target as VariableVectorCondition;
       if (targetCast == null) { return false; }
-      if (Condition.Keys.Except(targetCast.Condition.Keys).Count() != 0
-        || targetCast.Condition.Keys.Except(Condition.Keys).Count() != 0) { return false; }
+      if (Condition.VariableDictionary.Keys.Except(targetCast.VariableDictionary.Keys).Count() != 0
+        || targetCast.VariableDictionary.Keys.Except(Condition.VariableDictionary.Keys).Count() != 0) { return false; }
 
-      double thisGenerality = Condition.Values.Sum(x => x.GetGenerality());
-      double targetGenerality = Condition.Values.Sum(x => x.GetGenerality());
+      double thisGenerality = Condition.VariableDictionary.Values.Sum(x => x.GetGenerality());
+      double targetGenerality = targetCast.VariableDictionary.Values.Sum(x => x.GetGenerality());
       if (thisGenerality <= targetGenerality) { return false; }
 
-      foreach (var variables in targetCast.Condition) {
-        if (!Condition[variables.Key].IsGreaterThanOrEquallyGeneral(variables.Value)) {
+      foreach (var variables in targetCast.VariableDictionary) {
+        if (!Condition.VariableDictionary[variables.Key].IsGreaterThanOrEquallyGeneral(variables.Value)) {
           return false;
         }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorAction.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Text;
@@ -33 +31 @@
   [StorableClass]
   [Item("VariableVectorAction", "")]
-  public class VariableVectorAction : Dictionary<string, IActionVariable>, IAction {
+  public class VariableVectorAction : Item, IAction {
 
-    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
+    [Storable]
+    private Dictionary<string, IActionVariable> variableDictionary;
+    public Dictionary<string, IActionVariable> VariableDictionary {
+      get { return variableDictionary; }
+      protected set { variableDictionary = value; }
+    }
 
-    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
+    public IOrderedEnumerable<string> Order { get { return VariableDictionary.Keys.OrderBy(x => x); } }
+
+    public int VirtualLength { get { return VariableDictionary.Values.Sum(x => x.VirtualLength); } }
 
     [StorableConstructor]
     protected VariableVectorAction(bool deserializing) { }
     protected VariableVectorAction(VariableVectorAction original, Cloner cloner) {
-      foreach (var item in original) {
-        Add((string)item.Key.Clone(), (IActionVariable)item.Value.Clone());
+      VariableDictionary = new Dictionary<string, IActionVariable>(original.VariableDictionary.Count);
+      foreach (var item in original.VariableDictionary) {
+        VariableDictionary.Add(item.Key, cloner.Clone(item.Value));
       }
     }
-    public VariableVectorAction() : base() { }
-    public VariableVectorAction(int capacity) : base(capacity) { }
-    public VariableVectorAction(IDictionary<string, IActionVariable> dictionary) : base(dictionary) { }
-
-    //protected override void OnItemsAdded(IEnumerable<KeyValuePair<string, IActionVariable>> items) {
-    //  foreach (var item in items) {
-    //    if (!(item.Value is StringVariable || item.Value is IntVariable)) {
-    //      throw new ArgumentException("Value has to be of type 'StringVariable' or 'IntVariable'");
-    //    }
-    //  }
-    //}
+    public VariableVectorAction()
+      : base() {
+      VariableDictionary = new Dictionary<string, IActionVariable>();
+    }
+    public VariableVectorAction(int capacity)
+      : base() {
+      VariableDictionary = new Dictionary<string, IActionVariable>(capacity);
+    }
+    public VariableVectorAction(IDictionary<string, IActionVariable> dictionary)
+      : base() {
+      VariableDictionary = new Dictionary<string, IActionVariable>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorAction(this, cloner);
+    }
 
     public VariableVectorAction GetEmptyCopy() {
-      VariableVectorAction emptyCopy = new VariableVectorAction(this.Count);
-      foreach (var keyValuePair in this) {
-        emptyCopy.Add(keyValuePair.Key, keyValuePair.Value.GetEmptyCopy());
-      }
+      VariableVectorAction emptyCopy = new VariableVectorAction(VariableDictionary.Count);
+      emptyCopy.Add(VariableDictionary.Values.Select(x => x.GetEmptyCopy()));
       return emptyCopy;
     }
 
     public VariableVectorAction GetSetCopy() {
-      VariableVectorAction setCopy = new VariableVectorAction(this.Count);
-      foreach (var keyValuePair in this) {
-        setCopy.Add(keyValuePair.Key, keyValuePair.Value.GetSetCopy());
-      }
+      VariableVectorAction setCopy = new VariableVectorAction(VariableDictionary.Count);
+      setCopy.Add(VariableDictionary.Values.Select(x => x.GetSetCopy()));
       return setCopy;
     }
@@ -78 +84 @@
       if (targetCast == null) { return false; }
       if (!this.Order.SequenceEqual(targetCast.Order)) { return false; }
-      foreach (var keyValuePair in targetCast) {
-        if (!this[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
+      foreach (var keyValuePair in targetCast.VariableDictionary) {
+        if (!VariableDictionary[keyValuePair.Key].MatchVariable(keyValuePair.Value)) {
           return false;
         }
@@ -88 +94 @@
     public void Add(IEnumerable<IActionVariable> action) {
       foreach (var variable in action) {
-        this.Add(variable.VariableName, variable);
+        VariableDictionary.Add(variable.VariableName, variable);
       }
     }
@@ -95 +101 @@
       StringBuilder sb = new StringBuilder();
       bool first = true;
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         if (first) {
           first = false;
@@ -107 +113 @@
 
     public void Randomize(IRandom random) {
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         variable.Randomize(random);
       }
@@ -113 +119 @@
 
     public bool Identical(VariableVectorAction target) {
-      if (this.Order.SequenceEqual(target.Order)) { return false; }
-      foreach (var keyValuePair in target) {
-        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
+      if (!this.Order.SequenceEqual(target.Order)) { return false; }
+      foreach (var keyValuePair in target.VariableDictionary) {
+        if (!VariableDictionary[keyValuePair.Key].Identical(keyValuePair.Value)) {
           return false;
         }
@@ -121 +127 @@
       return true;
     }
-
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public Version ItemVersion {
-      get { return ItemAttribute.GetVersion(this.GetType()); }
-    }
-    public static Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
-    }
-    public virtual Image ItemImage {
-      get { return ItemAttribute.GetImage(this.GetType()); }
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorAction(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public event EventHandler ItemImageChanged;
-    protected virtual void OnItemImageChanged() {
-      EventHandler handler = ItemImageChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ToStringChanged;
-    protected virtual void OnToStringChanged() {
-      EventHandler handler = ToStringChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorActionComparer.cs

@@ -44 +44 @@
     public bool Equals(VariableVectorAction x, VariableVectorAction y) {
       if (!x.Order.SequenceEqual(y.Order)) return false;
-      foreach (var key in x.Keys) {
-        if (!x[key].Identical(y[key])) {
+      foreach (var key in x.VariableDictionary.Keys) {
+        if (!x.VariableDictionary[key].Identical(y.VariableDictionary[key])) {
           return false;
         }
@@ -54 +54 @@
     public int GetHashCode(VariableVectorAction obj) {
       int result = 1;
-      foreach (var key in obj.Keys) {
+      foreach (var key in obj.VariableDictionary.Keys) {
         result = 37 * result + key.GetHashCode();
       }
 
-      foreach (var val in obj.Values) {
+      foreach (var val in obj.VariableDictionary.Values) {
         result = 37 * result + val.GetHashCode();
       }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCondition.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Text;
@@ -33 +31 @@
   [StorableClass]
   [Item("VariableVectorCondition", "")]
-  public class VariableVectorCondition : Dictionary<string, IVariable>, ICondition {
+  public class VariableVectorCondition : Item, ICondition {
 
-    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
+    [Storable]
+    private Dictionary<string, IVariable> variableDictionary;
+    public Dictionary<string, IVariable> VariableDictionary {
+      get { return variableDictionary; }
+      protected set { variableDictionary = value; }
+    }
 
-    public int VirtualLength { get { return this.Values.Sum(x => x.VirtualLength); } }
+    public IOrderedEnumerable<string> Order { get { return VariableDictionary.Keys.OrderBy(x => x); } }
+
+    public int VirtualLength { get { return VariableDictionary.Values.Sum(x => x.VirtualLength); } }
 
     [StorableConstructor]
     protected VariableVectorCondition(bool deserializing) { }
     protected VariableVectorCondition(VariableVectorCondition original, Cloner cloner) {
-      foreach (var item in original) {
-        Add((string)item.Key.Clone(), (IVariable)item.Value.Clone());
+      VariableDictionary = new Dictionary<string, IVariable>(original.VariableDictionary.Count);
+      foreach (var item in original.VariableDictionary) {
+        VariableDictionary.Add(item.Key, cloner.Clone(item.Value));
       }
     }
-    public VariableVectorCondition() : base() { }
-    public VariableVectorCondition(int capacity) : base(capacity) { }
-    public VariableVectorCondition(IDictionary<string, IVariable> dictionary) : base(dictionary) { }
+    public VariableVectorCondition()
+      : base() {
+      VariableDictionary = new Dictionary<string, IVariable>();
+    }
+    public VariableVectorCondition(int capacity)
+      : base() {
+      VariableDictionary = new Dictionary<string, IVariable>(capacity);
+    }
+    public VariableVectorCondition(IDictionary<string, IVariable> dictionary)
+      : base() {
+      VariableDictionary = new Dictionary<string, IVariable>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorCondition(this, cloner);
+    }
 
     public bool Match(IInput target) {
       var targetCast = target as VariableVectorInput;
       if (targetCast == null) { return false; }
-      if (!this.Keys.All(x => targetCast.Keys.Contains(x))) { return false; }
-      foreach (var key in this.Keys) {
-        if (!this[key].MatchInput(targetCast[key])) {
+      foreach (var key in VariableDictionary.Keys) {
+        if (!targetCast.InputDictionary.ContainsKey(key) || !VariableDictionary[key].MatchInput(targetCast.InputDictionary[key])) {
           return false;
         }
@@ -64 +81 @@
     public void Add(IEnumerable<IVariable> condition) {
       foreach (var variable in condition) {
-        this.Add(variable.VariableName, variable);
+        VariableDictionary.Add(variable.VariableName, variable);
       }
     }
@@ -71 +88 @@
       StringBuilder sb = new StringBuilder();
       bool first = true;
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         if (first) {
           first = false;
@@ -83 +100 @@
 
     public void Randomize(IRandom random, double spreadPercentage) {
-      foreach (var variable in this.Values) {
+      foreach (var variable in VariableDictionary.Values) {
         if (variable is DoubleVariable) {
           ((DoubleVariable)variable).Randomize(random, spreadPercentage);
@@ -94 +111 @@
     public bool Identical(VariableVectorCondition target) {
       if (!this.Order.SequenceEqual(target.Order)) { return false; }
-      foreach (var keyValuePair in target) {
-        if (!this[keyValuePair.Key].Identical(keyValuePair.Value)) {
+      foreach (var keyValuePair in target.VariableDictionary) {
+        if (!VariableDictionary[keyValuePair.Key].Identical(keyValuePair.Value)) {
           return false;
         }
@@ -101 +118 @@
       return true;
     }
-
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public Version ItemVersion {
-      get { return ItemAttribute.GetVersion(this.GetType()); }
-    }
-    public static Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
-    }
-    public virtual Image ItemImage {
-      get { return ItemAttribute.GetImage(this.GetType()); }
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorCondition(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public event EventHandler ItemImageChanged;
-    protected virtual void OnItemImageChanged() {
-      EventHandler handler = ItemImageChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ToStringChanged;
-    protected virtual void OnToStringChanged() {
-      EventHandler handler = ToStringChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorCreator.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Operators;
 using HeuristicLab.Optimization;
@@ -34 +33 @@
 
     #region Parameter Properties
-    public IValueLookupParameter<PercentValue> SpreadPercentageParameter {
-      get { return (IValueLookupParameter<PercentValue>)Parameters["SpreadPercentage"]; }
-    }
-    public IValueLookupParameter<VariableVector> SampleVariableVectorParameter {
-      get { return (IValueLookupParameter<VariableVector>)Parameters["SampleVariableVector"]; }
+    public IValueLookupParameter<IVariableVectorClassificationProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<IVariableVectorClassificationProblemData>)Parameters["ProblemData"]; }
     }
     public ILookupParameter<VariableVector> VariableVectorParameter {
@@ -48 +44 @@
     #endregion
 
+    protected IVariableVectorClassificationProblemData ProblemData {
+      get { return ProblemDataParameter.ActualValue; }
+    }
+
     [StorableConstructor]
     protected VariableVectorCreator(bool deserializing) : base(deserializing) { }
@@ -55 +55 @@
     public VariableVectorCreator()
       : base() {
-      Parameters.Add(new ValueLookupParameter<PercentValue>("SpreadPercentage", ""));
-      Parameters.Add(new ValueLookupParameter<VariableVector>("SampleVariableVector", ""));
+      Parameters.Add(new ValueLookupParameter<IVariableVectorClassificationProblemData>("ProblemData", ""));
       Parameters.Add(new LookupParameter<VariableVector>("VariableVector", ""));
       Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
@@ -62 +61 @@
 
     public override IOperation Apply() {
-      VariableVectorParameter.ActualValue = Create(RandomParameter.ActualValue, SampleVariableVectorParameter.ActualValue, SpreadPercentageParameter.ActualValue.Value);
+      VariableVectorParameter.ActualValue = Create(RandomParameter.ActualValue, ProblemData.SampleVariableVectorParameter.Value, ProblemData.SpreadPercentageParameter.Value.Value);
       return base.Apply();
     }

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3/VariableVectorInput.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Drawing;
 using System.Linq;
 using System.Text;
@@ -33 +32 @@
   [StorableClass]
   [Item("VariableVectorInput", "")]
-  public class VariableVectorInput : Dictionary<string, string>, IInput {
+  public class VariableVectorInput : Item, IInput {
 
-    public IOrderedEnumerable<string> Order { get { return this.Keys.OrderBy(x => x); } }
+    [Storable]
+    private Dictionary<string, string> inputDictionary;
+    public Dictionary<string, string> InputDictionary {
+      get { return inputDictionary; }
+      protected set {
+        inputDictionary = value;
+      }
+    }
+
+    public IOrderedEnumerable<string> Order { get { return InputDictionary.Keys.OrderBy(x => x); } }
 
     [StorableConstructor]
     protected VariableVectorInput(bool deserializing) { }
     protected VariableVectorInput(VariableVectorInput original, Cloner cloner) {
-      foreach (var item in original) {
-        Add((string)item.Key.Clone(), (string)item.Value.Clone());
+      InputDictionary = new Dictionary<string, string>(original.InputDictionary.Count);
+      foreach (var item in original.InputDictionary) {
+        InputDictionary.Add(item.Key, item.Value);
       }
     }
-    public VariableVectorInput() : base() { }
-    public VariableVectorInput(int capacity) : base(capacity) { }
-    public VariableVectorInput(IDictionary<string, string> dictionary) : base(dictionary) { }
+    public VariableVectorInput()
+      : base() {
+      InputDictionary = new Dictionary<string, string>();
+    }
+    public VariableVectorInput(int capacity)
+      : base() {
+      InputDictionary = new Dictionary<string, string>(capacity);
+    }
+    public VariableVectorInput(IDictionary<string, string> dictionary)
+      : base() {
+      InputDictionary = new Dictionary<string, string>(dictionary);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableVectorInput(this, cloner);
+    }
 
     public override string ToString() {
       StringBuilder sb = new StringBuilder();
       bool first = true;
-      foreach (var item in this) {
+      foreach (var item in InputDictionary) {
         if (first) {
           first = false;
@@ -61 +82 @@
       return sb.ToString();
     }
-
-    public virtual string ItemName {
-      get { return ItemAttribute.GetName(this.GetType()); }
-    }
-    public virtual string ItemDescription {
-      get { return ItemAttribute.GetDescription(this.GetType()); }
-    }
-    public Version ItemVersion {
-      get { return ItemAttribute.GetVersion(this.GetType()); }
-    }
-    public static Image StaticItemImage {
-      get { return HeuristicLab.Common.Resources.VSImageLibrary.Class; }
-    }
-    public virtual Image ItemImage {
-      get { return ItemAttribute.GetImage(this.GetType()); }
-    }
-
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      return new VariableVectorInput(this, cloner);
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-
-    public event EventHandler ItemImageChanged;
-    protected virtual void OnItemImageChanged() {
-      EventHandler handler = ItemImageChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-    public event EventHandler ToStringChanged;
-    protected virtual void OnToStringChanged() {
-      EventHandler handler = ToStringChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
   }
 }

branches/LearningClassifierSystems/HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/CombinedIntegerVectorClassificationProblem.cs

@@ -37 +37 @@
   public class CombinedIntegerVectorClassificationProblem : ConditionActionClassificationProblem<UniformRandomCombinedIntegerVectorCreator,
                                                             CombinedIntegerVectorComparer,
-                                                            CombinedIntegerVectorClassificationProblemData> {
+                                                            CombinedIntegerVectorClassificationProblemData>, ICombinedIntegerVectorClassificationProblem {
     public override string ChildName {
       get { return "CombinedIntegerVector"; }
@@ -57 +57 @@
         ProblemDataParameter.Value = value;
         if (value != null) {
-          SetProblemDataSpecificParameters();
+          SetProblemDataSettings();
         }
       }
@@ -91 +91 @@
       Parameters.Add(new FixedValueParameter<ItemSet<CombinedIntegerVector>>("PossibleActionsConcreteClass", new ItemSet<CombinedIntegerVector>(ClassifierComparer)));
 
-      SetProblemDataSpecificParameters();
+      SetProblemDataSettings();
 
       InitializeOperators();
-
-      problemData.Changed += new System.EventHandler(problemData_Changed);
     }
 
-    private void problemData_Changed(object sender, System.EventArgs e) {
-      SetProblemDataSpecificParameters();
-    }
-
-    private void SetProblemDataSpecificParameters() {
-      SolutionCreator.ActionPartLengthParameter.Value = ProblemData.ActionLengthParameter.Value;
-      SolutionCreator.LengthParameter.Value = ProblemData.LengthParameter.Value;
-      SolutionCreator.BoundsParameter.Value = ProblemData.BoundsParameter.Value;
+    protected override void SetProblemDataSettings() {
+      SolutionCreator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
 
       SetPossibleActions();

branches/LearningClassifierSystems/HeuristicLab.Problems.CombinedIntegerVectorClassification/3.3/CombinedIntegerVectorClassificationProblemData.cs

@@ -36 +36 @@
   [StorableClass]
   [Item("CombinedIntegerVectorClassificationProblemData", "A problem data for LCS.")]
-  public class CombinedIntegerVectorClassificationProblemData : ConditionActionClassificationProblemData {
+  public class CombinedIntegerVectorClassificationProblemData : ConditionActionClassificationProblemData, ICombinedIntegerVectorClassificationProblemData {
 
     #region parameter properites

branches/LearningClassifierSystems/HeuristicLab.Problems.ConditionActionClassification/3.3/ConditionActionClassificationProblem.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Linq;
 using HeuristicLab.Common;
@@ -184 +185 @@
       InitializeOperators();
 
-      problemData.Changed += new System.EventHandler(problemData_Changed);
-    }
-
-    private void problemData_Changed(object sender, System.EventArgs e) {
-      SetPossibleActions();
-    }
+      //test event handlers after deserialization
+      RegisterEventHandlers();
+    }
+
+    private void RegisterEventHandlers() {
+      ProblemDataParameter.ValueChanged += new EventHandler(ProblemDataParameter_ValueChanged);
+      if (ProblemDataParameter.Value != null) ProblemDataParameter.Value.Changed += new EventHandler(ProblemData_Changed);
+    }
+
+    private void ProblemDataParameter_ValueChanged(object sender, EventArgs e) {
+      ProblemDataParameter.Value.Changed += new EventHandler(ProblemData_Changed);
+      SetProblemDataSettings();
+      OnReset();
+    }
+
+    private void ProblemData_Changed(object sender, EventArgs e) {
+      SetProblemDataSettings();
+    }
+
+    protected abstract void SetProblemDataSettings();
 
     private void InitializeOperators() {

branches/LearningClassifierSystems/HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/HeuristicLab.Problems.Instances.ConditionActionClassification-3.3.csproj

@@ -79 +79 @@
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.CombinedIntegerVectorEncoding\3.3\HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3.csproj">
+      <Project>{CE7163C5-BFFE-45F0-9BD0-E10EF24E8BD2}</Project>
+      <Name>HeuristicLab.Encodings.CombinedIntegerVectorEncoding-3.3</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.ConditionActionEncoding\3.3\HeuristicLab.Encodings.ConditionActionEncoding-3.3.csproj">
       <Project>{422FB262-0845-4969-8D16-12F057AA90B1}</Project>
       <Name>HeuristicLab.Encodings.ConditionActionEncoding-3.3</Name>
       <Private>False</Private>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.VariableVector\3.3\HeuristicLab.Encodings.VariableVector-3.3.csproj">
+      <Project>{7C116F48-7218-4105-BD6E-EE868E2D4823}</Project>
+      <Name>HeuristicLab.Encodings.VariableVector-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Problems.CombinedIntegerVectorClassification\3.3\HeuristicLab.Problems.CombinedIntegerVectorClassification-3.3.csproj">

branches/LearningClassifierSystems/HeuristicLab.Problems.Instances.ConditionActionClassification/3.3/VariableVectorCVSInstanceProvider.cs

@@ -22 +22 @@
 using System.Collections.Generic;
 using System.Linq;
-using HeuristicLab.Problems.CombinedIntegerVectorClassification;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.Instances.DataAnalysis;
+using HeuristicLab.Problems.VariableVectorClassification;
 
 namespace HeuristicLab.Problems.Instances.ConditionActionClassification {

branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblem.cs

@@ -33 +33 @@
 using HeuristicLab.Problems.DataAnalysis;
 
-namespace HeuristicLab.Problems.CombinedIntegerVectorClassification {
+namespace HeuristicLab.Problems.VariableVectorClassification {
   [StorableClass]
   public class VariableVectorClassificationProblem : ConditionActionClassificationProblem<UniformRandomVariableVectorCreator,
                                                             VariableVectorActionComparer,
-                                                            VariableVectorClassificationProblemData> {
+                                                            VariableVectorClassificationProblemData>, IVariableVectorClassificationProblem {
     public override string ChildName {
       get { return "VariableVector"; }
@@ -49 +49 @@
       get { return (IFixedValueParameter<VariableVectorActionComparer>)Parameters["ClassifierComparer"]; }
     }
+    public IVariableVectorCoveringCreator VariableVectorCoveringCreator {
+      get { return (IVariableVectorCoveringCreator)CoveringSolutionCreator; }
+    }
     #endregion
 
@@ -57 +60 @@
         ProblemDataParameter.Value = value;
         if (value != null) {
-          SetProblemDataSpecificParameters();
+          SetProblemDataSettings();
         }
       }
@@ -91 +94 @@
       Parameters.Add(new FixedValueParameter<ItemSet<VariableVectorAction>>("PossibleActionsConcreteClass", new ItemSet<VariableVectorAction>(ClassifierComparer)));
 
-      coveringSolutionCreator.SampleVariableVectorParameter.ActualName = problemData.SampleVariableVectorParameter.Name;
+      SolutionCreator.VariableVectorParameter.ActualName = ChildName;
 
-      SetProblemDataSpecificParameters();
+      SetProblemDataSettings();
 
       InitializeOperators();
-
-      problemData.Changed += new System.EventHandler(problemData_Changed);
     }
 
-    private void problemData_Changed(object sender, System.EventArgs e) {
-      SetProblemDataSpecificParameters();
-    }
+    protected override void SetProblemDataSettings() {
+      SolutionCreator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
 
-    private void SetProblemDataSpecificParameters() {
-      SolutionCreator.SampleVariableVectorParameter.Value = ProblemData.SampleVariableVectorParameter.Value;
-      SolutionCreator.VariableVectorParameter.ActualName = ChildName;
-      SolutionCreator.SpreadPercentageParameter.Value = ProblemData.SpreadPercentageParameter.Value;
+      VariableVectorCoveringCreator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
 
       SetPossibleActions();
@@ -130 +127 @@
       var sampleAction = ProblemData.SampleVariableVector.Action;
       var actionKeys = sampleAction.Order;
-      var actionsEnumeratorList = sampleAction.ToDictionary(x => x.Key, y => y.Value.GetAllPossibleActions().ToList());
+      var actionsEnumeratorList = sampleAction.VariableDictionary.ToDictionary(x => x.Key, y => y.Value.GetAllPossibleActions().ToList());
       int[] curPos = new int[actionsEnumeratorList.Count];
       //initialize curPos
@@ -145 +142 @@
         cur = 0;
         foreach (var key in actionKeys) {
-          curAction[key].SetTo(actionsEnumeratorList[key][curPos[cur]]);
+          curAction.VariableDictionary[key].SetTo(actionsEnumeratorList[key][curPos[cur]]);
           cur++;
         }

branches/LearningClassifierSystems/HeuristicLab.Problems.VariableVectorClassification/3.3/VariableVectorClassificationProblemData.cs

@@ -33 +33 @@
 using HeuristicLab.Problems.DataAnalysis;
 
-namespace HeuristicLab.Problems.CombinedIntegerVectorClassification {
+namespace HeuristicLab.Problems.VariableVectorClassification {
   [StorableClass]
   [Item("CombinedIntegerVectorClassificationProblemData", "A problem data for LCS.")]
-  public class VariableVectorClassificationProblemData : ConditionActionClassificationProblemData {
+  public class VariableVectorClassificationProblemData : ConditionActionClassificationProblemData, IVariableVectorClassificationProblemData {
 
     #region parameter properites
@@ -90 +90 @@
           var doubleValues = (variableValues as List<double>).Distinct();
           if (doubleValues.All(x => x % 1 == 0)) {
-            variable = new IntVariable(variableName, doubleValues.Select(x => Convert.ToInt32(x)));
+            // ToList call is necessary, because otherwise it wouldn't be possible to serialize it
+            variable = new IntVariable(variableName, doubleValues.Select(x => Convert.ToInt32(x)).ToList());
           } else {
             variable = new DoubleVariable(variableName, doubleValues);
@@ -105 +106 @@
       if (!fetchInputCache.ContainsKey(rowNumber)) {
         VariableVectorInput input = new VariableVectorInput();
-        IEnumerable<string> variableNames = SampleVariableVector.Condition.Keys.Union(SampleVariableVector.Action.Keys);
+        IEnumerable<string> variableNames = SampleVariableVector.Condition.VariableDictionary.Keys.Union(SampleVariableVector.Action.VariableDictionary.Keys);
         foreach (var variableName in variableNames) {
-          input.Add(variableName, Dataset.GetValue(rowNumber, variableName));
+          input.InputDictionary.Add(variableName, Dataset.GetValue(rowNumber, variableName));
         }
         fetchInputCache.Add(rowNumber, input);
@@ -118 +119 @@
       if (!fetchActionCache.ContainsKey(rowNumber)) {
         var action = SampleVariableVector.Action.GetEmptyCopy();
-        foreach (var variableName in action.Keys) {
-          action[variableName].SetTo(Dataset.GetValue(rowNumber, variableName));
+        foreach (var variableName in action.VariableDictionary.Keys) {
+          action.VariableDictionary[variableName].SetTo(Dataset.GetValue(rowNumber, variableName));
         }
         fetchActionCache.Add(rowNumber, action);

@@ -1 +1 @@
 obj
+Plugin.cs