source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encoding/ValueConfigurations/ValueConfiguration.cs @ 5522

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Data;
using System.Drawing;
using HeuristicLab.Encodings.RealVectorEncoding;
using HeuristicLab.Encodings.IntegerVectorEncoding;
using HeuristicLab.PluginInfrastructure;
using System.Collections.Generic;
using System.Text;

namespace HeuristicLab.Problems.MetaOptimization {
  // TODO: ItemName/Descr, storability
  [StorableClass]
  public class ValueConfiguration : NamedItem, IValueConfiguration {
    public override bool CanChangeName {
      get { return true; }
    }

    public override bool CanChangeDescription {
      get { return true; }
    }

    [Storable]
    protected bool isOptimizable;
    public bool IsOptimizable {
      get { return isOptimizable; }
      set {
        if (this.isOptimizable != value) {
          this.isOptimizable = value;
          OnIsOptimizableChanged();
        }
      }
    }

    [Storable]
    protected bool optimize;
    public bool Optimize {
      get { return optimize; }
      set {
        if (optimize != value) {
          optimize = value;
          if (optimize) {
            ClearParameterConfigurations();
            if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem);
          } else {
            ClearParameterConfigurations();
          }
          OnOptimizeChanged();
          OnToStringChanged();
        }
      }
    }

    [Storable]
    protected IItemCollection<IParameterConfiguration> parameterConfigurations = new ItemCollection<IParameterConfiguration>();
    public IItemCollection<IParameterConfiguration> ParameterConfigurations {
      get { return new ReadOnlyItemCollection<IParameterConfiguration>(this.parameterConfigurations); }
      protected set { this.parameterConfigurations = value; }
    }

    [Storable]
    protected ConstrainedValue actualValue;
    public virtual ConstrainedValue ActualValue {
      get { return actualValue; }
      set {
        if (this.actualValue != value) {
          DeregisterActualValueEvents();
          ClearParameterConfigurations();
          this.actualValue = value;
          if (this.actualValue.Value is IParameterizedNamedItem) PopulateParameterConfigurations(this.actualValue.Value as IParameterizedNamedItem);
          OnValueChanged();
          OnToStringChanged();
          RegisterActualValueEvents();
        }
      }
    }

    [Storable]
    protected IRange rangeConstraint;
    public IRange RangeConstraint {
      get { return rangeConstraint; }
      private set {
        if (rangeConstraint != value) {
          DeregisterRangeConstraintEvents();
          rangeConstraint = value;
          RegisterActualValueEvents();
        }
      }
    }

    [Storable]
    protected int number = 0;
    public int Number {
      get { return number; }
      set {
        if (value != number) {
          number = value;
          OnToStringChanged();
        }
      }
    }

    #region Constructors and Cloning
    public ValueConfiguration(IItem value, Type valueDataType) {
      this.ParameterConfigurations = new ItemList<IParameterConfiguration>();
      var validTypes = ApplicationManager.Manager.GetTypes(valueDataType).OrderBy(x => x.Name).ToArray();
      this.ActualValue = new ConstrainedValue(value, valueDataType, new ItemSet<IItem> { value }, false);
      this.IsOptimizable = true;
      if (actualValue.ValueDataType == typeof(IntValue)) {
        RangeConstraint = new IntValueRange(new IntValue(0), (IntValue)value, new IntValue(1));
      } else if (actualValue.ValueDataType == typeof(DoubleValue)) {
        RangeConstraint = new DoubleValueRange(new DoubleValue(0), (DoubleValue)value, new DoubleValue(0.01));
      } else if (actualValue.ValueDataType == typeof(PercentValue)) {
        RangeConstraint = new PercentValueRange(new PercentValue(0), new PercentValue(1), new PercentValue(0.01));
      } else if (actualValue.ValueDataType == typeof(BoolValue)) {
        this.IsOptimizable = false; // there is nothing to configure for bools
      } else {
        RangeConstraint = null;
      }
    }

    public ValueConfiguration() { }
    [StorableConstructor]
    protected ValueConfiguration(bool deserializing) { }
    protected ValueConfiguration(ValueConfiguration original, Cloner cloner)
      : base(original, cloner) {
      this.ParameterConfigurations = cloner.Clone(original.parameterConfigurations);
      this.actualValue = cloner.Clone(original.ActualValue);
      this.rangeConstraint = cloner.Clone(original.RangeConstraint);
      this.isOptimizable = original.isOptimizable;
      this.optimize = original.optimize;
      this.number = original.number;
      RegisterActualValueEvents();
      RegisterRangeConstraintEvents();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ValueConfiguration(this, cloner);
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterRangeConstraintEvents();
    }
    #endregion

    protected virtual void PopulateParameterConfigurations(IParameterizedNamedItem parameterizedItem) {
      foreach (var childParameter in parameterizedItem.Parameters) {
        var pc = ParameterConfiguration.Create(parameterizedItem, childParameter);
        if (pc != null) this.parameterConfigurations.Add(pc);
      }
    }
    protected virtual void ClearParameterConfigurations() {
      parameterConfigurations.Clear();
    }

    private void RegisterRangeConstraintEvents() {
      if (this.RangeConstraint != null) this.RangeConstraint.ToStringChanged += new EventHandler(RangeConstraint_ToStringChanged);
    }
    private void DeregisterRangeConstraintEvents() {
      if (this.RangeConstraint != null) this.RangeConstraint.ToStringChanged -= new EventHandler(RangeConstraint_ToStringChanged);
    }
    private void RegisterActualValueEvents() {
      if (this.actualValue != null) this.actualValue.ToStringChanged += new EventHandler(actualValue_ToStringChanged);
    }
    private void DeregisterActualValueEvents() {
      if (this.actualValue != null) this.actualValue.ToStringChanged -= new EventHandler(actualValue_ToStringChanged);
    }

    #region Events
    void actualValue_ToStringChanged(object sender, EventArgs e) {
      OnToStringChanged();
    }
    void RangeConstraint_ToStringChanged(object sender, EventArgs e) {
      OnToStringChanged();
    }
    #endregion

    #region IItem Members
    public override string ItemDescription {
      get { return (actualValue != null && actualValue.Value != null) ? actualValue.Value.ItemDescription : base.ItemDescription; }
    }

    public override Image ItemImage {
      get { return (actualValue != null && actualValue.Value != null) ? actualValue.Value.ItemImage : base.ItemImage; }
    }

    public override string ItemName {
      get { return (actualValue != null && actualValue.Value != null) ? actualValue.Value.ItemDescription : base.ItemName; }
    }
    #endregion

    #region Event Handlers
    public virtual event EventHandler ValueChanged;
    protected virtual void OnValueChanged() {
      var handler = ValueChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public virtual event EventHandler IsOptimizableChanged;
    private void OnIsOptimizableChanged() {
      var handler = IsOptimizableChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }

    public virtual event EventHandler OptimizeChanged;
    protected virtual void OnOptimizeChanged() {
      var handler = OptimizeChanged;
      if (handler != null) handler(this, EventArgs.Empty);
    }
    #endregion

    public override string ToString() {
      if (ActualValue != null && ActualValue.Value != null) {
        string name = NumberedName;

        if (ActualValue.Value is IParameterizedItem) {
          if (Optimize) {
            return string.Format("{0} (Optimize)", name);
          } else {
            return string.Format("{0}", name);
          }
        } else {
          if (Optimize) {
            return string.Format("{0} (Optimize: {1})", name, RangeConstraint);
          } else {
            return string.Format("{0}: {1}", name, ActualValue.Value);
          }
        }
      } else {
        return base.ToString();
      }
    }

    public string NumberedName {
      get {
        if (this.number == 0) {
          return (ActualValue != null && ActualValue.Value != null) ? ActualValue.Value.ItemName : base.ToString();
        } else {
          return string.Format("{0} {1}", ActualValue.Value.ItemName, number);
        }
      }
    }

    public string ParameterInfoString {
      get {
        StringBuilder sb = new StringBuilder();
        if (this.Optimize && this.ParameterConfigurations.Count > 0) {
          var parameterInfos = new List<string>();
          foreach (var pc in this.ParameterConfigurations) {
            if (pc.Optimize) parameterInfos.Add(pc.ParameterInfoString);
          }
          sb.Append(string.Join(", ", parameterInfos.ToArray()));
        }
        return sb.ToString();
      }
    }

    public virtual void Parameterize(IParameterizedItem item) {
      foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
        pc.Parameterize((IValueParameter)item.Parameters[pc.ParameterName]);
      }
    }

    public void Randomize(IRandom random) {
      if (Optimize) {
        if (rangeConstraint != null) {
          this.actualValue.Value = rangeConstraint.GetRandomValue(random);
        } else {
          foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
            pc.Randomize(random);
          }
        }
      }
    }

    public void Mutate(IRandom random, MutateDelegate mutate, IIntValueManipulator intValueManipulator, IDoubleValueManipulator doubleValueManipulator) {
      if (Optimize) {
        if (rangeConstraint != null) {
          mutate(random, this, intValueManipulator, doubleValueManipulator);
        } else {
          foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
            pc.Mutate(random, mutate, intValueManipulator, doubleValueManipulator);
          }
        }
      }
    }

    public void Cross(IRandom random, IOptimizable other, CrossDelegate cross, IIntValueCrossover intValueCrossover, IDoubleValueCrossover doubleValueCrossover) {
      if (Optimize) {
        if (rangeConstraint != null) {
          cross(random, this, other, intValueCrossover, doubleValueCrossover);
        } else {
          IValueConfiguration otherVc = (IValueConfiguration)other;
          for (int i = 0; i < this.ParameterConfigurations.Count; i++) {
            this.ParameterConfigurations.ElementAt(i).Cross(random, otherVc.ParameterConfigurations.ElementAt(i), cross, intValueCrossover, doubleValueCrossover);
          }
        }
      }
    }

    public List<IOptimizable> GetAllOptimizables() {
      var list = new List<IOptimizable>();
      foreach (var pc in ParameterConfigurations) {
        if (pc.Optimize) {
          if (pc.ValueConfigurations.CheckedItems.Count() > 1) list.Add(pc); // only add if there are more than 1 choices. otherwise it makes no sense to optimize which VC is selected
          list.AddRange(pc.GetAllOptimizables());
        }
      }
      return list;
    }

    public void CollectOptimizedParameterNames(List<string> parameterNames, string prefix) {
      foreach (var pc in ParameterConfigurations) {
        if (pc.Optimize) {
          parameterNames.Add(prefix + pc.ParameterName);
          pc.CollectOptimizedParameterNames(parameterNames, prefix + pc.ParameterName + ".");
        }
      }
    }

    public IEnumerable<string> GetOptimizedParameterNames() {
      var list = new List<string>();
      this.CollectOptimizedParameterNames(list, "");
      return list;
    }

    public double CalculateSimilarity(IOptimizable optimizable) {
      var other = (IValueConfiguration)optimizable;
      if (rangeConstraint != null) {
        return this.RangeConstraint.CalculateSimilarity(this.ActualValue.Value, other.ActualValue.Value);
      } else {
        double sum = 0;
        int count = 0;
        for (int i = 0; i < ParameterConfigurations.Count; i++) {
          if (this.ParameterConfigurations.ElementAt(i).Optimize) {
            sum += this.ParameterConfigurations.ElementAt(i).CalculateSimilarity(other.ParameterConfigurations.ElementAt(i));
            count++;
          }
        }
        return count == 0 ? 1.0 : sum / (double)count;
      }
    }
  }
}