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

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

namespace HeuristicLab.Problems.GaussianProcessTuning {

  [StorableClass]
  public sealed class EmptyTerminalTreeNode : SymbolicExpressionTreeTerminalNode {
    [StorableConstructor]
    private EmptyTerminalTreeNode(bool deserializing) : base(deserializing) { }
    private EmptyTerminalTreeNode(EmptyTerminalTreeNode original, Cloner cloner)
      : base(original, cloner) {
    }
    public EmptyTerminalTreeNode(ISymbol symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new EmptyTerminalTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class MeanConstTreeNode : SymbolicExpressionTreeTerminalNode {
    public new MeanConst Symbol { get { return (MeanConst)base.Symbol; } }

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

    public MeanConstTreeNode() : base(new MeanConst()) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanConstTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class MeanLinearTreeNode : SymbolicExpressionTreeTerminalNode {
    public new MeanLinear Symbol { get { return (MeanLinear)base.Symbol; } }

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

    public MeanLinearTreeNode(MeanLinear symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanLinearTreeNode(this, cloner);
    }
  }


  [StorableClass]
  public sealed class MeanScaleTreeNode : SymbolicExpressionTreeNode {
    public new MeanScale Symbol { get { return (MeanScale)base.Symbol; } }

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

    public MeanScaleTreeNode() : base(new MeanScale()) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanScaleTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class MeanMaskTreeNode : SymbolicExpressionTreeNode {
    public new MeanMask Symbol { get { return (MeanMask)base.Symbol; } }

    public override bool HasLocalParameters {
      get { return true; }
    }

    [Storable]
    public bool[] Mask { get; set; }

    [StorableConstructor]
    private MeanMaskTreeNode(bool deserializing) : base(deserializing) { }
    private MeanMaskTreeNode(MeanMaskTreeNode original, Cloner cloner)
      : base(original, cloner) {
      Mask = new bool[original.Mask.Length];
      Array.Copy(original.Mask, Mask, Mask.Length);
    }

    public MeanMaskTreeNode(MeanMask symbol)
      : base(symbol) {
      Mask = new bool[symbol.Dimension];
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanMaskTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      for (int i = 0; i < Mask.Length; i++)
        Mask[i] = random.NextDouble() < Symbol.MaskingProbability;
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      // one point bit flip
      int i = random.Next(Mask.Length);
      Mask[i] = !Mask[i];
    }
  }
  [StorableClass]
  public sealed class CovConstTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovConst Symbol { get { return (CovConst)base.Symbol; } }

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

    public CovConstTreeNode() : base(new CovConst()) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovConstTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovNoiseTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovNoise Symbol { get { return (CovNoise)base.Symbol; } }

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

    public CovNoiseTreeNode() : base(new CovNoise()) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovNoiseTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovLinArdTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovLinArd Symbol { get { return (CovLinArd)base.Symbol; } }

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

    public CovLinArdTreeNode(CovLinArd symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovLinArdTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovSeArdTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovSeArd Symbol { get { return (CovSeArd)base.Symbol; } }
    [StorableConstructor]
    private CovSeArdTreeNode(bool deserializing) : base(deserializing) { }
    private CovSeArdTreeNode(CovSeArdTreeNode original, Cloner cloner)
      : base(original, cloner) {
    }

    public CovSeArdTreeNode(CovSeArd symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSeArdTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovSeIsoTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovSeIso Symbol { get { return (CovSeIso)base.Symbol; } }

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

    public CovSeIsoTreeNode(CovSeIso symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSeIsoTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovMaternTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovMatern Symbol { get { return (CovMatern)base.Symbol; } }

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

    public CovMaternTreeNode(CovMatern symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovMaternTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovPeriodicTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovPeriodic Symbol { get { return (CovPeriodic)base.Symbol; } }

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

    public CovPeriodicTreeNode(CovPeriodic symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovPeriodicTreeNode(this, cloner);
    }
  }

  [StorableClass]
  public sealed class CovRQArdTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovRQArd Symbol { get { return (CovRQArd)base.Symbol; } }

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

    public CovRQArdTreeNode(CovRQArd symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovRQArdTreeNode(this, cloner);
    }
  }

  [StorableClass]
  public sealed class CovRQisoTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovRQIso Symbol { get { return (CovRQIso)base.Symbol; } }

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

    public CovRQisoTreeNode(CovRQIso symbol)
      : base(symbol) {
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovRQisoTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovScaleTreeNode : SymbolicExpressionTreeNode {
    public new CovScale Symbol { get { return (CovScale)base.Symbol; } }

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

    public CovScaleTreeNode(CovScale symbol) : base(symbol) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovScaleTreeNode(this, cloner);
    }
  }
  [StorableClass]
  public sealed class CovMaskTreeNode : SymbolicExpressionTreeNode {
    public new CovMask Symbol { get { return (CovMask)base.Symbol; } }

    public override bool HasLocalParameters {
      get { return true; }
    }

    [Storable]
    public bool[] Mask { get; set; }

    [StorableConstructor]
    private CovMaskTreeNode(bool deserializing) : base(deserializing) { }
    private CovMaskTreeNode(CovMaskTreeNode original, Cloner cloner)
      : base(original, cloner) {
      Mask = new bool[original.Mask.Length];
      Array.Copy(original.Mask, Mask, Mask.Length);
    }

    public CovMaskTreeNode(CovMask symbol)
      : base(symbol) {
      Mask = new bool[symbol.Dimension];
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovMaskTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      for (int i = 0; i < Mask.Length; i++)
        Mask[i] = random.NextDouble() < Symbol.MaskingProbability;
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      // one point bit flip
      int i = random.Next(Mask.Length);
      Mask[i] = !Mask[i];
    }
  }

  [StorableClass]
  public sealed class LikGaussTreeNode : SymbolicExpressionTreeTerminalNode {
    public new LikGauss Symbol { get { return (LikGauss)base.Symbol; } }

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

    public LikGaussTreeNode(LikGauss symbol) : base(symbol) { }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new LikGaussTreeNode(this, cloner);
    }
  }
}