Free cookie consent management tool by TermsFeed Policy Generator

Changeset 6387


Ignore:
Timestamp:
06/08/11 10:42:57 (13 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
Files:
59 edited

Legend:

Unmodified
Added
Removed
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionGrammarEditorView.cs

    r6377 r6387  
    178178      VisualSymbolicExpressionTreeNode clickedNode = (VisualSymbolicExpressionTreeNode)sender;
    179179      var selectedNode = clickedNode.SymbolicExpressionTreeNode;
    180       if (selectedNode.SubtreesCount == 0) {
     180      if (selectedNode.SubtreeCount == 0) {
    181181        if (!selectedSymbolicExpressionTreeNodes.Contains(selectedNode))
    182182          selectedSymbolicExpressionTreeNodes.Add(selectedNode);
     
    349349  [NonDiscoverableType]
    350350  internal class DummySymbol : Symbol {
     351    private const int minimumArity = 1;
     352    private const int maximumArity = byte.MaxValue;
     353
     354    public override int MinimumArity {
     355      get { return minimumArity; }
     356    }
     357    public override int MaximumArity {
     358      get { return maximumArity; }
     359    }
     360
    351361    public DummySymbol(DummySymbol original, Cloner cloner) : base(original, cloner) { }
    352362    public DummySymbol(string name) : base(name, "DummySymbol for views") { }
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionTreeChart.cs

    r6377 r6387  
    262262
    263263      //draw terminal node
    264       if (node.SubtreesCount == 0) {
     264      if (node.SubtreeCount == 0) {
    265265        graphics.FillRectangle(nodeFillBrush, visualTreeNode.X, visualTreeNode.Y, visualTreeNode.Width, visualTreeNode.Height);
    266266        graphics.DrawRectangle(nodeLinePen, visualTreeNode.X, visualTreeNode.Y, visualTreeNode.Width, visualTreeNode.Height);
     
    280280      //calculate areas for the subtrees according to their tree size and call drawFunctionTree
    281281      Point connectFrom = new Point(visualTreeNode.X + visualTreeNode.Width / 2, visualTreeNode.Y + visualTreeNode.Height);
    282       int[] xBoundaries = new int[node.SubtreesCount + 1];
     282      int[] xBoundaries = new int[node.SubtreeCount + 1];
    283283      xBoundaries[0] = x;
    284       for (int i = 0; i < node.SubtreesCount; i++) {
     284      for (int i = 0; i < node.SubtreeCount; i++) {
    285285        xBoundaries[i + 1] = (int)(xBoundaries[i] + (width * (double)node.GetSubtree(i).GetLength()) / (node.GetLength() - 1));
    286286        DrawFunctionTree(node.GetSubtree(i), graphics, xBoundaries[i], y + height,
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Analyzers/SymbolicExpressionSymbolFrequencyAnalyzer.cs

    r5983 r6387  
    126126          string symbolName;
    127127          if (aggregateDifferentNumberOfSubtrees) symbolName = node.Symbol.Name;
    128           else symbolName = node.Symbol.Name + "-" + node.SubtreesCount;
     128          else symbolName = node.Symbol.Name + "-" + node.SubtreeCount;
    129129          if (symbolFrequencies.ContainsKey(symbolName)) symbolFrequencies[symbolName] += 1;
    130130          else symbolFrequencies.Add(symbolName, 1);
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Compiler/SymbolicExpressionTreeCompiler.cs

    r5809 r6387  
    6262      foreach (var node in branch.IterateNodesPrefix()) {
    6363        Instruction instr = new Instruction();
    64         int subtreesCount = node.SubtreesCount;
     64        int subtreesCount = node.SubtreeCount;
    6565        if (subtreesCount > 255) throw new ArgumentException("Number of subtrees is too big (>255)");
    6666        instr.nArguments = (byte)subtreesCount;
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs

    r6284 r6387  
    133133      if (newChild == null) {
    134134        // make sure that one subtree can be removed and that only the last subtree is removed
    135         return parent.Grammar.GetMinimumSubtreeCount(parent.Symbol) < parent.SubtreesCount &&
    136           cutPoint.ChildIndex == parent.SubtreesCount - 1;
     135        return parent.Grammar.GetMinimumSubtreeCount(parent.Symbol) < parent.SubtreeCount &&
     136          cutPoint.ChildIndex == parent.SubtreeCount - 1;
    137137      } else {
    138138        // check syntax constraints of direct parent - child relation
     
    146146            result &&
    147147            parent.Grammar.ContainsSymbol(n.Symbol) &&
    148             n.SubtreesCount >= parent.Grammar.GetMinimumSubtreeCount(n.Symbol) &&
    149             n.SubtreesCount <= parent.Grammar.GetMaximumSubtreeCount(n.Symbol);
     148            n.SubtreeCount >= parent.Grammar.GetMinimumSubtreeCount(n.Symbol) &&
     149            n.SubtreeCount <= parent.Grammar.GetMaximumSubtreeCount(n.Symbol);
    150150        });
    151151        return result;
     
    169169          }
    170170          // add one additional extension point if the number of sub trees for the symbol is not full
    171           if (n.SubtreesCount < n.Grammar.GetMaximumSubtreeCount(n.Symbol)) {
     171          if (n.SubtreeCount < n.Grammar.GetMaximumSubtreeCount(n.Symbol)) {
    172172            // empty extension point
    173             internalCrossoverPoints.Add(new CutPoint(n, n.SubtreesCount));
     173            internalCrossoverPoints.Add(new CutPoint(n, n.SubtreeCount));
    174174          }
    175175        }
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbol.cs

    r6296 r6387  
    3030    bool Fixed { get; set; }
    3131
     32    int MinimumArity { get; }
     33    int MaximumArity { get; }
     34
    3235    event EventHandler Changed;
    3336  }
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs

    r5809 r6387  
    3939
    4040    IEnumerable<ISymbolicExpressionTreeNode> Subtrees { get; }
    41     int SubtreesCount { get; }
     41    int SubtreeCount { get; }
    4242    ISymbolicExpressionTreeNode GetSubtree(int index);
    4343    int IndexOfSubtree(ISymbolicExpressionTreeNode tree);
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs

    r6377 r6387  
    143143    private void AddSymbolToDictionaries(ISymbol symbol) {
    144144      symbols.Add(symbol.Name, symbol);
    145       symbolSubtreeCount.Add(symbol.Name, Tuple.Create(0, 0));
     145      symbolSubtreeCount.Add(symbol.Name, Tuple.Create(symbol.MinimumArity, symbol.MaximumArity));
    146146      RegisterSymbolEvents(symbol);
    147147    }
     
    315315    protected void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
    316316      var groupSymbol = symbol as GroupSymbol;
    317       if (groupSymbol != null)
    318         foreach (ISymbol s in groupSymbol.Flatten().Where(s => !(s is GroupSymbol)))
     317      if (groupSymbol != null) {
     318        var symbols = groupSymbol.Flatten().Where(s => !(s is GroupSymbol));
     319        if (symbols.Any(s => s.MinimumArity > minimumSubtreeCount)) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);
     320        if (symbols.Any(s => s.MaximumArity < maximumSubtreeCount)) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);
     321        foreach (ISymbol s in symbols)
    319322          SetSubTreeCountInDictionaries(s, minimumSubtreeCount, maximumSubtreeCount);
    320       else
     323      } else {
     324        if (symbol.MinimumArity > minimumSubtreeCount) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);
     325        if (symbol.MaximumArity < maximumSubtreeCount) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);
    321326        SetSubTreeCountInDictionaries(symbol, minimumSubtreeCount, maximumSubtreeCount);
     327      }
    322328
    323329      ClearCaches();
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs

    r6377 r6387  
    126126    public virtual void ShakeLocalParameters(IRandom random, double shakingFactor) { }
    127127
    128     public int SubtreesCount {
     128    public int SubtreeCount {
    129129      get {
    130130        if (subtrees == null) return 0;
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Argument.cs

    r6233 r6387  
    3232    public const string ArgumentName = "Argument";
    3333    public const string ArgumentDescription = "Symbol that represents a function argument.";
     34    private const int minimumArity = 0;
     35    private const int maximumArity = 0;
     36
     37    public override int MinimumArity {
     38      get { return minimumArity; }
     39    }
     40    public override int MaximumArity {
     41      get { return maximumArity; }
     42    }
     43
    3444    [Storable]
    3545    private int argumentIndex;
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Defun.cs

    r5809 r6387  
    3232    public const string DefunName = "Defun";
    3333    public const string DefunDescription = "Symbol that represents a function defining node.";
     34    private const int minimumArity = 1;
     35    private const int maximumArity = 1;
     36
     37    public override int MinimumArity {
     38      get { return minimumArity; }
     39    }
     40    public override int MaximumArity {
     41      get { return maximumArity; }
     42    }
    3443
    3544    [StorableConstructor]
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/GroupSymbol.cs

    r6377 r6387  
    2828namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding {
    2929  public sealed class GroupSymbol : Symbol {
     30    private const int minimumArity = 0;
     31    private const int maximumArity = 0;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    private ObservableSet<ISymbol> symbols;
    3141    public IObservableSet<ISymbol> SymbolsCollection {
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/InvokeFunction.cs

    r6233 r6387  
    3232    public const string InvokeFunctionName = "InvokeFunction";
    3333    public const string InvokeFunctionDescription = "Symbol that the invocation of another function.";
     34    private const int minimumArity = 0;
     35    private const int maximumArity = byte.MaxValue;
     36
     37    public override int MinimumArity {
     38      get { return minimumArity; }
     39    }
     40    public override int MaximumArity {
     41      get { return maximumArity; }
     42    }
    3443
    3544    [Storable]
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/ProgramRootSymbol.cs

    r5809 r6387  
    2929    public const string ProgramRootSymbolName = "ProgramRootSymbol";
    3030    public const string ProgramRootSymbolDescription = "Special symbol that represents the program root node of a symbolic expression tree.";
     31    private const int minimumArity = 1;
     32    private const int maximumArity = byte.MaxValue;
     33
     34    public override int MinimumArity {
     35      get { return minimumArity; }
     36    }
     37    public override int MaximumArity {
     38      get { return maximumArity; }
     39    }
    3140
    3241    [StorableConstructor]
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/StartSymbol.cs

    r5809 r6387  
    2929    public const string StartSymbolName = "StartSymbol";
    3030    public const string StartSymbolDescription = "Special symbol that represents the starting node of the result producing branch of a symbolic expression tree.";
     31    private const int minimumArity = 1;
     32    private const int maximumArity = 1;
     33
     34    public override int MinimumArity {
     35      get { return minimumArity; }
     36    }
     37    public override int MaximumArity {
     38      get { return maximumArity; }
     39    }
    3140
    3241    [StorableConstructor]
    33     private StartSymbol(bool deserializing) : base(deserializing) { }
     42    private StartSymbol(bool deserializing)
     43      : base(deserializing) {
     44    }
    3445    private StartSymbol(StartSymbol original, Cloner cloner) : base(original, cloner) { }
    3546    public StartSymbol() : base(StartSymbol.StartSymbolName, StartSymbol.StartSymbolDescription) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Symbol.cs

    r6299 r6387  
    7373      get { return false; }
    7474    }
     75
     76    public abstract int MinimumArity { get; }
     77    public abstract int MaximumArity { get; }
    7578    #endregion
    7679
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Grammars.cs

    r6377 r6387  
    2727namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._4.Tests {
    2828  public static class Grammars {
    29 
    3029    [StorableClass]
    3130    private class Addition : Symbol {
     31      private const int minimumArity = 1;
     32      private const int maximumArity = byte.MaxValue;
     33
     34      public override int MinimumArity {
     35        get { return minimumArity; }
     36      }
     37      public override int MaximumArity {
     38        get { return maximumArity; }
     39      }
     40
    3241      [StorableConstructor]
    3342      protected Addition(bool deserializing) : base(deserializing) { }
     
    4150    [StorableClass]
    4251    private class Subtraction : Symbol {
     52      private const int minimumArity = 1;
     53      private const int maximumArity = byte.MaxValue;
     54
     55      public override int MinimumArity {
     56        get { return minimumArity; }
     57      }
     58      public override int MaximumArity {
     59        get { return maximumArity; }
     60      }
     61
    4362      [StorableConstructor]
    4463      protected Subtraction(bool deserializing) : base(deserializing) { }
     
    5271    [StorableClass]
    5372    private class Multiplication : Symbol {
     73      private const int minimumArity = 1;
     74      private const int maximumArity = byte.MaxValue;
     75
     76      public override int MinimumArity {
     77        get { return minimumArity; }
     78      }
     79      public override int MaximumArity {
     80        get { return maximumArity; }
     81      }
     82
    5483      [StorableConstructor]
    5584      protected Multiplication(bool deserializing) : base(deserializing) { }
     
    6392    [StorableClass]
    6493    private class Division : Symbol {
     94      private const int minimumArity = 1;
     95      private const int maximumArity = byte.MaxValue;
     96
     97      public override int MinimumArity {
     98        get { return minimumArity; }
     99      }
     100      public override int MaximumArity {
     101        get { return maximumArity; }
     102      }
     103
    65104      [StorableConstructor]
    66105      protected Division(bool deserializing) : base(deserializing) { }
     
    74113    [StorableClass]
    75114    private class Terminal : Symbol {
     115      private const int minimumArity = 0;
     116      private const int maximumArity = 0;
     117
     118      public override int MinimumArity {
     119        get { return minimumArity; }
     120      }
     121      public override int MaximumArity {
     122        get { return maximumArity; }
     123      }
     124
    76125      [StorableConstructor]
    77126      protected Terminal(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs

    r5809 r6387  
    122122
    123123        foreach (var argTreenode in defunTreeNode.IterateNodesPrefix().OfType<ArgumentTreeNode>()) {
    124           Assert.IsTrue(argTreenode.SubtreesCount == 0);
     124          Assert.IsTrue(argTreenode.SubtreeCount == 0);
    125125          Assert.IsTrue(((Argument)argTreenode.Symbol).ArgumentIndex < arity);
    126126        }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/IfFoodAhead.cs

    r5809 r6387  
    2828  [Item("IfFoodAhead", "Represents the if-food-ahead symbol in a artificial ant expression.")]
    2929  public sealed class IfFoodAhead : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 3;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private IfFoodAhead(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Left.cs

    r5809 r6387  
    2828  [Item("Left", "Represents the turn-left symbol in a artificial ant expression.")]
    2929  public sealed class Left : Symbol {
     30    private const int minimumArity = 0;
     31    private const int maximumArity = 0;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Left(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Move.cs

    r5809 r6387  
    2828  [Item("Move", "Represents the move-forward symbol in a artificial ant expression.")]
    2929  public sealed class Move : Symbol {
     30    private const int minimumArity = 0;
     31    private const int maximumArity = 0;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Move(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Prog2.cs

    r5809 r6387  
    2929  [Item("Prog2", "Represents the sequence symbol with 2 sub-trees in a artificial ant expression.")]
    3030  public sealed class Prog2 : Symbol {
     31    private const int minimumArity = 2;
     32    private const int maximumArity = 2;
     33
     34    public override int MinimumArity {
     35      get { return minimumArity; }
     36    }
     37    public override int MaximumArity {
     38      get { return maximumArity; }
     39    }
     40
    3141    [StorableConstructor]
    3242    private Prog2(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Prog3.cs

    r5809 r6387  
    2828  [Item("Prog3", "Represents the sequence symbol with 3 sub-trees in a artificial ant expression.")]
    2929  public sealed class Prog3 : Symbol {
     30    private const int minimumArity = 3;
     31    private const int maximumArity = 3;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Prog3(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Right.cs

    r5809 r6387  
    2828  [Item("Right", "Represents the turn-right symbol in a artificial ant expression.")]
    2929  public sealed class Right : Symbol {
     30    private const int minimumArity = 0;
     31    private const int maximumArity = 0;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Right(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs

    r6256 r6387  
    108108    private double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree) {
    109109      // remove old ADFs
    110       while (tempTree.Root.SubtreesCount > 1) tempTree.Root.RemoveSubtree(1);
     110      while (tempTree.Root.SubtreeCount > 1) tempTree.Root.RemoveSubtree(1);
    111111      // clone ADFs of source tree
    112       for (int i = 1; i < sourceTree.Root.SubtreesCount; i++) {
     112      for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) {
    113113        tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone());
    114114      }
    115115      var start = tempTree.Root.GetSubtree(0);
    116       while (start.SubtreesCount > 0) start.RemoveSubtree(0);
     116      while (start.SubtreeCount > 0) start.RemoveSubtree(0);
    117117      start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone());
    118118      var interpreter = Content.Model.Interpreter;
     
    123123
    124124    private void SwitchNode(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode oldBranch, ISymbolicExpressionTreeNode newBranch) {
    125       for (int i = 0; i < root.SubtreesCount; i++) {
     125      for (int i = 0; i < root.SubtreeCount; i++) {
    126126        if (root.GetSubtree(i) == oldBranch) {
    127127          root.RemoveSubtree(i);
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs

    r6234 r6387  
    130130      if (startNode.GetSubtree(0).Symbol is Addition) {
    131131        var addNode = startNode.GetSubtree(0);
    132         if (addNode.SubtreesCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
     132        if (addNode.SubtreeCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
    133133          alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode;
    134134          var mulNode = addNode.GetSubtree(0);
    135           if (mulNode.SubtreesCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
     135          if (mulNode.SubtreeCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
    136136            betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode;
    137137          }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs

    r6377 r6387  
    9797    private double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree) {
    9898      // remove old ADFs
    99       while (tempTree.Root.SubtreesCount > 1) tempTree.Root.RemoveSubtree(1);
     99      while (tempTree.Root.SubtreeCount > 1) tempTree.Root.RemoveSubtree(1);
    100100      // clone ADFs of source tree
    101       for (int i = 1; i < sourceTree.Root.SubtreesCount; i++) {
     101      for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) {
    102102        tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone());
    103103      }
    104104      var start = tempTree.Root.GetSubtree(0);
    105       while (start.SubtreesCount > 0) start.RemoveSubtree(0);
     105      while (start.SubtreeCount > 0) start.RemoveSubtree(0);
    106106      start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone());
    107107      var interpreter = Content.Model.Interpreter;
     
    112112
    113113    private void SwitchNode(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode oldBranch, ISymbolicExpressionTreeNode newBranch) {
    114       for (int i = 0; i < root.SubtreesCount; i++) {
     114      for (int i = 0; i < root.SubtreeCount; i++) {
    115115        if (root.GetSubtree(i) == oldBranch) {
    116116          root.RemoveSubtree(i);
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs

    r6234 r6387  
    7979      if (startNode.GetSubtree(0).Symbol is Addition) {
    8080        var addNode = startNode.GetSubtree(0);
    81         if (addNode.SubtreesCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
     81        if (addNode.SubtreeCount == 2 && addNode.GetSubtree(0).Symbol is Multiplication && addNode.GetSubtree(1).Symbol is Constant) {
    8282          alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode;
    8383          var mulNode = addNode.GetSubtree(0);
    84           if (mulNode.SubtreesCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
     84          if (mulNode.SubtreeCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {
    8585            betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode;
    8686          }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs

    r6377 r6387  
    7171
    7272    protected override void OnModelChanged(EventArgs e) {
     73      RecalculateResults();
    7374      base.OnModelChanged(e);
    74       RecalculateResults();
    7575    }
    7676
    77     protected override void RecalculateResults() {
     77    protected new void RecalculateResults() {
    7878      ModelLength = Model.SymbolicExpressionTree.Length;
    7979      ModelDepth = Model.SymbolicExpressionTree.Depth;
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs

    r6256 r6387  
    9595          List<ISymbolicExpressionTreeNode> nodeList = Content.Model.SymbolicExpressionTree.Root.GetSubtree(0).IterateNodesPrefix().ToList();
    9696          foreach (var parent in nodeList) {
    97             for (int subTreeIndex = 0; subTreeIndex < parent.SubtreesCount; subTreeIndex++) {
     97            for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) {
    9898              var child = parent.GetSubtree(subTreeIndex);
    9999              if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) {
     
    105105
    106106        // show only interesting part of solution
    107         if (tree.Root.SubtreesCount > 1)
     107        if (tree.Root.SubtreeCount > 1)
    108108          this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
    109109        else
     
    130130      var tree = Content.Model.SymbolicExpressionTree;
    131131      foreach (SymbolicExpressionTreeNode treeNode in tree.IterateNodesPostfix()) {
    132         for (int i = 0; i < treeNode.SubtreesCount; i++) {
     132        for (int i = 0; i < treeNode.SubtreeCount; i++) {
    133133          ISymbolicExpressionTreeNode subTree = treeNode.GetSubtree(i);
    134134          // only allow to replace nodes for which a replacement value is known (replacement value for ADF nodes are not available)
     
    137137
    138138            // show only interesting part of solution
    139             if (tree.Root.SubtreesCount > 1)
     139            if (tree.Root.SubtreeCount > 1)
    140140              this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs
    141141            else
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs

    r6135 r6387  
    8888      StringBuilder builder = new StringBuilder();
    8989      builder.Append("(" + tree.ToString());
    90       for (int i = 0; i < tree.SubtreesCount; i++) {
     90      for (int i = 0; i < tree.SubtreeCount; i++) {
    9191        builder.Append(" " + GetTextualRepresentationFromSubtreeOfDepth(tree.GetSubtree(i), d - 1));
    9292      }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

    r5817 r6387  
    7373      FormatBegin(node, strBuilder);
    7474
    75       if (node.SubtreesCount > 0) {
     75      if (node.SubtreeCount > 0) {
    7676        strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    7777      }
     
    9191        strBuilder.Append(@" \left( ");
    9292      } else if (node.Symbol is Subtraction) {
    93         if (node.SubtreesCount == 1) {
     93        if (node.SubtreeCount == 1) {
    9494          strBuilder.Append(@"- \left(");
    9595        } else {
     
    9898      } else if (node.Symbol is Multiplication) {
    9999      } else if (node.Symbol is Division) {
    100         if (node.SubtreesCount == 1) {
     100        if (node.SubtreeCount == 1) {
    101101          strBuilder.Append(@" \cfrac{1}{");
    102102        } else {
     
    105105      } else if (node.Symbol is Average) {
    106106        // skip output of (1/1) if only one subtree
    107         if (node.SubtreesCount > 1) {
    108           strBuilder.Append(@" \cfrac{1}{" + node.SubtreesCount + @"}");
     107        if (node.SubtreeCount > 1) {
     108          strBuilder.Append(@" \cfrac{1}{" + node.SubtreeCount + @"}");
    109109        }
    110110        strBuilder.Append(@" \left(");
     
    246246      } else if (node.Symbol is Division) {
    247247        strBuilder.Append("} ");
    248         if (node.SubtreesCount > 1)
     248        if (node.SubtreeCount > 1)
    249249          strBuilder.Append("{1} ");
    250         for (int i = 1; i < node.SubtreesCount; i++) {
     250        for (int i = 1; i < node.SubtreeCount; i++) {
    251251          strBuilder.Append(" } ");
    252252        }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

    r5809 r6387  
    106106
    107107      if (symbol is Addition) {
    108         for (int i = 0; i < node.SubtreesCount; i++) {
     108        for (int i = 0; i < node.SubtreeCount; i++) {
    109109          if (i > 0) stringBuilder.Append("+");
    110110          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
     
    112112      } else if (symbol is And) {
    113113        stringBuilder.Append("((");
    114         for (int i = 0; i < node.SubtreesCount; i++) {
     114        for (int i = 0; i < node.SubtreeCount; i++) {
    115115          if (i > 0) stringBuilder.Append("&");
    116116          stringBuilder.Append("((");
     
    121121      } else if (symbol is Average) {
    122122        stringBuilder.Append("(1/");
    123         stringBuilder.Append(node.SubtreesCount);
     123        stringBuilder.Append(node.SubtreeCount);
    124124        stringBuilder.Append(")*(");
    125         for (int i = 0; i < node.SubtreesCount; i++) {
     125        for (int i = 0; i < node.SubtreeCount; i++) {
    126126          if (i > 0) stringBuilder.Append("+");
    127127          stringBuilder.Append("(");
     
    138138        stringBuilder.Append(")");
    139139      } else if (symbol is Division) {
    140         if (node.SubtreesCount == 1) {
     140        if (node.SubtreeCount == 1) {
    141141          stringBuilder.Append("1/");
    142142          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     
    144144          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    145145          stringBuilder.Append("/(");
    146           for (int i = 1; i < node.SubtreesCount; i++) {
     146          for (int i = 1; i < node.SubtreeCount; i++) {
    147147            if (i > 1) stringBuilder.Append("*");
    148148            stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
     
    187187        stringBuilder.Append(")");
    188188      } else if (symbol is Multiplication) {
    189         for (int i = 0; i < node.SubtreesCount; i++) {
     189        for (int i = 0; i < node.SubtreeCount; i++) {
    190190          if (i > 0) stringBuilder.Append("*");
    191191          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
     
    197197      } else if (symbol is Or) {
    198198        stringBuilder.Append("((");
    199         for (int i = 0; i < node.SubtreesCount; i++) {
     199        for (int i = 0; i < node.SubtreeCount; i++) {
    200200          if (i > 0) stringBuilder.Append("|");
    201201          stringBuilder.Append("((");
     
    209209        stringBuilder.Append(")");
    210210      } else if (symbol is Subtraction) {
    211         if (node.SubtreesCount == 1) {
     211        if (node.SubtreeCount == 1) {
    212212          stringBuilder.Append("-1*");
    213213          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    214214        } else {
    215215          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    216           for (int i = 1; i < node.SubtreesCount; i++) {
     216          for (int i = 1; i < node.SubtreeCount; i++) {
    217217            stringBuilder.Append("-");
    218218            stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

    r5936 r6387  
    6464    private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node, IList<ISymbolicExpressionTreeNode> argumentTrees) {
    6565      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
    66       while (node.SubtreesCount > 0) node.RemoveSubtree(0);
     66      while (node.SubtreeCount > 0) node.RemoveSubtree(0);
    6767      if (node.Symbol is InvokeFunction) {
    6868        var invokeSym = node.Symbol as InvokeFunction;
     
    901901        // x0 * x1 * .. * xn * -1 => x0 * x1 * .. * -xn
    902902        var lastSubTree = x.Subtrees.Last();
    903         x.RemoveSubtree(x.SubtreesCount - 1);
     903        x.RemoveSubtree(x.SubtreeCount - 1);
    904904        x.AddSubtree(Negate(lastSubTree)); // last is maybe a constant, prefer to negate the constant
    905905      } else {
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Addition.cs

    r5809 r6387  
    2222using HeuristicLab.Common;
    2323using HeuristicLab.Core;
     24using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2425using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    25 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    2727  [StorableClass]
    2828  [Item("Addition", "Symbol that represents the + operator.")]
    2929  public sealed class Addition : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Addition(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/And.cs

    r5809 r6387  
    2828  [Item("And", "Symbol that represents the boolean AND operator.")]
    2929  public sealed class And : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private And(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Average.cs

    r5809 r6387  
    2828  [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
    2929  public sealed class Average : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Average(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs

    r5809 r6387  
    8888    }
    8989
     90    private const int minimumArity = 0;
     91    private const int maximumArity = 0;
     92
     93    public override int MinimumArity {
     94      get { return minimumArity; }
     95    }
     96    public override int MaximumArity {
     97      get { return maximumArity; }
     98    }
    9099    #endregion
     100
    91101    [StorableConstructor]
    92102    private Constant(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Cosine.cs

    r5809 r6387  
    2828  [Item("Cosine", "Symbol that represents the cosine function.")]
    2929  public sealed class Cosine : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Cosine(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Derivative.cs

    r5809 r6387  
    2828  [Item("Derivative", "Represents the derivative over the specified subtree.")]
    2929  public sealed class Derivative : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Derivative(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Division.cs

    r5809 r6387  
    2828  [Item("Division", "Symbol that represents the / operator.")]
    2929  public sealed class Division : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Division(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Exponential.cs

    r5809 r6387  
    2828  [Item("Exponential", "Symbol that represents the exponential function.")]
    2929  public sealed class Exponential : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Exponential(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/GreaterThan.cs

    r5809 r6387  
    2828  [Item("GreaterThan", "Symbol that represents a greater than relation.")]
    2929  public sealed class GreaterThan : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private GreaterThan(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/IfThenElse.cs

    r5809 r6387  
    2828  [Item("IfThenElse", "Symbol that represents a conditional operator.")]
    2929  public sealed class IfThenElse : Symbol {
     30    private const int minimumArity = 3;
     31    private const int maximumArity = 3;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private IfThenElse(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Integral.cs

    r5809 r6387  
    2727  [Item("Integral", "Represents the integral over the specified subtree.")]
    2828  public sealed class Integral : LaggedSymbol {
     29    private const int minimumArity = 1;
     30    private const int maximumArity = 1;
     31
     32    public override int MinimumArity {
     33      get { return minimumArity; }
     34    }
     35    public override int MaximumArity {
     36      get { return maximumArity; }
     37    }
     38
    2939    [StorableConstructor]
    3040    private Integral(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/LessThan.cs

    r5809 r6387  
    2828  [Item("LessThan", "Symbol that represents a less than relation.")]
    2929  public sealed class LessThan : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private LessThan(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Logarithm.cs

    r5809 r6387  
    2828  [Item("Logarithm", "Symbol that represents the logarithm function.")]
    2929  public sealed class Logarithm : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Logarithm(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Multiplication.cs

    r5809 r6387  
    2828  [Item("Multiplication", "Symbol that represents the * operator.")]
    2929  public sealed class Multiplication : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Multiplication(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Not.cs

    r5809 r6387  
    2828  [Item("Not", "Symbol that represents the boolean NOT operator.")]
    2929  public sealed class Not : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Not(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Or.cs

    r5809 r6387  
    2828  [Item("Or", "Symbol that represents the boolean OR operator.")]
    2929  public sealed class Or : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Or(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Power.cs

    r5809 r6387  
    2828  [Item("Power", "Symbol that represents the power function.")]
    2929  public sealed class Power : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Power(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Root.cs

    r5809 r6387  
    2828  [Item("Root", "Symbol that represents the n-th root function.")]
    2929  public sealed class Root : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Root(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sine.cs

    r5809 r6387  
    2828  [Item("Sine", "Symbol that represents the sine function.")]
    2929  public sealed class Sine : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Sine(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Subtraction.cs

    r5809 r6387  
    2828  [Item("Subtraction", "Symbol that represents the - operator.")]
    2929  public sealed class Subtraction : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Subtraction(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Tangent.cs

    r5809 r6387  
    2828  [Item("Tangent", "Symbol that represents the tangent trigonometric function.")]
    2929  public sealed class Tangent : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Tangent(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeLag.cs

    r5809 r6387  
    2828  [Item("TimeLag", "Represents a symblol whose evaluation is shifted.")]
    2929  public sealed class TimeLag : LaggedSymbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private TimeLag(bool deserializing) : base(deserializing) { }
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Variable.cs

    r6284 r6387  
    100100      }
    101101    }
     102
     103    private const int minimumArity = 0;
     104    private const int maximumArity = 0;
     105
     106    public override int MinimumArity {
     107      get { return minimumArity; }
     108    }
     109    public override int MaximumArity {
     110      get { return maximumArity; }
     111    }
    102112    #endregion
     113
    103114    [StorableConstructor]
    104115    protected Variable(bool deserializing)
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs

    r5809 r6387  
    138138      }
    139139    }
     140
     141    private const int minimumArity = 2;
     142    private const int maximumArity = 2;
     143
     144    public override int MinimumArity {
     145      get { return minimumArity; }
     146    }
     147    public override int MaximumArity {
     148      get { return maximumArity; }
     149    }
    140150    #endregion
    141151
  • branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs

    r6377 r6387  
    118118
    119119    protected override void OnProblemDataChanged(EventArgs e) {
     120      RecalculateResults();
    120121      base.OnProblemDataChanged(e);
    121       RecalculateResults();
    122122    }
    123123    protected override void OnModelChanged(EventArgs e) {
     124      RecalculateResults();
    124125      base.OnModelChanged(e);
    125       RecalculateResults();
    126126    }
    127127
    128     protected virtual void RecalculateResults() {
     128    protected void RecalculateResults() {
    129129      double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values
    130130      IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
Note: See TracChangeset for help on using the changeset viewer.