source: branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ValueConfigurations/ValueConfiguration.cs @ 4997

using System;
using System.Linq;
using HeuristicLab.Common;
using HeuristicLab.Core;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
using HeuristicLab.Data;
using System.Drawing;

namespace HeuristicLab.Problems.MetaOptimization {
  // TODO: ItemName/Descr, storability
  public class ValueConfiguration : Item, IValueConfiguration {
    protected bool isOptimizable;
    public bool IsOptimizable {
      get { return isOptimizable; }
      set {
        if (this.isOptimizable != value) {
          this.isOptimizable = value;
          OnIsOptimizableChanged();
        }
      }
    }

    protected bool optimize;
    public bool Optimize {
      get { return optimize; }
      set {
        if (optimize != value) {
          optimize = value;
          if (optimize) {
            ClearParameterConfigurations();
            PopulateParameterConfigurations();
          } else {
            ClearParameterConfigurations();
          }
          OnOptimizeChanged();
          OnToStringChanged();
        }
      }
    }

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

    protected ConstrainedValue actualValue;
    public ConstrainedValue ActualValue {
      get { return actualValue; }
      set {
        if (this.actualValue != value) {
          ClearParameterConfigurations();
          this.actualValue = value;
          PopulateParameterConfigurations();
          OnValueChanged();
          OnToStringChanged();
        }
      }
    }

    protected IRange rangeConstraint;
    public IRange RangeConstraint {
      get { return rangeConstraint; }
    }

    #region Constructors and Cloning
    public ValueConfiguration(IItem value, Type valueDataType) {
      this.ParameterConfigurations = new ItemList<IParameterConfiguration>();
      this.ActualValue = new ConstrainedValue(value, valueDataType);
      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.001));
      } else if (actualValue.ValueDataType == typeof(BoolValue)) {
        this.IsOptimizable = false; // there is nothing to configure for bools
      } else {
        rangeConstraint = null;
      }
      RegisterEvents();
    }

    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;
      RegisterEvents();
    }
    public override IDeepCloneable Clone(Cloner cloner) {
      return new ValueConfiguration(this, cloner);
    }
    #endregion

    protected virtual void PopulateParameterConfigurations() {
      if (this.actualValue.Value is IParameterizedNamedItem) {
        var parameterizedItem = this.actualValue.Value as IParameterizedNamedItem;
        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 RegisterEvents() {
      if (this.RangeConstraint != null) this.RangeConstraint.ToStringChanged += new EventHandler(RangeConstraint_ToStringChanged);
      if (this.ActualValue != null) this.ActualValue.ToStringChanged += new EventHandler(ConstrainedValue_ToStringChanged);
    }
    private void DeregisterEvents() {
      if (this.RangeConstraint != null) this.RangeConstraint.ToStringChanged += new EventHandler(RangeConstraint_ToStringChanged);
      if (this.ActualValue != null) this.ActualValue.ToStringChanged += new EventHandler(ConstrainedValue_ToStringChanged);
    }

    void ConstrainedValue_ToStringChanged(object sender, EventArgs e) {
      OnToStringChanged();
    }
    void RangeConstraint_ToStringChanged(object sender, EventArgs e) {
      OnToStringChanged();
    }

    #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) {
        if (ActualValue.Value is IParameterizedItem) {
          if (Optimize) {
            return string.Format("{0} (Optimize)", ActualValue.Value.ItemName);
          } else {
            return string.Format("{0}", ActualValue.Value.ItemName);
          }
        } else {
          if (Optimize) {
            return string.Format("{0} (Optimize: {1})", ActualValue.Value.ItemName, RangeConstraint);
          } else {
            return string.Format("{0}: {1}", ActualValue.Value.ItemName, ActualValue.Value);
          }
        }
      } else {
        return base.ToString();
      }
    }
    
    public void Parameterize() {
      foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
        pc.Parameterize();
      }
    }

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

    public void Mutate() {
      if (Optimize) {
        if (rangeConstraint != null) {
          Random rand = new Random(); // todo: use common random
          // mutate every other value. todo: use some kind of mutation operator which is exchangable
          if(rand.NextDouble() > 0.5)
            this.actualValue.Value = rangeConstraint.GetRandomValue();
        } else {
          foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
            pc.Mutate();
          }
        }
      }
    }

    public void Cross(IOptimizable other) {
      if (Optimize) {
        IValueConfiguration otherVc = (IValueConfiguration)other;
        if (rangeConstraint != null) {
          if (this.actualValue.ValueDataType == typeof(IntValue)) {
            this.actualValue.Value = new IntValue((((IntValue)this.actualValue.Value).Value + ((IntValue)other.ActualValue.Value).Value) / 2);
          } else if (this.actualValue.ValueDataType == typeof(DoubleValue)) {
            this.actualValue.Value = new DoubleValue((((DoubleValue)this.actualValue.Value).Value + ((DoubleValue)other.ActualValue.Value).Value) / 2);
          } else if (this.actualValue.ValueDataType == typeof(PercentValue)) {
            this.actualValue.Value = new PercentValue((((PercentValue)this.actualValue.Value).Value + ((PercentValue)other.ActualValue.Value).Value) / 2);
          } else if (this.actualValue.ValueDataType == typeof(BoolValue)) {
            bool first = ((BoolValue)this.actualValue.Value).Value;
            bool second = ((BoolValue)other.ActualValue.Value).Value;
            if (first && second) {
              this.actualValue.Value = new BoolValue(true);
            } else if (!first && !second) {
              this.actualValue.Value = new BoolValue(false);
            } else {
              Random rand = new Random(); // todo: use common random
              if(rand.NextDouble() > 0.5)
                this.actualValue.Value = new BoolValue(true);
              else
                this.actualValue.Value = new BoolValue(false);
            }
          } else {
            throw new NotImplementedException();
          }
        } else {
          for (int i = 0; i < this.ParameterConfigurations.Count; i++) {
            this.ParameterConfigurations.ElementAt(i).Cross(otherVc.ParameterConfigurations.ElementAt(i));
          }
        }
      }
    }
  }
}