source: branches/HeuristicLab.Problems.GaussianProcessTuning/HeuristicLab.Problems.GaussianProcessTuning/Grammar.cs @ 9212

using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.GaussianProcessTuning {
  [StorableClass]
  [Item("Gaussian Process Configuration Grammar", "The grammar for the Gaussian process configration problem.")]
  public sealed class Grammar : SymbolicExpressionGrammar {
    [Storable]
    private int dimension;
    public int Dimension {
      get { return dimension; }
      set {
        if (dimension != value) {
          dimension = value;
          UpdateSymbolDimension();
        }
      }
    }

    [StorableConstructor]
    private Grammar(bool deserializing) : base(deserializing) { }
    private Grammar(Grammar original, Cloner cloner)
      : base(original, cloner) {
    }

    public Grammar()
      : base("Gaussian Process Configuration Grammar", "The grammar for the Gaussian process configuration problem.") {
      Dimension = 10;
      Initialize();
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new Grammar(this, cloner);
    }
    private void Initialize() {
      // create all symbols
      //var meanOne = new MeanOne();
      var meanConst = new MeanConst();
      var meanLinear = new MeanLinear(Dimension);
      //var meanScale = new MeanScale();
      var meanSum = new MeanSum();
      var meanProd = new MeanProd();
      //var meanPow2 = new MeanPow(2) { Name = "MeanPow2" };
      //var meanPow3 = new MeanPow(3) { Name = "MeanPow3" };
      //var meanMask = new MeanMask(Dimension);
      var covConst = new CovConst();
      var covLin = new CovLin();
      var covLinArd = new CovLinArd(Dimension);
      var covSeArd = new CovSeArd(Dimension);
      var covSeIso = new CovSeIso();
      var covRQard = new CovRQArd(Dimension);
      var covRQiso = new CovRQIso();
      var covMatern1 = new CovMatern(1);
      covMatern1.Name = "CovMatern1";
      var covMatern3 = new CovMatern(3);
      covMatern3.Name = "CovMatern3";
      var covMatern5 = new CovMatern(5);
      covMatern5.Name = "CovMatern5";
      var covPeriodic = new CovPeriodic();
      var covPeriodic1 = new CovPeriodic(1.0);
      covPeriodic1.Name = "CovPeriodic(1.0)";
      var covPeriodicCO = new CovPeriodic(0.021817864467425927);
      covPeriodicCO.Name = "CovPeriodicCO";
      var covNoise = new CovNoise();
      var covScale = new CovScale();
      var covSum = new CovSum();
      var covProd = new CovProd();
      var covMask = new CovMask(Dimension);
      var likGauss = new LikGauss();

      var configurationStartSymbol = new ConfigurationStartSymbol();

      var meanSymbols = new List<ISymbol>()
                         {
                            meanConst, 
                            meanLinear,
                            meanSum,  
                            meanProd, 
                            //meanPow2, 
                            //meanPow3, 
                            //meanMask, 
                         };
      var covSymbols = new List<ISymbol>()
                         {
                            covConst, 
                            covLin, 
                            covLinArd, 
                            covSeArd, 
                            covSeIso, 
                            covRQiso,
                            covRQard,
                            covMatern1,
                            covMatern3,
                            covMatern5,
                            covPeriodic,
                            covPeriodic1,
                            covPeriodicCO,
                            covNoise,
                            covScale, 
                            covSum,
                            covProd,  
                            covMask, 
                         };
      var likSymbols = new List<ISymbol>()
                         {
                           likGauss
                         };
      var allSymbols = covSymbols.Concat(meanSymbols).Concat(likSymbols);

      AddSymbol(configurationStartSymbol);
      // add all symbols to the grammar
      foreach (var s in allSymbols)
        AddSymbol(s);

      AddAllowedChildSymbol(StartSymbol, configurationStartSymbol, 0);

      foreach (var meanSymbol in meanSymbols) {
        AddAllowedChildSymbol(configurationStartSymbol, meanSymbol, 0);
      }
      foreach (var covSymbol in covSymbols) {
        AddAllowedChildSymbol(configurationStartSymbol, covSymbol, 1);
      }
      foreach (var likSymbol in likSymbols) {
        AddAllowedChildSymbol(configurationStartSymbol, likSymbol, 2);
      }
      foreach (var meanFunctionSymbol in new ISymbol[] { meanSum, meanProd }) {
        foreach (var meanSymbol in meanSymbols) {
          for (int i = 0; i < meanFunctionSymbol.MaximumArity; i++) {
            AddAllowedChildSymbol(meanFunctionSymbol, meanSymbol, i);
          }
        }
      }

      foreach (var covFunctionSymbol in new ISymbol[] { covSum, covProd, covScale }) {
        foreach (var covSymbol in covSymbols) {
          for (int i = 0; i < covFunctionSymbol.MaximumArity; i++) {
            AddAllowedChildSymbol(covFunctionSymbol, covSymbol, i);
          }
        }
      }

      // mask
      foreach (var covSymbol in new List<ISymbol>()
                         {
                            covConst, 
                            covLin, 
                            covLinArd, 
                            covSeArd, 
                            covSeIso, 
                            covRQiso,
                            covRQard,
                            covMatern1,
                            covMatern3,
                            covMatern5,
                            covPeriodic,
                            covPeriodic1,
                            covPeriodicCO,
                         }) {
        for (int i = 0; i < covMask.MaximumArity; i++) {
          AddAllowedChildSymbol(covMask, covSymbol, i);
        }
      }

    }

    private void UpdateSymbolDimension() {
      foreach (var s in Symbols.OfType<IDimensionSymbol>()) {
        s.Dimension = dimension;
      }
    }
  }
}