source: addons/HeuristicLab.Problems.BioBoost/HeuristicLab.Problems.BioBoost/3.3/Operators/Mutation/MultiMutator.cs @ 16575

#region License Information
/* HeuristicLab
 * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
 *
 * This file is part of HeuristicLab.
 *
 * HeuristicLab is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * HeuristicLab is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
 */
#endregion

using System.Reflection;
using HeuristicLab.Collections;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Data;
using HeuristicLab.Encodings.IntegerVectorEncoding;
using HeuristicLab.Operators;
using HeuristicLab.Optimization;
using HeuristicLab.Parameters;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.PluginInfrastructure;
using System;
using System.Collections.Generic;
using System.Linq;
using HEAL.Attic;

namespace HeuristicLab.BioBoost.Operators.Mutation {
  [StorableType("4051852F-E6DA-45A6-A63B-E62FA18D9D3E")]
  public class MultiMutator : StochasticMultiBranch<IManipulator>, IManipulator, IStochasticOperator {

    public override bool CanChangeName { get { return false; } }

    protected override bool CreateChildOperation { get { return true; } }

    public IValueLookupParameter<IntValue> SeriesLengthParameter { get { return (IValueLookupParameter<IntValue>)Parameters["SeriesLength"]; } }
    public ValueParameter<PercentArray> MinGenerationPercentagesParameter { get { return (ValueParameter<PercentArray>)Parameters["MinGenerationPercentages"]; } }
    public ILookupParameter<IntValue> GenerationsParameter { get { return (ILookupParameter<IntValue>)Parameters["Generations"]; } }
    public ILookupParameter<IntValue> MaxGenerationsParameter { get { return (ILookupParameter<IntValue>)Parameters["MaximumGenerations"]; } }
    public PercentArray MinGenerationPercentages {
      get { return MinGenerationPercentagesParameter.Value; }
      set { MinGenerationPercentagesParameter.Value = value; }
    }

    public int SeriesLength { get { return SeriesLengthParameter.ActualValue.Value; } }

    #region Construction & Cloning
    [StorableConstructor]
    protected MultiMutator(StorableConstructorFlag _) : base(_) { }
    protected MultiMutator(MultiMutator orig, Cloner cloner) : base(orig, cloner) { }
    public MultiMutator() {
      Parameters.Add(new ValueLookupParameter<IntValue>("SeriesLength", "The number of manipulations to perform at once", new IntValue(1)));
      Parameters.Add(new ValueParameter<PercentArray>("MinGenerationPercentages", "Relative number of generations before the respetive mutation becomes active.", new PercentArray(0)));
      Parameters.Add(new LookupParameter<IntValue>("Generations", "Current number of generations/iterations."));
      Parameters.Add(new LookupParameter<IntValue>("MaximumGenerations", "Maximum number of generations/iterations."));
      foreach (var t in ApplicationManager.Manager.GetTypes(typeof(IManipulator), Assembly.GetExecutingAssembly())) {
        if (t == this.GetType() || typeof(IIntegerVectorManipulator).IsAssignableFrom(t)) continue;
        IManipulator instance = null;
        try {
          instance = Activator.CreateInstance(t) as IManipulator;
        } catch { }
        if (instance != null) Operators.Add(instance);
      }
      for (int i = 0; i < Operators.Count; i++) {
        if (Operators[i] is CompoundMutator ||
            Operators[i] is PlantMerger ||
            Operators[i] is PlantSplitter ||
            Operators[i] is PlantMover) {
          // everything is fine
        } else if (Operators[i] is PlantSupplierToggler ||
                   Operators[i] is PlantSupplierUtilizationExchanger ||
                   Operators[i] is PlantSupplierEqualizer ||
                   Operators[i] is PlantSupplierRandomizer ||
                   Operators[i] is PlantScalingMutator) {
          MinGenerationPercentages[i] = 0.5;
        } else if (Operators[i] is EmptyMutator) {
          MinGenerationPercentages[i] = 0.8;
        } else if (Operators[i] is PlantKiller) {
          MinGenerationPercentages[i] = 0.9;
        } else {
          Operators.SetItemCheckedState(Operators[i], false);
        }
      }
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new MultiMutator(this, cloner);
    }

    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      if (!Parameters.ContainsKey("MinGenerationPercentages")) {
        Parameters.Add(new ValueParameter<PercentArray>("MinGenerationPercentages", "Relative number of generations before the respetive mutation becomes active.", new PercentArray(Operators.Count)));
      }
      if (!Parameters.ContainsKey("Generations"))
        Parameters.Add(new LookupParameter<IntValue>("Generations", "Current number of generations/iterations."));
      if (!Parameters.ContainsKey("MaximumGenerations"))
        Parameters.Add(new LookupParameter<IntValue>("MaximumGenerations", "Maximum number of generations/iterations."));
      if (!Parameters.ContainsKey("SeriesLength"))
        Parameters.Add(new ValueLookupParameter<IntValue>("SeriesLength", "The number of manipulations to perform at once", new IntValue(1)));
    }
    #endregion

    protected override void Operators_ItemsAdded(object sender, CollectionItemsChangedEventArgs<IndexedItem<IManipulator>> e) {
      base.Operators_ItemsAdded(sender, e);
      if (MinGenerationPercentages.Length >= Operators.Count) return;
      var added = e.Items.OrderBy(x => x.Index).ToList();
      int insertCount = 0;
      var percentages = new PercentArray(Operators.Count);
      for (int i = 0; i < Operators.Count; i++) {
        if (insertCount < added.Count && i == added[insertCount].Index) {
          percentages[i] = 0;
          insertCount++;
        } else if (i - insertCount < MinGenerationPercentages.Length) {
          percentages[i] = MinGenerationPercentages[i - insertCount];
        } else percentages[i] = 0;
      }
      MinGenerationPercentages = percentages;
    }

    protected override void Operators_ItemsRemoved(object sender, CollectionItemsChangedEventArgs<IndexedItem<IManipulator>> e) {
      base.Operators_ItemsRemoved(sender, e);
      if (MinGenerationPercentages.Length <= Operators.Count) return;
      var percentages = new List<double>(MinGenerationPercentages);
      var sorted = e.Items.OrderByDescending(x => x.Index);
      foreach (var item in sorted)
        if (percentages.Count > item.Index) percentages.RemoveAt(item.Index);
      MinGenerationPercentages = new PercentArray(percentages.ToArray());
    }

    public override IOperation InstrumentedApply() {
      if (Operators.Count == 0) throw new InvalidOperationException(Name + ": Please add at least one manipulator to choose from.");
      if (MaxGenerationsParameter.ActualValue == null || GenerationsParameter.ActualValue == null || MinGenerationPercentages.Max() == 0)
        return base.InstrumentedApply();
      DoubleArray probability = null;
      try {
        var generationPercentage = 1.0 * GenerationsParameter.ActualValue.Value / MaxGenerationsParameter.ActualValue.Value;
        for (int i = 0; i < Probabilities.Length; i++) {
          if (MinGenerationPercentages[i] > generationPercentage) {
            if (probability == null) probability = (DoubleArray)Probabilities.Clone(); // backup old probabilities
            Probabilities[i] = 0;
          }
        }
        if (SeriesLength == 1) {
          return base.InstrumentedApply();
        } else {
          var operations = new OperationCollection();
          for (var i = 0; i < SeriesLength; i++) {
            operations.Add(base.InstrumentedApply());
          }
          return operations;
        }
      } finally {
        // restore old probabilities
        if (probability != null)
          Probabilities = probability;
      }
    }
  }
}