source: branches/GaussianProcessEvolution/HeuristicLab.Problems.GaussianProcessTuning/TreeNodes.cs @ 8753

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; } }

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

    private double value;
    [Storable]
    public double Value { get { return value; } private set { this.value = value; } }

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

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanConstTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      value = Symbol.MinValue + random.NextDouble() * (Symbol.MaxValue - Symbol.MinValue);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.ValueShakingMu, Symbol.ValueShakingSigma);
      value = Math.Max(Symbol.MinValue, Math.Min(Symbol.MaxValue, value + normRandom.NextDouble() * shakingFactor));
    }
  }
  [StorableClass]
  public sealed class MeanLinearTreeNode : SymbolicExpressionTreeTerminalNode {
    public new MeanLinear Symbol { get { return (MeanLinear)base.Symbol; } }

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

    [Storable]
    public double[] Alpha { get; set; }

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

    public MeanLinearTreeNode(MeanLinear symbol)
      : base(symbol) {
      Alpha = new double[symbol.Dimension];
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanLinearTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      var normRandom = new NormalDistributedRandom(random, Symbol.AlphaMu, Symbol.AlphaSigma);
      for (int i = 0; i < Alpha.Length; i++)
        Alpha[i] = normRandom.NextDouble();
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.AlphaShakingMu, Symbol.AlphaShakingSigma);
      int index = random.Next(Alpha.Length);
      Alpha[index] += shakingFactor * normRandom.NextDouble();
    }
  }


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

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

    private double alpha;
    [Storable]
    public double Alpha { get { return alpha; } private set { this.alpha = value; } }

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

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MeanScaleTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      var normRandom = new NormalDistributedRandom(random, Symbol.AlphaMu, Symbol.AlphaSigma);
      alpha = normRandom.NextDouble();
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.AlphaShakingMu, Symbol.AlphaShakingSigma);
      alpha += shakingFactor * normRandom.NextDouble();
    }
  }
  [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; } }

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

    private double sigma;
    [Storable]
    public double Sigma { get { return sigma; } private set { this.sigma = value; } }

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

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovConstTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      sigma = random.Next((int)Symbol.MinSigma, (int)Symbol.MaxSigma);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, sigma + normRandom.NextDouble() * shakingFactor));
    }
  }
  [StorableClass]
  public sealed class CovNoiseTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovNoise Symbol { get { return (CovNoise)base.Symbol; } }

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

    private double sigma;
    [Storable]
    public double Sigma { get { return sigma; } private set { this.sigma = value; } }

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

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovNoiseTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      sigma = random.Next((int)Symbol.MinSigma, (int)Symbol.MaxSigma);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, sigma + normRandom.NextDouble() * shakingFactor));
    }
  }
  [StorableClass]
  public sealed class CovLinArdTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovLinArd Symbol { get { return (CovLinArd)base.Symbol; } }

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

    [Storable]
    public double[] Lambda { get; set; }

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

    public CovLinArdTreeNode(CovLinArd symbol)
      : base(symbol) {
      Lambda = new double[symbol.Dimension];
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovLinArdTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      var normRandom = new NormalDistributedRandom(random, Symbol.LambdaMu, Symbol.LambdaSigma);
      for (int i = 0; i < Lambda.Length; i++)
        Lambda[i] = normRandom.NextDouble();
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      int index = random.Next(Lambda.Length);
      var normRandom = new NormalDistributedRandom(random, Symbol.LambdaShakingMu, Symbol.LambdaShakingSigma);
      Lambda[index] += shakingFactor * normRandom.NextDouble();
    }
  }
  [StorableClass]
  public sealed class CovSeArdTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovSeArd Symbol { get { return (CovSeArd)base.Symbol; } }

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

    [Storable]
    public double[] Lambda { get; set; }

    [Storable]
    public double Sigma { get; set; }

    [StorableConstructor]
    private CovSeArdTreeNode(bool deserializing) : base(deserializing) { }
    private CovSeArdTreeNode(CovSeArdTreeNode original, Cloner cloner)
      : base(original, cloner) {
      Lambda = new double[original.Lambda.Length];
      Array.Copy(original.Lambda, Lambda, Lambda.Length);
      Sigma = original.Sigma;
    }

    public CovSeArdTreeNode(CovSeArd symbol)
      : base(symbol) {
      Lambda = new double[symbol.Dimension];
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSeArdTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      var normRandom = new NormalDistributedRandom(random, Symbol.LambdaMu, Symbol.LambdaSigma);
      for (int i = 0; i < Lambda.Length; i++)
        Lambda[i] = normRandom.NextDouble();

      Sigma = Symbol.MinSigma + random.NextDouble() * (Symbol.MaxSigma - Symbol.MinSigma);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      int index = random.Next(Lambda.Length);
      var normRandom = new NormalDistributedRandom(random, Symbol.LambdaShakingMu, Symbol.LambdaShakingSigma);
      Lambda[index] += shakingFactor * normRandom.NextDouble();

      var sigmaRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      Sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, Sigma + shakingFactor * sigmaRandom.NextDouble()));
    }
  }
  [StorableClass]
  public sealed class CovSeIsoTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovSeIso Symbol { get { return (CovSeIso)base.Symbol; } }

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

    [Storable]
    public double L { get; set; }

    [Storable]
    public double Sigma { get; set; }

    [StorableConstructor]
    private CovSeIsoTreeNode(bool deserializing) : base(deserializing) { }
    private CovSeIsoTreeNode(CovSeIsoTreeNode original, Cloner cloner)
      : base(original, cloner) {
      L = original.L;
      Sigma = original.Sigma;
    }

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovSeIsoTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      Sigma = Symbol.MinSigma + random.NextDouble() * (Symbol.MaxSigma - Symbol.MinSigma);
      L = Symbol.MinL + random.NextDouble() * (Symbol.MaxL - Symbol.MinL);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var sigmaRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      Sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, Sigma + shakingFactor * sigmaRandom.NextDouble()));

      var lRandom = new NormalDistributedRandom(random, Symbol.LShakingMu, Symbol.LShakingSigma);
      L = Math.Max(Symbol.MinL, Math.Min(Symbol.MaxL, L + shakingFactor * lRandom.NextDouble()));
    }
  }
  [StorableClass]
  public sealed class CovMaternTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovMatern Symbol { get { return (CovMatern)base.Symbol; } }

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

    [Storable]
    public double L { get; set; }

    [Storable]
    public double Sigma { get; set; }

    [StorableConstructor]
    private CovMaternTreeNode(bool deserializing) : base(deserializing) { }
    private CovMaternTreeNode(CovMaternTreeNode original, Cloner cloner)
      : base(original, cloner) {
      L = original.L;
      Sigma = original.Sigma;
    }

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovMaternTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      Sigma = Symbol.MinSigma + random.NextDouble() * (Symbol.MaxSigma - Symbol.MinSigma);
      L = Symbol.MinL + random.NextDouble() * (Symbol.MaxL - Symbol.MinL);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var sigmaRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      Sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, Sigma + shakingFactor * sigmaRandom.NextDouble()));

      var lRandom = new NormalDistributedRandom(random, Symbol.LShakingMu, Symbol.LShakingSigma);
      L = Math.Max(Symbol.MinL, Math.Min(Symbol.MaxL, L + shakingFactor * lRandom.NextDouble()));
    }
  }
  [StorableClass]
  public sealed class CovPeriodicTreeNode : SymbolicExpressionTreeTerminalNode {
    public new CovPeriodic Symbol { get { return (CovPeriodic)base.Symbol; } }

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

    [Storable]
    public double L { get; set; }

    [Storable]
    public double Sigma { get; set; }

    [Storable]
    public double Period { get; set; }

    [StorableConstructor]
    private CovPeriodicTreeNode(bool deserializing) : base(deserializing) { }
    private CovPeriodicTreeNode(CovPeriodicTreeNode original, Cloner cloner)
      : base(original, cloner) {
      L = original.L;
      Sigma = original.Sigma;
      Period = original.Period;
    }

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovPeriodicTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      Sigma = Symbol.MinSigma + random.NextDouble() * (Symbol.MaxSigma - Symbol.MinSigma);
      L = Symbol.MinL + random.NextDouble() * (Symbol.MaxL - Symbol.MinL);
      Period = Symbol.MinPeriod + random.NextDouble() * (Symbol.MaxPeriod - Symbol.MinPeriod);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var sigmaRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      Sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, Sigma + shakingFactor * sigmaRandom.NextDouble()));

      var lRandom = new NormalDistributedRandom(random, Symbol.LShakingMu, Symbol.LShakingSigma);
      L = Math.Max(Symbol.MinL, Math.Min(Symbol.MaxL, L + shakingFactor * lRandom.NextDouble()));

      var pRandom = new NormalDistributedRandom(random, Symbol.PeriodShakingMu, Symbol.PeriodShakingSigma);
      Period = Math.Max(Symbol.MinPeriod, Math.Min(Symbol.MaxPeriod, Period + shakingFactor * pRandom.NextDouble()));
    }
  }

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

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

    [Storable]
    public double[] Lambda { get; set; }

    [Storable]
    public double Sigma { get; set; }

    [Storable]
    public double Shape { get; set; }

    [StorableConstructor]
    private CovRQArdTreeNode(bool deserializing) : base(deserializing) { }
    private CovRQArdTreeNode(CovRQArdTreeNode original, Cloner cloner)
      : base(original, cloner) {
      Lambda = new double[original.Lambda.Length];
      Array.Copy(original.Lambda, Lambda, Lambda.Length);
      Sigma = original.Sigma;
      Shape = original.Shape;
    }

    public CovRQArdTreeNode(CovRQArd symbol)
      : base(symbol) {
      Lambda = new double[symbol.Dimension];
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovRQArdTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      var normRandom = new NormalDistributedRandom(random, Symbol.LambdaMu, Symbol.LambdaSigma);
      for (int i = 0; i < Lambda.Length; i++)
        Lambda[i] = normRandom.NextDouble();

      Sigma = Symbol.MinSigma + random.NextDouble() * (Symbol.MaxSigma - Symbol.MinSigma);
      Shape = Symbol.MinShape + random.NextDouble() * (Symbol.MaxShape - Symbol.MinShape);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      int index = random.Next(Lambda.Length);
      var normRandom = new NormalDistributedRandom(random, Symbol.LambdaShakingMu, Symbol.LambdaShakingSigma);
      Lambda[index] += shakingFactor * normRandom.NextDouble();

      var sigmaRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      Sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, Sigma + shakingFactor * sigmaRandom.NextDouble()));

      var shapeRandom = new NormalDistributedRandom(random, Symbol.ShapeShakingMu, Symbol.ShapeShakingSigma);
      Sigma = Math.Max(Symbol.MinShape, Math.Min(Symbol.MaxShape, Shape + shakingFactor * shapeRandom.NextDouble()));
    }
  }

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

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

    [Storable]
    public double L { get; set; }

    [Storable]
    public double Sigma { get; set; }

    [Storable]
    public double Shape { get; set; }

    [StorableConstructor]
    private CovRQisoTreeNode(bool deserializing) : base(deserializing) { }
    private CovRQisoTreeNode(CovRQisoTreeNode original, Cloner cloner)
      : base(original, cloner) {
      L = original.L;
      Sigma = original.Sigma;
      Shape = original.Shape;
    }

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovRQisoTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      Sigma = Symbol.MinSigma + random.NextDouble() * (Symbol.MaxSigma - Symbol.MinSigma);
      L = Symbol.MinL + random.NextDouble() * (Symbol.MaxL - Symbol.MinL);
      Shape = Symbol.MinShape + random.NextDouble() * (Symbol.MaxShape - Symbol.MinShape);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var sigmaRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      Sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, Sigma + shakingFactor * sigmaRandom.NextDouble()));

      var lRandom = new NormalDistributedRandom(random, Symbol.LShakingMu, Symbol.LShakingSigma);
      L = Math.Max(Symbol.MinL, Math.Min(Symbol.MaxL, L + shakingFactor * lRandom.NextDouble()));

      var shapeRandom = new NormalDistributedRandom(random, Symbol.ShapeShakingMu, Symbol.ShapeShakingSigma);
      Shape = Math.Max(Symbol.MinShape, Math.Min(Symbol.MaxShape, Shape + shakingFactor * shapeRandom.NextDouble()));
    }
  }
  [StorableClass]
  public sealed class CovScaleTreeNode : SymbolicExpressionTreeNode {
    public new CovScale Symbol { get { return (CovScale)base.Symbol; } }

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

    private double alpha;
    [Storable]
    public double Alpha { get { return alpha; } private set { this.alpha = value; } }

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

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new CovScaleTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      var normRandom = new NormalDistributedRandom(random, Symbol.AlphaMu, Symbol.AlphaSigma);
      alpha = normRandom.NextDouble();
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.AlphaShakingMu, Symbol.AlphaShakingSigma);
      alpha += shakingFactor * normRandom.NextDouble();
    }
  }
  [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; } }

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

    private double sigma;
    [Storable]
    public double Sigma { get { return sigma; } private set { this.sigma = value; } }

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

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

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new LikGaussTreeNode(this, cloner);
    }
    public override void ResetLocalParameters(IRandom random) {
      sigma = random.Next((int)Symbol.MinSigma, (int)Symbol.MaxSigma);
    }
    public override void ShakeLocalParameters(IRandom random, double shakingFactor) {
      var normRandom = new NormalDistributedRandom(random, Symbol.SigmaShakingMu, Symbol.SigmaShakingSigma);
      sigma = Math.Max(Symbol.MinSigma, Math.Min(Symbol.MaxSigma, sigma + normRandom.NextDouble() * shakingFactor));
    }
  }
}