Changeset 16383

Timestamp:

12/14/18 14:17:31 (6 years ago)

Author:

chaider

Message:

#2966

• Some renaming and reordering
• Changed GetVariableRanges method in DatasetUtil
• Added cases for substract and divide with arity 1

Location:

branches/2966_interval_calculation

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs (modified) (6 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/DatasetUtil.cs (modified) (1 diff)

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

@@ -348 +348 @@
   <ItemGroup>
     <ProjectReference Include="..\..\HeuristicLab.Problems.DataAnalysis\3.4\HeuristicLab.Problems.DataAnalysis-3.4.csproj">
-      <Project>{DF87C13E-A889-46FF-8153-66DCAA8C5674}</Project>
+      <Project>{df87c13e-a889-46ff-8153-66dcaa8c5674}</Project>
       <Name>HeuristicLab.Problems.DataAnalysis-3.4</Name>
-      <Private>False</Private>
     </ProjectReference>
   </ItemGroup>

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

@@ -70 +70 @@
 
     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
-      lock (syncRoot) {
-        EvaluatedSolutions++;
-      }
-      int instructionCount = 0;
-      var intervalBoundaries = DatasetUtil.GetVariableBoundaries(dataset, rows);
-      var instructions = PrepareInterpreterState(tree, intervalBoundaries);
-      var x = Evaluate(instructions, ref instructionCount);
-
-      return x;
+      var intervalBoundaries = DatasetUtil.GetVariableRanges(dataset, rows);
+      return GetSymbolicExressionTreeIntervals(tree, intervalBoundaries);
     }
 
     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
       out Dictionary<ISymbolicExpressionTreeNode, Interval> intervals, IEnumerable<int> rows = null) {
-      lock (syncRoot) {
-        EvaluatedSolutions++;
-      }
-      int instructionCount = 0;
-      var intervalBoundaries = DatasetUtil.GetVariableBoundaries(dataset, rows);
-      intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      var instructions = PrepareInterpreterState(tree, intervalBoundaries);
-      var x = Evaluate(instructions, ref instructionCount, intervals);
-
-      return x;
+      var intervalBoundaries = DatasetUtil.GetVariableRanges(dataset, rows);
+      return GetSymbolicExressionTreeIntervals(tree, intervalBoundaries, out intervals);
     }
 
@@ -101 +86 @@
       int instructionCount = 0;
       var instructions = PrepareInterpreterState(tree, customIntervals);
-      var x = Evaluate(instructions, ref instructionCount);
-
-      return x;
+      var outputInterval = Evaluate(instructions, ref instructionCount);
+
+      return outputInterval;
     }
 
@@ -115 +100 @@
       intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
       var instructions = PrepareInterpreterState(tree, customIntervals);
-      var x = Evaluate(instructions, ref instructionCount, intervals);
-
-      return x;
+      var outputInterval = Evaluate(instructions, ref instructionCount, intervals);
+
+      return outputInterval;
     }
 
@@ -138 +123 @@
     }
 
-    private Interval Evaluate(Instruction[] instructions, ref int instructionCount, Dictionary<ISymbolicExpressionTreeNode,
-      Interval> intervals = null) {
+    private Interval Evaluate(Instruction[] instructions, ref int instructionCount, Dictionary<ISymbolicExpressionTreeNode, Interval> intervals = null) {
       Instruction currentInstr = instructions[instructionCount++];
       Interval result = null;
 
       switch (currentInstr.opCode) {
-        //Elementary arithmetic rules
-        case OpCodes.Add: {
-            result = Evaluate(instructions, ref instructionCount, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              result = Interval.Add(result, Evaluate(instructions, ref instructionCount, intervals));
-            }
-            break;
-          }
-        case OpCodes.Sub: {
-            result = Evaluate(instructions, ref instructionCount, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              result = Interval.Subtract(result, Evaluate(instructions, ref instructionCount, intervals));
-            }
-            break;
-          }
-        case OpCodes.Mul: {
-            result = Evaluate(instructions, ref instructionCount, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              result = Interval.Multiply(result, Evaluate(instructions, ref instructionCount, intervals));
-            }
-            break;
-          }
-        case OpCodes.Div: {
-            result = Evaluate(instructions, ref instructionCount, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              result = Interval.Divide(result, Evaluate(instructions, ref instructionCount, intervals));
-            }
-            break;
-          }
-        //Trigonometric functions
-        case OpCodes.Sin: {
-            result = Interval.Sine(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
-        case OpCodes.Cos: {
-            result = Interval.Cosine(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
-        case OpCodes.Tan: {
-            result = Interval.Tangens(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
-        //Exponential functions
-        case OpCodes.Log: {
-            result = Interval.Logarithm(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
-        case OpCodes.Exp: {
-            result = Interval.Exponential(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
-        case OpCodes.Power: {
-            result = Evaluate(instructions, ref instructionCount, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              result = Interval.Power(result, Evaluate(instructions, ref instructionCount, intervals));
-            }
-            break;
-          }
-        case OpCodes.Square: {
-            result = Interval.Square(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
-        case OpCodes.Root: {
-            result = Evaluate(instructions, ref instructionCount, intervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              result = Interval.Root(result, Evaluate(instructions, ref instructionCount, intervals));
-            }
-            break;
-          }
-        case OpCodes.SquareRoot: {
-            result = Interval.SquareRoot(Evaluate(instructions, ref instructionCount, intervals));
-            break;
-          }
         //Variables, Constants, ...
         case OpCodes.Variable: {
@@ -222 +133 @@
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             var variableWeight = variableTreeNode.Weight;
-            
+
             return Interval.Multiply((Interval)currentInstr.data, new Interval(variableWeight, variableWeight));
           }
@@ -231 +142 @@
             return inter;
           }
+        //Elementary arithmetic rules
+        case OpCodes.Add: {
+            result = Evaluate(instructions, ref instructionCount, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+              result = Interval.Add(result, argumentInterval);
+            }
+            break;
+          }
+        case OpCodes.Sub: {
+            result = Evaluate(instructions, ref instructionCount, intervals);
+            if (currentInstr.nArguments == 1)
+              result = Interval.Multiply(new Interval(-1, -1), result);
+            
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+              result = Interval.Subtract(result, argumentInterval);
+            }
+            break;
+          }
+        case OpCodes.Mul: {
+            result = Evaluate(instructions, ref instructionCount, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+              result = Interval.Multiply(result, argumentInterval);
+            }
+            break;
+          }
+        case OpCodes.Div: {
+            result = Evaluate(instructions, ref instructionCount, intervals);
+            if(currentInstr.nArguments == 1)
+              result = Interval.Divide(new Interval(1,1),result);
+
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+              result = Interval.Divide(result, argumentInterval);
+            }
+            break;
+          }
+        //Trigonometric functions
+        case OpCodes.Sin: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.Sine(argumentInterval);
+            break;
+          }
+        case OpCodes.Cos: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.Cosine(argumentInterval);
+            break;
+          }
+        case OpCodes.Tan: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.Tangens(argumentInterval);
+            break;
+          }
+        //Exponential functions
+        case OpCodes.Log: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.Logarithm(argumentInterval);
+            break;
+          }
+        case OpCodes.Exp: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.Exponential(argumentInterval);
+            break;
+          }
+        case OpCodes.Power: {
+            result = Evaluate(instructions, ref instructionCount, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+              result = Interval.Power(result, argumentInterval);
+            }
+            break;
+          }
+        case OpCodes.Square: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.Square(argumentInterval);
+            break;
+          }
+        case OpCodes.Root: {
+            result = Evaluate(instructions, ref instructionCount, intervals);
+            for (int i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+              result = Interval.Root(result, argumentInterval);
+            }
+            break;
+          }
+        case OpCodes.SquareRoot: {
+            var argumentInterval = Evaluate(instructions, ref instructionCount, intervals);
+            result = Interval.SquareRoot(argumentInterval);
+            break;
+          }
         default:
-          throw new NotSupportedException("Tree contains an unknown symbol.");
+          throw new NotSupportedException($"The tree contains the unknown symbol {currentInstr.dynamicNode.Symbol}");
       }
 
       if (intervals != null)
         intervals.Add(currentInstr.dynamicNode, result);
+
       return result;
     }

branches/2966_interval_calculation/HeuristicLab.Problems.DataAnalysis/3.4/DatasetUtil.cs

@@ -93 +93 @@
     }
 
-    public static Dictionary<string, Interval> GetVariableBoundaries(IDataset dataset, IEnumerable<int> rows = null) {
-      Dictionary<string, Interval> variableBoundaries = new Dictionary<string, Interval>();
+    public static Dictionary<string, Interval> GetVariableRanges(IDataset dataset, IEnumerable<int> rows = null) {
+      Dictionary<string, Interval> variableRanges = new Dictionary<string, Interval>();
 
       foreach (var variable in dataset.VariableNames) {
         var min = double.MaxValue;
         var max = double.MinValue;
+        IEnumerable<double> values = null;
 
-        if (rows != null) {
-          foreach (int row in rows) {
-            var val = dataset.GetDoubleValue(variable, row);
-            if (val < min) min = val;
-            if (val > max) max = val;
-          }
-        } else {
-          foreach (var val in dataset.GetDoubleValues(variable)) {
-            if (val < min) min = val;
-            if (val > max) max = val;
-          }
+        if (rows == null) values = dataset.GetDoubleValues(variable);
+        else values = dataset.GetDoubleValues(variable, rows);
+
+        foreach (var val in values) {
+          if (val < min) min = val;
+          if (val > max) max = val;
         }
-        variableBoundaries.Add(variable, new Interval(min, max));
+
+        variableRanges.Add(variable, new Interval(min, max));
       }
 
-      return variableBoundaries;
+      return variableRanges;
     }