Changeset 7695

Timestamp:

04/03/12 00:32:03 (13 years ago)

Author:

gkronber

Message:

#1810 merged patch to add square and square root function symbols by mkommend

Location:

trunk/sources

Files:

• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (9 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Square.cs (added)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/SquareRoot.cs (added)
• HeuristicLab.Tests/HeuristicLab.Tests.csproj (modified) (2 diffs)

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

@@ -112 +112 @@
       } else if (node.Symbol is Exponential) {
         strBuilder.Append(@"\exp \left( ");
+      } else if (node.Symbol is Square) {
+        strBuilder.Append(@"\left(");
+      } else if (node.Symbol is SquareRoot) {
+        strBuilder.Append(@"\sqrt{");
       } else if (node.Symbol is Sine) {
         strBuilder.Append(@"\sin \left( ");
@@ -209 +213 @@
       } else if (node.Symbol is Exponential) {
         throw new InvalidOperationException();
+      } else if (node.Symbol is Square) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is SquareRoot) {
+        throw new InvalidOperationException();
       } else if (node.Symbol is Sine) {
         throw new InvalidOperationException();
@@ -266 +274 @@
       } else if (node.Symbol is Exponential) {
         strBuilder.Append(@" \right) ");
+      } else if (node.Symbol is Square) {
+        strBuilder.Append(@"\right)^2");
+      } else if (node.Symbol is SquareRoot) {
+        strBuilder.Append(@"}");
       } else if (node.Symbol is Sine) {
         strBuilder.Append(@" \right) ");

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

@@ -20 +20 @@
 #endregion
 
+using System.Globalization;
 using System.Text;
-using System.Linq;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
-using HeuristicLab.Common;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Problems.DataAnalysis;
-using System.Collections.Generic;
-using System;
-using System.Globalization;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -84 +80 @@
     }
 
-    public string FormatOnlyExpression(ISymbolicExpressionTreeNode expressionNode)
-    {
+    public string FormatOnlyExpression(ISymbolicExpressionTreeNode expressionNode) {
       var stringBuilder = new StringBuilder();
       stringBuilder.AppendLine("  for " + CurrentIndexVariable + " = 1:1:rows");
@@ -151 +146 @@
       } else if (symbol is Exponential) {
         stringBuilder.Append("exp(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(")");
+      } else if (symbol is Square) {
+        stringBuilder.Append("(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(").^2");
+      } else if (symbol is SquareRoot) {
+        stringBuilder.Append("sqrt(");
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(")");
@@ -283 +286 @@
 
 
-    private string LagToString(int lag)
-    {
+    private string LagToString(int lag) {
       if (lag < 0) {
         return "(" + CurrentIndexVariable + "" + lag + ")";

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/FullFunctionalExpressionGrammar.cs

@@ -55 +55 @@
       var pow = new Power();
       pow.InitialFrequency = 0.0;
+      var square = new Square();
+      square.InitialFrequency = 0.0;
       var root = new Root();
       root.InitialFrequency = 0.0;
+      var sqrt = new SquareRoot();
+      sqrt.InitialFrequency = 0.0;
       var exp = new Exponential();
       var @if = new IfThenElse();
@@ -82 +86 @@
       laggedVariable.InitialFrequency = 0.0;
 
-      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, pow, root, exp, @if, gt, lt, and, or, not, timeLag, integral, derivative, constant, variableSymbol, laggedVariable, variableCondition };
-      var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, not, timeLag, integral, derivative };
+      var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, square, pow, sqrt, root, exp, @if, gt, lt, and, or, not, timeLag, integral, derivative, constant, variableSymbol, laggedVariable, variableCondition };
+      var unaryFunctionSymbols = new List<Symbol>() { square, sqrt, sin, cos, tan, log, exp, not, timeLag, integral, derivative };
 
       var binaryFunctionSymbols = new List<Symbol>() { pow, root, gt, lt, variableCondition };

trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

@@ -65 +65 @@
       var log = new Logarithm();
       var pow = new Power();
+      var square = new Square();
       var root = new Root();
+      var sqrt = new SquareRoot();
       var exp = new Exponential();
       var @if = new IfThenElse();
@@ -93 +95 @@
       var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, terminalSymbols });
 
-      var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { pow, root });
+      var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { square, pow, sqrt, root });
 
       var conditionSymbols = new GroupSymbol(ConditionsName, new List<ISymbol> { @if, variableCondition });
@@ -111 +113 @@
       SetSubtreeCount(arithmeticSymbols, 2, 2);
       SetSubtreeCount(trigonometricSymbols, 1, 1);
-      SetSubtreeCount(powerSymbols, 2, 2);
+      SetSubtreeCount(pow, 2, 2);
+      SetSubtreeCount(root, 2, 2);
+      SetSubtreeCount(square, 1, 1);
+      SetSubtreeCount(sqrt, 1, 1);
       SetSubtreeCount(exponentialAndLogarithmicSymbols, 1, 1);
       SetSubtreeCount(terminalSymbols, 0, 0);
@@ -140 +145 @@
       AddAllowedChildSymbol(powerSymbols, laggedVariable, 0);
       AddAllowedChildSymbol(powerSymbols, constant, 1);
+      AddAllowedChildSymbol(square, realValuedSymbols, 0);
+      AddAllowedChildSymbol(sqrt, realValuedSymbols, 0);
 
       AddAllowedChildSymbol(@if, comparisonSymbols, 0);

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

@@ -161 +161 @@
     <Compile Include="Symbols\Constant.cs" />
     <Compile Include="Symbols\ConstantTreeNode.cs" />
+    <Compile Include="Symbols\SquareRoot.cs" />
+    <Compile Include="Symbols\Square.cs" />
     <Compile Include="Symbols\Cosine.cs" />
     <Compile Include="Symbols\Derivative.cs" />

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

@@ -133 +133 @@
 
       public const byte VariableCondition = 27;
+
+      public const byte Square = 28;
+      public const byte SquareRoot = 29;
     }
     #endregion
@@ -154 +157 @@
       { typeof(Average), OpCodes.Average},
       { typeof(InvokeFunction), OpCodes.Call },
-      { typeof(HeuristicLab.Problems.DataAnalysis.Symbolic.Variable), OpCodes.Variable },
+      { typeof(Variable), OpCodes.Variable },
       { typeof(LaggedVariable), OpCodes.LagVariable },
       { typeof(Constant), OpCodes.Constant },
@@ -163 +166 @@
       { typeof(Integral), OpCodes.Integral},
       { typeof(Derivative), OpCodes.Derivative},
-      { typeof(VariableCondition),OpCodes.VariableCondition}
+      { typeof(VariableCondition),OpCodes.VariableCondition},
+      { typeof(Square),OpCodes.Square},
+      {typeof(SquareRoot),OpCodes.SquareRoot}
     };
 
@@ -305 +310 @@
             return Math.Tan(Evaluate(dataset, ref row, state));
           }
+        case OpCodes.Square: {
+            return Math.Pow(Evaluate(dataset, ref row, state), 2);
+          }
         case OpCodes.Power: {
             double x = Evaluate(dataset, ref row, state);
             double y = Math.Round(Evaluate(dataset, ref row, state));
             return Math.Pow(x, y);
+          }
+        case OpCodes.SquareRoot: {
+            return Math.Sqrt(Evaluate(dataset, ref row, state));
           }
         case OpCodes.Root: {

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

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using HeuristicLab.Common;
@@ -41 +40 @@
     private Exponential expSymbol = new Exponential();
     private Root rootSymbol = new Root();
+    private Square sqrSymbol = new Square();
+    private SquareRoot sqrtSymbol = new SquareRoot();
     private Power powSymbol = new Power();
     private Sine sineSymbol = new Sine();
@@ -125 +126 @@
     private bool IsRoot(ISymbolicExpressionTreeNode node) {
       return node.Symbol is Root;
+    }
+    private bool IsSquare(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is Square;
+    }
+    private bool IsSquareRoot(ISymbolicExpressionTreeNode node) {
+      return node.Symbol is SquareRoot;
     }
     private bool IsPower(ISymbolicExpressionTreeNode node) {
@@ -201 +208 @@
       } else if (IsExp(original)) {
         return SimplifyExp(original);
+      } else if (IsSquare(original)) {
+        return SimplifySquare(original);
+      } else if (IsSquareRoot(original)) {
+        return SimplifySquareRoot(original);
+      } else if (IsPower(original)) {
+        return SimplifyPower(original);
       } else if (IsRoot(original)) {
         return SimplifyRoot(original);
-      } else if (IsPower(original)) {
-        return SimplifyPower(original);
       } else if (IsSine(original)) {
         return SimplifySine(original);
@@ -348 +359 @@
       return MakeExp(GetSimplifiedTree(original.GetSubtree(0)));
     }
+    private ISymbolicExpressionTreeNode SimplifySquare(ISymbolicExpressionTreeNode original) {
+      return MakeSquare(GetSimplifiedTree(original.GetSubtree(0)));
+    }
+    private ISymbolicExpressionTreeNode SimplifySquareRoot(ISymbolicExpressionTreeNode original) {
+      return MakeSquareRoot(GetSimplifiedTree(original.GetSubtree(0)));
+    }
 
     private ISymbolicExpressionTreeNode SimplifyLog(ISymbolicExpressionTreeNode original) {
@@ -532 +549 @@
       }
     }
+
+    private ISymbolicExpressionTreeNode MakeSquare(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) {
+        var constT = node as ConstantTreeNode;
+        return MakeConstant(constT.Value * constT.Value);
+      } else if (IsSquareRoot(node)) {
+        return node.GetSubtree(0);
+      } else {
+        var sqrNode = sqrSymbol.CreateTreeNode();
+        sqrNode.AddSubtree(node);
+        return sqrNode;
+      }
+    }
+    private ISymbolicExpressionTreeNode MakeSquareRoot(ISymbolicExpressionTreeNode node) {
+      if (IsConstant(node)) {
+        var constT = node as ConstantTreeNode;
+        return MakeConstant(Math.Sqrt(constT.Value));
+      } else if (IsSquare(node)) {
+        return node.GetSubtree(0);
+      } else {
+        var sqrtNode = sqrtSymbol.CreateTreeNode();
+        sqrtNode.AddSubtree(node);
+        return sqrtNode;
+      }
+    }
+
     private ISymbolicExpressionTreeNode MakeLog(ISymbolicExpressionTreeNode node) {
       if (IsConstant(node)) {
@@ -636 +679 @@
       } else if (IsDivision(a) && IsConstant(b)) {
         // (a1 / a2) / c => (a1 / (a2 * c))
-        Trace.Assert(a.Subtrees.Count() == 2);
         return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) / (b1 / b2) => 
-        Trace.Assert(a.Subtrees.Count() == 2);
-        Trace.Assert(b.Subtrees.Count() == 2);
         return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(1)), MakeProduct(a.GetSubtree(1), b.GetSubtree(0)));
       } else if (IsDivision(a)) {
         // (a1 / a2) / b => (a1 / (a2 * b))
-        Trace.Assert(a.Subtrees.Count() == 2);
         return MakeFraction(a.GetSubtree(0), MakeProduct(a.GetSubtree(1), b));
       } else if (IsDivision(b)) {
         // a / (b1 / b2) => (a * b2) / b1
-        Trace.Assert(b.Subtrees.Count() == 2);
         return MakeFraction(MakeProduct(a, b.GetSubtree(1)), b.GetSubtree(0));
       } else {
@@ -774 +812 @@
       } else if (IsDivision(a) && IsDivision(b)) {
         // (a1 / a2) * (b1 / b2) => (a1 * b1) / (a2 * b2)
-        Trace.Assert(a.Subtrees.Count() == 2);
-        Trace.Assert(b.Subtrees.Count() == 2);
         return MakeFraction(MakeProduct(a.GetSubtree(0), b.GetSubtree(0)), MakeProduct(a.GetSubtree(1), b.GetSubtree(1)));
       } else if (IsDivision(a)) {
         // (a1 / a2) * b => (a1 * b) / a2
-        Trace.Assert(a.Subtrees.Count() == 2);
         return MakeFraction(MakeProduct(a.GetSubtree(0), b), a.GetSubtree(1));
       } else if (IsDivision(b)) {
         // a * (b1 / b2) => (b1 * a) / b2
-        Trace.Assert(b.Subtrees.Count() == 2);
         return MakeFraction(MakeProduct(b.GetSubtree(0), a), b.GetSubtree(1));
       } else if (IsMultiplication(a) && IsMultiplication(b)) {
@@ -912 +946 @@
         return MakeConstant(1.0 / ((ConstantTreeNode)x).Value);
       } else if (IsDivision(x)) {
-        Trace.Assert(x.Subtrees.Count() == 2);
         return MakeFraction(x.GetSubtree(1), x.GetSubtree(0));
       } else {

trunk/sources/HeuristicLab.Tests/HeuristicLab.Tests.csproj

@@ -102 +102 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.4.0">
-      <HintPath>..\bin\ALGLIB-3.4.0.dll</HintPath>
+    <Reference Include="ALGLIB-3.5.0, Version=3.5.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <HintPath>..\bin\ALGLIB-3.5.0.dll</HintPath>
     </Reference>
     <Reference Include="Calendar.DayView">
@@ -112 +112 @@
       <HintPath>..\bin\Google.ProtocolBuffers-0.9.1.dll</HintPath>
       <Private>True</Private>
-    </Reference>
-    <Reference Include="HeuristicLab.ALGLIB-3.4.0">
-      <HintPath>..\bin\HeuristicLab.ALGLIB-3.4.0.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.LibSVM-1.6.3">