source: branches/FitnessLandscapeAnalysis/HeuristicLab.Problems.NK/NKLandscape.cs @ 12531

using System;
using System.Collections.Generic;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.BinaryVectorEncoding;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;
using HeuristicLab.Problems.NK.WeightInitializers;
using HeuristicLab.Random;

namespace HeuristicLab.Problems.NK {

  [Item("NK Landscape", "Represents an NK landscape optimization problem.")]
  [Creatable("Problems")]
  [StorableClass]
  public sealed class NKLandscape : SingleObjectiveHeuristicOptimizationProblem<INKEvaluator, IBinaryVectorCreator>, IStorableContent {

    public string Filename { get; set; }

    #region Parameter Properties
    public ValueParameter<IntValue> LengthParameter {
      get { return (ValueParameter<IntValue>)Parameters["Length"]; }
    }
    public ValueParameter<BoolMatrix> GeneInteractionsParameter {
      get { return (ValueParameter<BoolMatrix>)Parameters["GeneInteractions"]; }
    }
    public ValueParameter<IntValue> InteractionSeedParameter {
      get { return (ValueParameter<IntValue>)Parameters["InteractionSeed"]; }
    }
    public ValueParameter<IntValue> NrOfInteractionsParameter {
      get { return (ValueParameter<IntValue>)Parameters["NrOfInteractions"]; }
    }
    public ValueParameter<IntValue> NrOfFitnessComponentsParameter {
      get { return (ValueParameter<IntValue>)Parameters["NrOfFitnessComponents"]; }
    }
    public ValueParameter<DoubleArray> WeightsParameter {
      get { return (ValueParameter<DoubleArray>)Parameters["Weights"]; }
    }
    public IConstrainedValueParameter<IInteractionInitializer> InteractionInitializerParameter {
      get { return (IConstrainedValueParameter<IInteractionInitializer>)Parameters["InteractionInitializer"]; }
    }
    public IConstrainedValueParameter<IWeightsInitializer> WeightsInitializerParameter {
      get { return (IConstrainedValueParameter<IWeightsInitializer>)Parameters["WeightsInitializer"]; }
    }
    #endregion

    #region Properties
    public IntValue Length {
      get { return LengthParameter.Value; }
      set { LengthParameter.Value = value; }
    }
    public IInteractionInitializer InteractionInitializer {
      get { return InteractionInitializerParameter.Value; }
    }
    [Storable(AllowOneWay = true)]
    private List<IOperator> operators {
      set {
        Operators.AddRange(value);
      }
    }
    #endregion

    private static MersenneTwister random = new MersenneTwister();

    [StorableConstructor]
    private NKLandscape(bool deserializing) : base(deserializing) { }
    private NKLandscape(NKLandscape original, Cloner cloner)
      : base(original, cloner) {
      AttachEventHandlers();
    }
    public NKLandscape()
      : base() {
      Parameters.Add(new ValueParameter<IntValue>("Length", "The length of the BinaryVector.", new IntValue(10)));
      Parameters.Add(new ValueParameter<BoolMatrix>("GeneInteractions", "Every column gives the participating genes for each fitness component"));
      Parameters.Add(new ValueParameter<IntValue>("InteractionSeed", "The seed used for the hash function to generate interaction tables.", new IntValue(random.Next())));
      Parameters.Add(new ValueParameter<IntValue>("NrOfFitnessComponents", "Number of fitness component functions. (nr of columns in the interaction column)", new IntValue(10)));
      Parameters.Add(new ValueParameter<IntValue>("NrOfInteractions", "Number of genes interacting with each other. (nr of True values per column in the interaction matrix)", new IntValue(3)));
      Parameters.Add(new ValueParameter<DoubleArray>("Weights", "The weights for the component functions. If shorted, will be repeated.", new DoubleArray(new[] { 1.0 })));
      Parameters.Add(new OptionalConstrainedValueParameter<IInteractionInitializer>("InteractionInitializer", "Initialize interactions within the component functions."));
      Parameters.Add(new OptionalConstrainedValueParameter<IWeightsInitializer>("WeightsInitializer", "Operator to initialize weights distribution"));

      SolutionCreator = new RandomBinaryVectorCreator();
      Evaluator = new NKEvaluator();

      InitializeInteractionInitializerParameter();
      InitializeWeightsInitializerParameter();

      ParameterizeSolutionCreator();
      ParameterizeEvaluator();

      InitializeOperators();
      AttachEventHandlers();
      InitializeInteractions();
    }

    private void InitializeInteractionInitializerParameter() {
      foreach (var initializer in ApplicationManager.Manager.GetInstances<IInteractionInitializer>())
        InteractionInitializerParameter.ValidValues.Add(initializer);
      InteractionInitializerParameter.Value = InteractionInitializerParameter.ValidValues.First(v => v is RandomInteractionsInitializer);
    }

    private void InitializeWeightsInitializerParameter() {
      foreach (var initializer in ApplicationManager.Manager.GetInstances<IWeightsInitializer>())
        WeightsInitializerParameter.ValidValues.Add(initializer);
      WeightsInitializerParameter.Value = WeightsInitializerParameter.ValidValues.First(v => v is EqualWeightsInitializer);
    }

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

    #region Events
    protected override void OnSolutionCreatorChanged() {
      SolutionCreator.BinaryVectorParameter.ActualNameChanged += SolutionCreator_BinaryVectorParameter_ActualNameChanged;
      ParameterizeSolutionCreator();
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      ParameterizeOperators();
      base.OnSolutionCreatorChanged();
    }
    private void SolutionCreator_BinaryVectorParameter_ActualNameChanged(object sender, EventArgs e) {
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      ParameterizeOperators();
    }
    protected override void OnEvaluatorChanged() {
      ParameterizeEvaluator();
      ParameterizeAnalyzer();
      base.OnEvaluatorChanged();
    }
    void LengthParameter_ValueChanged(object sender, EventArgs e) {
      ParameterizeSolutionCreator();
      LengthParameter.Value.ValueChanged += new EventHandler(Length_ValueChanged);
      BestKnownQualityParameter.Value.Value = Length.Value;
    }
    void Length_ValueChanged(object sender, EventArgs e) {
      NrOfFitnessComponentsParameter.Value = new IntValue(Length.Value);
    }
    void OneBitflipMoveParameter_ActualNameChanged(object sender, EventArgs e) {
      string name = ((ILookupParameter<OneBitflipMove>)sender).ActualName;
      foreach (IOneBitflipMoveOperator op in Operators.OfType<IOneBitflipMoveOperator>()) {
        op.OneBitflipMoveParameter.ActualName = name;
      }
    }
    #endregion

    #region Helpers
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey("InteractionInitializer")) {
        Parameters.Add(new OptionalConstrainedValueParameter<IInteractionInitializer>("InteractionInitializer", "Initialized the interaction between bits and fitness components"));
        InitializeInteractionInitializerParameter();
      }
      if (!Parameters.ContainsKey("WeightsInitializer")) {
        Parameters.Add(new OptionalConstrainedValueParameter<IWeightsInitializer>("WeightsInitializer", "Operator to initialize weights distribution"));
        InitializeWeightsInitializerParameter();
      }
      AttachEventHandlers();
    }

    private void AttachEventHandlers() {
      SolutionCreator.BinaryVectorParameter.ActualNameChanged += new EventHandler(SolutionCreator_BinaryVectorParameter_ActualNameChanged);
      LengthParameter.ValueChanged += new EventHandler(LengthParameter_ValueChanged);
      LengthParameter.Value.ValueChanged += new EventHandler(Length_ValueChanged);
      NrOfInteractionsParameter.ValueChanged += InteractionParameterChanged;
      NrOfInteractionsParameter.Value.ValueChanged += InteractionParameterChanged;
      NrOfFitnessComponentsParameter.ValueChanged += InteractionParameterChanged;
      NrOfFitnessComponentsParameter.Value.ValueChanged += InteractionParameterChanged;
      InteractionInitializerParameter.ValueChanged += new EventHandler(InteractionInitializerParameter_ValueChanged);
      WeightsInitializerParameter.ValueChanged += new EventHandler(WeightsInitializerParameter_ValueChanged);
    }

    void WeightsInitializerParameter_ValueChanged(object sender, EventArgs e) {
      InitializeWeights();
    }

    void InteractionInitializerParameter_ValueChanged(object sender, EventArgs e) {
      InitializeInteractions();
    }

    private void InteractionParameterChanged(object sender, EventArgs e) {
      InitializeInteractions();
    }

    private void ParameterizeSolutionCreator() {
      SolutionCreator.LengthParameter.ActualName = LengthParameter.Name;
    }

    private void ParameterizeEvaluator() {
      if (Evaluator is NKEvaluator)
        ((NKEvaluator)Evaluator).BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
    }
    private void ParameterizeAnalyzer() {
      //BestOneMaxSolutionAnalyzer.MaximizationParameter.ActualName = MaximizationParameter.Name;
      //BestOneMaxSolutionAnalyzer.BestKnownQualityParameter.ActualName = BestKnownQualityParameter.Name;
      //BestOneMaxSolutionAnalyzer.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
      //BestOneMaxSolutionAnalyzer.ResultsParameter.ActualName = "Results";
    }

    private void InitializeOperators() {
      ParameterizeAnalyzer();
      foreach (IBinaryVectorOperator op in ApplicationManager.Manager.GetInstances<IBinaryVectorOperator>()) {
        if (!(op is ISingleObjectiveMoveEvaluator) || (op is INKMoveEvaluator)) {
          Operators.Add(op);
        }
      }
      ParameterizeOperators();
      InitializeMoveGenerators();
    }
    private void InitializeMoveGenerators() {
      foreach (IOneBitflipMoveOperator op in Operators.OfType<IOneBitflipMoveOperator>()) {
        if (op is IMoveGenerator) {
          op.OneBitflipMoveParameter.ActualNameChanged += new EventHandler(OneBitflipMoveParameter_ActualNameChanged);
        }
      }
    }
    private void ParameterizeOperators() {
      foreach (IBinaryVectorCrossover op in Operators.OfType<IBinaryVectorCrossover>()) {
        op.ParentsParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
        op.ChildParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
      }
      foreach (IBinaryVectorManipulator op in Operators.OfType<IBinaryVectorManipulator>()) {
        op.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
      }
      foreach (IBinaryVectorMoveOperator op in Operators.OfType<IBinaryVectorMoveOperator>()) {
        op.BinaryVectorParameter.ActualName = SolutionCreator.BinaryVectorParameter.ActualName;
      }
    }

    private void InitializeInteractions() {
      if (InteractionInitializer != null)
        GeneInteractionsParameter.Value = InteractionInitializer.InitializeInterations(
          Length.Value,
          NrOfFitnessComponentsParameter.Value.Value,
          NrOfInteractionsParameter.Value.Value,
          random);
    }

    private void InitializeWeights() {
      if (WeightsInitializerParameter.Value != null)
        WeightsParameter.Value = new DoubleArray(
          WeightsInitializerParameter.Value.GetWeights(NrOfFitnessComponentsParameter.Value.Value)
          .ToArray());
    }
    #endregion

  }
}