Changeset 14777 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs

Timestamp:

03/23/17 01:11:18 (7 years ago)

Author:

pkimmesw

Message:

#2665 simplifier, push solution results view, performance improvements, small bug fixes, ui fixes

File:

• branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Expressions/ExpressionTable.cs (modified) (9 diffs)

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

@@ -10 +10 @@
   public static class ExpressionTable {
     public static readonly IDictionary<string, Expression> StatelessExpressionTable;
-    public static readonly IDictionary<string, Func<Expression>> StatefullExpressionFactory;
-    public static readonly IDictionary<StackType, IList<string>> StackTypeToNamesTable = new Dictionary<StackType, IList<string>>();
+    public static readonly IDictionary<string, Func<Expression>> StatefulExpressionFactory;
+    public static readonly IDictionary<StackTypes, IList<string>> StackTypeToNamesTable = new Dictionary<StackTypes, IList<string>>();
     public static readonly IDictionary<int, string> IndexToNameTable = new Dictionary<int, string>();
     public static readonly IDictionary<Type, string> TypeToNameTable = new Dictionary<Type, string>();
+    public static readonly IDictionary<StackTypes, IList<string>> StackDependencyToNamesTable = new Dictionary<StackTypes, IList<string>>();
     public static readonly string[] ExpressionNames;
 
+    public static readonly Type[] StatelessExpressionTypes;
+    public static readonly Type[] StatefulExpressionTypes;
+
     public static readonly int Count;
 
     static ExpressionTable() {
+      StatelessExpressionTypes = GetExpressionTypes(typeof(StatelessExpression)).ToArray();
+      StatefulExpressionTypes = GetExpressionTypes(typeof(StatefulExpression<>)).ToArray();
+
       StatelessExpressionTable = GetStatelessExpressionTable();
-      StatefullExpressionFactory = GetStatefullExpressionFactory();
-      ExpressionNames = StatelessExpressionTable.Keys.Concat(StatefullExpressionFactory.Keys).ToArray();
-
-      Count = StatelessExpressionTable.Count + StatefullExpressionFactory.Count;
+      StatefulExpressionFactory = GetStatefulExpressionFactory();
+      ExpressionNames = StatelessExpressionTable.Keys.Concat(StatefulExpressionFactory.Keys).ToArray();
+
+      Count = StatelessExpressionTable.Count + StatefulExpressionFactory.Count;
     }
 
@@ -38 +45 @@
       get
       {
-        return StatefullExpressionFactory.Count;
+        return StatefulExpressionFactory.Count;
       }
     }
@@ -44 +51 @@
     private static Dictionary<string, Expression> GetStatelessExpressionTable() {
       var dictionary = new Dictionary<string, Expression>();
-      var expressionTypes = GetExpressionTypes(typeof(StatelessExpression));
-
-      foreach (var type in expressionTypes) {
+
+      foreach (var type in StatelessExpressionTypes) {
         var expression = Activator.CreateInstance(type) as Expression;
         var attribute = (PushExpressionAttribute)Attribute.GetCustomAttribute(type, typeof(PushExpressionAttribute));
@@ -54 +60 @@
         TypeToNameTable.Add(type, attribute.ExpressionName);
 
-        if (!StackTypeToNamesTable.ContainsKey(attribute.StackType)) {
-          StackTypeToNamesTable.Add(attribute.StackType, new List<string>());
-        }
-
-        StackTypeToNamesTable[attribute.StackType].Add(attribute.ExpressionName);
+        if (!StackTypeToNamesTable.ContainsKey(attribute.StackTypes)) {
+          StackTypeToNamesTable.Add(attribute.StackTypes, new List<string>());
+        }
+
+        StackTypeToNamesTable[attribute.StackTypes].Add(attribute.ExpressionName);
+
+        var dependencies = attribute.StackTypes | attribute.AdditionalStackDependencies;
+        if (!StackDependencyToNamesTable.ContainsKey(dependencies)) {
+          StackDependencyToNamesTable.Add(dependencies, new List<string>());
+        }
+
+        StackDependencyToNamesTable[dependencies].Add(attribute.ExpressionName);
       }
 
@@ -64 +77 @@
     }
 
-    private static Dictionary<string, Func<Expression>> GetStatefullExpressionFactory() {
+    private static Dictionary<string, Func<Expression>> GetStatefulExpressionFactory() {
       var dictionary = new Dictionary<string, Func<Expression>>();
-      var statefullExpressionType = typeof(StatefulExpression<>);
-      var expressionTypes = GetExpressionTypes(statefullExpressionType);
-
-      foreach (var type in expressionTypes) {
+
+      foreach (var type in StatefulExpressionTypes) {
         // Make a NewExpression that calls the ctor
         var newExp = System.Linq.Expressions.Expression.New(type);
@@ -81 +92 @@
         TypeToNameTable.Add(type, attribute.ExpressionName);
 
-        if (!StackTypeToNamesTable.ContainsKey(attribute.StackType)) {
-          StackTypeToNamesTable.Add(attribute.StackType, new List<string>());
-        }
-
-        StackTypeToNamesTable[attribute.StackType].Add(attribute.ExpressionName);
+        if (!StackTypeToNamesTable.ContainsKey(attribute.StackTypes)) {
+          StackTypeToNamesTable.Add(attribute.StackTypes, new List<string>());
+        }
+
+        StackTypeToNamesTable[attribute.StackTypes].Add(attribute.ExpressionName);
+
+        var dependencies = attribute.StackTypes | attribute.AdditionalStackDependencies;
+        if (!StackDependencyToNamesTable.ContainsKey(dependencies)) {
+          StackDependencyToNamesTable.Add(dependencies, new List<string>());
+        }
+
+        StackDependencyToNamesTable[dependencies].Add(attribute.ExpressionName);
       }
 
@@ -124 +142 @@
     }
 
+    public static IReadOnlyList<string> GetEnabledExpressionsByStackTypes(StackTypes allowedTypes) {
+      return StackDependencyToNamesTable
+          .Where(entry => (entry.Key & ~allowedTypes) == StackTypes.None)
+          .SelectMany(entry => entry.Value)
+          .ToArray();
+    }
+
     public static PushProgram GetProgram(IManagedPool<PushProgram> pool, int[] index) {
       var expressions = new Expression[index.Length];
@@ -142 +167 @@
 
       if (!TryGetStatelessExpression(name, out expression) &&
-          !TryGetStatefullExpression(name, out expression))
+          !TryGetStatefulExpression(name, out expression))
         throw new InvalidOperationException(string.Format("Expression with name {0} not found", name));
 
@@ -153 +178 @@
 
     public static Expression GetStatelessExpression(string name) {
-      Expression expression;
-      if (StatelessExpressionTable.TryGetValue(name, out expression))
-        return expression;
+      if (StatelessExpressionTable.ContainsKey(name))
+        return StatelessExpressionTable[name];
       throw new NotSupportedException("Expression not supported: " + name);
     }
 
     public static bool TryGetStatelessExpression(string name, out Expression expression) {
-      return StatelessExpressionTable.TryGetValue(name, out expression);
-    }
-
-    public static Expression GetStatefullExpression<T>() {
-      return GetStatefullExpression(TypeToNameTable[typeof(T)]);
-    }
-
-    public static Expression GetStatefullExpression(string name) {
+      if (!StatelessExpressionTable.ContainsKey(name)) {
+        expression = null;
+        return false;
+      }
+
+      expression = StatelessExpressionTable[name];
+
+      return true;
+    }
+
+    public static Expression GetStatefulExpression<T>() {
+      return GetStatefulExpression(TypeToNameTable[typeof(T)]);
+    }
+
+    public static Expression GetStatefulExpression(string name) {
       Func<Expression> creator;
-      if (StatefullExpressionFactory.TryGetValue(name, out creator))
+      if (StatefulExpressionFactory.TryGetValue(name, out creator))
         return creator();
       throw new NotSupportedException("Expression not supported: " + name);
     }
 
-    public static bool TryGetStatefullExpression(string name, out Expression expression) {
-      Func<Expression> creator;
-
-      if (StatefullExpressionFactory.TryGetValue(name, out creator)) {
-        expression = creator();
+    public static bool TryGetStatefulExpression(string name, out Expression expression) {
+      if (StatefulExpressionFactory.ContainsKey(name)) {
+        expression = StatefulExpressionFactory[name]();
         return true;
       }