Changeset 16899 for branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

Timestamp:

05/06/19 14:20:06 (5 years ago)

Author:

msemenki

Message:

#2988: New version of class structure.

Location:

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic

Files:

• . (modified) (1 prop)
• 3.4/Interpreter/IntervalInterpreter.cs (modified) (15 diffs)

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

@@ -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));
@@ -133 +133 @@
       }
 
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
-      foreach (Instruction instr in code.Where(i => i.opCode == OpCodes.Variable)) {
+      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
+      foreach (Instruction instr in code.Where(i => i.opCode == OpCode.Variable)) {
         var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
         instr.data = variableRanges[variableTreeNode.VariableName];
@@ -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
@@ -150 +150 @@
       switch (currentInstr.opCode) {
         //Variables, Constants, ...
-        case OpCodes.Variable: {
+        case OpCode.Variable: {
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
@@ -158 +158 @@
             break;
           }
-        case OpCodes.Constant: {
+        case OpCode.Constant: {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
             result = new Interval(constTreeNode.Value, constTreeNode.Value);
@@ -164 +164 @@
           }
         //Elementary arithmetic rules
-        case OpCodes.Add: {
+        case OpCode.Add: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -172 +172 @@
             break;
           }
-        case OpCodes.Sub: {
+        case OpCode.Sub: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             if (currentInstr.nArguments == 1)
@@ -183 +183 @@
             break;
           }
-        case OpCodes.Mul: {
+        case OpCode.Mul: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -191 +191 @@
             break;
           }
-        case OpCodes.Div: {
+        case OpCode.Div: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             if (currentInstr.nArguments == 1)
@@ -203 +203 @@
           }
         //Trigonometric functions
-        case OpCodes.Sin: {
+        case OpCode.Sin: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Sine(argumentInterval);
             break;
           }
-        case OpCodes.Cos: {
+        case OpCode.Cos: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Cosine(argumentInterval);
             break;
           }
-        case OpCodes.Tan: {
+        case OpCode.Tan: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Tangens(argumentInterval);
             break;
           }
+        case OpCode.Tanh: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.HyperbolicTangent(argumentInterval);
+            break;
+          }
         //Exponential functions
-        case OpCodes.Log: {
+        case OpCode.Log: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Logarithm(argumentInterval);
             break;
           }
-        case OpCodes.Exp: {
+        case OpCode.Exp: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Exponential(argumentInterval);
             break;
           }
-        case OpCodes.Power: {
+        case OpCode.Power: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -237 +242 @@
             break;
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Square(argumentInterval);
             break;
           }
-        case OpCodes.Root: {
+        case OpCode.Root: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -250 +255 @@
             break;
           }
-        case OpCodes.SquareRoot: {
+        case OpCode.SquareRoot: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.SquareRoot(argumentInterval);