Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
09/20/11 11:12:10 (13 years ago)
Author:
mkommend
Message:

#1479: Merged grammar editor branch into trunk.

Location:
trunk/sources
Files:
33 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic

    • Property svn:ignore set to
      bin

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/SymbolicDataAnalysisAlleleFrequencyAnalyzer.cs

    r6728 r6803  
    8585      StringBuilder builder = new StringBuilder();
    8686      builder.Append("(" + tree.ToString());
    87       for (int i = 0; i < tree.SubtreesCount; i++) {
     87      for (int i = 0; i < tree.SubtreeCount; i++) {
    8888        builder.Append(" " + GetTextualRepresentationFromSubtreeOfDepth(tree.GetSubtree(i), d - 1));
    8989      }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

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

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

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

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/ArithmeticExpressionGrammar.cs

    r5809 r6803  
    2525using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2626using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
     27using HeuristicLab.PluginInfrastructure;
    2728
    2829namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
     30  [NonDiscoverableType]
    2931  [StorableClass]
    3032  [Item("ArithmeticExpressionGrammar", "Represents a grammar for functional expressions using only arithmetic operations.")]

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/TypeCoherentExpressionGrammar.cs

    r5809 r6803  
    3030  [Item("TypeCoherentExpressionGrammar", "Represents a grammar for functional expressions in which special syntactic constraints are enforced so that boolean and real-valued expressions are not mixed.")]
    3131  public class TypeCoherentExpressionGrammar : SymbolicExpressionGrammar, ISymbolicDataAnalysisGrammar {
     32    private const string ArithmeticFunctionsName = "Arithmetic Functions";
     33    private const string TrigonometricFunctionsName = "Trigonometric Functions";
     34    private const string ExponentialFunctionsName = "Exponential and Logarithmic Functions";
     35    private const string RealValuedSymbolsName = "Real Valued Symbols";
     36    private const string TerminalsName = "Terminals";
     37    private const string PowerFunctionsName = "Power Functions";
     38    private const string ConditionsName = "Conditions";
     39    private const string ComparisonsName = "Comparisons";
     40    private const string BooleanOperatorsName = "Boolean Operators";
     41    private const string ConditionalSymbolsName = "ConditionalSymbols";
     42    private const string TimeSeriesSymbolsName = "Time Series Symbols";
    3243
    3344    [StorableConstructor]
    … …  
    4354
    4455    private void Initialize() {
     56      #region symbol declaration
    4557      var add = new Addition();
    4658      var sub = new Subtraction();
    … …  
    5365      var log = new Logarithm();
    5466      var pow = new Power();
    55       pow.InitialFrequency = 0.0;
    5667      var root = new Root();
    57       root.InitialFrequency = 0.0;
    5868      var exp = new Exponential();
    5969      var @if = new IfThenElse();
    … …  
    6373      var or = new Or();
    6474      var not = new Not();
     75      var variableCondition = new VariableCondition();
    6576
    6677      var timeLag = new TimeLag();
    67       timeLag.InitialFrequency = 0.0;
    6878      var integral = new Integral();
    69       integral.InitialFrequency = 0.0;
    7079      var derivative = new Derivative();
    71       derivative.InitialFrequency = 0.0;
    72       var variableCondition = new VariableCondition();
    73       variableCondition.InitialFrequency = 0.0;
    7480
    7581      var constant = new Constant();
    7682      constant.MinValue = -20;
    7783      constant.MaxValue = 20;
    78       var variableSymbol = new HeuristicLab.Problems.DataAnalysis.Symbolic.Variable();
     84      var variableSymbol = new Variable();
    7985      var laggedVariable = new LaggedVariable();
     86      #endregion
    8087
    81       laggedVariable.InitialFrequency = 0.0;
    82       mean.InitialFrequency = 0.0;
     88      #region group symbol declaration
     89      var arithmeticSymbols = new GroupSymbol(ArithmeticFunctionsName, new List<ISymbol>() { add, sub, mul, div, mean });
     90      var trigonometricSymbols = new GroupSymbol(TrigonometricFunctionsName, new List<ISymbol>() { sin, cos, tan });
     91      var exponentialAndLogarithmicSymbols = new GroupSymbol(ExponentialFunctionsName, new List<ISymbol> { exp, log });
     92      var terminalSymbols = new GroupSymbol(TerminalsName, new List<ISymbol> { constant, variableSymbol });
     93      var realValuedSymbols = new GroupSymbol(RealValuedSymbolsName, new List<ISymbol>() { arithmeticSymbols, trigonometricSymbols, exponentialAndLogarithmicSymbols, terminalSymbols });
    8394
    84       /*
    85        * Start = RealValueExpression
    86        *
    87        * RealValueExpression =
    88        *   "Variable"  |
    89        *   "Constant" |
    90        *   BinaryOperator RealValueExpression RealValueExpression |
    91        *   UnaryOperator RealValueExpression |
    92        *   "IF" BooleanExpression RealValueExpression RealValueExpression |
    93        *   "VariableCondition" RealValueExpression RealValueExpression
    94        *
    95        * BinaryOperator =
    96        *   "+" | "-" | "*" | "/" | "Power"
    97        *
    98        * UnaryOperator =
    99        *   "Sin" | "Cos" | "Tan" | "Log" | "Exp"
    100        *
    101        * BooleanExpression =
    102        *   "AND" BooleanExpression BooleanExpression |
    103        *   "OR" BooleanExpression BooleanExpression |
    104        *   "NOT" BooleanExpression |
    105        *   ">" RealValueExpression RealValueExpression |
    106        *   "<" RealValueExpression RealValueExpression
    107        */
     95      var powerSymbols = new GroupSymbol(PowerFunctionsName, new List<ISymbol> { pow, root });
    10896
    109       var allSymbols = new List<Symbol>() { add, sub, mul, div, mean, sin, cos, tan, log, pow, root, exp, @if, gt, lt, and, or, not, timeLag, integral, derivative, constant, variableSymbol, laggedVariable, variableCondition };
     97      var conditionSymbols = new GroupSymbol(ConditionsName, new List<ISymbol> { @if, variableCondition });
     98      var comparisonSymbols = new GroupSymbol(ComparisonsName, new List<ISymbol> { gt, lt });
     99      var booleanOperationSymbols = new GroupSymbol(BooleanOperatorsName, new List<ISymbol> { and, or, not });
     100      var conditionalSymbols = new GroupSymbol(ConditionalSymbolsName, new List<ISymbol> { conditionSymbols, comparisonSymbols, booleanOperationSymbols });
    110101
    111       var unaryFunctionSymbols = new List<Symbol>() { sin, cos, tan, log, exp, timeLag, integral, derivative };
    112       var binaryFunctionSymbols = new List<Symbol>() { add, sub, mul, div, mean, pow, root, variableCondition };
     102      var timeSeriesSymbols = new GroupSymbol(TimeSeriesSymbolsName, new List<ISymbol> { timeLag, integral, derivative, laggedVariable });
     103      #endregion
    113104
    114       var unaryBooleanFunctionSymbols = new List<Symbol>() { not };
    115       var binaryBooleanFunctionSymbols = new List<Symbol>() { or, and };
    116       var relationalFunctionSymbols = new List<Symbol>() { gt, lt };
    117       var terminalSymbols = new List<Symbol>() { variableSymbol, constant, laggedVariable };
    118       var realValuedSymbols = unaryFunctionSymbols.Concat(binaryFunctionSymbols).Concat(terminalSymbols).Concat(new List<Symbol>() { @if });
    119       var booleanSymbols = unaryBooleanFunctionSymbols.Concat(binaryBooleanFunctionSymbols).Concat(relationalFunctionSymbols);
     105      AddSymbol(realValuedSymbols);
     106      AddSymbol(powerSymbols);
     107      AddSymbol(conditionalSymbols);
     108      AddSymbol(timeSeriesSymbols);
    120109
    121       foreach (var symb in allSymbols)
    122         AddSymbol(symb);
    123 
    124       foreach (var unaryFun in unaryFunctionSymbols.Concat(unaryBooleanFunctionSymbols)) {
    125         SetSubtreeCount(unaryFun, 1, 1);
    126       }
    127       foreach (var binaryFun in binaryFunctionSymbols.Concat(binaryBooleanFunctionSymbols).Concat(relationalFunctionSymbols)) {
    128         SetSubtreeCount(binaryFun, 2, 2);
    129       }
    130 
    131       foreach (var terminalSymbol in terminalSymbols) {
    132         SetSubtreeCount(terminalSymbol, 0, 0);
    133       }
     110      #region subtree count configuration
     111      SetSubtreeCount(arithmeticSymbols, 2, 2);
     112      SetSubtreeCount(trigonometricSymbols, 1, 1);
     113      SetSubtreeCount(powerSymbols, 2, 2);
     114      SetSubtreeCount(exponentialAndLogarithmicSymbols, 1, 1);
     115      SetSubtreeCount(terminalSymbols, 0, 0);
    134116
    135117      SetSubtreeCount(@if, 3, 3);
     118      SetSubtreeCount(variableCondition, 2, 2);
     119      SetSubtreeCount(comparisonSymbols, 2, 2);
     120      SetSubtreeCount(and, 2, 2);
     121      SetSubtreeCount(or, 2, 2);
     122      SetSubtreeCount(not, 1, 1);
     123
     124      SetSubtreeCount(timeLag, 1, 1);
     125      SetSubtreeCount(integral, 1, 1);
     126      SetSubtreeCount(derivative, 1, 1);
     127      SetSubtreeCount(laggedVariable, 0, 0);
     128      #endregion
     129
     130      #region alloed child symbols configuration
     131      AddAllowedChildSymbol(StartSymbol, realValuedSymbols);
     132      AddAllowedChildSymbol(DefunSymbol, realValuedSymbols);
     133
     134      AddAllowedChildSymbol(realValuedSymbols, realValuedSymbols);
     135      AddAllowedChildSymbol(realValuedSymbols, powerSymbols);
     136      AddAllowedChildSymbol(realValuedSymbols, conditionSymbols);
     137      AddAllowedChildSymbol(realValuedSymbols, timeSeriesSymbols);
     138
     139      AddAllowedChildSymbol(powerSymbols, variableSymbol, 0);
     140      AddAllowedChildSymbol(powerSymbols, constant, 1);
     141
     142      AddAllowedChildSymbol(@if, comparisonSymbols, 0);
     143      AddAllowedChildSymbol(@if, booleanOperationSymbols, 0);
     144      AddAllowedChildSymbol(@if, conditionSymbols, 1);
     145      AddAllowedChildSymbol(@if, realValuedSymbols, 1);
     146      AddAllowedChildSymbol(@if, powerSymbols, 1);
     147      AddAllowedChildSymbol(@if, timeSeriesSymbols, 1);
     148      AddAllowedChildSymbol(@if, conditionSymbols, 2);
     149      AddAllowedChildSymbol(@if, realValuedSymbols, 2);
     150      AddAllowedChildSymbol(@if, powerSymbols, 2);
     151      AddAllowedChildSymbol(@if, timeSeriesSymbols, 2);
     152
     153      AddAllowedChildSymbol(booleanOperationSymbols, comparisonSymbols);
     154      AddAllowedChildSymbol(comparisonSymbols, realValuedSymbols);
     155      AddAllowedChildSymbol(comparisonSymbols, powerSymbols);
     156      AddAllowedChildSymbol(comparisonSymbols, conditionSymbols);
     157      AddAllowedChildSymbol(comparisonSymbols, timeSeriesSymbols);
     158
     159      AddAllowedChildSymbol(variableCondition, realValuedSymbols);
     160      AddAllowedChildSymbol(variableCondition, powerSymbols);
     161      AddAllowedChildSymbol(variableCondition, conditionSymbols);
     162      AddAllowedChildSymbol(variableCondition, timeSeriesSymbols);
    136163
    137164
    138       // allow only real-valued expressions as child of the start symbol
    139       foreach (var symb in realValuedSymbols) {
    140         AddAllowedChildSymbol(StartSymbol, symb);
    141         AddAllowedChildSymbol(DefunSymbol, symb);
    142       }
     165      AddAllowedChildSymbol(timeLag, realValuedSymbols);
     166      AddAllowedChildSymbol(timeLag, powerSymbols);
     167      AddAllowedChildSymbol(timeLag, conditionSymbols);
    143168
    144       foreach (var symb in unaryFunctionSymbols) {
    145         foreach (var childSymb in realValuedSymbols) {
    146           AddAllowedChildSymbol(symb, childSymb);
    147         }
    148       }
     169      AddAllowedChildSymbol(integral, realValuedSymbols);
     170      AddAllowedChildSymbol(integral, powerSymbols);
     171      AddAllowedChildSymbol(integral, conditionSymbols);
    149172
    150       foreach (var symb in binaryFunctionSymbols) {
    151         foreach (var childSymb in realValuedSymbols) {
    152           AddAllowedChildSymbol(symb, childSymb);
    153         }
    154       }
     173      AddAllowedChildSymbol(derivative, realValuedSymbols);
     174      AddAllowedChildSymbol(derivative, powerSymbols);
     175      AddAllowedChildSymbol(derivative, conditionSymbols);
     176      #endregion
     177    }
    155178
    156       foreach (var childSymb in booleanSymbols) {
    157         AddAllowedChildSymbol(@if, childSymb, 0);
    158       }
    159       foreach (var childSymb in realValuedSymbols) {
    160         AddAllowedChildSymbol(@if, childSymb, 1);
    161         AddAllowedChildSymbol(@if, childSymb, 2);
    162       }
     179    public void ConfigureAsDefaultRegressionGrammar() {
     180      Symbols.Where(s => s is Average).First().Enabled = false;
     181      Symbols.Where(s => s.Name == TrigonometricFunctionsName).First().Enabled = false;
     182      Symbols.Where(s => s.Name == PowerFunctionsName).First().Enabled = false;
     183      Symbols.Where(s => s.Name == ConditionalSymbolsName).First().Enabled = false;
     184      Symbols.Where(s => s.Name == TimeSeriesSymbolsName).First().Enabled = false;
     185    }
    163186
    164       foreach (var symb in relationalFunctionSymbols) {
    165         foreach (var childSymb in realValuedSymbols) {
    166           AddAllowedChildSymbol(symb, childSymb);
    167         }
    168       }
    169       foreach (var symb in binaryBooleanFunctionSymbols) {
    170         foreach (var childSymb in booleanSymbols) {
    171           AddAllowedChildSymbol(symb, childSymb);
    172         }
    173       }
    174       foreach (var symb in unaryBooleanFunctionSymbols) {
    175         foreach (var childSymb in booleanSymbols) {
    176           AddAllowedChildSymbol(symb, childSymb);
    177         }
    178       }
     187    public void ConfigureAsDefaultClassificationGrammar() {
     188      Symbols.Where(s => s is Average).First().Enabled = false;
     189      Symbols.Where(s => s.Name == TrigonometricFunctionsName).First().Enabled = false;
     190      Symbols.Where(s => s.Name == ExponentialFunctionsName).First().Enabled = false;
     191      Symbols.Where(s => s.Name == PowerFunctionsName).First().Enabled = false;
     192      Symbols.Where(s => s.Name == TimeSeriesSymbolsName).First().Enabled = false;
    179193    }
    180194  }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisExpressionTreeSimplifier.cs

    r6774 r6803  
    6464    private ISymbolicExpressionTreeNode MacroExpand(ISymbolicExpressionTreeNode root, ISymbolicExpressionTreeNode node, IList<ISymbolicExpressionTreeNode> argumentTrees) {
    6565      List<ISymbolicExpressionTreeNode> subtrees = new List<ISymbolicExpressionTreeNode>(node.Subtrees);
    66       while (node.SubtreesCount > 0) node.RemoveSubtree(0);
     66      while (node.SubtreeCount > 0) node.RemoveSubtree(0);
    6767      if (node.Symbol is InvokeFunction) {
    6868        var invokeSym = node.Symbol as InvokeFunction;
    … …  
    893893        // x0 * x1 * .. * xn * -1 => x0 * x1 * .. * -xn
    894894        var lastSubTree = x.Subtrees.Last();
    895         x.RemoveSubtree(x.SubtreesCount - 1);
     895        x.RemoveSubtree(x.SubtreeCount - 1);
    896896        x.AddSubtree(Negate(lastSubTree)); // last is maybe a constant, prefer to negate the constant
    897897      } else {

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisProblem.cs

    r6533 r6803  
    190190      SymbolicExpressionTreeGrammar.MaximumFunctionDefinitions = MaximumFunctionDefinitions.Value;
    191191      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.Variable>()) {
    192         varSymbol.VariableNames = ProblemData.AllowedInputVariables;
     192        if (!varSymbol.Fixed) varSymbol.VariableNames = ProblemData.AllowedInputVariables;
    193193      }
    194194      foreach (var varSymbol in SymbolicExpressionTreeGrammar.Symbols.OfType<HeuristicLab.Problems.DataAnalysis.Symbolic.VariableCondition>()) {
    195         varSymbol.VariableNames = ProblemData.AllowedInputVariables;
     195        if (!varSymbol.Fixed) varSymbol.VariableNames = ProblemData.AllowedInputVariables;
    196196      }
    197197    }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Addition.cs

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

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/And.cs

    r5809 r6803  
    2828  [Item("And", "Symbol that represents the boolean AND operator.")]
    2929  public sealed class And : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private And(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Average.cs

    r5809 r6803  
    2828  [Item("Average", "Symbol that represents the average (arithmetic mean) function.")]
    2929  public sealed class Average : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Average(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Constant.cs

    r5809 r6803  
    8888    }
    8989
     90    private const int minimumArity = 0;
     91    private const int maximumArity = 0;
     92
     93    public override int MinimumArity {
     94      get { return minimumArity; }
     95    }
     96    public override int MaximumArity {
     97      get { return maximumArity; }
     98    }
    9099    #endregion
     100
    91101    [StorableConstructor]
    92102    private Constant(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Cosine.cs

    r5809 r6803  
    2828  [Item("Cosine", "Symbol that represents the cosine function.")]
    2929  public sealed class Cosine : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Cosine(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Derivative.cs

    r5809 r6803  
    2828  [Item("Derivative", "Represents the derivative over the specified subtree.")]
    2929  public sealed class Derivative : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Derivative(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Division.cs

    r5809 r6803  
    2828  [Item("Division", "Symbol that represents the / operator.")]
    2929  public sealed class Division : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Division(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Exponential.cs

    r5809 r6803  
    2828  [Item("Exponential", "Symbol that represents the exponential function.")]
    2929  public sealed class Exponential : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Exponential(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/GreaterThan.cs

    r5809 r6803  
    2828  [Item("GreaterThan", "Symbol that represents a greater than relation.")]
    2929  public sealed class GreaterThan : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private GreaterThan(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/IfThenElse.cs

    r5809 r6803  
    2828  [Item("IfThenElse", "Symbol that represents a conditional operator.")]
    2929  public sealed class IfThenElse : Symbol {
     30    private const int minimumArity = 3;
     31    private const int maximumArity = 3;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private IfThenElse(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Integral.cs

    r5809 r6803  
    2727  [Item("Integral", "Represents the integral over the specified subtree.")]
    2828  public sealed class Integral : LaggedSymbol {
     29    private const int minimumArity = 1;
     30    private const int maximumArity = 1;
     31
     32    public override int MinimumArity {
     33      get { return minimumArity; }
     34    }
     35    public override int MaximumArity {
     36      get { return maximumArity; }
     37    }
     38
    2939    [StorableConstructor]
    3040    private Integral(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/LessThan.cs

    r5809 r6803  
    2828  [Item("LessThan", "Symbol that represents a less than relation.")]
    2929  public sealed class LessThan : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private LessThan(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Logarithm.cs

    r5809 r6803  
    2828  [Item("Logarithm", "Symbol that represents the logarithm function.")]
    2929  public sealed class Logarithm : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Logarithm(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Multiplication.cs

    r5809 r6803  
    2828  [Item("Multiplication", "Symbol that represents the * operator.")]
    2929  public sealed class Multiplication : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Multiplication(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Not.cs

    r5809 r6803  
    2828  [Item("Not", "Symbol that represents the boolean NOT operator.")]
    2929  public sealed class Not : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Not(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Or.cs

    r5809 r6803  
    2828  [Item("Or", "Symbol that represents the boolean OR operator.")]
    2929  public sealed class Or : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Or(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Power.cs

    r5809 r6803  
    2828  [Item("Power", "Symbol that represents the power function.")]
    2929  public sealed class Power : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Power(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Root.cs

    r5809 r6803  
    2828  [Item("Root", "Symbol that represents the n-th root function.")]
    2929  public sealed class Root : Symbol {
     30    private const int minimumArity = 2;
     31    private const int maximumArity = 2;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Root(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Sine.cs

    r5809 r6803  
    2828  [Item("Sine", "Symbol that represents the sine function.")]
    2929  public sealed class Sine : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Sine(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Subtraction.cs

    r5809 r6803  
    2828  [Item("Subtraction", "Symbol that represents the - operator.")]
    2929  public sealed class Subtraction : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = byte.MaxValue;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Subtraction(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Tangent.cs

    r5809 r6803  
    2828  [Item("Tangent", "Symbol that represents the tangent trigonometric function.")]
    2929  public sealed class Tangent : Symbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private Tangent(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/TimeLag.cs

    r5809 r6803  
    2828  [Item("TimeLag", "Represents a symblol whose evaluation is shifted.")]
    2929  public sealed class TimeLag : LaggedSymbol {
     30    private const int minimumArity = 1;
     31    private const int maximumArity = 1;
     32
     33    public override int MinimumArity {
     34      get { return minimumArity; }
     35    }
     36    public override int MaximumArity {
     37      get { return maximumArity; }
     38    }
     39
    3040    [StorableConstructor]
    3141    private TimeLag(bool deserializing) : base(deserializing) { }

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/Variable.cs

    r5809 r6803  
    100100      }
    101101    }
     102
     103    private const int minimumArity = 0;
     104    private const int maximumArity = 0;
     105
     106    public override int MinimumArity {
     107      get { return minimumArity; }
     108    }
     109    public override int MaximumArity {
     110      get { return maximumArity; }
     111    }
    102112    #endregion
     113
    103114    [StorableConstructor]
    104115    protected Variable(bool deserializing)
    … …  
    126137    }
    127138
     139    protected override void OnChanged(EventArgs e) {
     140      if (@Fixed) {
     141        weightManipulatorMu = 1;
     142        weightManipulatorSigma = 0;
     143        weightMu = 1;
     144        weightSigma = 0;
     145        multiplicativeWeightManipulatorSigma = 0;
     146      }
     147      base.OnChanged(e);
     148    }
     149
    128150    public override ISymbolicExpressionTreeNode CreateTreeNode() {
    129151      return new VariableTreeNode(this);

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/VariableCondition.cs

    r5809 r6803  
    138138      }
    139139    }
     140
     141    private const int minimumArity = 2;
     142    private const int maximumArity = 2;
     143
     144    public override int MinimumArity {
     145      get { return minimumArity; }
     146    }
     147    public override int MaximumArity {
     148      get { return maximumArity; }
     149    }
    140150    #endregion
    141151
Note: See TracChangeset for help on using the changeset viewer.