Changeset 6387
- Timestamp:
- 06/08/11 10:42:57 (13 years ago)
- 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 178 178 VisualSymbolicExpressionTreeNode clickedNode = (VisualSymbolicExpressionTreeNode)sender; 179 179 var selectedNode = clickedNode.SymbolicExpressionTreeNode; 180 if (selectedNode.Subtree sCount == 0) {180 if (selectedNode.SubtreeCount == 0) { 181 181 if (!selectedSymbolicExpressionTreeNodes.Contains(selectedNode)) 182 182 selectedSymbolicExpressionTreeNodes.Add(selectedNode); … … 349 349 [NonDiscoverableType] 350 350 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 351 361 public DummySymbol(DummySymbol original, Cloner cloner) : base(original, cloner) { } 352 362 public DummySymbol(string name) : base(name, "DummySymbol for views") { } -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views/3.4/SymbolicExpressionTreeChart.cs
r6377 r6387 262 262 263 263 //draw terminal node 264 if (node.Subtree sCount == 0) {264 if (node.SubtreeCount == 0) { 265 265 graphics.FillRectangle(nodeFillBrush, visualTreeNode.X, visualTreeNode.Y, visualTreeNode.Width, visualTreeNode.Height); 266 266 graphics.DrawRectangle(nodeLinePen, visualTreeNode.X, visualTreeNode.Y, visualTreeNode.Width, visualTreeNode.Height); … … 280 280 //calculate areas for the subtrees according to their tree size and call drawFunctionTree 281 281 Point connectFrom = new Point(visualTreeNode.X + visualTreeNode.Width / 2, visualTreeNode.Y + visualTreeNode.Height); 282 int[] xBoundaries = new int[node.Subtree sCount + 1];282 int[] xBoundaries = new int[node.SubtreeCount + 1]; 283 283 xBoundaries[0] = x; 284 for (int i = 0; i < node.Subtree sCount; i++) {284 for (int i = 0; i < node.SubtreeCount; i++) { 285 285 xBoundaries[i + 1] = (int)(xBoundaries[i] + (width * (double)node.GetSubtree(i).GetLength()) / (node.GetLength() - 1)); 286 286 DrawFunctionTree(node.GetSubtree(i), graphics, xBoundaries[i], y + height, -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Analyzers/SymbolicExpressionSymbolFrequencyAnalyzer.cs
r5983 r6387 126 126 string symbolName; 127 127 if (aggregateDifferentNumberOfSubtrees) symbolName = node.Symbol.Name; 128 else symbolName = node.Symbol.Name + "-" + node.Subtree sCount;128 else symbolName = node.Symbol.Name + "-" + node.SubtreeCount; 129 129 if (symbolFrequencies.ContainsKey(symbolName)) symbolFrequencies[symbolName] += 1; 130 130 else symbolFrequencies.Add(symbolName, 1); -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Compiler/SymbolicExpressionTreeCompiler.cs
r5809 r6387 62 62 foreach (var node in branch.IterateNodesPrefix()) { 63 63 Instruction instr = new Instruction(); 64 int subtreesCount = node.Subtree sCount;64 int subtreesCount = node.SubtreeCount; 65 65 if (subtreesCount > 255) throw new ArgumentException("Number of subtrees is too big (>255)"); 66 66 instr.nArguments = (byte)subtreesCount; -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs
r6284 r6387 133 133 if (newChild == null) { 134 134 // make sure that one subtree can be removed and that only the last subtree is removed 135 return parent.Grammar.GetMinimumSubtreeCount(parent.Symbol) < parent.Subtree sCount &&136 cutPoint.ChildIndex == parent.Subtree sCount - 1;135 return parent.Grammar.GetMinimumSubtreeCount(parent.Symbol) < parent.SubtreeCount && 136 cutPoint.ChildIndex == parent.SubtreeCount - 1; 137 137 } else { 138 138 // check syntax constraints of direct parent - child relation … … 146 146 result && 147 147 parent.Grammar.ContainsSymbol(n.Symbol) && 148 n.Subtree sCount >= parent.Grammar.GetMinimumSubtreeCount(n.Symbol) &&149 n.Subtree sCount <= parent.Grammar.GetMaximumSubtreeCount(n.Symbol);148 n.SubtreeCount >= parent.Grammar.GetMinimumSubtreeCount(n.Symbol) && 149 n.SubtreeCount <= parent.Grammar.GetMaximumSubtreeCount(n.Symbol); 150 150 }); 151 151 return result; … … 169 169 } 170 170 // add one additional extension point if the number of sub trees for the symbol is not full 171 if (n.Subtree sCount < n.Grammar.GetMaximumSubtreeCount(n.Symbol)) {171 if (n.SubtreeCount < n.Grammar.GetMaximumSubtreeCount(n.Symbol)) { 172 172 // empty extension point 173 internalCrossoverPoints.Add(new CutPoint(n, n.Subtree sCount));173 internalCrossoverPoints.Add(new CutPoint(n, n.SubtreeCount)); 174 174 } 175 175 } -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbol.cs
r6296 r6387 30 30 bool Fixed { get; set; } 31 31 32 int MinimumArity { get; } 33 int MaximumArity { get; } 34 32 35 event EventHandler Changed; 33 36 } -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Interfaces/ISymbolicExpressionTreeNode.cs
r5809 r6387 39 39 40 40 IEnumerable<ISymbolicExpressionTreeNode> Subtrees { get; } 41 int Subtree sCount { get; }41 int SubtreeCount { get; } 42 42 ISymbolicExpressionTreeNode GetSubtree(int index); 43 43 int IndexOfSubtree(ISymbolicExpressionTreeNode tree); -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs
r6377 r6387 143 143 private void AddSymbolToDictionaries(ISymbol symbol) { 144 144 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)); 146 146 RegisterSymbolEvents(symbol); 147 147 } … … 315 315 protected void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) { 316 316 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) 319 322 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); 321 326 SetSubTreeCountInDictionaries(symbol, minimumSubtreeCount, maximumSubtreeCount); 327 } 322 328 323 329 ClearCaches(); -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionTreeNode.cs
r6377 r6387 126 126 public virtual void ShakeLocalParameters(IRandom random, double shakingFactor) { } 127 127 128 public int Subtree sCount {128 public int SubtreeCount { 129 129 get { 130 130 if (subtrees == null) return 0; -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Argument.cs
r6233 r6387 32 32 public const string ArgumentName = "Argument"; 33 33 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 34 44 [Storable] 35 45 private int argumentIndex; -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Defun.cs
r5809 r6387 32 32 public const string DefunName = "Defun"; 33 33 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 } 34 43 35 44 [StorableConstructor] -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/GroupSymbol.cs
r6377 r6387 28 28 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding { 29 29 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 30 40 private ObservableSet<ISymbol> symbols; 31 41 public IObservableSet<ISymbol> SymbolsCollection { -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/InvokeFunction.cs
r6233 r6387 32 32 public const string InvokeFunctionName = "InvokeFunction"; 33 33 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 } 34 43 35 44 [Storable] -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/ProgramRootSymbol.cs
r5809 r6387 29 29 public const string ProgramRootSymbolName = "ProgramRootSymbol"; 30 30 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 } 31 40 32 41 [StorableConstructor] -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/StartSymbol.cs
r5809 r6387 29 29 public const string StartSymbolName = "StartSymbol"; 30 30 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 } 31 40 32 41 [StorableConstructor] 33 private StartSymbol(bool deserializing) : base(deserializing) { } 42 private StartSymbol(bool deserializing) 43 : base(deserializing) { 44 } 34 45 private StartSymbol(StartSymbol original, Cloner cloner) : base(original, cloner) { } 35 46 public StartSymbol() : base(StartSymbol.StartSymbolName, StartSymbol.StartSymbolDescription) { } -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Symbols/Symbol.cs
r6299 r6387 73 73 get { return false; } 74 74 } 75 76 public abstract int MinimumArity { get; } 77 public abstract int MaximumArity { get; } 75 78 #endregion 76 79 -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Grammars.cs
r6377 r6387 27 27 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding_3._4.Tests { 28 28 public static class Grammars { 29 30 29 [StorableClass] 31 30 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 32 41 [StorableConstructor] 33 42 protected Addition(bool deserializing) : base(deserializing) { } … … 41 50 [StorableClass] 42 51 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 43 62 [StorableConstructor] 44 63 protected Subtraction(bool deserializing) : base(deserializing) { } … … 52 71 [StorableClass] 53 72 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 54 83 [StorableConstructor] 55 84 protected Multiplication(bool deserializing) : base(deserializing) { } … … 63 92 [StorableClass] 64 93 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 65 104 [StorableConstructor] 66 105 protected Division(bool deserializing) : base(deserializing) { } … … 74 113 [StorableClass] 75 114 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 76 125 [StorableConstructor] 77 126 protected Terminal(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Tests/Util.cs
r5809 r6387 122 122 123 123 foreach (var argTreenode in defunTreeNode.IterateNodesPrefix().OfType<ArgumentTreeNode>()) { 124 Assert.IsTrue(argTreenode.Subtree sCount == 0);124 Assert.IsTrue(argTreenode.SubtreeCount == 0); 125 125 Assert.IsTrue(((Argument)argTreenode.Symbol).ArgumentIndex < arity); 126 126 } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/IfFoodAhead.cs
r5809 r6387 28 28 [Item("IfFoodAhead", "Represents the if-food-ahead symbol in a artificial ant expression.")] 29 29 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 30 40 [StorableConstructor] 31 41 private IfFoodAhead(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Left.cs
r5809 r6387 28 28 [Item("Left", "Represents the turn-left symbol in a artificial ant expression.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Left(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Move.cs
r5809 r6387 28 28 [Item("Move", "Represents the move-forward symbol in a artificial ant expression.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Move(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Prog2.cs
r5809 r6387 29 29 [Item("Prog2", "Represents the sequence symbol with 2 sub-trees in a artificial ant expression.")] 30 30 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 31 41 [StorableConstructor] 32 42 private Prog2(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Prog3.cs
r5809 r6387 28 28 [Item("Prog3", "Represents the sequence symbol with 3 sub-trees in a artificial ant expression.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Prog3(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.ArtificialAnt/3.4/Symbols/Right.cs
r5809 r6387 28 28 [Item("Right", "Represents the turn-right symbol in a artificial ant expression.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Right(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification.Views/3.4/InteractiveSymbolicDiscriminantFunctionClassificationSolutionSimplifierView.cs
r6256 r6387 108 108 private double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree) { 109 109 // remove old ADFs 110 while (tempTree.Root.Subtree sCount > 1) tempTree.Root.RemoveSubtree(1);110 while (tempTree.Root.SubtreeCount > 1) tempTree.Root.RemoveSubtree(1); 111 111 // clone ADFs of source tree 112 for (int i = 1; i < sourceTree.Root.Subtree sCount; i++) {112 for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { 113 113 tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); 114 114 } 115 115 var start = tempTree.Root.GetSubtree(0); 116 while (start.Subtree sCount > 0) start.RemoveSubtree(0);116 while (start.SubtreeCount > 0) start.RemoveSubtree(0); 117 117 start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); 118 118 var interpreter = Content.Model.Interpreter; … … 123 123 124 124 private void SwitchNode(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode oldBranch, ISymbolicExpressionTreeNode newBranch) { 125 for (int i = 0; i < root.Subtree sCount; i++) {125 for (int i = 0; i < root.SubtreeCount; i++) { 126 126 if (root.GetSubtree(i) == oldBranch) { 127 127 root.RemoveSubtree(i); -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Classification/3.4/SymbolicDiscriminantFunctionClassificationModel.cs
r6234 r6387 130 130 if (startNode.GetSubtree(0).Symbol is Addition) { 131 131 var addNode = startNode.GetSubtree(0); 132 if (addNode.Subtree sCount == 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) { 133 133 alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode; 134 134 var mulNode = addNode.GetSubtree(0); 135 if (mulNode.Subtree sCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {135 if (mulNode.SubtreeCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) { 136 136 betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode; 137 137 } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression.Views/3.4/InteractiveSymbolicRegressionSolutionSimplifierView.cs
r6377 r6387 97 97 private double CalculateReplacementValue(ISymbolicExpressionTreeNode node, ISymbolicExpressionTree sourceTree) { 98 98 // remove old ADFs 99 while (tempTree.Root.Subtree sCount > 1) tempTree.Root.RemoveSubtree(1);99 while (tempTree.Root.SubtreeCount > 1) tempTree.Root.RemoveSubtree(1); 100 100 // clone ADFs of source tree 101 for (int i = 1; i < sourceTree.Root.Subtree sCount; i++) {101 for (int i = 1; i < sourceTree.Root.SubtreeCount; i++) { 102 102 tempTree.Root.AddSubtree((ISymbolicExpressionTreeNode)sourceTree.Root.GetSubtree(i).Clone()); 103 103 } 104 104 var start = tempTree.Root.GetSubtree(0); 105 while (start.Subtree sCount > 0) start.RemoveSubtree(0);105 while (start.SubtreeCount > 0) start.RemoveSubtree(0); 106 106 start.AddSubtree((ISymbolicExpressionTreeNode)node.Clone()); 107 107 var interpreter = Content.Model.Interpreter; … … 112 112 113 113 private void SwitchNode(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode oldBranch, ISymbolicExpressionTreeNode newBranch) { 114 for (int i = 0; i < root.Subtree sCount; i++) {114 for (int i = 0; i < root.SubtreeCount; i++) { 115 115 if (root.GetSubtree(i) == oldBranch) { 116 116 root.RemoveSubtree(i); -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionModel.cs
r6234 r6387 79 79 if (startNode.GetSubtree(0).Symbol is Addition) { 80 80 var addNode = startNode.GetSubtree(0); 81 if (addNode.Subtree sCount == 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) { 82 82 alphaTreeNode = addNode.GetSubtree(1) as ConstantTreeNode; 83 83 var mulNode = addNode.GetSubtree(0); 84 if (mulNode.Subtree sCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) {84 if (mulNode.SubtreeCount == 2 && mulNode.GetSubtree(1).Symbol is Constant) { 85 85 betaTreeNode = mulNode.GetSubtree(1) as ConstantTreeNode; 86 86 } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs
r6377 r6387 71 71 72 72 protected override void OnModelChanged(EventArgs e) { 73 RecalculateResults(); 73 74 base.OnModelChanged(e); 74 RecalculateResults();75 75 } 76 76 77 protected overridevoid RecalculateResults() {77 protected new void RecalculateResults() { 78 78 ModelLength = Model.SymbolicExpressionTree.Length; 79 79 ModelDepth = Model.SymbolicExpressionTree.Depth; -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic.Views/3.4/InteractiveSymbolicDataAnalysisSolutionSimplifierView.cs
r6256 r6387 95 95 List<ISymbolicExpressionTreeNode> nodeList = Content.Model.SymbolicExpressionTree.Root.GetSubtree(0).IterateNodesPrefix().ToList(); 96 96 foreach (var parent in nodeList) { 97 for (int subTreeIndex = 0; subTreeIndex < parent.Subtree sCount; subTreeIndex++) {97 for (int subTreeIndex = 0; subTreeIndex < parent.SubtreeCount; subTreeIndex++) { 98 98 var child = parent.GetSubtree(subTreeIndex); 99 99 if (!(child.Symbol is Constant) && nodeImpacts[child].IsAlmost(0.0)) { … … 105 105 106 106 // show only interesting part of solution 107 if (tree.Root.Subtree sCount > 1)107 if (tree.Root.SubtreeCount > 1) 108 108 this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs 109 109 else … … 130 130 var tree = Content.Model.SymbolicExpressionTree; 131 131 foreach (SymbolicExpressionTreeNode treeNode in tree.IterateNodesPostfix()) { 132 for (int i = 0; i < treeNode.Subtree sCount; i++) {132 for (int i = 0; i < treeNode.SubtreeCount; i++) { 133 133 ISymbolicExpressionTreeNode subTree = treeNode.GetSubtree(i); 134 134 // only allow to replace nodes for which a replacement value is known (replacement value for ADF nodes are not available) … … 137 137 138 138 // show only interesting part of solution 139 if (tree.Root.Subtree sCount > 1)139 if (tree.Root.SubtreeCount > 1) 140 140 this.treeChart.Tree = new SymbolicExpressionTree(tree.Root); // RPB + ADFs 141 141 else -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs
r6135 r6387 88 88 StringBuilder builder = new StringBuilder(); 89 89 builder.Append("(" + tree.ToString()); 90 for (int i = 0; i < tree.Subtree sCount; i++) {90 for (int i = 0; i < tree.SubtreeCount; i++) { 91 91 builder.Append(" " + GetTextualRepresentationFromSubtreeOfDepth(tree.GetSubtree(i), d - 1)); 92 92 } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs
r5817 r6387 73 73 FormatBegin(node, strBuilder); 74 74 75 if (node.Subtree sCount > 0) {75 if (node.SubtreeCount > 0) { 76 76 strBuilder.Append(FormatRecursively(node.GetSubtree(0))); 77 77 } … … 91 91 strBuilder.Append(@" \left( "); 92 92 } else if (node.Symbol is Subtraction) { 93 if (node.Subtree sCount == 1) {93 if (node.SubtreeCount == 1) { 94 94 strBuilder.Append(@"- \left("); 95 95 } else { … … 98 98 } else if (node.Symbol is Multiplication) { 99 99 } else if (node.Symbol is Division) { 100 if (node.Subtree sCount == 1) {100 if (node.SubtreeCount == 1) { 101 101 strBuilder.Append(@" \cfrac{1}{"); 102 102 } else { … … 105 105 } else if (node.Symbol is Average) { 106 106 // skip output of (1/1) if only one subtree 107 if (node.Subtree sCount > 1) {108 strBuilder.Append(@" \cfrac{1}{" + node.Subtree sCount + @"}");107 if (node.SubtreeCount > 1) { 108 strBuilder.Append(@" \cfrac{1}{" + node.SubtreeCount + @"}"); 109 109 } 110 110 strBuilder.Append(@" \left("); … … 246 246 } else if (node.Symbol is Division) { 247 247 strBuilder.Append("} "); 248 if (node.Subtree sCount > 1)248 if (node.SubtreeCount > 1) 249 249 strBuilder.Append("{1} "); 250 for (int i = 1; i < node.Subtree sCount; i++) {250 for (int i = 1; i < node.SubtreeCount; i++) { 251 251 strBuilder.Append(" } "); 252 252 } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs
r5809 r6387 106 106 107 107 if (symbol is Addition) { 108 for (int i = 0; i < node.Subtree sCount; i++) {108 for (int i = 0; i < node.SubtreeCount; i++) { 109 109 if (i > 0) stringBuilder.Append("+"); 110 110 stringBuilder.Append(FormatRecursively(node.GetSubtree(i))); … … 112 112 } else if (symbol is And) { 113 113 stringBuilder.Append("(("); 114 for (int i = 0; i < node.Subtree sCount; i++) {114 for (int i = 0; i < node.SubtreeCount; i++) { 115 115 if (i > 0) stringBuilder.Append("&"); 116 116 stringBuilder.Append("(("); … … 121 121 } else if (symbol is Average) { 122 122 stringBuilder.Append("(1/"); 123 stringBuilder.Append(node.Subtree sCount);123 stringBuilder.Append(node.SubtreeCount); 124 124 stringBuilder.Append(")*("); 125 for (int i = 0; i < node.Subtree sCount; i++) {125 for (int i = 0; i < node.SubtreeCount; i++) { 126 126 if (i > 0) stringBuilder.Append("+"); 127 127 stringBuilder.Append("("); … … 138 138 stringBuilder.Append(")"); 139 139 } else if (symbol is Division) { 140 if (node.Subtree sCount == 1) {140 if (node.SubtreeCount == 1) { 141 141 stringBuilder.Append("1/"); 142 142 stringBuilder.Append(FormatRecursively(node.GetSubtree(0))); … … 144 144 stringBuilder.Append(FormatRecursively(node.GetSubtree(0))); 145 145 stringBuilder.Append("/("); 146 for (int i = 1; i < node.Subtree sCount; i++) {146 for (int i = 1; i < node.SubtreeCount; i++) { 147 147 if (i > 1) stringBuilder.Append("*"); 148 148 stringBuilder.Append(FormatRecursively(node.GetSubtree(i))); … … 187 187 stringBuilder.Append(")"); 188 188 } else if (symbol is Multiplication) { 189 for (int i = 0; i < node.Subtree sCount; i++) {189 for (int i = 0; i < node.SubtreeCount; i++) { 190 190 if (i > 0) stringBuilder.Append("*"); 191 191 stringBuilder.Append(FormatRecursively(node.GetSubtree(i))); … … 197 197 } else if (symbol is Or) { 198 198 stringBuilder.Append("(("); 199 for (int i = 0; i < node.Subtree sCount; i++) {199 for (int i = 0; i < node.SubtreeCount; i++) { 200 200 if (i > 0) stringBuilder.Append("|"); 201 201 stringBuilder.Append("(("); … … 209 209 stringBuilder.Append(")"); 210 210 } else if (symbol is Subtraction) { 211 if (node.Subtree sCount == 1) {211 if (node.SubtreeCount == 1) { 212 212 stringBuilder.Append("-1*"); 213 213 stringBuilder.Append(FormatRecursively(node.GetSubtree(0))); 214 214 } else { 215 215 stringBuilder.Append(FormatRecursively(node.GetSubtree(0))); 216 for (int i = 1; i < node.Subtree sCount; i++) {216 for (int i = 1; i < node.SubtreeCount; i++) { 217 217 stringBuilder.Append("-"); 218 218 stringBuilder.Append(FormatRecursively(node.GetSubtree(i))); -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs
r5936 r6387 64 64 private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node, IList<ISymbolicExpressionTreeNode> argumentTrees) { 65 65 List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees); 66 while (node.Subtree sCount > 0) node.RemoveSubtree(0);66 while (node.SubtreeCount > 0) node.RemoveSubtree(0); 67 67 if (node.Symbol is InvokeFunction) { 68 68 var invokeSym = node.Symbol as InvokeFunction; … … 901 901 // x0 * x1 * .. * xn * -1 => x0 * x1 * .. * -xn 902 902 var lastSubTree = x.Subtrees.Last(); 903 x.RemoveSubtree(x.Subtree sCount - 1);903 x.RemoveSubtree(x.SubtreeCount - 1); 904 904 x.AddSubtree(Negate(lastSubTree)); // last is maybe a constant, prefer to negate the constant 905 905 } else { -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Addition.cs
r5809 r6387 22 22 using HeuristicLab.Common; 23 23 using HeuristicLab.Core; 24 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding; 24 25 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable; 25 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;26 26 namespace HeuristicLab.Problems.DataAnalysis.Symbolic { 27 27 [StorableClass] 28 28 [Item("Addition", "Symbol that represents the + operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Addition(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/And.cs
r5809 r6387 28 28 [Item("And", "Symbol that represents the boolean AND operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private And(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Average.cs
r5809 r6387 28 28 [Item("Average", "Symbol that represents the average (arithmetic mean) function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Average(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs
r5809 r6387 88 88 } 89 89 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 } 90 99 #endregion 100 91 101 [StorableConstructor] 92 102 private Constant(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Cosine.cs
r5809 r6387 28 28 [Item("Cosine", "Symbol that represents the cosine function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Cosine(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Derivative.cs
r5809 r6387 28 28 [Item("Derivative", "Represents the derivative over the specified subtree.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Derivative(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Division.cs
r5809 r6387 28 28 [Item("Division", "Symbol that represents the / operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Division(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Exponential.cs
r5809 r6387 28 28 [Item("Exponential", "Symbol that represents the exponential function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Exponential(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/GreaterThan.cs
r5809 r6387 28 28 [Item("GreaterThan", "Symbol that represents a greater than relation.")] 29 29 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 30 40 [StorableConstructor] 31 41 private GreaterThan(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/IfThenElse.cs
r5809 r6387 28 28 [Item("IfThenElse", "Symbol that represents a conditional operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private IfThenElse(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Integral.cs
r5809 r6387 27 27 [Item("Integral", "Represents the integral over the specified subtree.")] 28 28 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 29 39 [StorableConstructor] 30 40 private Integral(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/LessThan.cs
r5809 r6387 28 28 [Item("LessThan", "Symbol that represents a less than relation.")] 29 29 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 30 40 [StorableConstructor] 31 41 private LessThan(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Logarithm.cs
r5809 r6387 28 28 [Item("Logarithm", "Symbol that represents the logarithm function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Logarithm(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Multiplication.cs
r5809 r6387 28 28 [Item("Multiplication", "Symbol that represents the * operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Multiplication(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Not.cs
r5809 r6387 28 28 [Item("Not", "Symbol that represents the boolean NOT operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Not(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Or.cs
r5809 r6387 28 28 [Item("Or", "Symbol that represents the boolean OR operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Or(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Power.cs
r5809 r6387 28 28 [Item("Power", "Symbol that represents the power function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Power(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Root.cs
r5809 r6387 28 28 [Item("Root", "Symbol that represents the n-th root function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Root(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sine.cs
r5809 r6387 28 28 [Item("Sine", "Symbol that represents the sine function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Sine(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Subtraction.cs
r5809 r6387 28 28 [Item("Subtraction", "Symbol that represents the - operator.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Subtraction(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Tangent.cs
r5809 r6387 28 28 [Item("Tangent", "Symbol that represents the tangent trigonometric function.")] 29 29 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 30 40 [StorableConstructor] 31 41 private Tangent(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeLag.cs
r5809 r6387 28 28 [Item("TimeLag", "Represents a symblol whose evaluation is shifted.")] 29 29 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 30 40 [StorableConstructor] 31 41 private TimeLag(bool deserializing) : base(deserializing) { } -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Variable.cs
r6284 r6387 100 100 } 101 101 } 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 } 102 112 #endregion 113 103 114 [StorableConstructor] 104 115 protected Variable(bool deserializing) -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs
r5809 r6387 138 138 } 139 139 } 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 } 140 150 #endregion 141 151 -
branches/GP.Grammar.Editor/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionSolution.cs
r6377 r6387 118 118 119 119 protected override void OnProblemDataChanged(EventArgs e) { 120 RecalculateResults(); 120 121 base.OnProblemDataChanged(e); 121 RecalculateResults();122 122 } 123 123 protected override void OnModelChanged(EventArgs e) { 124 RecalculateResults(); 124 125 base.OnModelChanged(e); 125 RecalculateResults();126 126 } 127 127 128 protected v irtual void RecalculateResults() {128 protected void RecalculateResults() { 129 129 double[] estimatedTrainingValues = EstimatedTrainingValues.ToArray(); // cache values 130 130 IEnumerable<double> originalTrainingValues = ProblemData.Dataset.GetEnumeratedVariableValues(ProblemData.TargetVariable, ProblemData.TrainingIndizes);
Note: See TracChangeset
for help on using the changeset viewer.