Changeset 17193 for branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter

Timestamp:

08/07/19 13:32:09 (5 years ago)

Author:

mkommend

Message:

#2974: Merged trunk changes into branch.

Location:

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic

Files:

• . (modified) (1 prop)
• 3.4/Interpreter/BatchOperations.cs (modified) (1 diff)
• 3.4/Interpreter/InterpreterState.cs (modified) (1 diff)
• 3.4/Interpreter/IntervalInterpreter.cs (modified) (7 diffs)
• 3.4/Interpreter/OpCodes.cs (modified) (3 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs (modified) (3 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs (modified) (2 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs (modified) (3 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (2 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs (modified) (2 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs (modified) (3 diffs)

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/BatchOperations.cs

@@ -101 +101 @@
     public static void CubeRoot(double[] a, double[] b) {
       for (int i = 0; i < BATCHSIZE; ++i)
-        a[i] = Math.Pow(b[i], 1d / 3d);
+        a[i] = b[i] < 0 ? -Math.Pow(-b[i], 1d / 3d) : Math.Pow(b[i], 1d / 3d);
     }
 

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/InterpreterState.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -69 +69 @@
     #endregion
 
-    public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
-      return GetSymbolicExressionTreeInterval(tree, variableRanges);
-    }
-
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
-      out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
+      return GetSymbolicExpressionTreeInterval(tree, variableRanges);
+    }
+
+    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
-      return GetSymbolicExressionTreeIntervals(tree, variableRanges, out nodeIntervals);
-    }
-
-    public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
+      return GetSymbolicExpressionTreeIntervals(tree, variableRanges, out nodeIntervals);
+    }
+
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -96 +96 @@
 
 
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree,
-      Dictionary<string, Interval> variableRanges, out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
+    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
+      IDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -108 +108 @@
       // fix incorrect intervals if necessary (could occur because of numerical errors)
       nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      foreach(var kvp in intervals) {
+      foreach (var kvp in intervals) {
         var interval = kvp.Value;
         if (interval.IsInfiniteOrUndefined || interval.LowerBound <= interval.UpperBound)
@@ -124 +124 @@
 
 
-    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
+    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
       if (variableRanges == null)
         throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
@@ -141 +141 @@
     }
 
-    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
+    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
       Instruction currentInstr = instructions[instructionCounter];
       //Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
@@ -216 +216 @@
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Tangens(argumentInterval);
+            break;
+          }
+        case OpCodes.Tanh: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.HyperbolicTangent(argumentInterval);
             break;
           }

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  public enum OpCode : byte {
+    Add = 1,
+    Sub = 2,
+    Mul = 3,
+    Div = 4,
+    Sin = 5,
+    Cos = 6,
+    Tan = 7,
+    Log = 8,
+    Exp = 9,
+    IfThenElse = 10,
+    GT = 11,
+    LT = 12,
+    AND = 13,
+    OR = 14,
+    NOT = 15,
+    Average = 16,
+    Call = 17,
+    Variable = 18,
+    LagVariable = 19,
+    Constant = 20,
+    Arg = 21,
+    Power = 22,
+    Root = 23,
+    TimeLag = 24,
+    Integral = 25,
+    Derivative = 26,
+    VariableCondition = 27,
+    Square = 28,
+    SquareRoot = 29,
+    Gamma = 30,
+    Psi = 31,
+    Dawson = 32,
+    ExponentialIntegralEi = 33,
+    CosineIntegral = 34,
+    SineIntegral = 35,
+    HyperbolicCosineIntegral = 36,
+    HyperbolicSineIntegral = 37,
+    FresnelCosineIntegral = 38,
+    FresnelSineIntegral = 39,
+    AiryA = 40,
+    AiryB = 41,
+    Norm = 42,
+    Erf = 43,
+    Bessel = 44,
+    XOR = 45,
+    FactorVariable = 46,
+    BinaryFactorVariable = 47,
+    Absolute = 48,
+    AnalyticQuotient = 49,
+    Cube = 50,
+    CubeRoot = 51,
+    Tanh = 52,
+  };
   public static class OpCodes {
-    public const byte Add = 1;
-    public const byte Sub = 2;
-    public const byte Mul = 3;
-    public const byte Div = 4;
-
-    public const byte Sin = 5;
-    public const byte Cos = 6;
-    public const byte Tan = 7;
-
-    public const byte Log = 8;
-    public const byte Exp = 9;
-
-    public const byte IfThenElse = 10;
-
-    public const byte GT = 11;
-    public const byte LT = 12;
-
-    public const byte AND = 13;
-    public const byte OR = 14;
-    public const byte NOT = 15;
-
-
-    public const byte Average = 16;
-
-    public const byte Call = 17;
-
-    public const byte Variable = 18;
-    public const byte LagVariable = 19;
-    public const byte Constant = 20;
-    public const byte Arg = 21;
-
-    public const byte Power = 22;
-    public const byte Root = 23;
-    public const byte TimeLag = 24;
-    public const byte Integral = 25;
-    public const byte Derivative = 26;
-
-    public const byte VariableCondition = 27;
-
-    public const byte Square = 28;
-    public const byte SquareRoot = 29;
-    public const byte Gamma = 30;
-    public const byte Psi = 31;
-    public const byte Dawson = 32;
-    public const byte ExponentialIntegralEi = 33;
-    public const byte CosineIntegral = 34;
-    public const byte SineIntegral = 35;
-    public const byte HyperbolicCosineIntegral = 36;
-    public const byte HyperbolicSineIntegral = 37;
-    public const byte FresnelCosineIntegral = 38;
-    public const byte FresnelSineIntegral = 39;
-    public const byte AiryA = 40;
-    public const byte AiryB = 41;
-    public const byte Norm = 42;
-    public const byte Erf = 43;
-    public const byte Bessel = 44;
-    public const byte XOR = 45;
-    public const byte FactorVariable = 46;
-    public const byte BinaryFactorVariable = 47;
-    public const byte Absolute = 48;
-    public const byte AnalyticQuotient = 49;
-    public const byte Cube = 50;
-    public const byte CubeRoot = 51;
-
-    public const byte Tanh = 52;
+    // constants for API compatibility only
+    public const byte Add = (byte)OpCode.Add;
+    public const byte Sub =(byte)OpCode.Sub;
+    public const byte Mul =(byte)OpCode.Mul;
+    public const byte Div =(byte)OpCode.Div;
+    public const byte Sin =(byte)OpCode.Sin;
+    public const byte Cos =(byte)OpCode.Cos;
+    public const byte Tan =(byte)OpCode.Tan;
+    public const byte Log =(byte)OpCode.Log;
+    public const byte Exp = (byte)OpCode.Exp;
+    public const byte IfThenElse = (byte)OpCode.IfThenElse;
+    public const byte GT = (byte)OpCode.GT;
+    public const byte LT = (byte)OpCode.LT;
+    public const byte AND = (byte)OpCode.AND;
+    public const byte OR = (byte)OpCode.OR;
+    public const byte NOT = (byte)OpCode.NOT;
+    public const byte Average = (byte)OpCode.Average;
+    public const byte Call = (byte)OpCode.Call;
+    public const byte Variable = (byte)OpCode.Variable;
+    public const byte LagVariable = (byte)OpCode.LagVariable;
+    public const byte Constant = (byte)OpCode.Constant;
+    public const byte Arg = (byte)OpCode.Arg;
+    public const byte Power = (byte)OpCode.Power;
+    public const byte Root = (byte)OpCode.Root;
+    public const byte TimeLag = (byte)OpCode.TimeLag;
+    public const byte Integral = (byte)OpCode.Integral;
+    public const byte Derivative = (byte)OpCode.Derivative;
+    public const byte VariableCondition = (byte)OpCode.VariableCondition;
+    public const byte Square = (byte)OpCode.Square;
+    public const byte SquareRoot = (byte)OpCode.SquareRoot;
+    public const byte Gamma = (byte)OpCode.Gamma;
+    public const byte Psi = (byte)OpCode.Psi;
+    public const byte Dawson = (byte)OpCode.Dawson;
+    public const byte ExponentialIntegralEi = (byte)OpCode.ExponentialIntegralEi;
+    public const byte CosineIntegral = (byte)OpCode.CosineIntegral;
+    public const byte SineIntegral = (byte)OpCode.SineIntegral;
+    public const byte HyperbolicCosineIntegral = (byte)OpCode.HyperbolicCosineIntegral;
+    public const byte HyperbolicSineIntegral = (byte)OpCode.HyperbolicSineIntegral;
+    public const byte FresnelCosineIntegral = (byte)OpCode.FresnelCosineIntegral;
+    public const byte FresnelSineIntegral = (byte)OpCode.FresnelSineIntegral;
+    public const byte AiryA = (byte)OpCode.AiryA;
+    public const byte AiryB = (byte)OpCode.AiryB;
+    public const byte Norm = (byte)OpCode.Norm;
+    public const byte Erf = (byte)OpCode.Erf;
+    public const byte Bessel = (byte)OpCode.Bessel;
+    public const byte XOR = (byte)OpCode.XOR;
+    public const byte FactorVariable = (byte)OpCode.FactorVariable;
+    public const byte BinaryFactorVariable = (byte)OpCode.BinaryFactorVariable;
+    public const byte Absolute = (byte)OpCode.Absolute;
+    public const byte AnalyticQuotient = (byte)OpCode.AnalyticQuotient;
+    public const byte Cube = (byte)OpCode.Cube;
+    public const byte CubeRoot = (byte)OpCode.CubeRoot;
+    public const byte Tanh = (byte)OpCode.Tanh;
 
 
@@ -150 +193 @@
 
     public static byte MapSymbolToOpCode(ISymbolicExpressionTreeNode treeNode) {
-      byte opCode;
-      if (symbolToOpcode.TryGetValue(treeNode.Symbol.GetType(), out opCode)) return opCode;
+      if (symbolToOpcode.TryGetValue(treeNode.Symbol.GetType(), out byte opCode)) return opCode;
       else throw new NotSupportedException("Symbol: " + treeNode.Symbol);
     }

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -247 +247 @@
         case OpCodes.CubeRoot: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
-            return Expression.Power(arg, Expression.Constant(1.0 / 3.0));
+            return Expression.Condition(Expression.LessThan(arg, Expression.Constant(0.0)),
+              Expression.Negate(Expression.Power(Expression.Negate(arg), Expression.Constant(1.0 / 3.0))),
+              Expression.Power(arg, Expression.Constant(1.0 / 3.0)));
           }
         case OpCodes.Root: {
@@ -514 +516 @@
             var x1 = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var x2 = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
-            return Expression.Divide(x1, 
-              Expression.Call(Sqrt, 
+            return Expression.Divide(x1,
+              Expression.Call(Sqrt,
               Expression.Add(
                 Expression.Constant(1.0),

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

@@ -63 +63 @@
               break;
             }
-
+          case OpCodes.Constant: break; // nothing to do here, don't remove because we want to prevent falling into the default case here.
           case OpCodes.Add: {
               Load(instr.buf, code[c].buf);
@@ -173 +173 @@
               break;
             }
+          default: throw new NotSupportedException($"This interpreter does not support {(OpCode)instr.opcode}");
         }
       }

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -336 +336 @@
         case OpCodes.CubeRoot: {
             CompileInstructions(il, state, ds);
+            var c1 = il.DefineLabel();
+            var end = il.DefineLabel();
+
+            il.Emit(System.Reflection.Emit.OpCodes.Dup); // x
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0);
+            il.Emit(System.Reflection.Emit.OpCodes.Clt); // x < 0?
+            il.Emit(System.Reflection.Emit.OpCodes.Brfalse, c1);
+            il.Emit(System.Reflection.Emit.OpCodes.Neg); // x = -x
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
             il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            il.Emit(System.Reflection.Emit.OpCodes.Neg); // -Math.Pow(-x, 1/3)
+            il.Emit(System.Reflection.Emit.OpCodes.Br, end);
+            il.MarkLabel(c1);
+            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
+            il.Emit(System.Reflection.Emit.OpCodes.Call, power);
+            il.MarkLabel(end);
             return;
           }
@@ -422 +436 @@
             il.Emit(System.Reflection.Emit.OpCodes.Mul); // x2*x2
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
-            il.Emit(System.Reflection.Emit.OpCodes.Mul); // 1+x2*x2
+            il.Emit(System.Reflection.Emit.OpCodes.Add); // 1+x2*x2
             il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
             il.Emit(System.Reflection.Emit.OpCodes.Div);

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -232 +232 @@
           }
         case OpCodes.CubeRoot: {
-            return Math.Pow(Evaluate(dataset, ref row, state), 1.0 / 3.0);
+            var arg = Evaluate(dataset, ref row, state);
+            return arg < 0 ? -Math.Pow(-arg, 1.0 / 3.0) : Math.Pow(arg, 1.0 / 3.0);
           }
         case OpCodes.Root: {

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -245 +245 @@
           instr.value = Math.Sqrt(code[instr.childIndex].value);
         } else if (instr.opCode == OpCodes.CubeRoot) {
-          instr.value = Math.Pow(code[instr.childIndex].value, 1.0 / 3.0);
+          var arg = code[instr.childIndex].value;
+          instr.value = arg < 0 ? -Math.Pow(-arg, 1.0 / 3.0) : Math.Pow(arg, 1.0 / 3.0);
         } else if (instr.opCode == OpCodes.Root) {
           double x = code[instr.childIndex].value;

branches/2974_Constants_Optimization/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -101 +101 @@
     private IDataset dataset;
 
+    private static readonly HashSet<byte> supportedOpCodes = new HashSet<byte>() {
+      (byte)OpCode.Constant,
+      (byte)OpCode.Variable,
+      (byte)OpCode.Add,
+      (byte)OpCode.Sub,
+      (byte)OpCode.Mul,
+      (byte)OpCode.Div,
+      (byte)OpCode.Exp,
+      (byte)OpCode.Log,
+      (byte)OpCode.Sin,
+      (byte)OpCode.Cos,
+      (byte)OpCode.Tan,
+      (byte)OpCode.Tanh,
+      (byte)OpCode.Power,
+      (byte)OpCode.Root,
+      (byte)OpCode.SquareRoot,
+      (byte)OpCode.Square,
+      (byte)OpCode.CubeRoot,
+      (byte)OpCode.Cube,
+      (byte)OpCode.Absolute,
+      (byte)OpCode.AnalyticQuotient
+    };
+
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
       if (!rows.Any()) return Enumerable.Empty<double>();
@@ -108 +131 @@
       }
 
-      var code = Compile(tree, OpCodes.MapSymbolToOpCode);
+      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {        
+        var opCode = OpCodes.MapSymbolToOpCode(node);
+        if (supportedOpCodes.Contains(opCode)) return opCode;
+        else throw new NotSupportedException($"The native interpreter does not support {node.Symbol.Name}");
+      };
+      var code = Compile(tree, mapSupportedSymbols);
 
       var rowsArray = rows.ToArray();