Changeset 14905 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push

Timestamp:

05/02/17 20:42:40 (8 years ago)

Author:

pkimmesw

Message:

#2665 Made ErcOptions checkable

Location:

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push

Files:

• Configuration/IEnabledExpressionsConfiguration.cs (modified) (1 diff)
• Configuration/PushConfiguration.cs (modified) (5 diffs)
• Expressions/BooleanExpressions.cs (modified) (2 diffs)
• Expressions/Expression.cs (modified) (3 diffs)
• Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs (modified) (3 diffs)
• Views/ExpressionSelectionView.cs (modified) (1 diff)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs

@@ -22 +22 @@
     IList<string> EnabledExpressions { get; }
 
-    void EnableStack(StackTypes types, bool enableExpressions = false);
-    void DisableStack(StackTypes type, bool disableExpressions = false);
-    void SetStack(StackTypes type, bool state, bool cascadeForExpressions = false);
+    void EnableStack(StackTypes types, bool enableExpressions = true, bool enableDependencies = true);
+    void DisableStack(StackTypes type, bool disableExpressions = true, bool enableDepenencies = true);
+    void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true);
     void EnableExpressionOfStack(StackTypes types);
-    void DisableExpressionOfStack(StackTypes types);
+    void DisableExpressionsOfStack(StackTypes types);
     void EnableExpression(string name, bool enableStackIfDisabled = false);
     void DisableExpression(string name, bool disableStackIfEnabled = false);

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs

@@ -3 +3 @@
   using System.Collections.Generic;
   using System.Linq;
-  using Attributes;
   using Base.Erc;
   using Common;
@@ -174 +173 @@
 
         if (types.HasFlag(type))
-          EnableStack(type, true);
+          EnableStack(type, false, true);
       }
     }
 
     public void EnableExpressionOfStack(StackTypes types) {
-      var names = ExpressionTable.StackTypeToNamesTable[types]
-        .Except(EnabledExpressions)
-        .ToArray();
-
-      foreach (var name in names)
+      EnableExpressions(ExpressionTable.StackTypeToNamesTable[types]);
+    }
+
+    public void EnableExpressionDependentOnStack(StackTypes types) {
+      var names = ExpressionTable.StackDependencyToNamesTable[types].Where(
+        name => {
+          var type = ExpressionTable.NameToTypeTable[name];
+          var attribute = ExpressionTable.TypeToAttributeTable[type];
+
+          return (attribute.StackType | attribute.AdditionalStackDependencies)
+            .ToEnumerable()
+            .All(st => enabledStacks.ContainsKey(st) && enabledStacks[st]);
+        });
+
+      EnableExpressions(names);
+    }
+
+    private void EnableExpressions(IEnumerable<string> names) {
+      foreach (var name in names.Except(EnabledExpressions))
         EnabledExpressions.Add(name);
 
@@ -191 +204 @@
     }
 
-    public void DisableExpressionOfStack(StackTypes types) {
-      var names = ExpressionTable.StackTypeToNamesTable[types]
-        .Intersect(EnabledExpressions)
-        .ToArray();
-
-      foreach (var name in names)
+    public void DisableExpressionsOfStack(StackTypes types) {
+      DisableExpressions(ExpressionTable.StackTypeToNamesTable[types]);
+    }
+
+    public void DisableExpressionsDependentOnStack(StackTypes types) {
+      var names = ExpressionTable.StackDependencyToNamesTable
+          .Where(pair => pair.Key.HasFlag(types))
+          .SelectMany(pair => pair.Value);
+
+      DisableExpressions(names);
+    }
+
+    private void DisableExpressions(IEnumerable<string> names) {
+      foreach (var name in names.Intersect(EnabledExpressions))
         EnabledExpressions.Remove(name);
 
@@ -241 +262 @@
 
     public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
-      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
+      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
       EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
     }
 
     public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
-      var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(typeof(T), typeof(PushExpressionAttribute));
+      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
       DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
     }
@@ -260 +281 @@
     }
 
-    public void EnableStack(StackTypes type, bool enableExpressions = false) {
+    public void EnableStack(StackTypes type, bool enableExpressions = true, bool enableDependencies = true) {
       enabledStacks[type] = true;
 
-      if (enableExpressions)
-        EnableExpressionOfStack(type);
-    }
-
-    public void DisableStack(StackTypes type, bool disableExpressions = false) {
+      if (enableExpressions) EnableExpressionOfStack(type);
+      if (enableDependencies) EnableExpressionDependentOnStack(type);
+    }
+
+    public void DisableStack(StackTypes type, bool disableExpressions = true, bool disableDependencies = true) {
       enabledStacks[type] = false;
 
-      if (disableExpressions)
-        DisableExpressionOfStack(type);
-    }
-
-    public void SetStack(StackTypes type, bool state, bool cascadeForExpressions = false) {
-      if (state) EnableStack(type, cascadeForExpressions);
-      else DisableStack(type, cascadeForExpressions);
+      if (disableExpressions) DisableExpressionsOfStack(type);
+      if (disableDependencies) DisableExpressionsDependentOnStack(type);
+    }
+
+    public void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true) {
+      if (state) EnableStack(type, setExpressions, setDependencies);
+      else DisableStack(type, setExpressions, setDependencies);
     }
 

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/BooleanExpressions.cs

@@ -11 +11 @@
   [PushExpression(StackTypes.Boolean, "BOOLEAN.AND")]
   public class BooleanAndExpression : StatelessExpression {
-    public override bool Eval(IInternalPushInterpreter interpreter) {
-      if (interpreter.BooleanStack.Count < 2)
-        return false;
+    public bool IsNoop(IInternalPushInterpreter interpreter) {
+      return interpreter.BooleanStack.Count < 2;
+    }
 
+    public void TryEval(IInternalPushInterpreter interpreter) {
       var first = interpreter.BooleanStack.Pop();
       var second = interpreter.BooleanStack.Top;
@@ -20 +21 @@
 
       interpreter.BooleanStack.SetTop(result);
+    }
+
+    public override bool Eval(IInternalPushInterpreter interpreter) {
+      if (IsNoop(interpreter))
+        return false;
+
+      TryEval(interpreter);
       return true;
     }

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/Expression.cs

@@ -2 +2 @@
   using System;
   using System.Collections.Generic;
-
-  using HeuristicLab.Problems.ProgramSynthesis.Push.Attributes;
   using HeuristicLab.Problems.ProgramSynthesis.Push.Data.Pool;
 
@@ -10 +8 @@
   [Serializable]
   public abstract class Expression : IPooledObject {
-    public bool IsProgram { get { return this.GetType() == typeof(PushProgram); } }
+    public bool IsProgram { get { return GetType() == typeof(PushProgram); } }
 
     public static readonly IReadOnlyCollection<Expression> EmptyContainer = new Expression[0];
@@ -18 +16 @@
       get
       {
-        var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(this.GetType(), typeof(PushExpressionAttribute));
-
-        return attribute != null
-          ? attribute.ExpressionName
-          : string.Empty;
+        return ExpressionTable.TypeToAttributeTable[GetType()].ExpressionName;
       }
     }
+
+    //public abstract bool IsNoop(IInternalPushInterpreter interpreter);
 
     public abstract bool Eval(IInternalPushInterpreter interpreter);

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Problem/BenchmarkSuite/PushBenchmarkSuiteProblem.cs

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Problem.BenchmarkSuite {
-  using System.Linq;
   using Common;
   using Configuration;
   using Core;
   using Encodings.IntegerVectorEncoding;
-  using Expressions;
   using HeuristicLab.BenchmarkSuite.Problems;
   using Instances;
@@ -46 +44 @@
       config.SetEnabledStacks((StackTypes)data.EnabledDataTypes);
 
-      // update enabled stack types
-      foreach (var stackType in ExpressionTable.StackTypeToNamesTable.Keys) {
-        var enable = config.EnabledExpressions.Intersect(ExpressionTable.StackTypeToNamesTable[stackType]).Any();
-        config.SetStack(stackType, enable);
-      }
-
       Encoding.Bounds[0, 0] = 0;
       Encoding.Bounds[0, 1] = config.EnabledExpressions.Count;
@@ -63 +55 @@
       IReadOnlyPushConfiguration config,
       IPushEvaluator evaluator) {
-      return new PushBenchmarkSuiteSolution(vector, bestQuality, random, config, (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
+      return new PushBenchmarkSuiteSolution(vector, bestQuality, random, (IReadOnlyPushConfiguration)config.Clone(), (PushBenchmarkSuiteEvaluator)PushEvaluator.Clone());
     }
   }

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Views/ExpressionSelectionView.cs

@@ -52 +52 @@
 
       if (e.Node.Parent == null) {
-        Content.SetStack(stackType, e.Node.Checked, true);
+        Content.SetStack(stackType, e.Node.Checked, true, false);
         SetStackNodeText(e.Node);
         foreach (var subNode in e.Node.Nodes.OfType<TreeNode>().Where(n => n.Checked != e.Node.Checked))