Changeset 9089 for branches/LearningClassifierSystems/HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs

Timestamp:

12/27/12 19:14:51 (11 years ago)

Author:

sforsten

Message:

#1980:

• added ConditionActionClassificationProblem
• added ConditionActionEncoding
• added Manipulators, Crossovers and an LCSAdaptedGeneticAlgorithm
• changed LearningClassifierSystemMainLoop

Location:

branches/LearningClassifierSystems

Files:

• . (modified) (1 prop)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3 (modified) (1 prop)
• HeuristicLab.Encodings.CombinedIntegerVectorEncoding/3.3/CombinedIntegerVector.cs (modified) (10 diffs)

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

@@ -25 +25 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Data;
+using HeuristicLab.Encodings.ConditionActionEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
@@ -31 +33 @@
   [StorableClass]
   [Item("CombinedIntegerVector", "Represents a combined vector of integer values.")]
-  public class CombinedIntegerVector : IntegerVector, IMatching {
+  public class CombinedIntegerVector : IntegerVector, IClassifier {
 
     [Storable]
-    protected int actionPart;
+    protected int actionLength;
+    public int ActionLength { get { return actionLength; } }
 
     /// <summary>
@@ -42 +45 @@
     /// </summary>
     [Storable]
-    protected int[,] bounds;
+    protected IntMatrix bounds;
+    public IntMatrix Bounds { get { return (IntMatrix)bounds.Clone(); } }
 
     [StorableConstructor]
@@ -48 +52 @@
     public CombinedIntegerVector() : base() { }
 
-    public CombinedIntegerVector(int[] elements, int actionPart, int[,] bounds)
+    public CombinedIntegerVector(int[] elements, int actionPart, IntMatrix bounds)
       : base(elements) {
-      this.actionPart = actionPart;
+      this.actionLength = actionPart;
       //check if combinedVector satisfies bounds and if bounds is set correctly (at leats one row with 2 columns) is missing!
       this.bounds = bounds;
     }
 
-    public CombinedIntegerVector(IntegerVector combinedVector, int actionPart, int[,] bounds)
+    public CombinedIntegerVector(IntegerVector combinedVector, int actionPart, IntMatrix bounds)
       : this(combinedVector.ToArray(), actionPart, bounds) { }
 
-    public CombinedIntegerVector(IntegerVector condition, IntegerVector action, int[,] bounds)
+    public CombinedIntegerVector(IntegerVector condition, IntegerVector action, IntMatrix bounds)
       : base(condition.Concat(action).ToArray()) {
-      actionPart = action.Length;
+      actionLength = action.Length;
       //check if combinedVector satisfies bounds and if bounds is set correctly (at leats one row with 2 columns) is missing!
       this.bounds = bounds;
     }
 
+    public CombinedIntegerVector(IntegerVector condition, IntMatrix conditionBounds, IntegerVector action, IntMatrix actionBounds)
+      : this(condition, action, CombineBounds(conditionBounds, actionBounds)) {
+    }
+
+    private static IntMatrix CombineBounds(IntMatrix conditionBounds, IntMatrix actionBounds) {
+      int columns = conditionBounds.Columns < actionBounds.Columns ? conditionBounds.Columns : actionBounds.Columns;
+      IntMatrix bounds = new IntMatrix(conditionBounds.Rows + actionBounds.Rows, columns);
+      for (int i = 0; i < conditionBounds.Rows; i++) {
+        for (int j = 0; j < columns; j++) {
+          bounds[i, j] = conditionBounds[i % conditionBounds.Rows, j];
+        }
+      }
+
+      for (int i = conditionBounds.Rows; i < actionBounds.Rows + conditionBounds.Rows; i++) {
+        for (int j = 0; j < columns; j++) {
+          bounds[i, j] = actionBounds[i % actionBounds.Rows, j];
+        }
+      }
+      return bounds;
+    }
+
     public CombinedIntegerVector(IRandom random, int length, int min, int max, int actionLenght, int actionMin, int actionMax) :
       this(new IntegerVector(length, random, min, max), new IntegerVector(actionLenght, random, actionMin, actionMax), null) {
-      bounds = new int[length + actionLenght, 2];
+      bounds = new IntMatrix(length + actionLenght, 2);
       for (int i = 0; i < length; i++) {
         bounds[i, 0] = min;
@@ -78 +103 @@
     }
 
-    public CombinedIntegerVector(int length, int actionPart, int[,] bounds)
+    public CombinedIntegerVector(int length, int actionPart, IntMatrix bounds)
       : base(length) {
-      this.actionPart = actionPart;
+      this.actionLength = actionPart;
       this.bounds = bounds;
     }
@@ -86 +111 @@
     protected CombinedIntegerVector(CombinedIntegerVector original, Cloner cloner)
       : base(original, cloner) {
-      actionPart = original.actionPart;
-      bounds = (int[,])original.bounds.Clone();
-    }
+      actionLength = original.actionLength;
+      bounds = (IntMatrix)original.bounds.Clone();
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new CombinedIntegerVector(this, cloner);
     }
 
-    public IMatching Condition {
+    public IClassifier Condition {
       get {
-        int[] condition = new int[Length - actionPart];
-        Array.Copy(this.array, condition, Length - actionPart);
+        int[] condition = new int[Length - actionLength];
+        Array.Copy(this.array, condition, Length - actionLength);
         return new CombinedIntegerVector(condition, 0, bounds);
       }
     }
 
-    public IMatching Action {
+    public IClassifier Action {
       get {
-        int[] action = new int[actionPart];
-        Array.Copy(this.array, Length - actionPart, action, 0, actionPart);
-        return new CombinedIntegerVector(action, actionPart, bounds);
-      }
-    }
-
-    public bool MatchCondition(IMatching target) {
+        int[] action = new int[actionLength];
+        Array.Copy(this.array, Length - actionLength, action, 0, actionLength);
+
+        IntMatrix actionBounds = GetElementsOfBoundsForAction(bounds, Length, actionLength);
+        return new CombinedIntegerVector(action, actionLength, actionBounds);
+      }
+    }
+
+    private IntMatrix GetElementsOfBoundsForAction(IntMatrix bounds, int length, int actionPartLength) {
+      IntMatrix actionBounds = new IntMatrix(actionPartLength, bounds.Columns);
+      int start = length - actionPartLength;
+      for (int i = start; i < length; i++) {
+        int pos = i % bounds.Rows;
+        for (int j = 0; j < bounds.Columns; j++) {
+          actionBounds[i - start, j] = bounds[pos, j];
+        }
+      }
+      return actionBounds;
+    }
+
+    public bool MatchCondition(IClassifier target) {
       var targetVector = target as CombinedIntegerVector;
       if (targetVector == null) return false;
@@ -115 +155 @@
 
       int curbounds;
-      for (int i = 0; i < this.Length - this.actionPart; i++) {
-        curbounds = i % bounds.GetLength(0);
+      for (int i = 0; i < this.Length - this.actionLength; i++) {
+        curbounds = i % bounds.Rows;
         //if don't care symbol is matched, next indices can be checked
         if (this[i].Equals(bounds[curbounds, 1] - 1)) {
@@ -129 +169 @@
 
     // no "don't care" symbols have to be considered
-    public bool MatchAction(IMatching target) {
+    public bool MatchAction(IClassifier target) {
       var targetVector = target as CombinedIntegerVector;
       if (targetVector == null) return false;
-      if (targetVector.actionPart != this.actionPart) return false;
-
-      int curPos = this.Length - this.actionPart;
-      int curTargetPos = targetVector.Length - targetVector.actionPart;
-      for (int i = 0; i < this.actionPart; i++) {
+      if (targetVector.actionLength != this.actionLength) return false;
+
+      int curPos = this.Length - this.actionLength;
+      int curTargetPos = targetVector.Length - targetVector.actionLength;
+      for (int i = 0; i < this.actionLength; i++) {
         if (!this[curPos + i].Equals(targetVector[curTargetPos + i])) {
           return false;
@@ -149 +189 @@
       int curbounds;
       for (int i = 0; i < this.Length; i++) {
-        curbounds = i % bounds.GetLength(0);
-        if (i >= this.Length - this.actionPart || this[i] < bounds[curbounds, 1] - 1) {
+        curbounds = i % bounds.Rows;
+        if (i >= this.Length - this.actionLength || this[i] < bounds[curbounds, 1] - 1) {
           strBuilder.Append(this[i]);
         } else {
@@ -171 +211 @@
     }
 
-    public bool Equals(IMatching other) {
+    public bool Equals(IClassifier other) {
       return this.MatchAction(other) && this.MatchCondition(other);
     }
 
     public override int GetHashCode() {
-      int result = actionPart;
+      int result = actionLength;
       for (int i = 0; i < array.Length; i++) {
         result ^= array[i];