source: branches/PushGP/HeuristicLab.PushGP/HeuristicLab.Problems.ProgramSynthesis/Push/Manipulator/UniformMutation.cs @ 15275

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.Push.Configuration;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Encoding;
  using HeuristicLab.Problems.ProgramSynthesis.Push.Generators.CodeGenerator;
  using HeuristicLab.Random;

  /// <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<IntValue>("MinLength", "The min length of the vector."));
      Parameters.Add(new ValueLookupParameter<IntValue>("MaxLength", "The max length of the vector."));
      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 a value gets mutated", new PercentValue(0.02)));
      Parameters.Add(new FixedValueParameter<DoubleValue>("CloseMutationDeviation", "When mutating individual, the amount of which the close marker is incremented or decrement is based on a random sample from a normal distribution with mean 0 and standard deviation set by the close mutation deviation parameter", new DoubleValue(1.0)));
    }

    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> CloseMutationDeviationParameter
    {
      get { return (IValueParameter<PercentValue>)Parameters["CloseMutationDeviation"]; }
    }

    public double CloseMutationDeviation
    {
      get { return CloseMutationDeviationParameter.Value.Value; }
      set { CloseMutationDeviationParameter.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<IntValue> MinLengthParameter
    {
      get { return (IValueLookupParameter<IntValue>)Parameters["MinLength"]; }
    }
    public IValueLookupParameter<IntValue> MaxLengthParameter
    {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaxLength"]; }
    }
    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);
      return base.InstrumentedApply();
    }

    private void Manipulate(IRandom random, PlushVector plushVector) {
      var normalDistributedRandom = new NormalDistributedRandom(random, 0, CloseMutationDeviation);
      var ercOptions = ErcOptionsParameter.ActualValue;
      var instructions = InstructionsParameter.ActualValue;
      var inInstructionProbability = InInstructionProbabilityParameter.ActualValue.Value;
      var instructionMutationProbability = InstructionMutationProbability;

      for (var i = 0; i < plushVector.Entries.Count; i++) {
        var entry = plushVector[i];
        var x = random.NextDouble();

        if (x < instructionMutationProbability) {
          var instruction = CodeGeneratorUtils.GetRandomExpression(
            random,
            ercOptions,
            instructions,
            inInstructionProbability);
          entry.Instruction = instruction;
        }

        entry.Close += normalDistributedRandom.Next();
      }

      // specifies that the program cached within entry must be updated before reuse
      plushVector.UpdatePushProgram();
    }
  }
}