Changeset 15960

Timestamp:

06/15/18 14:53:46 (6 years ago)

Author:

bburlacu

Message:

#2886: Fix serialization and cloning and plugin properties.

Location:

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration

Files:

• GrammarEnumeration/Grammar.cs (modified) (4 diffs)
• GrammarEnumeration/GrammarEnumerationAlgorithm.cs (modified) (7 diffs)
• GrammarEnumeration/SearchDataStructure.cs (modified) (7 diffs)
• GrammarEnumeration/Sentence.cs (modified) (2 diffs)
• GrammarEnumeration/Symbol.cs (modified) (3 diffs)
• Hashing/Hasher.cs (modified) (4 diffs)
• HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.csproj (modified) (3 diffs)
• HeuristicLab.snk (added)
• Plugin.cs.frame (modified) (3 diffs)
• Properties/AssemblyInfo.cs (modified) (1 diff)

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Grammar.cs

@@ -4 +4 @@
 using System.Linq;
 using HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration;
+using HeuristicLab.Common;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 using HeuristicLab.Problems.DataAnalysis;
 using HeuristicLab.Problems.DataAnalysis.Symbolic;
@@ -18 +20 @@
   }
 
-  public class Grammar {
+  [StorableClass(StorableClassType.AllFieldsAndAllProperties)]
+  public class Grammar : DeepCloneable {
 
     public Symbol StartSymbol { get; }
@@ -74 +77 @@
 
     public Grammar(string[] variables) : this(variables, Enum.GetValues(typeof(GrammarRule)).Cast<GrammarRule>()) { }
+
+    protected Grammar(Grammar original, Cloner cloner) : base(original, cloner) {
+      VarTerminals = original.VarTerminals.Select(cloner.Clone).ToArray();
+      StartSymbol = cloner.Clone(original.StartSymbol);
+      Hasher = cloner.Clone(original.Hasher); // how to handle circular reference grammar <-> hasher? (the cloner *should* handle it)
+      Productions = original.Productions.ToDictionary(x => cloner.Clone(x.Key), x => (IReadOnlyList<Production>)x.Value.Select(cloner.Clone).ToList());
+      Var = cloner.Clone(original.Var);
+      VarTerminals = original.VarTerminals.Select(cloner.Clone).ToList();
+      Expr = cloner.Clone(original.Expr);
+      Term = cloner.Clone(original.Term);
+      Factor = cloner.Clone(original.Factor);
+      LogFactor = cloner.Clone(original.LogFactor);
+      ExpFactor = cloner.Clone(original.ExpFactor);
+      SinFactor = cloner.Clone(original.SinFactor);
+      SimpleExpr = cloner.Clone(original.SimpleExpr);
+      SimpleTerm = cloner.Clone(original.SimpleTerm);
+      InvExpr = cloner.Clone(original.InvExpr);
+      InvTerm = cloner.Clone(original.InvTerm);
+      Addition = cloner.Clone(original.Addition);
+      Multiplication = cloner.Clone(original.Multiplication);
+      Log = cloner.Clone(original.Log);
+      Exp = cloner.Clone(original.Exp);
+      Sin = cloner.Clone(original.Sin);
+      Sin = cloner.Clone(original.Sin);
+      Inv = cloner.Clone(original.Inv);
+      Const = cloner.Clone(original.Const);
+
+
+      constSy = cloner.Clone(original.constSy);
+      varSy = cloner.Clone(original.varSy);
+      addSy = cloner.Clone(original.addSy);
+      mulSy = cloner.Clone(original.mulSy);
+      logSy = cloner.Clone(original.logSy);
+      expSy = cloner.Clone(original.expSy);
+      divSy = cloner.Clone(original.divSy);
+      sinSy = cloner.Clone(original.sinSy);
+
+      rootSy = cloner.Clone(original.rootSy);
+      startSy = cloner.Clone(original.startSy);
+
+      infixExpressionFormatter = cloner.Clone(original.infixExpressionFormatter);
+    }
 
     public Grammar(string[] variables, IEnumerable<GrammarRule> includedRules) {
@@ -291 +336 @@
     }
     #endregion
+
+    #region abstract DeepCloneable methods
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new Grammar(this, cloner);
+    }
+    #endregion
   }
 }

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/GrammarEnumerationAlgorithm.cs

@@ -37 +37 @@
     private readonly string GrammarSymbolsParameterName = "Grammar Symbols";
 
-    public override bool SupportsPause { get { return false; } }
+    public override bool SupportsPause { get { return true; } }
 
     protected IValueParameter<DoubleValue> VariableImportanceWeightParameter {
@@ -107 +107 @@
     #endregion
 
+    [Storable]
     public Dictionary<int, int> DistinctSentencesComplexity { get; private set; }  // Semantically distinct sentences and their length in a run.
+
+    [Storable]
     public HashSet<int> ArchivedPhrases { get; private set; }
+
+    [Storable]
     internal SearchDataStore OpenPhrases { get; private set; }           // Stack/Queue/etc. for fetching the next node in the search tree.  
 
@@ -121 +126 @@
 
     public Grammar Grammar { get; private set; }
-
 
     #region ctors
@@ -174 +178 @@
         analyzer.Register(this);
       Analyzers.CheckedItemsChanged += Analyzers_CheckedItemsChanged;
+
+      DistinctSentencesComplexity = new Dictionary<int, int>(original.DistinctSentencesComplexity);
+      ArchivedPhrases = new HashSet<int>(original.ArchivedPhrases);
+      OpenPhrases = cloner.Clone(original.OpenPhrases);
+
+      AllGeneratedSentencesCount = original.AllGeneratedSentencesCount;
+      OverwrittenSentencesCount = original.OverwrittenSentencesCount;
+      PhraseExpansionCount = original.PhraseExpansionCount;
+      Grammar = cloner.Clone(original.Grammar);
+
+      if (original.variableImportance != null)
+        variableImportance = new Dictionary<VariableTerminalSymbol, double>(original.variableImportance);
     }
     #endregion
@@ -193 +209 @@
     }
 
-    protected override void Run(CancellationToken cancellationToken) {
-      InitResults();
-      var phrase0 = new SymbolString(new[] { Grammar.StartSymbol });
-      var phrase0Hash = Grammar.Hasher.CalcHashCode(phrase0);
-
-      #region Variable Importance
+    private Dictionary<VariableTerminalSymbol, double> CalculateVariableImportances() {
       variableImportance = new Dictionary<VariableTerminalSymbol, double>();
 
@@ -216 +227 @@
         variableImportance[varSym] = rfImpact.Item2 / sum;
       }
-      #endregion
+      return variableImportance;
+    }
+
+    protected override void Run(CancellationToken cancellationToken) {
+      // do not reinitialize the algorithm if we're resuming from pause
+      if (previousExecutionState != ExecutionState.Paused) {
+        CalculateVariableImportances();
+        InitResults();
+        var phrase0 = new SymbolString(new[] { Grammar.StartSymbol });
+        var phrase0Hash = Grammar.Hasher.CalcHashCode(phrase0);
+        OpenPhrases.Store(new SearchNode(phrase0Hash, 0.0, 0.0, phrase0));
+      }
 
       int maxSentenceLength = GetMaxSentenceLength();
-
-      OpenPhrases.Store(new SearchNode(phrase0Hash, 0.0, 0.0, phrase0));
-
       var errorWeight = ErrorWeight;
       var variableImportanceWeight = VariableImportanceWeight;
-
+      // main search loop
       while (OpenPhrases.Count > 0) {
-        if (cancellationToken.IsCancellationRequested) break;
+        if (cancellationToken.IsCancellationRequested)
+          break;
 
         SearchNode fetchedSearchNode = OpenPhrases.GetNext();
@@ -343 +363 @@
       return p.Count(s => s is NonterminalSymbol);
     }
+
+    #region pause support
+    private ExecutionState previousExecutionState;
+    protected override void OnPaused() {
+      previousExecutionState = this.ExecutionState;
+      base.OnPaused();
+    }
+    protected override void OnPrepared() {
+      previousExecutionState = this.ExecutionState;
+      base.OnPrepared();
+    }
+    protected override void OnStarted() {
+      previousExecutionState = this.ExecutionState;
+      base.OnStarted();
+    }
+    protected override void OnStopped() {
+      previousExecutionState = this.ExecutionState;
+      base.OnStopped();
+    }
+    #endregion
 
     #region Visualization in HL

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/SearchDataStructure.cs

@@ -2 +2 @@
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration {
-
-  public class SearchNode {
+  [StorableClass]
+  public class SearchNode : DeepCloneable {
+    [Storable]
     public readonly int Hash;
+    [Storable]
     public readonly SymbolString SymbolString;
+    [Storable]
     public readonly double Priority;
+    [Storable]
     public readonly double R2;
+
+    private SearchNode() { }
 
     public SearchNode(int hash, double priority, double r2, SymbolString symbolString) {
@@ -17 +26 @@
       R2 = r2;
     }
+
+    protected SearchNode(SearchNode original, Cloner cloner) : base(original, cloner) {
+      Hash = original.Hash;
+      Priority = original.Priority;
+      SymbolString = original.SymbolString;
+      R2 = original.R2;
+    }
+
+    [StorableConstructor]
+    protected SearchNode(bool deserializing) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SearchNode(this, cloner);
+    }
   }
 
@@ -23 +46 @@
   }
 
-  class SearchDataStore : IEnumerable<SearchNode> {
-
+  [StorableClass]
+  class SearchDataStore : DeepCloneable, IEnumerable<SearchNode> {
+    [Storable]
     private Dictionary<int, SearchNode> storedValues; // Store hash-references and associated, actual values 
+    [Storable]
+    private StorageType storageType;
+
+    // private storage
+    [Storable]
+    private Queue<int> queue;
+
+    [Storable]
+    private Stack<int> stack;
+
+    [Storable]
+    private List<int> list;
+
+    [ExcludeFromObjectGraphTraversal]
+    PriorityQueue<double, int> priorityQueue; // does not support [Storable], we rebuild it from the storedValues
+
     private Action<int, double> storeInternal; // Store hash-references 
     private Func<int> fetchInternal; // Fetch hash-reference
 
+    public SearchDataStore() : this(StorageType.PriorityQueue) { }
+
+    [StorableConstructor]
+    protected SearchDataStore(bool deserializing) : this() { }
+
     public SearchDataStore(StorageType storageType) {
+      this.storageType = storageType;
       storedValues = new Dictionary<int, SearchNode>();
-
+      InitStorage();
+    }
+
+    private void InitStorage() {
       switch (storageType) {
         case StorageType.PriorityQueue:
@@ -46 +95 @@
           break;
       }
-
-    }
-
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SearchDataStore(this, cloner);
+    }
+
+    protected SearchDataStore(SearchDataStore original, Cloner cloner) : base(original, cloner) {
+      storedValues = original.storedValues.ToDictionary(x => x.Key, x => cloner.Clone(x.Value));
+      storageType = original.storageType;
+      InitStorage();
+      switch (storageType) {
+        case StorageType.PriorityQueue:
+          foreach (var t in storedValues)
+            storeInternal(t.Key, t.Value.Priority);
+          break;
+        case StorageType.Stack:
+          foreach (var v in original.stack.Reverse()) {
+            stack.Push(v);
+          }
+          break;
+        case StorageType.Queue:
+          foreach (var v in original.queue) {
+            queue.Enqueue(v);
+          }
+          break;
+        case StorageType.RandomList:
+          list.AddRange(original.list);
+          break;
+      }
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      // access lambdas need to be reinitialized
+      switch (storageType) {
+        case StorageType.PriorityQueue:
+          InitPriorityQueue();
+          foreach (var t in storedValues)
+            storeInternal(t.Key, t.Value.Priority);
+          break;
+        case StorageType.Stack:
+          storeInternal = (hash, prio) => stack.Push(hash);
+          fetchInternal = () => stack.Pop();
+          break;
+        case StorageType.Queue:
+          storeInternal = (hash, prio) => queue.Enqueue(hash);
+          fetchInternal = () => queue.Dequeue();
+          break;
+        case StorageType.RandomList:
+          System.Random rand = new System.Random(999);
+          storeInternal = (hash, prio) => list.Add(hash);
+          fetchInternal = () => {
+            int indexOfHash = rand.Next(list.Count);
+            int result = list[indexOfHash];
+            list.RemoveAt(indexOfHash);  // TODO: beware this is O(n), at some point in time we should fix this. Maybe change to priority queue with random key.
+            return result;
+          };
+          break;
+      }
+    }
     #region SearchStrategies
 
     private void InitPriorityQueue() {
       int capacity = 10000000;
-      PriorityQueue<double, int> queue = new PriorityQueue<double, int>(double.MaxValue, double.MinValue, capacity);
-      storeInternal = (hash, prio) => queue.Insert(prio, hash);
+      priorityQueue = new PriorityQueue<double, int>(double.MaxValue, double.MinValue, capacity);
+      storeInternal = (hash, prio) => priorityQueue.Insert(prio, hash);
       fetchInternal = () => {
-        int ret = queue.PeekMinValue();
-        queue.RemoveMin();
+        int ret = priorityQueue.PeekMinValue();
+        priorityQueue.RemoveMin();
         return ret;
       };
@@ -63 +169 @@
 
     private void InitStack() {
-      Stack<int> stack = new Stack<int>();
+      stack = new Stack<int>();
 
       storeInternal = (hash, prio) => stack.Push(hash);
@@ -70 +176 @@
 
     private void InitQueue() {
-      Queue<int> queue = new Queue<int>();
+      queue = new Queue<int>();
 
       storeInternal = (hash, prio) => queue.Enqueue(hash);
@@ -77 +183 @@
 
     private void InitRandomList() {
-      List<int> list = new List<int>();
+      list = new List<int>();
       System.Random rand = new System.Random(999);
 

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Sentence.cs

@@ -4 +4 @@
 using System.Diagnostics;
 using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration {
-  public class SymbolString : IEnumerable<Symbol> {
+  [StorableClass]
+  public class SymbolString : DeepCloneable, IEnumerable<Symbol> {
+    [Storable]
     private readonly Symbol[] symbols;
 
@@ -19 +23 @@
     public SymbolString(params Symbol[] s) {
       symbols = s;
+    }
+
+    protected SymbolString(SymbolString original, Cloner cloner) : base(original, cloner) {
+      symbols = original.symbols.ToArray();
+    }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolString(this, cloner);
     }
 

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/GrammarEnumeration/Symbol.cs

@@ -1 +1 @@
 using System;
 using System.Collections.Generic;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration {
-
-  public abstract class Symbol : IEquatable<Symbol> {
+  [StorableClass]
+  public abstract class Symbol : DeepCloneable, IEquatable<Symbol> {
+    [Storable]
     private readonly int stringRepresentationHash;
 
+    [Storable]
     public string StringRepresentation { get; }
 
@@ -12 +16 @@
       StringRepresentation = representation;
       stringRepresentationHash = representation.GetHashCode();
+    }
+
+    protected Symbol(Symbol original, Cloner cloner) : base(original, cloner) {
+      StringRepresentation = original.StringRepresentation;
+      stringRepresentationHash = original.stringRepresentationHash;
     }
 
@@ -49 +58 @@
   }
 
+  [StorableClass]
   public class TerminalSymbol : Symbol {
+    public TerminalSymbol(string representation) : base(representation) { }
+    public TerminalSymbol(TerminalSymbol original, Cloner cloner) : base(original, cloner) { }
 
-    public TerminalSymbol(string representation) : base(representation) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new TerminalSymbol(this, cloner);
+    }
   }
 
+  [StorableClass]
   public class VariableTerminalSymbol : TerminalSymbol {
     public VariableTerminalSymbol(string representation) : base(representation) { }
+    public VariableTerminalSymbol(VariableTerminalSymbol original, Cloner cloner) : base(original, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new VariableTerminalSymbol(this, cloner);
+    }
   }
 
-
+  [StorableClass]
   public class NonterminalSymbol : Symbol {
     public NonterminalSymbol(string representation) : base(representation) { }
+    public NonterminalSymbol(NonterminalSymbol original, Cloner cloner) : base(original, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new NonterminalSymbol(this, cloner);
+    }
   }
 
-  public class Production : List<Symbol> {
+  [StorableClass]
+  public class Production : List<Symbol>, IDeepCloneable {
 
     public Production(params Symbol[] symbols) : base(symbols) { }
 
     public Production(IEnumerable<Symbol> symbols) : base(symbols) { }
+
+    protected Production(Production original, Cloner cloner) : this(original) {
+      cloner.RegisterClonedObject(original, this);
+    }
+
+    public IDeepCloneable Clone(Cloner cloner) {
+      return new Production(this, cloner);
+    }
+
+    public object Clone() {
+      return Clone(new Cloner());
+    }
 
     public override string ToString() {

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Hashing/Hasher.cs

@@ -3 +3 @@
 using System.Diagnostics;
 using System.Linq;
+using HeuristicLab.Common;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
 
 namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.GrammarEnumeration {
-  public abstract class Hasher<THashType> {
+  [StorableClass]
+  public abstract class Hasher<THashType> : DeepCloneable {
     protected Hasher(Grammar grammar) {
       Grammar = grammar;
+    }
+
+    protected Hasher(Hasher<THashType> original, Cloner cloner) : base(original, cloner) {
+      Grammar = cloner.Clone(original.Grammar);
     }
 
@@ -22 +29 @@
       return AggregateHashes(peek, GetSubtreeHashes(parseStack)).GetHashCode();
     }
+
+    [StorableConstructor]
+    protected Hasher(bool deserializing) { }
 
     private THashType[] GetSubtreeHashes(Stack<Symbol> parseStack) {
@@ -109 +119 @@
         .ToArray();
     }
-
-
   }
 
+  [StorableClass]
   public class IntHasher : Hasher<int> {
     public IntHasher(Grammar grammar) : base(grammar) { }
+
+    public IntHasher(IntHasher original, Cloner cloner) : base(original, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new IntHasher(this, cloner);
+    }
+
+    [StorableConstructor]
+    protected IntHasher(bool deserializing) : base(deserializing) { }
 
     protected override int AggregateHashes(Symbol operatorSym, int[] hashes) {
@@ -135 +153 @@
   }
 
+  [StorableClass]
   public class StringHasher : Hasher<string> {
     public StringHasher(Grammar grammar) : base(grammar) { }
+
+    public StringHasher(StringHasher original, Cloner cloner) : base(original, cloner) { }
+
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new StringHasher(this, cloner);
+    }
+
+    [StorableConstructor]
+    protected StringHasher(bool deserializing) : base(deserializing) { }
 
     protected override string AggregateHashes(Symbol operatorSym, string[] hashes) {

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.csproj

@@ -9 +9 @@
     <AppDesignerFolder>Properties</AppDesignerFolder>
     <RootNamespace>HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration</RootNamespace>
-    <AssemblyName>HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration</AssemblyName>
+    <AssemblyName>HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration-3.4</AssemblyName>
     <TargetFrameworkVersion>v4.5.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
@@ -29 +29 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SignAssembly>true</SignAssembly>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AssemblyOriginatorKeyFile>HeuristicLab.snk</AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
@@ -130 +136 @@
   </ItemGroup>
   <ItemGroup>
+    <None Include="HeuristicLab.snk" />
     <None Include="Plugin.cs.frame" />
   </ItemGroup>

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Plugin.cs.frame

@@ -23 +23 @@
 
 namespace HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration {
-  [Plugin("HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration", "", "3.4.0.$WCREV$")]
-  [PluginFile("HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.ALGLIB", "3.7")]
+  /// <summary>
+  /// Plugin class for the Grammar Enumeration Symbolc Regression algorithm.
+  /// </summary>
+  [Plugin("HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration", "3.4.0.$WCREV$")]
+  [PluginFile("HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration-3.4.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Algorithms.DataAnalysis", "3.4")]
-  [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]
   [PluginDependency("HeuristicLab.Common", "3.3")]
@@ -33 +34 @@
   [PluginDependency("HeuristicLab.Data", "3.3")]
   [PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding", "3.4")]
-  [PluginDependency("HeuristicLab.Operators", "3.3")]
   [PluginDependency("HeuristicLab.Optimization", "3.3")]
   [PluginDependency("HeuristicLab.Parameters", "3.3")]
@@ -41 +41 @@
   [PluginDependency("HeuristicLab.Problems.DataAnalysis.Symbolic.Regression", "3.4")]
   [PluginDependency("HeuristicLab.Problems.Instances", "3.3")]
+  [PluginDependency("HeuristicLab.Problems.Instances.DataAnalysis", "3.3")]
   [PluginDependency("HeuristicLab.Random", "3.3")]
 

branches/2886_SymRegGrammarEnumeration/HeuristicLab.Algorithms.DataAnalysis.SymRegGrammarEnumeration/Properties/AssemblyInfo.cs

@@ -33 +33 @@
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyVersion("3.4.0.0")]
 [assembly: AssemblyFileVersion("1.0.0.0")]