Changeset 13300 for trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Timestamp:

11/19/15 14:15:19 (9 years ago)

Author:

gkronber

Message:

#2175 made some changes while reviewing the code

Location:

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs (modified) (1 diff)
• SymbolicDataAnalysisModelComplexityCalculator.cs (modified) (4 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplificationOperator.cs

@@ -28 +28 @@
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [Item("SymbolicExpressionTreeSimplificationOperator", "Simplfies symbolic expression trees encoding a mathematical formula.")]
+  [Item("SymbolicExpressionTreeSimplificationOperator", "Simplifies symbolic expression trees encoding a mathematical formula.")]
   [StorableClass]
   public class SymbolicDataAnalysisExpressionTreeSimplificationOperator : SingleSuccessorOperator, ISymbolicExpressionTreeOperator {

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs

@@ -42 +42 @@
             return 2;
           }
-        case OpCodes.Add: {
-            double complexity = 0;
-            for (int i = 0; i < node.SubtreeCount; i++) {
-              complexity += CalculateComplexity(node.GetSubtree(i));
-            }
-            return complexity;
-          }
+        case OpCodes.Add: 
         case OpCodes.Sub: {
             double complexity = 0;
@@ -56 +50 @@
             return complexity;
           }
-        case OpCodes.Mul: {
-            double complexity = 1;
-            for (int i = 0; i < node.SubtreeCount; i++) {
-              var nodeComplexity = CalculateComplexity(node.GetSubtree(i));
-              complexity *= nodeComplexity + 1;
-            }
-            return complexity;
-          }
+        case OpCodes.Mul: 
         case OpCodes.Div: {
             double complexity = 1;
@@ -72 +59 @@
             return complexity;
           }
-        case OpCodes.Sin: {
-            double complexity = CalculateComplexity(node.GetSubtree(0));
-            return Math.Pow(2.0, complexity);
-          }
-        case OpCodes.Cos: {
-            double complexity = CalculateComplexity(node.GetSubtree(0));
-            return Math.Pow(2.0, complexity);
-          }
-        case OpCodes.Tan: {
-            double complexity = CalculateComplexity(node.GetSubtree(0));
-            return Math.Pow(2.0, complexity);
-          }
-        case OpCodes.Exp: {
-            double complexity = CalculateComplexity(node.GetSubtree(0));
-            return Math.Pow(2.0, complexity);
-          }
+        case OpCodes.Sin:
+        case OpCodes.Cos: 
+        case OpCodes.Tan:
+        case OpCodes.Exp: 
         case OpCodes.Log: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
@@ -100 +75 @@
             return complexity * complexity * complexity;
           }
-        case OpCodes.Power: {
+        case OpCodes.Power:          
+        case OpCodes.Root: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
-            var exponentNode = node.GetSubtree(1) as ConstantTreeNode;
-            if (exponentNode != null) {
-              double exponent = exponentNode.Value;
-              if (exponent < 0) exponent = Math.Abs(exponent);
-              if (exponent < 1) exponent = 1 / exponent;
-              return Math.Pow(complexity, Math.Round(exponent));
+            var exponent = node.GetSubtree(1) as ConstantTreeNode;
+            if (exponent != null) {
+              double expVal = exponent.Value;
+              if (expVal < 0) expVal = Math.Abs(expVal);
+              if (expVal < 1) expVal = 1 / expVal;
+              return Math.Pow(complexity, Math.Round(expVal));
             }
 
-            double exponentComplexity = CalculateComplexity(node.GetSubtree(1));
-            return Math.Pow(complexity, 2 * exponentComplexity);
-          }
-        case OpCodes.Root: {
-            double complexity = CalculateComplexity(node.GetSubtree(0));
-            var rootNode = node.GetSubtree(1) as ConstantTreeNode;
-            if (rootNode != null) {
-              double root = rootNode.Value;
-              if (root < 0) root = Math.Abs(root);
-              if (root < 1) root = 1 / root;
-              return Math.Pow(complexity, Math.Round(root));
-            }
-
-            double rootComplexity = CalculateComplexity(node.GetSubtree(1));
-            return Math.Pow(complexity, 2 * rootComplexity);
+            double expComplexity = CalculateComplexity(node.GetSubtree(1));
+            return Math.Pow(complexity, 2 * expComplexity);
           }