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:
4 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/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  }
Note: See TracChangeset for help on using the changeset viewer.