Changeset 16330 for branches/2966_interval_calculation

Timestamp:

11/27/18 10:20:59 (6 years ago)

Author:

chaider

Message:

#2966: Implemented review comments and added IsCompatible method.

Location:

branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• Interpreter/IntervalInterpreter.cs (moved) (moved from branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/Intervalnterpreter.cs) (14 diffs)

branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -199 +199 @@
     <Compile Include="Interfaces\IVariableSymbol.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs" />
-    <Compile Include="Interpreter\Intervalnterpreter.cs" />
+    <Compile Include="Interpreter\IntervalInterpreter.cs" />
     <Compile Include="SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs" />
     <Compile Include="SymbolicDataAnalysisModelComplexityCalculator.cs" />

branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

@@ -1 @@
-using System;
+#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2018 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -12 +33 @@
 namespace HeuristicLab.Algorithms.DataAnalysis.Symbolic {
   [StorableClass]
-  [Item("SymbolicDataAnalysisIntervalArithmeticInterpreter", "Interpreter for interval arithmetic within symbolic regression.")]
+  [Item("IntervalInterpreter", "Intperter for calculation of intervals of symbolic models.")]
   public sealed class IntervalInterpreter : ParameterizedNamedItem, IStatefulItem {
 
     private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
+    private static int InstructionCount = 0;
+
     public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
       get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
@@ -30 +53 @@
 
     public IntervalInterpreter()
-        : base("SymbolicDataAnalysisIntervalArithmeticInterpreter", "Interpreter for interval arithmetic within symbolic regression.") { }
+        : base("IntervalInterpreter", "Intperter for calculation of intervals of symbolic models.") { }
 
     public override IDeepCloneable Clone(Cloner cloner) {
       return new IntervalInterpreter(this, cloner);
     }
+
+    private readonly object syncRoot = new object();
 
     #region IStatefulItem Members
@@ -43 +68 @@
     #endregion
 
-
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IEnumerable<int> rows, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+    private static void ResetInstrucitonCount() {
+      InstructionCount = 0;
+    }
+
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
+      lock (syncRoot) {
+        EvaluatedSolutions++;
+        ResetInstrucitonCount();
+      }
+      var instructions = PrepareInterpreterState(tree, rows, dataset);
+      var x = Evaluate(instructions);
+
+      return x;
+    }
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, Dictionary<string, Interval> customIntervals, IEnumerable<int> rows = null) {
+      lock (syncRoot) {
+        EvaluatedSolutions++;
+        ResetInstrucitonCount();
+      }
+      var instructions = PrepareInterpreterState(tree, rows, null, customIntervals);
+      var x = Evaluate(instructions);
+
+      return x;
+    }
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
+      Dictionary<string, Interval> customIntervals, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals, IEnumerable<int> rows = null) {
+      lock (syncRoot) {
+        EvaluatedSolutions++;
+        ResetInstrucitonCount();
+      }
       intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      var state = PrepareInterpreterState(tree, rows);
-      var x = Evaluate(state, intervals);
-
-      return x;
-    }
-
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows,
-      Dictionary<string, Interval> customIntervals, out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      var instructions = PrepareInterpreterState(tree, rows, dataset, customIntervals);
+      var x = Evaluate(instructions, intervals);
+
+      return x;
+    }
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
+      out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals, IEnumerable<int> rows = null) {
+      lock(syncRoot) {
+        EvaluatedSolutions++;
+        ResetInstrucitonCount();
+      }
       intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      var state = PrepareInterpreterState(tree, rows, dataset, customIntervals);
-      var x = Evaluate(state, intervals);
-
-      return x;
-    }
-
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows,
-      out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
+      var instructions = PrepareInterpreterState(tree, rows, dataset);
+      var x = Evaluate(instructions, intervals);
+
+      return x;
+    }
+
+    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, Dictionary<string, Interval> customIntervals, 
+      out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals, IEnumerable<int> rows = null) {
+      lock (syncRoot) {
+        EvaluatedSolutions++;
+        ResetInstrucitonCount();
+      }
       intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      var state = PrepareInterpreterState(tree, rows, dataset);
-      var x = Evaluate(state, intervals);
-
-      return x;
-    }
-
-    private readonly object syncRoot = new object();
-
-    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree,
-      IEnumerable<int> rows, IDataset dataset = null, Dictionary<string, Interval> customIntervals = null) {
+      var instructions = PrepareInterpreterState(tree, rows, null, customIntervals);
+      var x = Evaluate(instructions, intervals);
+
+      return x;
+    }
+
+    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree,
+      IEnumerable<int> rows = null, IDataset dataset = null, Dictionary<string, Interval> customIntervals = null) {
       Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
-      int necessaryArgStackSize = 0;
+
+      if (dataset == null && customIntervals == null)
+        throw new Exception("No dataset or ranges for intervals are given!");
+
+      if(rows == null)
+        rows = Enumerable.Range(0, dataset.Rows);
 
       foreach (Instruction instr in code) {
@@ -82 +149 @@
           IList<double> values = new List<double>();
 
-          if (dataset != null && customIntervals != null) {
+          if (customIntervals != null) {
             if (customIntervals.ContainsKey(variableTreeNode.VariableName)) {
               instr.data = customIntervals[variableTreeNode.VariableName];
             }
-            else {
-              foreach (var rowEnum in rows) {
-                values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
-              }
-              instr.data = new Interval(values.Min(), values.Max());
-            }
-          }
-          else if (dataset != null) {
+          } else {
             foreach (var rowEnum in rows) {
               values.Add(dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName)[rowEnum]);
@@ -99 +159 @@
             instr.data = new Interval(values.Min(), values.Max());
           }
-          else if (customIntervals != null) {
-            if (customIntervals.ContainsKey(variableTreeNode.VariableName)) {
-              instr.data = customIntervals[variableTreeNode.VariableName];
-            }
-          }
-          else {
-            throw new Exception("No valid input for variables!");
-          }
         }
       }
-
-      return new InterpreterState(code, necessaryArgStackSize);
-    }
-
-    private Interval Evaluate(InterpreterState state, Dictionary<ISymbolicExpressionTreeNode, Interval> intervals) {
-      Instruction currentInstr = state.NextInstruction();
+      return code;
+    }
+
+    private Interval Evaluate(Instruction[] instructions, Dictionary<ISymbolicExpressionTreeNode, Interval> intervals = null) {
+      Instruction currentInstr = instructions[InstructionCount++];
       switch (currentInstr.opCode) {
         //Elementary arithmetic rules
         case OpCodes.Add: {
-            var s = Evaluate(state, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s = Interval.Add(s, Evaluate(state, intervals));
+            var s = Evaluate(instructions, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Add(s, Evaluate(instructions, intervals));
             }
             intervals.Add(currentInstr.dynamicNode, s);
@@ -126 +177 @@
           }
         case OpCodes.Sub: {
-            var s = Evaluate(state, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s = Interval.Subtract(s, Evaluate(state, intervals));
+            var s = Evaluate(instructions, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Subtract(s, Evaluate(instructions, intervals));
             }
             intervals.Add(currentInstr.dynamicNode, s);
@@ -134 +185 @@
           }
         case OpCodes.Mul: {
-            var s = Evaluate(state, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s = Interval.Multiply(s, Evaluate(state, intervals));
+            var s = Evaluate(instructions, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Multiply(s, Evaluate(instructions, intervals));
             }
             intervals.Add(currentInstr.dynamicNode, s);
@@ -142 +193 @@
           }
         case OpCodes.Div: {
-            var s = Evaluate(state, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s = Interval.Divide(s, Evaluate(state, intervals));
+            var s = Evaluate(instructions, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Divide(s, Evaluate(instructions, intervals));
             }
             intervals.Add(currentInstr.dynamicNode, s);
@@ -151 +202 @@
         //Trigonometric functions
         case OpCodes.Sin: {
-            var s = Interval.Sine(Evaluate(state, intervals));
+            var s = Interval.Sine(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
           }
         case OpCodes.Cos: {
-            var s = Interval.Cosine(Evaluate(state, intervals));
+            var s = Interval.Cosine(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
           }
         case OpCodes.Tan: {
-            var s = Interval.Tangens(Evaluate(state, intervals));
+            var s = Interval.Tangens(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
@@ -167 +218 @@
         //Exponential functions
         case OpCodes.Log: {
-            var s = Interval.Logarithm(Evaluate(state, intervals));
+            var s = Interval.Logarithm(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
           }
         case OpCodes.Exp: {
-            var s = Interval.Exponential(Evaluate(state, intervals));
+            var s = Interval.Exponential(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
           }
         case OpCodes.Power: {
-            var s = Evaluate(state, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s = Interval.Power(s, Evaluate(state, intervals));
+            var s = Evaluate(instructions, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Power(s, Evaluate(instructions, intervals));
             }
             intervals.Add(currentInstr.dynamicNode, s);
@@ -185 +236 @@
           }
         case OpCodes.Square: {
-            var s = Interval.Square(Evaluate(state, intervals));
+            var s = Interval.Square(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
           }
         case OpCodes.Root: {
-            var s = Evaluate(state, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              s = Interval.Root(s, Evaluate(state, intervals));
+            var s = Evaluate(instructions, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              s = Interval.Root(s, Evaluate(instructions, intervals));
             }
             intervals.Add(currentInstr.dynamicNode, s);
@@ -198 +249 @@
           }
         case OpCodes.SquareRoot: {
-            var s = Interval.SquareRoot(Evaluate(state, intervals));
+            var s = Interval.SquareRoot(Evaluate(instructions, intervals));
             intervals.Add(currentInstr.dynamicNode, s);
             return s;
@@ -214 +265 @@
           }
         default:
-          throw new NotSupportedException();
-      }
+          throw new NotSupportedException("Tree contains an unknown symbol.");
+      }
+    }
+
+    public static bool IsCompatible(ISymbolicExpressionTree tree) {
+      var containsUnknownSyumbol = (
+        from n in tree.Root.GetSubtree(0).IterateNodesPrefix()
+        where
+          !(n.Symbol is StartSymbol) &&
+          !(n.Symbol is Addition) &&
+          !(n.Symbol is Subtraction) &&
+          !(n.Symbol is Multiplication) &&
+          !(n.Symbol is Division) &&
+          !(n.Symbol is Sine) &&
+          !(n.Symbol is Cosine) &&
+          !(n.Symbol is Tangent) &&
+          !(n.Symbol is Logarithm) &&
+          !(n.Symbol is Exponential) &&
+          !(n.Symbol is Power) &&
+          !(n.Symbol is Square) &&
+          !(n.Symbol is Root) &&
+          !(n.Symbol is SquareRoot) &&
+          !(n.Symbol is Problems.DataAnalysis.Symbolic.Variable) &&
+          !(n.Symbol is Constant)
+        select n).Any();
+      return !containsUnknownSyumbol;
     }
   }