source: addons/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs @ 15692

// ReSharper disable CompareOfFloatsByEqualityOperator
namespace HeuristicLab.Problems.ProgramSynthesis.Push.Manipulator {

  using HeuristicLab.Common;
  using HeuristicLab.Core;
  using HeuristicLab.Data;
  using HeuristicLab.Operators;
  using HeuristicLab.Optimization;
  using HeuristicLab.Parameters;
  using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Erc;
  using HeuristicLab.Problems.ProgramSynthesis.Base.Extensions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Configuration;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Expressions;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;

  /// <summary>
  /// Uniformly distributed change of a single position of an integer vector.
  /// </summary>
  [Item("UniformMutation", " Uniformly distributed change of a single position of an plush vector.")]
  [StorableClass]
  public class UniformMutation : InstrumentedOperator, IPlushManipulator, IStochasticOperator {

    public UniformMutation() {
      Parameters.Add(new LookupParameter<IRandom>("Random", "The pseudo random number generator which should be used for stochastic manipulation operators."));
      Parameters.Add(new LookupParameter<PlushVector>("PlushVector", "The vector which should be manipulated."));
      Parameters.Add(new ValueLookupParameter<IReadOnlyExpressionsConfiguration>("Instructions", "The enabled instructions"));
      Parameters.Add(new ValueLookupParameter<IReadOnlyErcOptions>("ErcOptions", "ERC options"));
      Parameters.Add(new ValueLookupParameter<PercentValue>("InInstructionProbability", "The probability of IN Instructions"));

      Parameters.Add(new FixedValueParameter<PercentValue>("InstructionMutationProbability", "The probability instructions get mutated", new PercentValue(0.8)));
      Parameters.Add(new FixedValueParameter<PercentValue>("InstructionMutationRate", "The probability an instruction gets mutated", new PercentValue(0.01)));
      Parameters.Add(new FixedValueParameter<PercentValue>("InstructionConstantTweakRate", "When mutating an instruction, this parameter specifies if mutation is related to the current type (e.g. INTEGER, FLOAT) or not. ", new PercentValue(0)));
      Parameters.Add(new FixedValueParameter<PercentValue>("CloseMutationProbability", "The probability close gets mutated", new PercentValue(0.2)));
      Parameters.Add(new FixedValueParameter<PercentValue>("CloseIncrementRate", "When mutating individual, the increment rate specifies if close should be increased or decreased by 1.", new PercentValue(0.1)));
    }

    public UniformMutation(bool deserializing) : base(deserializing) {
    }

    public UniformMutation(UniformMutation origin, Cloner cloner) : base(origin, cloner) {
    }

    public IValueParameter<PercentValue> InstructionMutationProbabilityParameter
    {
      get { return (IValueParameter<PercentValue>)Parameters["InstructionMutationProbability"]; }
    }

    public double InstructionMutationProbability
    {
      get { return InstructionMutationProbabilityParameter.Value.Value; }
      set { InstructionMutationProbabilityParameter.Value.Value = value; }
    }

    public IValueParameter<PercentValue> InstructionMutationRateParameter
    {
      get { return (IValueParameter<PercentValue>)Parameters["InstructionMutationRate"]; }
    }

    public double InstructionMutationRate
    {
      get { return InstructionMutationRateParameter.Value.Value; }
      set { InstructionMutationRateParameter.Value.Value = value; }
    }

    public IValueParameter<PercentValue> InstructionConstantTweakRateParameter
    {
      get { return (IValueParameter<PercentValue>)Parameters["InstructionConstantTweakRate"]; }
    }

    public double InstructionConstantTweakRate
    {
      get { return InstructionConstantTweakRateParameter.Value.Value; }
      set { InstructionConstantTweakRateParameter.Value.Value = value; }
    }

    public IValueParameter<PercentValue> CloseMutationProbabilityParameter
    {
      get { return (IValueParameter<PercentValue>)Parameters["CloseMutationProbability"]; }
    }

    public double CloseMutationProbability
    {
      get { return CloseMutationProbabilityParameter.Value.Value; }
      set { CloseMutationProbabilityParameter.Value.Value = value; }
    }

    public IValueParameter<PercentValue> CloseIncrementRateParameter
    {
      get { return (IValueParameter<PercentValue>)Parameters["CloseIncrementRate"]; }
    }

    public double CloseIncrementRate
    {
      get { return CloseIncrementRateParameter.Value.Value; }
      set { CloseIncrementRateParameter.Value.Value = value; }
    }

    public override bool CanChangeName
    {
      get { return false; }
    }
    public ILookupParameter<IRandom> RandomParameter
    {
      get { return (LookupParameter<IRandom>)Parameters["Random"]; }
    }
    public ILookupParameter<PlushVector> PlushVectorParameter
    {
      get { return (ILookupParameter<PlushVector>)Parameters["PlushVector"]; }
    }
    public IValueLookupParameter<IReadOnlyExpressionsConfiguration> InstructionsParameter
    {
      get { return (IValueLookupParameter<IReadOnlyExpressionsConfiguration>)Parameters["Instructions"]; }
    }
    public IValueLookupParameter<IReadOnlyErcOptions> ErcOptionsParameter
    {
      get { return (IValueLookupParameter<IReadOnlyErcOptions>)Parameters["ErcOptions"]; }
    }
    public IValueLookupParameter<PercentValue> InInstructionProbabilityParameter
    {
      get { return (IValueLookupParameter<PercentValue>)Parameters["InInstructionProbability"]; }
    }

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

    public sealed override IOperation InstrumentedApply() {
      Manipulate(
        RandomParameter.ActualValue,
        PlushVectorParameter.ActualValue,
        ErcOptionsParameter.ActualValue,
        InstructionsParameter.ActualValue,
        InInstructionProbabilityParameter.ActualValue.Value,
        CloseMutationProbability,
        CloseIncrementRate,
        InstructionMutationProbability,
        InstructionMutationRate,
        InstructionConstantTweakRate);
      return base.InstrumentedApply();
    }

    private static void Manipulate(
      IRandom random,
      PlushVector plushVector,
      IReadOnlyErcOptions ercOptions,
      IReadOnlyExpressionsConfiguration instructions,
      double inInstructionProbability,
      double closeMutationProbability,
      double closeIncrementRate,
      double instructionMutationProbability,
      double instructionMutationRate,
      double constantTweakRate
      ) {

      var x = random.NextDouble();

      // instruction manipulation
      if (x < instructionMutationProbability) {
        if (instructionMutationRate == 0) return;
        for (var i = 0; i < plushVector.Entries.Count; i++) {
          MutateInstruction(random, ercOptions, instructions, inInstructionProbability, instructionMutationRate, constantTweakRate, plushVector[i]);
        }

        plushVector.UpdatePushProgram();
        return;
      }

      // close manipulation
      if (x < instructionMutationProbability + closeMutationProbability) {
        if (closeIncrementRate == 0) return;
        for (var i = 0; i < plushVector.Entries.Count; i++) {
          MutateClose(random, closeIncrementRate, plushVector[i]);
        }

        plushVector.UpdatePushProgram();
        return;
      }
    }

    private static void MutateClose(IRandom random, double closeIncrementRate, PlushEntry entry) {
      entry.Close += random.NextDouble() < closeIncrementRate ? 1 : -1;

      if (entry.Close < 0)
        entry.Close = 0;
    }

    private static void MutateInstruction(
      IRandom random,
      IReadOnlyErcOptions ercOptions,
      IReadOnlyExpressionsConfiguration instructions,
      double inInstructionProbability,
      double instructionMutationRate,
      double constantTweakRate,
      PlushEntry entry) {

      if (random.NextDouble() >= instructionMutationRate)
        return;

      var entryType = entry.Instruction.GetType();

      if (constantTweakRate > 0 && random.NextDouble() < constantTweakRate &&
          entryType.IsSubclass(typeof(PushExpression<>))) {
        var attribute = ExpressionTable.TypeToAttributeTable[entryType];
        entry.Instruction = CodeGeneratorUtils.CreateRandomErcExpression(attribute.StackType, random, ercOptions);
        return;
      }

      entry.Instruction = CodeGeneratorUtils.GetRandomExpression(
        random,
        ercOptions,
        instructions,
        inInstructionProbability);
    }
  }
}