Changeset 6387 for branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic

Timestamp:

06/08/11 10:42:57 (14 years ago)

Author:

mkommend

Message:

#1540: Added min and max arity to symbols and renamed SymbolicExpressionTreeNode.SubtreesCount to SymbolicExpressionTreeNode.SubtreeCount.

Location:

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4

Files:

• Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs (modified) (1 diff)
• Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs (modified) (5 diffs)
• Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs (modified) (8 diffs)
• SymbolicDataAnalysisExpressionTreeSimplifier.cs (modified) (2 diffs)
• Symbols/Addition.cs (modified) (1 diff)
• Symbols/And.cs (modified) (1 diff)
• Symbols/Average.cs (modified) (1 diff)
• Symbols/Constant.cs (modified) (1 diff)
• Symbols/Cosine.cs (modified) (1 diff)
• Symbols/Derivative.cs (modified) (1 diff)
• Symbols/Division.cs (modified) (1 diff)
• Symbols/Exponential.cs (modified) (1 diff)
• Symbols/GreaterThan.cs (modified) (1 diff)
• Symbols/IfThenElse.cs (modified) (1 diff)
• Symbols/Integral.cs (modified) (1 diff)
• Symbols/LessThan.cs (modified) (1 diff)
• Symbols/Logarithm.cs (modified) (1 diff)
• Symbols/Multiplication.cs (modified) (1 diff)
• Symbols/Not.cs (modified) (1 diff)
• Symbols/Or.cs (modified) (1 diff)
• Symbols/Power.cs (modified) (1 diff)
• Symbols/Root.cs (modified) (1 diff)
• Symbols/Sine.cs (modified) (1 diff)
• Symbols/Subtraction.cs (modified) (1 diff)
• Symbols/Tangent.cs (modified) (1 diff)
• Symbols/TimeLag.cs (modified) (1 diff)
• Symbols/Variable.cs (modified) (1 diff)
• Symbols/VariableCondition.cs (modified) (1 diff)

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs

@@ -88 +88 @@
       StringBuilder builder = new StringBuilder();
       builder.Append("(" + tree.ToString());
-      for (int i = 0; i < tree.SubtreesCount; i++) {
+      for (int i = 0; i < tree.SubtreeCount; i++) {
         builder.Append(" " + GetTextualRepresentationFromSubtreeOfDepth(tree.GetSubtree(i), d - 1));
       }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

@@ -73 +73 @@
       FormatBegin(node, strBuilder);
 
-      if (node.SubtreesCount > 0) {
+      if (node.SubtreeCount > 0) {
         strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
       }
@@ -91 +91 @@
         strBuilder.Append(@" \left( ");
       } else if (node.Symbol is Subtraction) {
-        if (node.SubtreesCount == 1) {
+        if (node.SubtreeCount == 1) {
           strBuilder.Append(@"- \left(");
         } else {
@@ -98 +98 @@
       } else if (node.Symbol is Multiplication) {
       } else if (node.Symbol is Division) {
-        if (node.SubtreesCount == 1) {
+        if (node.SubtreeCount == 1) {
           strBuilder.Append(@" \cfrac{1}{");
         } else {
@@ -105 +105 @@
       } else if (node.Symbol is Average) {
         // skip output of (1/1) if only one subtree
-        if (node.SubtreesCount > 1) {
-          strBuilder.Append(@" \cfrac{1}{" + node.SubtreesCount + @"}");
+        if (node.SubtreeCount > 1) {
+          strBuilder.Append(@" \cfrac{1}{" + node.SubtreeCount + @"}");
         }
         strBuilder.Append(@" \left(");
@@ -246 +246 @@
       } else if (node.Symbol is Division) {
         strBuilder.Append("} ");
-        if (node.SubtreesCount > 1)
+        if (node.SubtreeCount > 1)
           strBuilder.Append("{1} ");
-        for (int i = 1; i < node.SubtreesCount; i++) {
+        for (int i = 1; i < node.SubtreeCount; i++) {
           strBuilder.Append(" } ");
         }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

@@ -106 +106 @@
 
       if (symbol is Addition) {
-        for (int i = 0; i < node.SubtreesCount; i++) {
+        for (int i = 0; i < node.SubtreeCount; i++) {
           if (i > 0) stringBuilder.Append("+");
           stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
@@ -112 +112 @@
       } else if (symbol is And) {
         stringBuilder.Append("((");
-        for (int i = 0; i < node.SubtreesCount; i++) {
+        for (int i = 0; i < node.SubtreeCount; i++) {
           if (i > 0) stringBuilder.Append("&");
           stringBuilder.Append("((");
@@ -121 +121 @@
       } else if (symbol is Average) {
         stringBuilder.Append("(1/");
-        stringBuilder.Append(node.SubtreesCount);
+        stringBuilder.Append(node.SubtreeCount);
         stringBuilder.Append(")*(");
-        for (int i = 0; i < node.SubtreesCount; i++) {
+        for (int i = 0; i < node.SubtreeCount; i++) {
           if (i > 0) stringBuilder.Append("+");
           stringBuilder.Append("(");
@@ -138 +138 @@
         stringBuilder.Append(")");
       } else if (symbol is Division) {
-        if (node.SubtreesCount == 1) {
+        if (node.SubtreeCount == 1) {
           stringBuilder.Append("1/");
           stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
@@ -144 +144 @@
           stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
           stringBuilder.Append("/(");
-          for (int i = 1; i < node.SubtreesCount; i++) {
+          for (int i = 1; i < node.SubtreeCount; i++) {
             if (i > 1) stringBuilder.Append("*");
             stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
@@ -187 +187 @@
         stringBuilder.Append(")");
       } else if (symbol is Multiplication) {
-        for (int i = 0; i < node.SubtreesCount; i++) {
+        for (int i = 0; i < node.SubtreeCount; i++) {
           if (i > 0) stringBuilder.Append("*");
           stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
@@ -197 +197 @@
       } else if (symbol is Or) {
         stringBuilder.Append("((");
-        for (int i = 0; i < node.SubtreesCount; i++) {
+        for (int i = 0; i < node.SubtreeCount; i++) {
           if (i > 0) stringBuilder.Append("|");
           stringBuilder.Append("((");
@@ -209 +209 @@
         stringBuilder.Append(")");
       } else if (symbol is Subtraction) {
-        if (node.SubtreesCount == 1) {
+        if (node.SubtreeCount == 1) {
           stringBuilder.Append("-1*");
           stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         } else {
           stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
-          for (int i = 1; i < node.SubtreesCount; i++) {
+          for (int i = 1; i < node.SubtreeCount; i++) {
             stringBuilder.Append("-");
             stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

@@ -64 +64 @@
     private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node, IList<ISymbolicExpressionTreeNode> argumentTrees) {
       List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
-      while (node.SubtreesCount > 0) node.RemoveSubtree(0);
+      while (node.SubtreeCount > 0) node.RemoveSubtree(0);
       if (node.Symbol is InvokeFunction) {
         var invokeSym = node.Symbol as InvokeFunction;
@@ -901 +901 @@
         // x0 * x1 * .. * xn * -1 => x0 * x1 * .. * -xn
         var lastSubTree = x.Subtrees.Last();
-        x.RemoveSubtree(x.SubtreesCount - 1);
+        x.RemoveSubtree(x.SubtreeCount - 1);
         x.AddSubtree(Negate(lastSubTree)); // last is maybe a constant, prefer to negate the constant
       } else {

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Addition.cs

@@ -22 +22 @@
 using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableClass]
   [Item("Addition", "Symbol that represents the + operator.")]
   public sealed class Addition : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Addition(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/And.cs

@@ -28 +28 @@
   [Item("And", "Symbol that represents the boolean AND operator.")]
   public sealed class And : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private And(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Average.cs

@@ -28 +28 @@
   [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
   public sealed class Average : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Average(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs

@@ -88 +88 @@
     }
 
+    private const int minimumArity = 0;
+    private const int maximumArity = 0;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
     #endregion
+
     [StorableConstructor]
     private Constant(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Cosine.cs

@@ -28 +28 @@
   [Item("Cosine", "Symbol that represents the cosine function.")]
   public sealed class Cosine : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Cosine(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Derivative.cs

@@ -28 +28 @@
   [Item("Derivative", "Represents the derivative over the specified subtree.")]
   public sealed class Derivative : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Derivative(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Division.cs

@@ -28 +28 @@
   [Item("Division", "Symbol that represents the / operator.")]
   public sealed class Division : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Division(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Exponential.cs

@@ -28 +28 @@
   [Item("Exponential", "Symbol that represents the exponential function.")]
   public sealed class Exponential : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Exponential(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/GreaterThan.cs

@@ -28 +28 @@
   [Item("GreaterThan", "Symbol that represents a greater than relation.")]
   public sealed class GreaterThan : Symbol {
+    private const int minimumArity = 2;
+    private const int maximumArity = 2;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private GreaterThan(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/IfThenElse.cs

@@ -28 +28 @@
   [Item("IfThenElse", "Symbol that represents a conditional operator.")]
   public sealed class IfThenElse : Symbol {
+    private const int minimumArity = 3;
+    private const int maximumArity = 3;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private IfThenElse(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Integral.cs

@@ -27 +27 @@
   [Item("Integral", "Represents the integral over the specified subtree.")]
   public sealed class Integral : LaggedSymbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Integral(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/LessThan.cs

@@ -28 +28 @@
   [Item("LessThan", "Symbol that represents a less than relation.")]
   public sealed class LessThan : Symbol {
+    private const int minimumArity = 2;
+    private const int maximumArity = 2;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private LessThan(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Logarithm.cs

@@ -28 +28 @@
   [Item("Logarithm", "Symbol that represents the logarithm function.")]
   public sealed class Logarithm : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Logarithm(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Multiplication.cs

@@ -28 +28 @@
   [Item("Multiplication", "Symbol that represents the * operator.")]
   public sealed class Multiplication : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Multiplication(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Not.cs

@@ -28 +28 @@
   [Item("Not", "Symbol that represents the boolean NOT operator.")]
   public sealed class Not : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Not(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Or.cs

@@ -28 +28 @@
   [Item("Or", "Symbol that represents the boolean OR operator.")]
   public sealed class Or : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Or(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Power.cs

@@ -28 +28 @@
   [Item("Power", "Symbol that represents the power function.")]
   public sealed class Power : Symbol {
+    private const int minimumArity = 2;
+    private const int maximumArity = 2;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Power(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Root.cs

@@ -28 +28 @@
   [Item("Root", "Symbol that represents the n-th root function.")]
   public sealed class Root : Symbol {
+    private const int minimumArity = 2;
+    private const int maximumArity = 2;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Root(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sine.cs

@@ -28 +28 @@
   [Item("Sine", "Symbol that represents the sine function.")]
   public sealed class Sine : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Sine(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Subtraction.cs

@@ -28 +28 @@
   [Item("Subtraction", "Symbol that represents the - operator.")]
   public sealed class Subtraction : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = byte.MaxValue;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Subtraction(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Tangent.cs

@@ -28 +28 @@
   [Item("Tangent", "Symbol that represents the tangent trigonometric function.")]
   public sealed class Tangent : Symbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private Tangent(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeLag.cs

@@ -28 +28 @@
   [Item("TimeLag", "Represents a symblol whose evaluation is shifted.")]
   public sealed class TimeLag : LaggedSymbol {
+    private const int minimumArity = 1;
+    private const int maximumArity = 1;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
+
     [StorableConstructor]
     private TimeLag(bool deserializing) : base(deserializing) { }

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Variable.cs

@@ -100 +100 @@
       }
     }
+
+    private const int minimumArity = 0;
+    private const int maximumArity = 0;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
     #endregion
+
     [StorableConstructor]
     protected Variable(bool deserializing)

branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs

@@ -138 +138 @@
       }
     }
+
+    private const int minimumArity = 2;
+    private const int maximumArity = 2;
+
+    public override int MinimumArity {
+      get { return minimumArity; }
+    }
+    public override int MaximumArity {
+      get { return maximumArity; }
+    }
     #endregion