Changeset 10850 for branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures

Timestamp:

05/14/14 14:46:00 (11 years ago)

Author:

abeham

Message:

#2174: Major refactoring:

• ParameterVector is only a temporary datastructure that is constructed for evaluation purposes only
• Multiple permutations are allowed
• Special support for single-vector encodings (to apply specialized algorithms such as PSO or CMA-ES)
• General support for multi-vector encoding

Location:

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures

Files:

• . (added)
• BinaryParameterConfiguration.cs (added)
• Configuration.cs (added)
• IntegerParameterConfiguration.cs (added)
• ParameterConfiguration.cs (added)
• ParameterVector.cs (copied) (copied from branches/SimSharp/HeuristicLab.Encodings.ParameterVector/ParameterVector.cs) (1 diff)
• PermutationParameterConfiguration.cs (added)
• RealParameterConfiguration.cs (added)

branches/SimSharp/HeuristicLab.Problems.Programmable/3.3/Datastructures/ParameterVector.cs

@@ -20 +20 @@
 #endregion
 
-using System;
 using System.Collections.Generic;
-using HeuristicLab.Collections;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Data;
+using System.Linq;
 using HeuristicLab.Encodings.BinaryVectorEncoding;
 using HeuristicLab.Encodings.IntegerVectorEncoding;
 using HeuristicLab.Encodings.PermutationEncoding;
 using HeuristicLab.Encodings.RealVectorEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
-namespace HeuristicLab.Encodings.ParameterVectorEncoding {
-  [Item("ParameterVector", "Encodes a range of parameters of different types.")]
-  [StorableClass]
-  public class ParameterVector : Item {
-    private bool isFeasible;
-    [Storable]
-    public bool IsFeasible {
-      get { return isFeasible; }
-      set {
-        if (isFeasible == value) return;
-        isFeasible = value;
-        OnIsFeasibleChanged();
-      }
+namespace HeuristicLab.Problems.Programmable {
+  public class ParameterVector {
+    protected Dictionary<string, BinaryVector> BinaryParameters;
+    protected Dictionary<string, IntegerVector> IntegerParameters;
+    protected Dictionary<string, RealVector> RealParameters;
+    protected Dictionary<string, Permutation> PermutationParameters;
+
+    public ParameterVector(IEnumerable<KeyValuePair<string, BinaryVector>> binaryVectors = null,
+      IEnumerable<KeyValuePair<string, IntegerVector>> integerVectors = null,
+      IEnumerable<KeyValuePair<string, RealVector>> realVectors = null,
+      IEnumerable<KeyValuePair<string, Permutation>> permutations = null) {
+      if (binaryVectors != null) BinaryParameters = binaryVectors.ToDictionary(x => x.Key, x => x.Value);
+      if (integerVectors != null) IntegerParameters = integerVectors.ToDictionary(x => x.Key, x => x.Value);
+      if (realVectors != null) RealParameters = realVectors.ToDictionary(x => x.Key, x => x.Value);
+      if (permutations != null) PermutationParameters = permutations.ToDictionary(x => x.Key, x => x.Value);
     }
 
-    [Storable]
-    public BinaryVector BooleanParameters { get; set; }
-    [Storable]
-    public IntegerVector IntegerParameters { get; set; }
-    [Storable]
-    public RealVector RealParameters { get; set; }
-    [Storable]
-    public Permutation PermutationParameter { get; set; }
-
-    [Storable]
-    protected BidirectionalDictionary<string, int> BoolMap;
-    [Storable]
-    protected BidirectionalDictionary<string, int> IntMap;
-    [Storable]
-    protected BidirectionalDictionary<string, int> RealMap;
-
-    [Storable]
-    public IntMatrix IntegerBounds { get; set; }
-    [Storable]
-    public DoubleMatrix RealBounds { get; set; }
-
-    [StorableConstructor]
-    protected ParameterVector(bool deserializing) : base(deserializing) { }
-    protected ParameterVector(ParameterVector original, Cloner cloner)
-      : base(original, cloner) {
-      IsFeasible = original.IsFeasible;
-      if (original.BooleanParameters != null) {
-        BooleanParameters = cloner.Clone(original.BooleanParameters);
-        BoolMap = new BidirectionalDictionary<string, int>(original.BoolMap);
-      }
-      if (original.IntegerParameters != null) {
-        IntegerParameters = cloner.Clone(original.IntegerParameters);
-        IntMap = new BidirectionalDictionary<string, int>(original.IntMap);
-        IntegerBounds = cloner.Clone(original.IntegerBounds);
-      }
-      if (original.RealParameters != null) {
-        RealParameters = cloner.Clone(original.RealParameters);
-        RealMap = new BidirectionalDictionary<string, int>(original.RealMap);
-        RealBounds = cloner.Clone(original.RealBounds);
-      }
-      PermutationParameter = cloner.Clone(original.PermutationParameter);
-    }
-    public ParameterVector() {
-
+    public BinaryVector Binary(string name) {
+      return BinaryParameters[name];
     }
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new ParameterVector(this, cloner);
+    public bool Binary(string name, int index) {
+      return BinaryParameters[name][index];
     }
 
-    public bool Boolean(string name) {
-      return BooleanParameters[BoolMap.GetByFirst(name)];
+    public IEnumerable<string> BinaryNames {
+      get { return BinaryParameters.Keys; }
     }
 
-    public bool Boolean(int index) {
-      return BooleanParameters[index];
+    public IntegerVector Integer(string name) {
+      return IntegerParameters[name];
     }
 
-    public IEnumerable<string> BooleanParameterNames {
-      get {
-        for (int i = 0; i < BooleanParameters.Length; i++)
-          yield return BoolMap.GetBySecond(i);
-      }
+    public int Integer(string name, int index) {
+      return IntegerParameters[name][index];
     }
 
-    public int Integer(string name) {
-      return IntegerParameters[IntMap.GetByFirst(name)];
+    public IEnumerable<string> IntegerNames {
+      get { return IntegerParameters.Keys; }
     }
 
-    public int Integer(int index) {
-      return IntegerParameters[index];
+    public RealVector Real(string name) {
+      return RealParameters[name];
     }
 
-    public IEnumerable<string> IntegerParameterNames {
-      get {
-        for (int i = 0; i < IntegerParameters.Length; i++)
-          yield return IntMap.GetBySecond(i);
-      }
+    public double Real(string name, int index) {
+      return RealParameters[name][index];
     }
 
-    public double Real(string name) {
-      return RealParameters[RealMap.GetByFirst(name)];
+    public IEnumerable<string> RealNames {
+      get { return RealParameters.Keys; }
     }
 
-    public double Real(int index) {
-      return RealParameters[index];
+    public Permutation Permutation(string name) {
+      return PermutationParameters[name];
     }
 
-    public IEnumerable<string> RealParameterNames {
-      get {
-        for (int i = 0; i < RealParameters.Length; i++)
-          yield return RealMap.GetBySecond(i);
-      }
+    public IEnumerable<string> PermutationNames {
+      get { return PermutationParameters.Keys; }
     }
-
-    public Permutation Permutation() {
-      return PermutationParameter;
-    }
-
-    public event EventHandler IsFeasibleChanged;
-    protected virtual void OnIsFeasibleChanged() {
-      var handler = IsFeasibleChanged;
-      if (handler != null) handler(this, EventArgs.Empty);
-    }
-
-    #region Internal Methods for the Builder
-    internal void SetBooleanParameters(HashSet<string> bools = null) {
-      if (bools == null) {
-        BooleanParameters = null;
-        BoolMap = null;
-      } else {
-        BooleanParameters = new BinaryVector(bools.Count);
-        BoolMap = new BidirectionalDictionary<string, int>();
-        foreach (var p in bools) {
-          BoolMap.Add(p, BoolMap.Count);
-        }
-      }
-    }
-
-    internal void SetIntegerParameters(Dictionary<string, Tuple<int, int, int?>> ints = null) {
-      if (ints == null) {
-        IntegerParameters = null;
-        IntMap = null;
-        IntegerBounds = null;
-      } else {
-        IntegerParameters = new IntegerVector(ints.Count);
-        IntMap = new BidirectionalDictionary<string, int>();
-        IntegerBounds = new IntMatrix(ints.Count, 3);
-        var i = 0;
-        foreach (var p in ints) {
-          IntegerBounds[i, 0] = p.Value.Item1;
-          IntegerBounds[i, 1] = p.Value.Item2;
-          IntegerBounds[i, 2] = p.Value.Item3 ?? 1;
-          IntegerParameters[i] = p.Value.Item1; // default to min
-          IntMap.Add(p.Key, i++);
-        }
-      }
-    }
-
-    internal void SetRealParameters(Dictionary<string, Tuple<double, double>> reals = null) {
-      if (reals == null) {
-        RealParameters = null;
-        RealMap = null;
-        RealBounds = null;
-      } else {
-        RealParameters = new RealVector(reals.Count);
-        RealMap = new BidirectionalDictionary<string, int>();
-        RealBounds = new DoubleMatrix(reals.Count, 2);
-        var i = 0;
-        foreach (var p in reals) {
-          RealBounds[i, 0] = p.Value.Item1;
-          RealBounds[i, 1] = p.Value.Item2;
-          RealParameters[i] = p.Value.Item1; // default to min
-          RealMap.Add(p.Key, i++);
-        }
-      }
-    }
-
-    internal void SetPermutationParameters(Tuple<PermutationTypes, int> perms = null) {
-      if (perms == null) PermutationParameter = null;
-      else PermutationParameter = new Permutation(perms.Item1, perms.Item2);
-    }
-    #endregion
   }
 }