source: branches/2895_PushGP_GenealogyAnalysis/HeuristicLab.Problems.ProgramSynthesis/Push/SolutionCreator/PlushCreator.cs @ 15771

using System;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.ProgramSynthesis {
  [Item("PlushCreator", "An operator which creates a new random plush vector with each element uniformly distributed")]
  [StorableClass]
  public class PlushCreator : InstrumentedOperator, IPlushCreator, IStochasticOperator {

    public PlushCreator() {
      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<IntValue>("MaxClose", "The max close variable for a plush genome entry."));
      Parameters.Add(new ValueLookupParameter<DoubleValue>("CloseBiasLevel", "Determines how strongly the random close variable is biased towards 0."));
      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"));
    }

    [StorableConstructor]
    public PlushCreator(bool deserializing) : base(deserializing) { }

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

    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 IValueLookupParameter<IntValue> MaxCloseParameter {
      get { return (IValueLookupParameter<IntValue>)Parameters["MaxClose"]; }
    }
    public IValueLookupParameter<DoubleValue> CloseBiasLevelParameter {
      get { return (IValueLookupParameter<DoubleValue>)Parameters["CloseBiasLevel"]; }
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new PlushCreator(this, cloner);
    }

    public sealed override IOperation InstrumentedApply() {
      PlushVectorParameter.ActualValue = Create();
      return base.InstrumentedApply();
    }

    private PlushVector Create() {
      var random = RandomParameter.ActualValue;
      var minLength = MinLengthParameter.ActualValue.Value;
      var maxLength = MaxLengthParameter.ActualValue.Value;
      var ercOptions = ErcOptionsParameter.ActualValue;
      var instructions = InstructionsParameter.ActualValue;
      var inInstructionProbability = InInstructionProbabilityParameter.ActualValue.Value;
      var maxClose = MaxCloseParameter.ActualValue.Value;
      var biasLevel = CloseBiasLevelParameter.ActualValue.Value;

      if (minLength > maxLength)
        throw new InvalidOperationException("MinLength > MaxLength");

      var length = random.Next(minLength, maxLength);
      var result = new PlushVector(length);

      for (var i = 0; i < length; i++) {
        var expression = CodeGeneratorUtils.GetRandomExpression(
          random,
          ercOptions,
          instructions,
          inInstructionProbability);

        var close = maxClose == 0 ? 1 : random.NextBiased(0, maxClose, biasLevel);

        result.Add(new PlushEntry {
          Close = close,
          Instruction = expression,
        });
      }

      return result;
    }
  }
}