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

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;

namespace HeuristicLab.Problems.MetaOptimization {
  // TODO: ItemName/Descr, storability
  [StorableClass]
  public class ValueConfiguration : Item, IValueConfiguration {
    [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();
            PopulateParameterConfigurations();
          } 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 ConstrainedValue ActualValue {
      get { return actualValue; }
      set {
        if (this.actualValue != value) {
          ClearParameterConfigurations();
          this.actualValue = value;
          PopulateParameterConfigurations();
          OnValueChanged();
          OnToStringChanged();
        }
      }
    }

    [Storable]
    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);
    }
    [StorableHook(HookType.AfterDeserialization)]
    private void AfterDeserialization() {
      RegisterEvents();
    }
    #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(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) {
      if (Optimize) {
        if (rangeConstraint != null) {
          if (random.NextDouble() > 0.5)
            this.actualValue.Value = rangeConstraint.GetRandomValue(random);
        } else {
          foreach (IParameterConfiguration pc in this.ParameterConfigurations) {
            pc.Mutate(random);
          }
        }
      }
    }

    public void Cross(IOptimizable other, IRandom random) {
      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);

            IntegerVector[] parents = new IntegerVector[2];
            parents[0] = new IntegerVector(new int[] { ((IntValue)this.actualValue.Value).Value });
            parents[1] = new IntegerVector(new int[] { ((IntValue)other.ActualValue.Value).Value });

            this.actualValue.Value = new IntValue(HeuristicLab.Encodings.IntegerVectorEncoding.DiscreteCrossover.Apply(random, parents[0], parents[1]).First());

          } else if (this.actualValue.ValueDataType == typeof(DoubleValue)) {
            //this.actualValue.Value = new DoubleValue((((DoubleValue)this.actualValue.Value).Value + ((DoubleValue)other.ActualValue.Value).Value) / 2);
            RealVector[] parents = new RealVector[2];
            parents[0] = new RealVector( new double[] {((DoubleValue)this.actualValue.Value).Value} );
            parents[1] = new RealVector( new double[] {((DoubleValue)other.ActualValue.Value).Value} );

            if (random.NextDouble() < 0.5) {
              this.actualValue.Value = new DoubleValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
            } else {
              this.actualValue.Value = new DoubleValue(HeuristicLab.Encodings.RealVectorEncoding.DiscreteCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
            }
            //this.actualValue.Value = new DoubleValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
            
          } else if (this.actualValue.ValueDataType == typeof(PercentValue)) {
            //this.actualValue.Value = new PercentValue((((PercentValue)this.actualValue.Value).Value + ((PercentValue)other.ActualValue.Value).Value) / 2);

            RealVector[] parents = new RealVector[2];
            parents[0] = new RealVector(new double[] { ((PercentValue)this.actualValue.Value).Value });
            parents[1] = new RealVector(new double[] { ((PercentValue)other.ActualValue.Value).Value });

            if (random.NextDouble() < 0.5) {
              this.actualValue.Value = new PercentValue(AverageCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
            } else {
              this.actualValue.Value = new PercentValue(HeuristicLab.Encodings.RealVectorEncoding.DiscreteCrossover.Apply(random, new ItemArray<RealVector>(parents)).First());
            }

          } else if (this.actualValue.ValueDataType == typeof(BoolValue)) {
            if (random.NextDouble() > 0.5)
              this.actualValue.Value = this.actualValue.Value;
            else
              this.actualValue.Value = other.ActualValue.Value;
          } else {
            throw new NotImplementedException();
          }
        } else {
          for (int i = 0; i < this.ParameterConfigurations.Count; i++) {
            this.ParameterConfigurations.ElementAt(i).Cross(otherVc.ParameterConfigurations.ElementAt(i), random);
          }
        }
      }
    }
  }
}