Changeset 15189 for branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter

Timestamp:

07/10/17 21:36:03 (7 years ago)

Author:

pkimmesw

Message:

#2665 Fixed small issues, testet benchmark suite, added INX Expressions

Location:

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

Files:

• Extensions.cs (modified) (1 diff)
• IInternalPushInterpreter.cs (modified) (1 diff)
• IPushInterpreter.cs (modified) (2 diffs)
• PushInterpreter.cs (modified) (8 diffs)
• PushInterpreterPool.cs (modified) (1 diff)

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/Extensions.cs

@@ -25 +25 @@
 
     public static Type GetStackEntryType(this StackTypes stackType) {
+      if (StackProperties.ContainsKey(stackType) &&
+          StackProperties[stackType].PropertyType.IsGenericType) {
+        var genericTypeDef = StackProperties[stackType].PropertyType.GetGenericTypeDefinition();
+        if (genericTypeDef == typeof(IPushStack<>))
+          return genericTypeDef.GetGenericArguments()[0];
+      }
+
       return StackProperties.ContainsKey(stackType)
-        ? StackProperties[stackType].PropertyType.GetGenericArguments().Single()
+        ? StackProperties[stackType]
+            .PropertyType
+            .GetInterfaces()
+            .First(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IPushStack<>))
+            .GetGenericArguments()
+            .First()
         : null;
     }
 
     public static void PrintStacks(this IPushInterpreter interpreter) {
-      var stackTypesType = typeof(StackTypes);
-
-      foreach (StackTypes type in Enum.GetValues(stackTypesType)) {
-        if (!interpreter.Stacks.ContainsKey(type)) continue;
-
-        var stackName = Enum.GetName(stackTypesType, type);
-        var stack = interpreter.Stacks[type];
+      foreach (var pair in interpreter.Stacks) {
+        var stackName = pair.Key.ToString();
+        var stack = interpreter.Stacks[pair.Key];
 
         if (stack.IsEmpty || !stack.IsEnabled) continue;
 
-        var stackString = string.Join(" ", interpreter.StringifyStack(type).Reverse());
+        var stackString = string.Join(" ", interpreter.StringifyStack(pair.Key).Reverse());
         Console.WriteLine("--------- {0} ---------\n{1}\n", stackName, stackString);
       }

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IInternalPushInterpreter.cs

@@ -1 +1 @@
 namespace HeuristicLab.Problems.ProgramSynthesis.Push.Interpreter {
+  using System.Collections.Generic;
+
+  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
+
   public interface IInternalPushInterpreter : IPushInterpreter {
     InterpreterPoolContainer PoolContainer { get; }
     bool IsNameQuoteFlagSet { get; set; }
+    IReadOnlyList<Expression> InputExpressions { get; }
   }
 }

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/IPushInterpreter.cs

@@ -24 +24 @@
     IPushStack<IReadOnlyList<bool>> BooleanVectorStack { get; }
     IPushStack<IReadOnlyList<string>> StringVectorStack { get; }
-    IPushStack<string> PrintStack { get; }
+    IPrintStack PrintStack { get; }
     IDictionary<string, Expression> CustomExpressions { get; }
     IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; }
@@ -30 +30 @@
     void Clear();
     void Reset();
+
+    void SetInput(
+      IReadOnlyList<long> integers = null,
+      IReadOnlyList<double> floats = null,
+      IReadOnlyList<bool> booleans = null,
+      IReadOnlyList<char> chars = null,
+      IReadOnlyList<string> strings = null,
+      IReadOnlyList<IReadOnlyList<long>> integerVectors = null,
+      IReadOnlyList<IReadOnlyList<double>> floatVectors = null,
+      IReadOnlyList<IReadOnlyList<string>> stringVectors = null);
 
     void Run(bool stepwise);

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreter.cs

@@ -2 +2 @@
   using System;
   using System.Collections.Generic;
+  using System.Linq;
   using System.Runtime.CompilerServices;
   using System.Threading;
@@ -35 +36 @@
       BooleanVectorStack = new PushStack<IReadOnlyList<bool>>();
       StringVectorStack = new PushStack<IReadOnlyList<string>>();
-      PrintStack = new PushStack<string>();
+      PrintStack = new PrintStack();
 
       Stacks = new Dictionary<StackTypes, IPushStack> {
@@ -53 +54 @@
       };
 
+      supportedStackTypes = Stacks.Keys.ToArray();
+
       CustomExpressions = new Dictionary<string, Expression>();
       PoolContainer = poolContainer ?? new InterpreterPoolContainer();
@@ -63 +66 @@
     }
 
+    private readonly StackTypes[] supportedStackTypes;
     public IReadOnlyDictionary<StackTypes, IPushStack> Stacks { get; private set; }
 
@@ -128 +132 @@
     public IPushStack<IReadOnlyList<string>> StringVectorStack { get; private set; }
     [PushStack(StackTypes.Print)]
-    public IPushStack<string> PrintStack { get; private set; }
+    public IPrintStack PrintStack { get; private set; }
 
     public IDictionary<string, Expression> CustomExpressions { get; private set; }
 
     public bool IsNameQuoteFlagSet { get; set; }
+
+    private readonly List<Expression> inputExpressions = new List<Expression>();
+    IReadOnlyList<Expression> IInternalPushInterpreter.InputExpressions { get { return inputExpressions; } }
+
+    public void SetInput(
+      IReadOnlyList<long> integers = null,
+      IReadOnlyList<double> floats = null,
+      IReadOnlyList<bool> booleans = null,
+      IReadOnlyList<char> chars = null,
+      IReadOnlyList<string> strings = null,
+      IReadOnlyList<IReadOnlyList<long>> integerVectors = null,
+      IReadOnlyList<IReadOnlyList<double>> floatVectors = null,
+      IReadOnlyList<IReadOnlyList<string>> stringVectors = null) {
+
+      // Integer
+      if (integers != null && integers.Count > 0) {
+        var integerPushExpressionPool = PoolContainer.GetStatefulExpressionPool<IntegerPushExpression>();
+
+        for (var i = 0; i < integers.Count; i++) {
+          var expression = IntegerPushExpression.Create(integerPushExpressionPool, integers[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // Float
+      if (floats != null && floats.Count > 0) {
+        var floatPushExpressionPool = PoolContainer.GetStatefulExpressionPool<FloatPushExpression>();
+
+        for (var i = 0; i < floats.Count; i++) {
+          var expression = FloatPushExpression.Create(floatPushExpressionPool, floats[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // Booleans
+      if (booleans != null && booleans.Count > 0) {
+        var booleanPushExpressionPool = PoolContainer.GetStatefulExpressionPool<BooleanPushExpression>();
+
+        for (var i = 0; i < booleans.Count; i++) {
+          var expression = BooleanPushExpression.Create(booleanPushExpressionPool, booleans[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // Char
+      if (chars != null && chars.Count > 0) {
+        var charPushExpressionPool = PoolContainer.GetStatefulExpressionPool<CharPushExpression>();
+
+        for (var i = 0; i < chars.Count; i++) {
+          var expression = CharPushExpression.Create(charPushExpressionPool, chars[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // String
+      if (strings != null && strings.Count > 0) {
+        var stringPushExpressionPool = PoolContainer.GetStatefulExpressionPool<StringPushExpression>();
+
+        for (var i = 0; i < strings.Count; i++) {
+          var expression = StringPushExpression.Create(stringPushExpressionPool, strings[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // IntegerVector
+      if (integerVectors != null && integerVectors.Count > 0) {
+        var integerVectorPushExpressionPool = PoolContainer.GetStatefulExpressionPool<IntegerVectorPushExpression>();
+
+        for (var i = 0; i < integerVectors.Count; i++) {
+          var expression = IntegerVectorPushExpression.Create(integerVectorPushExpressionPool, integerVectors[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // FloatVector
+      if (floatVectors != null && floatVectors.Count > 0) {
+        var floatVectorPushExpressionPool = PoolContainer.GetStatefulExpressionPool<FloatVectorPushExpression>();
+
+        for (var i = 0; i < floatVectors.Count; i++) {
+          var expression = FloatVectorPushExpression.Create(floatVectorPushExpressionPool, floatVectors[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+
+      // StringVector
+      if (stringVectors != null && stringVectors.Count > 0) {
+        var stringVectorPushExpressionPool = PoolContainer.GetStatefulExpressionPool<StringVectorPushExpression>();
+
+        for (var i = 0; i < stringVectors.Count; i++) {
+          var expression = StringVectorPushExpression.Create(stringVectorPushExpressionPool, stringVectors[i]);
+          inputExpressions.Add(expression);
+        }
+      }
+    }
+
 
     public Task RunAsync(string code, CancellationToken token = default(CancellationToken)) {
@@ -240 +339 @@
       currentProgram = null;
 
+      inputExpressions.Clear();
       Clear();
       ConfigureStacks();
@@ -245 +345 @@
 
     private void ConfigureStacks() {
-      foreach (var pair in this.Stacks) {
-        pair.Value.IsEnabled = Configuration.IsStackEnabled(pair.Key);
+      for (var i = 0u; i < supportedStackTypes.Length; i++) {
+        var key = supportedStackTypes[i];
+        Stacks[key].IsEnabled = Configuration.IsStackEnabled(key);
       }
 
@@ -257 +358 @@
     /// </summary>
     public void Clear() {
-      foreach (var stack in Stacks)
-        stack.Value.Clear();
+      for (var i = 0u; i < supportedStackTypes.Length; i++) {
+        var key = supportedStackTypes[i];
+        Stacks[key].Clear();
+      }
 
       CustomExpressions.Clear();

branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Interpreter/PushInterpreterPool.cs

@@ -47 +47 @@
       PushProgramPoolProvider.Clear();
       ExpressionListPoolProvider.Clear();
+      pool.Clear();
     }
   }