Changeset 9392 for branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3

Timestamp:

04/23/13 13:31:29 (11 years ago)

Author:

sforsten

Message:

#1980:

• several small bug fixes
• added windowing technique ILAS to GAssist
• GAssist and XCS work now with real-valued features
• severely improved the performance of XCS

Location:

branches/LearningClassifierSystems/HeuristicLab.Encodings.VariableVector/3.3

Files:

• Crossover/SinglePointCrossover.cs (modified) (1 diff)
• Manipulator/UniformOnePositionInConditionManipulator.cs (modified) (1 diff)
• Variable/DoubleVariable.cs (modified) (1 diff)
• Variable/IntVariable.cs (modified) (1 diff)
• Variable/StringVariable.cs (modified) (2 diffs)
• VariableVectorActionComparer.cs (modified) (2 diffs)
• VariableVectorCondition.cs (modified) (2 diffs)

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

@@ -62 +62 @@
       IList<IVariable> newCondition = new List<IVariable>(parent1Condition.VariableDictionary.Count);
 
-      var keyEnumerator = parent1Condition.Order.GetEnumerator();
+      var keyEnumerator = parent1Condition.VariableDictionary.Keys.GetEnumerator();
 
       int index = 0;

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

@@ -54 +54 @@
         throw new ArgumentOutOfRangeException();
       }
-      var keyEnumerator = condition.Order.GetEnumerator();
+      var keyEnumerator = condition.VariableDictionary.Keys.GetEnumerator();
       int count = 0;
       keyEnumerator.MoveNext();

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

@@ -130 +130 @@
       var targetCast = target as DoubleVariable;
       if (targetCast == null) { return false; }
-      if (variableName != targetCast.variableName || currentCenter.IsAlmost(targetCast.currentCenter)
-        || currentSpread.IsAlmost(targetCast.currentSpread) || max.IsAlmost(targetCast.max)
-        || min.IsAlmost(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;

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

@@ -133 +133 @@
         || currentValue != targetCast.currentValue) { return false; }
 
-      if (possibleFeatures.Except(targetCast.possibleFeatures).Count() != 0
-        || targetCast.possibleFeatures.Except(possibleFeatures).Count() != 0) { return false; }
+      var thisEnumerator = possibleFeatures.GetEnumerator();
+      var castEnumerator = targetCast.possibleFeatures.GetEnumerator();
+      while (thisEnumerator.MoveNext() && castEnumerator.MoveNext()) {
+        if (thisEnumerator.Current != castEnumerator.Current)
+          return false;
+      }
 
-      return true;
+      return !thisEnumerator.MoveNext() && !castEnumerator.MoveNext();
     }
 

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

@@ -87 +87 @@
       featureMapping = new Dictionary<int, string>();
       var distinctValuesEnumerator = variableValues.Distinct().GetEnumerator();
-      possibleFeatures = Enumerable.Range(0, featureMapping.Count());
+      possibleFeatures = Enumerable.Range(0, variableValues.Count());
       var possibleFeaturesEnumerator = possibleFeatures.GetEnumerator();
       while (possibleFeaturesEnumerator.MoveNext() && distinctValuesEnumerator.MoveNext()) {
@@ -178 +178 @@
         || currentValue != targetCast.currentValue) { return false; }
 
-      if (featureMapping.Keys.Except(targetCast.featureMapping.Keys).Count() != 0
-        || targetCast.featureMapping.Keys.Except(featureMapping.Keys).Count() != 0) { return false; }
-
-      foreach (var keyValuePair in targetCast.featureMapping) {
-        if (!featureMapping[keyValuePair.Key].Equals(keyValuePair.Value)) { return false; }
-      }
-
-      return true;
+      var thisEnumerator = featureMapping.GetEnumerator();
+      var castEnumerator = targetCast.featureMapping.GetEnumerator();
+      while (thisEnumerator.MoveNext() && castEnumerator.MoveNext()) {
+        if (thisEnumerator.Current.Key != castEnumerator.Current.Key ||
+          thisEnumerator.Current.Value != castEnumerator.Current.Value)
+          return false;
+      }
+
+      return !thisEnumerator.MoveNext() && !castEnumerator.MoveNext();
     }
 

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

@@ -21 +21 @@
 
 using System.Collections.Generic;
-using System.Linq;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -43 +42 @@
 
     public bool Equals(VariableVectorAction x, VariableVectorAction y) {
-      if (!x.Order.SequenceEqual(y.Order)) return false;
-      foreach (var key in x.VariableDictionary.Keys) {
-        if (!x.VariableDictionary[key].Identical(y.VariableDictionary[key])) {
-          return false;
+      //if (!x.Order.SequenceEqual(y.Order)) return false;
+      var xEnumerator = x.VariableDictionary.Keys.GetEnumerator();
+      var yEnumerator = y.VariableDictionary.Keys.GetEnumerator();
+      while (xEnumerator.MoveNext() && yEnumerator.MoveNext())
+        foreach (var key in x.VariableDictionary.Keys) {
+          if (xEnumerator.Current != yEnumerator.Current ||
+            !x.VariableDictionary[xEnumerator.Current].Identical(y.VariableDictionary[yEnumerator.Current])) {
+            return false;
+          }
         }
-      }
-      return true;
+      return !xEnumerator.MoveNext() && !yEnumerator.MoveNext();
     }
 

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

@@ -39 +39 @@
       protected set { variableDictionary = value; }
     }
-
-    public IOrderedEnumerable<string> Order { get { return VariableDictionary.Keys.OrderBy(x => x); } }
 
     public int VirtualLength { get { return VariableDictionary.Values.Sum(x => x.VirtualLength); } }
@@ -110 +108 @@
 
     public bool Identical(VariableVectorCondition target) {
-      if (!this.Order.SequenceEqual(target.Order)) { return false; }
-      foreach (var keyValuePair in target.VariableDictionary) {
-        if (!VariableDictionary[keyValuePair.Key].Identical(keyValuePair.Value)) {
+      var thisEnumerator = VariableDictionary.GetEnumerator();
+      var targetEnumerator = target.VariableDictionary.GetEnumerator();
+
+      while (thisEnumerator.MoveNext() && targetEnumerator.MoveNext()) {
+        if (thisEnumerator.Current.Key != targetEnumerator.Current.Key ||
+          !thisEnumerator.Current.Value.Identical(targetEnumerator.Current.Value)) {
           return false;
         }
       }
-      return true;
+
+      return !thisEnumerator.MoveNext() && !targetEnumerator.MoveNext();
     }
   }