Changeset 5712 for branches/DataAnalysis Refactoring

Timestamp:

03/16/11 14:47:32 (14 years ago)

Author:

mkommend

Message:

#1418: Fixed persistence of SymbolicExpressionGrammars.

Location:

branches/DataAnalysis Refactoring

Files:

• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs (modified) (2 diffs)
• HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TupleSerializer.cs (copied) (copied from trunk/sources/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TupleSerializer.cs) (3 diffs)
• HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj (modified) (1 diff)
• HeuristicLab.Persistence/3.3/Tests/UseCases.cs (modified) (1 diff)
• HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs (modified) (3 diffs)

branches/DataAnalysis Refactoring/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/SymbolicExpressionGrammarBase.cs

@@ -51 +51 @@
     [Storable(Name = "AllowedChildSymbols")]
     private IEnumerable<KeyValuePair<ISymbol, IEnumerable<ISymbol>>> StorableAllowedChildSymbols {
-      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(y => GetSymbol(y)))).ToArray(); ; }
+      get { return allowedChildSymbols.Select(x => new KeyValuePair<ISymbol, IEnumerable<ISymbol>>(GetSymbol(x.Key), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
       set { allowedChildSymbols = value.ToDictionary(x => x.Key.Name, x => x.Value.Select(y => y.Name).ToList()); }
     }
@@ -57 +57 @@
     [Storable(Name = "AllowedChildSymbolsPerIndex")]
     private IEnumerable<KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>> StorableAllowedChildSymbolsPerIndex {
-      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)))).ToArray(); }
+      get { return allowedChildSymbolsPerIndex.Select(x => new KeyValuePair<Tuple<ISymbol, int>, IEnumerable<ISymbol>>(Tuple.Create<ISymbol, int>(GetSymbol(x.Key.Item1), x.Key.Item2), x.Value.Select(y => GetSymbol(y)).ToArray())).ToArray(); }
       set { allowedChildSymbolsPerIndex = value.ToDictionary(x => Tuple.Create(x.Key.Item1.Name, x.Key.Item2), x => x.Value.Select(y => y.Name).ToList()); }
     }

branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Default/CompositeSerializers/TupleSerializer.cs

@@ -63 +63 @@
     public IEnumerable<Tag> CreateMetaInfo(object obj) {
       Type t = obj.GetType();
-      for (int i = 1; i<=t.GetGenericArguments().Length; i++) {
+      for (int i = 1; i <= t.GetGenericArguments().Length; i++) {
         string name = string.Format("Item{0}", i);
         yield return new Tag(name, t.GetProperty(name).GetValue(obj, null));
@@ -79 +79 @@
     static TupleSerializer() {
       foreach (MethodInfo mi in typeof(Tuple).GetMethods(public_static).Where(mi => mi.Name == "Create")) {
-        CreateMethods[mi.GetGenericArguments().Length-1] = mi;
+        CreateMethods[mi.GetGenericArguments().Length - 1] = mi;
       }
     }
@@ -85 +85 @@
     public object CreateInstance(Type type, IEnumerable<Tag> metaInfo) {
       var values = metaInfo.Select(t => t.Value).ToArray();
-      MethodInfo createMethod = CreateMethods[values.Length-1].MakeGenericMethod(values.Select(v => v.GetType()).ToArray());
+
+      MethodInfo createMethod = CreateMethods[values.Length - 1].MakeGenericMethod(type.GetGenericArguments());
       return createMethod.Invoke(null, values.ToArray());
     }

branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/HeuristicLab.Persistence-3.3.csproj

@@ -142 +142 @@
     <Compile Include="Default\CompositeSerializers\CompactNumberArray2StringSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\ConcreteDictionarySerializer.cs" />
+    <Compile Include="Default\CompositeSerializers\TupleSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\HashSetSerializer.cs" />
     <Compile Include="Default\CompositeSerializers\DictionarySerializer.cs" />

branches/DataAnalysis Refactoring/HeuristicLab.Persistence/3.3/Tests/UseCases.cs

@@ -1243 +1243 @@
     }
 
+    [TestMethod]
+    public void TupleTest() {
+      var t1 = Tuple.Create(1);
+      var t2 = Tuple.Create('1', "2");
+      var t3 = Tuple.Create(3.0, 3f, 5);
+      var t4 = Tuple.Create(Tuple.Create(1, 2, 3), Tuple.Create(4, 5, 6), Tuple.Create(8, 9, 10));
+      var tuple = Tuple.Create(t1, t2, t3, t4);
+      XmlGenerator.Serialize(tuple, tempFile);
+      var newTuple = XmlParser.Deserialize<Tuple<Tuple<int>, Tuple<char, string>, Tuple<double, float, int>, Tuple<Tuple<int, int, int>, Tuple<int, int, int>, Tuple<int, int, int>>>>(tempFile);
+      Assert.AreEqual(tuple, newTuple);
+    }
+
 
 

branches/DataAnalysis Refactoring/HeuristicLab.Problems.ArtificialAnt/3.4/ArtificialAntProblem.cs

@@ -105 +105 @@
     }
     public IValueParameter<IntValue> MaxExpressionLengthParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxExpressionLength"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumExpressionLength"]; }
     }
     public IValueParameter<IntValue> MaxExpressionDepthParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxExpressionDepth"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumExpressionDepth"]; }
     }
     public IValueParameter<IntValue> MaxFunctionDefinitionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxFunctionDefinitions"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumFunctionDefinitions"]; }
     }
     public IValueParameter<IntValue> MaxFunctionArgumentsParameter {
-      get { return (ValueParameter<IntValue>)Parameters["MaxFunctionArguments"]; }
+      get { return (ValueParameter<IntValue>)Parameters["MaximumFunctionArguments"]; }
     }
     public IValueParameter<BoolMatrix> WorldParameter {
@@ -120 +120 @@
     }
     public IValueParameter<IntValue> MaxTimeStepsParameter {
-      get { return (IValueParameter<IntValue>)Parameters["MaxTimeSteps"]; }
+      get { return (IValueParameter<IntValue>)Parameters["MaximumTimeSteps"]; }
     }
 
@@ -215 +215 @@
       Parameters.Add(new ValueParameter<Evaluator>("Evaluator", "The operator which should be used to evaluate artificial ant solutions.", evaluator));
       Parameters.Add(new ValueParameter<DoubleValue>("BestKnownQuality", "The quality of the best known solution of this artificial ant instance.", new DoubleValue(89)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxExpressionLength", "Maximal length of the expression to control the artificial ant.", new IntValue(100)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxExpressionDepth", "Maximal depth of the expression to control the artificial ant.", new IntValue(10)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionDefinitions", "Maximal number of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
-      Parameters.Add(new ValueParameter<IntValue>("MaxFunctionArguments", "Maximal number of arguments of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumExpressionLength", "Maximal length of the expression to control the artificial ant.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumExpressionDepth", "Maximal depth of the expression to control the artificial ant.", new IntValue(10)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumFunctionDefinitions", "Maximal number of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumFunctionArguments", "Maximal number of arguments of automatically defined functions in the expression to control the artificial ant.", new IntValue(3)));
       Parameters.Add(new ValueParameter<ISymbolicExpressionGrammar>("ArtificialAntExpressionGrammar", "The grammar that should be used for artificial ant expressions.", new ArtificialAntExpressionGrammar()));
       Parameters.Add(new ValueParameter<BoolMatrix>("World", "The world for the artificial ant with scattered food items.", world));
-      Parameters.Add(new ValueParameter<IntValue>("MaxTimeSteps", "The number of time steps the artificial ant has available to collect all food items.", new IntValue(600)));
+      Parameters.Add(new ValueParameter<IntValue>("MaximumTimeSteps", "The number of time steps the artificial ant has available to collect all food items.", new IntValue(600)));
 
       creator.SymbolicExpressionTreeParameter.ActualName = "AntTrailSolution";