Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
06/12/17 14:11:43 (7 years ago)
Author:
pkimmesw
Message:

#2665 Fixed bias 0 issue, PushExpressionFrequencyAnalyzer, Fixed probability for ERC settings, Fixed enable/disable instructions, Added expression descriptions

Location:
branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IEnabledExpressionsConfiguration.cs

    r14905 r15032  
    2020    event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
    2121
    22     IList<string> EnabledExpressions { get; }
     22    IReadOnlyList<string> EnabledExpressions { get; }
    2323
    24     void EnableStack(StackTypes types, bool enableExpressions = true, bool enableDependencies = true);
    25     void DisableStack(StackTypes type, bool disableExpressions = true, bool enableDepenencies = true);
    26     void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true);
     24    void EnableStack(StackTypes types, bool enableDependencies = false);
     25    void DisableStack(StackTypes type, bool enableDepenencies = false);
     26    void SetStack(StackTypes type, bool state, bool setDependencies = false);
    2727    void EnableExpressionOfStack(StackTypes types);
    2828    void DisableExpressionsOfStack(StackTypes types);
    29     void EnableExpression(string name, bool enableStackIfDisabled = false);
    30     void DisableExpression(string name, bool disableStackIfEnabled = false);
    31     void SetExpression(string name, bool state, bool cascadeForStack = false);
    32     void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression;
    33     void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression;
    34     void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression;
     29    void EnableExpression(string name);
     30    void DisableExpression(string name);
     31    void SetExpression(string name, bool state);
     32    void SetExpression<T>(bool state) where T : Expression;
     33    void EnableExpression<T>() where T : Expression;
     34    void DisableExpression<T>() where T : Expression;
    3535  }
    3636}

  • branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/IReadonlyPushConfiguration.cs

    r15017 r15032  
    33  using Base.Erc;
    44  using Common;
     5
     6  using HeuristicLab.Core;
     7
    58  using Stack;
    69
    7   public interface IReadOnlyPushConfiguration : IDeepCloneable {
    8     IReadOnlyDictionary<StackTypes, bool> EnabledStacks { get; }
     10  public interface IReadOnlyPushConfiguration : IItem {
    911    int EvalPushLimit { get; }
    1012    int MaxDepth { get; }
    … …  
    2022    IReadOnlyList<string> EnabledExpressions { get; }
    2123    string FloatStringFormat { get; }
     24
     25    bool IsStackEnabled(StackTypes stackType);
    2226  }
    2327}

  • branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfiguration.cs

    r15017 r15032  
    11namespace HeuristicLab.Problems.ProgramSynthesis.Push.Configuration {
    2   using System;
    32  using System.Collections.Generic;
    4   using System.Linq;
    53  using Base.Erc;
    64  using Common;
    7   using Core;
    8   using Expressions;
    95  using Persistence.Default.CompositeSerializers.Storable;
    10   using Stack;
    116
    127  [StorableClass]
    13   public class PushConfiguration : ParameterizedNamedItem, IReadOnlyPushConfiguration, IEnabledExpressionsConfiguration {
     8  public class PushConfiguration : PushConfigurationBase, IReadOnlyPushConfiguration {
    149    public PushConfiguration() {
    1510      Name = "Push Configuration";
    16 
    17       enabledExpressions = ExpressionTable.ExpressionNames.ToList();
    18       enabledStacks = new Dictionary<StackTypes, bool>();
    1911
    2012      ErcOptions = new ErcOptions();
    … …  
    3123      MaxParenthesesClose = 4;
    3224      ParenthesesCloseBiasLevel = 1;
    33 
    34       InitEnabledStacks();
    3525    }
    3626
    37     private void InitEnabledStacks(bool state = true) {
    38       foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
    39         if (!enabledStacks.ContainsKey(type) && type != StackTypes.None)
    40           enabledStacks.Add(type, state);
    41       }
    42     }
    4327
    4428    [StorableConstructor]
    … …  
    4832
    4933    public PushConfiguration(PushConfiguration origin, Cloner cloner) : base(origin, cloner) {
    50       enabledExpressions = origin.EnabledExpressions.ToList();
    51       enabledStacks = origin.EnabledStacks.ToDictionary(x => x.Key, x => x.Value);
    5234
    5335      ErcOptions = cloner.Clone(origin.ErcOptions);
    … …  
    6648    }
    6749
    68     [StorableHook(HookType.AfterDeserialization)]
    69     // ReSharper disable once UnusedMember.Local
    70     private void AfterDeserialization() {
    71       // Ensures that all types added after last serialization are available in enabledStacks
    72       InitEnabledStacks(false);
    73     }
    74 
    7550    [Storable]
    7651    public string FloatStringFormat { get; set; }
    7752
    78     [Storable]
    79     private readonly Dictionary<StackTypes, bool> enabledStacks;
    8053
    81     public IReadOnlyDictionary<StackTypes, bool> EnabledStacks { get { return enabledStacks; } }
    82 
    83     public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
    84 
    85     [Storable]
    86     private readonly List<string> enabledExpressions;
    87 
    88     public IList<string> EnabledExpressions
    89     {
    90       get { return enabledExpressions; }
    91       set
    92       {
    93         var removedExpressions = enabledExpressions.ToArray();
    94         enabledExpressions.Clear();
    95         enabledExpressions.AddRange(value);
    96 
    97         if (EnabledExpressionsChanged != null) {
    98           EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(value, removedExpressions));
    99         }
    100       }
    101     }
    10254    IReadOnlyList<string> IReadOnlyPushConfiguration.EnabledExpressions { get { return enabledExpressions; } }
    10355
    … …  
    174126    public int MaxVectorLength { get; set; }
    175127
    176 
    177     public void SetEnabledStacks(StackTypes types) {
    178       // Disable all
    179       EnabledExpressions.Clear();
    180 
    181       foreach (StackTypes type in Enum.GetValues(types.GetType())) {
    182         if (type == StackTypes.None) continue;
    183         enabledStacks[type] = false;
    184       }
    185 
    186       foreach (var pair in ExpressionTable.StackDependencyToNamesTable) {
    187         if (types.HasFlag(pair.Key)) {
    188           foreach (var name in pair.Value) {
    189             EnableExpression(name, true);
    190           }
    191         }
    192       }
    193     }
    194 
    195     public void EnableExpressionOfStack(StackTypes types) {
    196       EnableExpressions(ExpressionTable.StackTypeToNamesTable[types]);
    197     }
    198 
    199     public void EnableExpressionDependentOnStack(StackTypes types) {
    200       var names = ExpressionTable.StackDependencyToNamesTable[types].Where(
    201         name => {
    202           var type = ExpressionTable.NameToTypeTable[name];
    203           var attribute = ExpressionTable.TypeToAttributeTable[type];
    204 
    205           return (attribute.StackType | attribute.AdditionalStackDependencies)
    206             .ToEnumerable()
    207             .All(st => enabledStacks.ContainsKey(st) && enabledStacks[st]);
    208         });
    209 
    210       EnableExpressions(names);
    211     }
    212 
    213     private void EnableExpressions(IEnumerable<string> names) {
    214       foreach (var name in names.Except(EnabledExpressions))
    215         EnabledExpressions.Add(name);
    216 
    217       if (EnabledExpressionsChanged != null) {
    218         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(names, new string[0]));
    219       }
    220     }
    221 
    222     public void DisableExpressionsOfStack(StackTypes types) {
    223       DisableExpressions(ExpressionTable.StackTypeToNamesTable[types]);
    224     }
    225 
    226     public void DisableExpressionsDependentOnStack(StackTypes types) {
    227       var names = ExpressionTable.StackDependencyToNamesTable
    228           .Where(pair => pair.Key.HasFlag(types))
    229           .SelectMany(pair => pair.Value);
    230 
    231       DisableExpressions(names);
    232     }
    233 
    234     private void DisableExpressions(IEnumerable<string> names) {
    235       foreach (var name in names.Intersect(EnabledExpressions))
    236         EnabledExpressions.Remove(name);
    237 
    238       if (EnabledExpressionsChanged != null) {
    239         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], names));
    240       }
    241     }
    242 
    243     public void EnableExpression(string name, bool enableStackIfDisabled = false) {
    244       if (EnabledExpressions.Contains(name)) return;
    245 
    246       EnabledExpressions.Add(name);
    247 
    248       if (enableStackIfDisabled) {
    249         var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
    250         var attribute = ExpressionTable.TypeToAttributeTable[type];
    251         enabledStacks[attribute.StackType] = true;
    252       }
    253 
    254       if (EnabledExpressionsChanged != null) {
    255         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
    256           new[] { name },
    257           new string[0]));
    258       }
    259     }
    260 
    261     public void DisableExpression(string name, bool disableStackIfEnabled = false) {
    262       if (!EnabledExpressions.Contains(name)) return;
    263 
    264       EnabledExpressions.Remove(name);
    265 
    266       if (disableStackIfEnabled) {
    267         var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
    268         var attribute = ExpressionTable.TypeToAttributeTable[type];
    269         enabledStacks[attribute.StackType] = false;
    270       }
    271 
    272       if (EnabledExpressionsChanged != null) {
    273         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
    274           new string[0],
    275           new[] { name }));
    276       }
    277     }
    278 
    279     public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
    280       var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
    281       EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
    282     }
    283 
    284     public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
    285       var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
    286       DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
    287     }
    288 
    289     public void SetExpression(string name, bool state, bool cascadeForStack = false) {
    290       if (state) EnableExpression(name, cascadeForStack);
    291       else DisableExpression(name, cascadeForStack);
    292     }
    293 
    294     public void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression {
    295       if (state) EnableExpression<T>(cascadeForStack);
    296       else DisableExpression<T>(cascadeForStack);
    297     }
    298 
    299     public void EnableStack(StackTypes type, bool enableExpressions = true, bool enableDependencies = true) {
    300       enabledStacks[type] = true;
    301 
    302       if (enableExpressions) EnableExpressionOfStack(type);
    303       if (enableDependencies) EnableExpressionDependentOnStack(type);
    304     }
    305 
    306     public void DisableStack(StackTypes type, bool disableExpressions = true, bool disableDependencies = true) {
    307       enabledStacks[type] = false;
    308 
    309       if (disableExpressions) DisableExpressionsOfStack(type);
    310       if (disableDependencies) DisableExpressionsDependentOnStack(type);
    311     }
    312 
    313     public void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true) {
    314       if (state) EnableStack(type, setExpressions, setDependencies);
    315       else DisableStack(type, setExpressions, setDependencies);
    316     }
    317 
    318128    public override IDeepCloneable Clone(Cloner cloner) {
    319129      return new PushConfiguration(this, cloner);

  • branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationBase.cs

    r15017 r15032  
    88  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    99  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
     10  using HeuristicLab.Problems.ProgramSynthesis.Push.Extensions;
    1011  using HeuristicLab.Problems.ProgramSynthesis.Push.Stack;
    1112
    … …  
    1718
    1819      enabledExpressions = ExpressionTable.ExpressionNames.ToList();
    19       enabledStacks = new Dictionary<StackTypes, bool>();
    20 
    21       InitEnabledStacks();
     20      expressionsPerStackCount = new Dictionary<StackTypes, int>();
     21      InitExpressionsPerStackCount();
    2222    }
    2323
    … …  
    2727    protected PushConfigurationBase(PushConfigurationBase origin, Cloner cloner) : base(origin, cloner) {
    2828      enabledExpressions = origin.EnabledExpressions.ToList();
    29       enabledStacks = origin.EnabledStacks.ToDictionary(x => x.Key, x => x.Value);
     29      expressionsPerStackCount = origin.expressionsPerStackCount.ToDictionary(x => x.Key, x => x.Value);
    3030    }
    3131
    3232    [Storable]
    33     private readonly Dictionary<StackTypes, bool> enabledStacks;
    34 
    35     public IReadOnlyDictionary<StackTypes, bool> EnabledStacks { get { return enabledStacks; } }
     33    private readonly Dictionary<StackTypes, int> expressionsPerStackCount;
    3634
    3735    public event EventHandler<EnabledExpressionsChangedEventArgs> EnabledExpressionsChanged;
    … …  
    4038    protected readonly List<string> enabledExpressions;
    4139
    42     public IList<string> EnabledExpressions
     40    public bool IsStackEnabled(StackTypes type) {
     41      int count;
     42      return expressionsPerStackCount.TryGetValue(type, out count) && count > 0;
     43    }
     44
     45    public IReadOnlyList<string> EnabledExpressions
    4346    {
    4447      get { return enabledExpressions; }
    … …  
    5558    }
    5659
    57     private void InitEnabledStacks(bool state = true) {
     60    private void InitExpressionsPerStackCount() {
    5861      foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
    59         if (!enabledStacks.ContainsKey(type) && type != StackTypes.None)
    60           enabledStacks.Add(type, state);
     62        if (type == StackTypes.None) continue;
     63        expressionsPerStackCount.Add(type, 0);
     64      }
     65
     66      foreach (var expressionName in ExpressionTable.ExpressionNames) {
     67        var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == expressionName).Key;
     68        var attribute = ExpressionTable.TypeToAttributeTable[type];
     69
     70        expressionsPerStackCount[attribute.StackType]++;
     71
     72        foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
     73          expressionsPerStackCount[additionalStackType]++;
    6174      }
    6275    }
    … …  
    6477    public void SetEnabledStacks(StackTypes types) {
    6578      // Disable all
    66       EnabledExpressions.Clear();
    67 
    68       foreach (StackTypes type in Enum.GetValues(types.GetType())) {
     79      enabledExpressions.Clear();
     80
     81      foreach (StackTypes type in Enum.GetValues(typeof(StackTypes))) {
    6982        if (type == StackTypes.None) continue;
    70         enabledStacks[type] = false;
    71       }
    72 
    73       foreach (var pair in ExpressionTable.StackDependencyToNamesTable) {
    74         if (types.HasFlag(pair.Key)) {
    75           foreach (var name in pair.Value) {
    76             EnableExpression(name, true);
    77           }
    78         }
    79       }
     83        expressionsPerStackCount[type] = 0;
     84      }
     85
     86      var expressionNames = ExpressionTable.StackDependencyToNamesTable
     87        .Where(pair => types.HasFlag(pair.Key))
     88        .SelectMany(pair => pair.Value);
     89
     90      EnableExpressions(expressionNames);
    8091    }
    8192
    … …  
    92103          return (attribute.StackType | attribute.AdditionalStackDependencies)
    93104            .ToEnumerable()
    94             .All(st => enabledStacks.ContainsKey(st) && enabledStacks[st]);
     105            .All(IsStackEnabled);
    95106        });
    96107
    … …  
    98109    }
    99110
    100     private void EnableExpressions(IEnumerable<string> names) {
    101       foreach (var name in names.Except(EnabledExpressions))
    102         EnabledExpressions.Add(name);
     111    private void EnableExpressions(IEnumerable<string> expressionNames) {
     112      foreach (var expressionName in expressionNames.Except(EnabledExpressions))
     113        EnableExpression(expressionName, false);
    103114
    104115      if (EnabledExpressionsChanged != null) {
    105         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(names, new string[0]));
     116        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(expressionNames, new string[0]));
    106117      }
    107118    }
    … …  
    119130    }
    120131
    121     private void DisableExpressions(IEnumerable<string> names) {
    122       foreach (var name in names.Intersect(EnabledExpressions))
    123         EnabledExpressions.Remove(name);
     132    private void DisableExpressions(IEnumerable<string> expressionNames) {
     133      foreach (var expressionName in expressionNames.Intersect(EnabledExpressions))
     134        DisableExpression(expressionName, false);
    124135
    125136      if (EnabledExpressionsChanged != null) {
    126         EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], names));
    127       }
    128     }
    129 
    130     public void EnableExpression(string name, bool enableStackIfDisabled = false) {
    131       if (EnabledExpressions.Contains(name)) return;
    132 
    133       EnabledExpressions.Add(name);
    134 
    135       if (enableStackIfDisabled) {
    136         var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
    137         var attribute = ExpressionTable.TypeToAttributeTable[type];
    138         enabledStacks[attribute.StackType] = true;
    139       }
    140 
    141       if (EnabledExpressionsChanged != null) {
     137        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(new string[0], expressionNames));
     138      }
     139    }
     140
     141    public void EnableExpression(string expressionName) {
     142      EnableExpression(expressionName, true);
     143    }
     144
     145    private void EnableExpression(string expressionName, bool triggerExpressionChanged) {
     146      if (enabledExpressions.Contains(expressionName)) return;
     147
     148      var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == expressionName).Key;
     149      var attribute = ExpressionTable.TypeToAttributeTable[type];
     150
     151      enabledExpressions.Add(expressionName);
     152      expressionsPerStackCount[attribute.StackType]++;
     153      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
     154        expressionsPerStackCount[additionalStackType]++;
     155
     156      if (EnabledExpressionsChanged != null && triggerExpressionChanged) {
    142157        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
    143           new[] { name },
     158          new[] { expressionName },
    144159          new string[0]));
    145160      }
    146161    }
    147162
    148     public void DisableExpression(string name, bool disableStackIfEnabled = false) {
    149       if (!EnabledExpressions.Contains(name)) return;
    150 
    151       EnabledExpressions.Remove(name);
    152 
    153       if (disableStackIfEnabled) {
    154         var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == name).Key;
    155         var attribute = ExpressionTable.TypeToAttributeTable[type];
    156         enabledStacks[attribute.StackType] = false;
    157       }
    158 
    159       if (EnabledExpressionsChanged != null) {
     163    public void DisableExpression(string expressionName) {
     164      DisableExpression(expressionName, true);
     165    }
     166
     167    public void DisableExpression(string expressionName, bool triggerExpressionChanged) {
     168      if (!EnabledExpressions.Contains(expressionName)) return;
     169
     170      var type = ExpressionTable.TypeToNameTable.Single(x => x.Value == expressionName).Key;
     171      var attribute = ExpressionTable.TypeToAttributeTable[type];
     172
     173      enabledExpressions.Remove(expressionName);
     174      expressionsPerStackCount[attribute.StackType]--;
     175      foreach (var additionalStackType in attribute.AdditionalStackDependencies.ToValues())
     176        expressionsPerStackCount[additionalStackType]--;
     177
     178      if (EnabledExpressionsChanged != null && triggerExpressionChanged) {
    160179        EnabledExpressionsChanged(this, new EnabledExpressionsChangedEventArgs(
    161180          new string[0],
    162           new[] { name }));
    163       }
    164     }
    165 
    166     public void EnableExpression<T>(bool enableStackIfDisabled = false) where T : Expression {
     181          new[] { expressionName }));
     182      }
     183    }
     184
     185    public void EnableExpression<T>() where T : Expression {
    167186      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
    168       EnableExpression(attribute.ExpressionName, enableStackIfDisabled);
    169     }
    170 
    171     public void DisableExpression<T>(bool disableStackIfEnabled = false) where T : Expression {
     187      EnableExpression(attribute.Name);
     188    }
     189
     190    public void DisableExpression<T>() where T : Expression {
    172191      var attribute = ExpressionTable.TypeToAttributeTable[typeof(T)];
    173       DisableExpression(attribute.ExpressionName, disableStackIfEnabled);
    174     }
    175 
    176     public void SetExpression(string name, bool state, bool cascadeForStack = false) {
    177       if (state) EnableExpression(name, cascadeForStack);
    178       else DisableExpression(name, cascadeForStack);
    179     }
    180 
    181     public void SetExpression<T>(bool state, bool cascadeForStack = false) where T : Expression {
    182       if (state) EnableExpression<T>(cascadeForStack);
    183       else DisableExpression<T>(cascadeForStack);
    184     }
    185 
    186     public void EnableStack(StackTypes type, bool enableExpressions = true, bool enableDependencies = true) {
    187       enabledStacks[type] = true;
    188 
    189       if (enableExpressions) EnableExpressionOfStack(type);
    190       if (enableDependencies) EnableExpressionDependentOnStack(type);
    191     }
    192 
    193     public void DisableStack(StackTypes type, bool disableExpressions = true, bool disableDependencies = true) {
    194       enabledStacks[type] = false;
    195 
    196       if (disableExpressions) DisableExpressionsOfStack(type);
    197       if (disableDependencies) DisableExpressionsDependentOnStack(type);
    198     }
    199 
    200     public void SetStack(StackTypes type, bool state, bool setExpressions = true, bool setDependencies = true) {
    201       if (state) EnableStack(type, setExpressions, setDependencies);
    202       else DisableStack(type, setExpressions, setDependencies);
     192      DisableExpression(attribute.Name);
     193    }
     194
     195    public void SetExpression(string name, bool state) {
     196      if (state) EnableExpression(name);
     197      else DisableExpression(name);
     198    }
     199
     200    public void SetExpression<T>(bool state) where T : Expression {
     201      if (state) EnableExpression<T>();
     202      else DisableExpression<T>();
     203    }
     204
     205    public void EnableStack(StackTypes type, bool enableDependencies = false) {
     206      EnableExpressionOfStack(type);
     207
     208      if (enableDependencies)
     209        EnableExpressionDependentOnStack(type);
     210    }
     211
     212    public void DisableStack(StackTypes type, bool disableDependencies = false) {
     213      DisableExpressionsOfStack(type);
     214
     215      if (disableDependencies)
     216        DisableExpressionsDependentOnStack(type);
     217    }
     218
     219    public void SetStack(StackTypes type, bool state, bool setDependencies = false) {
     220      if (state) EnableStack(type, setDependencies);
     221      else DisableStack(type, setDependencies);
    203222    }
    204223  }

  • branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Configuration/PushConfigurationParameterCollection.cs

    r15017 r15032  
    192192
    193193    /// <summary>
    194     /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
     194    /// Determines the likelyhood of smaller or bigger values.
     195    /// x greater than 1 means that result is biased towards min.
     196    /// x smaller than 1 means that result is biased towards max.
    195197    /// </summary>
    196198    public IValueParameter<DoubleValue> ParenthesesCloseBiasLevelParameter
    … …  
    206208
    207209    /// <summary>
    208     /// This is the maximum of depth a push program can have. Expressions, which lead to exceed this limit are interpreted as NOOP.
     210    /// Determines the maximum of blocks which will be closed.
    209211    /// </summary>
    210212    public IValueParameter<IntValue> MaxParenthesesCloseParameter
Note: See TracChangeset for help on using the changeset viewer.