Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
06/23/15 12:50:05 (10 years ago)
Author:
gkronber
Message:

#2261: merged trunk changes to branch
r12494
#2403: added a null check in the MatlabParameterVectorEvaluator to prevent exceptions when clearstate is called

r12493
#2369: added support for squared errors and relative errors to error-characteristic-curve view

r12492
#2392: implemented PearsonsRCalculator to fix incorrect correlation values in the correlation matrix.

r12491
#2402 don't set task state to waiting when it fails

r12490
#2401 added missing Mono.Cecil plugin dependency

r12488
#2400 - Interfaces for Capaciated-, PickupAndDelivery- and TimeWindowed-ProblemInstances now specify an additional penalty parameter to set the current penalty factor for the constraint relaxation. - The setter of the penalty-property in ...

r12485
#2374 made RegressionSolution and ClassificationSolution non-abstract

r12482
#2320: Fixed warnings in unit test solutions introduced in r12420 by marking methods as obsolete.

r12481
#2320: Fixed AfterDeserialization of GEArtifialAntEvaluator.

r12480
#2320: Fixed error in symbolicexpressiontree crossover regarding the wiring of lookup parameters if persisted file is loaded.

r12479
#2397 moved GeoIP project into ExtLibs

r12478
#2329 fixed bug in simple code editor

r12476
#2331 removed outdated plugins

r12475
#2368 fixed compile warnings

r12474
#2399 worked on Mono project prepare script

r12473
#2329 added a simple code editor for Linux

r12472
#2399 - fixed MathJax.js file name - worked on Mono project prepare script

r12471
#2399 worked on Mono project prepare script

r12470
#2399 fixed pre-build events in project files

r12465
#2399 worked on mono project prepare script

r12464
#2399 added patch to project

r12463
#2399 fixed EPPlus so that it compiles on Linux

r12461
#2398: Skip root and start symbols when calculating impacts and replacement values in the pruning operators.

r12458
#2354 show label when no data is displayed and don't show the legend

r12457
#2353 removed duplicated call to Any() in Hive Status page

r12456
#2368 fixed modifier

r12455
#2368 added support in persistence for typecaches in streams

r12445
#2394: Changed Web.config compilation from debug to release to force script bundling. Changed history loading type from lazy to eager loading to increase performance. Fixed "getCoreStatus" typo in statusCtrl.js

r12443
#2394: Fixed UserTaskQuery and GetStatusHistory in the WebApp.Status plugin

r12442
#2394 added nuget folders to svn ignore list

r12435
#2394: Improved PluginManager and updated hive status monitor.

r12434
#2396 added symbolic expression tree formatter for C#

r12433
#2395: Minor change in DoubleValue.GetValue.

r12432
#2395 Use simple round-trip format for doubles because G17 prints some strange numbers (20.22 to 20.219999999999999999). Some accuracy can still be lost on 64bit machines, but should be very rare and minimal. double.MaxValue can still be pa...

r12431
#2395 Fixed parsing issues by using the G17 format.

r12430
#2394 added missing package config

r12429
#2394 added missing package config

r12428
#2394 added web app and status page to trunk

r12424
#2320: Adapted plugin file and updated project file of SymbolicExpressionTreeEncoding.

r12422
#2320: Merged the encoding class and all accompanying changes in the trunk.

r12401
#2387 Fixed a bug where the automatic selection of the first element behaved differently for the NewItemDialog.

r12400
#2387 Forgot to commit a file.

r12399
#2387 - Added context-menu for expanding and collapsing tree-nodes. - Improve response time when expanding/collapsing all nodes for TypeSelector and NewItemDialog.

r12398
#2387 - Added clearSearch-button in TypeSelector. - Adapted behavior of TypeSelector and NewItemDialog that a selected node stays selected as long as it matches the search criteria.

r12397
#2387 - Adapted behavior of the matching in the TypeSelector that it behave the same as the NewItemDialog. The search string is tokenized by space and matches if all tokens are contained, (eg. "Sym Reg" matches "SymbolicRegression...")...

r12393
#2025 - Removed Expand/CollapseAll buttons. - Removed cycling of items.

r12392
#2386: Updated GetHashCode method in the EnumerableBoolEqualityComparer.

Location:
branches/GBT
Files:
6 edited
1 copied

Legend:

Unmodified
Added
Removed

  • branches/GBT

  • branches/GBT/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding

  • branches/GBT/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/EmptySymbolicExpressionTreeGrammar.cs

    r12012 r12495  
    3737
    3838    [StorableConstructor]
    39     private EmptySymbolicExpressionTreeGrammar(bool deserializing) : base(deserializing) {}
     39    private EmptySymbolicExpressionTreeGrammar(bool deserializing) : base(deserializing) { }
    4040    internal EmptySymbolicExpressionTreeGrammar(ISymbolicExpressionGrammar grammar)
    4141      : base() {
    … …  
    7070    }
    7171
    72     IEnumerable<ISymbol> ISymbolicExpressionGrammarBase.GetAllowedChildSymbols(ISymbol parent) {
     72    public IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent) {
    7373      return grammar.GetAllowedChildSymbols(parent);
    7474    }
    7575
    76     IEnumerable<ISymbol> ISymbolicExpressionGrammarBase.GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
     76    public IEnumerable<ISymbol> GetAllowedChildSymbols(ISymbol parent, int argumentIndex) {
    7777      return grammar.GetAllowedChildSymbols(parent, argumentIndex);
    7878    }
    … …  
    8585    }
    8686
    87     int ISymbolicExpressionGrammarBase.GetMinimumExpressionDepth(ISymbol symbol) {
     87    public int GetMinimumExpressionDepth(ISymbol symbol) {
    8888      return grammar.GetMinimumExpressionDepth(symbol);
    8989    }
    90     int ISymbolicExpressionGrammarBase.GetMaximumExpressionDepth(ISymbol symbol) {
     90    public int GetMaximumExpressionDepth(ISymbol symbol) {
    9191      return grammar.GetMaximumExpressionDepth(symbol);
    9292    }
    93     int ISymbolicExpressionGrammarBase.GetMinimumExpressionLength(ISymbol symbol) {
     93    public int GetMinimumExpressionLength(ISymbol symbol) {
    9494      return grammar.GetMinimumExpressionLength(symbol);
    9595    }
    96     int ISymbolicExpressionGrammarBase.GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
     96    public int GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
    9797      return grammar.GetMaximumExpressionLength(symbol, maxDepth);
    9898    }
    9999
     100    public void AddSymbol(ISymbol symbol) { throw new NotSupportedException(); }
     101    public void RemoveSymbol(ISymbol symbol) { throw new NotSupportedException(); }
     102    public void AddAllowedChildSymbol(ISymbol parent, ISymbol child) { throw new NotSupportedException(); }
     103    public void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) { throw new NotSupportedException(); }
     104    public void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) { throw new NotSupportedException(); }
     105    public void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) { throw new NotSupportedException(); }
     106    public void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) { throw new NotSupportedException(); }
     107
    100108
    101109    #region ISymbolicExpressionTreeGrammar Members
    102     IEnumerable<ISymbol> ISymbolicExpressionTreeGrammar.ModifyableSymbols {
     110    public IEnumerable<ISymbol> ModifyableSymbols {
    103111      get { return Enumerable.Empty<ISymbol>(); }
    104112    }
    105113
    106     bool ISymbolicExpressionTreeGrammar.IsModifyableSymbol(ISymbol symbol) {
     114    public bool IsModifyableSymbol(ISymbol symbol) {
    107115      return false;
    108116    }
    109117
    110     void ISymbolicExpressionTreeGrammar.AddSymbol(ISymbol symbol) {
    111       throw new NotSupportedException();
    112     }
    113 
    114     void ISymbolicExpressionTreeGrammar.RemoveSymbol(ISymbol symbol) {
    115       throw new NotSupportedException();
    116     }
    117 
    118     void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
    119       throw new NotSupportedException();
    120     }
    121 
    122     void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    123       throw new NotSupportedException();
    124     }
    125 
    126     void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
    127       throw new NotSupportedException();
    128     }
    129 
    130     void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    131       throw new NotSupportedException();
    132     }
    133 
    134     void ISymbolicExpressionTreeGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
    135       throw new NotSupportedException();
    136     }
    137    
    138     #pragma warning disable 0067 //disable usage warning
     118#pragma warning disable 0067 //disable usage warning
    139119    public event EventHandler Changed;
    140     #pragma warning restore 0067
     120#pragma warning restore 0067
    141121    #endregion
    142122  }

  • branches/GBT/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammar.cs

    r12012 r12495  
    177177    }
    178178
    179     protected override sealed void AddSymbol(ISymbol symbol) {
     179    public override sealed void AddSymbol(ISymbol symbol) {
     180      if (ReadOnly) throw new InvalidOperationException();
    180181      base.AddSymbol(symbol);
    181182      RegisterSymbolEvents(symbol);
    182183      OnChanged();
    183184    }
    184     protected override sealed void RemoveSymbol(ISymbol symbol) {
     185    public override sealed void RemoveSymbol(ISymbol symbol) {
     186      if (ReadOnly) throw new InvalidOperationException();
    185187      DeregisterSymbolEvents(symbol);
    186188      base.RemoveSymbol(symbol);
    … …  
    204206    #endregion
    205207
    206     #region ISymbolicExpressionGrammar methods
    207     void ISymbolicExpressionGrammar.AddSymbol(ISymbol symbol) {
    208       if (ReadOnly) throw new InvalidOperationException();
    209       AddSymbol(symbol);
    210     }
    211     void ISymbolicExpressionGrammar.RemoveSymbol(ISymbol symbol) {
    212       if (ReadOnly) throw new InvalidOperationException();
    213       RemoveSymbol(symbol);
    214     }
    215 
    216     void ISymbolicExpressionGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
     208    public sealed override void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
    217209      if (ReadOnly) throw new InvalidOperationException();
    218210      base.AddAllowedChildSymbol(parent, child);
    219211    }
    220     void ISymbolicExpressionGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
     212    public sealed override void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    221213      if (ReadOnly) throw new InvalidOperationException();
    222214      base.AddAllowedChildSymbol(parent, child, argumentIndex);
    223215    }
    224     void ISymbolicExpressionGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
     216    public sealed override void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
    225217      if (ReadOnly) throw new InvalidOperationException();
    226218      base.RemoveAllowedChildSymbol(parent, child);
    227219    }
    228     void ISymbolicExpressionGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
     220    public sealed override void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    229221      if (ReadOnly) throw new InvalidOperationException();
    230222      base.RemoveAllowedChildSymbol(parent, child, argumentIndex);
    231223    }
    232224
    233     void ISymbolicExpressionGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
     225    public sealed override void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
    234226      if (ReadOnly) throw new InvalidOperationException();
    235227      base.SetSubtreeCount(symbol, minimumSubtreeCount, maximumSubtreeCount);
    … …  
    237229
    238230    private bool suppressEvents = false;
    239     void ISymbolicExpressionGrammar.StartGrammarManipulation() {
     231    public void StartGrammarManipulation() {
    240232      suppressEvents = true;
    241233    }
    242     void ISymbolicExpressionGrammar.FinishedGrammarManipulation() {
     234    public void FinishedGrammarManipulation() {
    243235      suppressEvents = false;
    244236      OnChanged();
    245237    }
    246238
    247     protected override void OnChanged() {
     239    protected sealed override void OnChanged() {
    248240      if (suppressEvents) return;
    249241      base.OnChanged();
    250242    }
    251     #endregion
    252243
    253244    #region symbol events
    … …  
    305296    private void Symbol_NameChanged(object sender, EventArgs e) {
    306297      ISymbol symbol = (ISymbol)sender;
    307       string oldName = symbols.Where(x => x.Value == symbol).First().Key;
     298      string oldName = symbols.First(x => x.Value == symbol).Key;
    308299      string newName = symbol.Name;
    309300

  • branches/GBT/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionGrammarBase.cs

    r12012 r12495  
    4141    private IEnumerable<ISymbol> StorableSymbols {
    4242      get { return symbols.Values.ToArray(); }
    43       set { symbols = value.ToDictionary(sym => sym.Name); }
     43      set { foreach (var s in value) symbols.Add(s.Name, s); }
    4444    }
    4545
    … …  
    4747    private IEnumerable<KeyValuePair<ISymbol, Tuple<int, int>>> StorableSymbolSubtreeCount {
    4848      get { return symbolSubtreeCount.Select(x => new KeyValuePair<ISymbol, Tuple<int, int>>(GetSymbol(x.Key), x.Value)).ToArray(); }
    49       set { symbolSubtreeCount = value.ToDictionary(x => x.Key.Name, x => x.Value); }
     49      set { foreach (var pair in value) symbolSubtreeCount.Add(pair.Key.Name, pair.Value); }
    5050    }
    5151
    … …  
    5353    private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
    5454      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
    55       set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
     55      set { foreach (var pair in value) allowedChildSymbols.Add(pair.Key.Name, pair.Value.Select(y => y.Name).ToList()); }
    5656    }
    5757
    5858    [Storable(Name = "AllowedChildSymbolsPerIndex")]
    5959    private IEnumerable<KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>> StorableAllowedChildSymbolsPerIndex {
    60       get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create<ISymbol, int>(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
    61       set { allowedChildSymbolsPerIndex = value.ToDictionary(x => Tuple.Create(x.Key.Item1.Name, x.Key.Item2), x => x.Value.Select(y => y.Name).ToList()); }
     60      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(GetSymbol).ToArray())).ToArray(); }
     61      set {
     62        foreach (var pair in value)
     63          allowedChildSymbolsPerIndex.Add(Tuple.Create(pair.Key.Item1.Name, pair.Key.Item2), pair.Value.Select(y => y.Name).ToList());
     64      }
    6265    }
    6366    #endregion
    6467
    6568    private bool suppressEvents;
    66     protected Dictionary<string, ISymbol> symbols;
    67     protected Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
    68     protected Dictionary<string, List<string>> allowedChildSymbols;
    69     protected Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
     69    protected readonly Dictionary<string, ISymbol> symbols;
     70    protected readonly Dictionary<string, Tuple<int, int>> symbolSubtreeCount;
     71    protected readonly Dictionary<string, List<string>> allowedChildSymbols;
     72    protected readonly Dictionary<Tuple<string, int>, List<string>> allowedChildSymbolsPerIndex;
    7073
    7174    public override bool CanChangeName {
    … …  
    8790      cachedIsAllowedChildSymbolIndex = new Dictionary<Tuple<string, string, int>, bool>();
    8891
     92      symbols = new Dictionary<string, ISymbol>();
     93      symbolSubtreeCount = new Dictionary<string, Tuple<int, int>>();
     94      allowedChildSymbols = new Dictionary<string, List<string>>();
     95      allowedChildSymbolsPerIndex = new Dictionary<Tuple<string, int>, List<string>>();
     96
    8997      suppressEvents = false;
    9098    }
    … …  
    133141
    134142    #region protected grammar manipulation methods
    135     protected virtual void AddSymbol(ISymbol symbol) {
     143    public virtual void AddSymbol(ISymbol symbol) {
    136144      if (ContainsSymbol(symbol)) throw new ArgumentException("Symbol " + symbol + " is already defined.");
    137145      foreach (var s in symbol.Flatten()) {
    … …  
    143151    }
    144152
    145     protected virtual void RemoveSymbol(ISymbol symbol) {
     153    public virtual void RemoveSymbol(ISymbol symbol) {
    146154      foreach (var s in symbol.Flatten()) {
    147155        symbols.Remove(s.Name);
    … …  
    175183    }
    176184
    177     protected void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
     185    public virtual void AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
    178186      bool changed = false;
    179187
    … …  
    204212    }
    205213
    206     protected void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
     214    public virtual void AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    207215      bool changed = false;
    208216
    … …  
    238246    }
    239247
    240     protected void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
     248    public virtual void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
    241249      bool changed = false;
    242250      List<string> childSymbols;
    … …  
    257265    }
    258266
    259     protected void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
     267    public virtual void RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    260268      bool changed = false;
    261269
    … …  
    282290    }
    283291
    284     protected void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
     292    public virtual void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
    285293      var symbols = symbol.Flatten().Where(s => !(s is GroupSymbol));
    286294      if (symbols.Any(s => s.MinimumArity > minimumSubtreeCount)) throw new ArgumentException("Invalid minimum subtree count " + minimumSubtreeCount + " for " + symbol);
    … …  
    308316    }
    309317    public virtual IEnumerable<ISymbol> AllowedSymbols {
    310       get { foreach (var s in Symbols) if (s.Enabled) yield return s; }
     318      get { return Symbols.Where(s => s.Enabled); }
    311319    }
    312320    public virtual bool ContainsSymbol(ISymbol symbol) {
    … …  
    510518      if (suppressEvents) return;
    511519      var handler = Changed;
    512       if (handler != null) Changed(this, EventArgs.Empty);
     520      if (handler != null) handler(this, EventArgs.Empty);
    513521    }
    514522  }

  • branches/GBT/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Grammars/SymbolicExpressionTreeGrammar.cs

    r12012 r12495  
    5555      }
    5656    }
    57     public override IEnumerable<ISymbol> AllowedSymbols {
    58       get { return base.AllowedSymbols; }
    59     }
    6057    public IEnumerable<ISymbol> ModifyableSymbols {
    6158      get { return base.symbols.Values; }
    … …  
    7673    }
    7774
    78     public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
    79       return grammar.IsAllowedChildSymbol(parent, child) || base.IsAllowedChildSymbol(parent, child);
    80     }
    81     public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    82       return grammar.IsAllowedChildSymbol(parent, child, argumentIndex) || base.IsAllowedChildSymbol(parent, child, argumentIndex);
     75    public override void RemoveSymbol(ISymbol symbol) {
     76      if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
     77      base.RemoveSymbol(symbol);
    8378    }
    8479
    … …  
    9186      return base.GetMaximumSubtreeCount(symbol);
    9287    }
    93 
    94     void ISymbolicExpressionTreeGrammar.AddSymbol(ISymbol symbol) {
    95       base.AddSymbol(symbol);
    96     }
    97     void ISymbolicExpressionTreeGrammar.RemoveSymbol(ISymbol symbol) {
    98       if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
    99       base.RemoveSymbol(symbol);
    100     }
    101     void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child) {
    102       base.AddAllowedChildSymbol(parent, child);
    103     }
    104     void ISymbolicExpressionTreeGrammar.AddAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    105       base.AddAllowedChildSymbol(parent, child, argumentIndex);
    106     }
    107     void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child) {
    108       base.RemoveAllowedChildSymbol(parent, child);
    109     }
    110     void ISymbolicExpressionTreeGrammar.RemoveAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
    111       base.RemoveAllowedChildSymbol(parent, child, argumentIndex);
    112     }
    113 
    114     void ISymbolicExpressionTreeGrammar.SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
     88    public override void SetSubtreeCount(ISymbol symbol, int minimumSubtreeCount, int maximumSubtreeCount) {
    11589      if (!IsModifyableSymbol(symbol)) throw new InvalidOperationException();
    11690      base.SetSubtreeCount(symbol, minimumSubtreeCount, maximumSubtreeCount);
    11791    }
    11892
    119     int ISymbolicExpressionGrammarBase.GetMinimumExpressionDepth(ISymbol symbol) {
    120       if (symbols.Count == 0) return grammar.GetMinimumExpressionDepth(symbol);
    121       else return base.GetMinimumExpressionDepth(symbol);
     93    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child) {
     94      return grammar.IsAllowedChildSymbol(parent, child) || base.IsAllowedChildSymbol(parent, child);
    12295    }
    123     int ISymbolicExpressionGrammarBase.GetMaximumExpressionDepth(ISymbol symbol) {
    124       if (symbols.Count == 0) return grammar.GetMaximumExpressionDepth(symbol);
    125       else return base.GetMaximumExpressionDepth(symbol);
     96    public override bool IsAllowedChildSymbol(ISymbol parent, ISymbol child, int argumentIndex) {
     97      return grammar.IsAllowedChildSymbol(parent, child, argumentIndex) || base.IsAllowedChildSymbol(parent, child, argumentIndex);
    12698    }
    127     int ISymbolicExpressionGrammarBase.GetMinimumExpressionLength(ISymbol symbol) {
    128       if (symbols.Count == 0) return grammar.GetMinimumExpressionLength(symbol);
    129       else return base.GetMinimumExpressionLength(symbol);
    130     }
    131     int ISymbolicExpressionGrammarBase.GetMaximumExpressionLength(ISymbol symbol, int maxDepth) {
    132       if (symbols.Count == 0) return grammar.GetMaximumExpressionLength(symbol, maxDepth);
    133       else return base.GetMaximumExpressionLength(symbol, maxDepth);
    134     }
    135 
    13699  }
    137100}
Note: See TracChangeset for help on using the changeset viewer.