source: branches/HeuristicLab.Problems.GaussianProcessTuning/HeuristicLab.Problems.GaussianProcessTuning/Symbols.cs @ 9562

using System;
using HeuristicLab.Common;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.GaussianProcessTuning {

  #region interfaces
  public interface IDimensionSymbol : ISymbol {
    int Dimension { get; set; }
  }
  #endregion

  [StorableClass]
  public sealed class ConfigurationStartSymbol : Symbol {
    public override int MinimumArity {
      get { return 3; }
    }
    public override int MaximumArity {
      get { return 3; }
    }
    [StorableConstructor]
    private ConfigurationStartSymbol(bool deserializing) : base(deserializing) { }
    private ConfigurationStartSymbol(ConfigurationStartSymbol original, Cloner cloner)
      : base(original, cloner) {
    }

    public ConfigurationStartSymbol()
      : base("GP Configuration", "The start symbol for a GP configuration") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ConfigurationStartSymbol(this, cloner);
    }
  }

  #region mean function terminals
  [StorableClass]
  public sealed class MeanZero : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [StorableConstructor]
    private MeanZero(bool deserializing) : base(deserializing) { }
    private MeanZero(MeanZero original, Cloner cloner)
      : base(original, cloner) {
    }

    public MeanZero()
      : base("MeanZero", "Zero mean function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new EmptyTerminalTreeNode(new MeanZero());
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanZero(this, cloner);
    }
  }

  [StorableClass]
  public sealed class MeanOne : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [StorableConstructor]
    private MeanOne(bool deserializing) : base(deserializing) { }
    private MeanOne(MeanOne original, Cloner cloner)
      : base(original, cloner) {
    }

    public MeanOne()
      : base("MeanOne", "One mean function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new EmptyTerminalTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanOne(this, cloner);
    }
  }

  [StorableClass]
  public sealed class MeanConst : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [StorableConstructor]
    private MeanConst(bool deserializing) : base(deserializing) { }
    private MeanConst(MeanConst original, Cloner cloner)
      : base(original, cloner) {
    }

    public MeanConst()
      : base("MeanConst", "Constant mean function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new MeanConstTreeNode();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanConst(this, cloner);
    }
  }

  [StorableClass]
  public sealed class MeanLinear : Symbol, IDimensionSymbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [Storable]
    public int Dimension { get; set; }

    [StorableConstructor]
    private MeanLinear(bool deserializing) : base(deserializing) { }
    private MeanLinear(MeanLinear original, Cloner cloner)
      : base(original, cloner) {
      Dimension = original.Dimension;
    }

    public MeanLinear(int dimension)
      : base("MeanLinear", "Linear mean function") {
      this.Dimension = dimension;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new MeanLinearTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanLinear(this, cloner);
    }
  }
  #endregion

  #region mean function functions
  [StorableClass]
  public sealed class MeanScale : Symbol {
    public override int MinimumArity {
      get { return 1; }
    }
    public override int MaximumArity {
      get { return 1; }
    }

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

    public MeanScale()
      : base("MeanScale", "Scaled version of a mean function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new MeanScaleTreeNode();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanScale(this, cloner);
    }
  }


  [StorableClass]
  public sealed class MeanPow : Symbol {
    [Storable]
    public int Exponent { get; set; }
    public override int MinimumArity {
      get { return 1; }
    }
    public override int MaximumArity {
      get { return 1; }
    }

    [StorableConstructor]
    private MeanPow(bool deserializing) : base(deserializing) { }
    private MeanPow(MeanPow original, Cloner cloner)
      : base(original, cloner) {
      Exponent = original.Exponent;
    }

    public MeanPow(int exponent = 2)
      : base("MeanPow", "Power of a mean function") {
      Exponent = exponent;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanPow(this, cloner);
    }
  }

  [StorableClass]
  public sealed class MeanProd : Symbol {
    public override int MinimumArity {
      get { return 2; }
    }
    public override int MaximumArity {
      get { return 2; }
    }

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

    public MeanProd()
      : base("MeanProd", "Product of two functions") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanProd(this, cloner);
    }
  }

  [StorableClass]
  public sealed class MeanSum : Symbol {
    public override int MinimumArity {
      get { return 2; }
    }
    public override int MaximumArity {
      get { return 2; }
    }

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

    public MeanSum()
      : base("MeanSum", "Sum of two functions") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanSum(this, cloner);
    }
  }

  [StorableClass]
  public sealed class MeanMask : Symbol, IDimensionSymbol {
    [Storable]
    public double MaskingProbability { get; set; }

    public override int MinimumArity {
      get { return 1; }
    }
    public override int MaximumArity {
      get { return 1; }
    }
    [Storable]
    public int Dimension { get; set; }

    [StorableConstructor]
    private MeanMask(bool deserializing) : base(deserializing) { }
    private MeanMask(MeanMask original, Cloner cloner)
      : base(original, cloner) {
      MaskingProbability = original.MaskingProbability;
      Dimension = original.Dimension;
    }

    public MeanMask(int dimension)
      : base("MeanMask", "Mask some dimensions of the data") {
      this.Dimension = dimension;
      MaskingProbability = 0.2;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new MeanMaskTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanMask(this, cloner);
    }
  }

  #endregion

  #region covariance function terminals
  [StorableClass]
  public sealed class CovConst : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [StorableConstructor]
    private CovConst(bool deserializing) : base(deserializing) { }
    private CovConst(CovConst original, Cloner cloner)
      : base(original, cloner) {
    }

    public CovConst()
      : base("CovConst", "Covariance for constant functions") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovConstTreeNode();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovConst(this, cloner);
    }
  }

  [StorableClass]
  public sealed class CovNoise : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [StorableConstructor]
    private CovNoise(bool deserializing) : base(deserializing) { }
    private CovNoise(CovNoise original, Cloner cloner)
      : base(original, cloner) {
    }

    public CovNoise()
      : base("CovNoise", "Noise covariance function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovNoiseTreeNode();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovNoise(this, cloner);
    }
  }

  [StorableClass]
  public sealed class CovLin : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }
    [StorableConstructor]
    private CovLin(bool deserializing) : base(deserializing) { }
    private CovLin(CovLin original, Cloner cloner)
      : base(original, cloner) {
    }

    public CovLin()
      : base("CovLin", "linear covariance function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new EmptyTerminalTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovLin(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovLinArd : Symbol, IDimensionSymbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

    [Storable]
    public int Dimension { get; set; }

    [StorableConstructor]
    private CovLinArd(bool deserializing) : base(deserializing) { }
    private CovLinArd(CovLinArd original, Cloner cloner)
      : base(original, cloner) {
      Dimension = original.Dimension;
    }

    public CovLinArd(int dimension)
      : base("CovLinArd", "linear covariance function with ARD") {
      this.Dimension = dimension;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovLinArdTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovLinArd(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovSeArd : Symbol, IDimensionSymbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

    [Storable]
    public int Dimension { get; set; }

    [StorableConstructor]
    private CovSeArd(bool deserializing) : base(deserializing) { }
    private CovSeArd(CovSeArd original, Cloner cloner)
      : base(original, cloner) {
      Dimension = original.Dimension;
    }

    public CovSeArd(int dimension)
      : base("CovSeArd", "full squared exponential covariance function with ARD") {
      this.Dimension = dimension;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovSeArdTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSeArd(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovSeIso : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

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

    public CovSeIso()
      : base("CovSeIso", "diagonal squared exponential covariance function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovSeIsoTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSeIso(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovPoly : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

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

    public CovPoly()
      : base("CovPoly", "") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovPolyTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovPoly(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovPiecewisePoly : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

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

    public CovPiecewisePoly()
      : base("CovPiecewisePoly", "") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovPiecewisePolyTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovPiecewisePoly(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovNn : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

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

    public CovNn()
      : base("CovNn", "neural network covariance function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovNnTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovNn(this, cloner);
    }
  }

  [StorableClass]
  public sealed class CovMatern : Symbol {
    [Storable]
    public int D { get; set; }

    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

    [StorableConstructor]
    private CovMatern(bool deserializing) : base(deserializing) { }
    private CovMatern(CovMatern original, Cloner cloner)
      : base(original, cloner) {
      D = original.D;
    }

    public CovMatern(int d)
      : base("CovMatern", "Matern covariance function") {
      this.D = d;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovMaternTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovMatern(this, cloner);
    }
  }

  [StorableClass]
  public sealed class CovPeriodic : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

    [Storable]
    private double? period;
    public double? Period {
      get { return period; }
    }


    [StorableConstructor]
    private CovPeriodic(bool deserializing) : base(deserializing) { }
    private CovPeriodic(CovPeriodic original, Cloner cloner)
      : base(original, cloner) {
      period = original.period;
    }

    public CovPeriodic(double? period = null)
      : base("CovPeriodic", "Periodic covariance function") {
      this.period = period;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovPeriodicTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovPeriodic(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovRQArd : Symbol, IDimensionSymbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

    [Storable]
    public int Dimension { get; set; }

    [StorableConstructor]
    private CovRQArd(bool deserializing) : base(deserializing) { }
    private CovRQArd(CovRQArd original, Cloner cloner)
      : base(original, cloner) {
      Dimension = original.Dimension;
    }

    public CovRQArd(int dimension)
      : base("CovRQArd", "full rational quadratic covariance function with ARD") {
      this.Dimension = dimension;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovRQArdTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovRQArd(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovRQIso : Symbol {
    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

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

    public CovRQIso()
      : base("CovRQIso", "Rational quadratic covariance function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovRQisoTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovRQIso(this, cloner);
    }
  }
  #endregion

  #region covariance function functions
  [StorableClass]
  public sealed class CovSum : Symbol {
    public override int MinimumArity {
      get { return 3; }
    }
    public override int MaximumArity {
      get { return 3; }
    }

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

    public CovSum()
      : base("CovSum", "Sum of two covariance functions") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSum(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovProd : Symbol {
    public override int MinimumArity {
      get { return 3; }
    }
    public override int MaximumArity {
      get { return 3; }
    }

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

    public CovProd()
      : base("CovProd", "Product of two covariance functions") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovProd(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovScale : Symbol {

    public override int MinimumArity {
      get { return 1; }
    }
    public override int MaximumArity {
      get { return 1; }
    }

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

    public CovScale()
      : base("CovScale", "Scale a covariance function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovScaleTreeNode(this);
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovScale(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovMask : Symbol, IDimensionSymbol {
    [Storable]
    public double MaskingProbability { get; set; }

    public override int MinimumArity {
      get { return 1; }
    }
    public override int MaximumArity {
      get { return 1; }
    }
    [Storable]
    public int Dimension { get; set; }

    [StorableConstructor]
    private CovMask(bool deserializing) : base(deserializing) { }
    private CovMask(CovMask original, Cloner cloner)
      : base(original, cloner) {
      this.Dimension = original.Dimension;
      this.MaskingProbability = original.MaskingProbability;
    }

    public CovMask(int dimension)
      : base("CovMask", "Mask some dimensions of the data") {
      this.Dimension = dimension;
      MaskingProbability = 0.2;
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new CovMaskTreeNode(this);
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovMask(this, cloner);
    }
  }
  #endregion

  #region likelihood functions
  [StorableClass]
  public sealed class LikGauss : Symbol {

    public override int MinimumArity {
      get { return 0; }
    }
    public override int MaximumArity {
      get { return 0; }
    }

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

    public LikGauss()
      : base("LikGauss", "Gaussian likelihood function") {
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }

    public override ISymbolicExpressionTreeNode CreateTreeNode() {
      return new LikGaussTreeNode(this);
    }

    public override IDeepCloneable Clone(Cloner cloner) {
      return new LikGauss(this, cloner);
    }
  }
  #endregion
}