Changeset 722

Timestamp:

11/08/08 13:55:59 (15 years ago)

Author:

gkronber

Message:

fixed bugs in GP.boolean plugin #340 (Plugin for genetic programming for boolean logic)

Location:

trunk/sources/HeuristicLab.GP.Boolean

Files:

• BooleanTreeInterpreter.cs (modified) (3 diffs)
• FunctionLibraryInjector.cs (modified) (5 diffs)

trunk/sources/HeuristicLab.GP.Boolean/BooleanTreeInterpreter.cs

@@ -37 +37 @@
     private int targetVariable;
     private int currentRow;
+    private Dictionary<IFunctionTree, int> cachedIndex = new Dictionary<IFunctionTree, int>();
 
     public void Reset(Dataset dataset, IFunctionTree tree, int targetVariable) {
@@ -42 +43 @@
       this.tree = tree;
       this.targetVariable = targetVariable;
+      cachedIndex.Clear();
     }
 
     internal int GetNumberMatchingInstances(int start, int end) {
       int matchingInstances = 0;
-      for(int i = start; i < end; i++) {
+      for (int i = start; i < end; i++) {
         currentRow = i;
         int result = Step(tree) ? 1 : 0;
-        if(result - dataset.GetValue(i, targetVariable) < EPSILON) matchingInstances++;
+        if (Math.Abs(result - dataset.GetValue(i, targetVariable)) < EPSILON) matchingInstances++;
       }
       return matchingInstances;
@@ -56 +58 @@
     internal bool Step(IFunctionTree tree) {
       int symbol = SymbolTable.MapFunction(tree.Function);
-      switch(symbol) {
-        case SymbolTable.AND: return Step(tree.SubTrees[0]) & Step(tree.SubTrees[0]);
-        case SymbolTable.OR: return Step(tree.SubTrees[0]) | Step(tree.SubTrees[0]);
+      switch (symbol) {
+        case SymbolTable.AND: return Step(tree.SubTrees[0]) && Step(tree.SubTrees[1]);
+        case SymbolTable.OR: return Step(tree.SubTrees[0]) || Step(tree.SubTrees[1]);
         case SymbolTable.NOT: return !Step(tree.SubTrees[0]);
         case SymbolTable.XOR: return Step(tree.SubTrees[0]) ^ Step(tree.SubTrees[1]);
-        case SymbolTable.NAND: return !(Step(tree.SubTrees[0]) & Step(tree.SubTrees[0]));
-        case SymbolTable.NOR: return !(Step(tree.SubTrees[0]) | Step(tree.SubTrees[0]));
+        case SymbolTable.NAND: return !(Step(tree.SubTrees[0]) && Step(tree.SubTrees[1]));
+        case SymbolTable.NOR: return !(Step(tree.SubTrees[0]) || Step(tree.SubTrees[1]));
         case SymbolTable.VARIABLE:
-          int index = ((ConstrainedIntData)tree.LocalVariables.ToArray()[0].Value).Data;
-          if(dataset.GetValue(currentRow, targetVariable) == 0.0) return false;
-          else return true;
+          int index;
+          if (cachedIndex.TryGetValue(tree, out index)==false) {
+          } else {
+            index = ((ConstrainedIntData)tree.LocalVariables.ToArray()[0].Value).Data;
+            cachedIndex[tree] = index;
+          }
+          return dataset.GetValue(currentRow, index) != 0.0;
         case SymbolTable.UNKNOWN:
         default:

trunk/sources/HeuristicLab.GP.Boolean/FunctionLibraryInjector.cs

@@ -31 +31 @@
 namespace HeuristicLab.GP.Boolean {
   public class FunctionLibraryInjector : OperatorBase {
+    private const string TARGETVARIABLE = "TargetVariable";
+    private const string ALLOWEDFEATURES = "AllowedFeatures";
     private const string OPERATORLIBRARY = "FunctionLibrary";
 
     private GPOperatorLibrary operatorLibrary;
+    private Variable variable;
 
     public override string Description {
@@ -41 +44 @@
     public FunctionLibraryInjector()
       : 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));
       return null;
@@ -57 +77 @@
       Nor nor = new Nor();
       Xor xor = new Xor();
-      HeuristicLab.GP.Boolean.Variable variable = new HeuristicLab.GP.Boolean.Variable();
+      variable = new HeuristicLab.GP.Boolean.Variable();
 
       IFunction[] allFunctions = new IFunction[] {
@@ -74 +94 @@
       SetAllowedSubOperators(nand, allFunctions);
       SetAllowedSubOperators(nor, allFunctions);
-      SetAllowedSubOperators(not, allFunctions);
+      SetAllowedSubOperators(xor, allFunctions);
 
       operatorLibrary = new GPOperatorLibrary();
@@ -87 +107 @@
 
     private void SetAllowedSubOperators(IFunction f, IFunction[] gs) {
-      foreach(IConstraint c in f.Constraints) {
-        if(c is SubOperatorTypeConstraint) {
+      foreach (IConstraint c in f.Constraints) {
+        if (c is SubOperatorTypeConstraint) {
           SubOperatorTypeConstraint typeConstraint = c as SubOperatorTypeConstraint;
           typeConstraint.Clear();
-          foreach(IFunction g in gs) {
+          foreach (IFunction g in gs) {
             typeConstraint.AddOperator(g);
           }
-        } else if(c is AllSubOperatorsTypeConstraint) {
+        } else if (c is AllSubOperatorsTypeConstraint) {
           AllSubOperatorsTypeConstraint typeConstraint = c as AllSubOperatorsTypeConstraint;
           typeConstraint.Clear();
-          foreach(IFunction g in gs) {
+          foreach (IFunction g in gs) {
             typeConstraint.AddOperator(g);
           }