Changeset 4830 for branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings

Timestamp:

11/18/10 00:53:15 (14 years ago)

Author:

cneumuel

Message:

#1215 worked on metaoptimization

Location:

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings

Files:

• BooleanParameterConfiguration.cs (deleted)
• Crossovers/ParameterSetCrossover.cs (deleted)
• Crossovers/ParameterVectorCrossover.cs (added)
• EnumerableParameterConfiguration.cs (deleted)
• IntValueParameterConfiguration.cs (added)
• NumericParameterConfiguration.cs (deleted)
• ParameterConfiguration.cs (modified) (1 diff)
• ParameterConfigurationList.cs (deleted)
• ParameterSet.cs (deleted)
• RootParameterConfiguration.cs (added)
• ValueTypeParameterConfiguration.cs (added)

branches/HeuristicLab.MetaOptimization/HeuristicLab.Problems.MetaOptimization/3.3/Encodings/ParameterConfiguration.cs

@@ -6 +6 @@
 using HeuristicLab.Common;
 using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 
 namespace HeuristicLab.Problems.MetaOptimization {
   [StorableClass]
-  public abstract class ParameterConfiguration : IParameterConfiguration {
-    [Storable]
-    public IParameter Parameter { get; set; }
-
-    [Storable]
-    public string Category { get; set; }
+  public class ParameterConfiguration : DeepCloneable, IParameterConfiguration, IStorableContent {
+    protected ParameterConfiguration parentConfiguration;
+
+    [Storable]
+    public string Filename { get; set; }
+
+    [Storable]
+    protected bool optimizationEnabled;
+    public bool OptimizationEnabled {
+      get { return optimizationEnabled; }
+      set {
+        if (optimizationEnabled != value) {
+          optimizationEnabled = value;
+          OnOptimizationEnabledChanged();
+        }
+      }
+    }
+
+    [Storable]
+    protected string parameterName;
+    public string ParameterName {
+      get { return parameterName; }
+      set {
+        if (parameterName != value) {
+          parameterName = value;
+        }
+      }
+    }
+
+    [Storable]
+    protected IItemList<IParameterConfiguration> childParameterConfigurations = new ItemList<IParameterConfiguration>();
+    public IItemList<IParameterConfiguration> ChildParameterConfigurations {
+      get { return childParameterConfigurations; }
+    }
+
+    public virtual IParameter Parameter {
+      get {
+        return parentConfiguration.GetChildParameter(this.parameterName);
+      }
+    }
+
+    protected IItem value;
+    public IItem Value {
+      get { return value; }
+      set {
+        if (this.value != value) {
+          ClearChildParameterConfigurations();
+          OnValueChanging();
+          this.value = value;
+          if(this.value is IParameterizedNamedItem) AddChildParameterConfigurations(this.value as IParameterizedNamedItem);
+          OnValueChanged();
+        }
+      }
+    }
+
+    public ParameterConfiguration(ParameterConfiguration parentConfiguration, string parameterName, IItem value) {
+      this.parentConfiguration = parentConfiguration;
+      this.ParameterName = parameterName;
+      this.Value = value;
+    }
 
     public ParameterConfiguration() { }
-    
     [StorableConstructor]
     protected ParameterConfiguration(bool deserializing) { }
-
-    public ParameterConfiguration(IParameter parameter, string category) {
-      this.Parameter = parameter;
-      this.Category = category;
-      Parameter.NameChanged += this.NameChanged;
-      Parameter.NameChanging += this.NameChanging;
-      Parameter.DescriptionChanged += this.DescriptionChanged;
-      Parameter.ItemImageChanged += this.ItemImageChanged;
-      parameter.ToStringChanged += this.ToStringChanged;
-    }
-
-    public bool CanChangeDescription {
-      get { return false; }
-    }
-
-    public bool CanChangeName {
-      get { return false; }
-    }
-
-    public string Description {
+    protected ParameterConfiguration(ParameterConfiguration original, Cloner cloner)
+      : base(original, cloner) {
+      this.OptimizationEnabled = original.optimizationEnabled;
+      this.ParameterName = original.parameterName;
+      this.Value = cloner.Clone(original.Value);
+      this.childParameterConfigurations = cloner.Clone(original.childParameterConfigurations);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new ParameterConfiguration(this, cloner);
+    }
+
+    protected virtual IValueParameter GetChildParameter(string childParameterName) {
+      return (IValueParameter)((IParameterizedItem)Value).Parameters[childParameterName];
+    }
+
+    protected virtual void AddChildParameterConfigurations(IParameterizedNamedItem parameterizedItem) {
+      foreach (var childParameter in parameterizedItem.Parameters) {
+        var pc = ParameterConfiguration.Create(this, parameterizedItem, childParameter);
+        if (pc != null) this.childParameterConfigurations.Add(pc);
+      }
+    }
+    protected virtual void ClearChildParameterConfigurations() {
+      childParameterConfigurations.Clear();
+    }
+
+    #region INamedItem Properties
+    public virtual string Name {
+      get { return Parameter.Name; }
+      set { throw new NotSupportedException(); }
+    }
+    public virtual string Description {
       get { return Parameter.Description; }
       set { throw new NotSupportedException(); }
     }
-    public string Name {
-      get { return Parameter.Name; }
-      set { throw new NotSupportedException(); }
-    }
-
-    public string ItemDescription {
+    public virtual bool CanChangeDescription {
+      get { return false; }
+    }
+    public virtual bool CanChangeName {
+      get { return false; }
+    }
+    public virtual string ItemDescription {
       get { return Parameter.ItemDescription; }
     }
-
-    public System.Drawing.Image ItemImage {
+    public virtual System.Drawing.Image ItemImage {
       get { return Parameter.ItemImage; }
     }
-
-    public string ItemName {
+    public virtual string ItemName {
       get { return Parameter.ItemName; }
     }
-
-    public Version ItemVersion {
+    public virtual Version ItemVersion {
       get { return Parameter.ItemVersion; }
     }
+    #endregion
 
     #region Events
     public virtual event EventHandler NameChanged;
+    protected virtual void OnNameChanged(object sender, EventArgs e) {
+      var handler = NameChanged;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler<CancelEventArgs<string>> NameChanging;
+    protected virtual void OnNameChanging(object sender, CancelEventArgs<string> e) {
+      var handler = NameChanging;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler DescriptionChanged;
+    protected virtual void OnDescriptionChanged(object sender, EventArgs e) {
+      var handler = DescriptionChanged;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler ItemImageChanged;
+    protected virtual void OnItemImageChanged(object sender, EventArgs e) {
+      var handler = ItemImageChanged;
+      if (handler != null) handler(sender, e);
+    }
+
     public virtual event EventHandler ToStringChanged;
-
-    protected virtual void OnToStringChanged() {
+    protected virtual void OnStringChanged(object sender, EventArgs e) {
       var handler = ToStringChanged;
+      if (handler != null) handler(this, e); // important to set 'this' as sender
+    }
+
+    public virtual event EventHandler OptimizationEnabledChanged;
+    protected virtual void OnOptimizationEnabledChanged() {
+      var handler = OptimizationEnabledChanged;
       if (handler != null) handler(this, EventArgs.Empty);
     }
+
+    public virtual event EventHandler ValueChanging;
+    protected virtual void OnValueChanging() {
+      var handler = ValueChanging;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
+
+    public virtual event EventHandler ValueChanged;
+    protected virtual void OnValueChanged() {
+      var handler = ValueChanged;
+      if (handler != null) handler(this, EventArgs.Empty);
+    }
     #endregion
 
-    #region Cloning
-    public virtual IDeepCloneable Clone(Cloner cloner) {
-      ParameterConfiguration clone = (ParameterConfiguration)Activator.CreateInstance(this.GetType(), true);
-      cloner.RegisterClonedObject(this, clone);
-      clone.Parameter = (IParameter)cloner.Clone(this.Parameter);
-      clone.Category = this.Category;
-      return clone;
-    }
-
-    public object Clone() {
-      return Clone(new Cloner());
-    }
-    #endregion
-
     public override string ToString() {
-      return string.Format("{0}.{1}", Category, Parameter.Name);
-    }
-    
-    public abstract void SetParameterWithRandomValue(IRandom random);
+      return string.Format("{0} ({1})", ParameterName, Value);
+    }
+
+    public static IParameterConfiguration Create(IParameterizedNamedItem parent) {
+      return new RootParameterConfiguration(parent);
+    }
+
+    public static IParameterConfiguration Create(ParameterConfiguration parentConfiguration, IParameterizedNamedItem parent, IParameter parameter) {
+      if (parameter is IValueParameter) {
+        IValueParameter valueParameter = parameter as IValueParameter;
+
+        if (typeof(IntValue).IsAssignableFrom(parameter.DataType)) {
+          return new IntValueParameterConfiguration(parentConfiguration, parameter.Name, valueParameter.Value);
+        } else if (typeof(IParameterizedItem).IsAssignableFrom(parameter.DataType)) {
+          return new ParameterConfiguration(parentConfiguration, parameter.Name, valueParameter.Value);
+        } else {
+          // todo
+          return new IntValueParameterConfiguration(parentConfiguration, parameter.Name, valueParameter.Value);
+        }
+      }
+      return null;
+    }
+
+    public void Parameterize(IParameterizedItem parameterizedItem) {
+      throw new NotImplementedException();
+    }
 
   }